@ductape/cli 0.2.0 → 0.2.1

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/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 };
+}

package/src/lib/templates.ts

@@ -49,7 +49,7 @@ DUCTAPE_ENV=dev
   const envPath = path.join(dir, '.env.ductape.example');
   if (!fs.existsSync(envPath)) fs.writeFileSync(envPath, envContent);
 
-  const ductapeDir = path.join(dir, '.ductape');
+  const ductapeDir = path.join(dir, 'ductape');
   fs.mkdirSync(ductapeDir, { recursive: true });
 
   const readme = `# Ductape project
@@ -66,6 +66,85 @@ Docs: https://docs.ductape.app/docs/cli/
   const readmePath = path.join(ductapeDir, 'README.md');
   if (!fs.existsSync(readmePath)) fs.writeFileSync(readmePath, readme);
 
+  const dbDir = path.join(ductapeDir, 'database');
+  const migrationsDir = path.join(dbDir, 'migrations');
+  fs.mkdirSync(migrationsDir, { recursive: true });
+
+  const schemaPath = path.join(dbDir, 'schema.json');
+  if (!fs.existsSync(schemaPath)) {
+    const schemaTemplate = [
+      {
+        db: 'your_db_tag',
+        tables: {
+          example_table: {
+            id: { type: 'String', primaryKey: true, autoGenerate: true },
+            name: { type: 'String', required: true },
+            createdAt: { type: 'Date', default: 'now' },
+          },
+        },
+      },
+    ];
+    fs.writeFileSync(schemaPath, JSON.stringify(schemaTemplate, null, 2) + '\n');
+  }
+
+  const sessionsPath = path.join(ductapeDir, 'sessions.json');
+  if (!fs.existsSync(sessionsPath)) {
+    const sessionsTemplate = [
+      {
+        tag: 'user-session',
+        name: 'User session',
+        description: 'Standard authenticated user session',
+        expiry: 604800,
+        refresh_expiry: 2592000,
+      },
+    ];
+    fs.writeFileSync(sessionsPath, JSON.stringify(sessionsTemplate, null, 2) + '\n');
+  }
+
+  const notificationsPath = path.join(ductapeDir, 'notifications.json');
+  if (!fs.existsSync(notificationsPath)) {
+    const notificationsTemplate = [
+      {
+        tag: 'transactional-email',
+        name: 'Transactional email',
+        description: 'Email channel for transactional messages',
+        envs: [
+          {
+            slug: 'dev',
+            emails: {
+              host: 'smtp.example.com',
+              port: 587,
+              user: 'your-smtp-user',
+              pass: 'your-smtp-pass',
+              sender: 'no-reply@example.com',
+            },
+          },
+        ],
+      },
+    ];
+    fs.writeFileSync(notificationsPath, JSON.stringify(notificationsTemplate, null, 2) + '\n');
+  }
+
+  const eventsPath = path.join(ductapeDir, 'events.json');
+  if (!fs.existsSync(eventsPath)) {
+    const eventsTemplate = [
+      {
+        tag: 'main-event-bus',
+        name: 'Main event bus',
+        description: 'Primary message broker for application events',
+        envs: [
+          {
+            slug: 'dev',
+            type: 'kafka',
+            brokers: ['localhost:9092'],
+            client_id: 'my-app-dev',
+          },
+        ],
+      },
+    ];
+    fs.writeFileSync(eventsPath, JSON.stringify(eventsTemplate, null, 2) + '\n');
+  }
+
   copyTemplate(lang, dir);
 
   const gitignorePath = path.join(dir, '.gitignore');