@ductape/cli 0.3.19 → 0.3.21

package/dist/commands/component-actions.d.ts

@@ -0,0 +1,8 @@
+export type ComponentActionKind = 'graph' | 'vector';
+export type ComponentActionVerb = 'create' | 'update' | 'get' | 'list' | 'delete' | 'execute';
+export declare function runComponentActions(kind: ComponentActionKind, verb: ComponentActionVerb, opts: {
+    resource?: string;
+    action?: string;
+    file?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/component-actions.js

@@ -0,0 +1,45 @@
+import { readJsonBody } from '../lib/read-body.js';
+import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
+import { printJson } from '../lib/output.js';
+export async function runComponentActions(kind, verb, opts) {
+    const session = requireSession();
+    const body = readJsonBody(opts.file) ?? {};
+    const resourceKey = kind === 'graph' ? 'graph' : 'vector';
+    const resource = opts.resource ?? String(body[resourceKey] ?? body[`${resourceKey}Tag`] ?? '');
+    const action = opts.action ?? String(body.actionTag ?? body.action ?? '');
+    const base = { product: session.project.product_tag, ...body };
+    let method;
+    let params;
+    if (verb === 'create') {
+        if (!opts.file)
+            throw new Error(`${kind} actions create requires --action-file <file.json>`);
+        method = kind === 'graph' ? 'action.create' : 'actions.create';
+        params = [base];
+    }
+    else if (verb === 'update') {
+        if (!opts.file)
+            throw new Error(`${kind} actions update requires --action-file <file.json>`);
+        method = kind === 'graph' ? 'action.update' : 'actions.update';
+        params = [base];
+    }
+    else if (verb === 'list') {
+        if (!resource)
+            throw new Error(`${kind} actions list requires --${kind} <tag>`);
+        method = kind === 'graph' ? 'action.fetchAll' : 'actions.fetchAll';
+        params = [{ product: session.project.product_tag, [resourceKey]: resource }];
+    }
+    else if (verb === 'get' || verb === 'delete') {
+        if (!resource || !action)
+            throw new Error(`${kind} actions ${verb} requires <action> --${kind} <tag>`);
+        method = kind === 'graph' ? `action.${verb === 'get' ? 'fetch' : 'delete'}` : `actions.${verb === 'get' ? 'fetch' : 'delete'}`;
+        params = [{ product: session.project.product_tag, [resourceKey]: resource, actionTag: action }];
+    }
+    else {
+        if (!opts.file)
+            throw new Error(`${kind} actions execute requires --action-file <file.json>`);
+        method = kind === 'graph' ? 'action.execute' : 'actions.execute';
+        params = [{ product: session.project.product_tag, env: session.project.env_slug, ...body }];
+    }
+    const result = await getSdkProxy(session).execute(kind, method, params);
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/db-schema.js

@@ -259,6 +259,11 @@ export async function runDbSchemaGenerate(opts) {
                     },
                 ];
                 for (const { fieldName, unique } of parsed.indexFields) {
+                    // createCollection already materializes fields marked unique. Emitting a
+                    // second named createIndex operation gives MongoDB the same key/options
+                    // under a different name and fails with IndexOptionsConflict.
+                    if (unique)
+                        continue;
                     up.push({
                         type: 'createIndex',
                         collection: tableName,

package/dist/commands/db.d.ts

@@ -4,11 +4,10 @@ export declare function runDb(method: string, opts: {
 }): Promise<void>;
 /**
  * Database Actions — reusable, parameterized query/mutation definitions saved against a
- * database component (databases.action.* in the SDK). This is administrative metadata
- * (uses the access-key-backed sdk-proxy, same as `resources <type> create`), not a runtime
- * query — it never connects to the live database. Required for any Feature step that calls
- * ctx.database.query/insert/update/delete, since those take an `event` tag pointing at one
- * of these, not a raw {table, where} shape.
+ * database component (databases.action.* in the SDK). Definition management is
+ * administrative metadata (uses the access-key-backed sdk-proxy, same as
+ * `resources <type> create`). Runtime execution uses databases.execute with an `action`
+ * tag. Direct query/insert/update/delete calls keep their raw {table, where, ...} shape.
  *
  * Tag format is always "product_tag:database_tag:action_tag" — always pass it fully
  * qualified here (the SDK's 2-part fallback only works inside a single long-lived process

package/dist/commands/db.js

@@ -47,14 +47,13 @@ export async function runDb(method, opts) {
     }
     printJson(result, Boolean(opts.json));
 }
-const DB_ACTION_VERBS = ['create', 'update', 'get', 'list', 'delete'];
+const DB_ACTION_VERBS = ['create', 'update', 'get', 'list', 'delete', 'execute', 'dispatch'];
 /**
  * Database Actions — reusable, parameterized query/mutation definitions saved against a
- * database component (databases.action.* in the SDK). This is administrative metadata
- * (uses the access-key-backed sdk-proxy, same as `resources <type> create`), not a runtime
- * query — it never connects to the live database. Required for any Feature step that calls
- * ctx.database.query/insert/update/delete, since those take an `event` tag pointing at one
- * of these, not a raw {table, where} shape.
+ * database component (databases.action.* in the SDK). Definition management is
+ * administrative metadata (uses the access-key-backed sdk-proxy, same as
+ * `resources <type> create`). Runtime execution uses databases.execute with an `action`
+ * tag. Direct query/insert/update/delete calls keep their raw {table, where, ...} shape.
  *
  * Tag format is always "product_tag:database_tag:action_tag" — always pass it fully
  * qualified here (the SDK's 2-part fallback only works inside a single long-lived process
@@ -109,6 +108,22 @@ export async function runDbActions(verb, opts, extraArgs) {
             method = 'action.delete';
             params = [tag];
             break;
+        case 'dispatch': {
+            const body = readJsonBody(opts.file);
+            if (!body || Object.keys(body).length === 0)
+                throw new Error('dispatch requires --action-file <file.json>');
+            method = 'action.dispatch';
+            params = [body];
+            break;
+        }
+        case 'execute': {
+            const body = readJsonBody(opts.file);
+            if (!body || Object.keys(body).length === 0)
+                throw new Error('execute requires --action-file <file.json>');
+            method = 'execute';
+            params = [body];
+            break;
+        }
     }
     const result = await proxy.execute('databases', method, params);
     printJson(result, Boolean(opts.json));

package/dist/index.js

@@ -16,6 +16,7 @@ import { runStart, runStop, runStatus } from './commands/platform.js';
 import { runResourceCrud, runResourcesList, runEventTopicCrud, runNotificationMessageCrud } from './commands/resources.js';
 import { runCloud, runCloudPreflight } from './commands/cloud.js';
 import { runDb, runDbActions, runDbContext } from './commands/db.js';
+import { runComponentActions } from './commands/component-actions.js';
 import { runDbMigrate, runDbMigrateStatus, runDbMigrateRollback } from './commands/db-migrate.js';
 import { runFeaturesSync } from './commands/features-sync.js';
 import { runDbSchemaGenerate, runDbSchemaPush } from './commands/db-schema.js';
@@ -807,23 +808,23 @@ dbMigrate
     .action(wrap((opts) => runDbMigrateRollback({ env: opts.env, db: opts.db, n: Number(opts.n) })));
 const dbActions = db
     .command('actions')
-    .description('Reusable database action definitions (saved parameterized queries). Required for any ' +
-    'Feature step that uses ctx.database.query/insert/update/delete — those take an `event` ' +
-    'tag pointing at one of these, not a raw table/where shape. Administrative (access-key), ' +
-    'not a runtime query — create/update never touch the live database.');
+    .description('Reusable database action definitions (saved parameterized queries). Execute them with ' +
+    'database.execute({ database, action, input }) in Features, databases.execute({ product, ' +
+    'env, database, action, input }) in the SDK, or `db actions execute` in the CLI. Direct ' +
+    'query/insert/update/delete calls keep their raw table/where/data shape.');
 dbActions
     .command('create')
     .description('Create a database action from a file: { tag: "product:database:action", name, tableName, operation, template }')
-    .requiredOption('-f, --file <path>', 'JSON file with the action definition')
+    .requiredOption('--action-file <path>', 'JSON file with the action definition')
     .option('--json', 'JSON output')
-    .action(wrap((opts) => runDbActions('create', { file: opts.file, json: opts.json }, [])));
+    .action(wrap((opts) => runDbActions('create', { file: opts.actionFile, json: opts.json }, [])));
 dbActions
     .command('update')
     .description('Update an existing database action')
     .requiredOption('-t, --tag <tag>', 'Action tag ("product:database:action")')
-    .requiredOption('-f, --file <path>', 'JSON file with the fields to change')
+    .requiredOption('--action-file <path>', 'JSON file with the fields to change')
     .option('--json', 'JSON output')
-    .action(wrap((opts) => runDbActions('update', { tag: opts.tag, file: opts.file, json: opts.json }, [])));
+    .action(wrap((opts) => runDbActions('update', { tag: opts.tag, file: opts.actionFile, json: opts.json }, [])));
 dbActions
     .command('get')
     .description('Fetch one database action')
@@ -842,6 +843,18 @@ dbActions
     .argument('<tag>', 'Action tag ("product:database:action")')
     .option('--json', 'JSON output')
     .action(wrap((tag, opts) => runDbActions('delete', { tag, json: opts.json }, [])));
+dbActions
+    .command('dispatch')
+    .description('Dispatch a database action immediately or on a schedule')
+    .requiredOption('--action-file <path>', 'JSON body: { product, env, database, action, input, schedule? }')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runDbActions('dispatch', { file: opts.actionFile, json: opts.json }, [])));
+dbActions
+    .command('execute')
+    .description('Execute a saved database action synchronously')
+    .requiredOption('--action-file <path>', 'JSON body: { product, env, database, action, input }')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runDbActions('execute', { file: opts.actionFile, json: opts.json }, [])));
 const dbSchema = db.command('schema').description('Schema management for ductape/database/schema.json');
 dbSchema
     .command('generate')
@@ -873,11 +886,56 @@ features
     .argument('[filter]', 'Optional substring passed through to the project\'s features:sync script')
     .action(wrap((filter) => runFeaturesSync({ filter })));
 const graph = program.command('graph').description('Graph runtime (graph-proxy)');
+const graphActions = graph.command('actions').description('Reusable graph actions');
+for (const verb of ['create', 'update', 'get', 'list', 'delete', 'execute']) {
+    const command = graphActions.command(verb);
+    if (verb === 'get' || verb === 'delete')
+        command.argument('<action>');
+    if (verb !== 'create' && verb !== 'update' && verb !== 'execute')
+        command.requiredOption('--graph <tag>');
+    if (verb === 'create' || verb === 'update' || verb === 'execute')
+        command.requiredOption('--action-file <path>');
+    command.option('--json').action(wrap((actionOrOpts, maybeOpts) => {
+        const hasArgument = verb === 'get' || verb === 'delete';
+        const opts = hasArgument ? maybeOpts : actionOrOpts;
+        return runComponentActions('graph', verb, {
+            action: hasArgument ? actionOrOpts : undefined,
+            resource: opts.graph,
+            file: opts.actionFile,
+            json: opts.json,
+        });
+    }));
+}
 graph
-    .argument('<verb>', 'connect | query | createAction | validateAction | updateAction | …')
+    .argument('[verb]', 'connect | query | createAction | validateAction | updateAction | …')
     .option('-f, --file <path>')
     .option('--json', 'JSON output')
-    .action(wrap((verb, opts) => runGraph(verb, { file: opts.file, json: opts.json })));
+    .action(wrap((verb, opts) => {
+    if (!verb)
+        throw new Error('Specify a graph verb or use `graph actions --help`');
+    return runGraph(verb, { file: opts.file, json: opts.json });
+}));
+const vector = program.command('vector').description('Vector runtime and reusable actions');
+const vectorActions = vector.command('actions').description('Reusable vector actions');
+for (const verb of ['create', 'update', 'get', 'list', 'delete', 'execute']) {
+    const command = vectorActions.command(verb);
+    if (verb === 'get' || verb === 'delete')
+        command.argument('<action>');
+    if (verb !== 'create' && verb !== 'update' && verb !== 'execute')
+        command.requiredOption('--vector <tag>');
+    if (verb === 'create' || verb === 'update' || verb === 'execute')
+        command.requiredOption('--action-file <path>');
+    command.option('--json').action(wrap((actionOrOpts, maybeOpts) => {
+        const hasArgument = verb === 'get' || verb === 'delete';
+        const opts = hasArgument ? maybeOpts : actionOrOpts;
+        return runComponentActions('vector', verb, {
+            action: hasArgument ? actionOrOpts : undefined,
+            resource: opts.vector,
+            file: opts.actionFile,
+            json: opts.json,
+        });
+    }));
+}
 program
     .command('secrets <verb>')
     .description('Workspace secrets CRUD')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.3.19",
+  "version": "0.3.21",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",