@zintrust/core 0.1.41 → 0.1.43

package/src/cache/drivers/RedisDriver.js

@@ -2,40 +2,235 @@
  * Redis Cache Driver
  * Zero-dependency implementation using Node.js native net module
  */
+import { Cloudflare } from '../../config/cloudflare.js';
 import { Env } from '../../config/env.js';
 import { Logger } from '../../config/logger.js';
+import { createRedisConnection } from '../../config/workers.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import * as net from '../../node-singletons/net.js';
 import { RedisKeys } from '../../tools/redis/RedisKeyManager.js';
-/**
- * Create a new Redis driver instance
- */
-const create = () => {
+const listenPreferOnce = (socket, event, cb) => {
+    if (typeof socket.once === 'function') {
+        socket.once(event, cb);
+        return;
+    }
+    socket.on?.(event, cb);
+};
+const listenPreferOn = (socket, event, cb) => {
+    if (typeof socket.on === 'function') {
+        socket.on(event, cb);
+        return;
+    }
+    socket.once?.(event, cb);
+};
+const hasToString = (value) => {
+    if (value === null || value === undefined)
+        return false;
+    return typeof value.toString === 'function';
+};
+const createIoredisClient = (params) => {
+    if (String(Env.NODE_ENV ?? '').startsWith('test'))
+        return null;
+    try {
+        const db = Env.getInt('REDIS_CACHE_DB', Env.getInt('REDIS_QUEUE_DB', 0));
+        const client = createRedisConnection({
+            host: Env.REDIS_HOST,
+            port: Env.REDIS_PORT,
+            password: Env.get('REDIS_PASSWORD', ''),
+            db,
+        }, 3);
+        return client !== null && typeof client.get === 'function' ? client : null;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (params.isWorkersRuntime || params.wantsProxy) {
+            Logger.error('Redis cache driver initialization failed', { error: msg });
+            throw error;
+        }
+        Logger.warn('Redis cache driver falling back to TCP socket implementation', {
+            error: msg,
+        });
+        return null;
+    }
+};
+const createCacheDriverFromIoredisClient = (client) => ({
+    async get(key) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            const value = await client.get(prefixedKey);
+            if (value === null)
+                return null;
+            return JSON.parse(value);
+        }
+        catch (error) {
+            Logger.error('Redis GET failed', error);
+            return null;
+        }
+    },
+    async set(key, value, ttl) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            const jsonValue = JSON.stringify(value);
+            if (ttl === undefined) {
+                await client.set(prefixedKey, jsonValue);
+                return;
+            }
+            await client.set(prefixedKey, jsonValue, 'EX', ttl);
+        }
+        catch (error) {
+            Logger.error('Redis SET failed', error);
+        }
+    },
+    async delete(key) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            await client.del(prefixedKey);
+        }
+        catch (error) {
+            Logger.error('Redis DEL failed', error);
+        }
+    },
+    async clear() {
+        try {
+            await client.flushdb();
+        }
+        catch (error) {
+            Logger.error('Redis FLUSHDB failed', error);
+        }
+    },
+    async has(key) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            const out = await client.exists(prefixedKey);
+            return out > 0;
+        }
+        catch (error) {
+            Logger.error('Redis EXISTS failed', error);
+            return false;
+        }
+    },
+});
+const createIoredisCacheDriver = (params) => {
+    const client = createIoredisClient(params);
+    return client === null ? null : createCacheDriverFromIoredisClient(client);
+};
+const createTcpConnect = (params) => {
     let client = null;
-    const host = Env.REDIS_HOST;
-    const port = Env.REDIS_PORT;
-    const connect = async () => {
+    return async () => {
         if (client && !client.destroyed)
             return client;
         return new Promise((resolve, reject) => {
-            const socket = net.connect(port, host, () => {
-                client = socket;
-                resolve(socket);
-            });
-            socket.on('error', (err) => {
+            const onTimeout = () => {
+                cleanup();
+                try {
+                    socket.destroy?.();
+                }
+                catch {
+                    /* ignore */
+                }
+                reject(ErrorFactory.createConnectionError('Redis connection timeout', {
+                    host: params.host,
+                    port: params.port,
+                    timeoutMs: params.connectTimeoutMs,
+                }));
+            };
+            const onError = (err) => {
+                cleanup();
                 Logger.error(`Redis Connection Error: ${err.message}`);
                 reject(err);
-            });
+            };
+            const onErrorUnknown = (err) => {
+                if (err instanceof Error) {
+                    onError(err);
+                    return;
+                }
+                cleanup();
+                const msg = String(err);
+                Logger.error(`Redis Connection Error: ${msg}`);
+                reject(ErrorFactory.createConnectionError(`Redis Connection Error: ${msg}`, {
+                    error: msg,
+                }));
+            };
+            const onConnect = () => {
+                cleanup();
+                client = socket;
+                resolve(socket);
+            };
+            const socket = net.connect(params.port, params.host, onConnect);
+            const anySocket = socket;
+            const cleanup = () => {
+                anySocket.setTimeout?.(0);
+                anySocket.removeListener?.('timeout', onTimeout);
+                anySocket.removeListener?.('error', onErrorUnknown);
+            };
+            anySocket.setTimeout?.(Math.max(1, params.connectTimeoutMs));
+            listenPreferOnce(anySocket, 'timeout', onTimeout);
+            listenPreferOn(anySocket, 'error', onErrorUnknown);
         });
     };
-    const sendCommand = async (command) => {
-        const socket = await connect();
-        return new Promise((resolve, _reject) => {
-            socket.once('data', (data) => {
-                resolve(data.toString());
-            });
-            socket.write(command);
+};
+const createTcpSendCommand = (params) => {
+    return async (command) => {
+        const socket = await params.connect();
+        const anySocket = socket;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const onDataUnknown = (data) => {
+                if (typeof data === 'string') {
+                    settleOk(data);
+                    return;
+                }
+                if (hasToString(data)) {
+                    settleOk(data.toString());
+                    return;
+                }
+                settleOk(String(data));
+            };
+            const onErrorUnknown = (err) => {
+                settleErr(err instanceof Error
+                    ? err
+                    : ErrorFactory.createConnectionError('Redis socket error', {
+                        error: String(err),
+                    }));
+            };
+            const cleanup = () => {
+                anySocket.setTimeout?.(0);
+                anySocket.removeListener?.('data', onDataUnknown);
+                anySocket.removeListener?.('error', onErrorUnknown);
+                anySocket.removeListener?.('timeout', onTimeout);
+            };
+            const settleOk = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(value);
+            };
+            const settleErr = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(err);
+            };
+            const onTimeout = () => settleErr(ErrorFactory.createConnectionError('Redis command timeout', {
+                timeoutMs: params.commandTimeoutMs,
+            }));
+            anySocket.setTimeout?.(Math.max(1, params.commandTimeoutMs));
+            listenPreferOnce(anySocket, 'data', onDataUnknown);
+            listenPreferOnce(anySocket, 'timeout', onTimeout);
+            listenPreferOn(anySocket, 'error', onErrorUnknown);
+            anySocket.write?.(command);
         });
     };
+};
+const createTcpCacheDriver = () => {
+    const host = Env.REDIS_HOST;
+    const port = Env.REDIS_PORT;
+    const connectTimeoutMs = Env.getInt('REDIS_CONNECT_TIMEOUT_MS', 5_000);
+    const commandTimeoutMs = Env.getInt('REDIS_COMMAND_TIMEOUT_MS', 5_000);
+    const connect = createTcpConnect({ host, port, connectTimeoutMs });
+    const sendCommand = createTcpSendCommand({ connect, commandTimeoutMs });
     return {
         async get(key) {
             try {
@@ -43,7 +238,6 @@ const create = () => {
                 const response = await sendCommand(`GET ${prefixedKey}\r\n`);
                 if (response.startsWith('$-1'))
                     return null;
-                // Basic RESP parsing
                 const lines = response.split('\r\n');
                 const value = lines[1];
                 return JSON.parse(value);
@@ -54,28 +248,57 @@ const create = () => {
             }
         },
         async set(key, value, ttl) {
-            const prefixedKey = RedisKeys.createCacheKey(key);
-            const jsonValue = JSON.stringify(value);
-            let command = `SET ${prefixedKey} ${jsonValue}\r\n`;
-            if (ttl !== undefined) {
-                command = `SETEX ${prefixedKey} ${ttl} ${jsonValue}\r\n`;
+            try {
+                const prefixedKey = RedisKeys.createCacheKey(key);
+                const jsonValue = JSON.stringify(value);
+                const command = ttl === undefined
+                    ? `SET ${prefixedKey} ${jsonValue}\r\n`
+                    : `SETEX ${prefixedKey} ${ttl} ${jsonValue}\r\n`;
+                await sendCommand(command);
+            }
+            catch (error) {
+                Logger.error('Redis SET failed', error);
             }
-            await sendCommand(command);
         },
         async delete(key) {
-            const prefixedKey = RedisKeys.createCacheKey(key);
-            await sendCommand(`DEL ${prefixedKey}\r\n`);
+            try {
+                const prefixedKey = RedisKeys.createCacheKey(key);
+                await sendCommand(`DEL ${prefixedKey}\r\n`);
+            }
+            catch (error) {
+                Logger.error('Redis DEL failed', error);
+            }
         },
         async clear() {
-            await sendCommand(`FLUSHDB\r\n`);
+            try {
+                await sendCommand(`FLUSHDB\r\n`);
+            }
+            catch (error) {
+                Logger.error('Redis FLUSHDB failed', error);
+            }
         },
         async has(key) {
-            const prefixedKey = RedisKeys.createCacheKey(key);
-            const response = await sendCommand(`EXISTS ${prefixedKey}\r\n`);
-            return response.includes(':1');
+            try {
+                const prefixedKey = RedisKeys.createCacheKey(key);
+                const response = await sendCommand(`EXISTS ${prefixedKey}\r\n`);
+                return response.includes(':1');
+            }
+            catch (error) {
+                Logger.error('Redis EXISTS failed', error);
+                return false;
+            }
         },
     };
 };
+/**
+ * Create a new Redis driver instance
+ */
+const create = () => {
+    const isWorkersRuntime = Cloudflare.getWorkersEnv() !== null;
+    const wantsProxy = Env.USE_REDIS_PROXY === true || (Env.get('REDIS_PROXY_URL', '') || '').trim() !== '';
+    const ioredisDriver = createIoredisCacheDriver({ isWorkersRuntime, wantsProxy });
+    return ioredisDriver ?? createTcpCacheDriver();
+};
 /**
  * RedisDriver namespace - sealed for immutability
  */

package/src/cli/CLI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CLI.d.ts","sourceRoot":"","sources":["../../../src/cli/CLI.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA2DH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,MAAM,WAAW,IAAI;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,UAAU,IAAI,OAAO,CAAC;CACvB;AAiPD;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;cACJ,IAAI;EAed,CAAC"}
+{"version":3,"file":"CLI.d.ts","sourceRoot":"","sources":["../../../src/cli/CLI.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,MAAM,WAAW,IAAI;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,UAAU,IAAI,OAAO,CAAC;CACvB;AAuPD;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;cACJ,IAAI;EAed,CAAC"}

package/src/cli/CLI.js

@@ -8,6 +8,7 @@ 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';
@@ -17,6 +18,7 @@ import { DeployContainerWorkersCommand } from './commands/DeployContainerWorkers
 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';
@@ -34,12 +36,16 @@ 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';
@@ -71,6 +77,7 @@ const buildCommandRegistry = () => {
         InitContainerCommand.create(),
         InitProxyCommand.create(),
         InitProducerCommand.create(),
+        InitEcosystemCommand.create(),
         DoctorArchitectureCommand.create(),
         AddCommand.create(),
         CreateCommand.create(),
@@ -79,12 +86,16 @@ const buildCommandRegistry = () => {
         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(),
@@ -93,6 +104,7 @@ const buildCommandRegistry = () => {
         ContainerProxiesCommand.create(),
         PluginCommand.create(),
         PublishCommand.create(),
+        PutCommand.create(),
         DeployCommand.create(),
         DeployContainerWorkersCommand.create(),
         DeployContainerProxiesCommand.create(),

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/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"}