primitive-admin 1.0.21 → 1.0.23

package/dist/src/commands/databases.js

@@ -0,0 +1,645 @@
+import { ApiClient } from "../lib/api-client.js";
+import { getCurrentAppId } from "../lib/config.js";
+import { success, error, info, keyValue, formatTable, formatId, formatDate, json, } from "../lib/output.js";
+function resolveAppId(appId, options) {
+    const resolved = appId || options.app || getCurrentAppId();
+    if (!resolved) {
+        error("No app specified. Use <app-id>, --app, or 'primitive use <app-id>' to set context.");
+        process.exit(1);
+    }
+    return resolved;
+}
+export function registerDatabasesCommands(program) {
+    const databases = program
+        .command("databases")
+        .description("Create, manage, and configure online databases")
+        .addHelpText("after", `
+Examples:
+  $ primitive databases list
+  $ primitive databases create "My Database"
+  $ primitive databases get <database-id>
+  $ primitive databases records models <database-id>
+  $ primitive databases records describe <database-id> <model-name>
+  $ primitive databases operations list <database-id>
+  $ primitive databases operations execute <database-id> <operation-name> --params '{"key":"value"}'
+  $ primitive databases indexes list <database-id>
+  $ primitive databases indexes create <database-id> --model contacts --field email
+  $ primitive databases permissions list <database-id>
+`);
+    // List databases
+    databases
+        .command("list")
+        .description("List databases in an app")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.listDatabases(resolvedAppId);
+            const list = Array.isArray(result) ? result : result?.databases ?? [];
+            if (options.json) {
+                json(list);
+                return;
+            }
+            if (list.length === 0) {
+                info("No databases found.");
+                return;
+            }
+            console.log(formatTable(list, [
+                { header: "ID", key: "databaseId", format: formatId },
+                { header: "TITLE", key: "title" },
+                { header: "TYPE", key: "databaseType", format: (v) => v || "—" },
+                { header: "PERMISSION", key: "permission" },
+                { header: "CREATED", key: "createdAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Create database
+    databases
+        .command("create")
+        .description("Create a new database")
+        .argument("<title>", "Database title")
+        .option("--app <app-id>", "App ID")
+        .requiredOption("--type <database-type>", "Database type (required)")
+        .option("--json", "Output as JSON")
+        .action(async (title, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const params = { title, databaseType: options.type };
+            const result = await client.createDatabase(resolvedAppId, params);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Database created.");
+            keyValue("Database ID", result.databaseId);
+            keyValue("Title", result.title);
+            if (result.databaseType) {
+                keyValue("Database Type", result.databaseType);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get database
+    databases
+        .command("get")
+        .description("Get database details")
+        .argument("<database-id>", "Database ID")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.getDatabase(resolvedAppId, databaseId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            keyValue("Database ID", result.databaseId);
+            keyValue("Title", result.title);
+            keyValue("Database Type", result.databaseType || "none");
+            keyValue("Permission", result.permission || "none");
+            keyValue("Created", formatDate(result.createdAt));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Update database
+    databases
+        .command("update")
+        .description("Update a database (title, type)")
+        .argument("<database-id>", "Database ID")
+        .option("--app <app-id>", "App ID")
+        .option("--title <title>", "New title")
+        .option("--type <database-type>", "Database type (use 'none' to clear)")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        const params = {};
+        if (options.title) {
+            params.title = options.title;
+        }
+        if (options.type !== undefined) {
+            params.databaseType =
+                options.type === "none"
+                    ? null
+                    : options.type;
+        }
+        if (Object.keys(params).length === 0) {
+            error("Provide at least one of --title or --type.");
+            process.exit(1);
+        }
+        try {
+            const result = await client.updateDatabase(resolvedAppId, databaseId, params);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Database updated.");
+            keyValue("Database ID", result.databaseId);
+            keyValue("Title", result.title);
+            keyValue("Database Type", result.databaseType || "none");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete database
+    databases
+        .command("delete")
+        .description("Delete a database")
+        .argument("<database-id>", "Database ID")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            const inquirer = await import("inquirer");
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Delete database ${databaseId}? This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.deleteDatabase(resolvedAppId, databaseId);
+            success(`Database ${databaseId} deleted.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ---- Permissions subcommand group ----
+    const permissions = databases
+        .command("permissions")
+        .description("Manage user permissions on a database");
+    // List permissions
+    permissions
+        .command("list")
+        .description("List user permissions for a database")
+        .argument("<database-id>", "Database ID")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.listDatabasePermissions(resolvedAppId, databaseId);
+            const list = Array.isArray(result) ? result : result?.permissions ?? [];
+            if (options.json) {
+                json(list);
+                return;
+            }
+            if (list.length === 0) {
+                info("No permissions found.");
+                return;
+            }
+            console.log(formatTable(list, [
+                { header: "USER_ID", key: "userId", format: formatId },
+                { header: "EMAIL", key: "userEmail" },
+                { header: "PERMISSION", key: "permission" },
+                { header: "GRANTED", key: "grantedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Grant permission
+    permissions
+        .command("grant")
+        .description("Grant a user permission on a database")
+        .argument("<database-id>", "Database ID")
+        .requiredOption("--user-id <user-id>", "User ID to grant permission to")
+        .requiredOption("--permission <permission>", "Permission level: manager")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.grantDatabasePermission(resolvedAppId, databaseId, {
+                userId: options.userId,
+                permission: options.permission,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Permission '${options.permission}' granted to user ${options.userId}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Revoke permission
+    permissions
+        .command("revoke")
+        .description("Revoke a user's permission on a database")
+        .argument("<database-id>", "Database ID")
+        .argument("<user-id>", "User ID to revoke")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (databaseId, userId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            const inquirer = await import("inquirer");
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Revoke permission for user ${userId} on database ${databaseId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.revokeDatabasePermission(resolvedAppId, databaseId, userId);
+            success(`Permission revoked for user ${userId}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ---- Records subcommand group (models & describe only) ----
+    const records = databases
+        .command("records")
+        .description("Inspect models and schemas in a database");
+    // List models
+    records
+        .command("models")
+        .description("List model names in a database")
+        .argument("<database-id>", "Database ID")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.listDatabaseModels(resolvedAppId, databaseId);
+            const models = result.models || [];
+            if (options.json) {
+                json(models);
+                return;
+            }
+            if (models.length === 0) {
+                info("No models found.");
+                return;
+            }
+            for (const m of models) {
+                console.log(`  ${m}`);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Describe model
+    records
+        .command("describe")
+        .description("Show inferred schema for a model")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, modelName, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.describeDatabaseModel(resolvedAppId, databaseId, modelName);
+            const fields = result.fields || [];
+            if (options.json) {
+                json(fields);
+                return;
+            }
+            if (fields.length === 0) {
+                info("No fields detected.");
+                return;
+            }
+            console.log(formatTable(fields, [
+                { header: "FIELD", key: "field_name" },
+                { header: "TYPE", key: "inferred_type" },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ---- Metadata subcommand group ----
+    const metadata = databases
+        .command("metadata")
+        .description("Manage database metadata");
+    metadata
+        .command("update")
+        .description("Update database metadata (merge with existing)")
+        .argument("<database-id>", "Database ID")
+        .requiredOption("--data <json>", "Metadata fields as JSON (merged with existing)")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        let data;
+        try {
+            data = JSON.parse(options.data);
+        }
+        catch {
+            error("Invalid --data JSON.");
+            process.exit(1);
+            return;
+        }
+        try {
+            const result = await client.updateDatabaseMetadata(resolvedAppId, databaseId, data);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Metadata updated.");
+            if (result.metadata) {
+                keyValue("Metadata", JSON.stringify(result.metadata));
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ---- Operations subcommand group ----
+    const operations = databases
+        .command("operations")
+        .description("List and execute registered operations on a database");
+    // List operations
+    operations
+        .command("list")
+        .description("List registered operations available on a database")
+        .argument("<database-id>", "Database ID")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.listDatabaseOperations(resolvedAppId, databaseId);
+            const list = Array.isArray(result) ? result : [];
+            if (options.json) {
+                json(list);
+                return;
+            }
+            if (list.length === 0) {
+                info("No operations found.");
+                return;
+            }
+            console.log(formatTable(list, [
+                { header: "NAME", key: "name" },
+                { header: "TYPE", key: "type" },
+                { header: "MODEL", key: "modelName" },
+                { header: "ACCESS", key: "access" },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Execute operation
+    operations
+        .command("execute")
+        .description("Execute a registered operation on a database")
+        .argument("<database-id>", "Database ID")
+        .argument("<operation-name>", "Operation name")
+        .option("--params <json>", "Operation parameters as JSON")
+        .option("--limit <n>", "Max records to return (for queries)")
+        .option("--cursor <cursor>", "Pagination cursor")
+        .option("--token <jwt>", "Execute as a specific user (dev/test — JWT visible in process args)")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .option("--timing", "Show server-side timing breakdown")
+        .action(async (databaseId, operationName, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        let params;
+        if (options.params) {
+            try {
+                params = JSON.parse(options.params);
+            }
+            catch {
+                error("Invalid --params JSON.");
+                process.exit(1);
+                return;
+            }
+        }
+        const body = {};
+        if (params)
+            body.params = params;
+        if (options.limit)
+            body.limit = parseInt(options.limit, 10);
+        if (options.cursor)
+            body.cursor = options.cursor;
+        try {
+            const result = await client.executeDatabaseOperation(resolvedAppId, databaseId, operationName, body, options.token, { timing: !!options.timing });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            // Smart display based on result shape
+            if (result.data && Array.isArray(result.data)) {
+                if (result.data.length === 0) {
+                    info("No records found.");
+                }
+                else {
+                    const cols = Object.keys(result.data[0]).filter((k) => k !== "type");
+                    console.log(formatTable(result.data, cols.map((c) => ({
+                        header: c.toUpperCase(),
+                        key: c,
+                        format: (v) => {
+                            if (v === null || v === undefined)
+                                return "—";
+                            if (typeof v === "object") {
+                                const s = JSON.stringify(v);
+                                return s.length > 50 ? s.slice(0, 47) + "..." : s;
+                            }
+                            const s = String(v);
+                            return s.length > 50 ? s.slice(0, 47) + "..." : s;
+                        },
+                    }))));
+                }
+                if (result.hasMore) {
+                    info(`More records available. Use --cursor ${result.cursor} to continue.`);
+                }
+            }
+            else if (result.count !== undefined) {
+                console.log(`Count: ${result.count}`);
+            }
+            else if (result.result !== undefined) {
+                // Aggregate result
+                json(result);
+            }
+            else if (result.results && Array.isArray(result.results)) {
+                // Batch/mutation results
+                success(`Operation executed (${result.results.length} result${result.results.length === 1 ? "" : "s"}).`);
+            }
+            else if (result.success !== undefined) {
+                success("Operation executed.");
+            }
+            else {
+                json(result);
+            }
+            // Display timing if present
+            if (result._timing) {
+                console.log("");
+                console.log("Timing:");
+                for (const [key, value] of Object.entries(result._timing)) {
+                    console.log(`  ${key}: ${value}ms`);
+                }
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ---- Indexes subcommand group ----
+    const indexes = databases
+        .command("indexes")
+        .description("Manage indexes on a database");
+    // List indexes
+    indexes
+        .command("list")
+        .description("List indexes for a database or model")
+        .argument("<database-id>", "Database ID")
+        .option("--model <model-name>", "Filter by model name")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.listDatabaseIndexes(resolvedAppId, databaseId, options.model);
+            const list = result.indexes || [];
+            if (options.json) {
+                json(list);
+                return;
+            }
+            if (list.length === 0) {
+                info("No indexes found.");
+                return;
+            }
+            console.log(formatTable(list, [
+                { header: "MODEL", key: "model_name" },
+                { header: "FIELD", key: "field_name" },
+                { header: "TYPE", key: "field_type" },
+                { header: "UNIQUE", key: "is_unique", format: (v) => (v ? "Yes" : "No") },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Register index
+    indexes
+        .command("create")
+        .description("Create an index on a model field")
+        .argument("<database-id>", "Database ID")
+        .requiredOption("--model <model-name>", "Model name")
+        .requiredOption("--field <field-name>", "Field name to index")
+        .option("--type <field-type>", "Field type: string, number, or boolean", "string")
+        .option("--unique", "Make this a unique index")
+        .option("--app <app-id>", "App ID")
+        .option("--json", "Output as JSON")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.registerDatabaseIndex(resolvedAppId, databaseId, {
+                modelName: options.model,
+                fieldName: options.field,
+                fieldType: options.type,
+                unique: !!options.unique,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Index created on ${options.model}.${options.field} (${options.type}${options.unique ? ", unique" : ""}).`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Drop index
+    indexes
+        .command("drop")
+        .description("Drop an index from a model field")
+        .argument("<database-id>", "Database ID")
+        .requiredOption("--model <model-name>", "Model name")
+        .requiredOption("--field <field-name>", "Field name")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (databaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            const inquirer = await import("inquirer");
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Drop index on ${options.model}.${options.field}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.dropDatabaseIndex(resolvedAppId, databaseId, {
+                modelName: options.model,
+                fieldName: options.field,
+            });
+            success(`Index dropped on ${options.model}.${options.field}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=databases.js.map