@zintrust/core 0.1.18 → 0.1.20

package/src/cli/commands/RoutesCommand.js

@@ -0,0 +1,242 @@
+/**
+ * Routes Command
+ * Lists all registered routes in a table.
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { Env } from '../../config/env.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { registerRoutes } from '../../../routes/api.js';
+import { Router } from '../../routing/Router.js';
+const parseGroupBy = (value) => {
+    const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (raw === '' || raw === 'group')
+        return 'group';
+    if (raw === 'service')
+        return 'service';
+    if (raw === 'none')
+        return 'none';
+    throw ErrorFactory.createCliError(`Invalid --group-by '${String(value)}'. Expected: group | service | none.`);
+};
+const parseMethodFilter = (value) => {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (raw === '')
+        return null;
+    const items = raw
+        .split(',')
+        .map((s) => s.trim().toUpperCase())
+        .filter((s) => s.length > 0);
+    return items.length === 0 ? null : new Set(items);
+};
+const normalizeHandlerName = (handler) => {
+    const name = typeof handler === 'function' &&
+        typeof handler.name === 'string'
+        ? handler.name
+        : '';
+    if (name.trim() === '')
+        return '<anonymous>';
+    return name.startsWith('bound ') ? name.slice('bound '.length) : name;
+};
+const normalizePath = (path) => (typeof path === 'string' ? path : '');
+const normalizePathForUrl = (path) => {
+    const raw = path.trim();
+    if (raw === '')
+        return '/';
+    const withLeadingSlash = raw.startsWith('/') ? raw : `/${raw}`;
+    // Avoid accidental double slashes when Router.group prefixes with '/api/v1' and child route starts with '/'
+    return withLeadingSlash.replaceAll(/\/+/g, '/');
+};
+const getBaseOrigin = () => {
+    const baseUrlRaw = Env.get('BASE_URL', Env.BASE_URL ?? '').trim();
+    const port = Env.getInt('PORT', typeof Env.PORT === 'number' && Number.isFinite(Env.PORT) ? Env.PORT : 0);
+    // Treat empty or path-only values as "unset" (avoid weird results like ":3000")
+    if (baseUrlRaw === '' || baseUrlRaw === '/' || baseUrlRaw.startsWith('/'))
+        return '';
+    const withScheme = baseUrlRaw.includes('://') ? baseUrlRaw : `http://${baseUrlRaw}`;
+    try {
+        const url = new URL(withScheme);
+        if (url.port === '' && port > 0) {
+            url.port = String(port);
+        }
+        return url.origin;
+    }
+    catch {
+        // Fallback: best-effort string join
+        const noTrailingSlash = baseUrlRaw.endsWith('/') ? baseUrlRaw.slice(0, -1) : baseUrlRaw;
+        if (noTrailingSlash === '')
+            return '';
+        return port > 0 && !noTrailingSlash.includes(':')
+            ? `${noTrailingSlash}:${port}`
+            : noTrailingSlash;
+    }
+};
+const buildFullUrl = (origin, path) => {
+    if (origin.trim() === '')
+        return path;
+    const cleanOrigin = origin.endsWith('/') ? origin.slice(0, -1) : origin;
+    const cleanPath = normalizePathForUrl(path);
+    return `${cleanOrigin}${cleanPath}`;
+};
+const deriveGroup = (path) => {
+    if (path === '/' || path.trim() === '')
+        return '/';
+    const parts = path.split('/').filter(Boolean);
+    if (parts.length === 0)
+        return '/';
+    // Prefer deeper groups for common API patterns
+    if (parts[0] === 'api' && parts[1] !== undefined)
+        return `/api/${parts[1]}`;
+    return `/${parts[0]}`;
+};
+const deriveService = (path) => {
+    if (path === '/' || path.trim() === '')
+        return '/';
+    const parts = path.split('/').filter(Boolean);
+    if (parts.length === 0)
+        return '/';
+    // For /api/v1/<service>/... group by <service>
+    if (parts[0] === 'api' && parts[1] !== undefined) {
+        const service = parts[2] ?? parts[1];
+        return service === '' ? `/api/${parts[1]}` : service;
+    }
+    return parts[0];
+};
+const partitionMiddleware = (names) => {
+    const validations = [];
+    const middleware = [];
+    for (const name of names) {
+        if (name.toLowerCase().startsWith('validate')) {
+            validations.push(name);
+        }
+        else {
+            middleware.push(name);
+        }
+    }
+    return { middleware, validations };
+};
+const unique = (items) => Array.from(new Set(items));
+const truncate = (value, max) => {
+    if (value.length <= max)
+        return value;
+    if (max <= 1)
+        return value.slice(0, max);
+    return `${value.slice(0, Math.max(0, max - 1))}…`;
+};
+const pad = (value, width) => value.padEnd(width);
+const renderTable = (rows) => {
+    /* eslint-disable no-console */
+    const columns = [
+        { key: 'url', title: 'URL', max: 64 },
+        { key: 'group', title: 'Group', max: 18 },
+        { key: 'method', title: 'Method', max: 6 },
+        { key: 'path', title: 'Path', max: 42 },
+        { key: 'middleware', title: 'Middleware', max: 28 },
+        { key: 'validations', title: 'Validation', max: 24 },
+        { key: 'handler', title: 'Handler', max: 28 },
+    ];
+    const widths = Object.fromEntries(columns.map((c) => {
+        const contentMax = Math.max(c.title.length, ...rows.map((r) => truncate(String(r[c.key] ?? ''), c.max).length));
+        return [c.key, Math.min(c.max, Math.max(4, contentMax))];
+    }));
+    const border = `┌${columns.map((c) => '─'.repeat(widths[c.key] + 2)).join('┬')}┐`;
+    const mid = `├${columns.map((c) => '─'.repeat(widths[c.key] + 2)).join('┼')}┤`;
+    const bottom = `└${columns.map((c) => '─'.repeat(widths[c.key] + 2)).join('┴')}┘`;
+    const header = `│${columns
+        .map((c) => ` ${pad(truncate(c.title, widths[c.key]), widths[c.key])} `)
+        .join('│')}│`;
+    console.log(border);
+    console.log(header);
+    console.log(mid);
+    for (const row of rows) {
+        const line = `│${columns
+            .map((c) => {
+            const cell = truncate(String(row[c.key] ?? ''), widths[c.key]);
+            return ` ${pad(cell, widths[c.key])} `;
+        })
+            .join('│')}│`;
+        console.log(line);
+    }
+    console.log(bottom);
+    /* eslint-enable no-console */
+};
+const buildRows = (options) => {
+    const groupBy = parseGroupBy(options.groupBy);
+    const filterText = typeof options.filter === 'string' ? options.filter.trim().toLowerCase() : '';
+    const methodFilter = parseMethodFilter(options.method);
+    const baseOrigin = getBaseOrigin();
+    const router = Router.createRouter();
+    registerRoutes(router);
+    const routes = Router.getRoutes(router);
+    const rows = routes.map((route) => {
+        const path = normalizePath(route.path);
+        let group = '';
+        if (groupBy === 'service') {
+            group = deriveService(path);
+        }
+        else if (groupBy === 'group') {
+            group = deriveGroup(path);
+        }
+        const mwNames = Array.isArray(route.middleware)
+            ? route.middleware.filter((m) => typeof m === 'string')
+            : [];
+        const mw = partitionMiddleware(unique(mwNames));
+        return {
+            url: buildFullUrl(baseOrigin, path),
+            group,
+            method: String(route.method ?? '').toUpperCase(),
+            path,
+            middleware: mw.middleware.join(', '),
+            validations: mw.validations.join(', '),
+            handler: normalizeHandlerName(route.handler),
+        };
+    });
+    const filtered = rows.filter((r) => {
+        if (methodFilter?.has(r.method) === false)
+            return false;
+        if (filterText === '')
+            return true;
+        const haystack = `${r.url} ${r.group} ${r.method} ${r.path} ${r.middleware} ${r.validations} ${r.handler}`
+            .toLowerCase()
+            .trim();
+        return haystack.includes(filterText);
+    });
+    // Keep stable ordering
+    filtered.sort((a, b) => {
+        if (a.group !== b.group)
+            return a.group.localeCompare(b.group);
+        if (a.path !== b.path)
+            return a.path.localeCompare(b.path);
+        return a.method.localeCompare(b.method);
+    });
+    return filtered;
+};
+const addOptions = (command) => {
+    command
+        .option('--group-by <mode>', 'group | service | none', 'group')
+        .option('--filter <text>', 'Filter by substring (path/middleware/handler/etc)')
+        .option('--method <methods>', 'Comma list of methods to include (e.g. GET,POST)')
+        .option('--json', 'Output machine-readable JSON instead of a table');
+};
+const execute = (cmd, options) => {
+    const rows = buildRows(options);
+    if (options.json === true) {
+        /* eslint-disable no-console */
+        console.log(JSON.stringify({ count: rows.length, routes: rows }, null, 2));
+        /* eslint-enable no-console */
+        return;
+    }
+    cmd.info(`Found ${rows.length} routes`);
+    renderTable(rows);
+};
+export const RoutesCommand = Object.freeze({
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'routes',
+            aliases: ['route:list'],
+            description: 'List all routes (grouped by router group or service) with middleware and handler info',
+            addOptions,
+            execute: (options) => execute(cmd, options),
+        });
+        return cmd;
+    },
+});
+export default RoutesCommand;

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

@@ -4,7 +4,7 @@
  * IMPORTANT: this uses the same ProjectScaffolder as `zin new`.
  * Usage: zin -sim my-blog
  */
-import { IBaseCommand } from '../BaseCommand';
+import type { IBaseCommand } from '../BaseCommand';
 /**
  * SimulateCommand - Generate simulated apps for testing
  */

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

@@ -1 +1 @@
-{"version":3,"file":"SimulateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SimulateCommand.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA+BhD;;GAEG;AACH,eAAO,MAAM,eAAe,EAuDvB,YAAY,CAAC"}
+{"version":3,"file":"SimulateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SimulateCommand.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA+BrD;;GAEG;AACH,eAAO,MAAM,eAAe,EAuDvB,YAAY,CAAC"}

package/src/cli/commands/SimulateCommand.js

@@ -67,7 +67,7 @@ export const SimulateCommand = {
                 Logger.info(`\n${chalk.bold('Next steps:')}`);
                 Logger.info(`  cd ${path.relative(process.cwd(), appPath)}`);
                 Logger.info('  npm install');
-                Logger.info('  npm run dev');
+                Logger.info('  zin start');
             }
             catch (error) {
                 Logger.error('Failed to create simulated app', error);

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

@@ -1 +1 @@
-{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmSvF,eAAO,MAAM,YAAY;cACb,YAAY;EAsBtB,CAAC"}
+{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAyZvF,eAAO,MAAM,YAAY;cACb,YAAY;EAyBtB,CAAC"}

package/src/cli/commands/StartCommand.js

@@ -1,9 +1,10 @@
 import { BaseCommand } from '../BaseCommand.js';
+import { DENO_RUNNER_SOURCE, LAMBDA_RUNNER_SOURCE } from '../commands/runner/index.js';
 import { EnvFileLoader } from '../utils/EnvFileLoader.js';
 import { SpawnUtil } from '../utils/spawn.js';
 import { resolveNpmPath } from '../../common/index.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import { existsSync, readFileSync } from '../../node-singletons/fs.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from '../../node-singletons/fs.js';
 import * as path from '../../node-singletons/path.js';
 const isValidModeInput = (value) => value === 'development' ||
     value === 'dev' ||
@@ -59,6 +60,22 @@ const resolveRuntime = (options) => {
     const raw = typeof options.runtime === 'string' ? options.runtime.trim() : '';
     return raw === '' ? undefined : raw;
 };
+const resolveStartVariant = (options) => {
+    const wantWrangler = options.wrangler === true || options.wg === true;
+    const wantDeno = options.deno === true;
+    const wantLambda = options.lambda === true;
+    const enabled = [wantWrangler, wantDeno, wantLambda].filter(Boolean).length;
+    if (enabled > 1) {
+        throw ErrorFactory.createCliError('Error: Choose only one of --wrangler/--wg, --deno, or --lambda.');
+    }
+    if (wantWrangler)
+        return 'wrangler';
+    if (wantDeno)
+        return 'deno';
+    if (wantLambda)
+        return 'lambda';
+    return 'node';
+};
 const hasFlag = (flag) => process.argv.includes(flag);
 const resolveWatchPreference = (options, mode) => {
     const hasWatch = hasFlag('--watch');
@@ -104,6 +121,10 @@ const findWranglerConfig = (cwd) => {
     return undefined;
 };
 const resolveWranglerEntry = (cwd) => {
+    const indexEntry = path.join(cwd, 'src/index.ts');
+    if (existsSync(indexEntry))
+        return 'src/index.ts';
+    // Legacy fallback
     const entry = path.join(cwd, 'src/functions/cloudflare.ts');
     return existsSync(entry) ? 'src/functions/cloudflare.ts' : undefined;
 };
@@ -167,6 +188,55 @@ const executeWranglerStart = async (cmd, cwd, port, runtime) => {
     const exitCode = await SpawnUtil.spawnAndWait({ command: 'wrangler', args: wranglerArgs });
     process.exit(exitCode);
 };
+const ensureTmpRunnerFile = (cwd, filename, content) => {
+    const tmpDir = path.join(cwd, 'tmp');
+    try {
+        mkdirSync(tmpDir, { recursive: true });
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Failed to create tmp directory', error);
+    }
+    const fullPath = path.join(tmpDir, filename);
+    try {
+        writeFileSync(fullPath, content, 'utf-8');
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Failed to write start runner', error);
+    }
+    return fullPath;
+};
+const executeDenoStart = async (cmd, cwd, mode, watchEnabled, _port, runtime) => {
+    if (runtime !== undefined) {
+        throw ErrorFactory.createCliError('Error: --runtime cannot be used with --deno.');
+    }
+    if (mode === 'testing') {
+        throw ErrorFactory.createCliError('Error: Cannot start server in testing mode. Use development or production.');
+    }
+    const denoRunner = ensureTmpRunnerFile(cwd, 'zin-start-deno.ts', DENO_RUNNER_SOURCE);
+    const args = [];
+    if (mode === 'development' && watchEnabled)
+        args.push('watch');
+    args.push(denoRunner);
+    cmd.info('Starting in Deno adapter mode...');
+    const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args });
+    process.exit(exitCode);
+};
+const executeLambdaStart = async (cmd, cwd, mode, watchEnabled, _port, runtime) => {
+    if (runtime !== undefined) {
+        throw ErrorFactory.createCliError('Error: --runtime cannot be used with --lambda.');
+    }
+    if (mode === 'testing') {
+        throw ErrorFactory.createCliError('Error: Cannot start server in testing mode. Use development or production.');
+    }
+    const lambdaRunner = ensureTmpRunnerFile(cwd, 'zin-start-lambda.ts', LAMBDA_RUNNER_SOURCE);
+    const args = [];
+    if (mode === 'development' && watchEnabled)
+        args.push('watch');
+    args.push(lambdaRunner);
+    cmd.info('Starting in Lambda adapter mode...');
+    const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args });
+    process.exit(exitCode);
+};
 const executeNodeStart = async (cmd, cwd, mode, watchEnabled) => {
     if (mode === 'testing') {
         throw ErrorFactory.createCliError('Error: Cannot start server in testing mode. Use --force to override (not supported).');
@@ -196,12 +266,26 @@ const executeStart = async (options, cmd) => {
     const mode = resolveMode(options);
     const port = resolvePort(options);
     const runtime = resolveRuntime(options);
-    EnvFileLoader.applyCliOverrides({ nodeEnv: mode, port, runtime });
-    if (options.wrangler === true) {
+    const variant = resolveStartVariant(options);
+    let effectiveRuntime = runtime;
+    if (variant === 'deno')
+        effectiveRuntime = 'deno';
+    if (variant === 'lambda')
+        effectiveRuntime = 'lambda';
+    EnvFileLoader.applyCliOverrides({ nodeEnv: mode, port, runtime: effectiveRuntime });
+    if (variant === 'wrangler') {
         await executeWranglerStart(cmd, cwd, port, runtime);
         return;
     }
     const watchEnabled = resolveWatchPreference(options, mode);
+    if (variant === 'deno') {
+        await executeDenoStart(cmd, cwd, mode, watchEnabled, port, runtime);
+        return;
+    }
+    if (variant === 'lambda') {
+        await executeLambdaStart(cmd, cwd, mode, watchEnabled, port, runtime);
+        return;
+    }
     await executeNodeStart(cmd, cwd, mode, watchEnabled);
 };
 export const StartCommand = Object.freeze({
@@ -210,6 +294,9 @@ export const StartCommand = Object.freeze({
             command.alias('s');
             command
                 .option('-w, --wrangler', 'Start with Wrangler dev mode (Cloudflare Workers)')
+                .option('--wg', 'Alias for --wrangler')
+                .option('--deno', 'Start a local server using the Deno runtime adapter')
+                .option('--lambda', 'Start a local server using the AWS Lambda runtime adapter')
                 .option('--watch', 'Force watch mode (Node only)')
                 .option('--no-watch', 'Disable watch mode (Node only)')
                 .option('--mode <development|production|testing>', 'Override app mode')

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

@@ -0,0 +1,16 @@
+/**
+ * Upgrade Command
+ *
+ * Goal: help existing Zintrust projects adopt new safe defaults without forcing
+ * a full re-scaffold.
+ *
+ * Current scope (minimal/safe):
+ * - Backfill required .env defaults (HOST, PORT, LOG_LEVEL) when missing or blank.
+ * - Never overwrite a non-empty user value.
+ */
+import { type IBaseCommand } from '../BaseCommand';
+export declare const UpgradeCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+export default UpgradeCommand;
+//# sourceMappingURL=UpgradeCommand.d.ts.map

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

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

package/src/cli/commands/UpgradeCommand.js

@@ -0,0 +1,107 @@
+/**
+ * Upgrade Command
+ *
+ * Goal: help existing Zintrust projects adopt new safe defaults without forcing
+ * a full re-scaffold.
+ *
+ * Current scope (minimal/safe):
+ * - Backfill required .env defaults (HOST, PORT, LOG_LEVEL) when missing or blank.
+ * - Never overwrite a non-empty user value.
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+import { EnvFileBackfill } from '../env/EnvFileBackfill.js';
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+const ensureEnvFileExists = (envPath) => {
+    const dir = path.dirname(envPath);
+    mkdirSync(dir, { recursive: true });
+    try {
+        readFileSync(envPath, 'utf8');
+    }
+    catch {
+        writeFileSync(envPath, '\n', 'utf8');
+    }
+};
+const resolveCwd = (cwd) => {
+    if (typeof cwd === 'string' && cwd.trim() !== '')
+        return cwd;
+    return process.cwd();
+};
+const getEnvDefaults = () => Object.freeze({
+    HOST: 'localhost',
+    PORT: '7777',
+    LOG_LEVEL: 'debug',
+});
+const envFileExists = (envPath) => {
+    try {
+        readFileSync(envPath, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const formatBackfillSummary = (result) => {
+    const filled = result.filledKeys.join(', ') || '(none)';
+    const appended = result.appendedKeys.join(', ') || '(none)';
+    return `filled=${filled}; appended=${appended}`;
+};
+const runDryRun = (envPath, defaults) => {
+    const exists = envFileExists(envPath);
+    if (exists === false) {
+        ErrorHandler.info(`[dry-run] Would create ${envPath}`);
+        return;
+    }
+    const raw = readFileSync(envPath, 'utf8');
+    const tmpPath = `${envPath}.zin-upgrade.tmp`;
+    writeFileSync(tmpPath, raw, 'utf8');
+    try {
+        const result = EnvFileBackfill.backfillEnvDefaults(tmpPath, defaults);
+        if (result.changed === false) {
+            ErrorHandler.success('No changes needed.');
+            return;
+        }
+        ErrorHandler.info(`[dry-run] Would backfill .env: ${formatBackfillSummary(result)}`);
+    }
+    finally {
+        try {
+            unlinkSync(tmpPath);
+        }
+        catch {
+            // ignore
+        }
+    }
+};
+const runUpgrade = (envPath, defaults) => {
+    ensureEnvFileExists(envPath);
+    return EnvFileBackfill.backfillEnvDefaults(envPath, defaults);
+};
+export const UpgradeCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'upgrade',
+            description: 'Upgrade an existing Zintrust project in-place (safe, non-destructive)',
+            addOptions: (command) => {
+                command.option('--cwd <path>', 'Project directory (default: current working directory)');
+                command.option('--dry-run', 'Print planned changes without writing files');
+            },
+            execute: (options) => {
+                const cwd = resolveCwd(options.cwd);
+                const envPath = path.resolve(cwd, '.env');
+                const defaults = getEnvDefaults();
+                if (options.dryRun === true) {
+                    runDryRun(envPath, defaults);
+                    return;
+                }
+                const result = runUpgrade(envPath, defaults);
+                if (result.changed === false) {
+                    ErrorHandler.success('No changes needed.');
+                    return;
+                }
+                ErrorHandler.success(`Upgraded .env: ${formatBackfillSummary(result)}`);
+            },
+        });
+    },
+});
+export default UpgradeCommand;

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

@@ -4,7 +4,9 @@
 export { AddCommand } from '../commands/AddCommand';
 export { BroadcastWorkCommand } from '../commands/BroadcastWorkCommand';
 export { ConfigCommand } from '../commands/ConfigCommand';
+export { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from '../commands/CreateCommand';
 export { DebugCommand } from '../commands/DebugCommand';
+export { JwtDevCommand } from '../commands/JwtDevCommand';
 export { LogsCleanupCommand } from '../commands/LogsCleanupCommand';
 export { MakeMailTemplateCommand } from '../commands/MakeMailTemplateCommand';
 export { MakeNotificationTemplateCommand } from '../commands/MakeNotificationTemplateCommand';
@@ -13,6 +15,7 @@ export { NewCommand } from '../commands/NewCommand';
 export { NotificationWorkCommand } from '../commands/NotificationWorkCommand';
 export { PrepareCommand } from '../commands/PrepareCommand';
 export { QueueCommand } from '../commands/QueueCommand';
+export { RoutesCommand } from '../commands/RoutesCommand';
 export { SecretsCommand } from '../commands/SecretsCommand';
 export { StartCommand } from '../commands/StartCommand';
 export { TemplatesCommand } from '../commands/TemplatesCommand';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,+BAA+B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,+BAA+B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}

package/src/cli/commands/index.js

@@ -4,7 +4,9 @@
 export { AddCommand } from '../commands/AddCommand.js';
 export { BroadcastWorkCommand } from '../commands/BroadcastWorkCommand.js';
 export { ConfigCommand } from '../commands/ConfigCommand.js';
+export { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from '../commands/CreateCommand.js';
 export { DebugCommand } from '../commands/DebugCommand.js';
+export { JwtDevCommand } from '../commands/JwtDevCommand.js';
 export { LogsCleanupCommand } from '../commands/LogsCleanupCommand.js';
 export { MakeMailTemplateCommand } from '../commands/MakeMailTemplateCommand.js';
 export { MakeNotificationTemplateCommand } from '../commands/MakeNotificationTemplateCommand.js';
@@ -13,6 +15,7 @@ export { NewCommand } from '../commands/NewCommand.js';
 export { NotificationWorkCommand } from '../commands/NotificationWorkCommand.js';
 export { PrepareCommand } from '../commands/PrepareCommand.js';
 export { QueueCommand } from '../commands/QueueCommand.js';
+export { RoutesCommand } from '../commands/RoutesCommand.js';
 export { SecretsCommand } from '../commands/SecretsCommand.js';
 export { StartCommand } from '../commands/StartCommand.js';
 export { TemplatesCommand } from '../commands/TemplatesCommand.js';

package/src/cli/commands/runner/index.d.ts

@@ -0,0 +1,3 @@
+export declare const DENO_RUNNER_SOURCE: string;
+export declare const LAMBDA_RUNNER_SOURCE: string;
+//# sourceMappingURL=index.d.ts.map

package/src/cli/commands/runner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/runner/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,QAwDnB,CAAC;AAEb,eAAO,MAAM,oBAAoB,QAiFrB,CAAC"}