@ductape/cli 0.2.0 → 0.2.2

package/src/commands/platform.ts

@@ -44,7 +44,7 @@ export async function runStart(opts: {
           '--build-arg',
           `VITE_API_BASE_URL=${apiBase}`,
           '--build-arg',
-          'VITE_APP_ENV=development',
+          'VITE_APP_ENV=self',
           'workbench',
         ],
         platformDir,

package/src/index.ts

@@ -15,6 +15,8 @@ import { runStart, runStop, runStatus } from './commands/platform.js';
 import { runResourceCrud, runResourcesList } from './commands/resources.js';
 import { runCloud } from './commands/cloud.js';
 import { runDb, runDbContext } from './commands/db.js';
+import { runDbMigrate, runDbMigrateStatus, runDbMigrateRollback } from './commands/db-migrate.js';
+import { runDbSchemaGenerate } from './commands/db-schema.js';
 import { runGraph } from './commands/graph.js';
 import { runSecrets } from './commands/secrets.js';
 import {
@@ -28,6 +30,7 @@ import { runCompletion } from './commands/completion.js';
 import { runProducts, runProductApps } from './commands/products.js';
 import { runApps } from './commands/apps.js';
 import { runAppsImport } from './commands/apps-import.js';
+import { runApply, type ApplyType } from './commands/apply.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(
@@ -181,6 +184,22 @@ program
     ),
   );
 
+const APPLY_TYPES = ['sessions', 'notifications', 'events'] as const;
+
+program
+  .command('apply')
+  .description('Sync declared sessions, notifications and events to your product')
+  .argument('[type]', `${APPLY_TYPES.join(' | ')}`)
+  .option('--dry-run', 'Print what would be created/updated without applying')
+  .action(
+    wrap((type: string | undefined, opts) => {
+      if (type && !(APPLY_TYPES as readonly string[]).includes(type)) {
+        throw new Error(`Unknown type "${type}". Use: ${APPLY_TYPES.join(', ')}`);
+      }
+      return runApply(type as ApplyType | undefined, { dryRun: Boolean(opts.dryRun) });
+    }),
+  );
+
 program
   .command('start')
   .description('Start platform via docker compose')
@@ -203,11 +222,8 @@ program.command('status').option('--json', 'JSON output').action(wrap((opts) =>
 
 const products = program
   .command('products')
-  .description('Workspace products CRUD (REST + sdk-proxy update)');
-
-products
-  .command('<verb>')
-  .description('list | get | create | update | delete')
+  .description('Workspace products CRUD (REST + sdk-proxy update)')
+  .argument('[verb]', 'list | get | create | update | delete')
   .option('--profile <name>')
   .option('--status <status>', 'Filter for list: all, active, draft, …', 'all')
   .option('--id <id>', 'Product _id (get, delete)')
@@ -217,7 +233,10 @@ products
   .option('--no-interactive', 'Require -f JSON for create/update')
   .option('--json', 'JSON output')
   .action(
-    wrap((verb: string, opts) => runProducts(verb, opts, [])),
+    wrap((verb: string | undefined, opts) => {
+      if (!verb) throw new Error('Specify a verb: list | get | create | update | delete');
+      return runProducts(verb, opts, []);
+    }),
   );
 
 const productApps = products.command('apps').description('Apps connected to a product');
@@ -229,11 +248,10 @@ productApps
   .option('--json', 'JSON output')
   .action(wrap((opts) => runProductApps('list', opts, [])));
 
-const apps = program.command('apps').description('Workspace integration apps CRUD (REST)');
-
-apps
-  .command('<verb>')
-  .description('list | get | create | update | delete')
+const apps = program
+  .command('apps')
+  .description('Workspace integration apps CRUD (REST)')
+  .argument('[verb]', 'list | get | create | update | delete')
   .option('--profile <name>')
   .option('--status <status>', 'Filter for list', 'all')
   .option('--id <id>', 'App _id')
@@ -243,7 +261,12 @@ apps
   .option('-i, --interactive', 'Prompt for fields (default in TTY when -f omitted)')
   .option('--no-interactive', 'Require -f JSON for create/update')
   .option('--json', 'JSON output')
-  .action(wrap((verb: string, opts) => runApps(verb, opts, [])));
+  .action(
+    wrap((verb: string | undefined, opts) => {
+      if (!verb) throw new Error('Specify a verb: list | get | create | update | delete');
+      return runApps(verb, opts, []);
+    }),
+  );
 
 apps
   .command('import <file>')
@@ -277,7 +300,8 @@ const resources = program.command('resources').description('Component CRUD (sdk-
 resources.command('types').option('--json', 'JSON output').action(wrap((opts) => runResourcesList(Boolean(opts.json))));
 
 resources
-  .command('<type> <verb>')
+  .argument('<type>', 'Resource type (e.g. storage, database, cache …)')
+  .argument('<verb>', 'list | get | create | update | delete | connect')
   .option('-t, --tag <tag>')
   .option('-f, --file <path>', 'JSON body (or use interactive prompts)')
   .option('-i, --interactive', 'Prompt for fields (default in TTY when -f omitted)')
@@ -309,16 +333,54 @@ const db = program.command('db').description('Database runtime (db-proxy)');
 
 db.command('context').option('--json', 'JSON output').action(wrap((opts) => runDbContext(Boolean(opts.json))));
 
+const dbMigrate = db
+  .command('migrate')
+  .description('Run pending migrations from ductape/database/migrations/')
+  .option('--env <tag>', 'Override environment slug')
+  .option('--db <tag>', 'Limit to one db entry from schema.json')
+  .option('--dry-run', 'Print what would run without applying')
+  .action(wrap((opts) => runDbMigrate({ env: opts.env, db: opts.db, dryRun: Boolean(opts.dryRun) })));
+
+dbMigrate
+  .command('status')
+  .description('Show applied vs pending migrations')
+  .option('--env <tag>', 'Override environment slug')
+  .option('--db <tag>', 'Limit to one db entry')
+  .option('--json', 'JSON output')
+  .action(wrap((opts) => runDbMigrateStatus({ env: opts.env, db: opts.db, json: Boolean(opts.json) })));
+
+dbMigrate
+  .command('rollback')
+  .description('Roll back the last N migrations')
+  .option('--env <tag>', 'Override environment slug')
+  .option('--db <tag>', 'Limit to one db entry')
+  .option('-n <count>', 'Number of migrations to roll back', '1')
+  .action(wrap((opts) => runDbMigrateRollback({ env: opts.env, db: opts.db, n: Number(opts.n) })));
+
+const dbSchema = db.command('schema').description('Schema management for ductape/database/schema.json');
+
+dbSchema
+  .command('generate')
+  .description('Diff schema.json vs applied migrations and write new migration files')
+  .option('--db <tag>', 'Limit to one db entry from schema.json')
+  .option('--destructive', 'Also generate drop migrations for removed fields/tables')
+  .action(wrap((opts) => runDbSchemaGenerate({ db: opts.db, destructive: Boolean(opts.destructive) })));
+
 db
-  .command('<verb>')
+  .argument('[verb]', 'connect | query | …')
   .option('-f, --file <path>')
   .option('--json', 'JSON output')
-  .action(wrap((verb: string, opts) => runDb(verb, { file: opts.file, json: opts.json })));
+  .action(
+    wrap((verb: string | undefined, opts) => {
+      if (!verb) throw new Error('Specify a verb: connect | query');
+      return runDb(verb, { file: opts.file, json: opts.json });
+    }),
+  );
 
 const graph = program.command('graph').description('Graph runtime (graph-proxy)');
 
 graph
-  .command('<verb>')
+  .argument('<verb>', 'connect | query | …')
   .option('-f, --file <path>')
   .option('--json', 'JSON output')
   .action(wrap((verb: string, opts) => runGraph(verb, { file: opts.file, json: opts.json })));

package/src/lib/apply-loaders.ts

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROJECT_CONFIG_DIR } from './config.js';
+
+export type ApplyItem = Record<string, unknown> & { tag: string };
+
+function loadArrayFile(filePath: string): ApplyItem[] | null {
+  if (!fs.existsSync(filePath)) return null;
+  const raw = JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
+  if (!Array.isArray(raw)) {
+    throw new Error(`${path.basename(filePath)} must be a JSON array.`);
+  }
+  return raw as ApplyItem[];
+}
+
+function declarationPath(projectDir: string, filename: string): string {
+  return path.join(projectDir, PROJECT_CONFIG_DIR, filename);
+}
+
+export function loadSessions(projectDir: string): ApplyItem[] | null {
+  return loadArrayFile(declarationPath(projectDir, 'sessions.json'));
+}
+
+export function loadNotifications(projectDir: string): ApplyItem[] | null {
+  return loadArrayFile(declarationPath(projectDir, 'notifications.json'));
+}
+
+export function loadEvents(projectDir: string): ApplyItem[] | null {
+  return loadArrayFile(declarationPath(projectDir, 'events.json'));
+}

package/src/lib/config.ts

@@ -8,7 +8,8 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export const GLOBAL_DIR = path.join(os.homedir(), '.ductape');
 export const CREDENTIALS_PATH = path.join(GLOBAL_DIR, 'credentials.json');
 export const GLOBAL_CONFIG_PATH = path.join(GLOBAL_DIR, 'config.json');
-export const PROJECT_CONFIG_DIR = '.ductape';
+export const HUB_PLATFORM_DIR = path.join(GLOBAL_DIR, 'platform');
+export const PROJECT_CONFIG_DIR = 'ductape';
 export const PROJECT_CONFIG_PATH = path.join(PROJECT_CONFIG_DIR, 'config.json');
 
 export interface Credentials {
@@ -198,7 +199,7 @@ export function loadProjectConfig(): ResolvedProjectConfig {
   const workspace_id = resolveWorkspaceId(cfg, creds);
   if (!workspace_id) {
     throw new Error(
-      'No workspace resolved. Set workspace_tag in .ductape/config.json or run `ductape workspaces use`.',
+      'No workspace resolved. Set workspace_tag in ductape/config.json or run `ductape workspaces use`.',
     );
   }
   return { ...cfg, workspace_id };
@@ -214,12 +215,16 @@ export function resolvePlatformDir(): string {
   if (process.env.DUCTAPE_PLATFORM_DIR) {
     return path.resolve(process.env.DUCTAPE_PLATFORM_DIR);
   }
-  // cli/ -> repo root -> platform/
+  // Hub install: ~/.ductape/platform/ (written by `ductape install`)
+  if (fs.existsSync(path.join(HUB_PLATFORM_DIR, 'docker-compose.yml'))) {
+    return HUB_PLATFORM_DIR;
+  }
+  // Dev/monorepo: cli/ -> repo root -> platform/
   const fromPackage = path.resolve(__dirname, '../../../platform');
   if (fs.existsSync(path.join(fromPackage, 'docker-compose.yml'))) {
     return fromPackage;
   }
   throw new Error(
-    'Platform directory not found. Set DUCTAPE_PLATFORM_DIR to the folder containing docker-compose.yml',
+    'Platform not installed. Run `ductape install` to pull the platform from Docker Hub.',
   );
 }

package/src/lib/db-types.ts

@@ -0,0 +1,104 @@
+export type FieldType =
+  | 'string'
+  | 'text'
+  | 'integer'
+  | 'bigint'
+  | 'smallint'
+  | 'decimal'
+  | 'float'
+  | 'double'
+  | 'uuid'
+  | 'boolean'
+  | 'date'
+  | 'time'
+  | 'datetime'
+  | 'timestamp'
+  | 'binary'
+  | 'blob'
+  | 'json'
+  | 'object'
+  | 'array'
+  | 'enum';
+
+export interface IFieldDefinition {
+  name: string;
+  type: FieldType;
+  nullable?: boolean;
+  unique?: boolean;
+  primaryKey?: boolean;
+  autoGenerate?: boolean;
+  defaultValue?: unknown;
+  maxLength?: number;
+  precision?: number;
+  scale?: number;
+  enumValues?: string[];
+  arrayElementType?: FieldType;
+}
+
+export interface ICreateCollectionOp {
+  type: 'createCollection';
+  name: string;
+  fields: IFieldDefinition[];
+  ifNotExists?: boolean;
+}
+
+export interface IDropCollectionOp {
+  type: 'dropCollection';
+  name: string;
+  ifExists?: boolean;
+  cascade?: boolean;
+}
+
+export interface IAddFieldOp {
+  type: 'addField';
+  collection: string;
+  field: IFieldDefinition;
+}
+
+export interface IDropFieldOp {
+  type: 'dropField';
+  collection: string;
+  fieldName: string;
+  cascade?: boolean;
+}
+
+export interface ICreateIndexOp {
+  type: 'createIndex';
+  collection: string;
+  name: string;
+  fields: Array<{ name: string; order?: 'asc' | 'desc' }>;
+  unique?: boolean;
+  ifNotExists?: boolean;
+}
+
+export interface IDropIndexOp {
+  type: 'dropIndex';
+  collection: string;
+  name: string;
+  ifExists?: boolean;
+}
+
+export type IMigrationOperation =
+  | ICreateCollectionOp
+  | IDropCollectionOp
+  | IAddFieldOp
+  | IDropFieldOp
+  | ICreateIndexOp
+  | IDropIndexOp;
+
+export interface IMigration {
+  tag: string;
+  name: string;
+  description?: string;
+  up: IMigrationOperation[];
+  down: IMigrationOperation[];
+  dependencies?: string[];
+  createdAt?: string;
+}
+
+export interface IMigrationHistory {
+  tag: string;
+  name: string;
+  checksum?: string;
+  appliedAt?: string;
+}

package/src/lib/migration-files.ts

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROJECT_CONFIG_DIR } from './config.js';
+import type { IMigration } from './db-types.js';
+
+export function getMigrationsDir(projectDir: string, dbTag: string): string {
+  return path.join(projectDir, PROJECT_CONFIG_DIR, 'database', 'migrations', dbTag);
+}
+
+export function loadMigrationFiles(projectDir: string, dbTag: string): IMigration[] {
+  const dir = getMigrationsDir(projectDir, dbTag);
+  if (!fs.existsSync(dir)) return [];
+
+  const files = fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith('.json'))
+    .sort();
+
+  return files.map((file) => {
+    const raw = JSON.parse(
+      fs.readFileSync(path.join(dir, file), 'utf8'),
+    ) as IMigration;
+    return raw;
+  });
+}
+
+function makeTimestamp(counter: number): string {
+  const now = new Date();
+  const pad = (n: number, len = 2) => String(n).padStart(len, '0');
+  const ts =
+    String(now.getFullYear()) +
+    pad(now.getMonth() + 1) +
+    pad(now.getDate()) +
+    pad(now.getHours()) +
+    pad(now.getMinutes()) +
+    pad(now.getSeconds());
+  return `${ts}_${pad(counter, 3)}`;
+}
+
+export function writeMigrationFile(
+  projectDir: string,
+  dbTag: string,
+  migration: IMigration,
+  counter: number,
+): string {
+  const dir = getMigrationsDir(projectDir, dbTag);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const safeName = migration.name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_|_$/g, '');
+  const ts = makeTimestamp(counter);
+  const filename = `${ts}_${safeName}.json`;
+  const filePath = path.join(dir, filename);
+  fs.writeFileSync(filePath, JSON.stringify(migration, null, 2) + '\n');
+  return filePath;
+}

package/src/lib/platform-api.ts

@@ -34,6 +34,20 @@ function unwrapOne<T>(result: unknown): T {
 
 // —— Products (integrations REST + sdk-proxy for update) ——
 
+const PRODUCT_LIST_ARRAY_FIELDS = [
+  'apps', 'caches', 'quota', 'fallback', 'storage', 'brokers',
+  'sessions', 'messageBrokers', 'functions', 'variables', 'auths',
+  'databases', 'graphs', 'jobs', 'healthchecks', 'notifications',
+  'features', 'vectors', 'agents', 'models', 'steps_data',
+];
+
+function summarizeProduct(p: unknown): unknown {
+  if (!p || typeof p !== 'object') return p;
+  const out: Record<string, unknown> = { ...(p as Record<string, unknown>) };
+  for (const field of PRODUCT_LIST_ARRAY_FIELDS) delete out[field];
+  return out;
+}
+
 export async function listProducts(
   ctx: WorkspaceContext,
   status = 'all',
@@ -42,7 +56,7 @@ export async function listProducts(
     `/integrations/v1/workspace/${ctx.workspaceId}/${status}`,
     workspaceAuthQuery(ctx),
   );
-  return unwrapList(result);
+  return unwrapList<unknown>(result).map(summarizeProduct);
 }
 
 export async function getProduct(

package/src/lib/resources.ts

@@ -19,6 +19,8 @@ export const RESOURCE_MODULES: Record<string, SDKModule> = {
   actions: 'actions',
   notification: 'notifications',
   notifications: 'notifications',
+  event: 'messageBrokers',
+  events: 'messageBrokers',
   broker: 'messageBrokers',
   brokers: 'messageBrokers',
   'message-brokers': 'messageBrokers',
@@ -144,7 +146,7 @@ export function listResourceTypes(): string[] {
     'features',
     'actions',
     'notifications',
-    'message-brokers',
+    'events',
     'sessions',
     'secrets',
     'quotas',

package/src/lib/schema-loader.ts

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROJECT_CONFIG_DIR } from './config.js';
+import type { FieldType, IFieldDefinition } from './db-types.js';
+
+export interface MongooseFieldDef {
+  type?: string | string[];
+  required?: boolean;
+  unique?: boolean;
+  default?: unknown;
+  maxlength?: number;
+  enum?: string[];
+  primaryKey?: boolean;
+  autoGenerate?: boolean;
+  float?: boolean;
+  ref?: string;
+  index?: boolean;
+}
+
+export interface SchemaEntry {
+  db: string;
+  tables: Record<string, Record<string, MongooseFieldDef>>;
+}
+
+export function getSchemaPath(projectDir: string): string {
+  return path.join(projectDir, PROJECT_CONFIG_DIR, 'database', 'schema.json');
+}
+
+export function loadSchemaFile(projectDir: string): SchemaEntry[] {
+  const schemaPath = getSchemaPath(projectDir);
+  if (!fs.existsSync(schemaPath)) {
+    throw new Error(
+      `No schema.json found at ${schemaPath}. Run \`ductape init\` to scaffold it.`,
+    );
+  }
+  const raw = JSON.parse(fs.readFileSync(schemaPath, 'utf8')) as unknown;
+  if (!Array.isArray(raw)) {
+    throw new Error('schema.json must be a JSON array of { db, tables } objects.');
+  }
+  return raw as SchemaEntry[];
+}
+
+const TYPE_MAP: Record<string, FieldType> = {
+  string: 'string',
+  String: 'string',
+  text: 'text',
+  Text: 'text',
+  number: 'integer',
+  Number: 'integer',
+  integer: 'integer',
+  Integer: 'integer',
+  int: 'integer',
+  Int: 'integer',
+  boolean: 'boolean',
+  Boolean: 'boolean',
+  bool: 'boolean',
+  Bool: 'boolean',
+  date: 'datetime',
+  Date: 'datetime',
+  datetime: 'datetime',
+  DateTime: 'datetime',
+  timestamp: 'timestamp',
+  Timestamp: 'timestamp',
+  buffer: 'binary',
+  Buffer: 'binary',
+  binary: 'binary',
+  Binary: 'binary',
+  mixed: 'object',
+  Mixed: 'object',
+  object: 'object',
+  Object: 'object',
+  array: 'array',
+  Array: 'array',
+  objectid: 'uuid',
+  ObjectId: 'uuid',
+  uuid: 'uuid',
+  UUID: 'uuid',
+  decimal128: 'decimal',
+  Decimal128: 'decimal',
+  decimal: 'decimal',
+  Decimal: 'decimal',
+  map: 'object',
+  Map: 'object',
+  bigint: 'bigint',
+  BigInt: 'bigint',
+  float: 'float',
+  Float: 'float',
+  double: 'double',
+  Double: 'double',
+  json: 'json',
+  JSON: 'json',
+  blob: 'blob',
+  Blob: 'blob',
+  smallint: 'smallint',
+  SmallInt: 'smallint',
+  time: 'time',
+  Time: 'time',
+};
+
+function resolveBaseType(raw: string | string[] | undefined, def: MongooseFieldDef): FieldType {
+  const t = Array.isArray(raw) ? raw[0] : (raw ?? 'String');
+  if (def.enum?.length) return 'enum';
+  const mapped = TYPE_MAP[t];
+  if (!mapped) return 'string';
+  if (mapped === 'integer' && def.float) return 'float';
+  return mapped;
+}
+
+export function parseField(name: string, def: MongooseFieldDef): IFieldDefinition {
+  const type = resolveBaseType(def.type, def);
+  const field: IFieldDefinition = { name, type };
+
+  if (def.required === true) field.nullable = false;
+  if (def.unique === true) field.unique = true;
+  if (def.primaryKey === true) field.primaryKey = true;
+  if (def.autoGenerate === true) field.autoGenerate = true;
+  if (def.maxlength != null) field.maxLength = def.maxlength;
+
+  if (def.default !== undefined) {
+    field.defaultValue =
+      def.default === 'now' || def.default === 'NOW' ? 'CURRENT_TIMESTAMP' : def.default;
+  }
+
+  if (type === 'enum' && def.enum?.length) {
+    field.enumValues = def.enum;
+  }
+
+  return field;
+}
+
+export interface ParsedTable {
+  name: string;
+  fields: IFieldDefinition[];
+  indexFields: Array<{ fieldName: string; unique: boolean }>;
+}
+
+export function parseTableDef(
+  tableName: string,
+  fieldDefs: Record<string, MongooseFieldDef>,
+): ParsedTable {
+  const fields: IFieldDefinition[] = [];
+  const indexFields: Array<{ fieldName: string; unique: boolean }> = [];
+
+  for (const [name, def] of Object.entries(fieldDefs)) {
+    fields.push(parseField(name, def));
+    if (def.index === true) {
+      indexFields.push({ fieldName: name, unique: def.unique === true });
+    }
+  }
+
+  return { name: tableName, fields, indexFields };
+}