nestgen-cli 0.1.0 → 0.2.2

package/dist/cli/doctor-output.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+/** Human-readable presentation only; structured diagnostics remain unchanged. */
+export function formatDoctorOutput(diagnostics, options = {}) {
+    const groups = [
+        { severity: 'ERROR', title: 'À corriger', marker: '✖', color: chalk.red },
+        { severity: 'WARNING', title: 'À vérifier', marker: '⚠', color: chalk.yellow },
+        { severity: 'INFO', title: 'Vérifications', marker: '✓', color: chalk.green },
+    ];
+    const lines = options.quiet
+        ? []
+        : [
+            '',
+            `  ${chalk.cyan.bold('◆ NestGen')} ${chalk.bold('Doctor')}`,
+            chalk.dim('  Diagnostic de votre environnement'),
+            '',
+        ];
+    for (const group of groups) {
+        if (options.quiet && group.severity === 'INFO')
+            continue;
+        const entries = diagnostics.filter((diagnostic) => diagnostic.severity === group.severity);
+        if (!entries.length)
+            continue;
+        if (!options.quiet)
+            lines.push(`  ${group.color.bold(group.title)} ${chalk.dim(`(${entries.length})`)}`, '');
+        for (const diagnostic of entries) {
+            lines.push(`  ${group.color(group.marker)} ${diagnostic.cause}`);
+            if (diagnostic.severity !== 'INFO' || (diagnostic.id === 'NESTGEN_CONFIG' && !diagnostic.detail))
+                lines.push(`    → ${diagnostic.action}`);
+            if (options.verbose) {
+                lines.push(chalk.dim(`    Code : ${diagnostic.id}`));
+                if (diagnostic.detail)
+                    lines.push(chalk.dim(`    Détail : ${diagnostic.detail}`));
+            }
+        }
+        if (!options.quiet)
+            lines.push('');
+    }
+    if (!options.quiet) {
+        const count = (severity) => diagnostics.filter((diagnostic) => diagnostic.severity === severity).length;
+        const errors = count('ERROR');
+        const warnings = count('WARNING');
+        lines.push(chalk.dim('  ────────────────────────────────────────'), `  ${errors ? chalk.red.bold('✖ Des corrections sont nécessaires') : warnings ? chalk.yellow.bold('⚠ Quelques points à vérifier') : chalk.green.bold('✓ Votre environnement est prêt')}`, `  ${chalk.red(`${errors} erreur${errors > 1 ? 's' : ''}`)}  ·  ${chalk.yellow(`${warnings} avertissement${warnings > 1 ? 's' : ''}`)}  ·  ${chalk.dim(`${count('INFO')} vérifications`)}`, '');
+    }
+    return lines.join('\n');
+}

package/dist/cli/output.js

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+export function heading(title, subtitle) {
+    return `\n  ${chalk.cyan.bold('◆ NestGen')} ${chalk.bold(title)}\n${subtitle ? `${chalk.dim(`  ${subtitle}`)}\n` : ''}`;
+}
+export function success(message) {
+    return `\n  ${chalk.green('✓')} ${chalk.bold(message)}\n`;
+}
+export function formatError(message) {
+    return `${heading('Erreur')}  ${chalk.red('✖')} ${message.split('\n').join('\n    ')}\n`;
+}
+export function formatConfig(config, subtitle) {
+    const rows = [
+        ['ORM', config.orm],
+        ['Architecture', config.profile],
+        ['Sources', config.sourceRoot],
+        ['Package manager', config.packageManager],
+        ['Version configuration', config.version],
+        ['Version templates', config.templateVersion],
+    ];
+    return `${heading('Configuration', subtitle)}${rows.map(([label, value]) => `  ${chalk.dim(label.padEnd(24))}${value}`).join('\n')}\n`;
+}
+export function formatMigration(migration) {
+    return [
+        `  ${chalk.bold('Migration à préparer')}`,
+        `    ${chalk.cyan(migration.command)}`,
+        chalk.dim('    Cette commande prépare la migration ; aucune migration appliquée.'),
+        ...migration.risks.map((risk) => `    ${risk.severity === 'danger' ? chalk.red('✖') : chalk.yellow('⚠')} ${risk.message}`),
+        '',
+    ].join('\n');
+}
+export function formatPlan(plan, verbose = false) {
+    const lines = [heading('Aperçu', `Génération ${plan.operation} · aucun fichier écrit`)];
+    for (const change of plan.changes) {
+        const label = change.status === 'create'
+            ? chalk.green('+ Créer')
+            : change.status === 'replace'
+                ? chalk.cyan('~ Modifier')
+                : chalk.red('✖ Conflit');
+        lines.push(`  ${label}  ${change.path}`);
+        if (change.reason)
+            lines.push(`    ${chalk.yellow(change.reason)}`);
+        if (verbose && change.diff)
+            lines.push(chalk.dim(`    ${change.diff.split('\n').join('\n    ')}`));
+    }
+    for (const conflict of plan.conflicts.filter((conflict) => !conflict.path))
+        lines.push(`  ${chalk.red('✖')} ${conflict.reason}`);
+    lines.push('', chalk.dim('  ────────────────────────────────────────'), `  ${plan.changes.length} fichiers · ${plan.conflicts.length} conflits`, '');
+    if (plan.migration)
+        lines.push(formatMigration(plan.migration));
+    return lines.join('\n');
+}
+/** Align help columns from the complete existing command/option descriptions. */
+export function formatHelp(usage) {
+    return `${heading('Aide')}${usage
+        .split('\n')
+        .map((line) => {
+        if (!line)
+            return '';
+        if (!line.startsWith(' '))
+            return `  ${chalk.bold(line)}`;
+        const [label, description] = line.trim().split(/\s{2,}/);
+        return description ? `  ${chalk.cyan(label.padEnd(34))}  ${description}` : `  ${line.trim()}`;
+    })
+        .join('\n')}\n`;
+}

package/dist/engine/file-transaction.js

@@ -0,0 +1,166 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectPath } from './project-path.js';
+const transactionDirectory = '.nestgen-transaction';
+function contentDiff(file, before, after) {
+    const removed = before
+        .split(/(?<=\n)/)
+        .map((line) => `-${line}`)
+        .join('');
+    const added = after
+        .split(/(?<=\n)/)
+        .map((line) => `+${line}`)
+        .join('');
+    return `--- ${file}\n+++ ${file}\n@@\n${removed}${added}`;
+}
+/** Inspect the exact file writes of a generation without touching the filesystem. */
+export function previewFileChanges(projectRoot, changes) {
+    const root = fs.realpathSync(projectRoot);
+    const seen = new Set();
+    return changes.map((change) => {
+        let target;
+        try {
+            target = projectPath(root, change.path);
+        }
+        catch (cause) {
+            return {
+                ...change,
+                status: 'conflict',
+                reason: cause instanceof Error ? cause.message : String(cause),
+            };
+        }
+        if (seen.has(target))
+            return { ...change, status: 'conflict', reason: `Destination dupliquée : ${change.path}` };
+        seen.add(target);
+        if (path.relative(root, target).split(path.sep)[0].startsWith(transactionDirectory))
+            return { ...change, status: 'conflict', reason: `Destination réservée : ${change.path}` };
+        const stat = fs.lstatSync(target, { throwIfNoEntry: false });
+        if (change.operation === 'create' && stat)
+            return { ...change, status: 'conflict', reason: `Le fichier existe déjà : ${change.path}` };
+        if (change.operation === 'replace' && !stat?.isFile())
+            return { ...change, status: 'conflict', reason: `Fichier à remplacer introuvable : ${change.path}` };
+        const before = stat ? fs.readFileSync(target, 'utf8') : '';
+        return {
+            ...change,
+            status: change.operation,
+            diff: contentDiff(change.path, before, change.content),
+        };
+    });
+}
+/** Apply a fully validated plan; roll back all applied files when a filesystem operation fails. */
+export function applyFileChanges(projectRoot, changes) {
+    const root = fs.realpathSync(projectRoot);
+    const stage = path.join(root, transactionDirectory);
+    const targets = new Set();
+    const plan = changes.map((change, index) => {
+        const target = projectPath(root, change.path);
+        const relative = path.relative(root, target);
+        if (relative.split(path.sep)[0].startsWith('.nestgen-transaction'))
+            throw new Error(`Destination réservée : ${change.path}`);
+        if (targets.has(target))
+            throw new Error(`Destination dupliquée : ${change.path}`);
+        targets.add(target);
+        const stat = fs.lstatSync(target, { throwIfNoEntry: false });
+        if (change.operation === 'create' && stat)
+            throw new Error(`Le fichier existe déjà : ${change.path}`);
+        if (change.operation === 'replace' && !stat?.isFile())
+            throw new Error(`Fichier à remplacer introuvable : ${change.path}`);
+        return {
+            ...change,
+            target,
+            original: stat ? fs.readFileSync(target) : undefined,
+            mode: stat ? stat.mode & 0o777 : 0o666 & ~process.umask(),
+            prepared: path.join(stage, `new-${index}`),
+            backup: path.join(stage, `old-${index}`),
+        };
+    });
+    for (const item of plan) {
+        let parent = path.dirname(item.target);
+        while (parent !== root) {
+            if (targets.has(parent))
+                throw new Error(`Conflit fichier/répertoire : ${parent}`);
+            parent = path.dirname(parent);
+        }
+    }
+    if (fs.existsSync(path.join(root, '.nestgen-transaction.json')))
+        throw new Error('Transaction interrompue détectée : .nestgen-transaction.json.');
+    // mkdir without recursive is an exclusive lock; never remove a lock owned by another invocation.
+    fs.mkdirSync(stage);
+    const directories = [];
+    const applied = [];
+    let retainBackups = false;
+    let committed = false;
+    try {
+        fs.writeFileSync(path.join(stage, 'manifest.json'), JSON.stringify(plan.map(({ path: file, operation, mode }, index) => ({ file, operation, mode, index }))));
+        for (const item of plan) {
+            fs.writeFileSync(item.prepared, item.content, { flag: 'wx', mode: item.mode });
+            fs.chmodSync(item.prepared, item.mode);
+            if (item.original !== undefined) {
+                fs.writeFileSync(item.backup, item.original, { flag: 'wx', mode: item.mode });
+                fs.chmodSync(item.backup, item.mode);
+            }
+        }
+        for (const item of plan) {
+            const missing = [];
+            let parent = path.dirname(item.target);
+            while (!fs.existsSync(parent)) {
+                missing.push(parent);
+                parent = path.dirname(parent);
+            }
+            for (const directory of missing.reverse()) {
+                fs.mkdirSync(directory);
+                directories.push(directory);
+            }
+            if (item.original !== undefined) {
+                if (!fs.readFileSync(item.target).equals(item.original))
+                    throw new Error(`Le fichier a changé pendant la génération : ${item.path}`);
+            }
+            else if (fs.existsSync(item.target)) {
+                throw new Error(`Le fichier est apparu pendant la génération : ${item.path}`);
+            }
+            fs.renameSync(item.prepared, item.target);
+            applied.push(item);
+        }
+        committed = true;
+    }
+    catch (error) {
+        const failures = [];
+        for (const item of applied.reverse()) {
+            try {
+                if (item.original !== undefined)
+                    fs.renameSync(item.backup, item.target);
+                else
+                    fs.unlinkSync(item.target);
+            }
+            catch (rollbackError) {
+                failures.push(rollbackError);
+            }
+        }
+        for (const directory of directories.reverse()) {
+            try {
+                fs.rmdirSync(directory);
+            }
+            catch (rollbackError) {
+                failures.push(rollbackError);
+            }
+        }
+        if (failures.length) {
+            retainBackups = true;
+            throw new AggregateError([error, ...failures], `Restauration incomplète ; sauvegardes conservées : ${stage}`);
+        }
+        throw error;
+    }
+    finally {
+        if (!retainBackups) {
+            try {
+                fs.rmSync(stage, { recursive: true, force: true });
+            }
+            catch (cleanupError) {
+                if (!committed)
+                    throw cleanupError;
+                // The complete plan is already committed. Never report a failed generation after that point.
+                console.warn(`Génération terminée ; nettoyage manuel nécessaire : ${stage}`, cleanupError);
+            }
+        }
+    }
+}

package/dist/engine/generated-code.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { format, resolveConfig } from 'prettier';
+/** Format newly generated TypeScript in memory before the transaction can write anything. */
+export async function formatGeneratedCode(root, changes) {
+    const result = [];
+    for (const change of changes) {
+        // Existing shared files contain user formatting; their targeted edits must stay targeted.
+        if (change.operation !== 'create' || !change.path.endsWith('.ts')) {
+            result.push(change);
+            continue;
+        }
+        const filepath = path.join(root, change.path);
+        const options = await resolveConfig(filepath, { editorconfig: true, useCache: false });
+        result.push({
+            ...change,
+            content: await format(change.content, {
+                singleQuote: true,
+                trailingComma: 'all',
+                ...options,
+                filepath,
+                parser: 'typescript',
+            }),
+        });
+    }
+    return result;
+}

package/dist/engine/generation-manifest.js

@@ -0,0 +1,118 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { projectPath } from './project-path.js';
+export const generationManifestPath = '.nestgen/generation-manifest.json';
+const manifestVersion = 1;
+function generatorVersion() {
+    const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../package.json');
+    const manifest = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    if (typeof manifest.version !== 'string')
+        throw new Error('Version du générateur introuvable.');
+    return manifest.version;
+}
+function generationKey(definition) {
+    return `${definition.kind}:${definition.sourceRoot}/app/${definition.name}`;
+}
+export function resourceGenerationKey(sourceRoot, name) {
+    return `resource:${sourceRoot}/app/${name}`;
+}
+function sha256(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+function normalizeManifest(manifest) {
+    return {
+        version: 1,
+        generations: Object.fromEntries(Object.entries(manifest.generations)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [
+            key,
+            {
+                definition: entry.definition,
+                files: Object.fromEntries(Object.entries(entry.files).sort(([left], [right]) => left.localeCompare(right))),
+                generator: entry.generator,
+            },
+        ])),
+    };
+}
+export function loadGenerationManifest(projectRoot) {
+    const file = projectPath(projectRoot, generationManifestPath);
+    if (!fs.existsSync(file))
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new Error('Le manifeste de génération est invalide.');
+    }
+    if (!value || typeof value !== 'object' || value.version !== manifestVersion)
+        throw new Error('Version de manifeste de génération non supportée.');
+    const generations = value.generations;
+    if (!generations || typeof generations !== 'object' || Array.isArray(generations))
+        throw new Error('Le manifeste de génération est invalide.');
+    return normalizeManifest(value);
+}
+function resourceDefinition(name, orm, sourceRoot, route, table, profile, fields, indexes, relations, list) {
+    return {
+        kind: 'resource',
+        name,
+        orm,
+        sourceRoot,
+        route,
+        table,
+        profile,
+        // Defaults can contain domain secrets. They remain in the resource definition,
+        // but generation metadata must stay safe to commit.
+        fields: fields.map(({ defaultValue: _defaultValue, ...field }) => field),
+        indexes,
+        relations,
+        list,
+    };
+}
+export function moduleGenerationDefinition(name, orm, sourceRoot) {
+    return { kind: 'module', name, orm, sourceRoot };
+}
+export function resourceGenerationDefinition(name, orm, sourceRoot, route, table, profile, fields, indexes, relations, list) {
+    return resourceDefinition(name, orm, sourceRoot, route, table, profile, fields, indexes, relations, list);
+}
+/** Add the versioned generation manifest to the same transaction as generated files. */
+export function withGenerationManifest(projectRoot, changes, definition) {
+    const existing = loadGenerationManifest(projectRoot) ?? { version: 1, generations: {} };
+    const files = Object.fromEntries(changes
+        .map((change) => [change.path, sha256(change.content)])
+        .sort(([left], [right]) => left.localeCompare(right)));
+    const manifest = normalizeManifest({
+        ...existing,
+        generations: {
+            ...existing.generations,
+            [generationKey(definition)]: {
+                definition,
+                files,
+                generator: { name: 'nestgen-cli', version: generatorVersion() },
+            },
+        },
+    });
+    return [
+        ...changes,
+        {
+            path: generationManifestPath,
+            content: `${JSON.stringify(manifest, null, 2)}\n`,
+            operation: existing.generations[generationKey(definition)] ||
+                fs.existsSync(projectPath(projectRoot, generationManifestPath))
+                ? 'replace'
+                : 'create',
+        },
+    ];
+}
+/** Report generated files changed after their recorded successful generation. */
+export function modifiedGeneratedFiles(projectRoot, entry) {
+    return Object.entries(entry.files)
+        .filter(([file, fingerprint]) => {
+        const target = projectPath(projectRoot, file);
+        return !fs.existsSync(target) || sha256(fs.readFileSync(target, 'utf8')) !== fingerprint;
+    })
+        .map(([file]) => file)
+        .sort();
+}

package/dist/engine/migration-plan.js

@@ -0,0 +1,78 @@
+import { loadGenerationManifest, resourceGenerationKey } from './generation-manifest.js';
+function migrationName(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(normalized))
+        throw new Error('Nom de migration invalide. Utilisez des minuscules, chiffres et tirets.');
+    return normalized;
+}
+function indexKey(index) {
+    return `${index.unique ? 'unique:' : 'index:'}${index.fields.join('+')}`;
+}
+/** Plan an official ORM migration without generating or applying it. */
+export function planResourceMigration(projectRoot, sourceRoot, resourceName, orm, requestedName, fields, indexes, relations) {
+    const manifest = loadGenerationManifest(projectRoot);
+    const entry = manifest?.generations[resourceGenerationKey(sourceRoot, resourceName)];
+    if (!entry || entry.definition.kind !== 'resource')
+        throw new Error(`Aucun manifeste de génération pour la ressource ${resourceName}.`);
+    const previous = entry.definition;
+    if (previous.kind !== 'resource' || entry.definition.orm !== orm)
+        throw new Error(`Le manifeste de la ressource ${resourceName} ne correspond pas à l'ORM ${orm}.`);
+    const risks = [];
+    const previousFields = new Map(previous.fields.map((field) => [field.name, field]));
+    const nextFields = new Map(fields.map((field) => [field.name, field]));
+    for (const [name, field] of previousFields) {
+        const next = nextFields.get(name);
+        if (!next) {
+            risks.push({
+                id: 'COLUMN_REMOVED',
+                severity: 'danger',
+                message: `Suppression potentielle de la colonne ${name}.`,
+            });
+            continue;
+        }
+        if (next.type !== field.type) {
+            risks.push({
+                id: 'FIELD_TYPE_CHANGED',
+                severity: 'danger',
+                message: `Changement de type potentiel pour ${name} (${field.type} vers ${next.type}).`,
+            });
+        }
+        if (field.nullable && !next.nullable) {
+            risks.push({
+                id: 'NULLABILITY_TIGHTENED',
+                severity: 'warning',
+                message: `${name} devient obligatoire ; les lignes existantes doivent être complétées.`,
+            });
+        }
+    }
+    const previousIndexes = new Set(previous.indexes.filter((index) => index.unique).map(indexKey));
+    for (const index of indexes.filter((item) => item.unique)) {
+        if (!previousIndexes.has(indexKey(index)))
+            risks.push({
+                id: 'UNIQUE_CONSTRAINT_ADDED',
+                severity: 'warning',
+                message: `Contrainte unique ajoutée sur ${index.fields.join(', ')} ; vérifiez les doublons existants.`,
+            });
+    }
+    const previousRelations = new Set(previous.relations.map((relation) => `${relation.type}:${relation.target}:${relation.field ?? ''}`));
+    const nextRelations = new Set(relations.map((relation) => `${relation.type}:${relation.target}:${relation.field ?? ''}`));
+    for (const relation of previousRelations) {
+        if (!nextRelations.has(relation))
+            risks.push({
+                id: 'RELATION_REMOVED',
+                severity: 'danger',
+                message: `Suppression potentielle de relation ${relation}.`,
+            });
+    }
+    const name = migrationName(requestedName);
+    return {
+        version: 1,
+        orm,
+        migrationName: name,
+        command: orm === 'typeorm'
+            ? `npx typeorm-ts-node-commonjs migration:generate src/database/migrations/${name} --dataSource src/database/data-source.ts`
+            : `npx prisma migrate dev --create-only --name ${name}`,
+        risks,
+        appliesMigration: false,
+    };
+}