@zintrust/core 0.1.40 → 0.1.42

package/src/cli/CLI.js

@@ -5,28 +5,51 @@
 import { AddCommand } from './commands/AddCommand.js';
 import { BroadcastWorkCommand } from './commands/BroadcastWorkCommand.js';
 import { ConfigCommand } from './commands/ConfigCommand.js';
+import { ContainerProxiesCommand } from './commands/ContainerProxiesCommand.js';
+import { ContainerWorkersCommand } from './commands/ContainerWorkersCommand.js';
 import { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from './commands/CreateCommand.js';
+import { D1LearnCommand } from './commands/D1LearnCommand.js';
 import { D1MigrateCommand } from './commands/D1MigrateCommand.js';
 import { DbSeedCommand } from './commands/DbSeedCommand.js';
 import { DebugCommand } from './commands/DebugCommand.js';
+import { DeployCommand } from './commands/DeployCommand.js';
+import { DeployContainerProxiesCommand } from './commands/DeployContainerProxiesCommand.js';
+import { DeployContainerWorkersCommand } from './commands/DeployContainerWorkersCommand.js';
+import { DoctorArchitectureCommand } from './commands/DoctorArchitectureCommand.js';
 import { FixCommand } from './commands/FixCommand.js';
+import { InitContainerCommand } from './commands/InitContainerCommand.js';
+import { InitEcosystemCommand } from './commands/InitEcosystemCommand.js';
+import { InitProducerCommand } from './commands/InitProducerCommand.js';
+import { InitProxyCommand } from './commands/InitProxyCommand.js';
 import { JwtDevCommand } from './commands/JwtDevCommand.js';
 import { KeyGenerateCommand } from './commands/KeyGenerateCommand.js';
 import { MakeMailTemplateCommand } from './commands/MakeMailTemplateCommand.js';
 import { MakeNotificationTemplateCommand } from './commands/MakeNotificationTemplateCommand.js';
 import { MigrateCommand } from './commands/MigrateCommand.js';
 import { MigrateWorkerCommand } from './commands/MigrateWorkerCommand.js';
+import { MongoDBProxyCommand } from './commands/MongoDBProxyCommand.js';
+import { MySqlProxyCommand } from './commands/MySqlProxyCommand.js';
 import { NewCommand } from './commands/NewCommand.js';
 import { NotificationWorkCommand } from './commands/NotificationWorkCommand.js';
 import { PluginCommand } from './commands/PluginCommand.js';
+import { PostgresProxyCommand } from './commands/PostgresProxyCommand.js';
 import { PrepareCommand } from './commands/PrepareCommand.js';
+import { ProxyCommand } from './commands/ProxyCommand.js';
 import { PublishCommand } from './commands/PublishCommand.js';
+import { PutCommand } from './commands/PutCommand.js';
 import { QACommand } from './commands/QACommand.js';
 import { QueueCommand } from './commands/QueueCommand.js';
+import { QueueRecoveryCommand } from './commands/QueueRecoveryCommand.js';
+import { RedisProxyCommand } from './commands/RedisProxyCommand.js';
 import { ResourceControlCommand } from './commands/ResourceControlCommand.js';
 import { RoutesCommand } from './commands/RoutesCommand.js';
+import { ScheduleListCommand } from './commands/ScheduleListCommand.js';
+import { ScheduleRunCommand } from './commands/ScheduleRunCommand.js';
+import { ScheduleStartCommand } from './commands/ScheduleStartCommand.js';
 import { SecretsCommand } from './commands/SecretsCommand.js';
 import { SimulateCommand } from './commands/SimulateCommand.js';
+import { SmtpProxyCommand } from './commands/SmtpProxyCommand.js';
+import { SqlServerProxyCommand } from './commands/SqlServerProxyCommand.js';
 import { StartCommand } from './commands/StartCommand.js';
 import { TemplatesCommand } from './commands/TemplatesCommand.js';
 import { UpgradeCommand } from './commands/UpgradeCommand.js';
@@ -40,60 +63,51 @@ import { readFileSync } from '../node-singletons/fs.js';
 import { join } from '../node-singletons/path.js';
 import { Command } from 'commander';
 const __dirname = esmDirname(import.meta.url);
-/**
- * Load version from package.json
- */
-const loadVersion = () => {
-    try {
-        const packagePath = join(__dirname, '../../package.json');
-        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
-        return typeof packageJson.version === 'string' ? packageJson.version : '1.0.0';
-    }
-    catch (error) {
-        ErrorFactory.createCliError('Failed to load version from package.json', error);
-        // Use default version if package.json not found
-        return '1.0.0';
-    }
-};
-/**
- * Setup program metadata
- */
-const setupProgram = (program, version) => {
-    program
-        .name('zintrust')
-        .description('ZinTrust Framework CLI - Build production-grade TypeScript APIs')
-        .version(version, '-v, --version', 'Output version number')
-        .helpOption('-h, --help', 'Display help for command')
-        .usage('[command] [options]');
-    // Global error handling
-    program.exitOverride();
+const isCommandProvider = (command) => {
+    return (typeof command === 'object' &&
+        command !== null &&
+        'getCommand' in command &&
+        typeof command.getCommand === 'function');
 };
-/**
- * Register all available commands
- */
-const registerCommands = (program) => {
-    const commands = [
+const buildCommandRegistry = () => {
+    return [
         NewCommand.create(),
         UpgradeCommand.create(),
         PrepareCommand,
+        InitContainerCommand.create(),
+        InitProxyCommand.create(),
+        InitProducerCommand.create(),
+        InitEcosystemCommand.create(),
+        DoctorArchitectureCommand.create(),
         AddCommand.create(),
         CreateCommand.create(),
         CreateMigrationCommand.create(),
         AddMigrationCommand.create(),
         StartCommand.create(),
         QueueCommand.create(),
+        QueueRecoveryCommand.create(),
+        ScheduleListCommand.create(),
+        ScheduleRunCommand.create(),
+        ScheduleStartCommand.create(),
         BroadcastWorkCommand.create(),
         NotificationWorkCommand.create(),
         ResourceControlCommand,
         MigrateWorkerCommand.create(),
         MigrateCommand.create(),
         DbSeedCommand.create(),
+        D1LearnCommand.create(),
         D1MigrateCommand.create(),
         DebugCommand.create(),
         SecretsCommand.create(),
         ConfigCommand.create(),
+        ContainerWorkersCommand.create(),
+        ContainerProxiesCommand.create(),
         PluginCommand.create(),
         PublishCommand.create(),
+        PutCommand.create(),
+        DeployCommand.create(),
+        DeployContainerWorkersCommand.create(),
+        DeployContainerProxiesCommand.create(),
         QACommand(),
         FixCommand.create(),
         KeyGenerateCommand.create(),
@@ -103,16 +117,62 @@ const registerCommands = (program) => {
         MakeNotificationTemplateCommand.create(),
         RoutesCommand.create(),
         JwtDevCommand,
-        // Worker management commands
+        ProxyCommand.create(),
+        MySqlProxyCommand.create(),
+        PostgresProxyCommand.create(),
+        MongoDBProxyCommand.create(),
+        SqlServerProxyCommand.create(),
+        RedisProxyCommand.create(),
+        SmtpProxyCommand.create(),
         WorkerCommands.createWorkerListCommand(),
         WorkerCommands.createWorkerStatusCommand(),
         WorkerCommands.createWorkerStartCommand(),
+        WorkerCommands.createWorkerStartAllCommand(),
         WorkerCommands.createWorkerStopCommand(),
         WorkerCommands.createWorkerRestartCommand(),
         WorkerCommands.createWorkerSummaryCommand(),
     ];
+};
+/**
+ * Load version from package.json
+ */
+const loadVersion = () => {
+    try {
+        const packagePath = join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : '1.0.0';
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Failed to load version from package.json', error);
+        // Use default version if package.json not found
+        return '1.0.0';
+    }
+};
+/**
+ * Setup program metadata
+ */
+const setupProgram = (program, version) => {
+    program
+        .name('zintrust')
+        .description('ZinTrust Framework CLI - Build production-grade TypeScript APIs')
+        .version(version, '-v, --version', 'Output version number')
+        .helpOption('-h, --help', 'Display help for command')
+        .usage('[command] [options]');
+    // Global error handling
+    program.exitOverride();
+};
+/**
+ * Register all available commands
+ */
+const registerCommands = (program) => {
+    const commands = buildCommandRegistry();
     for (const command of commands) {
-        program.addCommand(command.getCommand());
+        if (isCommandProvider(command)) {
+            program.addCommand(command.getCommand());
+        }
+        else {
+            program.addCommand(command);
+        }
     }
     // Help command
     program

package/src/cli/ErrorHandler.js

@@ -46,7 +46,7 @@ const displayBanner = (version) => {
     const framework = 'ZinTrust Framework';
     const bannerWidth = 46;
     const env = Env.NODE_ENV ?? 'development';
-    const db = Env.DB_CONNECTION ?? 'sqlite';
+    const db = Env.DB_CONNECTION || 'sqlite';
     const border = chalk.cyanBright;
     const label = chalk.bold.white;
     const frameworkValue = chalk.bold.cyanBright;

package/src/cli/commands/ConfigCommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConfigCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ConfigCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmVrE;;GAEG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;cACO,YAAY;EAsEtB,CAAC"}
+{"version":3,"file":"ConfigCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ConfigCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAiVrE;;GAEG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;cACO,YAAY;EAsEtB,CAAC"}

package/src/cli/commands/ConfigCommand.js

@@ -8,6 +8,7 @@ import { ConfigValidator } from '../config/ConfigValidator.js';
 import { ErrorHandler } from '../ErrorHandler.js';
 import { PromptHelper } from '../PromptHelper.js';
 import { Logger } from '../../config/logger.js';
+import { isArray, isObject } from '../../helper/index.js';
 import chalk from 'chalk';
 const addOptions = (command) => {
     command.argument('[action]', 'Action: get, set, list, reset, edit, export');
@@ -225,9 +226,8 @@ const handleEdit = async (cmd, manager) => {
 const handleExport = (cmd, manager) => {
     cmd.info(typeof manager.export === 'function' ? manager.export() : '{}');
 };
-const isUnknownArray = (value) => Array.isArray(value);
 const getArg = (args, index) => {
-    if (!isUnknownArray(args))
+    if (!isArray(args))
         return undefined;
     const value = args[index];
     return typeof value === 'string' ? value : undefined;
@@ -236,9 +236,7 @@ const executeConfig = async (cmd, options) => {
     const typedCmd = cmd;
     const command = cmd.getCommand();
     const toRecord = (value) => {
-        if (value === null || typeof value !== 'object' || Array.isArray(value))
-            return {};
-        return value;
+        return isObject(value) ? value : {};
     };
     const commandOpts = typeof command.opts === 'function' ? toRecord(command.opts()) : {};
     const mergedOptions = {

package/src/cli/commands/ContainerProxiesCommand.d.ts

@@ -0,0 +1,5 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const ContainerProxiesCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=ContainerProxiesCommand.d.ts.map

package/src/cli/commands/ContainerProxiesCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerProxiesCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ContainerProxiesCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAwErE,eAAO,MAAM,uBAAuB;cACxB,YAAY;EAuCtB,CAAC"}

package/src/cli/commands/ContainerProxiesCommand.js

@@ -0,0 +1,77 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveComposePath, runComposeWithFallback, } from '../commands/DockerComposeCommandUtils.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const runBuild = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'build'];
+    if (options.noCache === true) {
+        args.push('--no-cache');
+    }
+    if (options.pull === true) {
+        args.push('--pull');
+    }
+    Logger.info('Building proxy stack image...');
+    await runComposeWithFallback(args);
+};
+const runUp = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'up'];
+    if (options.detach === true) {
+        args.push('-d');
+    }
+    if (options.removeOrphans === true) {
+        args.push('--remove-orphans');
+    }
+    Logger.info('Starting proxy stack...');
+    await runComposeWithFallback(args);
+};
+const runDown = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'down'];
+    if (options.removeOrphans === true) {
+        args.push('--remove-orphans');
+    }
+    if (options.volumes === true) {
+        args.push('--volumes');
+    }
+    Logger.info('Stopping proxy stack...');
+    await runComposeWithFallback(args);
+};
+const normalizeAction = (raw) => {
+    const value = (raw ?? '').trim().toLowerCase();
+    if (value === 'build' || value === 'up' || value === 'down')
+        return value;
+    throw ErrorFactory.createCliError('Usage: zin cp <build|up|down> [options]');
+};
+export const ContainerProxiesCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'cp',
+            aliases: ['container-proxies'],
+            description: 'Build, start, or stop container-based proxy stack',
+            addOptions: (command) => {
+                command.argument('<action>', 'Action to run (build, up, down)');
+                command.option('-d, --detach', 'Run containers in background (up only)');
+                command.option('--no-cache', 'Disable Docker build cache (build only)');
+                command.option('--pull', 'Always attempt to pull a newer base image (build only)');
+                command.option('--build', 'Build before running up (up only)');
+                command.option('--remove-orphans', 'Remove containers for services not defined in compose');
+                command.option('--volumes', 'Remove named volumes when running down (down only)');
+            },
+            execute: async (options) => {
+                const action = normalizeAction(options.args?.[0]);
+                const composePath = resolveComposePath('docker-compose.proxy.yml', 'docker-compose.proxy.yml not found.');
+                if (action === 'build') {
+                    await runBuild(composePath, options);
+                    return;
+                }
+                if (action === 'down') {
+                    await runDown(composePath, options);
+                    return;
+                }
+                if (options.build === true) {
+                    await runBuild(composePath, options);
+                }
+                await runUp(composePath, options);
+            },
+        });
+    },
+});

package/src/cli/commands/ContainerWorkersCommand.d.ts

@@ -0,0 +1,5 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const ContainerWorkersCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=ContainerWorkersCommand.d.ts.map

package/src/cli/commands/ContainerWorkersCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerWorkersCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ContainerWorkersCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmDrE,eAAO,MAAM,uBAAuB;cACxB,YAAY;EAgCtB,CAAC"}

package/src/cli/commands/ContainerWorkersCommand.js

@@ -0,0 +1,57 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveComposePath, runComposeWithFallback, } from '../commands/DockerComposeCommandUtils.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const runBuild = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'build'];
+    if (options.noCache === true) {
+        args.push('--no-cache');
+    }
+    if (options.pull === true) {
+        args.push('--pull');
+    }
+    Logger.info('Building container workers image...');
+    await runComposeWithFallback(args);
+};
+const runUp = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'up'];
+    if (options.detach === true) {
+        args.push('-d');
+    }
+    Logger.info('Starting container workers...');
+    await runComposeWithFallback(args);
+};
+const normalizeAction = (raw) => {
+    const value = (raw ?? '').trim().toLowerCase();
+    if (value === 'build' || value === 'up')
+        return value;
+    throw ErrorFactory.createCliError('Usage: zin cw <build|up> [options]');
+};
+export const ContainerWorkersCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'cw',
+            aliases: ['container-workers'],
+            description: 'Build or start container-based workers',
+            addOptions: (command) => {
+                command.argument('<action>', 'Action to run (build or up)');
+                command.option('-d, --detach', 'Run containers in background (up only)');
+                command.option('--no-cache', 'Disable Docker build cache (build only)');
+                command.option('--pull', 'Always attempt to pull a newer base image (build only)');
+                command.option('--build', 'Build before running up (up only)');
+            },
+            execute: async (options) => {
+                const action = normalizeAction(options.args?.[0]);
+                const composePath = resolveComposePath('docker-compose.workers.yml', 'docker-compose.workers.yml not found. Run `zin init:cw` first.');
+                if (action === 'build') {
+                    await runBuild(composePath, options);
+                    return;
+                }
+                if (options.build === true) {
+                    await runBuild(composePath, options);
+                }
+                await runUp(composePath, options);
+            },
+        });
+    },
+});

package/src/cli/commands/D1LearnCommand.d.ts

@@ -0,0 +1,9 @@
+/**
+ * D1 Learn Command
+ * Runs a command in "learning mode" to capture D1 SQL statements for the registry.
+ */
+import { type IBaseCommand } from '../BaseCommand';
+export declare const D1LearnCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=D1LearnCommand.d.ts.map

package/src/cli/commands/D1LearnCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1LearnCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/D1LearnCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAgGvF,eAAO,MAAM,cAAc;cACf,YAAY;EAiEtB,CAAC"}

package/src/cli/commands/D1LearnCommand.js

@@ -0,0 +1,143 @@
+/**
+ * D1 Learn Command
+ * Runs a command in "learning mode" to capture D1 SQL statements for the registry.
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { isNonEmptyString, isObject } from '../../helper/index.js';
+import * as fs from '../../node-singletons/fs.js';
+import { StatementRegistryBuild } from '../../orm/SchemaStatemenWriter.js';
+import { spawn } from 'node:child_process';
+const LEARN_FILE = 'storage/d1-learned.jsonl';
+const isRecord = (value) => isObject(value);
+const coerceStringRegistry = (value) => {
+    if (!isRecord(value))
+        return {};
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (isNonEmptyString(v))
+            out[k] = v;
+    }
+    return out;
+};
+const readExistingRegistryFile = async (outputFile) => {
+    try {
+        await fs.stat(outputFile);
+        const existingContent = await fs.readFile(outputFile, 'utf-8');
+        const existingJson = JSON.parse(existingContent);
+        if (isRecord(existingJson) && 'queries' in existingJson) {
+            return coerceStringRegistry(existingJson['queries']);
+        }
+        return coerceStringRegistry(existingJson);
+    }
+    catch {
+        return {};
+    }
+};
+const cleanLearnFile = async () => {
+    try {
+        await fs.rm(LEARN_FILE, { force: true });
+    }
+    catch {
+        // ignore
+    }
+};
+const parseLearnedFile = async () => {
+    try {
+        const content = await fs.readFile(LEARN_FILE, 'utf-8');
+        return StatementRegistryBuild.fromJsonl(content);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+};
+const runLearner = async (cmd, args) => {
+    return new Promise((resolve, reject) => {
+        Logger.info(`Starting learner: ${cmd} ${args.join(' ')}`);
+        Logger.info(`Capturing queries to ${LEARN_FILE}...`);
+        const child = spawn(cmd, args, {
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ZT_D1_LEARN_FILE: LEARN_FILE,
+                D1_REMOTE_MODE: 'sql',
+            },
+        });
+        child.on('close', (code) => {
+            // Allow code 0 or 1 (tests fail sometimes but still run queries)
+            // Actually, we resolve regardless so we can harvest what ran
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                // We log error but resolve to process partial results
+                Logger.error(`Command exited with code ${code}`);
+                resolve();
+            }
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+};
+export const D1LearnCommand = Object.freeze({
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'd1:learn',
+            description: 'Run a command to learn D1 queries and generate a statement registry',
+            addOptions: (c) => {
+                c.argument('<command>', 'The command to run (e.g. "npm test")')
+                    .option('-o, --output <file>', 'Output JSON file (default: d1-statements.json)')
+                    .option('-a, --append', 'Append to existing output file instead of overwriting');
+            },
+            async execute(options) {
+                const learnOptions = options;
+                // In BaseCommand, positional arguments are stored in options.args array
+                // We defined .argument('<command>') so it's the first element.
+                const commandStr = options.args && options.args.length > 0 ? options.args[0] : '';
+                if (commandStr === '') {
+                    Logger.error('Missing command argument');
+                    return;
+                }
+                const outputFile = learnOptions.output ?? 'd1-statements.json';
+                const append = learnOptions.append === true;
+                // 1. Prepare
+                await cleanLearnFile();
+                const parts = commandStr.split(' ');
+                const cmdExe = parts[0];
+                const args = parts.slice(1);
+                // 2. Run command
+                try {
+                    await runLearner(cmdExe, args);
+                }
+                catch (err) {
+                    throw ErrorFactory.createCliError(`Learner failed to start: ${err.message}`);
+                }
+                // 3. Process results
+                const learned = await parseLearnedFile();
+                const count = Object.keys(learned).length;
+                if (count === 0) {
+                    Logger.warn('No D1 queries were captured.');
+                    return;
+                }
+                Logger.info(`Captured ${count} unique queries.`);
+                // 4. Merge with existing if needed
+                let finalMap = learned;
+                if (append) {
+                    const existingMap = await readExistingRegistryFile(outputFile);
+                    finalMap = StatementRegistryBuild.merge(existingMap, learned);
+                }
+                // 5. Output
+                // One-line JSON is easiest to paste into `wrangler secret put ZT_D1_STATEMENTS_JSON`.
+                const outputContent = StatementRegistryBuild.toStatementsJson(finalMap);
+                await fs.writeFile(outputFile, outputContent);
+                Logger.info(`Registry written to ${outputFile}`);
+            },
+        });
+        return cmd;
+    },
+});

package/src/cli/commands/D1MigrateCommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"D1MigrateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/D1MigrateCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAyDrE;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;cACO,YAAY;EAwBtB,CAAC"}
+{"version":3,"file":"D1MigrateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/D1MigrateCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA8GrE;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;cACO,YAAY;EAyBtB,CAAC"}