@kubun/server 0.1.0

package/lib/handlers/graph.js

@@ -0,0 +1,174 @@
+import { AttachmentID, DocumentID } from '@kubun/id';
+import { GraphModel } from '@kubun/protocol';
+import { Kind, OperationTypeNode, execute, parse } from 'graphql';
+import { fromB64 } from '@enkaku/codec';
+import { ServerSchemaBuilder } from '../data/graphql.js';
+import { applyMutation } from '../data/mutations.js';
+export function createHandlers(handlersParams) {
+    const { db } = handlersParams;
+    const graphModels = {};
+    async function getGraphModels(id) {
+        if (graphModels[id] == null) {
+            graphModels[id] = db.getGraph(id);
+        }
+        return await graphModels[id];
+    }
+    const schemas = {};
+    async function getGraphQLSchema(id) {
+        if (schemas[id] == null) {
+            schemas[id] = getGraphModels(id).then((record)=>{
+                const schema = new ServerSchemaBuilder({
+                    record
+                }).build();
+                // console.log(printSchema(schema))
+                return schema;
+            });
+        }
+        return await schemas[id];
+    }
+    function createContext(contextParams) {
+        async function createDocument(modelID, data) {
+            throw new Error('Not supported');
+        }
+        async function loadDocument(id) {
+            return await db.getDocument(typeof id === 'string' ? DocumentID.fromString(id) : id);
+        }
+        async function listDocuments(params) {
+            const graphModels = await getGraphModels(contextParams.schemaID);
+            const models = new Set();
+            if (params.model === null) {
+                // Match all concrete models
+                for (const [id, model] of Object.entries(graphModels)){
+                    if (model.behavior !== 'interface') {
+                        models.add(id);
+                    }
+                }
+            } else {
+                const matchModel = graphModels[params.model];
+                if (matchModel == null) {
+                    // Model does not exist in graph
+                    return [];
+                }
+                if (matchModel.behavior === 'interface') {
+                    // Match all concrete models for the given interface
+                    for (const [id, model] of Object.entries(graphModels)){
+                        if (model.interfaces.includes(params.model)) {
+                            models.add(id);
+                        }
+                    }
+                } else {
+                    // Matches a concrete model
+                    models.add(params.model);
+                }
+            }
+            return await db.listDocuments({
+                modelIDs: Array.from(models),
+                docIDS: params.ids
+            });
+        }
+        // TODO: access control filtering
+        async function queryDocuments(params) {
+            const { entries, hasMore } = await db.queryDocuments(params);
+            return {
+                edges: entries.map((e)=>({
+                        cursor: e.cursor,
+                        node: e.document
+                    })),
+                pageInfo: {
+                    hasNextPage: params.first ? hasMore : false,
+                    hasPreviousPage: params.first ? false : hasMore,
+                    endCursor: entries.at(-1)?.cursor ?? null,
+                    startCursor: entries.at(0)?.cursor ?? null
+                }
+            };
+        }
+        return {
+            createDocument,
+            listDocuments,
+            loadDocument,
+            queryDocuments,
+            mutatedDocuments: contextParams.mutatedDocuments,
+            viewerDID: contextParams.viewerDID ?? null
+        };
+    }
+    async function executeGraphQL(params) {
+        const schema = await getGraphQLSchema(params.schemaID);
+        const document = parse(params.text);
+        const definition = document.definitions[0];
+        if (definition == null) {
+            throw new Error('Missing GraphQL document definition');
+        }
+        // Ensure the operation matching the expected type
+        if (definition.kind !== Kind.OPERATION_DEFINITION || definition.operation !== params.type) {
+            throw new Error(`Invalid GraphQL document definition: expected ${params.type} operation`);
+        }
+        const executionResult = await execute({
+            document,
+            schema,
+            variableValues: params.variables,
+            contextValue: createContext(params)
+        });
+        return {
+            data: executionResult.data,
+            errors: executionResult.errors?.map((err)=>err.toJSON()),
+            extensions: executionResult.extensions
+        };
+    }
+    return {
+        'graph/create': async (ctx)=>{
+            const model = GraphModel.fromClusters({
+                clusters: ctx.params.clusters
+            });
+            const id = await db.createGraph({
+                name: ctx.params.name,
+                record: model.record
+            });
+            return {
+                id,
+                models: model.record
+            };
+        },
+        'graph/load': async (ctx)=>{
+            return {
+                models: await getGraphModels(ctx.params.id)
+            };
+        },
+        'graph/query': async (ctx)=>{
+            // TODO(enkaku): request should be JWT:
+            // schema ID is token subject
+            // viewer ID is token audience or fallback to the issuer
+            // also add token capabilities check
+            return await executeGraphQL({
+                type: OperationTypeNode.QUERY,
+                schemaID: ctx.params.id,
+                text: ctx.params.text,
+                variables: ctx.params.variables
+            });
+        },
+        'graph/mutate': async (ctx)=>{
+            const attachments = Object.entries(ctx.params.attachments ?? {}).map(([key, value])=>{
+                const aid = AttachmentID.fromString(key);
+                return {
+                    id: aid.cid.toString(),
+                    data: fromB64(value)
+                };
+            });
+            if (attachments.length !== 0) {
+                await db.addAttachments(attachments);
+            }
+            // Apply mutations and make the documents available to the GraphQL resolvers in the context
+            const mutatedDocuments = {};
+            await Promise.all(Object.entries(ctx.params.mutations).map(async ([key, mutation])=>{
+                mutatedDocuments[key] = await applyMutation(db, mutation);
+            }));
+            return await executeGraphQL({
+                type: OperationTypeNode.MUTATION,
+                schemaID: ctx.params.id,
+                text: ctx.params.text,
+                variables: ctx.params.variables,
+                // viewerDID: input.invocation.issuer.did(),
+                mutatedDocuments
+            });
+        }
+    };
+}

package/lib/handlers/index.d.ts

@@ -0,0 +1,9 @@
+import type { CommandHandlers } from '@enkaku/server';
+import type { GraphCommands } from '@kubun/protocol';
+import type { KubunDB } from '../data/db.js';
+export type CreateHandlersParams = {
+    db: KubunDB;
+};
+export type Handlers = CommandHandlers<GraphCommands>;
+export declare function createHandlers(params: CreateHandlersParams): Handlers;
+//# sourceMappingURL=index.d.ts.map

package/lib/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/handlers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAI5C,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,eAAe,CAAC,aAAa,CAAC,CAAA;AAErD,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,QAAQ,CAErE"}

package/lib/handlers/index.js

@@ -0,0 +1,4 @@
+import { createHandlers as graphHandlers } from './graph.js';
+export function createHandlers(params) {
+    return graphHandlers(params);
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { KubunDB, type KubunDBParams } from './data/db.js';
+export { KubunServer, type ServerParams } from './server.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAA"}

package/lib/index.js

@@ -0,0 +1,2 @@
+export { KubunDB } from './data/db.js';
+export { KubunServer } from './server.js';

package/lib/server.d.ts

@@ -0,0 +1,18 @@
+import type { Signer } from '@enkaku/jwt';
+import { type Server } from '@enkaku/server';
+import { KubunClient } from '@kubun/client';
+import type { ServerTransport } from '@kubun/protocol';
+import { KubunDB, type KubunDBParams } from './data/db.js';
+export type ServerParams = {
+    db: KubunDB | KubunDBParams;
+    signer: Signer;
+};
+export declare class KubunServer {
+    #private;
+    constructor(params: ServerParams);
+    get client(): KubunClient;
+    get db(): KubunDB;
+    createClient(signer: Signer, signal?: AbortSignal): KubunClient;
+    serve(transport: ServerTransport, signal?: AbortSignal): Server;
+}
+//# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EAAE,KAAK,MAAM,EAAS,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,KAAK,EAAgC,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEpF,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAG1D,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,OAAO,GAAG,aAAa,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,qBAAa,WAAW;;gBAMV,MAAM,EAAE,YAAY;IAOhC,IAAI,MAAM,IAAI,WAAW,CAKxB;IAED,IAAI,EAAE,IAAI,OAAO,CAEhB;IAED,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW;IAM/D,KAAK,CAAC,SAAS,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM;CAGhE"}

package/lib/server.js

@@ -0,0 +1,45 @@
+import { serve } from '@enkaku/server';
+import { createDirectTransports } from '@enkaku/transport';
+import { KubunClient } from '@kubun/client';
+import { KubunDB } from './data/db.js';
+import { createHandlers } from './handlers/index.js';
+export class KubunServer {
+    #client;
+    #db;
+    #handlers;
+    #signer;
+    constructor(params){
+        const { db, signer } = params;
+        this.#db = db instanceof KubunDB ? db : new KubunDB(db);
+        this.#handlers = createHandlers({
+            db: this.#db
+        });
+        this.#signer = signer;
+    }
+    get client() {
+        if (this.#client == null) {
+            this.#client = this.createClient(this.#signer);
+        }
+        return this.#client;
+    }
+    get db() {
+        return this.#db;
+    }
+    createClient(signer, signal) {
+        const transports = createDirectTransports({
+            signal
+        });
+        this.serve(transports.server, signal);
+        return new KubunClient({
+            signer,
+            transport: transports.client
+        });
+    }
+    serve(transport, signal) {
+        return serve({
+            handlers: this.#handlers,
+            signal,
+            transport
+        });
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@kubun/server",
+  "version": "0.1.0",
+  "license": "see LICENSE.md",
+  "keywords": [],
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/*",
+    "LICENSE.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@automerge/automerge": "^2.2.8",
+    "@enkaku/codec": "^0.2.0",
+    "@enkaku/jwt": "^0.2.3",
+    "@enkaku/schema": "^0.2.0",
+    "@enkaku/server": "^0.2.1",
+    "@enkaku/transport": "^0.2.0",
+    "better-sqlite3": "^11.4.0",
+    "graphql": "^16.9.0",
+    "graphql-relay": "^0.10.2",
+    "kysely": "^0.27.4",
+    "pg": "^8.13.0",
+    "@kubun/client": "^0.1.0",
+    "@kubun/id": "^0.1.0",
+    "@kubun/protocol": "^0.1.0",
+    "@kubun/graphql": "^0.1.0"
+  },
+  "devDependencies": {
+    "@databases/pg-test": "^3.1.2",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/pg": "^8.11.10"
+  },
+  "scripts": {
+    "build:clean": "del lib",
+    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test:types": "tsc --noEmit --skipLibCheck",
+    "test:unit": "node --experimental-vm-modules ../../node_modules/jest/bin/jest.js",
+    "test": "pnpm run test:types && pnpm run test:unit"
+  }
+}