@zintrust/core 0.4.15 → 0.4.17

package/src/cli/commands/ContainerWorkersCommand.js

@@ -1,34 +0,0 @@
-import { BaseCommand } from '../BaseCommand.js';
-import { ContainerComposeLifecycle } from '../commands/ContainerComposeLifecycle.js';
-import { resolveComposePath } from '../commands/DockerComposeCommandUtils.js';
-const normalizeAction = (raw) => {
-    return ContainerComposeLifecycle.normalizeAction(raw, ['build', 'up'], '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, 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 ContainerComposeLifecycle.runBuild(composePath, options, 'Building container workers image...');
-                    return;
-                }
-                if (options.build === true) {
-                    await ContainerComposeLifecycle.runBuild(composePath, options, 'Building container workers image...');
-                }
-                await ContainerComposeLifecycle.runUp(composePath, options, 'Starting container workers...');
-            },
-        });
-    },
-});

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

@@ -1,15 +0,0 @@
-/**
- * Create Command
- * Shortcuts for common scaffolding tasks.
- */
-import { type IBaseCommand } from '../BaseCommand';
-export declare const CreateCommand: Readonly<{
-    create(): IBaseCommand;
-}>;
-export declare const CreateMigrationCommand: Readonly<{
-    create(): IBaseCommand;
-}>;
-export declare const AddMigrationCommand: Readonly<{
-    create(): IBaseCommand;
-}>;
-//# sourceMappingURL=CreateCommand.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"CreateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/CreateCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA+HvF,eAAO,MAAM,aAAa;cACd,YAAY;EAUtB,CAAC;AAEH,eAAO,MAAM,sBAAsB;cACvB,YAAY;EAatB,CAAC;AAEH,eAAO,MAAM,mBAAmB;cACpB,YAAY;EActB,CAAC"}

package/src/cli/commands/CreateCommand.js

@@ -1,143 +0,0 @@
-/**
- * Create Command
- * Shortcuts for common scaffolding tasks.
- */
-import { BaseCommand } from '../BaseCommand.js';
-import { FileGenerator } from '../scaffolding/FileGenerator.js';
-import { MigrationGenerator } from '../scaffolding/MigrationGenerator.js';
-import { CommonUtils } from '../../common/index.js';
-import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import * as path from '../../node-singletons/path.js';
-const pluralize = (snake) => (snake.endsWith('s') ? snake : `${snake}s`);
-const buildCreateTableMigrationName = (model) => {
-    const modelSnake = CommonUtils.toSnakeCase(model).replaceAll(/[^a-z0-9_]+/g, '_');
-    const tablePlural = pluralize(modelSnake);
-    return `create_${tablePlural}_table`;
-};
-const buildAddColumnMigrationName = (column, model) => {
-    const colSnake = CommonUtils.toSnakeCase(column).replaceAll(/[^a-z0-9_]+/g, '_');
-    const modelSnake = CommonUtils.toSnakeCase(model).replaceAll(/[^a-z0-9_]+/g, '_');
-    const tablePlural = pluralize(modelSnake);
-    return `add_${colSnake}_${tablePlural}_table`;
-};
-const findMigrationBySuffix = (migrationsPath, suffix) => {
-    const files = FileGenerator.listFiles(migrationsPath, false);
-    for (const file of files) {
-        if (path.basename(file).endsWith(suffix))
-            return file;
-    }
-    return undefined;
-};
-const addOptions = (command) => {
-    command
-        .argument('<type>', 'What to create (currently: migration)')
-        .argument('<name>', 'Name (for migration: model name like "user")');
-    // Accepted for consistency with other CLI commands.
-    command.option('--no-interactive', 'Skip interactive prompts');
-};
-const executeCreate = async (cmd, options) => {
-    const args = Array.isArray(options.args) ? options.args : [];
-    const type = args[0];
-    const name = args[1];
-    if (type !== 'migration') {
-        throw ErrorFactory.createCliError('Usage: zin create migration <model>');
-    }
-    if (typeof name !== 'string' || name.trim() === '') {
-        throw ErrorFactory.createValidationError('Model name is required');
-    }
-    const projectRoot = process.cwd();
-    const migrationsPath = path.join(projectRoot, 'database', 'migrations');
-    const migrationName = buildCreateTableMigrationName(name);
-    const tableName = pluralize(CommonUtils.toSnakeCase(name).replaceAll(/[^a-z0-9_]+/g, '_'));
-    cmd.info(`Creating migration: ${migrationName}...`);
-    const result = await MigrationGenerator.generateMigration({
-        name: migrationName,
-        migrationsPath,
-        type: 'create',
-        table: tableName,
-    });
-    if (result.success === false)
-        throw ErrorFactory.createCliError(result.message);
-    cmd.success('Migration created successfully!');
-    cmd.info(`File: ${path.basename(result.filePath)}`);
-};
-const executeCm = async (cmd, options) => {
-    const args = Array.isArray(options.args) ? options.args : [];
-    const model = args[0];
-    if (typeof model !== 'string' || model.trim() === '') {
-        throw ErrorFactory.createCliError('Usage: zin cm <model>');
-    }
-    await executeCreate(cmd, { ...options, args: ['migration', model] });
-};
-const executeAm = async (cmd, options) => {
-    const args = Array.isArray(options.args) ? options.args : [];
-    const column = args[0];
-    const model = args[1];
-    if (typeof column !== 'string' ||
-        column.trim() === '' ||
-        typeof model !== 'string' ||
-        model.trim() === '') {
-        throw ErrorFactory.createCliError('Usage: zin am <column> <model>');
-    }
-    const projectRoot = process.cwd();
-    const migrationsPath = path.join(projectRoot, 'database', 'migrations');
-    const tableName = pluralize(CommonUtils.toSnakeCase(model).replaceAll(/[^a-z0-9_]+/g, '_'));
-    const createName = buildCreateTableMigrationName(model);
-    const existingCreate = findMigrationBySuffix(migrationsPath, `_${createName}.ts`);
-    if (existingCreate === undefined) {
-        throw ErrorFactory.createCliError(`Missing required create migration for model '${model}'. Create it first: zin cm ${model}`);
-    }
-    const migrationName = buildAddColumnMigrationName(column, model);
-    cmd.info(`Creating migration: ${migrationName}...`);
-    const result = await MigrationGenerator.generateMigration({
-        name: migrationName,
-        migrationsPath,
-        // Let generator infer type from name (add_* => alter)
-        table: tableName,
-        column: CommonUtils.toSnakeCase(column).replaceAll(/[^a-z0-9_]+/g, '_'),
-    });
-    if (result.success === false)
-        throw ErrorFactory.createCliError(result.message);
-    cmd.success('Migration created successfully!');
-    cmd.info(`File: ${path.basename(result.filePath)}`);
-};
-export const CreateCommand = Object.freeze({
-    create() {
-        const cmd = BaseCommand.create({
-            name: 'create',
-            description: 'Create resources (e.g. migrations) with opinionated naming',
-            addOptions,
-            execute: async (options) => executeCreate(cmd, options),
-        });
-        return cmd;
-    },
-});
-export const CreateMigrationCommand = Object.freeze({
-    create() {
-        const cmd = BaseCommand.create({
-            name: 'cm',
-            description: 'Shortcut: create migration for a model (create_<models>_table)',
-            addOptions: (command) => {
-                command.argument('<model>', 'Model name (e.g. user)');
-                command.option('--no-interactive', 'Skip interactive prompts');
-            },
-            execute: async (options) => executeCm(cmd, options),
-        });
-        return cmd;
-    },
-});
-export const AddMigrationCommand = Object.freeze({
-    create() {
-        const cmd = BaseCommand.create({
-            name: 'am',
-            description: 'Shortcut: add column migration for a model (add_<col>_<models>_table)',
-            addOptions: (command) => {
-                command.argument('<column>', 'Column name (e.g. bio)');
-                command.argument('<model>', 'Model name (e.g. user)');
-                command.option('--no-interactive', 'Skip interactive prompts');
-            },
-            execute: async (options) => executeAm(cmd, options),
-        });
-        return cmd;
-    },
-});

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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,143 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * D1 Migrate Command
- * Run Cloudflare D1 migrations using Wrangler
- */
-import type { IBaseCommand } from '../BaseCommand';
-/**
- * D1 Migrate Command
- * Run Cloudflare D1 migrations using Wrangler
- */
-/**
- * D1 Migrate Command Factory
- */
-export declare const D1MigrateCommand: Readonly<{
-    /**
-     * Create a new D1 migrate command instance
-     */
-    create(): IBaseCommand;
-}>;
-//# sourceMappingURL=D1MigrateCommand.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AA2HrE;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;cACO,YAAY;EAyBtB,CAAC"}

package/src/cli/commands/D1MigrateCommand.js

@@ -1,119 +0,0 @@
-import { BaseCommand } from '../BaseCommand.js';
-import { D1SqlMigrations } from '../d1/D1SqlMigrations.js';
-import { WranglerConfig } from '../d1/WranglerConfig.js';
-import { WranglerD1 } from '../d1/WranglerD1.js';
-import { resolveNpmPath } from '../../common/index.js';
-import { appConfig } from '../../config/app.js';
-import { databaseConfig } from '../../config/database.js';
-import { Logger } from '../../config/logger.js';
-import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import * as path from '../../node-singletons/path.js';
-const RESOLVED_VOID = Promise.resolve();
-const runWrangler = async (cmd, args) => {
-    // Back-compat entrypoint for tests; we only use this for D1 migrations apply.
-    const dbName = args[3];
-    const mode = args[4];
-    const isLocal = mode === '--local';
-    await RESOLVED_VOID;
-    return WranglerD1.applyMigrations({ cmd, dbName, isLocal });
-};
-const getDbName = (projectRoot, options) => {
-    const value = options['database'];
-    if (typeof value === 'string' && value.trim() !== '')
-        return value.trim();
-    const resolution = WranglerConfig.resolveD1Database(projectRoot);
-    if (resolution.status === 'resolved') {
-        return WranglerConfig.getDefaultD1DatabaseName(projectRoot) ?? 'zintrust_db';
-    }
-    if (resolution.status === 'ambiguous') {
-        throw ErrorFactory.createCliError('Multiple D1 targets are configured. Re-run with --database <database_name|binding> to choose the intended Wrangler D1 target.');
-    }
-    return 'zintrust_db';
-};
-const buildExecutionContext = (options) => {
-    const isWorkerCommand = process.argv.includes('d1:migrate:worker');
-    const isLocal = options['local'] === true || options['remote'] !== true;
-    const projectRoot = process.cwd();
-    const dbName = getDbName(projectRoot, options);
-    const migrationsRelDir = isWorkerCommand
-        ? path.join('database', 'migrations', 'd1')
-        : WranglerConfig.getD1MigrationsDir(projectRoot, dbName);
-    const sourceMigrationsDir = isWorkerCommand
-        ? path.join('packages', 'workers', 'migrations')
-        : databaseConfig.migrations.directory;
-    return {
-        isLocal,
-        dbName,
-        projectRoot,
-        migrationsRelDir,
-        sourceMigrationsDir,
-        outputDir: path.join(projectRoot, migrationsRelDir),
-    };
-};
-const handleMigrationError = (cmd, error) => {
-    Logger.error('D1 Migration failed', error);
-    ErrorFactory.createCliError('D1 Migration failed', error);
-    const err = error;
-    if (err.stdout !== undefined && err.stdout.length > 0)
-        cmd.info(err.stdout.toString());
-    if (err.stderr !== undefined && err.stderr.length > 0) {
-        const stderr = err.stderr.toString();
-        Logger.error('Wrangler stderr', stderr);
-        ErrorFactory.createCliError('Wrangler stderr', stderr);
-    }
-    throw error;
-};
-const executeD1Migrate = async (cmd, options) => {
-    const ctx = buildExecutionContext(options);
-    cmd.info(`Running D1 migrations for ${ctx.dbName} (${ctx.isLocal ? 'local' : 'remote'})...`);
-    cmd.info(`Generating D1 SQL migrations into ${ctx.migrationsRelDir}...`);
-    await RESOLVED_VOID;
-    try {
-        const generated = await D1SqlMigrations.compileAndWrite({
-            projectRoot: ctx.projectRoot,
-            globalDir: ctx.sourceMigrationsDir,
-            extension: databaseConfig.migrations.extension,
-            includeGlobal: true,
-            outputDir: ctx.outputDir,
-        });
-        cmd.info(`Generated ${generated.length} SQL migration file(s).`);
-        const output = WranglerD1.applyMigrations({ cmd, dbName: ctx.dbName, isLocal: ctx.isLocal });
-        if (output !== '')
-            cmd.info(output);
-        cmd.info('✓ D1 migrations completed successfully');
-    }
-    catch (error) {
-        handleMigrationError(cmd, error);
-    }
-};
-/**
- * D1 Migrate Command
- * Run Cloudflare D1 migrations using Wrangler
- */
-/**
- * D1 Migrate Command Factory
- */
-export const D1MigrateCommand = Object.freeze({
-    /**
-     * Create a new D1 migrate command instance
-     */
-    create() {
-        const addOptions = (command) => {
-            command
-                .option('--local', 'Run against local D1 database (via wrangler dev)')
-                .option('--remote', 'Run against remote D1 database (production)')
-                .option('--database <name>', 'Wrangler D1 identifier. Accepts database_name or binding; defaults to the configured wrangler d1_databases entry when available.');
-        };
-        const cmd = BaseCommand.create({
-            name: 'd1:migrate',
-            description: 'Run Cloudflare D1 migrations',
-            aliases: ['d1:migrate:worker'],
-            addOptions,
-            execute: async (options) => executeD1Migrate(cmd, options),
-        });
-        cmd.resolveNpmPath = () => resolveNpmPath();
-        cmd.getSafeEnv = () => appConfig.getSafeEnv();
-        cmd.runWrangler = async (args) => runWrangler(cmd, args);
-        return cmd;
-    },
-});

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

@@ -1,9 +0,0 @@
-/**
- * Db Seed Command
- * Run database seeders from database/seeders
- */
-import type { IBaseCommand } from '../BaseCommand';
-export declare const DbSeedCommand: Readonly<{
-    create(): IBaseCommand;
-}>;
-//# sourceMappingURL=DbSeedCommand.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DbSeedCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DbSeedCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAkKrE,eAAO,MAAM,aAAa;cACd,YAAY;EAUtB,CAAC"}

package/src/cli/commands/DbSeedCommand.js

@@ -1,139 +0,0 @@
-/**
- * Db Seed Command
- * Run database seeders from database/seeders
- */
-import { SeederDiscovery } from '../../seeders/SeederDiscovery.js';
-import { SeederLoader } from '../../seeders/SeederLoader.js';
-import { BaseCommand } from '../BaseCommand.js';
-import { confirmProductionRun, mapConnectionToOrmConfig } from '../utils/DatabaseCliUtils.js';
-import { databaseConfig } from '../../config/database.js';
-import { Env } from '../../config/env.js';
-import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import { resetDatabase, useDatabase } from '../../orm/Database.js';
-const addSeedOptions = (command) => {
-    command
-        .option('--dir <path>', 'Seeders directory (relative to project root)', databaseConfig.seeders.directory)
-        .option('--service <domain/name>', 'Run global + service-local seeders')
-        .option('--only-service <domain/name>', 'Run only service-local seeders')
-        .option('--no-interactive', 'Skip interactive prompts');
-};
-const getInteractive = (options) => options['interactive'] !== false && Env.CI !== 'true';
-const ensureNonD1Driver = (driver) => {
-    if (driver === 'd1' || driver === 'd1-remote') {
-        throw ErrorFactory.createCliError('This project is configured for D1. Seeding via `zin db:seed` is not supported yet.');
-    }
-};
-const getServiceArgs = (options) => {
-    let serviceArg;
-    if (typeof options['onlyService'] === 'string') {
-        serviceArg = String(options['onlyService']);
-    }
-    else if (typeof options['service'] === 'string') {
-        serviceArg = String(options['service']);
-    }
-    const includeGlobal = typeof options['onlyService'] !== 'string';
-    return { service: serviceArg, includeGlobal };
-};
-const parseServiceRef = (raw) => {
-    const trimmed = raw.trim();
-    const parts = trimmed.split('/').filter((p) => p.trim().length > 0);
-    if (parts.length !== 2) {
-        throw ErrorFactory.createCliError(`Invalid service reference: '${raw}'. Expected format: <domain>/<name>`);
-    }
-    return { domain: parts[0], name: parts[1] };
-};
-const normalizeSeederNameArg = (raw) => {
-    const trimmed = raw.trim();
-    if (trimmed.endsWith('.ts'))
-        return trimmed.slice(0, -3);
-    if (trimmed.endsWith('.js'))
-        return trimmed.slice(0, -3);
-    return trimmed;
-};
-const selectSeederFiles = (files, seederName) => {
-    if (seederName !== undefined) {
-        return files.filter((filePath) => {
-            const base = filePath.split('/').pop() ?? '';
-            const withoutExt = base.replace(/\.(ts|js)$/u, '');
-            return withoutExt === seederName;
-        });
-    }
-    const databaseSeeder = files.find((filePath) => {
-        const base = filePath.split('/').pop() ?? '';
-        const withoutExt = base.replace(/\.(ts|js)$/u, '');
-        return withoutExt === 'DatabaseSeeder';
-    });
-    if (databaseSeeder !== undefined)
-        return [databaseSeeder];
-    return files;
-};
-const executeSeed = async (options, cmd) => {
-    const interactive = getInteractive(options);
-    const okToProceed = await confirmProductionRun({
-        cmd,
-        interactive,
-        message: 'NODE_ENV=production. Continue running seeders?',
-    });
-    if (!okToProceed)
-        return;
-    const conn = databaseConfig.getConnection();
-    ensureNonD1Driver(conn.driver);
-    const ormConfig = mapConnectionToOrmConfig(conn);
-    const db = useDatabase(ormConfig, 'default');
-    const dirOpt = typeof options['dir'] === 'string' ? options['dir'] : databaseConfig.seeders.directory;
-    const { service, includeGlobal } = getServiceArgs(options);
-    const projectRoot = process.cwd();
-    const globalDir = SeederDiscovery.resolveDir(projectRoot, dirOpt);
-    const globalFiles = includeGlobal ? SeederDiscovery.listSeederFiles(globalDir) : [];
-    let serviceFiles = [];
-    if (service !== undefined) {
-        const { domain, name } = parseServiceRef(service);
-        const serviceRoot = `${projectRoot}/services/${domain}/${name}`;
-        const serviceDir = SeederDiscovery.resolveDir(serviceRoot, dirOpt);
-        serviceFiles = SeederDiscovery.listSeederFiles(serviceDir);
-    }
-    const seederArgRaw = Array.isArray(options.args) ? options.args[0] : undefined;
-    const seederName = typeof seederArgRaw === 'string' && seederArgRaw.trim() !== ''
-        ? normalizeSeederNameArg(seederArgRaw)
-        : undefined;
-    const selectedGlobal = selectSeederFiles(globalFiles, seederName);
-    const selectedService = selectSeederFiles(serviceFiles, seederName);
-    const selected = [...selectedGlobal, ...selectedService];
-    if (seederName !== undefined) {
-        if (selected.length === 0) {
-            throw ErrorFactory.createCliError(`Seeder not found: ${seederName} (dir=${dirOpt}, global=${globalFiles.length}, service=${serviceFiles.length})`);
-        }
-        if (selected.length > 1) {
-            throw ErrorFactory.createCliError(`Seeder name is ambiguous: ${seederName} (matches=${selected.length}). Use --only-service or adjust name.`);
-        }
-    }
-    if (selected.length === 0) {
-        cmd.info('No seeders found.');
-        return;
-    }
-    cmd.info(`Running ${selected.length} seeder(s)...`);
-    await db.connect();
-    try {
-        await selected.reduce(async (previous, filePath) => {
-            await previous;
-            const loaded = await SeederLoader.load(filePath);
-            cmd.info(`→ ${loaded.name}`);
-            await loaded.run(db);
-            cmd.success(`✓ Seeded: ${loaded.name}`);
-        }, Promise.resolve());
-    }
-    finally {
-        await resetDatabase();
-    }
-};
-export const DbSeedCommand = Object.freeze({
-    create() {
-        const cmd = BaseCommand.create({
-            name: 'db:seed',
-            description: 'Run database seeders',
-            addOptions: addSeedOptions,
-            execute: async (options) => executeSeed(options, cmd),
-        });
-        return cmd;
-    },
-});

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

@@ -1,15 +0,0 @@
-/**
- * Debug Command
- * Launch debug mode with profiling and monitoring
- */
-import type { IBaseCommand } from '../BaseCommand';
-/**
- * Debug Command Factory
- */
-export declare const DebugCommand: Readonly<{
-    /**
-     * Create a new debug command instance
-     */
-    create: () => IBaseCommand;
-}>;
-//# sourceMappingURL=DebugCommand.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DebugCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DebugCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAyDrE;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;kBApBc,YAAY;EAsB7B,CAAC"}