@ductape/cli 0.2.23 → 0.3.0

package/src/lib/read-body.ts

@@ -1,57 +0,0 @@
-import fs from 'node:fs';
-import {
-  getFormSchema,
-  isInteractive,
-  promptForm,
-  type InteractiveOpts,
-} from './forms/index.js';
-import type { FormSchema } from './forms/types.js';
-
-export function readJsonBody(filePath?: string): unknown {
-  if (!filePath) return undefined;
-  const raw = fs.readFileSync(filePath, 'utf8');
-  return JSON.parse(raw) as unknown;
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-  if (value === undefined) return undefined;
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    return value as Record<string, unknown>;
-  }
-  throw new Error('Body must be a JSON object');
-}
-
-export async function resolveBody(
-  opts: InteractiveOpts & {
-    file?: string;
-    schemaKey?: string;
-    schema?: FormSchema;
-    patch?: boolean;
-    requireBody?: boolean;
-  },
-): Promise<Record<string, unknown> | undefined> {
-  if (opts.file) {
-    return asRecord(readJsonBody(opts.file));
-  }
-
-  const schema = opts.schema ?? (opts.schemaKey ? getFormSchema(opts.schemaKey) : undefined);
-  if (schema && isInteractive(opts)) {
-    return promptForm(schema, { patch: opts.patch ?? opts.schemaKey?.endsWith(':update') });
-  }
-
-  if (opts.requireBody && isInteractive(opts) === false) {
-    return undefined;
-  }
-
-  if (opts.requireBody) {
-    return undefined;
-  }
-
-  return undefined;
-}
-
-export function bodyRequiredHint(schemaKey?: string): string {
-  const json = 'Pass -f <file.json> or run interactively (TTY)';
-  if (schemaKey) return `${json} — schema: ${schemaKey}`;
-  return json;
-}

package/src/lib/resources.ts

@@ -1,160 +0,0 @@
-import type { SDKModule } from './proxy/sdk-proxy.js';
-
-/** CLI resource type → sdk-proxy module */
-export const RESOURCE_MODULES: Record<string, SDKModule> = {
-  storage: 'storage',
-  databases: 'databases',
-  database: 'databases',
-  graph: 'graph',
-  graphs: 'graph',
-  vector: 'vector',
-  vectors: 'vector',
-  cache: 'caches',
-  caches: 'caches',
-  job: 'jobs',
-  jobs: 'jobs',
-  feature: 'features',
-  features: 'features',
-  action: 'actions',
-  actions: 'actions',
-  notification: 'notifications',
-  notifications: 'notifications',
-  event: 'messageBrokers',
-  events: 'messageBrokers',
-  broker: 'messageBrokers',
-  brokers: 'messageBrokers',
-  'message-brokers': 'messageBrokers',
-  messagebrokers: 'messageBrokers',
-  session: 'sessions',
-  sessions: 'sessions',
-  secret: 'secrets',
-  secrets: 'secrets',
-  quota: 'quotas',
-  quotas: 'quotas',
-  health: 'health',
-  healthcheck: 'health',
-  fallback: 'fallback',
-  product: 'product',
-  app: 'app',
-};
-
-export type CrudVerb = 'create' | 'list' | 'get' | 'update' | 'delete' | 'connect';
-
-export function resolveResourceType(name: string): SDKModule {
-  const mod = RESOURCE_MODULES[name.toLowerCase()];
-  if (!mod) {
-    throw new Error(
-      `Unknown resource type "${name}". Try: storage, databases, graph, product, app, … — or \`ductape products\` / \`ductape apps\` for workspace CRUD`,
-    );
-  }
-  return mod;
-}
-
-export function proxyMethodForVerb(verb: CrudVerb): string {
-  if (verb === 'get') return 'fetch';
-  return verb;
-}
-
-/** Build params array matching Workbench sdkProxy.ts conventions */
-export function buildCrudParams(
-  module: SDKModule,
-  method: string,
-  productTag: string,
-  args: { tag?: string; body?: unknown },
-): unknown[] {
-  const { tag, body } = args;
-
-  if (module === 'vector') {
-    if (method === 'list') return [{ product: productTag }];
-    if (method === 'fetch' || method === 'delete') {
-      if (!tag) throw new Error('tag is required');
-      return [{ product: productTag, tag }];
-    }
-    if (method === 'create' || method === 'update' || method === 'connect') {
-      const payload =
-        body && typeof body === 'object'
-          ? { product: productTag, ...(body as object) }
-          : { product: productTag };
-      return [payload];
-    }
-  }
-
-  if ((module === 'storage' || module === 'databases') && method === 'create') {
-    // databases.create and storage.create expect a single config object with product embedded,
-    // not the default (productTag, data) two-argument form.
-    const payload =
-      body && typeof body === 'object'
-        ? { product: productTag, ...(body as object) }
-        : { product: productTag };
-    return [payload];
-  }
-
-  if (module === 'secrets') {
-    if (method === 'list') return [];
-    if (method === 'fetch' || method === 'delete') {
-      if (!tag) throw new Error('key/tag is required');
-      return method === 'delete' ? [tag] : [tag];
-    }
-    if (method === 'create') return [body ?? {}];
-    if (method === 'update') {
-      if (!tag) throw new Error('key is required');
-      return [tag, body ?? {}];
-    }
-  }
-
-  if (module === 'product' || module === 'app') {
-    if (method === 'create') return [body ?? {}];
-    if (method === 'fetch') {
-      if (!tag) throw new Error('tag is required');
-      return [tag];
-    }
-    if (method === 'update') {
-      if (!tag) throw new Error('tag is required');
-      return [tag, body ?? {}];
-    }
-    if (method === 'list') return [];
-  }
-
-  // Default product-scoped components
-  if (method === 'create') return [productTag, body ?? {}];
-  if (method === 'list') return [productTag];
-  if (method === 'fetch' || method === 'delete') {
-    if (!tag) throw new Error('tag is required');
-    return [productTag, tag];
-  }
-  if (method === 'update') {
-    if (!tag) throw new Error('tag is required');
-    return [productTag, tag, body ?? {}];
-  }
-  if (method === 'connect') {
-    const payload =
-      body && typeof body === 'object'
-        ? { product: productTag, ...(body as object) }
-        : { product: productTag };
-    return [payload];
-  }
-
-  throw new Error(`Unsupported operation ${module}.${method}`);
-}
-
-export function listResourceTypes(): string[] {
-  return [
-    'storage',
-    'databases',
-    'graph',
-    'vector',
-    'caches',
-    'jobs',
-    'features',
-    'actions',
-    'notifications',
-    'events',
-    'sessions',
-    'secrets',
-    'quotas',
-    'health',
-    'fallback',
-    'product',
-    'app',
-  ];
-}

package/src/lib/schema-loader.ts

@@ -1,152 +0,0 @@
-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/snippets.ts

@@ -1,165 +0,0 @@
-const ALLOWED_SNIPPET_METHODS: Record<string, string[]> = {
-  action: ['run', 'dispatch', 'execute'],
-  workflow: ['run', 'dispatch', 'execute'],
-  database: ['dispatch', 'find', 'insert', 'update', 'delete', 'query', 'upsert', 'count', 'aggregate'],
-  graph: ['dispatch', 'find', 'insert', 'update', 'delete', 'query', 'execute'],
-  vector: ['query', 'find', 'findSimilar', 'upsert', 'insert', 'delete', 'dispatch'],
-  storage: ['dispatch', 'upload', 'download', 'remove', 'listFiles', 'getSignedUrl', 'stats'],
-  notification: ['dispatch', 'send', 'email.send', 'push.send', 'sms.send', 'callback.send'],
-  messaging: ['dispatch', 'send', 'publish', 'produce', 'consume'],
-  broker: ['dispatch', 'send', 'publish', 'produce', 'consume'],
-  quota: ['run', 'dispatch', 'check', 'consume'],
-  fallback: ['run', 'dispatch'],
-  healthcheck: ['run', 'check', 'status'],
-  health: ['run', 'check', 'status'],
-  session: ['start', 'verify', 'refresh', 'revoke', 'listActive'],
-  cache: ['get', 'set', 'clear', 'clearAll', 'dispatch', 'fetchValues'],
-};
-
-export function ensureSupportedSnippetOperation(operationFamily: string, method: string): void {
-  const family = operationFamily.toLowerCase();
-  const allowed = ALLOWED_SNIPPET_METHODS[family] ?? [];
-  if (!allowed.includes(method)) {
-    throw new Error(
-      `Unsupported snippet operation "${family}.${method}". Allowed: ${allowed.join(', ') || '(none)'}`,
-    );
-  }
-}
-
-function resolveSdkCallPath(operationFamily: string, method: string): string {
-  const family = operationFamily.toLowerCase();
-  const m = method.toLowerCase();
-
-  if (family === 'action') return `actions.${m}`;
-  if (family === 'workflow') return `workflows.${m}`;
-  if (family === 'database') return m === 'dispatch' ? 'databases.dispatch' : `databases.${m}`;
-  if (family === 'graph') return m === 'dispatch' ? 'graph.dispatch' : `graph.${m}`;
-  if (family === 'vector') return `vector.${m}`;
-  if (family === 'storage') return m === 'dispatch' ? 'storage.dispatch' : `storage.${m}`;
-  if (family === 'notification') return m === 'dispatch' ? 'notifications.dispatch' : `notifications.${m}`;
-  if (family === 'messaging' || family === 'broker') {
-    if (m === 'dispatch') return 'messageBrokers.dispatch';
-    if (m === 'send' || m === 'publish' || m === 'produce') return 'messageBrokers.produce';
-    return `messageBrokers.${m}`;
-  }
-  if (family === 'quota') return `quotas.${m}`;
-  if (family === 'fallback') return `fallback.${m}`;
-  if (family === 'healthcheck' || family === 'health') return `health.${m}`;
-  if (family === 'session') return `sessions.${m}`;
-  if (family === 'cache') return (m === 'dispatch' ? 'caches.dispatch' : `caches.${m}`);
-  return `${family}.${m}`;
-}
-
-function buildInvocationArgs(payload: Record<string, unknown>): Record<string, unknown> {
-  const input = (payload.input as Record<string, unknown>) ?? {};
-  return {
-    product: payload.product_tag,
-    env: payload.env,
-    ...input,
-    ...(payload.session ? { session: payload.session } : {}),
-    ...(payload.cache ? { cache: payload.cache } : {}),
-  };
-}
-
-function prettyJson(v: unknown): string {
-  return JSON.stringify(v ?? {}, null, 2);
-}
-
-export function buildTypeScriptSnippet(
-  payload: Record<string, unknown>,
-  operationFamily: string,
-  method: string,
-): string {
-  const callPath = resolveSdkCallPath(operationFamily, method);
-  const args = buildInvocationArgs(payload);
-  return `import Ductape from '@ductape/sdk';
-
-const ductape = new Ductape({
-  publishableKey: process.env.DUCTAPE_PUBLISHABLE_KEY!,
-  product: process.env.DUCTAPE_PRODUCT!,
-  env: process.env.DUCTAPE_ENV!,
-});
-
-async function main() {
-  const result = await ductape.${callPath}(${prettyJson(args)});
-  console.log(JSON.stringify(result, null, 2));
-}
-
-main().catch(console.error);
-`;
-}
-
-export function buildPythonSnippet(
-  payload: Record<string, unknown>,
-  operationFamily: string,
-  method: string,
-): string {
-  const callPath = resolveSdkCallPath(operationFamily, method).replace(/\./g, '_');
-  const args = buildInvocationArgs(payload);
-  return `import os
-import json
-from ductape import Ductape
-
-ductape = Ductape(
-    publishable_key=os.environ["DUCTAPE_PUBLISHABLE_KEY"],
-    product=os.environ["DUCTAPE_PRODUCT"],
-    env=os.environ["DUCTAPE_ENV"],
-)
-
-def main():
-    args = ${prettyJson(args)}
-    result = ductape.${callPath}(args)
-    print(json.dumps(result, indent=2))
-
-if __name__ == "__main__":
-    main()
-`;
-}
-
-export function buildGoSnippet(
-  payload: Record<string, unknown>,
-  operationFamily: string,
-  method: string,
-): string {
-  const callPath = resolveSdkCallPath(operationFamily, method);
-  return `package main
-
-// go get github.com/ductape/ductape/sdk/go
-// See https://docs.ductape.app for ${operationFamily}.${method}
-// Payload preview:
-// ${prettyJson(payload).split('\n').join('\n// ')}
-func main() {
-    // ductape.${callPath}(...)
-}
-`;
-}
-
-export function buildDotnetSnippet(
-  payload: Record<string, unknown>,
-  operationFamily: string,
-  method: string,
-): string {
-  const callPath = resolveSdkCallPath(operationFamily, method);
-  return `// dotnet add package Ductape.Sdk
-// Operation: ${operationFamily}.${method} -> ${callPath}
-// Payload: ${JSON.stringify(payload)}
-`;
-}
-
-export function buildSnippet(
-  language: 'typescript' | 'python' | 'go' | 'dotnet',
-  payload: Record<string, unknown>,
-  operationFamily: string,
-  method: string,
-): string {
-  switch (language) {
-    case 'python':
-      return buildPythonSnippet(payload, operationFamily, method);
-    case 'go':
-      return buildGoSnippet(payload, operationFamily, method);
-    case 'dotnet':
-      return buildDotnetSnippet(payload, operationFamily, method);
-    default:
-      return buildTypeScriptSnippet(payload, operationFamily, method);
-  }
-}

package/src/lib/templates.ts

@@ -1,157 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEMPLATES_ROOT = path.resolve(__dirname, '../../templates');
-
-export type InitLanguage = 'typescript' | 'python' | 'go' | 'dotnet' | 'unknown';
-
-export function detectLanguage(dir: string): InitLanguage {
-  if (fs.existsSync(path.join(dir, 'package.json'))) return 'typescript';
-  if (fs.existsSync(path.join(dir, 'pyproject.toml')) || fs.existsSync(path.join(dir, 'requirements.txt'))) {
-    return 'python';
-  }
-  if (fs.existsSync(path.join(dir, 'go.mod'))) return 'go';
-  try {
-    if (fs.readdirSync(dir).some((f) => f.endsWith('.csproj'))) return 'dotnet';
-  } catch {
-    /* ignore */
-  }
-  return 'unknown';
-}
-
-function copyTemplate(lang: InitLanguage, targetDir: string): void {
-  const map: Record<InitLanguage, { src: string; dest: string } | null> = {
-    typescript: { src: 'typescript/ductape.example.ts', dest: 'ductape.example.ts' },
-    python: { src: 'python/ductape_example.py', dest: 'ductape_example.py' },
-    go: { src: 'go/main.go', dest: 'ductape_example.go' },
-    dotnet: { src: 'dotnet/Program.cs', dest: 'DuctapeExample.cs' },
-    unknown: null,
-  };
-  const entry = map[lang];
-  if (!entry) return;
-  const srcPath = path.join(TEMPLATES_ROOT, entry.src);
-  const destPath = path.join(targetDir, entry.dest);
-  if (!fs.existsSync(destPath) && fs.existsSync(srcPath)) {
-    fs.copyFileSync(srcPath, destPath);
-  }
-}
-
-export function writeInitArtifacts(dir: string, lang: InitLanguage): void {
-  const envContent = `# Ductape — credentials from Workbench → SDK Access
-DUCTAPE_ACCESS_KEY=
-# Passed to new Ductape({ accessKey, product, env }) — constructor is the only place for product/env defaults
-DUCTAPE_PRODUCT=
-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');
-  fs.mkdirSync(ductapeDir, { recursive: true });
-
-  const readme = `# Ductape project
-
-Linked via \`ductape link\`. Manage resources with:
-
-\`\`\`bash
-ductape resources storage list
-ductape resources databases create -f database.json
-\`\`\`
-
-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');
-  if (fs.existsSync(gitignorePath)) {
-    const gi = fs.readFileSync(gitignorePath, 'utf8');
-    if (!gi.includes('.env') && !gi.includes('.env.local')) {
-      fs.appendFileSync(gitignorePath, '\n.env\n.env.local\n');
-    }
-  }
-}