@ductape/cli 0.2.0 → 0.2.1

package/dist/commands/install.js

@@ -1,13 +1,37 @@
-import { spawnSync } from 'node:child_process';
+import { spawnSync, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { resolvePlatformDir } from '../lib/config.js';
+import { fileURLToPath } from 'node:url';
+import { HUB_PLATFORM_DIR } from '../lib/config.js';
 import { success } from '../lib/output.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = path.resolve(__dirname, '../../templates');
+const HUB_IMAGES = [
+    'ductape/platform-api:latest',
+    'ductape/platform-workbench:latest',
+];
 function checkCommand(cmd, args) {
     const r = spawnSync(cmd, args, { stdio: 'ignore' });
     return r.status === 0;
 }
-export function runInstall() {
+function pull(image) {
+    return new Promise((resolve, reject) => {
+        console.log(`Pulling ${image} …`);
+        const child = spawn('docker', ['pull', image], {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+function copyTemplate(name, dest, overwrite = false) {
+    const src = path.join(TEMPLATES_DIR, name);
+    if (!overwrite && fs.existsSync(dest))
+        return;
+    fs.copyFileSync(src, dest);
+}
+export async function runInstall() {
     const issues = [];
     if (!checkCommand('docker', ['--version'])) {
         issues.push('Docker is not installed or not on PATH');
@@ -15,28 +39,28 @@ export function runInstall() {
     else if (!checkCommand('docker', ['compose', 'version'])) {
         issues.push('Docker Compose v2 is required (docker compose)');
     }
-    if (!checkCommand('node', ['--version'])) {
-        issues.push('Node.js 18+ is recommended for running the CLI');
-    }
-    let platformDir;
-    try {
-        platformDir = resolvePlatformDir();
-    }
-    catch (e) {
-        issues.push(e instanceof Error ? e.message : String(e));
-        platformDir = '';
-    }
-    if (platformDir) {
-        const envExample = path.join(platformDir, '.env.example');
-        const envFile = path.join(platformDir, '.env');
-        if (fs.existsSync(envExample) && !fs.existsSync(envFile)) {
-            fs.copyFileSync(envExample, envFile);
-            success(`Created ${envFile} from .env.example`);
-        }
-    }
     if (issues.length > 0) {
         console.error('Install check failed:\n' + issues.map((i) => `  - ${i}`).join('\n'));
         process.exit(1);
     }
-    success('Prerequisites OK. Run `ductape start` to launch the local platform.');
+    // Pull platform images from Docker Hub
+    for (const image of HUB_IMAGES) {
+        const code = await pull(image);
+        if (code !== 0) {
+            console.error(`Failed to pull ${image} (exit ${code}). Check your internet connection or run \`docker login\`.`);
+            process.exit(1);
+        }
+    }
+    // Write platform files to ~/.ductape/platform/
+    fs.mkdirSync(HUB_PLATFORM_DIR, { recursive: true });
+    copyTemplate('docker-compose.release.yml', path.join(HUB_PLATFORM_DIR, 'docker-compose.yml'), true);
+    copyTemplate('api-gateway.conf', path.join(HUB_PLATFORM_DIR, 'api-gateway.conf'), true);
+    copyTemplate('platform.env', path.join(HUB_PLATFORM_DIR, '.env'), false); // don't overwrite existing .env
+    success(`Platform installed to ${HUB_PLATFORM_DIR}`);
+    console.log('');
+    console.log('  Edit ~/.ductape/platform/.env to add your AWS credentials (needed for cloud connections).');
+    console.log('  Then run:  ductape start');
+    console.log('');
+    console.log('  Workbench:  http://localhost:4310');
+    console.log('  API:        http://localhost:4311');
 }

package/dist/index.js

@@ -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 { runWorkspacesCurrent, runWorkspacesList, runWorkspacesRefresh, runWorkspacesUse, } from './commands/workspaces.js';
@@ -23,6 +25,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 } from './commands/apply.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -140,6 +143,18 @@ program
     env: opts.env,
     language: opts.language,
 })));
+const APPLY_TYPES = ['sessions', 'notifications', 'events'];
+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, opts) => {
+    if (type && !APPLY_TYPES.includes(type)) {
+        throw new Error(`Unknown type "${type}". Use: ${APPLY_TYPES.join(', ')}`);
+    }
+    return runApply(type, { dryRun: Boolean(opts.dryRun) });
+}));
 program
     .command('start')
     .description('Start platform via docker compose')
@@ -155,10 +170,8 @@ program.command('stop').action(wrap(runStop));
 program.command('status').option('--json', 'JSON output').action(wrap((opts) => runStatus(Boolean(opts.json))));
 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)')
@@ -167,7 +180,11 @@ products
     .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, opts) => runProducts(verb, opts, [])));
+    .action(wrap((verb, 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');
 productApps
     .command('list')
@@ -175,10 +192,10 @@ productApps
     .option('--product <id>', 'Product _id')
     .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')
@@ -188,7 +205,11 @@ 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, opts) => runApps(verb, opts, [])));
+    .action(wrap((verb, opts) => {
+    if (!verb)
+        throw new Error('Specify a verb: list | get | create | update | delete');
+    return runApps(verb, opts, []);
+}));
 apps
     .command('import <file>')
     .description('Import Postman v2.1 or OpenAPI 3.0 into a new or existing app')
@@ -211,7 +232,8 @@ apps
 const resources = program.command('resources').description('Component CRUD (sdk-proxy)');
 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)')
@@ -231,14 +253,46 @@ cloud
     .action(wrap((verb, opts) => runCloud('resources', verb, { file: opts.file, json: opts.json }, [])));
 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, opts) => runDb(verb, { file: opts.file, json: opts.json })));
+    .action(wrap((verb, 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, opts) => runGraph(verb, { file: opts.file, json: opts.json })));

package/dist/lib/apply-loaders.d.ts

@@ -0,0 +1,6 @@
+export type ApplyItem = Record<string, unknown> & {
+    tag: string;
+};
+export declare function loadSessions(projectDir: string): ApplyItem[] | null;
+export declare function loadNotifications(projectDir: string): ApplyItem[] | null;
+export declare function loadEvents(projectDir: string): ApplyItem[] | null;

package/dist/lib/apply-loaders.js

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

package/dist/lib/config.d.ts

@@ -1,7 +1,8 @@
 export declare const GLOBAL_DIR: string;
 export declare const CREDENTIALS_PATH: string;
 export declare const GLOBAL_CONFIG_PATH: string;
-export declare const PROJECT_CONFIG_DIR = ".ductape";
+export declare const HUB_PLATFORM_DIR: string;
+export declare const PROJECT_CONFIG_DIR = "ductape";
 export declare const PROJECT_CONFIG_PATH: string;
 export interface Credentials {
     user_id: string;

package/dist/lib/config.js

@@ -6,7 +6,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');
 const DEFAULT_GLOBAL = {
     default_profile: 'cloud',
@@ -133,7 +134,7 @@ export function loadProjectConfig() {
     const cfg = { ...found.config };
     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`.');
+        throw new Error('No workspace resolved. Set workspace_tag in ductape/config.json or run `ductape workspaces use`.');
     }
     return { ...cfg, workspace_id };
 }
@@ -146,10 +147,14 @@ export function resolvePlatformDir() {
     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');
+    throw new Error('Platform not installed. Run `ductape install` to pull the platform from Docker Hub.');
 }

package/dist/lib/db-types.d.ts

@@ -0,0 +1,71 @@
+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/dist/lib/db-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/migration-files.d.ts

@@ -0,0 +1,4 @@
+import type { IMigration } from './db-types.js';
+export declare function getMigrationsDir(projectDir: string, dbTag: string): string;
+export declare function loadMigrationFiles(projectDir: string, dbTag: string): IMigration[];
+export declare function writeMigrationFile(projectDir: string, dbTag: string, migration: IMigration, counter: number): string;

package/dist/lib/migration-files.js

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROJECT_CONFIG_DIR } from './config.js';
+export function getMigrationsDir(projectDir, dbTag) {
+    return path.join(projectDir, PROJECT_CONFIG_DIR, 'database', 'migrations', dbTag);
+}
+export function loadMigrationFiles(projectDir, dbTag) {
+    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'));
+        return raw;
+    });
+}
+function makeTimestamp(counter) {
+    const now = new Date();
+    const pad = (n, 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, dbTag, migration, counter) {
+    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/dist/lib/resources.js

@@ -17,6 +17,8 @@ export const RESOURCE_MODULES = {
     actions: 'actions',
     notification: 'notifications',
     notifications: 'notifications',
+    event: 'messageBrokers',
+    events: 'messageBrokers',
     broker: 'messageBrokers',
     brokers: 'messageBrokers',
     'message-brokers': 'messageBrokers',
@@ -135,7 +137,7 @@ export function listResourceTypes() {
         'features',
         'actions',
         'notifications',
-        'message-brokers',
+        'events',
         'sessions',
         'secrets',
         'quotas',

package/dist/lib/schema-loader.d.ts

@@ -0,0 +1,30 @@
+import type { 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 declare function getSchemaPath(projectDir: string): string;
+export declare function loadSchemaFile(projectDir: string): SchemaEntry[];
+export declare function parseField(name: string, def: MongooseFieldDef): IFieldDefinition;
+export interface ParsedTable {
+    name: string;
+    fields: IFieldDefinition[];
+    indexFields: Array<{
+        fieldName: string;
+        unique: boolean;
+    }>;
+}
+export declare function parseTableDef(tableName: string, fieldDefs: Record<string, MongooseFieldDef>): ParsedTable;

package/dist/lib/schema-loader.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROJECT_CONFIG_DIR } from './config.js';
+export function getSchemaPath(projectDir) {
+    return path.join(projectDir, PROJECT_CONFIG_DIR, 'database', 'schema.json');
+}
+export function loadSchemaFile(projectDir) {
+    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'));
+    if (!Array.isArray(raw)) {
+        throw new Error('schema.json must be a JSON array of { db, tables } objects.');
+    }
+    return raw;
+}
+const TYPE_MAP = {
+    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, def) {
+    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, def) {
+    const type = resolveBaseType(def.type, def);
+    const field = { 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 function parseTableDef(tableName, fieldDefs) {
+    const fields = [];
+    const indexFields = [];
+    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 };
+}