@constructive-sdk/cli 1.20.1 → 1.20.3

package/esm/objects/orm/mutation/index.d.ts

@@ -6,26 +6,36 @@
 import { OrmClient } from '../client';
 import { QueryBuilder } from '../query-builder';
 import type { InferSelectResult, StrictSelect } from '../select-types';
-import type { InitEmptyRepoInput, InsertNodeAtPathInput, ProvisionBucketInput, SetDataAtPathInput, InitEmptyRepoPayload, InsertNodeAtPathPayload, ProvisionBucketPayload, SetDataAtPathPayload, InitEmptyRepoPayloadSelect, InsertNodeAtPathPayloadSelect, ProvisionBucketPayloadSelect, SetDataAtPathPayloadSelect } from '../input-types';
+import type { InitEmptyRepoInput, InsertNodeAtPathInput, InsertNodesAtPathsInput, ProvisionBucketInput, SetAndCommitInput, SetDataAtPathInput, SetManyAndCommitInput, InitEmptyRepoPayload, InsertNodeAtPathPayload, InsertNodesAtPathsPayload, ProvisionBucketPayload, SetAndCommitPayload, SetDataAtPathPayload, SetManyAndCommitPayload, InitEmptyRepoPayloadSelect, InsertNodeAtPathPayloadSelect, InsertNodesAtPathsPayloadSelect, ProvisionBucketPayloadSelect, SetAndCommitPayloadSelect, SetDataAtPathPayloadSelect, SetManyAndCommitPayloadSelect } from '../input-types';
 export interface InitEmptyRepoVariables {
     input: InitEmptyRepoInput;
 }
 export interface InsertNodeAtPathVariables {
     input: InsertNodeAtPathInput;
 }
+export interface InsertNodesAtPathsVariables {
+    input: InsertNodesAtPathsInput;
+}
 /**
  * Variables for provisionBucket
- * Provision an S3 bucket for a logical bucket in the database.
-Reads the bucket config via RLS, then creates and configures
-the S3 bucket with the appropriate privacy policies, CORS rules,
-and lifecycle settings.
+ * Reconcile an S3 bucket for a logical bucket in the database.
+Reads the bucket config via RLS, then enqueues the same
+storage:provision_bucket job used by the INSERT trigger. This is
+idempotent for an already-reconciled bucket; enqueue failures become
+GraphQL errors.
  */
 export interface ProvisionBucketVariables {
     input: ProvisionBucketInput;
 }
+export interface SetAndCommitVariables {
+    input: SetAndCommitInput;
+}
 export interface SetDataAtPathVariables {
     input: SetDataAtPathInput;
 }
+export interface SetManyAndCommitVariables {
+    input: SetManyAndCommitInput;
+}
 export declare function createMutationOperations(client: OrmClient): {
     initEmptyRepo: <S extends InitEmptyRepoPayloadSelect>(args: InitEmptyRepoVariables, options: {
         select: S;
@@ -37,14 +47,29 @@ export declare function createMutationOperations(client: OrmClient): {
     } & StrictSelect<S, InsertNodeAtPathPayloadSelect>) => QueryBuilder<{
         insertNodeAtPath: InferSelectResult<InsertNodeAtPathPayload, S> | null;
     }>;
+    insertNodesAtPaths: <S extends InsertNodesAtPathsPayloadSelect>(args: InsertNodesAtPathsVariables, options: {
+        select: S;
+    } & StrictSelect<S, InsertNodesAtPathsPayloadSelect>) => QueryBuilder<{
+        insertNodesAtPaths: InferSelectResult<InsertNodesAtPathsPayload, S> | null;
+    }>;
     provisionBucket: <S extends ProvisionBucketPayloadSelect>(args: ProvisionBucketVariables, options: {
         select: S;
     } & StrictSelect<S, ProvisionBucketPayloadSelect>) => QueryBuilder<{
         provisionBucket: InferSelectResult<ProvisionBucketPayload, S> | null;
     }>;
+    setAndCommit: <S extends SetAndCommitPayloadSelect>(args: SetAndCommitVariables, options: {
+        select: S;
+    } & StrictSelect<S, SetAndCommitPayloadSelect>) => QueryBuilder<{
+        setAndCommit: InferSelectResult<SetAndCommitPayload, S> | null;
+    }>;
     setDataAtPath: <S extends SetDataAtPathPayloadSelect>(args: SetDataAtPathVariables, options: {
         select: S;
     } & StrictSelect<S, SetDataAtPathPayloadSelect>) => QueryBuilder<{
         setDataAtPath: InferSelectResult<SetDataAtPathPayload, S> | null;
     }>;
+    setManyAndCommit: <S extends SetManyAndCommitPayloadSelect>(args: SetManyAndCommitVariables, options: {
+        select: S;
+    } & StrictSelect<S, SetManyAndCommitPayloadSelect>) => QueryBuilder<{
+        setManyAndCommit: InferSelectResult<SetManyAndCommitPayload, S> | null;
+    }>;
 };

package/esm/objects/orm/mutation/index.js

@@ -26,6 +26,18 @@ export function createMutationOperations(client) {
                 },
             ], connectionFieldsMap, 'InsertNodeAtPathPayload'),
         }),
+        insertNodesAtPaths: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'InsertNodesAtPaths',
+            fieldName: 'insertNodesAtPaths',
+            ...buildCustomDocument('mutation', 'InsertNodesAtPaths', 'insertNodesAtPaths', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'InsertNodesAtPathsInput!',
+                },
+            ], connectionFieldsMap, 'InsertNodesAtPathsPayload'),
+        }),
         provisionBucket: (args, options) => new QueryBuilder({
             client,
             operation: 'mutation',
@@ -38,6 +50,18 @@ export function createMutationOperations(client) {
                 },
             ], connectionFieldsMap, 'ProvisionBucketPayload'),
         }),
+        setAndCommit: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SetAndCommit',
+            fieldName: 'setAndCommit',
+            ...buildCustomDocument('mutation', 'SetAndCommit', 'setAndCommit', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SetAndCommitInput!',
+                },
+            ], connectionFieldsMap, 'SetAndCommitPayload'),
+        }),
         setDataAtPath: (args, options) => new QueryBuilder({
             client,
             operation: 'mutation',
@@ -50,5 +74,17 @@ export function createMutationOperations(client) {
                 },
             ], connectionFieldsMap, 'SetDataAtPathPayload'),
         }),
+        setManyAndCommit: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'SetManyAndCommit',
+            fieldName: 'setManyAndCommit',
+            ...buildCustomDocument('mutation', 'SetManyAndCommit', 'setManyAndCommit', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'SetManyAndCommitInput!',
+                },
+            ], connectionFieldsMap, 'SetManyAndCommitPayload'),
+        }),
     };
 }

package/esm/remote/cli/commands/auth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Authentication commands
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, unknown>>, prompter: Inquirerer, _options: CLIOptions) => Promise<void>;
+export default _default;

package/esm/remote/cli/commands/auth.js

@@ -0,0 +1,105 @@
+/**
+ * Authentication commands
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { extractFirst } from 'inquirerer';
+import { getStore } from '../executor';
+const usage = '\ncsdk auth <command>\n\nCommands:\n  set-token <token>     Set API token for the current context\n  status                Show authentication status\n  logout                Remove credentials for the current context\n\nOptions:\n  --context <name>      Specify context (defaults to current context)\n\n  --help, -h            Show this help message\n';
+export default async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(usage);
+        process.exit(0);
+    }
+    const store = getStore();
+    const { first: subcommand, newArgv } = extractFirst(argv);
+    if (!subcommand) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'subcommand',
+                message: 'What do you want to do?',
+                options: ['set-token', 'status', 'logout'],
+            },
+        ]);
+        return handleAuthSubcommand(answer.subcommand, newArgv, prompter, store);
+    }
+    return handleAuthSubcommand(subcommand, newArgv, prompter, store);
+};
+async function handleAuthSubcommand(subcommand, argv, prompter, store) {
+    switch (subcommand) {
+        case 'set-token':
+            return handleSetToken(argv, prompter, store);
+        case 'status':
+            return handleStatus(store);
+        case 'logout':
+            return handleLogout(argv, prompter, store);
+        default:
+            console.log(usage);
+            process.exit(1);
+    }
+}
+async function handleSetToken(argv, prompter, store) {
+    const current = store.getCurrentContext();
+    if (!current) {
+        console.error('No active context. Run "context create" first.');
+        process.exit(1);
+    }
+    const { first: token } = extractFirst(argv);
+    let tokenValue = token;
+    if (!tokenValue) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'password',
+                name: 'token',
+                message: 'API Token',
+                required: true,
+            },
+        ]);
+        tokenValue = answer.token;
+    }
+    store.setCredentials(current.name, {
+        token: String(tokenValue || '').trim(),
+    });
+    console.log(`Token saved for context: ${current.name}`);
+}
+function handleStatus(store) {
+    const contexts = store.listContexts();
+    const settings = store.loadSettings();
+    if (contexts.length === 0) {
+        console.log('No contexts configured.');
+        return;
+    }
+    console.log('Authentication Status:');
+    for (const ctx of contexts) {
+        const isCurrent = ctx.name === settings.currentContext;
+        const hasAuth = store.hasValidCredentials(ctx.name);
+        const marker = isCurrent ? '* ' : '  ';
+        const status = hasAuth ? 'authenticated' : 'no token';
+        console.log(`${marker}${ctx.name} [${status}]`);
+    }
+}
+async function handleLogout(argv, prompter, store) {
+    const current = store.getCurrentContext();
+    if (!current) {
+        console.log('No active context.');
+        return;
+    }
+    const confirm = await prompter.prompt(argv, [
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remove credentials for "${current.name}"?`,
+            default: false,
+        },
+    ]);
+    if (!confirm.confirm) {
+        return;
+    }
+    if (store.removeCredentials(current.name)) {
+        console.log(`Credentials removed for: ${current.name}`);
+    }
+    else {
+        console.log(`No credentials found for: ${current.name}`);
+    }
+}

package/esm/remote/cli/commands/context.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Context management commands
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, unknown>>, prompter: Inquirerer, _options: CLIOptions) => Promise<void>;
+export default _default;

package/esm/remote/cli/commands/context.js

@@ -0,0 +1,156 @@
+/**
+ * Context management commands
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { extractFirst } from 'inquirerer';
+import { getStore } from '../executor';
+const usage = '\ncsdk context <command>\n\nCommands:\n  create <name>         Create a new context\n  list                  List all contexts\n  use <name>            Set the active context\n  current               Show current context\n  delete <name>         Delete a context\n\nCreate Options:\n  --endpoint <url>      GraphQL endpoint URL\n\n  --help, -h            Show this help message\n';
+export default async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(usage);
+        process.exit(0);
+    }
+    const store = getStore();
+    const { first: subcommand, newArgv } = extractFirst(argv);
+    if (!subcommand) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'subcommand',
+                message: 'What do you want to do?',
+                options: ['create', 'list', 'use', 'current', 'delete'],
+            },
+        ]);
+        return handleSubcommand(answer.subcommand, newArgv, prompter, store);
+    }
+    return handleSubcommand(subcommand, newArgv, prompter, store);
+};
+async function handleSubcommand(subcommand, argv, prompter, store) {
+    switch (subcommand) {
+        case 'create':
+            return handleCreate(argv, prompter, store);
+        case 'list':
+            return handleList(store);
+        case 'use':
+            return handleUse(argv, prompter, store);
+        case 'current':
+            return handleCurrent(store);
+        case 'delete':
+            return handleDelete(argv, prompter, store);
+        default:
+            console.log(usage);
+            process.exit(1);
+    }
+}
+async function handleCreate(argv, prompter, store) {
+    const { first: name, newArgv: restArgv } = extractFirst(argv);
+    const answers = (await prompter.prompt({
+        name,
+        ...restArgv,
+    }, [
+        {
+            type: 'text',
+            name: 'name',
+            message: 'Context name',
+            required: true,
+        },
+        {
+            type: 'text',
+            name: 'endpoint',
+            message: 'GraphQL endpoint URL',
+            required: true,
+        },
+    ]));
+    const contextName = answers.name;
+    const endpoint = answers.endpoint;
+    store.createContext(contextName, {
+        endpoint: endpoint,
+    });
+    const settings = store.loadSettings();
+    if (!settings.currentContext) {
+        store.setCurrentContext(contextName);
+    }
+    console.log(`Created context: ${contextName}`);
+    console.log(`  Endpoint: ${endpoint}`);
+}
+function handleList(store) {
+    const contexts = store.listContexts();
+    const settings = store.loadSettings();
+    if (contexts.length === 0) {
+        console.log('No contexts configured.');
+        return;
+    }
+    console.log('Contexts:');
+    for (const ctx of contexts) {
+        const marker = ctx.name === settings.currentContext ? '* ' : '  ';
+        const authStatus = store.hasValidCredentials(ctx.name) ? '[authenticated]' : '[no token]';
+        console.log(`${marker}${ctx.name} ${authStatus}`);
+        console.log(`    Endpoint: ${ctx.endpoint}`);
+    }
+}
+async function handleUse(argv, prompter, store) {
+    const { first: name } = extractFirst(argv);
+    const contexts = store.listContexts();
+    if (contexts.length === 0) {
+        console.log('No contexts configured.');
+        return;
+    }
+    let contextName = name;
+    if (!contextName) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'name',
+                message: 'Select context',
+                options: contexts.map((c) => c.name),
+            },
+        ]);
+        contextName = answer.name;
+    }
+    if (store.setCurrentContext(contextName)) {
+        console.log(`Switched to context: ${contextName}`);
+    }
+    else {
+        console.error(`Context "${contextName}" not found.`);
+        process.exit(1);
+    }
+}
+function handleCurrent(store) {
+    const current = store.getCurrentContext();
+    if (!current) {
+        console.log('No current context set.');
+        return;
+    }
+    console.log(`Current context: ${current.name}`);
+    console.log(`  Endpoint: ${current.endpoint}`);
+    const hasAuth = store.hasValidCredentials(current.name);
+    console.log(`  Auth: ${hasAuth ? 'authenticated' : 'not authenticated'}`);
+}
+async function handleDelete(argv, prompter, store) {
+    const { first: name } = extractFirst(argv);
+    const contexts = store.listContexts();
+    if (contexts.length === 0) {
+        console.log('No contexts configured.');
+        return;
+    }
+    let contextName = name;
+    if (!contextName) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'name',
+                message: 'Select context to delete',
+                options: contexts.map((c) => c.name),
+            },
+        ]);
+        contextName = answer.name;
+    }
+    if (store.deleteContext(contextName)) {
+        console.log(`Deleted context: ${contextName}`);
+    }
+    else {
+        console.error(`Context "${contextName}" not found.`);
+        process.exit(1);
+    }
+}

package/esm/remote/cli/commands/machine-message.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI commands for MachineMessage
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, unknown>>, prompter: Inquirerer, _options: CLIOptions) => Promise<void>;
+export default _default;