@kubun/mutation 0.5.0 → 0.6.0

package/lib/apply.d.ts

@@ -1,6 +1,7 @@
 import { type Validator } from '@enkaku/schema';
 import type { KubunDB } from '@kubun/db';
 import type { ChangeDocumentMutation, DocumentData, DocumentMutation, DocumentNode, SetDocumentMutation } from '@kubun/protocol';
+import { HLC } from './hlc.js';
 export type DocumentValidator = Validator<DocumentData>;
 export type ValidatorsRecord = Record<string, Promise<DocumentValidator>>;
 export type AccessChecker = (doc: {
@@ -13,6 +14,8 @@ export type MutationContext = {
     db: KubunDB;
     validators: ValidatorsRecord;
     accessChecker?: AccessChecker;
+    hlc?: HLC;
+    maxDriftMS?: number;
 };
 export declare function getDocumentValidator(ctx: MutationContext, id: string): Promise<DocumentValidator>;
 export declare function applyChangeMutation(ctx: MutationContext, mutation: ChangeDocumentMutation): Promise<DocumentNode>;

package/lib/apply.js

@@ -1 +1 @@
-import*as t from"@automerge/automerge/slim";import{fromB64 as e}from"@enkaku/codec";import{asType as a,createValidator as r}from"@enkaku/schema";import{DocumentID as o}from"@kubun/id";import{automergeReady as n,automergeToData as i}from"./automerge.js";export function getDocumentValidator(t,e){return null==t.validators[e]&&(t.validators[e]=t.db.getDocumentModel(e).then(t=>r({...t.schema,$id:e}))),t.validators[e]}export async function applyChangeMutation(r,u){let s=o.fromString(u.sub),l=s.toString(),c=await r.db.getDocument(s);if(null==c)throw Error(`Document not found: ${l}`);if(u.iss!==c.owner)throw Error("Invalid mutation issuer");if(r.accessChecker&&!await r.accessChecker(c,"write"))throw Error(`Access denied: cannot write document ${l}`);if(null===u.data)return await r.db.saveDocument({id:s,existing:c,data:null,state:null});if(null===c.data)throw Error(`Cannot apply changes to empty document: ${l}`);let[m,d]=await Promise.all([r.db.getDocumentStates([l]),getDocumentValidator(r,s.model.toString()),n]),w=m[l]?t.load(m[l]):t.from(c.data),g=e(u.data),p=u.inc?t.loadIncremental(w,g):t.merge(w,t.load(g)),f=a(d,i(p));return await r.db.saveDocument({id:s,existing:c,data:f,state:t.save(p)})}export async function applySetMutation(r,u){let s=u.aud??u.iss;if(u.iss!==s)throw Error("Invalid mutation issuer");let l=o.fromString(u.sub),[c,m]=await Promise.all([r.db.getDocument(l),getDocumentValidator(r,l.model.toString()),n]),d=null===u.data?null:t.load(e(u.data)),w=d?a(m,i(d)):null;if(null===c)return await r.db.createDocument({id:l,owner:s,data:w,state:d?t.save(d):null,unique:e(u.unq)});if(c.owner!==s)throw Error(`Cannot change owner from ${c.owner} to ${s} in document: ${l.toString()}`);if(r.accessChecker&&!await r.accessChecker(c,"write"))throw Error(`Access denied: cannot write document ${l.toString()}`);return await r.db.saveDocument({id:l,existing:c,data:w,state:d?t.save(d):null})}export async function applyMutation(t,e){switch(e.typ){case"change":return await applyChangeMutation(t,e);case"set":return await applySetMutation(t,e);default:throw Error("Unsupported mutation type")}}
+import{fromB64 as t}from"@enkaku/codec";import{asType as e,createValidator as a}from"@enkaku/schema";import{DocumentID as r}from"@kubun/id";import{HLC as i}from"./hlc.js";export function getDocumentValidator(t,e){return null==t.validators[e]&&(t.validators[e]=t.db.getDocumentModel(e).then(t=>a({...t.schema,$id:e}))),t.validators[e]}function n(t,e,a){let r=i.parse(t),n=Date.now(),o=r.wallTime-n;if(o>e)throw Error(`HLC timestamp too far in the future: ${o}ms drift exceeds ${e}ms limit`);a&&a.receive(r)}export async function applyChangeMutation(t,a){let i=r.fromString(a.sub),o=i.toString(),l=await t.db.getDocument(i);if(null==l)throw Error(`Document not found: ${o}`);if(a.iss!==l.owner)throw Error("Invalid mutation issuer");if(t.accessChecker&&!await t.accessChecker(l,"write"))throw Error(`Access denied: cannot write document ${o}`);null!=t.maxDriftMS&&n(a.hlc,t.maxDriftMS,t.hlc);let c=i.model.toString(),u=await t.db.getFieldHLCs(o)??{};if(1===a.patch.length&&"replace"===a.patch[0].op&&"/"===a.patch[0].path&&null===a.patch[0].value){let e={...u,"/":a.hlc},r=Object.entries(e).every(([t,e])=>"/"===t||a.hlc>=e);return(await t.db.updateFieldHLCs(i,e),r)?await t.db.saveDocument({id:i,existing:l,data:null}):l}if(null!=u["/"]&&null===l.data)return l;let s=await getDocumentValidator(t,c),d=a.patch.filter(t=>"value"in t),h={...l.data??{}},m={...u},f=!1;for(let t of d){let e=u[t.path];(null==e||a.hlc>e)&&(h[t.path.slice(1)]=t.value,m[t.path]=a.hlc,f=!0)}if(!f)return l;await t.db.updateFieldHLCs(i,m);let p=e(s,h);return await t.db.saveDocument({id:i,existing:l,data:p})}export async function applySetMutation(a,i){let o=i.aud??i.iss;if(i.iss!==o)throw Error("Invalid mutation issuer");let l=r.fromString(i.sub),c=l.toString(),u=l.model.toString();null!=a.maxDriftMS&&n(i.hlc,a.maxDriftMS,a.hlc);let[s,d]=await Promise.all([a.db.getDocument(l),getDocumentValidator(a,u)]),h=e(d,i.data),m={};for(let t of Object.keys(h))m[`/${t}`]=i.hlc;if(null===s){let e=await a.db.createDocument({id:l,owner:o,data:h,unique:t(i.unq)});return await a.db.updateFieldHLCs(l,m),e}if(s.owner!==o)throw Error(`Cannot change owner from ${s.owner} to ${o} in document: ${l.toString()}`);if(a.accessChecker&&!await a.accessChecker(s,"write"))throw Error(`Access denied: cannot write document ${l.toString()}`);let f=await a.db.getFieldHLCs(c)??{},p={...s.data??{}},w={...f},g=!1;for(let[t,e]of Object.entries(h)){let a=`/${t}`,r=f[a];(null==r||i.hlc>r)&&(p[t]=e,w[a]=i.hlc,g=!0)}if(!g)return s;await a.db.updateFieldHLCs(l,w);let b=e(d,p);return await a.db.saveDocument({id:l,existing:s,data:b})}export async function applyMutation(t,e){switch(e.typ){case"change":return await applyChangeMutation(t,e);case"set":return await applySetMutation(t,e);default:throw Error("Unsupported mutation type")}}

package/lib/create.d.ts

@@ -1,24 +1,26 @@
 import type { PatchOperation } from '@kubun/graphql';
 import { DocumentID, type DocumentModelID } from '@kubun/id';
 import type { ChangeDocumentMutation, DocumentData, SetDocumentMutation } from '@kubun/protocol';
+import { HLC } from './hlc.js';
 export type CreateSetMutationParams<Data extends DocumentData = DocumentData> = {
-    data: Data | null;
+    data: Data;
+    hlc: HLC;
     issuer: string;
     modelID: DocumentModelID | string;
     owner?: string;
     unique: Uint8Array;
 };
 export declare function createSetMutation<Data extends DocumentData = DocumentData>(params: CreateSetMutationParams<Data>): Promise<SetDocumentMutation>;
-export type CreateChangeMutationParams<Data extends DocumentData = DocumentData> = {
+export type CreateChangeMutationParams = {
     docID: DocumentID | string;
-    from?: Partial<Data>;
+    hlc: HLC;
     issuer: string;
-    loadState: (id: string) => Promise<Uint8Array | null>;
     patch: Array<PatchOperation>;
 };
-export declare function createChangeMutation<Data extends DocumentData = DocumentData>(params: CreateChangeMutationParams<Data>): Promise<ChangeDocumentMutation>;
+export declare function createChangeMutation(params: CreateChangeMutationParams): ChangeDocumentMutation;
 export type CreateRemoveMutationParams = {
     docID: string;
+    hlc: HLC;
     issuer: string;
 };
 export declare function createRemoveMutation(params: CreateRemoveMutationParams): ChangeDocumentMutation;

package/lib/create.js

@@ -1 +1 @@
-import*as t from"@automerge/automerge/slim";import{toB64 as e}from"@enkaku/codec";import{applyPatches as a}from"@enkaku/patch";import{DocumentID as o}from"@kubun/id";import{automergeReady as r}from"./automerge.js";export async function createSetMutation(a){let n=a.issuer,u=a.owner??n,[i]=await Promise.all([o.create(a.modelID,u,a.unique),r]);return{typ:"set",iss:n,aud:u,sub:i.toString(),data:null==a.data?null:e(t.save(t.from(a.data))),unq:e(a.unique)}}export async function createChangeMutation(n){let u=o.from(n.docID).toString(),[i]=await Promise.all([n.loadState(u),r]),s=i?t.load(i):null,m=t.change(s??t.from(n.from??{}),t=>{a(t,n.patch)}),c=s?t.saveSince(m,t.getHeads(s)):t.save(m);return{typ:"change",iss:n.issuer,sub:u,data:e(c),inc:null!=s}}export function createRemoveMutation(t){return{typ:"change",iss:t.issuer,sub:t.docID,data:null,inc:!1}}
+import{toB64 as e}from"@enkaku/codec";import{DocumentID as t}from"@kubun/id";import{HLC as r}from"./hlc.js";export async function createSetMutation(a){let n=a.issuer,o=a.owner??n,i=await t.create(a.modelID,o,a.unique);return{typ:"set",iss:n,aud:o,sub:i.toString(),data:a.data,hlc:r.serialize(a.hlc.now()),unq:e(a.unique)}}export function createChangeMutation(e){return{typ:"change",iss:e.issuer,sub:t.from(e.docID).toString(),patch:e.patch,hlc:r.serialize(e.hlc.now())}}export function createRemoveMutation(e){return{typ:"change",iss:e.issuer,sub:e.docID,patch:[{op:"replace",path:"/",value:null}],hlc:r.serialize(e.hlc.now())}}

package/lib/hlc.d.ts

@@ -0,0 +1,19 @@
+export type HLCTimestamp = {
+    wallTime: number;
+    counter: number;
+    nodeID: string;
+};
+type HLCParams = {
+    nodeID: string;
+};
+export declare class HLC {
+    #private;
+    constructor(params: HLCParams);
+    get nodeID(): string;
+    now(): HLCTimestamp;
+    receive(remote: HLCTimestamp): HLCTimestamp;
+    static serialize(ts: HLCTimestamp): string;
+    static parse(s: string): HLCTimestamp;
+    static compare(a: HLCTimestamp, b: HLCTimestamp): number;
+}
+export {};

package/lib/hlc.js

@@ -0,0 +1 @@
+export class HLC{#t;#e=0;#l=0;constructor(t){this.#t=t.nodeID}get nodeID(){return this.#t}now(){let t=Date.now();return t>this.#e?(this.#e=t,this.#l=0):this.#l++,{wallTime:this.#e,counter:this.#l,nodeID:this.#t}}receive(t){let e=Date.now();return e>this.#e&&e>t.wallTime?(this.#e=e,this.#l=0):t.wallTime>this.#e?(this.#e=t.wallTime,this.#l=t.counter+1):this.#e>t.wallTime?this.#l++:this.#l=Math.max(this.#l,t.counter)+1,{wallTime:this.#e,counter:this.#l,nodeID:this.#t}}static serialize(t){let e=new Date(t.wallTime).toISOString(),l=t.counter.toString().padStart(4,"0");return`${e}:${l}:${t.nodeID}`}static parse(t){let e=t.indexOf("Z"),l=new Date(t.slice(0,e+1)).getTime(),i=t.slice(e+2),a=i.indexOf(":");return{wallTime:l,counter:Number.parseInt(i.slice(0,a),10),nodeID:i.slice(a+1)}}static compare(t,e){return t.wallTime!==e.wallTime?t.wallTime-e.wallTime:t.counter!==e.counter?t.counter-e.counter:t.nodeID<e.nodeID?-1:+(t.nodeID>e.nodeID)}}

package/lib/index.d.ts

@@ -2,3 +2,6 @@ export type { DocumentValidator, MutationContext, ValidatorsRecord } from './app
 export { applyChangeMutation, applyMutation, applySetMutation } from './apply.js';
 export type { CreateChangeMutationParams, CreateRemoveMutationParams, CreateSetMutationParams, } from './create.js';
 export { createChangeMutation, createRemoveMutation, createSetMutation } from './create.js';
+export { HLC, type HLCTimestamp } from './hlc.js';
+export type { CreateMutationOperationsParams, GetRandomValues, MutationOperations, } from './operations.js';
+export { convertPatchInput, createMutationOperations } from './operations.js';

package/lib/index.js

@@ -1 +1 @@
-export{applyChangeMutation,applyMutation,applySetMutation}from"./apply.js";export{createChangeMutation,createRemoveMutation,createSetMutation}from"./create.js";
+export{applyChangeMutation,applyMutation,applySetMutation}from"./apply.js";export{createChangeMutation,createRemoveMutation,createSetMutation}from"./create.js";export{HLC}from"./hlc.js";export{convertPatchInput,createMutationOperations}from"./operations.js";

package/lib/operations.d.ts

@@ -0,0 +1,19 @@
+import type { PatchOperation } from '@kubun/graphql';
+import type { ChangeDocumentMutation, DocumentData, SetDocumentMutation } from '@kubun/protocol';
+import type { HLC } from './hlc.js';
+export type GetRandomValues = <T extends ArrayBufferView>(array: T) => T;
+export type CreateMutationOperationsParams<T> = {
+    issuer: string;
+    hlc: HLC;
+    getRandomValues?: GetRandomValues;
+    processSetMutation(mutation: SetDocumentMutation): Promise<T>;
+    processChangeMutation(mutation: ChangeDocumentMutation): Promise<T>;
+};
+export type MutationOperations<T> = {
+    createDocument(modelID: string, data: DocumentData): Promise<T>;
+    setDocument(modelID: string, unique: Uint8Array, data: DocumentData): Promise<T>;
+    updateDocument(docID: string, patch: Array<PatchOperation>): Promise<T>;
+    removeDocument(docID: string): Promise<T>;
+};
+export declare function createMutationOperations<T>(params: CreateMutationOperationsParams<T>): MutationOperations<T>;
+export declare function convertPatchInput(patch: Array<Record<string, unknown>>): Array<PatchOperation>;

package/lib/operations.js

@@ -0,0 +1 @@
+import{createChangeMutation as t,createRemoveMutation as e,createSetMutation as a}from"./create.js";export function createMutationOperations(n){let{issuer:r,hlc:o,processSetMutation:c,processChangeMutation:u}=n,i=n.getRandomValues??globalThis.crypto.getRandomValues.bind(globalThis.crypto);return{async createDocument(t,e){let n=i(new Uint8Array(12)),u=await a({issuer:r,hlc:o,modelID:t,data:e,unique:n});return await c(u)},async setDocument(t,e,n){let u=await a({issuer:r,hlc:o,modelID:t,data:n,unique:e});return await c(u)},async updateDocument(e,a){let n=t({issuer:r,hlc:o,docID:e,patch:a});return await u(n)},async removeDocument(t){let a=e({docID:t,issuer:r,hlc:o});return await u(a)}}}export function convertPatchInput(t){return t.map(t=>{let[e,a]=Object.entries(t)[0];return{...a,op:e}})}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/mutation",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -15,17 +15,14 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@automerge/automerge": "^3.2.3",
-    "@enkaku/async": "^0.13.0",
     "@enkaku/codec": "^0.13.0",
-    "@enkaku/patch": "^0.13.0",
     "@enkaku/schema": "^0.13.0",
-    "@kubun/id": "^0.5.0"
+    "@kubun/id": "^0.6.0"
   },
   "devDependencies": {
-    "@kubun/graphql": "^0.5.0",
-    "@kubun/db": "^0.5.0",
-    "@kubun/protocol": "^0.5.0"
+    "@kubun/db": "^0.6.0",
+    "@kubun/graphql": "^0.6.0",
+    "@kubun/protocol": "^0.6.0"
   },
   "scripts": {
     "build:clean": "del lib",

package/lib/automerge.d.ts

@@ -1,4 +0,0 @@
-import * as A from '@automerge/automerge/slim';
-import type { DocumentData } from '@kubun/protocol';
-export declare const automergeReady: import("@enkaku/async").LazyPromise<void>;
-export declare function automergeToData(doc: A.Doc<DocumentData>): DocumentData;

package/lib/automerge.js

@@ -1 +0,0 @@
-import{automergeWasmBase64 as e}from"@automerge/automerge/automerge.wasm.base64";import*as a from"@automerge/automerge/slim";import{lazy as r}from"@enkaku/async";export const automergeReady=r(()=>a.initializeBase64Wasm(e));export function automergeToData(e){return JSON.parse(JSON.stringify(e))}