Kamu 178 set attachments from UI saving and editing attachments

resources/schema.graphql

@@ -51,7 +51,7 @@ type AttachmentsEmbedded {
   items: [AttachmentEmbedded!]!
 }
 
-type Auth {
+type AuthMut {
   githubLogin(code: String!): LoginResponse!
   accountInfo(accessToken: String!): AccountInfo!
 }
@@ -75,11 +75,11 @@ interface CommitResult {
   message: String!
 }
 
-type CommitResultAppendError implements CommitResult {
+type CommitResultAppendError implements CommitResult & UpdateReadmeResult {
   message: String!
 }
 
-type CommitResultSuccess implements CommitResult {
+type CommitResultSuccess implements CommitResult & UpdateReadmeResult {
   oldHead: Multihash
   newHead: Multihash!
   message: String!
@@ -317,6 +317,24 @@ type DatasetMetadata {
   currentVocab: SetVocab
 }
 
+type DatasetMetadataMut {
+  """
+  Access to the mutable metadata chain of the dataset
+  """
+  chain: MetadataChainMut!
+  """
+  Updates or clears the dataset readme
+  """
+  updateReadme(content: String): UpdateReadmeResult!
+}
+
+type DatasetMut {
+  """
+  Access to the mutable metadata of the dataset
+  """
+  metadata: DatasetMetadataMut!
+}
+
 scalar DatasetName
 
 scalar DatasetRefAny
@@ -346,6 +364,13 @@ type Datasets {
     page: Int
     perPage: Int
   ): DatasetConnection!
+}
+
+type DatasetsMut {
+  """
+  Returns a mutable dataset by its ID
+  """
+  byId(datasetId: DatasetID!): DatasetMut
   """
   Creates a new empty dataset
   """
@@ -519,6 +544,9 @@ type MetadataChain {
   Iterates all metadata blocks in the reverse chronological order
   """
   blocks(page: Int, perPage: Int): MetadataBlockConnection!
+}
+
+type MetadataChainMut {
   """
   Commits new event to the metadata chain
   """
@@ -555,8 +583,28 @@ type MetadataManifestUnsupportedVersion implements CommitResult & CreateDatasetF
 scalar Multihash
 
 type 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!
+}
+
+type NoChanges implements CommitResult & UpdateReadmeResult {
+  message: String!
 }
 
 type OffsetInterval {
@@ -910,7 +958,7 @@ type Tasks {
   ): TaskConnection!
 }
 
-type TasksMutations {
+type TasksMut {
   """
   Requests cancellation of the specified task
   """
@@ -952,6 +1000,10 @@ type TransformSql {
   temporalTables: [TemporalTable!]
 }
 
+interface UpdateReadmeResult {
+  message: String!
+}
+
 type User implements Account {
   """
   Unique and stable identitfier of this user account

src/app/api/dataset.api.spec.ts

@@ -19,7 +19,7 @@ import {
 import { DatasetApi } from "./dataset.api";
 import {
     CommitEventToDatasetDocument,
-    CommitEventToDatasetQuery,
+    CommitEventToDatasetMutation,
     DatasetsByAccountNameDocument,
     DatasetsByAccountNameQuery,
     GetDatasetDataSqlRunDocument,
@@ -188,22 +188,25 @@ describe("DatasetApi", () => {
     });
 
     it("should commit event", () => {
+        const mockDatasetId = "mockId";
+        const mockEvent = "mock event";
         service
             .commitEvent({
-                accountName: TEST_USER_NAME,
-                datasetName: TEST_DATASET_NAME,
-                event: "mock event",
+                datasetId: mockDatasetId,
+                event: mockEvent,
             })
-            .subscribe((res: CommitEventToDatasetQuery) => {
-                expect(
-                    res.datasets.byOwnerAndName?.metadata.chain.commitEvent
-                        .__typename,
-                ).toEqual("CommitResultSuccess");
-            });
+            .subscribe(
+                (res: CommitEventToDatasetMutation | null | undefined) => {
+                    expect(
+                        res?.datasets.byId?.metadata.chain.commitEvent
+                            .__typename,
+                    ).toEqual("CommitResultSuccess");
+                },
+            );
 
         const op = controller.expectOne(CommitEventToDatasetDocument);
-        expect(op.operation.variables.accountName).toEqual(TEST_USER_NAME);
-        expect(op.operation.variables.datasetName).toEqual(TEST_DATASET_NAME);
+        expect(op.operation.variables.datasetId).toEqual(mockDatasetId);
+        expect(op.operation.variables.event).toEqual(mockEvent);
         op.flush({
             data: mockCommitEventResponse,
         });

src/app/api/dataset.api.ts

@@ -1,12 +1,16 @@
 import {
     CommitEventToDatasetGQL,
-    CommitEventToDatasetQuery,
+    CommitEventToDatasetMutation,
     CreateDatasetFromSnapshotGQL,
-    CreateDatasetFromSnapshotQuery,
-    CreateEmptyDatasetQuery,
+    CreateDatasetFromSnapshotMutation,
+    CreateEmptyDatasetMutation,
+    DatasetByAccountAndDatasetNameGQL,
+    DatasetByAccountAndDatasetNameQuery,
     DatasetKind,
     GetDatasetSchemaGQL,
     GetDatasetSchemaQuery,
+    UpdateReadmeGQL,
+    UpdateReadmeMutation,
 } from "src/app/api/kamu.graphql.interface";
 import AppValues from "src/app/common/app.values";
 import { ApolloQueryResult } from "@apollo/client/core";
@@ -30,6 +34,7 @@ import {
     DatasetByIdGQL,
     CreateEmptyDatasetGQL,
 } from "./kamu.graphql.interface";
+import { MutationResult } from "apollo-angular";
 
 @Injectable({ providedIn: "root" })
 export class DatasetApi {
@@ -40,10 +45,12 @@ export class DatasetApi {
         private datasetsByAccountNameGQL: DatasetsByAccountNameGQL,
         private metadataBlockGQL: GetMetadataBlockGQL,
         private datasetByIdGQL: DatasetByIdGQL,
+        private datasetByAccountAndDatasetNameGQL: DatasetByAccountAndDatasetNameGQL,
         private createEmptyDatasetGQL: CreateEmptyDatasetGQL,
         private createDatasetFromSnapshotGQL: CreateDatasetFromSnapshotGQL,
-        private commitEventToDataset: CommitEventToDatasetGQL,
+        private commitEventToDatasetGQL: CommitEventToDatasetGQL,
         private datasetSchemaGQL: GetDatasetSchemaGQL,
+        private updateReadmeGQL: UpdateReadmeGQL,
     ) {}
 
     public getDatasetMainData(params: {
@@ -162,17 +169,38 @@ export class DatasetApi {
             );
     }
 
+    public getDatasetInfoByAccountAndDatasetName(
+        accountName: string,
+        datasetName: string,
+    ): Observable<DatasetByAccountAndDatasetNameQuery> {
+        return this.datasetByAccountAndDatasetNameGQL
+            .watch({
+                accountName,
+                datasetName,
+            })
+            .valueChanges.pipe(
+                first(),
+                map(
+                    (
+                        result: ApolloQueryResult<DatasetByAccountAndDatasetNameQuery>,
+                    ) => {
+                        return result.data;
+                    },
+                ),
+            );
+    }
+
     public createDatasetFromSnapshot(
         accountId: string,
         snapshot: string,
-    ): Observable<CreateDatasetFromSnapshotQuery> {
+    ): Observable<CreateDatasetFromSnapshotMutation | undefined | null> {
         return this.createDatasetFromSnapshotGQL
-            .watch({ accountId, snapshot })
-            .valueChanges.pipe(
+            .mutate({ accountId, snapshot })
+            .pipe(
                 first(),
                 map(
                     (
-                        result: ApolloQueryResult<CreateDatasetFromSnapshotQuery>,
+                        result: MutationResult<CreateDatasetFromSnapshotMutation>,
                     ) => {
                         return result.data;
                     },
@@ -184,31 +212,46 @@ export class DatasetApi {
         accountId: string,
         datasetKind: DatasetKind,
         datasetName: string,
-    ): Observable<CreateEmptyDatasetQuery> {
+    ): Observable<CreateEmptyDatasetMutation | null | undefined> {
         return this.createEmptyDatasetGQL
-            .watch({ accountId, datasetKind, datasetName })
-            .valueChanges.pipe(
+            .mutate({ accountId, datasetKind, datasetName })
+            .pipe(
                 first(),
-                map((result: ApolloQueryResult<CreateEmptyDatasetQuery>) => {
+                map((result: MutationResult<CreateEmptyDatasetMutation>) => {
                     return result.data;
                 }),
             );
     }
 
     public commitEvent(params: {
-        accountName: string;
-        datasetName: string;
+        datasetId: string;
         event: string;
-    }): Observable<CommitEventToDatasetQuery> {
-        return this.commitEventToDataset
-            .watch({
-                accountName: params.accountName,
-                datasetName: params.datasetName,
+    }): Observable<CommitEventToDatasetMutation | null | undefined> {
+        return this.commitEventToDatasetGQL
+            .mutate({
+                datasetId: params.datasetId,
                 event: params.event,
             })
-            .valueChanges.pipe(
+            .pipe(
+                first(),
+                map((result: MutationResult<CommitEventToDatasetMutation>) => {
+                    return result.data;
+                }),
+            );
+    }
+
+    public updateReadme(
+        datasetId: string,
+        content: string,
+    ): Observable<UpdateReadmeMutation | null | undefined> {
+        return this.updateReadmeGQL
+            .mutate({
+                datasetId,
+                content,
+            })
+            .pipe(
                 first(),
-                map((result: ApolloQueryResult<CommitEventToDatasetQuery>) => {
+                map((result: MutationResult<UpdateReadmeMutation>) => {
                     return result.data;
                 }),
             );

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) {

src/app/api/gql/create-dataset/create-empty-dataset.graphql

@@ -1,4 +1,4 @@
-query createEmptyDataset(
+mutation createEmptyDataset(
   $accountId: AccountID!
   $datasetKind: DatasetKind!
   $datasetName: DatasetName!

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

src/app/api/gql/create-dataset/update-readme.graphql

@@ -0,0 +1,15 @@
+mutation updateReadme($datasetId: DatasetID!, $content: String!) {
+  datasets {
+    byId(datasetId: $datasetId) {
+      metadata {
+        updateReadme(content: $content) {
+          __typename
+          message
+          ... on CommitResultSuccess {
+            oldHead
+          }
+        }
+      }
+    }
+  }
+}

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
+    }
+  }
+}