@gadmin2n/cli 0.0.91 → 0.0.92

package/lib/template-merge/json-merger.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonMerger = void 0;
+const PRESERVE_INSTANCE_KEYS = new Set([
+    'name',
+    'version',
+    'description',
+    'private',
+    'author',
+    'license',
+    'homepage',
+    'repository',
+    'bugs',
+]);
+const DEEP_MERGE_KEYS = new Set([
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+    'scripts',
+    'engines',
+    'volta',
+]);
+const POLICY_OBJECT_KEYS = new Set([
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+    'scripts',
+]);
+function isPlainObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function detectIndent(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (line.length === 0)
+            continue;
+        const m = line.match(/^([ \t]+)\S/);
+        if (!m)
+            continue;
+        const lead = m[1];
+        if (lead[0] === '\t')
+            return '\t';
+        if (lead.length >= 4)
+            return 4;
+        return 2;
+    }
+    return 2;
+}
+function unionArray(instArr, tmplArr) {
+    const seen = new Set();
+    const out = [];
+    for (const item of instArr) {
+        const key = JSON.stringify(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(item);
+        }
+    }
+    for (const item of tmplArr) {
+        const key = JSON.stringify(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(item);
+        }
+    }
+    return out;
+}
+function deepMergeKeepInstance(inst, tmpl) {
+    if (isPlainObject(inst) && isPlainObject(tmpl)) {
+        const out = {};
+        for (const k of Object.keys(inst)) {
+            if (k in tmpl) {
+                out[k] = deepMergeKeepInstance(inst[k], tmpl[k]);
+            }
+            else {
+                out[k] = inst[k];
+            }
+        }
+        for (const k of Object.keys(tmpl)) {
+            if (!(k in inst)) {
+                out[k] = tmpl[k];
+            }
+        }
+        return out;
+    }
+    if (Array.isArray(inst) && Array.isArray(tmpl)) {
+        return unionArray(inst, tmpl);
+    }
+    return inst;
+}
+function formatVal(v) {
+    if (typeof v === 'string')
+        return v;
+    return JSON.stringify(v);
+}
+class JsonMerger {
+    constructor() {
+        this.name = 'json';
+    }
+    merge(ctx) {
+        let instData;
+        let tmplData;
+        try {
+            instData = JSON.parse(ctx.instanceContent);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { ok: false, reason: `parse failure: instance JSON: ${msg}` };
+        }
+        try {
+            tmplData = JSON.parse(ctx.templateContent);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { ok: false, reason: `parse failure: template JSON: ${msg}` };
+        }
+        const indent = detectIndent(ctx.instanceContent);
+        const hasTrailingNewline = ctx.instanceContent.endsWith('\n');
+        const policies = ctx.policies || {};
+        const notes = [];
+        if (!isPlainObject(instData) || !isPlainObject(tmplData)) {
+            const merged = JSON.stringify(instData, null, indent) +
+                (hasTrailingNewline ? '\n' : '');
+            return { ok: true, merged, notes: ['no changes'] };
+        }
+        const result = {};
+        const orderedKeys = [];
+        for (const k of Object.keys(instData))
+            orderedKeys.push(k);
+        for (const k of Object.keys(tmplData)) {
+            if (!(k in instData))
+                orderedKeys.push(k);
+        }
+        for (const k of orderedKeys) {
+            const inInst = k in instData;
+            const inTmpl = k in tmplData;
+            const instVal = instData[k];
+            const tmplVal = tmplData[k];
+            const policyKey = `json.${k}`;
+            const policy = policies[policyKey];
+            if (POLICY_OBJECT_KEYS.has(k) && policy) {
+                if (policy === 'overwrite') {
+                    if (inTmpl) {
+                        result[k] = tmplVal;
+                        notes.push(`${k}: overwritten with template (policy)`);
+                    }
+                    else if (inInst) {
+                        result[k] = instVal;
+                    }
+                    continue;
+                }
+                if (policy === 'prefer-template' &&
+                    inInst &&
+                    inTmpl &&
+                    isPlainObject(instVal) &&
+                    isPlainObject(tmplVal)) {
+                    const obj = {};
+                    const adds = [];
+                    const changes = [];
+                    for (const ik of Object.keys(instVal)) {
+                        if (ik in tmplVal) {
+                            obj[ik] = tmplVal[ik];
+                            if (JSON.stringify(instVal[ik]) !== JSON.stringify(tmplVal[ik])) {
+                                changes.push(`${ik} (instance ${formatVal(instVal[ik])} -> template ${formatVal(tmplVal[ik])})`);
+                            }
+                        }
+                        else {
+                            obj[ik] = instVal[ik];
+                        }
+                    }
+                    for (const tk of Object.keys(tmplVal)) {
+                        if (!(tk in instVal)) {
+                            obj[tk] = tmplVal[tk];
+                            adds.push(tk);
+                        }
+                    }
+                    result[k] = obj;
+                    if (adds.length > 0) {
+                        notes.push(`${k}: added ${adds.length} from template (${adds.join(', ')})`);
+                    }
+                    for (const c of changes) {
+                        notes.push(`${k}: preferred template version of ${c}`);
+                    }
+                    continue;
+                }
+                // 'preserve-instance' or unmatched policy → fall through
+            }
+            if (inInst && !inTmpl) {
+                result[k] = instVal;
+                continue;
+            }
+            if (!inInst && inTmpl) {
+                result[k] = tmplVal;
+                continue;
+            }
+            if (PRESERVE_INSTANCE_KEYS.has(k)) {
+                result[k] = instVal;
+                continue;
+            }
+            if (DEEP_MERGE_KEYS.has(k) &&
+                isPlainObject(instVal) &&
+                isPlainObject(tmplVal)) {
+                const adds = [];
+                const kept = [];
+                const obj = {};
+                for (const ik of Object.keys(instVal)) {
+                    if (ik in tmplVal) {
+                        obj[ik] = instVal[ik];
+                        if (JSON.stringify(instVal[ik]) !== JSON.stringify(tmplVal[ik])) {
+                            kept.push(`${ik} (instance ${formatVal(instVal[ik])} vs template ${formatVal(tmplVal[ik])})`);
+                        }
+                    }
+                    else {
+                        obj[ik] = instVal[ik];
+                    }
+                }
+                for (const tk of Object.keys(tmplVal)) {
+                    if (!(tk in instVal)) {
+                        obj[tk] = tmplVal[tk];
+                        adds.push(tk);
+                    }
+                }
+                result[k] = obj;
+                if (adds.length > 0) {
+                    notes.push(`${k}: added ${adds.length} from template (${adds.join(', ')})`);
+                }
+                for (const keep of kept) {
+                    notes.push(`${k}: kept instance version of ${keep}`);
+                }
+                continue;
+            }
+            if (isPlainObject(instVal) && isPlainObject(tmplVal)) {
+                result[k] = deepMergeKeepInstance(instVal, tmplVal);
+                continue;
+            }
+            if (Array.isArray(instVal) && Array.isArray(tmplVal)) {
+                result[k] = unionArray(instVal, tmplVal);
+                continue;
+            }
+            result[k] = instVal;
+        }
+        if (notes.length === 0)
+            notes.push('no changes');
+        let serialized = JSON.stringify(result, null, indent);
+        if (hasTrailingNewline)
+            serialized += '\n';
+        return { ok: true, merged: serialized, notes };
+    }
+}
+exports.JsonMerger = JsonMerger;

package/lib/template-merge/merger.d.ts

@@ -0,0 +1,30 @@
+export interface MergeContext {
+    /** Relative path inside instance, e.g. 'web/package.json' */
+    filePath: string;
+    /** Absolute path to instance file */
+    instancePath: string;
+    /** Absolute path to template file */
+    templatePath: string;
+    instanceContent: string;
+    templateContent: string;
+    /** Optional per-merger policy values, dot-namespaced keys e.g. 'json.scripts': 'preserve-instance' */
+    policies?: Record<string, string>;
+}
+export declare type MergeOk = {
+    ok: true;
+    /** Final merged content to write to instance file */
+    merged: string;
+    /** Human-readable lines summarising what the merger did */
+    notes: string[];
+};
+export declare type MergeFail = {
+    ok: false;
+    /** Why this merger could not produce a result; caller should fall back */
+    reason: string;
+};
+export declare type MergeResult = MergeOk | MergeFail;
+export interface Merger {
+    /** Unique id, e.g. 'json' | 'ts-module' | 'prisma' | 'env' | 'skip' */
+    readonly name: string;
+    merge(ctx: MergeContext): Promise<MergeResult> | MergeResult;
+}

package/lib/template-merge/merger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/template-merge/prisma-merger.d.ts

@@ -0,0 +1,5 @@
+import { Merger, MergeContext, MergeResult } from './merger';
+export declare class PrismaMerger implements Merger {
+    readonly name = "prisma";
+    merge(ctx: MergeContext): MergeResult;
+}

package/lib/template-merge/prisma-merger.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaMerger = void 0;
+const BLOCK_HEADER_RE = /^(model|enum|generator|datasource|type|view)\s+(\w+)\s*\{/;
+function parseBlocks(content) {
+    const lines = content.split('\n');
+    const blocks = [];
+    let prefixLines = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const m = line.match(BLOCK_HEADER_RE);
+        if (m) {
+            const kind = m[1];
+            const name = m[2];
+            let depth = 0;
+            const blockLines = [];
+            let endIdx = -1;
+            for (let j = i; j < lines.length; j++) {
+                const l = lines[j];
+                for (const ch of l) {
+                    if (ch === '{')
+                        depth++;
+                    else if (ch === '}') {
+                        depth--;
+                        if (depth < 0) {
+                            return { ok: false, error: 'unbalanced braces' };
+                        }
+                    }
+                }
+                blockLines.push(l);
+                if (depth === 0) {
+                    endIdx = j;
+                    break;
+                }
+            }
+            if (endIdx === -1) {
+                return { ok: false, error: 'unbalanced braces' };
+            }
+            blocks.push({
+                kind,
+                name,
+                prefix: prefixLines.join('\n'),
+                content: blockLines.join('\n'),
+            });
+            prefixLines = [];
+            i = endIdx + 1;
+        }
+        else {
+            prefixLines.push(line);
+            i++;
+        }
+    }
+    return { ok: true, blocks, trailing: prefixLines.join('\n') };
+}
+class PrismaMerger {
+    constructor() {
+        this.name = 'prisma';
+    }
+    merge(ctx) {
+        const instParsed = parseBlocks(ctx.instanceContent);
+        if (!instParsed.ok) {
+            return { ok: false, reason: instParsed.error };
+        }
+        const tmplParsed = parseBlocks(ctx.templateContent);
+        if (!tmplParsed.ok) {
+            return { ok: false, reason: tmplParsed.error };
+        }
+        const instKeys = new Set();
+        const instKinds = new Set();
+        for (const b of instParsed.blocks) {
+            instKeys.add(`${b.kind}:${b.name}`);
+            instKinds.add(b.kind);
+        }
+        const notes = [];
+        const toAppend = [];
+        for (const tb of tmplParsed.blocks) {
+            if (tb.kind === 'generator' || tb.kind === 'datasource') {
+                if (instKinds.has(tb.kind)) {
+                    notes.push(`kept instance ${tb.kind} ${tb.name}`);
+                    continue;
+                }
+                toAppend.push(tb);
+                notes.push(`added ${tb.kind} ${tb.name} from template`);
+                continue;
+            }
+            const key = `${tb.kind}:${tb.name}`;
+            if (instKeys.has(key)) {
+                notes.push(`kept instance version of ${tb.kind} ${tb.name}`);
+            }
+            else {
+                toAppend.push(tb);
+                notes.push(`added ${tb.kind} ${tb.name} from template`);
+            }
+        }
+        let merged = ctx.instanceContent;
+        if (toAppend.length > 0) {
+            if (!merged.endsWith('\n'))
+                merged += '\n';
+            const parts = [];
+            for (const b of toAppend) {
+                const piece = (b.prefix ? b.prefix + '\n' : '') + b.content;
+                parts.push(piece);
+            }
+            merged += parts.join('\n') + '\n';
+        }
+        if (notes.length === 0)
+            notes.push('no changes');
+        return { ok: true, merged, notes };
+    }
+}
+exports.PrismaMerger = PrismaMerger;

package/lib/template-merge/registry.d.ts

@@ -0,0 +1,25 @@
+import { Merger } from './merger';
+export interface MergerRule {
+    /** Glob pattern, e.g. '**\/*.module.ts', 'package.json', 'config/prisma/*.prisma' */
+    pattern: string;
+    /** Refers to a Merger registered by this name in the registry */
+    mergerName: string;
+}
+export declare class MergerRegistry {
+    private mergers;
+    private rules;
+    /** Register a merger keyed by merger.name. Replaces any existing entry. */
+    register(merger: Merger): void;
+    /** Append a rule. Order matters: first match wins in resolve(). */
+    addRule(rule: MergerRule): void;
+    /** Clear all rules (mergers stay registered). Used when user config replaces defaults. */
+    resetRules(): void;
+    /**
+     * Resolve a Merger for the given file path by matching against rules in
+     * insertion order. Returns null if no rule matches OR if the matched rule
+     * names a merger that hasn't been registered.
+     */
+    resolve(filePath: string): Merger | null;
+    /** Look up a merger by name. */
+    getMerger(name: string): Merger | null;
+}

package/lib/template-merge/registry.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergerRegistry = void 0;
+const glob_1 = require("./glob");
+class MergerRegistry {
+    constructor() {
+        this.mergers = new Map();
+        this.rules = [];
+    }
+    /** Register a merger keyed by merger.name. Replaces any existing entry. */
+    register(merger) {
+        this.mergers.set(merger.name, merger);
+    }
+    /** Append a rule. Order matters: first match wins in resolve(). */
+    addRule(rule) {
+        this.rules.push(rule);
+    }
+    /** Clear all rules (mergers stay registered). Used when user config replaces defaults. */
+    resetRules() {
+        this.rules = [];
+    }
+    /**
+     * Resolve a Merger for the given file path by matching against rules in
+     * insertion order. Returns null if no rule matches OR if the matched rule
+     * names a merger that hasn't been registered.
+     */
+    resolve(filePath) {
+        var _a;
+        for (const rule of this.rules) {
+            if ((0, glob_1.globMatch)(filePath, rule.pattern)) {
+                return (_a = this.mergers.get(rule.mergerName)) !== null && _a !== void 0 ? _a : null;
+            }
+        }
+        return null;
+    }
+    /** Look up a merger by name. */
+    getMerger(name) {
+        var _a;
+        return (_a = this.mergers.get(name)) !== null && _a !== void 0 ? _a : null;
+    }
+}
+exports.MergerRegistry = MergerRegistry;

package/lib/template-merge/ts-module-merger.d.ts

@@ -0,0 +1,16 @@
+import { MergeContext, MergeResult, Merger } from './merger';
+/**
+ * Smart merger for NestJS-style `*.module.ts` files.
+ *
+ * Strategy: extract symbols from template's `@Module(...)` metadata arrays
+ * (imports/providers/controllers/exports) and missing top-level `import { ... } from '...'`
+ * lines, then insert each missing item into the instance file. Existing items are
+ * preserved. Method bodies and other class members are not touched.
+ *
+ * Falls back (returns `{ok: false}`) when the instance has no `@Module` decorator
+ * or when AST parsing/insertion throws.
+ */
+export declare class TsModuleMerger implements Merger {
+    readonly name = "ts-module";
+    merge(ctx: MergeContext): MergeResult;
+}

package/lib/template-merge/ts-module-merger.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsModuleMerger = void 0;
+const ts = require("typescript");
+const schematics_1 = require("@gadmin2n/schematics");
+const METADATA_KEYS = ['imports', 'providers', 'controllers', 'exports'];
+/**
+ * Smart merger for NestJS-style `*.module.ts` files.
+ *
+ * Strategy: extract symbols from template's `@Module(...)` metadata arrays
+ * (imports/providers/controllers/exports) and missing top-level `import { ... } from '...'`
+ * lines, then insert each missing item into the instance file. Existing items are
+ * preserved. Method bodies and other class members are not touched.
+ *
+ * Falls back (returns `{ok: false}`) when the instance has no `@Module` decorator
+ * or when AST parsing/insertion throws.
+ */
+class TsModuleMerger {
+    constructor() {
+        this.name = 'ts-module';
+    }
+    merge(ctx) {
+        var _a, _b;
+        const policies = (_a = ctx.policies) !== null && _a !== void 0 ? _a : {};
+        const notes = [];
+        try {
+            const templateSource = ts.createSourceFile('template.ts', ctx.templateContent, ts.ScriptTarget.ES2017, true);
+            const instanceSourceInitial = ts.createSourceFile('instance.ts', ctx.instanceContent, ts.ScriptTarget.ES2017, true);
+            if (!findModuleDecoratorArg(instanceSourceInitial)) {
+                return { ok: false, reason: 'no @Module decorator in instance' };
+            }
+            const templateModuleArg = findModuleDecoratorArg(templateSource);
+            let content = ctx.instanceContent;
+            // 1. Per-slot metadata merge (imports, providers, controllers, exports).
+            if (templateModuleArg) {
+                for (const key of METADATA_KEYS) {
+                    const policy = (_b = policies[`ts-module.${key}`]) !== null && _b !== void 0 ? _b : 'union';
+                    if (policy === 'skip') {
+                        notes.push(`${key}: skip (policy)`);
+                        continue;
+                    }
+                    const templateElements = extractMetadataArrayElements(templateModuleArg, key, templateSource);
+                    if (templateElements.length === 0)
+                        continue;
+                    for (const element of templateElements) {
+                        // Re-parse the current (possibly mutated) instance to get fresh
+                        // existing-element lookup. This mirrors the pattern used in
+                        // schematics' service.factory: each MetadataManager.insert call
+                        // takes the latest content.
+                        const reparsed = ts.createSourceFile('instance.ts', content, ts.ScriptTarget.ES2017, true);
+                        const arg = findModuleDecoratorArg(reparsed);
+                        if (!arg) {
+                            return { ok: false, reason: 'lost @Module decorator during merge' };
+                        }
+                        const existing = extractMetadataArrayElements(arg, key, reparsed);
+                        if (existing.includes(element)) {
+                            notes.push(`${key}: kept ${element}`);
+                            continue;
+                        }
+                        const next = new schematics_1.MetadataManager(content).insert(key, element);
+                        if (next === content) {
+                            // MetadataManager returned content unchanged (e.g. symbol already
+                            // exists by its own equality check). Treat as kept.
+                            notes.push(`${key}: kept ${element}`);
+                        }
+                        else {
+                            content = next;
+                            notes.push(`${key}: added ${element}`);
+                        }
+                    }
+                }
+            }
+            // 2. Top-level import lines merge.
+            const templateImports = collectTopImports(templateSource);
+            const instanceForImports = ts.createSourceFile('instance.ts', content, ts.ScriptTarget.ES2017, true);
+            const instanceImports = collectTopImports(instanceForImports);
+            const existingSymbols = new Set();
+            for (const imp of instanceImports) {
+                for (const s of imp.symbols)
+                    existingSymbols.add(s);
+            }
+            const linesToAdd = [];
+            for (const imp of templateImports) {
+                if (imp.symbols.length === 0)
+                    continue;
+                const allExist = imp.symbols.every((s) => existingSymbols.has(s));
+                if (allExist)
+                    continue;
+                linesToAdd.push(imp.line);
+                for (const s of imp.symbols)
+                    existingSymbols.add(s);
+                notes.push(`import: added ${imp.symbols.join(', ')} from '${imp.from}'`);
+            }
+            if (linesToAdd.length > 0) {
+                let lastEnd = -1;
+                for (const stmt of instanceForImports.statements) {
+                    if (ts.isImportDeclaration(stmt)) {
+                        lastEnd = stmt.getEnd();
+                    }
+                }
+                const insertion = '\n' + linesToAdd.join('\n');
+                if (lastEnd >= 0) {
+                    content = content.slice(0, lastEnd) + insertion + content.slice(lastEnd);
+                }
+                else {
+                    // No existing imports — prepend.
+                    content = linesToAdd.join('\n') + '\n' + content;
+                }
+            }
+            if (content === ctx.instanceContent) {
+                return { ok: true, merged: content, notes: ['no changes'] };
+            }
+            return { ok: true, merged: content, notes };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { ok: false, reason: `ts-module merge failed: ${message}` };
+        }
+    }
+}
+exports.TsModuleMerger = TsModuleMerger;
+/**
+ * Walk the AST to find the first `@Module(...)` decorator's
+ * `ObjectLiteralExpression` argument. Returns `undefined` if not found.
+ */
+function findModuleDecoratorArg(source) {
+    let result;
+    const visit = (node) => {
+        if (result)
+            return;
+        if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+            const callee = node.expression.expression;
+            if (ts.isIdentifier(callee) && callee.text === 'Module') {
+                const arg = node.expression.arguments[0];
+                if (arg && ts.isObjectLiteralExpression(arg)) {
+                    result = arg;
+                    return;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return result;
+}
+/**
+ * Extract the source text of each element of a metadata array property
+ * (e.g. `imports: [A, B.forRoot({...})]`).
+ */
+function extractMetadataArrayElements(arg, key, source) {
+    for (const prop of arg.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        let propName = '';
+        if (ts.isIdentifier(prop.name))
+            propName = prop.name.text;
+        else if (ts.isStringLiteral(prop.name))
+            propName = prop.name.text;
+        if (propName !== key)
+            continue;
+        if (!ts.isArrayLiteralExpression(prop.initializer))
+            continue;
+        return prop.initializer.elements.map((el) => el.getText(source));
+    }
+    return [];
+}
+/**
+ * Collect top-level `import { Named, ... } from '...'` declarations from a
+ * source file. Default and namespace imports are intentionally ignored — the
+ * NestJS module template convention is named-imports only.
+ */
+function collectTopImports(source) {
+    const result = [];
+    for (const stmt of source.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        if (!ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        const symbols = [];
+        const ic = stmt.importClause;
+        if (ic && ic.namedBindings && ts.isNamedImports(ic.namedBindings)) {
+            for (const el of ic.namedBindings.elements) {
+                symbols.push(el.name.text);
+            }
+        }
+        result.push({
+            line: stmt.getText(source),
+            symbols,
+            from: stmt.moduleSpecifier.text,
+        });
+    }
+    return result;
+}