@gadmin2n/cli 0.0.91 → 0.0.93

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;
+}

package/lib/version-check.d.ts

@@ -0,0 +1,39 @@
+export interface InstalledInfo {
+    name: string;
+    version: string;
+}
+export interface VersionInfo {
+    packageName: string;
+    installed: string;
+    latest: string;
+}
+/**
+ * Read the CLI's own installed version by walking up from __dirname looking
+ * for the closest package.json. Returns null if not found.
+ */
+export declare function getInstalledVersion(): InstalledInfo | null;
+/**
+ * HTTPS GET https://registry.npmjs.org/<name>/latest with a hard timeout.
+ * Returns the latest version string on success, or null on any failure
+ * (network error, non-200, parse error, timeout). Never throws.
+ */
+export declare function fetchLatestVersion(packageName: string, timeoutMs?: number): Promise<string | null>;
+/**
+ * Numeric compare of dotted version strings. Strips any prerelease suffix
+ * (`-alpha.1`, `-rc.0`, etc.) before comparing. Returns positive if a > b,
+ * negative if a < b, 0 if equal.
+ */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Convenience wrapper: read installed version + fetch latest. Returns
+ * null on any failure (no installed pkg.json located, network failure,
+ * timeout). Never throws.
+ */
+export declare function checkVersion(timeoutMs?: number): Promise<VersionInfo | null>;
+/**
+ * Print a yellow warning banner explaining that the CLI is outdated and
+ * how to upgrade. Uses the auto-detected install manager to suggest the
+ * matching upgrade command (npm install -g / yarn global add / pnpm add -g).
+ * Non-blocking — caller decides whether to continue.
+ */
+export declare function printOutdatedWarning(info: VersionInfo): void;

package/lib/version-check.js

@@ -0,0 +1,157 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printOutdatedWarning = exports.checkVersion = exports.compareVersions = exports.fetchLatestVersion = exports.getInstalledVersion = void 0;
+const chalk = require("chalk");
+const fs = require("fs");
+const https = require("https");
+const path = require("path");
+const install_manager_1 = require("./install-manager");
+const REGISTRY_URL = 'https://registry.npmjs.org';
+/**
+ * Read the CLI's own installed version by walking up from __dirname looking
+ * for the closest package.json. Returns null if not found.
+ */
+function getInstalledVersion() {
+    let dir = __dirname;
+    for (let i = 0; i < 8; i++) {
+        const pkgPath = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const json = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (json.name && json.version) {
+                    return { name: json.name, version: json.version };
+                }
+            }
+            catch (_a) {
+                // ignore and keep walking
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+exports.getInstalledVersion = getInstalledVersion;
+/**
+ * HTTPS GET https://registry.npmjs.org/<name>/latest with a hard timeout.
+ * Returns the latest version string on success, or null on any failure
+ * (network error, non-200, parse error, timeout). Never throws.
+ */
+function fetchLatestVersion(packageName, timeoutMs = 1500) {
+    return new Promise((resolve) => {
+        const url = `${REGISTRY_URL}/${encodeURIComponent(packageName).replace('%40', '@')}/latest`;
+        let settled = false;
+        const finish = (v) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(v);
+        };
+        const req = https.get(url, { timeout: timeoutMs }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                finish(null);
+                return;
+            }
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+                    finish(typeof json.version === 'string' ? json.version : null);
+                }
+                catch (_a) {
+                    finish(null);
+                }
+            });
+            res.on('error', () => finish(null));
+        });
+        req.on('error', () => finish(null));
+        req.on('timeout', () => {
+            req.destroy();
+            finish(null);
+        });
+    });
+}
+exports.fetchLatestVersion = fetchLatestVersion;
+/**
+ * Numeric compare of dotted version strings. Strips any prerelease suffix
+ * (`-alpha.1`, `-rc.0`, etc.) before comparing. Returns positive if a > b,
+ * negative if a < b, 0 if equal.
+ */
+function compareVersions(a, b) {
+    const parse = (v) => v.split('.').map((n) => parseInt(n.split('-')[0], 10) || 0);
+    const pa = parse(a);
+    const pb = parse(b);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const da = pa[i] || 0;
+        const db = pb[i] || 0;
+        if (da !== db)
+            return da - db;
+    }
+    return 0;
+}
+exports.compareVersions = compareVersions;
+/**
+ * Convenience wrapper: read installed version + fetch latest. Returns
+ * null on any failure (no installed pkg.json located, network failure,
+ * timeout). Never throws.
+ */
+function checkVersion(timeoutMs = 1500) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const installed = getInstalledVersion();
+        if (!installed)
+            return null;
+        const latest = yield fetchLatestVersion(installed.name, timeoutMs);
+        if (!latest)
+            return null;
+        return {
+            packageName: installed.name,
+            installed: installed.version,
+            latest,
+        };
+    });
+}
+exports.checkVersion = checkVersion;
+/**
+ * Print a yellow warning banner explaining that the CLI is outdated and
+ * how to upgrade. Uses the auto-detected install manager to suggest the
+ * matching upgrade command (npm install -g / yarn global add / pnpm add -g).
+ * Non-blocking — caller decides whether to continue.
+ */
+function printOutdatedWarning(info) {
+    const detection = (0, install_manager_1.detectInstallManager)();
+    const upgradeCmd = (0, install_manager_1.buildUpgradeCommand)(detection.manager, info.packageName, 'latest');
+    const bar = '═══════════════════════════════════════════════════';
+    console.warn();
+    console.warn(chalk.yellow.bold(bar));
+    console.warn(chalk.yellow.bold('⚠️  CLI is outdated:') +
+        chalk.yellow(` installed ${info.installed}, latest ${info.latest}`));
+    console.warn(chalk.yellow('   Templates ship bundled with the CLI — using an outdated CLI'));
+    console.warn(chalk.yellow('   means updating against an outdated template.'));
+    console.warn();
+    console.warn(chalk.yellow('   Upgrade with:'));
+    console.warn(chalk.cyan(`     gadmin2 self-update`));
+    console.warn(chalk.gray(`     (or: ${upgradeCmd})`));
+    console.warn(chalk.gray(`     detected manager: ${detection.manager}` +
+        (detection.pathHint !== detection.manager
+            ? ` (path hint: ${detection.pathHint})`
+            : '')));
+    console.warn();
+    console.warn(chalk.gray('   To skip this check: gadmin2 update --no-version-check'));
+    console.warn(chalk.yellow.bold(bar));
+    console.warn();
+}
+exports.printOutdatedWarning = printOutdatedWarning;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gadmin2n/cli",
-  "version": "0.0.91",
+  "version": "0.0.93",
   "description": "Gadmin - modern, fast, powerful node.js web framework (@cli)",
   "publishConfig": {
     "access": "public"
@@ -47,7 +47,7 @@
     "@angular-devkit/core": "13.3.2",
     "@angular-devkit/schematics": "13.3.2",
     "@angular-devkit/schematics-cli": "13.3.2",
-    "@gadmin2n/schematics": "^0.0.72",
+    "@gadmin2n/schematics": "^0.0.75",
     "abc": "^0.6.1",
     "chalk": "3.0.0",
     "chokidar": "3.5.3",

package/actions/template.action.d.ts

@@ -1,7 +0,0 @@
-import { Input } from '../commands';
-import { AbstractAction } from './abstract.action';
-export declare class TemplateAction extends AbstractAction {
-    handle(inputs: Input[], options: Input[]): Promise<void>;
-    private handleDiff;
-    private handleUpdate;
-}