kubun 0.2.0

package/dist/commands/graph/deploy.js

@@ -0,0 +1,32 @@
+import { Command, Flags } from '@oclif/core';
+import ora from 'ora';
+import { createClient } from '../../client.js';
+import { readJSON } from '../../fs.js';
+export default class DeployGraph extends Command {
+    static description = 'Deploy a documents model graph';
+    static flags = {
+        cluster: Flags.string({
+            description: 'path of the JSON file of the cluster',
+            char: 'c',
+            required: true,
+            multiple: true,
+        }),
+        id: Flags.string({ description: 'graph ID' }),
+        name: Flags.string({ description: 'graph name', char: 'n' }),
+        privateKey: Flags.string({
+            description: 'base64-encoded private key',
+            char: 'k',
+            env: 'KUBUN_PRIVATE_KEY',
+            required: true,
+        }),
+        url: Flags.string({ description: 'Kubun server URL' }),
+    };
+    async run() {
+        const spinner = ora('Deploying graph clusters...').start();
+        const { flags } = await this.parse(DeployGraph);
+        const client = createClient(flags.privateKey, flags.url);
+        const clusters = await Promise.all(flags.cluster.map((path) => readJSON(path)));
+        const graph = await client.deployGraph({ clusters, id: flags.id, name: flags.name });
+        spinner.succeed(`Deployed graph with ID: ${graph.id}`);
+    }
+}

package/dist/commands/graph/mutate.js

@@ -0,0 +1,32 @@
+import { Args, Command, Flags } from '@oclif/core';
+import ora from 'ora';
+import { createClient } from '../../client.js';
+export default class MutateGraph extends Command {
+    static description = 'Execute a GraphQL mutation on a graph';
+    static args = {
+        id: Args.string({ description: 'graph ID', required: true }),
+        text: Args.string({ description: 'mutation text', required: true }),
+    };
+    static flags = {
+        privateKey: Flags.string({
+            description: 'base64-encoded private key',
+            char: 'k',
+            env: 'KUBUN_PRIVATE_KEY',
+            required: true,
+        }),
+        url: Flags.string({ description: 'Kubun server URL' }),
+        variables: Flags.string({ description: 'query variables as JSON string' }),
+    };
+    async run() {
+        const spinner = ora('Executing graph mutation...').start();
+        const { args, flags } = await this.parse(MutateGraph);
+        const client = createClient(flags.privateKey, flags.url);
+        const result = await client.mutateGraph({
+            id: args.id,
+            text: args.text,
+            variables: flags.variables ? JSON.parse(flags.variables) : {},
+        });
+        spinner.succeed('Graph mutation executed');
+        this.log(JSON.stringify(result, null, 2));
+    }
+}

package/dist/commands/graph/query.js

@@ -0,0 +1,32 @@
+import { Args, Command, Flags } from '@oclif/core';
+import ora from 'ora';
+import { createClient } from '../../client.js';
+export default class QueryGraph extends Command {
+    static description = 'Execute a GraphQL query on a graph';
+    static args = {
+        id: Args.string({ description: 'graph ID', required: true }),
+        text: Args.string({ description: 'query text', required: true }),
+    };
+    static flags = {
+        privateKey: Flags.string({
+            description: 'base64-encoded private key',
+            char: 'k',
+            env: 'KUBUN_PRIVATE_KEY',
+            required: true,
+        }),
+        url: Flags.string({ description: 'Kubun server URL' }),
+        variables: Flags.string({ description: 'query variables as JSON string' }),
+    };
+    async run() {
+        const spinner = ora('Querying graph...').start();
+        const { args, flags } = await this.parse(QueryGraph);
+        const client = createClient(flags.privateKey, flags.url);
+        const result = await client.queryGraph({
+            id: args.id,
+            text: args.text,
+            variables: flags.variables ? JSON.parse(flags.variables) : {},
+        });
+        spinner.succeed('Graph query executed');
+        this.log(JSON.stringify(result, null, 2));
+    }
+}

package/dist/commands/graphql/schema.js

@@ -0,0 +1,46 @@
+import { ClientSchemaBuilder } from '@kubun/client';
+import { GraphModel } from '@kubun/protocol';
+import { Command, Flags } from '@oclif/core';
+import { printSchema } from 'graphql';
+import ora from 'ora';
+import { readJSON, writeFile } from '../../fs.js';
+export default class CreateGraphQLSchema extends Command {
+    static description = 'Create a GraphQL schema from clusters of document models';
+    static flags = {
+        cluster: Flags.string({
+            description: 'path of the JSON file of the cluster',
+            char: 'c',
+            required: true,
+            multiple: true,
+        }),
+        output: Flags.file({
+            description: 'output file for the GraphQL schema',
+            char: 'o',
+        }),
+        // id: Flags.string({ description: 'graph ID' }),
+        // privateKey: Flags.string({
+        //   description: 'base64-encoded private key',
+        //   char: 'k',
+        //   env: 'KUBUN_PRIVATE_KEY',
+        //   required: true,
+        // }),
+        // url: Flags.string({ description: 'Kubun server URL' }),
+    };
+    async run() {
+        const spinner = ora('Loading clusters...').start();
+        const { flags } = await this.parse(CreateGraphQLSchema);
+        const clusters = await Promise.all(flags.cluster.map((path) => readJSON(path)));
+        const model = await GraphModel.fromClusters({ clusters });
+        const builder = new ClientSchemaBuilder({ record: model.record });
+        const schema = printSchema(builder.build());
+        if (flags.output == null) {
+            spinner.succeed('GraphQL schema generated');
+            this.log(schema);
+        }
+        else {
+            await writeFile(flags.output, schema);
+            spinner.succeed(`GraphQL schema written to ${flags.output}`);
+        }
+        return schema;
+    }
+}

package/dist/commands/hello/index.js

@@ -0,0 +1,19 @@
+import { Args, Command, Flags } from '@oclif/core';
+export default class Hello extends Command {
+    static args = {
+        person: Args.string({ description: 'Person to say hello to', required: true }),
+    };
+    static description = 'Say hello';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> friend --from oclif
+hello friend from oclif! (./src/commands/hello/index.ts)
+`,
+    ];
+    static flags = {
+        from: Flags.string({ char: 'f', description: 'Who is saying hello', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Hello);
+        this.log(`hello ${args.person} from ${flags.from}! (./src/commands/hello/index.ts)`);
+    }
+}

package/dist/commands/hello/world.js

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class World extends Command {
+    static description = 'Say hello world';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>
+hello world! (./src/commands/hello/world.ts)
+`,
+    ];
+    async run() {
+        this.log('hello world! (./src/commands/hello/world.ts)');
+    }
+}

package/dist/commands/model/cluster.js

@@ -0,0 +1,35 @@
+import { ClusterBuilder } from '@kubun/protocol';
+import { Command, Flags } from '@oclif/core';
+import ora from 'ora';
+import { writeJSON } from '../../fs.js';
+export default class CreateClusterModel extends Command {
+    static description = 'Create a documents cluster model';
+    static flags = {
+        model: Flags.string({
+            description: 'document model as JSON string',
+            char: 'm',
+            multiple: true,
+            required: true,
+        }),
+        output: Flags.file({
+            description: 'output file for the cluster',
+            char: 'o',
+        }),
+    };
+    async run() {
+        const spinner = ora('Creating cluster model...').start();
+        const { flags } = await this.parse(CreateClusterModel);
+        const builder = new ClusterBuilder();
+        builder.addAll(flags.model.map((model) => JSON.parse(model)));
+        const cluster = builder.build();
+        if (flags.output == null) {
+            spinner.succeed('Cluster model created');
+            this.log(JSON.stringify(cluster));
+        }
+        else {
+            await writeJSON(flags.output, cluster);
+            spinner.succeed(`Cluster model written to ${flags.output}`);
+        }
+        return cluster;
+    }
+}

package/dist/commands/model/create.js

@@ -0,0 +1,69 @@
+import { ClusterBuilder, } from '@kubun/protocol';
+import { Args, Command, Flags } from '@oclif/core';
+import ora from 'ora';
+import { writeJSON } from '../../fs.js';
+export default class CreateDocumentModel extends Command {
+    static description = 'Create a document model';
+    static args = {
+        name: Args.string({ description: 'document model name', required: true }),
+        schema: Args.string({ description: 'document schema as JSON string', required: true }),
+    };
+    static flags = {
+        behavior: Flags.string({
+            description: 'behavior of the document',
+            char: 'b',
+            options: ['default', 'interface', 'unique'],
+            default: 'default',
+        }),
+        cluster: Flags.boolean({
+            description: 'create a cluster model instead of a document model',
+            char: 'c',
+        }),
+        output: Flags.file({
+            description: 'output file',
+            char: 'o',
+        }),
+        uniqueField: Flags.string({
+            description: 'unique field of the document when behavior is set to "unique"',
+            char: 'u',
+            multiple: true,
+        }),
+    };
+    async run() {
+        const spinner = ora('Creating document model...').start();
+        const { args, flags } = await this.parse(CreateDocumentModel);
+        const behavior = flags.behavior;
+        const model = {
+            name: args.name,
+            behavior,
+            schema: JSON.parse(args.schema),
+        };
+        if (behavior === 'unique') {
+            model.uniqueFields = flags.uniqueField;
+        }
+        const builder = new ClusterBuilder();
+        builder.add(model);
+        if (flags.cluster) {
+            const cluster = builder.build();
+            if (flags.output == null) {
+                spinner.succeed('Cluster model created');
+                this.log(JSON.stringify(cluster));
+            }
+            else {
+                await writeJSON(flags.output, cluster);
+                spinner.succeed(`Cluster model written to ${flags.output}`);
+            }
+            return cluster;
+        }
+        const document = builder.cluster[0];
+        if (flags.output == null) {
+            spinner.succeed('Document model created');
+            this.log(JSON.stringify(document));
+        }
+        else {
+            await writeJSON(flags.output, document);
+            spinner.succeed(`Document model written to ${flags.output}`);
+        }
+        return document;
+    }
+}

package/dist/commands/serve.js

@@ -0,0 +1,78 @@
+import { defer } from '@enkaku/async';
+import { toB64 } from '@enkaku/codec';
+import { ServerTransport } from '@enkaku/http-server-transport';
+import { serve } from '@enkaku/server';
+import { randomSigner, toTokenSigner } from '@enkaku/token';
+import { serve as serveHTTP } from '@hono/node-server';
+import { KubunDB } from '@kubun/db';
+import { PostgresAdapter } from '@kubun/db-postgres';
+import { SQLiteAdapter } from '@kubun/db-sqlite';
+import { createHandlers } from '@kubun/server';
+import { Command, Flags } from '@oclif/core';
+import getPort from 'get-port';
+import ora from 'ora';
+import { getSigner } from '../account.js';
+import { resolvePath } from '../fs.js';
+export default class Serve extends Command {
+    static description = 'Start a local Kubun server';
+    static flags = {
+        db: Flags.file({ description: 'path to the local SQLite database' }),
+        id: Flags.string({ description: 'server ID' }),
+        port: Flags.integer({ char: 'p', description: 'port to listen on' }),
+        privateKey: Flags.string({
+            char: 'k',
+            description: 'base64-encoded private key',
+            env: 'KUBUN_PRIVATE_KEY',
+            exclusive: ['id'],
+        }),
+    };
+    async run() {
+        let signer;
+        const spinner = ora();
+        const { flags } = await this.parse(Serve);
+        let id = flags.id;
+        if (id == null) {
+            if (flags.privateKey == null) {
+                spinner.info('Generating a random private key for the server').start();
+                const ownSigner = randomSigner();
+                spinner.warn(`Generated private key: ${toB64(ownSigner.privateKey)}`);
+                signer = toTokenSigner(ownSigner);
+            }
+            else {
+                spinner.info('Using the provided private key for the server').start();
+                signer = getSigner(flags.privateKey);
+            }
+            id = signer.id;
+        }
+        spinner.info(`Server DID: ${id}`);
+        let db;
+        if (flags.db == null) {
+            db = new KubunDB({ adapter: new SQLiteAdapter({ database: ':memory:' }) });
+            spinner.info('Using ephemeral (in memory) SQLite database');
+        }
+        else if (flags.db.startsWith('postgres://')) {
+            db = new KubunDB({ adapter: new PostgresAdapter({ url: flags.db }) });
+            spinner.info(`Using PostgreSQL database: ${flags.db}`);
+        }
+        else {
+            const database = resolvePath(flags.db);
+            db = new KubunDB({ adapter: new SQLiteAdapter({ database }) });
+            spinner.info(`Using local SQLite database: ${database}`);
+        }
+        const transport = new ServerTransport();
+        serve({ handlers: createHandlers({ db }), id, transport });
+        spinner.start('Starting the server');
+        const port = flags.port ?? (await getPort({ port: 4321 }));
+        const httpServer = serveHTTP({ fetch: transport.fetch, port }, (info) => {
+            spinner.succeed(`HTTP server listening on port ${info.port}`);
+        });
+        const stopped = defer();
+        async function stop() {
+            httpServer.close();
+            stopped.resolve();
+        }
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+        return stopped.promise;
+    }
+}

package/dist/fs.js

@@ -0,0 +1,14 @@
+import { readFile as read, writeFile as write } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+export function resolvePath(value) {
+    return isAbsolute(value) ? value : resolve(process.cwd(), value);
+}
+export async function readJSON(path) {
+    return JSON.parse(await read(resolvePath(path), { encoding: 'utf8' }));
+}
+export async function writeFile(path, value) {
+    await write(resolvePath(path), value, { encoding: 'utf8' });
+}
+export async function writeJSON(path, value, format = false) {
+    await writeFile(path, format ? JSON.stringify(value, null, 2) : JSON.stringify(value));
+}

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';