@kubun/client 0.1.0 → 0.2.0

package/lib/attachments.d.ts

@@ -1,11 +1,10 @@
-import { AttachmentID } from '@kubun/id';
-import { Block } from 'multiformats/block';
-import * as codec from 'multiformats/codecs/raw';
-export type BinaryBlock = Block<Uint8Array, typeof codec.code, 18, 1>;
-export declare function createBlock(value: Uint8Array): BinaryBlock;
+/** @internal */
 export type Attachment = {
-    block: BinaryBlock;
-    id: AttachmentID;
+    data: string;
+    id: string;
 };
-export declare function createAttachment(value: Uint8Array, mimeType?: string): Attachment;
+/** @internal */
+export declare function createAttachment(bytes: Uint8Array, mimeType?: string): Attachment;
+/** @internal */
+export declare function toAttachmentsRecord(attachments?: Array<Attachment>): Record<string, string>;
 //# sourceMappingURL=attachments.d.ts.map

package/lib/attachments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../src/attachments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuC,MAAM,WAAW,CAAA;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,yBAAyB,CAAA;AAEhD,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,UAAU,EAAE,OAAO,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,CAAA;AAErE,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAI1D;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,WAAW,CAAA;IAClB,EAAE,EAAE,YAAY,CAAA;CACjB,CAAA;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAGjF"}
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../src/attachments.ts"],"names":[],"mappings":"AAGA,gBAAgB;AAChB,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,gBAAgB;AAChB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAEjF;AAED,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,WAAW,GAAE,KAAK,CAAC,UAAU,CAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAM/F"}

package/lib/attachments.js

@@ -1,19 +1,15 @@
-import { AttachmentID, createAttachmentCID, toSHA256Digest } from '@kubun/id';
-import { Block } from 'multiformats/block';
-import * as codec from 'multiformats/codecs/raw';
-export function createBlock(value) {
-    const bytes = codec.encode(value);
-    const cid = createAttachmentCID(toSHA256Digest(bytes));
-    return new Block({
-        value,
-        bytes,
-        cid
-    });
-}
-export function createAttachment(value, mimeType) {
-    const block = createBlock(value);
+import { toB64 } from '@enkaku/codec';
+import { AttachmentID } from '@kubun/id';
+/** @internal */ export function createAttachment(bytes, mimeType) {
     return {
-        block,
-        id: new AttachmentID(block.cid, value.byteLength, mimeType)
+        data: toB64(bytes),
+        id: AttachmentID.create(bytes, mimeType).toString()
     };
 }
+/** @internal */ export function toAttachmentsRecord(attachments = []) {
+    const record = {};
+    for (const attachment of attachments){
+        record[attachment.id] = attachment.data;
+    }
+    return record;
+}

package/lib/client.d.ts

@@ -1,474 +1,43 @@
-import type { Signer } from '@enkaku/jwt';
-import type { ClientTransport, CreateGraphParams, ExecuteGraphParams, LoadGraphParams, MutateGraphParams as ProtocolMutateGraphParams } from '@kubun/protocol';
-import type { Attachment } from './attachments.js';
-export type ClientParams = {
-    signer: Signer;
-    transport: ClientTransport;
+import { Client, type RequestCall } from '@enkaku/client';
+import type { TokenSigner } from '@enkaku/token';
+import type { ClientTransport, DeployGraphParams, DeployGraphResult, ExecuteGraphParams, ExecuteGraphResult, ListGraphResult, LoadGraphParams, LoadGraphResult, Protocol } from '@kubun/protocol';
+export type MutateGraphParams = ExecuteGraphParams & {
+    attachments?: Record<string, string>;
+};
+export type KubunClientType = {
+    deployGraph: (params: DeployGraphParams) => RequestCall<DeployGraphResult>;
+    listGraphs: () => RequestCall<ListGraphResult>;
+    loadGraph: (params: LoadGraphParams) => RequestCall<LoadGraphResult>;
+    queryGraph: (params: ExecuteGraphParams) => RequestCall<ExecuteGraphResult>;
+    mutateGraph: (params: MutateGraphParams) => RequestCall<ExecuteGraphResult>;
 };
-export type MutateGraphInvocationParams = Omit<ProtocolMutateGraphParams, 'attachments'> & {
-    attachments?: Array<Attachment>;
+export type ReadClientParams = {
+    getRandomID?: () => string;
+    serverID?: string;
+    signer?: TokenSigner | Promise<TokenSigner>;
+    transport: ClientTransport;
 };
-export type MutateGraphParams = Omit<ExecuteGraphParams, 'attachments'> & {
-    attachments?: Array<Attachment>;
+export type ClientParams = Omit<ReadClientParams, 'signer'> & {
+    signer: TokenSigner | Promise<TokenSigner>;
 };
-export declare class KubunClient {
+export declare class KubunReadClient {
+    #private;
+    constructor(params: ReadClientParams);
+    /** @internal */
+    get client(): Client<Protocol>;
+    listGraphs(signal?: AbortSignal): RequestCall<ListGraphResult>;
+    loadGraph(param: LoadGraphParams, signal?: AbortSignal): RequestCall<LoadGraphResult>;
+    queryGraph(param: ExecuteGraphParams, signal?: AbortSignal): RequestCall<ExecuteGraphResult>;
+}
+export declare class KubunLightClient extends KubunReadClient implements KubunClientType {
+    deployGraph(param: DeployGraphParams, signal?: AbortSignal): RequestCall<DeployGraphResult>;
+    mutateGraph(param: MutateGraphParams, signal?: AbortSignal): RequestCall<ExecuteGraphResult>;
+}
+export declare class KubunClient extends KubunReadClient implements KubunClientType {
     #private;
     constructor(params: ClientParams);
-    createGraph(params: CreateGraphParams): Promise<import("@enkaku/client").InvokeReturn<{
-        id: string;
-        models: {
-            [x: string]: {
-                name: string;
-                version: "1.0";
-                interfaces: string[];
-                schema: {
-                    $defs: {
-                        [x: string]: {
-                            default?: boolean | undefined;
-                            type: "boolean";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "integer";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "number";
-                        } | {
-                            default?: string | undefined;
-                            title?: string | undefined;
-                            maxLength?: number | undefined;
-                            minLength?: number | undefined;
-                            pattern?: string | undefined;
-                            type: "string";
-                        } | {
-                            default?: string | undefined;
-                            enum: string[];
-                            title: string;
-                            type: "string";
-                        } | {
-                            format: "date" | "date-time" | "duration" | "time" | "uri";
-                            type: "string";
-                        } | {
-                            title: string;
-                            type: "array";
-                            items: {
-                                $ref: string;
-                            };
-                        } | {
-                            title: string;
-                            type: "object";
-                            additionalProperties: boolean;
-                            properties: {
-                                [x: string]: {
-                                    $ref: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    type: "object";
-                    additionalProperties: boolean;
-                    properties: {
-                        [x: string]: {
-                            $ref: string;
-                        };
-                    };
-                    required: string[];
-                };
-                fieldsMeta: {
-                    [x: string]: {
-                        relationModel?: string | null | undefined;
-                    };
-                };
-                behavior: "interface";
-            } | {
-                name: string;
-                version: "1.0";
-                interfaces: string[];
-                schema: {
-                    $defs: {
-                        [x: string]: {
-                            default?: boolean | undefined;
-                            type: "boolean";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "integer";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "number";
-                        } | {
-                            default?: string | undefined;
-                            title?: string | undefined;
-                            maxLength?: number | undefined;
-                            minLength?: number | undefined;
-                            pattern?: string | undefined;
-                            type: "string";
-                        } | {
-                            default?: string | undefined;
-                            enum: string[];
-                            title: string;
-                            type: "string";
-                        } | {
-                            format: "date" | "date-time" | "duration" | "time" | "uri";
-                            type: "string";
-                        } | {
-                            title: string;
-                            type: "array";
-                            items: {
-                                $ref: string;
-                            };
-                        } | {
-                            title: string;
-                            type: "object";
-                            additionalProperties: boolean;
-                            properties: {
-                                [x: string]: {
-                                    $ref: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    type: "object";
-                    additionalProperties: boolean;
-                    properties: {
-                        [x: string]: {
-                            $ref: string;
-                        };
-                    };
-                    required: string[];
-                };
-                fieldsMeta: {
-                    [x: string]: {
-                        relationModel?: string | null | undefined;
-                    };
-                };
-                behavior: "list";
-            } | {
-                name: string;
-                version: "1.0";
-                interfaces: string[];
-                schema: {
-                    $defs: {
-                        [x: string]: {
-                            default?: boolean | undefined;
-                            type: "boolean";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "integer";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "number";
-                        } | {
-                            default?: string | undefined;
-                            title?: string | undefined;
-                            maxLength?: number | undefined;
-                            minLength?: number | undefined;
-                            pattern?: string | undefined;
-                            type: "string";
-                        } | {
-                            default?: string | undefined;
-                            enum: string[];
-                            title: string;
-                            type: "string";
-                        } | {
-                            format: "date" | "date-time" | "duration" | "time" | "uri";
-                            type: "string";
-                        } | {
-                            title: string;
-                            type: "array";
-                            items: {
-                                $ref: string;
-                            };
-                        } | {
-                            title: string;
-                            type: "object";
-                            additionalProperties: boolean;
-                            properties: {
-                                [x: string]: {
-                                    $ref: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    type: "object";
-                    additionalProperties: boolean;
-                    properties: {
-                        [x: string]: {
-                            $ref: string;
-                        };
-                    };
-                    required: string[];
-                };
-                fieldsMeta: {
-                    [x: string]: {
-                        relationModel?: string | null | undefined;
-                    };
-                };
-                behavior: "set";
-                setFields: string[];
-            };
-        };
-    }>>;
-    loadGraph(params: LoadGraphParams): Promise<import("@enkaku/client").InvokeReturn<{
-        aliases?: {
-            [x: string]: string;
-        } | undefined;
-        models: {
-            [x: string]: {
-                name: string;
-                version: "1.0";
-                interfaces: string[];
-                schema: {
-                    $defs: {
-                        [x: string]: {
-                            default?: boolean | undefined;
-                            type: "boolean";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "integer";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "number";
-                        } | {
-                            default?: string | undefined;
-                            title?: string | undefined;
-                            maxLength?: number | undefined;
-                            minLength?: number | undefined;
-                            pattern?: string | undefined;
-                            type: "string";
-                        } | {
-                            default?: string | undefined;
-                            enum: string[];
-                            title: string;
-                            type: "string";
-                        } | {
-                            format: "date" | "date-time" | "duration" | "time" | "uri";
-                            type: "string";
-                        } | {
-                            title: string;
-                            type: "array";
-                            items: {
-                                $ref: string;
-                            };
-                        } | {
-                            title: string;
-                            type: "object";
-                            additionalProperties: boolean;
-                            properties: {
-                                [x: string]: {
-                                    $ref: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    type: "object";
-                    additionalProperties: boolean;
-                    properties: {
-                        [x: string]: {
-                            $ref: string;
-                        };
-                    };
-                    required: string[];
-                };
-                fieldsMeta: {
-                    [x: string]: {
-                        relationModel?: string | null | undefined;
-                    };
-                };
-                behavior: "interface";
-            } | {
-                name: string;
-                version: "1.0";
-                interfaces: string[];
-                schema: {
-                    $defs: {
-                        [x: string]: {
-                            default?: boolean | undefined;
-                            type: "boolean";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "integer";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "number";
-                        } | {
-                            default?: string | undefined;
-                            title?: string | undefined;
-                            maxLength?: number | undefined;
-                            minLength?: number | undefined;
-                            pattern?: string | undefined;
-                            type: "string";
-                        } | {
-                            default?: string | undefined;
-                            enum: string[];
-                            title: string;
-                            type: "string";
-                        } | {
-                            format: "date" | "date-time" | "duration" | "time" | "uri";
-                            type: "string";
-                        } | {
-                            title: string;
-                            type: "array";
-                            items: {
-                                $ref: string;
-                            };
-                        } | {
-                            title: string;
-                            type: "object";
-                            additionalProperties: boolean;
-                            properties: {
-                                [x: string]: {
-                                    $ref: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    type: "object";
-                    additionalProperties: boolean;
-                    properties: {
-                        [x: string]: {
-                            $ref: string;
-                        };
-                    };
-                    required: string[];
-                };
-                fieldsMeta: {
-                    [x: string]: {
-                        relationModel?: string | null | undefined;
-                    };
-                };
-                behavior: "list";
-            } | {
-                name: string;
-                version: "1.0";
-                interfaces: string[];
-                schema: {
-                    $defs: {
-                        [x: string]: {
-                            default?: boolean | undefined;
-                            type: "boolean";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "integer";
-                        } | {
-                            default?: number | undefined;
-                            min?: number | undefined;
-                            max?: number | undefined;
-                            type: "number";
-                        } | {
-                            default?: string | undefined;
-                            title?: string | undefined;
-                            maxLength?: number | undefined;
-                            minLength?: number | undefined;
-                            pattern?: string | undefined;
-                            type: "string";
-                        } | {
-                            default?: string | undefined;
-                            enum: string[];
-                            title: string;
-                            type: "string";
-                        } | {
-                            format: "date" | "date-time" | "duration" | "time" | "uri";
-                            type: "string";
-                        } | {
-                            title: string;
-                            type: "array";
-                            items: {
-                                $ref: string;
-                            };
-                        } | {
-                            title: string;
-                            type: "object";
-                            additionalProperties: boolean;
-                            properties: {
-                                [x: string]: {
-                                    $ref: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    type: "object";
-                    additionalProperties: boolean;
-                    properties: {
-                        [x: string]: {
-                            $ref: string;
-                        };
-                    };
-                    required: string[];
-                };
-                fieldsMeta: {
-                    [x: string]: {
-                        relationModel?: string | null | undefined;
-                    };
-                };
-                behavior: "set";
-                setFields: string[];
-            };
-        };
-    }>>;
-    queryGraph(params: ExecuteGraphParams): Promise<import("@enkaku/client").InvokeReturn<{
-        data?: {
-            [x: string]: unknown;
-        } | null | undefined;
-        errors?: {
-            locations?: {
-                line: number;
-                column: number;
-            }[] | undefined;
-            path?: string[] | undefined;
-            extensions?: {
-                [x: string]: unknown;
-            } | undefined;
-            message: string;
-        }[] | undefined;
-        extensions?: {
-            [x: string]: unknown;
-        } | undefined;
-    }>>;
-    mutateGraph(params: MutateGraphParams): Promise<import("@enkaku/client").InvokeReturn<{
-        data?: {
-            [x: string]: unknown;
-        } | null | undefined;
-        errors?: {
-            locations?: {
-                line: number;
-                column: number;
-            }[] | undefined;
-            path?: string[] | undefined;
-            extensions?: {
-                [x: string]: unknown;
-            } | undefined;
-            message: string;
-        }[] | undefined;
-        extensions?: {
-            [x: string]: unknown;
-        } | undefined;
-    }>>;
+    deployGraph(param: DeployGraphParams, signal?: AbortSignal): RequestCall<DeployGraphResult>;
+    loadGraph(param: LoadGraphParams, signal?: AbortSignal): RequestCall<LoadGraphResult>;
+    mutateGraph(param: MutateGraphParams, signal?: AbortSignal): RequestCall<ExecuteGraphResult>;
 }
 //# sourceMappingURL=client.d.ts.map

package/lib/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAEjB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,IAAI,yBAAyB,EAC/C,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAKlD,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,eAAe,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAAC,yBAAyB,EAAE,aAAa,CAAC,GAAG;IACzF,WAAW,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,GAAG;IACxE,WAAW,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;CAChC,CAAA;AAED,qBAAa,WAAW;;gBAKV,MAAM,EAAE,YAAY;IAM1B,WAAW,CAAC,MAAM,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASrC,SAAS,CAAC,MAAM,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASjC,UAAU,CAAC,MAAM,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;IAIrC,WAAW,CAAC,MAAM,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;CAmC5C"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,eAAe,EACf,QAAQ,EACT,MAAM,iBAAiB,CAAA;AAMxB,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AAE7F,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,WAAW,CAAC,iBAAiB,CAAC,CAAA;IAC1E,UAAU,EAAE,MAAM,WAAW,CAAC,eAAe,CAAC,CAAA;IAC9C,SAAS,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,WAAW,CAAC,eAAe,CAAC,CAAA;IACpE,UAAU,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,WAAW,CAAC,kBAAkB,CAAC,CAAA;IAC3E,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,WAAW,CAAC,kBAAkB,CAAC,CAAA;CAC5E,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,MAAM,CAAA;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3C,SAAS,EAAE,eAAe,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,GAAG;IAC5D,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;CAC3C,CAAA;AAED,qBAAa,eAAe;;gBAGd,MAAM,EAAE,gBAAgB;IAIpC,gBAAgB;IAChB,IAAI,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,CAE7B;IAED,UAAU,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,eAAe,CAAC;IAI9D,SAAS,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,eAAe,CAAC;IAIrF,UAAU,CAAC,KAAK,EAAE,kBAAkB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,kBAAkB,CAAC;CAG7F;AAED,qBAAa,gBAAiB,SAAQ,eAAgB,YAAW,eAAe;IAC9E,WAAW,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,iBAAiB,CAAC;IAI3F,WAAW,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,kBAAkB,CAAC;CAG7F;AAED,qBAAa,WAAY,SAAQ,eAAgB,YAAW,eAAe;;gBAI7D,MAAM,EAAE,YAAY;IAMhC,WAAW,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,iBAAiB,CAAC;IAU3F,SAAS,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,eAAe,CAAC;IAgDrF,WAAW,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC,kBAAkB,CAAC;CAM7F"}

package/lib/client.js

@@ -1,74 +1,144 @@
 import { Client } from '@enkaku/client';
-import { toB64 } from '@enkaku/codec';
+import { fromB64 } from '@enkaku/codec';
 import { GraphQLExecutionError } from './errors.js';
 import { ClientSchemaBuilder } from './graphql.js';
 import { MutationsRunner } from './mutations-runner.js';
-export class KubunClient {
+export class KubunReadClient {
     #client;
-    #mutationsRunner;
-    #signer;
     constructor(params){
-        this.#client = new Client({
-            transport: params.transport
+        this.#client = new Client(params);
+    }
+    /** @internal */ get client() {
+        return this.#client;
+    }
+    listGraphs(signal) {
+        return this.#client.request('graph/list', {
+            signal
         });
-        this.#mutationsRunner = new MutationsRunner();
-        this.#signer = params.signer;
     }
-    async createGraph(params) {
-        const request = await this.#client.request('graph/create', params);
-        request.result.then((res)=>{
-            const builder = new ClientSchemaBuilder({
-                record: res.models
-            });
-            this.#mutationsRunner.setSchema(res.id, builder.build());
+    loadGraph(param, signal) {
+        return this.#client.request('graph/load', {
+            param,
+            signal
+        });
+    }
+    queryGraph(param, signal) {
+        return this.#client.request('graph/query', {
+            param,
+            signal
+        });
+    }
+}
+export class KubunLightClient extends KubunReadClient {
+    deployGraph(param, signal) {
+        return this.client.request('graph/deploy', {
+            param,
+            signal
         });
-        return request;
     }
-    async loadGraph(params) {
-        const request = await this.#client.request('graph/load', params);
-        request.result.then((res)=>{
+    mutateGraph(param, signal) {
+        return this.client.request('graph/mutate', {
+            param: {
+                ...param,
+                mutations: {}
+            },
+            signal
+        });
+    }
+}
+export class KubunClient extends KubunReadClient {
+    #mutationsRunner;
+    #signerPromise;
+    constructor(params){
+        super(params);
+        this.#mutationsRunner = new MutationsRunner();
+        this.#signerPromise = Promise.resolve(params.signer);
+    }
+    deployGraph(param, signal) {
+        const request = this.client.request('graph/deploy', {
+            param,
+            signal
+        });
+        const call = request.then((result)=>{
             const builder = new ClientSchemaBuilder({
-                record: res.models
+                record: result.models
             });
-            this.#mutationsRunner.setSchema(params.id, builder.build());
+            this.#mutationsRunner.setSchema(result.id, builder.build());
+            return result;
+        });
+        return Object.assign(call, {
+            abort: request.abort,
+            signal: request.signal
         });
-        return request;
     }
-    async queryGraph(params) {
-        return await this.#client.request('graph/query', params);
+    loadGraph(param, signal) {
+        const request = super.loadGraph(param, signal);
+        const call = request.then((result)=>{
+            if (result.models != null) {
+                const builder = new ClientSchemaBuilder({
+                    record: result.models
+                });
+                this.#mutationsRunner.setSchema(param.id, builder.build());
+            }
+            return result;
+        });
+        return Object.assign(call, {
+            abort: request.abort,
+            signal: request.signal
+        });
     }
-    async mutateGraph(params) {
-        const { attachments, id, ...rest } = params;
+    async #mutateGraph(param, signal) {
+        const { id, ...rest } = param;
         if (!this.#mutationsRunner.hasSchema(id)) {
-            const loadGraphRequest = await this.loadGraph({
+            await this.loadGraph({
                 id
-            });
-            await loadGraphRequest.result;
+            }, signal);
         }
+        signal.throwIfAborted();
         const context = {
+            // TODO: local cache for documents state, ideally updated after successful mutations
+            loadState: async (docID)=>{
+                const res = await this.client.request('document/sync', {
+                    param: {
+                        documents: {
+                            [docID]: null
+                        }
+                    }
+                });
+                const state = res.states[docID];
+                return state ? fromB64(state) : null;
+            },
             mutations: {},
-            signer: this.#signer
+            signer: await this.#signerPromise
         };
         const { errors } = await this.#mutationsRunner.execute({
             context,
             schemaID: id,
-            source: params.text,
-            variables: params.variables
+            source: param.text,
+            variables: param.variables
         });
         if (errors != null && errors.length !== 0) {
             throw new GraphQLExecutionError(errors);
         }
-        const attachmentsRecord = {};
-        if (attachments != null) {
-            for (const { id, block } of attachments){
-                attachmentsRecord[id.toString()] = toB64(block.bytes);
-            }
-        }
-        return await this.#client.request('graph/mutate', {
-            id,
-            attachments: attachmentsRecord,
-            mutations: context.mutations,
-            ...rest
+        return await this.client.request('graph/mutate', {
+            param: {
+                id,
+                mutations: context.mutations,
+                ...rest
+            },
+            signal
+        });
+    }
+    mutateGraph(param, signal) {
+        const controller = new AbortController();
+        const anySignal = signal ? AbortSignal.any([
+            controller.signal,
+            signal
+        ]) : controller.signal;
+        const promise = this.#mutateGraph(param, anySignal);
+        return Object.assign(promise, {
+            abort: ()=>controller.abort(),
+            signal: anySignal
         });
     }
 }

package/lib/graphql.d.ts

@@ -1,9 +1,11 @@
-import { type Signer } from '@enkaku/jwt';
+import { type TokenSigner } from '@enkaku/token';
 import { type DocumentType, SchemaBuilder, type SharedDefinitions } from '@kubun/graphql';
 export type Context = {
+    loadState: (id: string) => Promise<Uint8Array | null>;
     mutations: Record<string, string>;
-    signer: Signer;
+    signer: TokenSigner;
 };
+/** @internal */
 export declare class ClientSchemaBuilder extends SchemaBuilder<DocumentType, Context> {
     buildMutations(id: string, definitions: SharedDefinitions<DocumentType, Context>): void;
 }

package/lib/graphql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../src/graphql.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,MAAM,EAAkB,MAAM,aAAa,CAAA;AAC3E,OAAO,EAAE,KAAK,YAAY,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAOzF,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAEjC,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,qBAAa,mBAAoB,SAAQ,aAAa,CAAC,YAAY,EAAE,OAAO,CAAC;IAC3E,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG,IAAI;CAkGxF"}
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../src/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAkB,MAAM,eAAe,CAAA;AAChE,OAAO,EACL,KAAK,YAAY,EAEjB,aAAa,EACb,KAAK,iBAAiB,EAGvB,MAAM,gBAAgB,CAAA;AAWvB,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAA;IACrD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAED,gBAAgB;AAChB,qBAAa,mBAAoB,SAAQ,aAAa,CAAC,YAAY,EAAE,OAAO,CAAC;IAC3E,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG,IAAI;CA4GxF"}

package/lib/graphql.js

@@ -1,10 +1,9 @@
-import { fromUTF } from '@enkaku/codec';
-import { stringifyToken } from '@enkaku/jwt';
-import { SchemaBuilder } from '@kubun/graphql';
+import { stringifyToken } from '@enkaku/token';
+import { PatchOperation, SchemaBuilder, getUniqueDocValue, toList } from '@kubun/graphql';
 import { GraphQLID, GraphQLNonNull } from 'graphql';
 import { mutationWithClientMutationId } from 'graphql-relay';
 import { createChangeMutation, createSetMutation } from './mutations.js';
-export class ClientSchemaBuilder extends SchemaBuilder {
+/** @internal */ export class ClientSchemaBuilder extends SchemaBuilder {
     buildMutations(id, definitions) {
         const model = this._record[id];
         if (model == null) {
@@ -15,7 +14,7 @@ export class ClientSchemaBuilder extends SchemaBuilder {
             case 'interface':
                 // Interfaces don't have mutations
                 return;
-            case 'list':
+            case 'default':
                 {
                     this._mutations[`create${name}`] = mutationWithClientMutationId({
                         name: `Create${name}`,
@@ -50,7 +49,7 @@ export class ClientSchemaBuilder extends SchemaBuilder {
                     });
                     break;
                 }
-            case 'set':
+            case 'unique':
                 {
                     this._mutations[`set${name}`] = mutationWithClientMutationId({
                         name: `Set${name}`,
@@ -67,13 +66,12 @@ export class ClientSchemaBuilder extends SchemaBuilder {
                             }),
                         mutateAndGetPayload: async (input, ctx, info)=>{
                             // Create the mutation token
-                            const unique = model.setFields.map((field)=>String(input.data[field] ?? '')).join('|');
                             const mutation = await createSetMutation({
                                 signer: ctx.signer,
                                 modelID: id,
                                 data: input.data,
                                 // owner: ctx.owner,
-                                unique: fromUTF(unique)
+                                unique: getUniqueDocValue(model.uniqueFields, input.data)
                             });
                             // Add the signed mutation to context so it can be retrieved by the client
                             ctx.mutations[info.path.key] = stringifyToken(mutation);
@@ -92,7 +90,10 @@ export class ClientSchemaBuilder extends SchemaBuilder {
                     id: {
                         type: new GraphQLNonNull(GraphQLID)
                     },
-                    data: {
+                    patch: {
+                        type: new GraphQLNonNull(toList(PatchOperation))
+                    },
+                    from: {
                         type: this._inputObjects[`${id}-update`]
                     }
                 }),
@@ -103,11 +104,20 @@ export class ClientSchemaBuilder extends SchemaBuilder {
                     }
                 }),
             mutateAndGetPayload: async (input, ctx, info)=>{
-                // TODO: add existing doc if available
                 const mutation = await createChangeMutation({
+                    loadState: ctx.loadState,
                     signer: ctx.signer,
                     docID: input.id,
-                    data: input.data
+                    patch: input.patch.map((patch)=>{
+                        // convert GraphQL patch input types to PatchOperationType
+                        const entries = Object.entries(patch);
+                        const [op, rest] = entries[0];
+                        return {
+                            ...rest,
+                            op
+                        };
+                    }),
+                    from: input.from
                 });
                 // Add the signed mutation to context so it can be retrieved by the client
                 ctx.mutations[info.path.key] = stringifyToken(mutation);

package/lib/index.d.ts

@@ -1,3 +1,4 @@
-export { createAttachment } from './attachments.js';
-export { type ClientParams, KubunClient, type MutateGraphParams, } from './client.js';
+export { type Attachment, createAttachment, toAttachmentsRecord } from './attachments.js';
+export { type ClientParams, KubunClient, type KubunClientType, KubunLightClient, KubunReadClient, type MutateGraphParams, type ReadClientParams, } from './client.js';
+export { ClientSchemaBuilder } from './graphql.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EACL,KAAK,YAAY,EACjB,WAAW,EACX,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AACzF,OAAO,EACL,KAAK,YAAY,EACjB,WAAW,EACX,KAAK,eAAe,EACpB,gBAAgB,EAChB,eAAe,EACf,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA"}

package/lib/index.js

@@ -1,2 +1,3 @@
-export { createAttachment } from './attachments.js';
-export { KubunClient } from './client.js';
+export { createAttachment, toAttachmentsRecord } from './attachments.js';
+export { KubunClient, KubunLightClient, KubunReadClient } from './client.js';
+export { ClientSchemaBuilder } from './graphql.js';

package/lib/mutations.d.ts

@@ -1,21 +1,45 @@
-import * as A from '@automerge/automerge';
-import { type SignedToken, type Signer } from '@enkaku/jwt';
-import { DocumentID, type GraphModelID } from '@kubun/id';
+import type { SignedToken, TokenSigner } from '@enkaku/token';
+import { DocumentID, type DocumentModelID } from '@kubun/id';
 import type { ChangeDocumentMutation, DocumentData, SetDocumentMutation } from '@kubun/protocol';
-export declare function getMutationData<Data extends DocumentData = DocumentData>(data: Data | null, doc?: A.Doc<Data>): string | null;
+export type PatchAddOperation = {
+    op: 'add';
+    path: string;
+    value: unknown;
+};
+export type PatchRemoveOperation = {
+    op: 'remove';
+    path: string;
+};
+export type PatchReplaceOperation = {
+    op: 'replace';
+    path: string;
+    value: unknown;
+};
+export type PatchMoveOperation = {
+    op: 'move';
+    from: string;
+    path: string;
+};
+export type PatchCopyOperation = {
+    op: 'copy';
+    from: string;
+    path: string;
+};
+export type PatchOperation = PatchAddOperation | PatchCopyOperation | PatchMoveOperation | PatchRemoveOperation | PatchReplaceOperation;
 export type SetMutationParams<Data extends DocumentData = DocumentData> = {
-    signer: Signer;
-    owner?: string;
-    modelID: GraphModelID | string;
     data: Data | null;
+    modelID: DocumentModelID | string;
+    owner?: string;
+    signer: TokenSigner;
     unique: Uint8Array;
 };
 export declare function createSetMutation<Data extends DocumentData = DocumentData>(params: SetMutationParams<Data>): Promise<SignedToken<SetDocumentMutation>>;
 export type CreateChangeMutationParams<Data extends DocumentData = DocumentData> = {
-    signer: Signer;
     docID: DocumentID | string;
-    data: Data | null;
-    doc?: A.Doc<Data>;
+    from?: Partial<Data>;
+    loadState: (id: string) => Promise<Uint8Array | null>;
+    patch: Array<PatchOperation>;
+    signer: TokenSigner;
 };
 export declare function createChangeMutation<Data extends DocumentData = DocumentData>(params: CreateChangeMutationParams<Data>): Promise<SignedToken<ChangeDocumentMutation>>;
 //# sourceMappingURL=mutations.d.ts.map

package/lib/mutations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../src/mutations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAA;AAEzC,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,MAAM,EAAqB,MAAM,aAAa,CAAA;AAC9E,OAAO,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAEhG,wBAAgB,eAAe,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,EACtE,IAAI,EAAE,IAAI,GAAG,IAAI,EACjB,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAChB,MAAM,GAAG,IAAI,CAWf;AAED,MAAM,MAAM,iBAAiB,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,IAAI;IACxE,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,YAAY,GAAG,MAAM,CAAA;IAC9B,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;IACjB,MAAM,EAAE,UAAU,CAAA;CACnB,CAAA;AAED,wBAAsB,iBAAiB,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,EAC9E,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,GAC9B,OAAO,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,CAU3C;AAED,MAAM,MAAM,0BAA0B,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,IAAI;IACjF,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,UAAU,GAAG,MAAM,CAAA;IAC1B,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;IACjB,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;CAClB,CAAA;AAED,wBAAsB,oBAAoB,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,EACjF,MAAM,EAAE,0BAA0B,CAAC,IAAI,CAAC,GACvC,OAAO,CAAC,WAAW,CAAC,sBAAsB,CAAC,CAAC,CAQ9C"}
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../src/mutations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,WAAW,CAAA;AAC5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAIhG,MAAM,MAAM,iBAAiB,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAA;AAC3E,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AACjE,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAA;AACnF,MAAM,MAAM,kBAAkB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAC3E,MAAM,MAAM,kBAAkB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAC3E,MAAM,MAAM,cAAc,GACtB,iBAAiB,GACjB,kBAAkB,GAClB,kBAAkB,GAClB,oBAAoB,GACpB,qBAAqB,CAAA;AA+EzB,MAAM,MAAM,iBAAiB,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,IAAI;IACxE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;IACjB,OAAO,EAAE,eAAe,GAAG,MAAM,CAAA;IACjC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,WAAW,CAAA;IACnB,MAAM,EAAE,UAAU,CAAA;CACnB,CAAA;AAED,wBAAsB,iBAAiB,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,EAC9E,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,GAC9B,OAAO,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,CAa3C;AAED,MAAM,MAAM,0BAA0B,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,IAAI;IACjF,KAAK,EAAE,UAAU,GAAG,MAAM,CAAA;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;IACpB,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAA;IACrD,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,CAAA;IAC5B,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAED,wBAAsB,oBAAoB,CAAC,IAAI,SAAS,YAAY,GAAG,YAAY,EACjF,MAAM,EAAE,0BAA0B,CAAC,IAAI,CAAC,GACvC,OAAO,CAAC,WAAW,CAAC,sBAAsB,CAAC,CAAC,CAkB9C"}

package/lib/mutations.js

@@ -1,36 +1,113 @@
-import * as A from '@automerge/automerge';
+// @ts-ignore missing type definition
+import { automergeWasmBase64 } from '@automerge/automerge/automerge.wasm.base64.js';
+import * as A from '@automerge/automerge/slim';
+import { lazy } from '@enkaku/async';
 import { toB64 } from '@enkaku/codec';
-import { createSignedToken } from '@enkaku/jwt';
 import { DocumentID } from '@kubun/id';
-export function getMutationData(data, doc) {
-    if (data == null) {
-        return null;
+const automergeReady = lazy(()=>A.initializeBase64Wasm(automergeWasmBase64));
+function parsePath(path) {
+    return path.slice(1).split('/').map((key)=>{
+        // Convert array indices to numbers
+        const index = Number(key);
+        return Number.isNaN(index) ? key : index;
+    });
+}
+function getPath(obj, path) {
+    const keys = parsePath(path);
+    // @ts-ignore index signature
+    return keys.reduce((acc, key)=>acc?.[key], obj);
+}
+function setPath(obj, path, value) {
+    const keys = parsePath(path);
+    const lastKey = keys.pop();
+    if (lastKey !== undefined) {
+        // @ts-ignore unknown object
+        const target = keys.reduce((acc, key)=>acc[key], obj);
+        if (Array.isArray(target) && typeof lastKey === 'number' && lastKey === target.length) {
+            target.push(value) // Append to array if index is equal to array length
+            ;
+        } else {
+            ;
+            target[lastKey] = value;
+        }
+    }
+}
+function deletePath(obj, path) {
+    const keys = parsePath(path);
+    const lastKey = keys.pop();
+    if (lastKey !== undefined) {
+        // @ts-ignore unknown object
+        const target = keys.reduce((acc, key)=>acc[key], obj);
+        if (Array.isArray(target) && typeof lastKey === 'number') {
+            target.splice(lastKey, 1) // Remove from array if lastKey is an index
+            ;
+        } else {
+            delete target[lastKey];
+        }
     }
-    if (doc == null) {
-        return toB64(A.save(A.from(data)));
+}
+function applyPatches(data, patches) {
+    for (const patch of patches){
+        switch(patch.op){
+            case 'add':
+            case 'replace':
+                setPath(data, patch.path, patch.value);
+                break;
+            case 'remove':
+                deletePath(data, patch.path);
+                break;
+            case 'copy':
+                {
+                    const value = getPath(data, patch.from);
+                    setPath(data, patch.path, value);
+                    break;
+                }
+            case 'move':
+                {
+                    const value = getPath(data, patch.from);
+                    deletePath(data, patch.from);
+                    setPath(data, patch.path, value);
+                    break;
+                }
+            default:
+                // @ts-ignore never type
+                throw new Error(`Unknown operation: ${patch.op}`);
+        }
     }
-    const changedDoc = A.change(doc, (proxy)=>{
-        Object.assign(proxy, data);
-    });
-    return toB64(A.saveSince(changedDoc, A.getHeads(doc)));
 }
 export async function createSetMutation(params) {
-    const owner = params.owner ?? params.signer.did;
-    return await createSignedToken(params.signer, {
+    const issuer = params.signer.id;
+    const owner = params.owner ?? issuer;
+    await automergeReady;
+    const docID = await DocumentID.create(params.modelID, owner, params.unique);
+    return await params.signer.createToken({
         typ: 'set',
-        iss: params.signer.did,
+        iss: issuer,
         aud: owner,
-        sub: DocumentID.create(params.modelID, owner, params.unique).toString(),
-        data: getMutationData(params.data),
+        sub: docID.toString(),
+        data: params.data == null ? null : toB64(A.save(A.from(params.data))),
         unq: toB64(params.unique)
     });
 }
 export async function createChangeMutation(params) {
-    return await createSignedToken(params.signer, {
+    const docID = DocumentID.from(params.docID).toString();
+    // Load current state of document from DB
+    const [state] = await Promise.all([
+        params.loadState(docID),
+        automergeReady
+    ]);
+    const loadedDoc = state ? A.load(state) : null;
+    // Apply patches to loaded doc or locally created one
+    const newDoc = A.change(loadedDoc ?? A.from(params.from ?? {}), (proxy)=>{
+        applyPatches(proxy, params.patch);
+    });
+    // Save incremental or full data state
+    const data = loadedDoc ? A.saveSince(newDoc, A.getHeads(loadedDoc)) : A.save(newDoc);
+    return await params.signer.createToken({
         typ: 'change',
-        iss: params.signer.did,
-        sub: DocumentID.from(params.docID).toString(),
-        data: getMutationData(params.data, params.doc),
-        inc: params.doc != null
+        iss: params.signer.id,
+        sub: docID,
+        data: toB64(data),
+        inc: loadedDoc != null
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/client",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -16,17 +16,18 @@
   "sideEffects": false,
   "dependencies": {
     "@automerge/automerge": "^2.2.8",
-    "@enkaku/client": "^0.2.2",
-    "@enkaku/codec": "^0.2.0",
-    "@enkaku/jwt": "^0.2.3",
+    "@enkaku/async": "^0.11.0",
+    "@enkaku/client": "^0.11.0",
+    "@enkaku/codec": "^0.11.0",
+    "@enkaku/token": "^0.11.0",
     "graphql": "^16.9.0",
     "graphql-relay": "^0.10.2",
-    "multiformats": "^13.3.0",
-    "@kubun/graphql": "^0.1.0",
-    "@kubun/id": "^0.1.0"
+    "multiformats": "^13.3.1",
+    "@kubun/graphql": "^0.2.0",
+    "@kubun/id": "^0.2.0"
   },
   "devDependencies": {
-    "@kubun/protocol": "^0.1.0"
+    "@kubun/protocol": "^0.2.0"
   },
   "scripts": {
     "build:clean": "del lib",