@zintrust/core 0.1.28 → 0.1.29

package/src/cli/scaffolding/FileGenerator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * File Generator
+ * Handles creation of files and directories
+ * Sealed namespace with file I/O operations
+ */
+export interface FileCreationOptions {
+    overwrite?: boolean;
+    createDirs?: boolean;
+    encoding?: BufferEncoding;
+}
+/**
+ * FileGenerator namespace - sealed for immutability
+ */
+export declare const FileGenerator: Readonly<{
+    createDirectory: (dirPath: string) => boolean;
+    createDirectories: (directories: string[], baseDir: string) => void;
+    writeFile: (filePath: string, content: string, options?: FileCreationOptions) => boolean;
+    writeFiles: (files: Array<{
+        path: string;
+        content: string;
+    }>, baseDir: string, options?: FileCreationOptions) => number;
+    readFile: (filePath: string, encoding?: BufferEncoding) => string;
+    fileExists: (filePath: string) => boolean;
+    directoryExists: (dirPath: string) => boolean;
+    deleteFile: (filePath: string) => boolean;
+    deleteDirectory: (dirPath: string) => boolean;
+    listFiles: (dirPath: string, recursive?: boolean) => string[];
+    copyFile: (source: string, destination: string, options?: FileCreationOptions) => boolean;
+    getDirectorySize: (dirPath: string) => number;
+}>;
+//# sourceMappingURL=FileGenerator.d.ts.map

package/src/cli/scaffolding/FileGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/FileGenerator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAsOD;;GAEG;AACH,eAAO,MAAM,aAAa;+BApOQ,MAAM,KAAG,OAAO;qCAgBV,MAAM,EAAE,WAAW,MAAM,KAAG,IAAI;0BAW5D,MAAM,WACP,MAAM,YACN,mBAAmB,KAC3B,OAAO;wBA8BD,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,WACtC,MAAM,YACL,mBAAmB,KAC5B,MAAM;yBAgBmB,MAAM,aAAY,cAAc,KAAa,MAAM;2BAWjD,MAAM,KAAG,OAAO;+BAOZ,MAAM,KAAG,OAAO;2BAOpB,MAAM,KAAG,OAAO;+BAgBZ,MAAM,KAAG,OAAO;yBAgBtB,MAAM,0BAAsB,MAAM,EAAE;uBAiCtD,MAAM,eACD,MAAM,YACV,mBAAmB,KAC3B,OAAO;gCAwByB,MAAM,KAAG,MAAM;EA6ChD,CAAC"}

package/src/cli/scaffolding/FileGenerator.js

@@ -0,0 +1,222 @@
+/**
+ * File Generator
+ * Handles creation of files and directories
+ * Sealed namespace with file I/O operations
+ */
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+/**
+ * Create a directory recursively
+ */
+const createDirectory = (dirPath) => {
+    try {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+            Logger.info(`Created directory: ${dirPath}`);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to create directory ${dirPath}:`, error);
+    }
+};
+/**
+ * Create multiple directories
+ */
+const createDirectories = (directories, baseDir) => {
+    for (const dir of directories) {
+        const fullPath = path.join(baseDir, dir);
+        createDirectory(fullPath);
+    }
+};
+/**
+ * Write file content
+ */
+const writeFile = (filePath, content, options = {}) => {
+    const { overwrite = false, createDirs = true, encoding = 'utf-8' } = options;
+    try {
+        const dir = path.dirname(filePath);
+        // Create parent directories if needed
+        if (createDirs && !fs.existsSync(dir)) {
+            createDirectory(dir);
+        }
+        // Check if file exists
+        if (fs.existsSync(filePath) && !overwrite) {
+            Logger.warn(`File already exists (skipped): ${filePath}`);
+            return false;
+        }
+        // Write file
+        fs.writeFileSync(filePath, content, { encoding });
+        Logger.info(`Created file: ${filePath}`);
+        return true;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to write file ${filePath}:`, error);
+    }
+};
+/**
+ * Write multiple files
+ */
+const writeFiles = (files, baseDir, options) => {
+    let count = 0;
+    for (const file of files) {
+        const fullPath = path.join(baseDir, file.path);
+        if (writeFile(fullPath, file.content, options)) {
+            count++;
+        }
+    }
+    return count;
+};
+/**
+ * Read file content
+ */
+const readFile = (filePath, encoding = 'utf-8') => {
+    try {
+        return fs.readFileSync(filePath, { encoding });
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to read file ${filePath}:`, error);
+    }
+};
+/**
+ * Check if file exists
+ */
+const fileExists = (filePath) => {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+};
+/**
+ * Check if directory exists
+ */
+const directoryExists = (dirPath) => {
+    return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+};
+/**
+ * Delete file
+ */
+const deleteFile = (filePath) => {
+    try {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            Logger.info(`Deleted file: ${filePath}`);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to delete file ${filePath}:`, error);
+    }
+};
+/**
+ * Delete directory recursively
+ */
+const deleteDirectory = (dirPath) => {
+    try {
+        if (fs.existsSync(dirPath)) {
+            fs.rmSync(dirPath, { recursive: true, force: true });
+            Logger.info(`Deleted directory: ${dirPath}`);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to delete directory ${dirPath}:`, error);
+    }
+};
+/**
+ * List files in directory
+ */
+const listFiles = (dirPath, recursive = false) => {
+    try {
+        if (!fs.existsSync(dirPath))
+            return [];
+        const files = [];
+        const traverse = (dir) => {
+            const entries = fs.readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry);
+                const stat = fs.statSync(fullPath);
+                if (stat.isFile()) {
+                    files.push(fullPath);
+                }
+                else if (stat.isDirectory() && recursive) {
+                    traverse(fullPath);
+                }
+            }
+        };
+        traverse(dirPath);
+        return files;
+    }
+    catch (error) {
+        ErrorFactory.createCliError(`Failed to list files in ${dirPath}:`, error);
+        return [];
+    }
+};
+/**
+ * Copy file
+ */
+const copyFile = (source, destination, options = {}) => {
+    try {
+        const { createDirs = true } = options;
+        if (!fs.existsSync(source)) {
+            ErrorFactory.createCliError(`Source file not found: ${source}`, { source });
+        }
+        const dir = path.dirname(destination);
+        if (createDirs && !fs.existsSync(dir)) {
+            createDirectory(dir);
+        }
+        fs.copyFileSync(source, destination);
+        Logger.info(`Copied file: ${source} → ${destination}`);
+        return true;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to copy file ${source}:`, error);
+    }
+};
+/**
+ * Get directory size in bytes
+ */
+const getDirectorySize = (dirPath) => {
+    let size = 0;
+    try {
+        if (!fs.existsSync(dirPath))
+            return 0;
+        const traverse = (dir) => {
+            const entries = fs.readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry);
+                const stat = fs.statSync(fullPath);
+                if (stat.isFile()) {
+                    size += stat.size;
+                }
+                else if (stat.isDirectory()) {
+                    traverse(fullPath);
+                }
+            }
+        };
+        traverse(dirPath);
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to calculate directory size for ${dirPath}:`, error);
+    }
+    return size;
+};
+/**
+ * FileGenerator namespace - sealed for immutability
+ */
+export const FileGenerator = Object.freeze({
+    createDirectory,
+    createDirectories,
+    writeFile,
+    writeFiles,
+    readFile,
+    fileExists,
+    directoryExists,
+    deleteFile,
+    deleteDirectory,
+    listFiles,
+    copyFile,
+    getDirectorySize,
+});

package/src/cli/scaffolding/GovernanceScaffolder.d.ts

@@ -0,0 +1,23 @@
+/**
+ * GovernanceScaffolder
+ *
+ * Adds optional governance tooling to a generated app:
+ * - ESLint config + scripts
+ * - Architecture tests (Vitest)
+ */
+export type GovernanceScaffoldOptions = Readonly<{
+    writeEslintConfig?: boolean;
+    writeArchTests?: boolean;
+    install?: boolean;
+    packageManager?: string;
+}>;
+export type GovernanceScaffoldResult = Readonly<{
+    success: boolean;
+    filesCreated: string[];
+    message: string;
+}>;
+export declare const GovernanceScaffolder: Readonly<{
+    scaffold(projectRoot: string, options?: GovernanceScaffoldOptions): Promise<GovernanceScaffoldResult>;
+}>;
+export default GovernanceScaffolder;
+//# sourceMappingURL=GovernanceScaffolder.d.ts.map

package/src/cli/scaffolding/GovernanceScaffolder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GovernanceScaffolder.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/GovernanceScaffolder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmBH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAC/C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AA8RH,eAAO,MAAM,oBAAoB;0BAEhB,MAAM,YACV,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC;EA+DpC,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/src/cli/scaffolding/GovernanceScaffolder.js

@@ -0,0 +1,327 @@
+/**
+ * GovernanceScaffolder
+ *
+ * Adds optional governance tooling to a generated app:
+ * - ESLint config + scripts
+ * - Architecture tests (Vitest)
+ */
+import { FileGenerator } from '../scaffolding/FileGenerator.js';
+import { SpawnUtil } from '../utils/spawn.js';
+import { resolvePackageManager } from '../../common/index.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import * as path from '../../node-singletons/path.js';
+const getStringRecord = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const obj = value;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (typeof v === 'string')
+            out[k] = v;
+    }
+    return out;
+};
+const readPackageJsonOrThrow = (projectRoot) => {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (!FileGenerator.fileExists(pkgPath)) {
+        throw ErrorFactory.createValidationError(`package.json not found at ${pkgPath}`);
+    }
+    const raw = FileGenerator.readFile(pkgPath);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw ErrorFactory.createValidationError('package.json is not a JSON object');
+    }
+    return parsed;
+};
+const writePackageJson = (projectRoot, pkg) => {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    const content = `${JSON.stringify(pkg, null, 2)}\n`;
+    FileGenerator.writeFile(pkgPath, content, { overwrite: true });
+};
+const upsertScript = (scripts, name, value) => {
+    if (typeof scripts[name] !== 'string' || scripts[name] === '') {
+        scripts[name] = value;
+    }
+};
+const ensureDevDependency = (devDependencies, name, version) => {
+    if (typeof devDependencies[name] !== 'string' || devDependencies[name] === '') {
+        devDependencies[name] = version;
+    }
+};
+const inferGovernanceVersion = (pkg) => {
+    const deps = getStringRecord(pkg.dependencies);
+    const core = deps?.['@zintrust/core'];
+    if (typeof core === 'string' && core.trim() !== '')
+        return core;
+    return '^0.1.0';
+};
+const writeEslintConfig = (projectRoot) => {
+    const eslintConfigPath = path.join(projectRoot, 'eslint.config.mjs');
+    const content = `import { zintrustAppEslintConfig } from '@zintrust/governance';
+
+export default zintrustAppEslintConfig({
+  tsconfigRootDir: import.meta.dirname,
+});
+`;
+    const wrote = FileGenerator.writeFile(eslintConfigPath, content, { overwrite: false });
+    return wrote ? [eslintConfigPath] : [];
+};
+const IMPORT_BOUNDARIES_ARCH_TEST_CONTENT = `import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+
+type ImportHit = {
+  specifier: string;
+  line: string;
+};
+
+type Violation = {
+  file: string;
+  reason: string;
+  hit: ImportHit;
+};
+
+const repoRoot = process.cwd();
+
+const isTsFile = (filePath: string): boolean => {
+  if (!filePath.endsWith('.ts')) return false;
+  if (filePath.endsWith('.d.ts')) return false;
+  return true;
+};
+
+const walkTsFiles = async (dir: string): Promise<string[]> => {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  const files = entries
+    .filter((ent) => ent.isFile())
+    .map((ent) => path.join(dir, ent.name))
+    .filter(isTsFile);
+
+  const subDirs = entries.filter((ent) => ent.isDirectory()).map((ent) => path.join(dir, ent.name));
+  const nested = await Promise.all(subDirs.map((subDir) => walkTsFiles(subDir)));
+
+  return [...files, ...nested.flat()];
+};
+
+const extractImportSpecifiers = (source: string, filePath: string): ImportHit[] => {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.ESNext,
+    true,
+    ts.ScriptKind.TS
+  );
+  const lines = source.split(/\r?\n/);
+  const hits: ImportHit[] = [];
+
+  const addHit = (specifier: string, pos: number) => {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+    hits.push({
+      specifier,
+      line: (lines[line] ?? '').trim(),
+    });
+  };
+
+  const visit = (node: ts.Node) => {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+        addHit(moduleSpecifier.text, moduleSpecifier.getStart(sourceFile));
+      }
+    }
+
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const arg = node.arguments.at(0);
+      if (arg && ts.isStringLiteral(arg)) {
+        addHit(arg.text, arg.getStart(sourceFile));
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return hits.filter((h) => h.specifier.trim() !== '');
+};
+
+const relFromRoot = (absPath: string): string => path.relative(repoRoot, absPath).replaceAll('\\\\', '/');
+
+const startsWithAny = (value: string, prefixes: readonly string[]): boolean => {
+  for (const p of prefixes) {
+    if (value.startsWith(p)) return true;
+  }
+  return false;
+};
+
+const findViolations = async (
+  files: string[],
+  disallowedPrefixes: readonly string[],
+  reasonPrefix: string
+): Promise<Violation[]> => {
+  const perFile = await Promise.all(
+    files.map(async (file): Promise<Violation[]> => {
+      const contents = await fs.readFile(file, 'utf-8');
+      const imports = extractImportSpecifiers(contents, file);
+
+      return imports
+        .filter((hit) => startsWithAny(hit.specifier, disallowedPrefixes))
+        .map((hit) => ({
+          file: relFromRoot(file),
+          reason: reasonPrefix + ' ' + hit.specifier,
+          hit,
+        }));
+    })
+  );
+
+  return perFile.flat();
+};
+
+describe('Architecture: import boundaries', () => {
+  it('prevents src/ from importing app/routes', async () => {
+    const srcDir = path.join(repoRoot, 'src');
+    const files = await walkTsFiles(srcDir);
+
+    const violations = await findViolations(files, ['@app/', '@routes/'], 'src/ must not import');
+
+    expect(violations).toEqual([]);
+  });
+
+  it('prevents app/ from importing routes', async () => {
+    const appDir = path.join(repoRoot, 'app');
+    const files = await walkTsFiles(appDir);
+
+    const violations = await findViolations(files, ['@routes/'], 'app/ must not import');
+
+    expect(violations).toEqual([]);
+  });
+});
+`;
+const ROUTE_MIDDLEWARE_REGISTRY_ARCH_TEST_CONTENT = `import { middlewareConfigObj } from '../../config/middleware';
+import { registerRoutes } from '../../../routes/api';
+import { RouteRegistry, Router } from '../../index.js';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+describe('Architecture: route middleware registry', () => {
+  beforeEach(() => {
+    RouteRegistry.clear();
+  });
+
+  it('ensures all route middleware names exist in middlewareConfigObj', () => {
+    const router = Router.createRouter();
+    registerRoutes(router);
+
+    const allowed = new Set(Object.keys(middlewareConfigObj));
+    const unknown: Array<{ method: string; path: string; middleware: string }> = [];
+
+    for (const route of RouteRegistry.list()) {
+      for (const name of route.middleware ?? []) {
+        if (!allowed.has(name)) {
+          unknown.push({ method: route.method, path: route.path, middleware: name });
+        }
+      }
+    }
+
+    expect(unknown).toEqual([]);
+  });
+});
+`;
+const writeArchTests = (projectRoot) => {
+    const files = [
+        {
+            rel: 'tests/unit/architecture/ImportBoundaries.arch.test.ts',
+            content: IMPORT_BOUNDARIES_ARCH_TEST_CONTENT,
+        },
+        {
+            rel: 'tests/unit/architecture/RouteMiddlewareRegistry.arch.test.ts',
+            content: ROUTE_MIDDLEWARE_REGISTRY_ARCH_TEST_CONTENT,
+        },
+    ];
+    const created = [];
+    for (const file of files) {
+        const abs = path.join(projectRoot, file.rel);
+        const wrote = FileGenerator.writeFile(abs, file.content, {
+            overwrite: false,
+            createDirs: true,
+        });
+        if (wrote)
+            created.push(abs);
+    }
+    return created;
+};
+const installGovernanceDeps = async (projectRoot, pm, packages) => {
+    if (packages.length === 0)
+        return;
+    let command = pm;
+    let args;
+    switch (pm) {
+        case 'pnpm':
+            args = ['add', '-D', ...packages];
+            break;
+        case 'yarn':
+            args = ['add', '--dev', ...packages];
+            break;
+        case 'npm':
+        default:
+            command = 'npm';
+            args = ['install', '--save-dev', ...packages];
+            break;
+    }
+    const exit = await SpawnUtil.spawnAndWait({ command, args, cwd: projectRoot });
+    if (exit !== 0) {
+        throw ErrorFactory.createCliError(`Failed to install governance dependencies (exit ${exit})`);
+    }
+};
+export const GovernanceScaffolder = Object.freeze({
+    async scaffold(projectRoot, options = {}) {
+        try {
+            const pkg = readPackageJsonOrThrow(projectRoot);
+            const scripts = typeof pkg.scripts === 'object' && pkg.scripts !== null ? pkg.scripts : {};
+            pkg.scripts = scripts;
+            upsertScript(scripts, 'lint', 'eslint .');
+            upsertScript(scripts, 'test:coverage', 'vitest run --coverage');
+            upsertScript(scripts, 'sonarqube', 'node -e "console.log(\'SonarQube not configured for this project; skipping.\');"');
+            const devDeps = typeof pkg.devDependencies === 'object' && pkg.devDependencies !== null
+                ? pkg.devDependencies
+                : {};
+            pkg.devDependencies = devDeps;
+            const govVersion = inferGovernanceVersion(pkg);
+            ensureDevDependency(devDeps, 'eslint', '^9.0.0');
+            ensureDevDependency(devDeps, '@zintrust/governance', govVersion);
+            writePackageJson(projectRoot, pkg);
+            const filesCreated = [];
+            if (options.writeEslintConfig !== false) {
+                filesCreated.push(...writeEslintConfig(projectRoot));
+            }
+            if (options.writeArchTests !== false) {
+                filesCreated.push(...writeArchTests(projectRoot));
+            }
+            if (options.install === true) {
+                const pm = typeof options.packageManager === 'string' && options.packageManager.trim() !== ''
+                    ? options.packageManager.trim()
+                    : resolvePackageManager();
+                Logger.info(`Installing governance devDependencies using ${pm}...`);
+                await installGovernanceDeps(projectRoot, pm, [
+                    'eslint',
+                    `@zintrust/governance@${govVersion}`,
+                ]);
+            }
+            return {
+                success: true,
+                filesCreated,
+                message: 'Governance installed successfully',
+            };
+        }
+        catch (error) {
+            Logger.error('Governance scaffolding failed', error);
+            const msg = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                filesCreated: [],
+                message: msg,
+            };
+        }
+    },
+});
+export default GovernanceScaffolder;

package/src/cli/scaffolding/MigrationGenerator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * MigrationGenerator - Generate database migrations
+ * Creates migration files for schema changes
+ */
+export type MigrationType = 'create' | 'alter' | 'drop';
+export interface MigrationOptions {
+    name: string;
+    migrationsPath: string;
+    type?: MigrationType;
+    /**
+     * Optional explicit table name to use in generated content.
+     * When provided, the generator will use it instead of inferring from the migration name.
+     */
+    table?: string;
+    /**
+     * Optional column name hint for alter migrations.
+     * When provided, the generator will use it in the example placeholder.
+     */
+    column?: string;
+}
+export interface MigrationScaffoldResult {
+    success: boolean;
+    migrationName: string;
+    filePath: string;
+    message: string;
+}
+/**
+ * Validate migration options
+ */
+export declare function validateOptions(options: MigrationOptions): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate migration file
+ */
+export declare function generateMigration(options: MigrationOptions): Promise<MigrationScaffoldResult>;
+/**
+ * MigrationGenerator creates database migration files
+ */
+export declare const MigrationGenerator: Readonly<{
+    validateOptions: typeof validateOptions;
+    generateMigration: typeof generateMigration;
+}>;
+//# sourceMappingURL=MigrationGenerator.d.ts.map

package/src/cli/scaffolding/MigrationGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrationGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/MigrationGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAExD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAmB/F;AAED;;GAEG;AAEH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAwE7F;AAoRD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;EAG7B,CAAC"}