primitive-admin 1.0.21 → 1.0.22

package/dist/src/commands/databases.js

@@ -0,0 +1,768 @@
+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 query <database-id> <model-name>
+  $ primitive databases records save <database-id> <model-name> --data '{"name":"Alice"}'
+  $ primitive databases indexes list <database-id>
+  $ primitive databases indexes create <database-id> --model contacts --field email
+  $ primitive databases permissions list <database-id>
+  $ primitive databases group-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: "DEFAULT PERM", key: "defaultPermission", 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")
+        .option("--default-permission <level>", "Default permission for all app users: reader or read-write")
+        .option("--json", "Output as JSON")
+        .action(async (title, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const params = { title };
+            if (options.defaultPermission) {
+                params.defaultPermission = options.defaultPermission;
+            }
+            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.defaultPermission) {
+                keyValue("Default Permission", result.defaultPermission);
+            }
+        }
+        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("Default Permission", result.defaultPermission || "none");
+            keyValue("Rule Set", result.ruleSetId || "none");
+            keyValue("Permission", result.permission);
+            keyValue("Created", formatDate(result.createdAt));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Update database
+    databases
+        .command("update")
+        .description("Update a database (title, default permission, rule set)")
+        .argument("<database-id>", "Database ID")
+        .option("--app <app-id>", "App ID")
+        .option("--title <title>", "New title")
+        .option("--default-permission <level>", "Default permission for all app users: reader, read-write, or none")
+        .option("--rule-set-id <id>", "Attach a rule set (use 'none' to detach)")
+        .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.defaultPermission !== undefined) {
+            params.defaultPermission =
+                options.defaultPermission === "none"
+                    ? null
+                    : options.defaultPermission;
+        }
+        if (options.ruleSetId !== undefined) {
+            params.ruleSetId =
+                options.ruleSetId === "none"
+                    ? null
+                    : options.ruleSetId;
+        }
+        if (Object.keys(params).length === 0) {
+            error("Provide at least one of --title, --default-permission, or --rule-set-id.");
+            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("Default Permission", result.defaultPermission || "none");
+            keyValue("Rule Set", result.ruleSetId || "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: owner, read-write, or reader")
+        .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 ----
+    const records = databases
+        .command("records")
+        .description("Query, create, and manage records 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);
+        }
+    });
+    // Query records
+    records
+        .command("query")
+        .description("Query records in a database")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .option("--filter <json>", "Filter as JSON", "{}")
+        .option("--limit <n>", "Max records to return", "25")
+        .option("--cursor <cursor>", "Pagination cursor")
+        .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();
+        let filter = {};
+        try {
+            filter = JSON.parse(options.filter);
+        }
+        catch {
+            error("Invalid --filter JSON.");
+            process.exit(1);
+        }
+        try {
+            const body = {
+                modelName,
+                filter,
+                options: { limit: parseInt(options.limit, 10) },
+            };
+            if (options.cursor)
+                body.options.cursor = options.cursor;
+            const result = await client.queryDatabaseRecords(resolvedAppId, databaseId, body);
+            const data = result.data || [];
+            if (options.json) {
+                json(result);
+                return;
+            }
+            if (data.length === 0) {
+                info("No records found.");
+                return;
+            }
+            // Derive columns from first record
+            const cols = Object.keys(data[0]).filter((k) => k !== "type");
+            console.log(formatTable(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.`);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Count records
+    records
+        .command("count")
+        .description("Count records of a model")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .option("--filter <json>", "Filter as JSON", "{}")
+        .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();
+        let filter = {};
+        try {
+            filter = JSON.parse(options.filter);
+        }
+        catch {
+            error("Invalid --filter JSON.");
+            process.exit(1);
+        }
+        try {
+            const result = await client.countDatabaseRecords(resolvedAppId, databaseId, {
+                modelName,
+                filter,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            console.log(`Count: ${result.count}`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Save record
+    records
+        .command("save")
+        .description("Create or update a record")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .option("--id <id>", "Record ID (auto-generated if omitted)")
+        .requiredOption("--data <json>", "Record data as JSON")
+        .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();
+        let data;
+        try {
+            data = JSON.parse(options.data);
+        }
+        catch {
+            error("Invalid --data JSON.");
+            process.exit(1);
+            return;
+        }
+        const id = options.id || crypto.randomUUID().replace(/-/g, "").slice(0, 20);
+        try {
+            const result = await client.saveDatabaseRecord(resolvedAppId, databaseId, {
+                modelName,
+                id,
+                data,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Record saved.`);
+            keyValue("ID", result.id || id);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete record
+    records
+        .command("delete")
+        .description("Delete a record")
+        .argument("<database-id>", "Database ID")
+        .argument("<model-name>", "Model name")
+        .argument("<record-id>", "Record ID")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (databaseId, modelName, recordId, 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 record ${recordId} from ${modelName}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.deleteDatabaseRecord(resolvedAppId, databaseId, {
+                modelName,
+                id: recordId,
+            });
+            success(`Record ${recordId} deleted.`);
+        }
+        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);
+        }
+    });
+    // ---- Group Permissions subcommand group ----
+    const groupPermissions = databases
+        .command("group-permissions")
+        .description("Manage group permissions on a database");
+    // List group permissions
+    groupPermissions
+        .command("list")
+        .description("List group 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.listDatabaseGroupPermissions(resolvedAppId, databaseId);
+            const list = Array.isArray(result) ? result : result?.permissions ?? [];
+            if (options.json) {
+                json(list);
+                return;
+            }
+            if (list.length === 0) {
+                info("No group permissions found.");
+                return;
+            }
+            console.log(formatTable(list, [
+                { header: "GROUP_TYPE", key: "groupType" },
+                { header: "GROUP_ID", key: "groupId" },
+                { header: "PERMISSION", key: "permission" },
+                { header: "GRANTED", key: "grantedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Grant group permission
+    groupPermissions
+        .command("grant")
+        .description("Grant a group permission on a database")
+        .argument("<database-id>", "Database ID")
+        .requiredOption("--group-type <type>", "Group type")
+        .requiredOption("--group-id <id>", "Group ID")
+        .requiredOption("--permission <permission>", "Permission level: read-write or reader")
+        .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.grantDatabaseGroupPermission(resolvedAppId, databaseId, {
+                groupType: options.groupType,
+                groupId: options.groupId,
+                permission: options.permission,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Permission '${options.permission}' granted to group ${options.groupType}/${options.groupId}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Revoke group permission
+    groupPermissions
+        .command("revoke")
+        .description("Revoke a group's permission on a database")
+        .argument("<database-id>", "Database ID")
+        .argument("<group-type>", "Group type")
+        .argument("<group-id>", "Group ID")
+        .option("--app <app-id>", "App ID")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (databaseId, groupType, groupId, 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 group ${groupType}/${groupId} on database ${databaseId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.revokeDatabaseGroupPermission(resolvedAppId, databaseId, groupType, groupId);
+            success(`Permission revoked for group ${groupType}/${groupId}.`);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=databases.js.map