@ductape/cli 0.2.5 → 0.2.6

package/dist/commands/db-schema.js

@@ -1,8 +1,10 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { findProjectConfig } from '../lib/config.js';
-import { loadSchemaFile, parseTableDef } from '../lib/schema-loader.js';
+import { loadSchemaFile, getSchemaPath, parseTableDef } from '../lib/schema-loader.js';
 import { loadMigrationFiles, writeMigrationFile } from '../lib/migration-files.js';
 import { fail } from '../lib/output.js';
+import { getDbProxy, requireSession } from '../lib/proxy/context.js';
 function replayMigrations(migrations) {
     const schema = new Map();
     for (const migration of migrations) {
@@ -29,16 +31,211 @@ function replayMigrations(migrations) {
     }
     return schema;
 }
+function columnTypeToMongooseType(raw) {
+    // Normalise: uppercase, collapse whitespace (handles "character varying", "timestamp without time zone", etc.)
+    const t = raw.toUpperCase().replace(/\s+/g, ' ').trim();
+    switch (t) {
+        case 'BIGINT':
+        case 'INT8': return 'bigint';
+        case 'SMALLINT':
+        case 'TINYINT':
+        case 'INT2': return 'smallint';
+        case 'INTEGER':
+        case 'INT':
+        case 'INT4':
+        case 'NUMBER': return 'number';
+        case 'FLOAT':
+        case 'REAL':
+        case 'FLOAT4':
+        case 'FLOAT8':
+        case 'DOUBLE PRECISION': return 'number'; // caller sets float:true
+        case 'DOUBLE': return 'double';
+        case 'DECIMAL':
+        case 'NUMERIC':
+        case 'DECIMAL128': return 'decimal';
+        case 'TEXT':
+        case 'MEDIUMTEXT':
+        case 'LONGTEXT':
+        case 'TINYTEXT': return 'text';
+        case 'STRING':
+        case 'VARCHAR':
+        case 'CHARACTER VARYING':
+        case 'CHAR':
+        case 'CHARACTER':
+        case 'BPCHAR': return 'string';
+        case 'BOOLEAN':
+        case 'BOOL': return 'boolean';
+        case 'DATE':
+        case 'DATETIME': return 'date';
+        case 'TIME':
+        case 'TIME WITHOUT TIME ZONE':
+        case 'TIME WITH TIME ZONE': return 'time';
+        case 'TIMESTAMP':
+        case 'TIMESTAMPTZ':
+        case 'TIMESTAMP WITHOUT TIME ZONE':
+        case 'TIMESTAMP WITH TIME ZONE': return 'timestamp';
+        case 'JSON':
+        case 'JSONB': return 'json';
+        case 'BINARY':
+        case 'VARBINARY':
+        case 'BYTEA': return 'binary';
+        case 'BLOB':
+        case 'MEDIUMBLOB':
+        case 'LONGBLOB':
+        case 'TINYBLOB': return 'blob';
+        case 'UUID':
+        case 'OBJECTID': return 'uuid';
+        case 'OBJECT':
+        case 'MIXED':
+        case 'MAP':
+        case 'HSTORE': return 'mixed';
+        case 'ARRAY': return 'array';
+        default: return 'string';
+    }
+}
+function buildMongooseFieldDef(col) {
+    const rawType = String(col.type ?? 'string');
+    const mongooseType = columnTypeToMongooseType(rawType);
+    const def = { type: mongooseType };
+    const upperType = rawType.toUpperCase().trim();
+    if (upperType === 'FLOAT' || upperType === 'REAL' || upperType === 'FLOAT4' || upperType === 'FLOAT8' || upperType === 'DOUBLE PRECISION')
+        def.float = true;
+    // Handle both IColumnDefinition style (primaryKey/unique) and IColumnInfo style (isPrimaryKey/isUnique)
+    if (col.nullable === false || col.required === true)
+        def.required = true;
+    if (col.unique === true || col.isUnique === true)
+        def.unique = true;
+    if (col.primaryKey === true || col.isPrimaryKey === true)
+        def.primaryKey = true;
+    if (col.autoIncrement === true || col.isAutoIncrement === true || col.autoGenerate === true)
+        def.autoGenerate = true;
+    // Handle both camelCase (defaultValue) and snake_case (default_value) from different adapters
+    const defVal = col.defaultValue ?? col.default_value;
+    if (defVal !== undefined && defVal !== null)
+        def.default = defVal;
+    // Handle both camelCase (length/maxLength) and snake_case (max_length) from different adapters
+    const len = col.length ?? col.maxLength ?? col.max_length;
+    if (typeof len === 'number')
+        def.maxlength = len;
+    if (Array.isArray(col.enumValues) && col.enumValues.length > 0) {
+        def.type = 'string';
+        def.enum = col.enumValues;
+    }
+    return def;
+}
+async function tryHydrateFromCloud(dir, schemaPath, opts) {
+    if (!opts.db)
+        return [];
+    let session;
+    try {
+        session = requireSession();
+    }
+    catch {
+        return [];
+    }
+    const proxy = getDbProxy(session);
+    const envSlug = session.project.env_slug;
+    const productTag = session.project.product_tag;
+    const dbContext = { database: opts.db, env: envSlug, product: productTag };
+    let tableNames = [];
+    try {
+        const raw = await proxy.execute('schema.list', [null], dbContext);
+        if (Array.isArray(raw)) {
+            tableNames = raw.map((r) => typeof r === 'string' ? r : typeof r.name === 'string' ? String(r.name) : null).filter((n) => n !== null);
+        }
+    }
+    catch {
+        return [];
+    }
+    if (tableNames.length === 0)
+        return [];
+    const tables = {};
+    for (const tableName of tableNames) {
+        try {
+            const tableSchema = await proxy.execute('schema.describe', [tableName], dbContext);
+            const cols = Array.isArray(tableSchema?.columns)
+                ? tableSchema.columns
+                : Array.isArray(tableSchema)
+                    ? tableSchema
+                    : [];
+            if (cols.length === 0) {
+                tables[tableName] = {};
+                continue;
+            }
+            const indexedFields = new Set();
+            const uniqueIndexFields = new Set();
+            const rawIndexes = tableSchema?.indexes;
+            if (Array.isArray(rawIndexes)) {
+                for (const idx of rawIndexes) {
+                    const idxCols = Array.isArray(idx.columns) ? idx.columns : [];
+                    if (idxCols.length === 1) {
+                        const fieldName = String(idxCols[0].name ?? idxCols[0]);
+                        if (idx.unique)
+                            uniqueIndexFields.add(fieldName);
+                        else
+                            indexedFields.add(fieldName);
+                    }
+                }
+            }
+            const fieldMap = {};
+            for (const col of cols) {
+                const name = String(col.name ?? '');
+                if (!name)
+                    continue;
+                const def = buildMongooseFieldDef(col);
+                if (uniqueIndexFields.has(name)) {
+                    def.unique = true;
+                    def.index = true;
+                }
+                else if (indexedFields.has(name))
+                    def.index = true;
+                fieldMap[name] = def;
+            }
+            tables[tableName] = fieldMap;
+        }
+        catch {
+            tables[tableName] = {};
+        }
+    }
+    const entry = { db: opts.db, tables };
+    const entries = [entry];
+    fs.writeFileSync(schemaPath, JSON.stringify(entries, null, 2), 'utf8');
+    console.log(`[${opts.db}] Hydrated schema.json from cloud (${tableNames.length} collection(s)): ${tableNames.join(', ')}`);
+    return entries;
+}
 export async function runDbSchemaGenerate(opts) {
     const found = findProjectConfig();
     if (!found)
         fail('No linked project. Run `ductape link` from your project directory.');
     const { dir } = found;
-    const schemaEntries = loadSchemaFile(dir);
+    const schemaPath = getSchemaPath(dir);
+    let schemaEntries;
+    let wasScaffolded = false;
+    if (!fs.existsSync(schemaPath)) {
+        // Create directory and empty schema.json first
+        fs.mkdirSync(path.dirname(schemaPath), { recursive: true });
+        fs.writeFileSync(schemaPath, '[]', 'utf8');
+        wasScaffolded = true;
+        console.log(`Created ${path.relative(dir, schemaPath)}`);
+        // Try to hydrate from the cloud (requires --db and an active session)
+        schemaEntries = await tryHydrateFromCloud(dir, schemaPath, opts);
+        if (schemaEntries.length === 0) {
+            const hint = opts.db
+                ? `(no existing collections found in "${opts.db}" for env "${requireSilent()?.project?.env_slug ?? 'default'}")`
+                : '(pass --db <tag> to auto-import existing collections from the cloud)';
+            console.log(`schema.json is empty ${hint}. Add your collection definitions and run \`ductape db schema generate\` again.`);
+            return;
+        }
+    }
+    else {
+        schemaEntries = loadSchemaFile(dir);
+    }
     const targets = opts.db
         ? schemaEntries.filter((e) => e.db === opts.db)
         : schemaEntries;
     if (targets.length === 0) {
+        if (wasScaffolded)
+            return; // already printed a message above
         fail(opts.db ? `No db entry found for tag "${opts.db}".` : 'schema.json is empty.');
     }
     let totalGenerated = 0;
@@ -133,3 +330,11 @@ export async function runDbSchemaGenerate(opts) {
         console.log(`\nGenerated ${totalGenerated} migration file(s). Run \`ductape db migrate\` to apply them.`);
     }
 }
+function requireSilent() {
+    try {
+        return requireSession();
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/db-schema.ts

@@ -1,8 +1,11 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { findProjectConfig } from '../lib/config.js';
-import { loadSchemaFile, parseTableDef } from '../lib/schema-loader.js';
+import { loadSchemaFile, getSchemaPath, parseTableDef } from '../lib/schema-loader.js';
 import { loadMigrationFiles, writeMigrationFile } from '../lib/migration-files.js';
 import { fail } from '../lib/output.js';
+import { getDbProxy, requireSession } from '../lib/proxy/context.js';
+import type { SchemaEntry, MongooseFieldDef } from '../lib/schema-loader.js';
 import type {
   IMigration,
   IMigrationOperation,
@@ -43,17 +46,184 @@ function replayMigrations(migrations: IMigration[]): Map<string, ReconstructedTa
   return schema;
 }
 
+function columnTypeToMongooseType(raw: string): string {
+  // Normalise: uppercase, collapse whitespace (handles "character varying", "timestamp without time zone", etc.)
+  const t = raw.toUpperCase().replace(/\s+/g, ' ').trim();
+  switch (t) {
+    case 'BIGINT': case 'INT8': return 'bigint';
+    case 'SMALLINT': case 'TINYINT': case 'INT2': return 'smallint';
+    case 'INTEGER': case 'INT': case 'INT4': case 'NUMBER': return 'number';
+    case 'FLOAT': case 'REAL': case 'FLOAT4': case 'FLOAT8': case 'DOUBLE PRECISION': return 'number'; // caller sets float:true
+    case 'DOUBLE': return 'double';
+    case 'DECIMAL': case 'NUMERIC': case 'DECIMAL128': return 'decimal';
+    case 'TEXT': case 'MEDIUMTEXT': case 'LONGTEXT': case 'TINYTEXT': return 'text';
+    case 'STRING': case 'VARCHAR': case 'CHARACTER VARYING': case 'CHAR': case 'CHARACTER': case 'BPCHAR': return 'string';
+    case 'BOOLEAN': case 'BOOL': return 'boolean';
+    case 'DATE': case 'DATETIME': return 'date';
+    case 'TIME': case 'TIME WITHOUT TIME ZONE': case 'TIME WITH TIME ZONE': return 'time';
+    case 'TIMESTAMP': case 'TIMESTAMPTZ': case 'TIMESTAMP WITHOUT TIME ZONE': case 'TIMESTAMP WITH TIME ZONE': return 'timestamp';
+    case 'JSON': case 'JSONB': return 'json';
+    case 'BINARY': case 'VARBINARY': case 'BYTEA': return 'binary';
+    case 'BLOB': case 'MEDIUMBLOB': case 'LONGBLOB': case 'TINYBLOB': return 'blob';
+    case 'UUID': case 'OBJECTID': return 'uuid';
+    case 'OBJECT': case 'MIXED': case 'MAP': case 'HSTORE': return 'mixed';
+    case 'ARRAY': return 'array';
+    default: return 'string';
+  }
+}
+
+function buildMongooseFieldDef(col: Record<string, unknown>): MongooseFieldDef {
+  const rawType = String(col.type ?? 'string');
+  const mongooseType = columnTypeToMongooseType(rawType);
+  const def: MongooseFieldDef = { type: mongooseType };
+
+  const upperType = rawType.toUpperCase().trim();
+  if (upperType === 'FLOAT' || upperType === 'REAL' || upperType === 'FLOAT4' || upperType === 'FLOAT8' || upperType === 'DOUBLE PRECISION') def.float = true;
+
+  // Handle both IColumnDefinition style (primaryKey/unique) and IColumnInfo style (isPrimaryKey/isUnique)
+  if (col.nullable === false || col.required === true) def.required = true;
+  if (col.unique === true || col.isUnique === true) def.unique = true;
+  if (col.primaryKey === true || col.isPrimaryKey === true) def.primaryKey = true;
+  if (col.autoIncrement === true || col.isAutoIncrement === true || col.autoGenerate === true) def.autoGenerate = true;
+
+  // Handle both camelCase (defaultValue) and snake_case (default_value) from different adapters
+  const defVal = col.defaultValue ?? col.default_value;
+  if (defVal !== undefined && defVal !== null) def.default = defVal as unknown;
+
+  // Handle both camelCase (length/maxLength) and snake_case (max_length) from different adapters
+  const len = col.length ?? col.maxLength ?? col.max_length;
+  if (typeof len === 'number') def.maxlength = len;
+
+  if (Array.isArray(col.enumValues) && (col.enumValues as string[]).length > 0) {
+    def.type = 'string';
+    def.enum = col.enumValues as string[];
+  }
+
+  return def;
+}
+
+async function tryHydrateFromCloud(
+  dir: string,
+  schemaPath: string,
+  opts: SchemaGenerateOpts,
+): Promise<SchemaEntry[]> {
+  if (!opts.db) return [];
+
+  let session: ReturnType<typeof requireSession>;
+  try {
+    session = requireSession();
+  } catch {
+    return [];
+  }
+
+  const proxy = getDbProxy(session);
+  const envSlug = session.project.env_slug;
+  const productTag = session.project.product_tag;
+  const dbContext = { database: opts.db, env: envSlug, product: productTag };
+
+  let tableNames: string[] = [];
+  try {
+    const raw = await proxy.execute<unknown>('schema.list', [null], dbContext);
+    if (Array.isArray(raw)) {
+      tableNames = (raw as unknown[]).map((r) =>
+        typeof r === 'string' ? r : typeof (r as Record<string, unknown>).name === 'string' ? String((r as Record<string, unknown>).name) : null,
+      ).filter((n): n is string => n !== null);
+    }
+  } catch {
+    return [];
+  }
+
+  if (tableNames.length === 0) return [];
+
+  const tables: Record<string, Record<string, MongooseFieldDef>> = {};
+
+  for (const tableName of tableNames) {
+    try {
+      const tableSchema = await proxy.execute<unknown>('schema.describe', [tableName], dbContext);
+      const cols: unknown[] = Array.isArray((tableSchema as Record<string, unknown>)?.columns)
+        ? ((tableSchema as Record<string, unknown>).columns as unknown[])
+        : Array.isArray(tableSchema)
+          ? (tableSchema as unknown[])
+          : [];
+
+      if (cols.length === 0) {
+        tables[tableName] = {};
+        continue;
+      }
+
+      const indexedFields = new Set<string>();
+      const uniqueIndexFields = new Set<string>();
+      const rawIndexes = (tableSchema as Record<string, unknown>)?.indexes;
+      if (Array.isArray(rawIndexes)) {
+        for (const idx of rawIndexes as Record<string, unknown>[]) {
+          const idxCols = Array.isArray(idx.columns) ? (idx.columns as Record<string, unknown>[]) : [];
+          if (idxCols.length === 1) {
+            const fieldName = String(idxCols[0].name ?? idxCols[0]);
+            if (idx.unique) uniqueIndexFields.add(fieldName);
+            else indexedFields.add(fieldName);
+          }
+        }
+      }
+
+      const fieldMap: Record<string, MongooseFieldDef> = {};
+      for (const col of cols as Record<string, unknown>[]) {
+        const name = String(col.name ?? '');
+        if (!name) continue;
+        const def = buildMongooseFieldDef(col);
+        if (uniqueIndexFields.has(name)) { def.unique = true; def.index = true; }
+        else if (indexedFields.has(name)) def.index = true;
+        fieldMap[name] = def;
+      }
+      tables[tableName] = fieldMap;
+    } catch {
+      tables[tableName] = {};
+    }
+  }
+
+  const entry: SchemaEntry = { db: opts.db, tables };
+  const entries = [entry];
+  fs.writeFileSync(schemaPath, JSON.stringify(entries, null, 2), 'utf8');
+  console.log(`[${opts.db}] Hydrated schema.json from cloud (${tableNames.length} collection(s)): ${tableNames.join(', ')}`);
+  return entries;
+}
+
 export async function runDbSchemaGenerate(opts: SchemaGenerateOpts): Promise<void> {
   const found = findProjectConfig();
   if (!found) fail('No linked project. Run `ductape link` from your project directory.');
 
   const { dir } = found;
-  const schemaEntries = loadSchemaFile(dir);
+  const schemaPath = getSchemaPath(dir);
+
+  let schemaEntries: SchemaEntry[];
+  let wasScaffolded = false;
+
+  if (!fs.existsSync(schemaPath)) {
+    // Create directory and empty schema.json first
+    fs.mkdirSync(path.dirname(schemaPath), { recursive: true });
+    fs.writeFileSync(schemaPath, '[]', 'utf8');
+    wasScaffolded = true;
+    console.log(`Created ${path.relative(dir, schemaPath)}`);
+
+    // Try to hydrate from the cloud (requires --db and an active session)
+    schemaEntries = await tryHydrateFromCloud(dir, schemaPath, opts);
+
+    if (schemaEntries.length === 0) {
+      const hint = opts.db
+        ? `(no existing collections found in "${opts.db}" for env "${requireSilent()?.project?.env_slug ?? 'default'}")`
+        : '(pass --db <tag> to auto-import existing collections from the cloud)';
+      console.log(`schema.json is empty ${hint}. Add your collection definitions and run \`ductape db schema generate\` again.`);
+      return;
+    }
+  } else {
+    schemaEntries = loadSchemaFile(dir);
+  }
+
   const targets = opts.db
     ? schemaEntries.filter((e) => e.db === opts.db)
     : schemaEntries;
 
   if (targets.length === 0) {
+    if (wasScaffolded) return; // already printed a message above
     fail(opts.db ? `No db entry found for tag "${opts.db}".` : 'schema.json is empty.');
   }
 
@@ -161,3 +331,7 @@ export async function runDbSchemaGenerate(opts: SchemaGenerateOpts): Promise<voi
     console.log(`\nGenerated ${totalGenerated} migration file(s). Run \`ductape db migrate\` to apply them.`);
   }
 }
+
+function requireSilent(): ReturnType<typeof requireSession> | null {
+  try { return requireSession(); } catch { return null; }
+}