diff --git a/src/app/api/dataset.api.ts b/src/app/api/dataset.api.ts index 8e67e7704..32d9a8ad1 100644 --- a/src/app/api/dataset.api.ts +++ b/src/app/api/dataset.api.ts @@ -1,9 +1,11 @@ import { CommitEventToDatasetGQL, - CommitEventToDatasetQuery, + CommitEventToDatasetMutation, CreateDatasetFromSnapshotGQL, - CreateDatasetFromSnapshotQuery, - CreateEmptyDatasetQuery, + CreateDatasetFromSnapshotMutation, + CreateEmptyDatasetMutation, + DatasetByAccountAndDatasetNameGQL, + DatasetByAccountAndDatasetNameQuery, DatasetKind, GetDatasetSchemaGQL, GetDatasetSchemaQuery, @@ -30,6 +32,7 @@ import { DatasetByIdGQL, CreateEmptyDatasetGQL, } from "./kamu.graphql.interface"; +import { MutationResult } from "apollo-angular"; @Injectable({ providedIn: "root" }) export class DatasetApi { @@ -40,6 +43,7 @@ export class DatasetApi { private datasetsByAccountNameGQL: DatasetsByAccountNameGQL, private metadataBlockGQL: GetMetadataBlockGQL, private datasetByIdGQL: DatasetByIdGQL, + private datasetByAccountAndDatasetNameGQL: DatasetByAccountAndDatasetNameGQL, private createEmptyDatasetGQL: CreateEmptyDatasetGQL, private createDatasetFromSnapshotGQL: CreateDatasetFromSnapshotGQL, private commitEventToDataset: CommitEventToDatasetGQL, @@ -162,17 +166,38 @@ export class DatasetApi { ); } + public getDatasetInfoByAccountAndDatasetName( + accountName: string, + datasetName: string, + ): Observable { + return this.datasetByAccountAndDatasetNameGQL + .watch({ + accountName, + datasetName, + }) + .valueChanges.pipe( + first(), + map( + ( + result: ApolloQueryResult, + ) => { + return result.data; + }, + ), + ); + } + public createDatasetFromSnapshot( accountId: string, snapshot: string, - ): Observable { + ): Observable { return this.createDatasetFromSnapshotGQL - .watch({ accountId, snapshot }) - .valueChanges.pipe( + .mutate({ accountId, snapshot }) + .pipe( first(), map( ( - result: ApolloQueryResult, + result: MutationResult, ) => { return result.data; }, @@ -184,31 +209,29 @@ export class DatasetApi { accountId: string, datasetKind: DatasetKind, datasetName: string, - ): Observable { + ): Observable { return this.createEmptyDatasetGQL - .watch({ accountId, datasetKind, datasetName }) - .valueChanges.pipe( + .mutate({ accountId, datasetKind, datasetName }) + .pipe( first(), - map((result: ApolloQueryResult) => { + map((result: MutationResult) => { return result.data; }), ); } public commitEvent(params: { - accountName: string; - datasetName: string; + datasetId: string; event: string; - }): Observable { + }): Observable { return this.commitEventToDataset - .watch({ - accountName: params.accountName, - datasetName: params.datasetName, + .mutate({ + datasetId: params.datasetId, event: params.event, }) - .valueChanges.pipe( + .pipe( first(), - map((result: ApolloQueryResult) => { + map((result: MutationResult) => { return result.data; }), ); diff --git a/src/app/api/gql/create-dataset/commit-event.graphql b/src/app/api/gql/create-dataset/commit-event.graphql index 913c70027..ecae479ba 100644 --- a/src/app/api/gql/create-dataset/commit-event.graphql +++ b/src/app/api/gql/create-dataset/commit-event.graphql @@ -1,10 +1,6 @@ -query commitEventToDataset( - $accountName: AccountName! - $datasetName: DatasetName! - $event: String! -) { +mutation commitEventToDataset($datasetId: DatasetID!, $event: String!) { datasets { - byOwnerAndName(accountName: $accountName, datasetName: $datasetName) { + byId(datasetId: $datasetId) { metadata { chain { commitEvent(event: $event, eventFormat: YAML) { diff --git a/src/app/api/gql/create-dataset/create-empty-dataset.graphql b/src/app/api/gql/create-dataset/create-empty-dataset.graphql index ca148b55a..451f26892 100644 --- a/src/app/api/gql/create-dataset/create-empty-dataset.graphql +++ b/src/app/api/gql/create-dataset/create-empty-dataset.graphql @@ -1,4 +1,4 @@ -query createEmptyDataset( +mutation createEmptyDataset( $accountId: AccountID! $datasetKind: DatasetKind! $datasetName: DatasetName! diff --git a/src/app/api/gql/create-dataset/create-from-snapshot.graphql b/src/app/api/gql/create-dataset/create-from-snapshot.graphql index ed2891c68..dfa041cb0 100644 --- a/src/app/api/gql/create-dataset/create-from-snapshot.graphql +++ b/src/app/api/gql/create-dataset/create-from-snapshot.graphql @@ -1,4 +1,4 @@ -query createDatasetFromSnapshot($accountId: AccountID!, $snapshot: String!) { +mutation createDatasetFromSnapshot($accountId: AccountID!, $snapshot: String!) { datasets { createFromSnapshot( accountId: $accountId diff --git a/src/app/api/gql/dataset-by-account-and-dataset-name.graphql b/src/app/api/gql/dataset-by-account-and-dataset-name.graphql new file mode 100644 index 000000000..6b066ab32 --- /dev/null +++ b/src/app/api/gql/dataset-by-account-and-dataset-name.graphql @@ -0,0 +1,10 @@ +query datasetByAccountAndDatasetName( + $accountName: AccountName! + $datasetName: DatasetName! +) { + datasets { + byOwnerAndName(accountName: $accountName, datasetName: $datasetName) { + ...DatasetBasics + } + } +} diff --git a/src/app/api/kamu.graphql.interface.ts b/src/app/api/kamu.graphql.interface.ts index 68dbcd762..e9dd4baca 100644 --- a/src/app/api/kamu.graphql.interface.ts +++ b/src/app/api/kamu.graphql.interface.ts @@ -94,17 +94,17 @@ export type AttachmentsEmbedded = { items: Array; }; -export type Auth = { - __typename?: "Auth"; +export type AuthMut = { + __typename?: "AuthMut"; accountInfo: AccountInfo; githubLogin: LoginResponse; }; -export type AuthAccountInfoArgs = { +export type AuthMutAccountInfoArgs = { accessToken: Scalars["String"]; }; -export type AuthGithubLoginArgs = { +export type AuthMutGithubLoginArgs = { code: Scalars["String"]; }; @@ -130,17 +130,19 @@ export type CommitResult = { message: Scalars["String"]; }; -export type CommitResultAppendError = CommitResult & { - __typename?: "CommitResultAppendError"; - message: Scalars["String"]; -}; +export type CommitResultAppendError = CommitResult & + UpdateReadmeResult & { + __typename?: "CommitResultAppendError"; + message: Scalars["String"]; + }; -export type CommitResultSuccess = CommitResult & { - __typename?: "CommitResultSuccess"; - message: Scalars["String"]; - newHead: Scalars["Multihash"]; - oldHead?: Maybe; -}; +export type CommitResultSuccess = CommitResult & + UpdateReadmeResult & { + __typename?: "CommitResultSuccess"; + message: Scalars["String"]; + newHead: Scalars["Multihash"]; + oldHead?: Maybe; + }; export enum CompressionFormat { Gzip = "GZIP", @@ -353,6 +355,24 @@ export type DatasetMetadataCurrentSchemaArgs = { format?: InputMaybe; }; +export type DatasetMetadataMut = { + __typename?: "DatasetMetadataMut"; + /** Access to the mutable metadata chain of the dataset */ + chain: MetadataChainMut; + /** Updates or clears the dataset readme */ + updateReadme: UpdateReadmeResult; +}; + +export type DatasetMetadataMutUpdateReadmeArgs = { + content?: InputMaybe; +}; + +export type DatasetMut = { + __typename?: "DatasetMut"; + /** Access to the mutable metadata of the dataset */ + metadata: DatasetMetadataMut; +}; + export type Datasets = { __typename?: "Datasets"; /** Returns datasets belonging to the specified account */ @@ -363,10 +383,6 @@ export type Datasets = { byId?: Maybe; /** Returns dataset by its owner and name */ byOwnerAndName?: Maybe; - /** Creates a new empty dataset */ - createEmpty: CreateDatasetResult; - /** Creates a new dataset from provided DatasetSnapshot manifest */ - createFromSnapshot: CreateDatasetFromSnapshotResult; }; export type DatasetsByAccountIdArgs = { @@ -390,13 +406,27 @@ export type DatasetsByOwnerAndNameArgs = { datasetName: Scalars["DatasetName"]; }; -export type DatasetsCreateEmptyArgs = { +export type DatasetsMut = { + __typename?: "DatasetsMut"; + /** Returns a mutable dataset by its ID */ + byId?: Maybe; + /** Creates a new empty dataset */ + createEmpty: CreateDatasetResult; + /** Creates a new dataset from provided DatasetSnapshot manifest */ + createFromSnapshot: CreateDatasetFromSnapshotResult; +}; + +export type DatasetsMutByIdArgs = { + datasetId: Scalars["DatasetID"]; +}; + +export type DatasetsMutCreateEmptyArgs = { accountId: Scalars["AccountID"]; datasetKind: DatasetKind; datasetName: Scalars["DatasetName"]; }; -export type DatasetsCreateFromSnapshotArgs = { +export type DatasetsMutCreateFromSnapshotArgs = { accountId: Scalars["AccountID"]; snapshot: Scalars["String"]; snapshotFormat: MetadataManifestFormat; @@ -553,8 +583,6 @@ export type MetadataChain = { blockByHashEncoded?: Maybe; /** Iterates all metadata blocks in the reverse chronological order */ blocks: MetadataBlockConnection; - /** Commits new event to the metadata chain */ - commitEvent: CommitResult; /** Returns all named metadata block references */ refs: Array; }; @@ -573,7 +601,13 @@ export type MetadataChainBlocksArgs = { perPage?: InputMaybe; }; -export type MetadataChainCommitEventArgs = { +export type MetadataChainMut = { + __typename?: "MetadataChainMut"; + /** Commits new event to the metadata chain */ + commitEvent: CommitResult; +}; + +export type MetadataChainMutCommitEventArgs = { event: Scalars["String"]; eventFormat: MetadataManifestFormat; }; @@ -608,10 +642,30 @@ export type MetadataManifestUnsupportedVersion = CommitResult & export type Mutation = { __typename?: "Mutation"; - auth: Auth; - tasks: TasksMutations; + /** Authentication and authorization-related functionality group */ + auth: AuthMut; + /** + * Dataset-related functionality group. + * + * Datasets are historical streams of events recorded under a cetrain + * schema. + */ + datasets: DatasetsMut; + /** + * Tasks-related functionality group. + * + * Tasks are units of work scheduled and executed by the system to query + * and process data. + */ + tasks: TasksMut; }; +export type NoChanges = CommitResult & + UpdateReadmeResult & { + __typename?: "NoChanges"; + message: Scalars["String"]; + }; + export type OffsetInterval = { __typename?: "OffsetInterval"; end: Scalars["Int"]; @@ -941,8 +995,8 @@ export type TasksListTasksByDatasetArgs = { perPage?: InputMaybe; }; -export type TasksMutations = { - __typename?: "TasksMutations"; +export type TasksMut = { + __typename?: "TasksMut"; /** Requests cancellation of the specified task */ cancelTask: Task; /** @@ -957,17 +1011,17 @@ export type TasksMutations = { createUpdateDatasetTask: Task; }; -export type TasksMutationsCancelTaskArgs = { +export type TasksMutCancelTaskArgs = { taskId: Scalars["TaskID"]; }; -export type TasksMutationsCreateProbeTaskArgs = { +export type TasksMutCreateProbeTaskArgs = { busyTimeMs?: InputMaybe; datasetId?: InputMaybe; endWithOutcome?: InputMaybe; }; -export type TasksMutationsCreateUpdateDatasetTaskArgs = { +export type TasksMutCreateUpdateDatasetTaskArgs = { datasetId: Scalars["DatasetID"]; }; @@ -995,6 +1049,10 @@ export type TransformSql = { version?: Maybe; }; +export type UpdateReadmeResult = { + message: Scalars["String"]; +}; + export type User = Account & { __typename?: "User"; /** Unique and stable identitfier of this user account */ @@ -1003,22 +1061,21 @@ export type User = Account & { name: Scalars["String"]; }; -export type CommitEventToDatasetQueryVariables = Exact<{ - accountName: Scalars["AccountName"]; - datasetName: Scalars["DatasetName"]; +export type CommitEventToDatasetMutationVariables = Exact<{ + datasetId: Scalars["DatasetID"]; event: Scalars["String"]; }>; -export type CommitEventToDatasetQuery = { - __typename?: "Query"; +export type CommitEventToDatasetMutation = { + __typename?: "Mutation"; datasets: { - __typename?: "Datasets"; - byOwnerAndName?: { - __typename?: "Dataset"; + __typename?: "DatasetsMut"; + byId?: { + __typename?: "DatasetMut"; metadata: { - __typename?: "DatasetMetadata"; + __typename?: "DatasetMetadataMut"; chain: { - __typename?: "MetadataChain"; + __typename?: "MetadataChainMut"; commitEvent: | { __typename: "CommitResultAppendError"; @@ -1034,23 +1091,24 @@ export type CommitEventToDatasetQuery = { __typename: "MetadataManifestMalformed"; message: string; } - | { __typename: "MetadataManifestUnsupportedVersion" }; + | { __typename: "MetadataManifestUnsupportedVersion" } + | { __typename: "NoChanges" }; }; }; } | null; }; }; -export type CreateEmptyDatasetQueryVariables = Exact<{ +export type CreateEmptyDatasetMutationVariables = Exact<{ accountId: Scalars["AccountID"]; datasetKind: DatasetKind; datasetName: Scalars["DatasetName"]; }>; -export type CreateEmptyDatasetQuery = { - __typename?: "Query"; +export type CreateEmptyDatasetMutation = { + __typename?: "Mutation"; datasets: { - __typename?: "Datasets"; + __typename?: "DatasetsMut"; createEmpty: | { __typename?: "CreateDatasetResultNameCollision"; @@ -1060,15 +1118,15 @@ export type CreateEmptyDatasetQuery = { }; }; -export type CreateDatasetFromSnapshotQueryVariables = Exact<{ +export type CreateDatasetFromSnapshotMutationVariables = Exact<{ accountId: Scalars["AccountID"]; snapshot: Scalars["String"]; }>; -export type CreateDatasetFromSnapshotQuery = { - __typename?: "Query"; +export type CreateDatasetFromSnapshotMutation = { + __typename?: "Mutation"; datasets: { - __typename?: "Datasets"; + __typename?: "DatasetsMut"; createFromSnapshot: | { __typename?: "CreateDatasetResultInvalidSnapshot"; @@ -1095,6 +1153,21 @@ export type CreateDatasetFromSnapshotQuery = { }; }; +export type DatasetByAccountAndDatasetNameQueryVariables = Exact<{ + accountName: Scalars["AccountName"]; + datasetName: Scalars["DatasetName"]; +}>; + +export type DatasetByAccountAndDatasetNameQuery = { + __typename?: "Query"; + datasets: { + __typename?: "Datasets"; + byOwnerAndName?: + | ({ __typename?: "Dataset" } & DatasetBasicsFragment) + | null; + }; +}; + export type DatasetByIdQueryVariables = Exact<{ datasetId: Scalars["DatasetID"]; }>; @@ -1790,7 +1863,7 @@ export type GithubLoginMutationVariables = Exact<{ export type GithubLoginMutation = { __typename?: "Mutation"; auth: { - __typename?: "Auth"; + __typename?: "AuthMut"; githubLogin: { __typename?: "LoginResponse"; token: { @@ -1813,7 +1886,7 @@ export type FetchAccountInfoMutationVariables = Exact<{ export type FetchAccountInfoMutation = { __typename?: "Mutation"; auth: { - __typename?: "Auth"; + __typename?: "AuthMut"; accountInfo: { __typename?: "AccountInfo" } & AccountDetailsFragment; }; }; @@ -2441,16 +2514,9 @@ export const DatasetSearchOverviewFragmentDoc = gql` ${LicenseFragmentDoc} `; export const CommitEventToDatasetDocument = gql` - query commitEventToDataset( - $accountName: AccountName! - $datasetName: DatasetName! - $event: String! - ) { + mutation commitEventToDataset($datasetId: DatasetID!, $event: String!) { datasets { - byOwnerAndName( - accountName: $accountName - datasetName: $datasetName - ) { + byId(datasetId: $datasetId) { metadata { chain { commitEvent(event: $event, eventFormat: YAML) { @@ -2477,9 +2543,9 @@ export const CommitEventToDatasetDocument = gql` @Injectable({ providedIn: "root", }) -export class CommitEventToDatasetGQL extends Apollo.Query< - CommitEventToDatasetQuery, - CommitEventToDatasetQueryVariables +export class CommitEventToDatasetGQL extends Apollo.Mutation< + CommitEventToDatasetMutation, + CommitEventToDatasetMutationVariables > { document = CommitEventToDatasetDocument; @@ -2488,7 +2554,7 @@ export class CommitEventToDatasetGQL extends Apollo.Query< } } export const CreateEmptyDatasetDocument = gql` - query createEmptyDataset( + mutation createEmptyDataset( $accountId: AccountID! $datasetKind: DatasetKind! $datasetName: DatasetName! @@ -2508,9 +2574,9 @@ export const CreateEmptyDatasetDocument = gql` @Injectable({ providedIn: "root", }) -export class CreateEmptyDatasetGQL extends Apollo.Query< - CreateEmptyDatasetQuery, - CreateEmptyDatasetQueryVariables +export class CreateEmptyDatasetGQL extends Apollo.Mutation< + CreateEmptyDatasetMutation, + CreateEmptyDatasetMutationVariables > { document = CreateEmptyDatasetDocument; @@ -2519,7 +2585,7 @@ export class CreateEmptyDatasetGQL extends Apollo.Query< } } export const CreateDatasetFromSnapshotDocument = gql` - query createDatasetFromSnapshot( + mutation createDatasetFromSnapshot( $accountId: AccountID! $snapshot: String! ) { @@ -2544,9 +2610,9 @@ export const CreateDatasetFromSnapshotDocument = gql` @Injectable({ providedIn: "root", }) -export class CreateDatasetFromSnapshotGQL extends Apollo.Query< - CreateDatasetFromSnapshotQuery, - CreateDatasetFromSnapshotQueryVariables +export class CreateDatasetFromSnapshotGQL extends Apollo.Mutation< + CreateDatasetFromSnapshotMutation, + CreateDatasetFromSnapshotMutationVariables > { document = CreateDatasetFromSnapshotDocument; @@ -2554,6 +2620,36 @@ export class CreateDatasetFromSnapshotGQL extends Apollo.Query< super(apollo); } } +export const DatasetByAccountAndDatasetNameDocument = gql` + query datasetByAccountAndDatasetName( + $accountName: AccountName! + $datasetName: DatasetName! + ) { + datasets { + byOwnerAndName( + accountName: $accountName + datasetName: $datasetName + ) { + ...DatasetBasics + } + } + } + ${DatasetBasicsFragmentDoc} +`; + +@Injectable({ + providedIn: "root", +}) +export class DatasetByAccountAndDatasetNameGQL extends Apollo.Query< + DatasetByAccountAndDatasetNameQuery, + DatasetByAccountAndDatasetNameQueryVariables +> { + document = DatasetByAccountAndDatasetNameDocument; + + constructor(apollo: Apollo.Apollo) { + super(apollo); + } +} export const DatasetByIdDocument = gql` query datasetById($datasetId: DatasetID!) { datasets { diff --git a/src/app/api/mock/auth.mock.ts b/src/app/api/mock/auth.mock.ts index 8a84cad85..5450bf1dd 100644 --- a/src/app/api/mock/auth.mock.ts +++ b/src/app/api/mock/auth.mock.ts @@ -19,14 +19,14 @@ export const mockAccountDetails: AccountDetailsFragment = { export const mockUserInfoFromAccessToken: FetchAccountInfoMutation = { auth: { - __typename: "Auth", + __typename: "AuthMut", accountInfo: mockAccountDetails, }, }; export const mockGithubLoginResponse: GithubLoginMutation = { auth: { - __typename: "Auth", + __typename: "AuthMut", githubLogin: { __typename: "LoginResponse", token: { diff --git a/src/app/app.module.ts b/src/app/app.module.ts index e6ad8736c..3853150ea 100644 --- a/src/app/app.module.ts +++ b/src/app/app.module.ts @@ -96,6 +96,12 @@ const Services = [ link: httpLink.create({ uri: appConfig.apiServerGqlUrl, }), + defaultOptions: { + watchQuery: { + fetchPolicy: "network-only", + errorPolicy: "all", + }, + }, }; }, deps: [HttpLink, AppConfigService], diff --git a/src/app/dataset-create/dataset-create.service.ts b/src/app/dataset-create/dataset-create.service.ts index 9376a6aed..feca38496 100644 --- a/src/app/dataset-create/dataset-create.service.ts +++ b/src/app/dataset-create/dataset-create.service.ts @@ -1,13 +1,14 @@ import { - CommitEventToDatasetQuery, - CreateDatasetFromSnapshotQuery, - CreateEmptyDatasetQuery, + CommitEventToDatasetMutation, + CreateDatasetFromSnapshotMutation, + CreateEmptyDatasetMutation, + DatasetByAccountAndDatasetNameQuery, } from "./../api/kamu.graphql.interface"; import { Observable, Subject } from "rxjs"; import { DatasetApi } from "src/app/api/dataset.api"; import { Injectable } from "@angular/core"; import { DatasetKind } from "../api/kamu.graphql.interface"; -import { map } from "rxjs/operators"; +import { map, switchMap } from "rxjs/operators"; import { NavigationService } from "../services/navigation.service"; import { DatasetViewTypeEnum } from "../dataset-view/dataset-view.interface"; import { DatasetService } from "../dataset-view/dataset.service"; @@ -33,6 +34,7 @@ export class AppDatasetCreateService { public get onErrorCommitEventChanges(): Observable { return this.errorCommitEventChanges$.asObservable(); } + private cache = new Map(); public constructor( private datasetApi: DatasetApi, @@ -48,9 +50,9 @@ export class AppDatasetCreateService { return this.datasetApi .createEmptyDataset(accountId, datasetKind, datasetName) .pipe( - map((data: CreateEmptyDatasetQuery) => { + map((data: CreateEmptyDatasetMutation | null | undefined) => { if ( - data.datasets.createEmpty.__typename === + data?.datasets.createEmpty.__typename === "CreateDatasetResultSuccess" ) { this.navigationService.navigateToDatasetView({ @@ -59,9 +61,10 @@ export class AppDatasetCreateService { tab: DatasetViewTypeEnum.Overview, }); } else { - this.errorMessageChanges( - data.datasets.createEmpty.message, - ); + if (data) + this.errorMessageChanges( + data.datasets.createEmpty.message, + ); } }), ); @@ -74,24 +77,32 @@ export class AppDatasetCreateService { return this.datasetApi .createDatasetFromSnapshot(accountId, snapshot) .pipe( - map((data: CreateDatasetFromSnapshotQuery) => { - if ( - data.datasets.createFromSnapshot.__typename === - "CreateDatasetResultSuccess" - ) { - const datasetName = data.datasets.createFromSnapshot - .dataset.name as string; - this.navigationService.navigateToDatasetView({ - accountName: accountId, - datasetName, - tab: DatasetViewTypeEnum.Overview, - }); - } else { - this.errorMessageChanges( - data.datasets.createFromSnapshot.message, - ); - } - }), + map( + ( + data: + | CreateDatasetFromSnapshotMutation + | null + | undefined, + ) => { + if ( + data?.datasets.createFromSnapshot.__typename === + "CreateDatasetResultSuccess" + ) { + const datasetName = data.datasets.createFromSnapshot + .dataset.name as string; + this.navigationService.navigateToDatasetView({ + accountName: accountId, + datasetName, + tab: DatasetViewTypeEnum.Overview, + }); + } else { + if (data) + this.errorMessageChanges( + data.datasets.createFromSnapshot.message, + ); + } + }, + ), ); } @@ -100,34 +111,55 @@ export class AppDatasetCreateService { datasetName: string, event: string, ): Observable { - return this.datasetApi - .commitEvent({ accountName, datasetName, event }) - .pipe( - map((data: CommitEventToDatasetQuery) => { - if ( - data.datasets.byOwnerAndName?.metadata.chain.commitEvent - .__typename === "CommitResultAppendError" || - data.datasets.byOwnerAndName?.metadata.chain.commitEvent - .__typename === "MetadataManifestMalformed" - ) { - this.errorCommitEventChanges( - data.datasets.byOwnerAndName.metadata.chain - .commitEvent.message, - ); - } else { - this.datasetService - .requestDatasetMainData({ - accountName, - datasetName, - }) - .subscribe(); - this.navigationService.navigateToDatasetView({ + const key = `${accountName}${datasetName}`; + let observable: Observable< + CommitEventToDatasetMutation | null | undefined + >; + if (this.cache.has(key)) { + observable = this.datasetApi.commitEvent({ + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + datasetId: this.cache.get(key)!, + event, + }); + } else { + observable = this.datasetApi + .getDatasetInfoByAccountAndDatasetName(accountName, datasetName) + .pipe( + switchMap((x: DatasetByAccountAndDatasetNameQuery) => { + const id = x.datasets.byOwnerAndName?.id as string; + this.cache.set(key, id); + return this.datasetApi.commitEvent({ + datasetId: id, + event, + }); + }), + ); + } + return observable.pipe( + map((data: CommitEventToDatasetMutation | undefined | null) => { + if ( + data?.datasets.byId?.metadata.chain.commitEvent + .__typename === "CommitResultAppendError" || + data?.datasets.byId?.metadata.chain.commitEvent + .__typename === "MetadataManifestMalformed" + ) { + this.errorCommitEventChanges( + data.datasets.byId.metadata.chain.commitEvent.message, + ); + } else { + this.datasetService + .requestDatasetMainData({ accountName, datasetName, - tab: DatasetViewTypeEnum.Overview, - }); - } - }), - ); + }) + .subscribe(); + this.navigationService.navigateToDatasetView({ + accountName, + datasetName, + tab: DatasetViewTypeEnum.Overview, + }); + } + }), + ); } }