@objectstack/cli 4.0.1 → 4.0.2

package/src/commands/data/get.ts

@@ -0,0 +1,84 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { Args, Command, Flags } from '@oclif/core';
+import { printError } from '../../utils/format.js';
+import { createApiClient, requireAuth } from '../../utils/api-client.js';
+import { formatOutput } from '../../utils/output-formatter.js';
+
+export default class DataGet extends Command {
+  static override description = 'Get a single record by ID';
+
+  static override examples = [
+    '$ os data get project_task abc123',
+    '$ os data get project_task abc123 --format json',
+  ];
+
+  static override args = {
+    object: Args.string({
+      description: 'Object name (snake_case)',
+      required: true,
+    }),
+    id: Args.string({
+      description: 'Record ID',
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    url: Flags.string({
+      char: 'u',
+      description: 'Server URL',
+      env: 'OBJECTSTACK_URL',
+    }),
+    token: Flags.string({
+      char: 't',
+      description: 'Authentication token',
+      env: 'OBJECTSTACK_TOKEN',
+    }),
+    format: Flags.string({
+      char: 'f',
+      description: 'Output format',
+      options: ['json', 'table', 'yaml'],
+      default: 'table',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(DataGet);
+
+    try {
+      const { client, token } = await createApiClient({
+        url: flags.url,
+        token: flags.token,
+      });
+
+      requireAuth(token);
+
+      // Get the record
+      const result = await client.data.get(args.object, args.id);
+
+      if (flags.format === 'json') {
+        formatOutput(result, 'json');
+      } else if (flags.format === 'yaml') {
+        formatOutput(result, 'yaml');
+      } else {
+        // Table format - show the record
+        if (result.record) {
+          formatOutput(result.record, 'table');
+        } else {
+          console.log('Record not found.');
+        }
+      }
+    } catch (error: any) {
+      if (flags.format === 'json') {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message,
+        }, null, 2));
+        this.exit(1);
+      }
+      printError(error.message || String(error));
+      this.exit(1);
+    }
+  }
+}

package/src/commands/data/query.ts

@@ -0,0 +1,127 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { Args, Command, Flags } from '@oclif/core';
+import { printError } from '../../utils/format.js';
+import { createApiClient, requireAuth } from '../../utils/api-client.js';
+import { formatOutput } from '../../utils/output-formatter.js';
+
+export default class DataQuery extends Command {
+  static override description = 'Query records from an object';
+
+  static override examples = [
+    '$ os data query project_task',
+    '$ os data query project_task --filter \'{"status":"open"}\'',
+    '$ os data query project_task --limit 10 --offset 0',
+    '$ os data query project_task --fields name,status,created_at',
+    '$ os data query project_task --sort -created_at',
+    '$ os data query project_task --format json',
+  ];
+
+  static override args = {
+    object: Args.string({
+      description: 'Object name (snake_case)',
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    url: Flags.string({
+      char: 'u',
+      description: 'Server URL',
+      env: 'OBJECTSTACK_URL',
+    }),
+    token: Flags.string({
+      char: 't',
+      description: 'Authentication token',
+      env: 'OBJECTSTACK_TOKEN',
+    }),
+    filter: Flags.string({
+      description: 'Filter criteria as JSON object',
+    }),
+    fields: Flags.string({
+      description: 'Comma-separated list of fields to retrieve',
+    }),
+    sort: Flags.string({
+      description: 'Sort field (prefix with - for descending)',
+    }),
+    limit: Flags.integer({
+      description: 'Maximum number of records to return',
+      default: 50,
+    }),
+    offset: Flags.integer({
+      description: 'Number of records to skip',
+      default: 0,
+    }),
+    format: Flags.string({
+      char: 'f',
+      description: 'Output format',
+      options: ['json', 'table', 'yaml'],
+      default: 'table',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(DataQuery);
+
+    try {
+      const { client, token } = await createApiClient({
+        url: flags.url,
+        token: flags.token,
+      });
+
+      requireAuth(token);
+
+      // Build query options
+      const queryOptions: any = {
+        limit: flags.limit,
+        offset: flags.offset,
+      };
+
+      if (flags.filter) {
+        try {
+          queryOptions.where = JSON.parse(flags.filter);
+        } catch (e) {
+          throw new Error(`Invalid filter JSON: ${(e as Error).message}`);
+        }
+      }
+
+      if (flags.fields) {
+        queryOptions.fields = flags.fields.split(',').map(f => f.trim());
+      }
+
+      if (flags.sort) {
+        queryOptions.orderBy = flags.sort;
+      }
+
+      // Execute query
+      const result = await client.data.query(args.object, queryOptions);
+
+      if (flags.format === 'json') {
+        formatOutput(result, 'json');
+      } else if (flags.format === 'yaml') {
+        formatOutput(result, 'yaml');
+      } else {
+        // Table format
+        if (result.records && result.records.length > 0) {
+          formatOutput(result.records, 'table');
+        } else {
+          console.log('No records found.');
+        }
+
+        if (result.total !== undefined) {
+          console.log(`\nTotal: ${result.total} record(s)`);
+        }
+      }
+    } catch (error: any) {
+      if (flags.format === 'json') {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message,
+        }, null, 2));
+        this.exit(1);
+      }
+      printError(error.message || String(error));
+      this.exit(1);
+    }
+  }
+}

package/src/commands/data/update.ts

@@ -0,0 +1,114 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { Args, Command, Flags } from '@oclif/core';
+import { printError, printSuccess } from '../../utils/format.js';
+import { createApiClient, requireAuth } from '../../utils/api-client.js';
+import { formatOutput } from '../../utils/output-formatter.js';
+
+export default class DataUpdate extends Command {
+  static override description = 'Update an existing record';
+
+  static override examples = [
+    '$ os data update project_task abc123 \'{"status":"completed"}\'',
+    '$ os data update project_task abc123 --data update-data.json',
+    '$ os data update project_task abc123 --data update-data.json --format json',
+  ];
+
+  static override args = {
+    object: Args.string({
+      description: 'Object name (snake_case)',
+      required: true,
+    }),
+    id: Args.string({
+      description: 'Record ID',
+      required: true,
+    }),
+    data: Args.string({
+      description: 'Update data as JSON string (or use --data flag for file)',
+    }),
+  };
+
+  static override flags = {
+    url: Flags.string({
+      char: 'u',
+      description: 'Server URL',
+      env: 'OBJECTSTACK_URL',
+    }),
+    token: Flags.string({
+      char: 't',
+      description: 'Authentication token',
+      env: 'OBJECTSTACK_TOKEN',
+    }),
+    data: Flags.string({
+      char: 'd',
+      description: 'Path to JSON file containing update data',
+    }),
+    format: Flags.string({
+      char: 'f',
+      description: 'Output format',
+      options: ['json', 'table', 'yaml'],
+      default: 'table',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(DataUpdate);
+
+    try {
+      const { client, token } = await createApiClient({
+        url: flags.url,
+        token: flags.token,
+      });
+
+      requireAuth(token);
+
+      // Parse update data
+      let updateData: any;
+
+      if (flags.data) {
+        // Read from file
+        const { readFile } = await import('node:fs/promises');
+        const fileContent = await readFile(flags.data, 'utf-8');
+        try {
+          updateData = JSON.parse(fileContent);
+        } catch (e) {
+          throw new Error(`Invalid JSON in file: ${(e as Error).message}`);
+        }
+      } else if (args.data) {
+        // Parse from argument
+        try {
+          updateData = JSON.parse(args.data);
+        } catch (e) {
+          throw new Error(`Invalid JSON: ${(e as Error).message}`);
+        }
+      } else {
+        throw new Error('Update data is required (provide JSON string or use --data flag)');
+      }
+
+      // Update the record
+      const result = await client.data.update(args.object, args.id, updateData);
+
+      if (flags.format === 'json') {
+        formatOutput(result, 'json');
+      } else if (flags.format === 'yaml') {
+        formatOutput(result, 'yaml');
+      } else {
+        printSuccess(`Record updated: ${result.id}`);
+        if (result.record) {
+          console.log('');
+          formatOutput(result.record, 'table');
+        }
+      }
+    } catch (error: any) {
+      if (flags.format === 'json') {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message,
+        }, null, 2));
+        this.exit(1);
+      }
+      printError(error.message || String(error));
+      this.exit(1);
+    }
+  }
+}

package/src/commands/meta/delete.ts

@@ -0,0 +1,79 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { Args, Command, Flags } from '@oclif/core';
+import { printError, printSuccess } from '../../utils/format.js';
+import { createApiClient, requireAuth } from '../../utils/api-client.js';
+import { formatOutput } from '../../utils/output-formatter.js';
+
+export default class MetaDelete extends Command {
+  static override description = 'Delete a metadata item';
+
+  static override examples = [
+    '$ os meta delete object my_custom_object',
+    '$ os meta delete plugin my-plugin',
+    '$ os meta delete object my_custom_object --format json',
+  ];
+
+  static override args = {
+    type: Args.string({
+      description: 'Metadata type',
+      required: true,
+    }),
+    name: Args.string({
+      description: 'Item name (snake_case)',
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    url: Flags.string({
+      char: 'u',
+      description: 'Server URL',
+      env: 'OBJECTSTACK_URL',
+    }),
+    token: Flags.string({
+      char: 't',
+      description: 'Authentication token',
+      env: 'OBJECTSTACK_TOKEN',
+    }),
+    format: Flags.string({
+      char: 'f',
+      description: 'Output format',
+      options: ['json', 'table', 'yaml'],
+      default: 'table',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MetaDelete);
+
+    try {
+      const { client, token } = await createApiClient({
+        url: flags.url,
+        token: flags.token,
+      });
+
+      requireAuth(token);
+
+      const result = await client.meta.deleteItem(args.type, args.name);
+
+      if (flags.format === 'json') {
+        formatOutput({ success: true, type: args.type, name: args.name, deleted: result.deleted }, 'json');
+      } else if (flags.format === 'yaml') {
+        formatOutput({ success: true, type: args.type, name: args.name, deleted: result.deleted }, 'yaml');
+      } else {
+        printSuccess(`Metadata deleted: ${args.type}/${args.name}`);
+      }
+    } catch (error: any) {
+      if (flags.format === 'json') {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message,
+        }, null, 2));
+        this.exit(1);
+      }
+      printError(error.message || String(error));
+      this.exit(1);
+    }
+  }
+}

package/src/commands/meta/get.ts

@@ -0,0 +1,73 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { Args, Command, Flags } from '@oclif/core';
+import { printError } from '../../utils/format.js';
+import { createApiClient, requireAuth } from '../../utils/api-client.js';
+import { formatOutput } from '../../utils/output-formatter.js';
+
+export default class MetaGet extends Command {
+  static override description = 'Get a metadata item';
+
+  static override examples = [
+    '$ os meta get object project_task',
+    '$ os meta get plugin my-plugin --format json',
+  ];
+
+  static override args = {
+    type: Args.string({
+      description: 'Metadata type',
+      required: true,
+    }),
+    name: Args.string({
+      description: 'Item name (snake_case)',
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    url: Flags.string({
+      char: 'u',
+      description: 'Server URL',
+      env: 'OBJECTSTACK_URL',
+    }),
+    token: Flags.string({
+      char: 't',
+      description: 'Authentication token',
+      env: 'OBJECTSTACK_TOKEN',
+    }),
+    format: Flags.string({
+      char: 'f',
+      description: 'Output format',
+      options: ['json', 'table', 'yaml'],
+      default: 'json',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MetaGet);
+
+    try {
+      const { client, token } = await createApiClient({
+        url: flags.url,
+        token: flags.token,
+      });
+
+      requireAuth(token);
+
+      // Get the metadata item
+      const item = await client.meta.getItem(args.type, args.name);
+
+      formatOutput(item, flags.format as any);
+    } catch (error: any) {
+      if (flags.format === 'json') {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message,
+        }, null, 2));
+        this.exit(1);
+      }
+      printError(error.message || String(error));
+      this.exit(1);
+    }
+  }
+}

package/src/commands/meta/list.ts

@@ -0,0 +1,105 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { Args, Command, Flags } from '@oclif/core';
+import { printError } from '../../utils/format.js';
+import { createApiClient, requireAuth } from '../../utils/api-client.js';
+import { formatOutput } from '../../utils/output-formatter.js';
+
+export default class MetaList extends Command {
+  static override description = 'List metadata types or items';
+
+  static override examples = [
+    '$ os meta list',
+    '$ os meta list object',
+    '$ os meta list plugin --format json',
+  ];
+
+  static override args = {
+    type: Args.string({
+      description: 'Metadata type (object, plugin, view, etc.)',
+    }),
+  };
+
+  static override flags = {
+    url: Flags.string({
+      char: 'u',
+      description: 'Server URL',
+      env: 'OBJECTSTACK_URL',
+    }),
+    token: Flags.string({
+      char: 't',
+      description: 'Authentication token',
+      env: 'OBJECTSTACK_TOKEN',
+    }),
+    format: Flags.string({
+      char: 'f',
+      description: 'Output format',
+      options: ['json', 'table', 'yaml'],
+      default: 'table',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MetaList);
+
+    try {
+      const { client, token } = await createApiClient({
+        url: flags.url,
+        token: flags.token,
+      });
+
+      requireAuth(token);
+
+      if (!args.type) {
+        // List all metadata types
+        const types = await client.meta.getTypes();
+
+        if (flags.format === 'json') {
+          formatOutput(types, 'json');
+        } else if (flags.format === 'yaml') {
+          formatOutput(types, 'yaml');
+        } else {
+          console.log('\nAvailable metadata types:\n');
+          if (Array.isArray(types)) {
+            types.forEach(type => console.log(`  • ${type}`));
+          } else {
+            console.log('No types available');
+          }
+          console.log('');
+        }
+      } else {
+        // List items of a specific type
+        const items = await client.meta.getItems(args.type);
+
+        if (flags.format === 'json') {
+          formatOutput(items, 'json');
+        } else if (flags.format === 'yaml') {
+          formatOutput(items, 'yaml');
+        } else {
+          console.log(`\n${args.type} items:\n`);
+          if (Array.isArray(items)) {
+            if (items.length === 0) {
+              console.log('  (no items)');
+            } else {
+              items.forEach(item => {
+                const name = item.name || item.id || JSON.stringify(item);
+                console.log(`  • ${name}`);
+              });
+            }
+          }
+          console.log('');
+        }
+      }
+    } catch (error: any) {
+      if (flags.format === 'json') {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message,
+        }, null, 2));
+        this.exit(1);
+      }
+      printError(error.message || String(error));
+      this.exit(1);
+    }
+  }
+}

package/src/commands/meta/register.ts

@@ -0,0 +1,97 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { Args, Command, Flags } from '@oclif/core';
+import { printError, printSuccess } from '../../utils/format.js';
+import { createApiClient, requireAuth } from '../../utils/api-client.js';
+import { formatOutput } from '../../utils/output-formatter.js';
+
+export default class MetaRegister extends Command {
+  static override description = 'Register metadata (create or update)';
+
+  static override examples = [
+    '$ os meta register object --data object-def.json',
+    '$ os meta register plugin --data plugin-manifest.json',
+  ];
+
+  static override args = {
+    type: Args.string({
+      description: 'Metadata type',
+      required: true,
+    }),
+  };
+
+  static override flags = {
+    url: Flags.string({
+      char: 'u',
+      description: 'Server URL',
+      env: 'OBJECTSTACK_URL',
+    }),
+    token: Flags.string({
+      char: 't',
+      description: 'Authentication token',
+      env: 'OBJECTSTACK_TOKEN',
+    }),
+    data: Flags.string({
+      char: 'd',
+      description: 'Path to JSON file containing metadata definition',
+      required: true,
+    }),
+    format: Flags.string({
+      char: 'f',
+      description: 'Output format',
+      options: ['json', 'table', 'yaml'],
+      default: 'table',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MetaRegister);
+
+    try {
+      const { client, token } = await createApiClient({
+        url: flags.url,
+        token: flags.token,
+      });
+
+      requireAuth(token);
+
+      // Read metadata from file
+      const { readFile } = await import('node:fs/promises');
+      const fileContent = await readFile(flags.data, 'utf-8');
+      let metadata: any;
+
+      try {
+        metadata = JSON.parse(fileContent);
+      } catch (e) {
+        throw new Error(`Invalid JSON in file: ${(e as Error).message}`);
+      }
+
+      // Extract name from metadata
+      const name = metadata.name;
+      if (!name) {
+        throw new Error('Metadata definition must include a "name" field');
+      }
+
+      // Register the metadata
+      const result = await client.meta.saveItem(args.type, name, metadata);
+
+      if (flags.format === 'json') {
+        formatOutput(result, 'json');
+      } else if (flags.format === 'yaml') {
+        formatOutput(result, 'yaml');
+      } else {
+        printSuccess(`Metadata registered: ${args.type}/${name}`);
+      }
+    } catch (error: any) {
+      if (flags.format === 'json') {
+        console.log(JSON.stringify({
+          success: false,
+          error: error.message,
+        }, null, 2));
+        this.exit(1);
+      }
+      printError(error.message || String(error));
+      this.exit(1);
+    }
+  }
+}