@appxdigital/appx-core 0.1.122 → 0.1.124

package/dist/config/generate-dtos.js

@@ -23,6 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldDtoSubclass = exports.generateDtoBases = void 0;
 const path = __importStar(require("path"));
 const utils_1 = require("./utils");
 /**
@@ -55,15 +56,13 @@ const utils_1 = require("./utils");
  *   enforces the matching ABAC rule for each (`create` rule / `connect` rule).
  */
 const cwd = process.cwd();
-// Read the consumer's generated Prisma client for the DMMF (authoritative
-// field metadata incl. `documentation`, which carries /// @Role / @NoWrite).
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { Prisma } = require(path.join(cwd, 'node_modules', '@prisma/client'));
 const generatedDtoRoot = path.join(cwd, 'src/generated/dto');
 const modulesRoot = path.join(cwd, 'src/modules');
-const modelsByName = {};
-for (const m of Prisma.dmmf.datamodel.models)
-    modelsByName[m.name] = m;
+// Populated by generateDtoBases() from the DMMF models it is handed (authoritative
+// field metadata incl. `documentation`, which carries /// @Role / @NoWrite).
+// A module-level lookup so the relation-nested-write renderer can resolve a
+// related model by name without threading it through every call.
+let modelsByName = {};
 function isNoWrite(doc) {
     if (!doc)
         return false;
@@ -84,7 +83,12 @@ function isServerManagedTimestamp(field) {
     const def = field.default;
     return !!def && typeof def === 'object' && def.name === 'now';
 }
-/** Decision for a scalar/enum field: base validator, TS type, optional enum arg. */
+/** Decision for a scalar/enum field: base validator, TS type, optional enum arg,
+ * optional class-transformer `@Type(() => <transform>)` (needed when the wire
+ * value must be coerced to a non-primitive before validation, e.g. ISO → Date).
+ * `fieldDecorator` marks a framework decorator (imported from
+ * `@appxdigital/appx-core`, emitted as `@Name()`) that does its own coercion +
+ * validation (Decimal/BigInt); `needsPrisma` requests a `Prisma` type import. */
 function mapField(field) {
     if (field.kind === 'enum') {
         return { validator: 'IsEnum', tsType: field.type, enumArg: field.type };
@@ -95,13 +99,25 @@ function mapField(field) {
         case 'Boolean':
             return { validator: 'IsBoolean', tsType: 'boolean' };
         case 'Int':
-        case 'BigInt':
             return { validator: 'IsInt', tsType: 'number' };
+        case 'BigInt':
+            // Prisma types BigInt columns as `bigint`; JSON can't carry one, so
+            // `@BigIntField()` accepts a string or number and coerces it.
+            return { validator: 'BigIntField', tsType: 'bigint', fieldDecorator: true };
         case 'Float':
-        case 'Decimal':
             return { validator: 'IsNumber', tsType: 'number' };
+        case 'Decimal':
+            // Prisma types Decimal columns as `Prisma.Decimal`; `@DecimalField()`
+            // accepts a string or number and coerces it to a real Decimal so the
+            // DTO matches the model type and Prisma gets the right value.
+            return { validator: 'DecimalField', tsType: 'Prisma.Decimal', fieldDecorator: true, needsPrisma: true };
         case 'DateTime':
-            return { validator: 'IsDateString', tsType: 'string' };
+            // Prisma types DateTime columns as `Date`; the DTO must match so a
+            // controller override (`data: UpdateXDto` vs base `Partial<X>`)
+            // type-checks. `@Type(() => Date)` still accepts an ISO string over
+            // the wire and coerces it (ValidationPipe runs with transform:true),
+            // so there is no API change and Prisma receives a real Date.
+            return { validator: 'IsDate', tsType: 'Date', transform: 'Date' };
         default:
             // Json, Bytes, and anything unrecognised: keep the field (so it isn't
             // stripped by whitelist) without a strict type validator.
@@ -133,13 +149,18 @@ function backFkColumns(relatedModel, relationName) {
     return inverse ? inverse.relationFromFields || [] : [];
 }
 /** Renders class-body lines for a set of scalar/enum fields; collects imports. */
-function renderScalarLines(fields, mode, validatorImports, enumImports) {
+function renderScalarLines(fields, mode, validatorImports, enumImports, transformerImports, frameworkImports) {
     const lines = [];
     for (const field of fields) {
         const m = mapField(field);
-        validatorImports.add(m.validator);
+        if (m.fieldDecorator)
+            frameworkImports.add(m.validator);
+        else
+            validatorImports.add(m.validator);
         if (m.enumArg)
             enumImports.add(m.enumArg);
+        if (m.needsPrisma)
+            enumImports.add('Prisma');
         // update / connect: everything optional. create: optional if not required or defaulted.
         const optional = mode !== 'create' || !field.isRequired || field.hasDefaultValue;
         const isList = field.isList;
@@ -148,6 +169,10 @@ function renderScalarLines(fields, mode, validatorImports, enumImports) {
         if (m.validator === 'Allow') {
             validatorDecorator = '@Allow()';
         }
+        else if (m.fieldDecorator) {
+            // Framework decorator handles list coercion internally — no `each`.
+            validatorDecorator = `@${m.validator}()`;
+        }
         else {
             const args = [];
             if (m.enumArg)
@@ -165,6 +190,10 @@ function renderScalarLines(fields, mode, validatorImports, enumImports) {
             validatorImports.add('IsArray');
             decoratorLines.push('    @IsArray()');
         }
+        if (m.transform) {
+            transformerImports.add('Type');
+            decoratorLines.push(`    @Type(() => ${m.transform})`);
+        }
         decoratorLines.push(`    ${validatorDecorator}`);
         lines.push(decoratorLines.join('\n'));
         lines.push(`    ${field.name}${optional ? '?' : '!'}: ${tsType};`);
@@ -180,7 +209,7 @@ function renderClass(className, bodyLines) {
  * plus the property lines to add to the parent class. Nested create classes are
  * scalars-only (no deeper relations) so there are no circular imports.
  */
-function renderRelationNestedWrites(model, validatorImports, enumImports, transformerImports) {
+function renderRelationNestedWrites(model, validatorImports, enumImports, transformerImports, frameworkImports) {
     const classes = [];
     const parentLines = [];
     const relations = model.fields.filter((f) => f.kind === 'object');
@@ -194,10 +223,10 @@ function renderRelationNestedWrites(model, validatorImports, enumImports, transf
         const writeCls = `${model.name}${relCap}NestedWriteDto`;
         // create: related writable scalars minus the back-reference FK.
         const omit = backFkColumns(related, rel.relationName);
-        classes.push(renderClass(createCls, renderScalarLines(writableFields(related, omit), 'create', validatorImports, enumImports)));
+        classes.push(renderClass(createCls, renderScalarLines(writableFields(related, omit), 'create', validatorImports, enumImports, transformerImports, frameworkImports)));
         // connect: related unique fields (all optional).
         const conn = connectFields(related);
-        classes.push(renderClass(connectCls, renderScalarLines(conn, 'connect', validatorImports, enumImports)));
+        classes.push(renderClass(connectCls, renderScalarLines(conn, 'connect', validatorImports, enumImports, transformerImports, frameworkImports)));
         // nested-write: create? / connect? only.
         transformerImports.add('Type');
         validatorImports.add('IsOptional');
@@ -231,10 +260,11 @@ function renderBaseDto(className, model, mode) {
     const validatorImports = new Set();
     const enumImports = new Set();
     const transformerImports = new Set();
-    const scalarLines = renderScalarLines(writableFields(model), mode, validatorImports, enumImports);
+    const frameworkImports = new Set();
+    const scalarLines = renderScalarLines(writableFields(model), mode, validatorImports, enumImports, transformerImports, frameworkImports);
     let nested = { classes: [], parentLines: [] };
     if (mode === 'create') {
-        nested = renderRelationNestedWrites(model, validatorImports, enumImports, transformerImports);
+        nested = renderRelationNestedWrites(model, validatorImports, enumImports, transformerImports, frameworkImports);
     }
     const parentClass = renderClass(className, [...scalarLines, ...nested.parentLines]);
     const importLines = [];
@@ -247,6 +277,9 @@ function renderBaseDto(className, model, mode) {
     if (enumImports.size > 0) {
         importLines.push(`import { ${[...enumImports].sort().join(', ')} } from '@prisma/client';`);
     }
+    if (frameworkImports.size > 0) {
+        importLines.push(`import { ${[...frameworkImports].sort().join(', ')} } from '@appxdigital/appx-core';`);
+    }
     return (utils_1.GENERATED_BANNER +
         '\n' +
         (importLines.length ? importLines.join('\n') + '\n\n' : '') +
@@ -264,22 +297,46 @@ function renderSubclassDto(subclass, baseClass, importPath) {
         ` */\n` +
         `export class ${subclass} extends ${baseClass} {}\n`);
 }
-for (const model of Prisma.dmmf.datamodel.models) {
-    const modelName = model.name; // Pascal, e.g. ProjectMember
-    const folder = (0, utils_1.pascalToKebabCase)(modelName); // kebab, e.g. project-member
-    if (utils_1.IGNORE_FOLDERS.includes(folder))
-        continue;
+/**
+ * Deploy-safe pass: (re)generate the DTO **base** classes under the gitignored
+ * `src/generated/dto/`, one per non-framework model. Overwrite-only — never
+ * touches `src/modules/`. `allModels` is the full DMMF list (framework models
+ * included) so relation-nested-write members can resolve their target model;
+ * bases are only emitted for non-framework models.
+ */
+function generateDtoBases(allModels) {
+    modelsByName = {};
+    for (const m of allModels)
+        modelsByName[m.name] = m;
+    for (const model of allModels) {
+        const modelName = model.name; // Pascal, e.g. ProjectMember
+        if (utils_1.FRAMEWORK_MODELS.includes(modelName))
+            continue;
+        const folder = (0, utils_1.pascalToKebabCase)(modelName); // kebab, e.g. project-member
+        for (const mode of ['create', 'update']) {
+            const capMode = mode.charAt(0).toUpperCase() + mode.slice(1);
+            const baseClass = `${capMode}${modelName}GeneratedDto`;
+            const basePath = path.join(generatedDtoRoot, folder, `${mode}-${folder}.generated.dto.ts`);
+            (0, utils_1.writeGeneratedFile)(basePath, renderBaseDto(baseClass, model, mode));
+        }
+    }
+    console.log('DTO base classes generated.');
+}
+exports.generateDtoBases = generateDtoBases;
+/**
+ * Wizard/scaffold pass: create the hand-owned DTO **subclass** files (create +
+ * update) for a single model under `src/modules/<model>/dto/`. Generated once,
+ * never overwritten — this is where the developer adds custom validation.
+ */
+function scaffoldDtoSubclass(modelName) {
+    const folder = (0, utils_1.pascalToKebabCase)(modelName);
     for (const mode of ['create', 'update']) {
         const capMode = mode.charAt(0).toUpperCase() + mode.slice(1);
         const baseClass = `${capMode}${modelName}GeneratedDto`;
         const subclass = `${capMode}${modelName}Dto`;
-        // Base (overwritten, gitignored).
-        const basePath = path.join(generatedDtoRoot, folder, `${mode}-${folder}.generated.dto.ts`);
-        (0, utils_1.writeGeneratedFile)(basePath, renderBaseDto(baseClass, model, mode));
-        // Subclass (once, hand-owned, committed).
         const subPath = path.join(modulesRoot, folder, 'dto', `${mode}-${folder}.dto.ts`);
         const importPath = `../../../generated/dto/${folder}/${mode}-${folder}.generated.dto`;
         (0, utils_1.createFileIfNotExists)(subPath, renderSubclassDto(subclass, baseClass, importPath));
     }
 }
-console.log('DTOs generated.');
+exports.scaffoldDtoSubclass = scaffoldDtoSubclass;

package/dist/config/generate-models.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=generate-models.d.ts.map

package/dist/config/generate-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-models.d.ts","sourceRoot":"","sources":["../../src/config/generate-models.ts"],"names":[],"mappings":""}

package/dist/config/generate-models.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `appx generate models` — the module WIZARD (bucket B + C).
+ *
+ * The only generator that writes hand-owned files under `src/modules/**` and
+ * mutates `src/app.module.ts`. For each selected model it scaffolds the module,
+ * service, controller, resolver and DTO subclass (each once, never overwritten),
+ * then registers the module in AppModule.
+ *
+ * Model discovery is DMMF-driven (schema is the source of truth), independent of
+ * whatever folders the GraphQL plugin emitted. Only models WITHOUT an existing
+ * module are offered; framework-owned models (User/Session/UserRefreshToken) are
+ * never listed.
+ *
+ * Usage:
+ *   appx generate models              interactive picker
+ *   appx generate models Habit Log    scaffold the named models (Pascal or kebab)
+ *   appx generate models --all        scaffold every generatable model (legacy)
+ *
+ * It first runs the deploy-safe pass (prisma generate + DTO bases), so the
+ * scaffolded resolver/controller imports resolve.
+ */
+const utils_1 = require("./utils");
+const generate_dtos_1 = require("./generate-dtos");
+const generate_modules_1 = require("./generate-modules");
+const generate_services_1 = require("./generate-services");
+const generate_controllers_1 = require("./generate-controllers");
+const generate_resolvers_1 = require("./generate-resolvers");
+// inquirer is ESM-only; this file compiles to CommonJS, where tsc would
+// down-level a normal `import('inquirer')` into `require()` (ERR_REQUIRE_ESM at
+// runtime). Wrapping in `new Function` keeps a genuine dynamic `import()` that
+// Node resolves as ESM. Only used on the interactive path.
+const dynamicImport = new Function('m', 'return import(m)');
+async function main() {
+    // 1) Deploy-safe pass first — refresh client + GraphQL artifacts + DTO bases.
+    console.log('Running Prisma Generate (client + GraphQL artifacts)...');
+    // Project-local prisma: the CLI is usually global, so PATH has no project .bin.
+    (0, utils_1.runProjectBin)('prisma', 'generate');
+    (0, generate_dtos_1.generateDtoBases)((0, utils_1.loadAllModels)());
+    // 2) Candidates = non-framework models with no module yet. "Has a module"
+    //    means either the canonical folder exists OR some existing module already
+    //    serves the model via CoreController/CoreService<Model> — the latter
+    //    catches hand-written modules under a non-canonical (e.g. pluralised)
+    //    folder, so we don't scaffold a duplicate.
+    const owned = (0, utils_1.ownedModels)();
+    const candidates = (0, utils_1.loadModels)().filter((m) => !(0, utils_1.moduleExists)(m.name) && !owned.has(m.name));
+    // 3) Resolve the selection from argv, else prompt.
+    const args = process.argv.slice(2);
+    const wantAll = args.includes('--all');
+    const requested = args.filter((a) => !a.startsWith('-'));
+    let selected;
+    if (wantAll) {
+        selected = candidates.map((m) => m.name);
+    }
+    else if (requested.length > 0) {
+        // Accept a Pascal model name or a kebab folder; only from candidates.
+        const byKey = new Map();
+        for (const m of candidates) {
+            byKey.set(m.name.toLowerCase(), m.name);
+            byKey.set((0, utils_1.modelFolder)(m.name), m.name);
+        }
+        selected = [];
+        for (const r of requested) {
+            const hit = byKey.get(r.toLowerCase()) ?? byKey.get(r);
+            if (hit)
+                selected.push(hit);
+            else
+                console.warn(`Skipping "${r}": not a generatable model (unknown, framework-owned, or already has a module).`);
+        }
+    }
+    else {
+        if (candidates.length === 0) {
+            console.log('No modules available to generate.');
+            return;
+        }
+        const inquirer = (await dynamicImport('inquirer')).default;
+        const answer = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'models',
+                message: 'Select models to generate CRUD modules for:',
+                choices: candidates.map((m) => ({ name: m.name, value: m.name })),
+            },
+        ]);
+        selected = answer.models;
+    }
+    if (selected.length === 0) {
+        console.log('No modules generated.');
+        return;
+    }
+    // 4) Scaffold hand-owned files per model, then register the modules.
+    for (const name of selected) {
+        (0, generate_modules_1.scaffoldModule)(name);
+        (0, generate_services_1.scaffoldService)(name);
+        (0, generate_controllers_1.scaffoldController)(name);
+        (0, generate_resolvers_1.scaffoldResolver)(name);
+        (0, generate_dtos_1.scaffoldDtoSubclass)(name);
+    }
+    (0, generate_modules_1.registerModulesInAppModule)(selected);
+    console.log(`Generated modules: ${selected.join(', ')}.`);
+}
+main().catch((err) => {
+    console.error('❌ Module generation failed:', err?.message ?? err);
+    process.exit(1);
+});

package/dist/config/generate-modules.d.ts

@@ -1,2 +1,31 @@
-export {};
+/** Scaffold the module file for a single model (once; never overwritten). */
+export declare function scaffoldModule(modelName: string): void;
+/**
+ * Pure source transform: register the given models' modules in app.module.ts
+ * source. Returns the new source and the module names actually added. Extracted
+ * from filesystem I/O so it is unit-testable.
+ *
+ * Correctness requirements this satisfies:
+ *   - **Registration order is preserved.** New modules are appended at the END of
+ *     the `@Module` `imports` array, after the existing entries.
+ *   - **Nested array literals are respected.** The array's closing `]` is found
+ *     by bracket-matching (skipping strings/comments), so a nested
+ *     `ThrottlerModule.forRoot([...])` never captures the insertion point.
+ *   - **No double registration.** A module already present as an entry in the
+ *     imports array is not added again.
+ *   - **No double import.** An `import { XModule } …` line is added only if one
+ *     isn't already present.
+ */
+export declare function addModulesToAppModuleSource(content: string, modelNames: string[]): {
+    content: string;
+    added: string[];
+};
+/**
+ * Register the given models' modules in `src/app.module.ts` — the ONE code
+ * mutation in the generator, performed only by the module wizard (never by the
+ * deploy-safe pass). Idempotent (already-imported modules are skipped) and scoped
+ * to the models passed in — it does NOT scan `src/modules`, so it never registers
+ * something the caller didn't ask for.
+ */
+export declare function registerModulesInAppModule(modelNames: string[]): void;
 //# sourceMappingURL=generate-modules.d.ts.map

package/dist/config/generate-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-modules.d.ts","sourceRoot":"","sources":["../../src/config/generate-modules.ts"],"names":[],"mappings":""}
+{"version":3,"file":"generate-modules.d.ts","sourceRoot":"","sources":["../../src/config/generate-modules.ts"],"names":[],"mappings":"AA2BA,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAItD;AAyCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CACvC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAAE,GACrB;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC,CAkDpC;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,CASrE"}

package/dist/config/generate-modules.js

@@ -23,10 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModulesInAppModule = exports.addModulesToAppModuleSource = exports.scaffoldModule = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const utils_1 = require("./utils");
-const modelsPath = path.join(process.cwd(), 'src/generated');
 const modulesOutputPath = path.join(process.cwd(), 'src/modules');
 const appModulePath = path.join(process.cwd(), 'src/app.module.ts');
 /**
@@ -48,101 +48,160 @@ import { ${model}Resolver } from './${folder}.resolver';
 })
 export class ${model}Module {}
 `;
+/** Scaffold the module file for a single model (once; never overwritten). */
+function scaffoldModule(modelName) {
+    const folder = (0, utils_1.modelFolder)(modelName);
+    const modulePath = path.join(modulesOutputPath, folder, `${folder}.module.ts`);
+    (0, utils_1.createFileIfNotExists)(modulePath, moduleTemplate(modelName, folder));
+}
+exports.scaffoldModule = scaffoldModule;
 /**
- * Create or update the module file for a given model
- * @param model
- * @param modulePath
- * @param folder
+ * Given the index of an opening `[`, return the index of its matching `]`,
+ * counting bracket depth while skipping string literals and comments so that
+ * neither a nested array literal (`ThrottlerModule.forRoot([{ ttl }])`) nor a
+ * bracket inside a string/comment throws off the match.
  */
-const createModuleFile = (model, modulePath, folder) => {
-    const moduleContent = moduleTemplate(model, folder);
-    fs.writeFileSync(modulePath, moduleContent);
-    console.log(`Module for ${model} created or updated.`);
-};
+function matchingBracket(src, openIdx) {
+    let depth = 0;
+    let inString = null;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = openIdx; i < src.length; i++) {
+        const c = src[i];
+        const next = src[i + 1];
+        if (inLineComment) {
+            if (c === '\n')
+                inLineComment = false;
+            continue;
+        }
+        if (inBlockComment) {
+            if (c === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            if (c === '\\') {
+                i++;
+                continue;
+            } // skip escaped char
+            if (c === inString)
+                inString = null;
+            continue;
+        }
+        if (c === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (c === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === '`') {
+            inString = c;
+            continue;
+        }
+        if (c === '[')
+            depth++;
+        else if (c === ']') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    throw new Error('app.module.ts: unbalanced `imports` array (no matching `]`)');
+}
 /**
- * Update the AppModule with new module imports
+ * Pure source transform: register the given models' modules in app.module.ts
+ * source. Returns the new source and the module names actually added. Extracted
+ * from filesystem I/O so it is unit-testable.
+ *
+ * Correctness requirements this satisfies:
+ *   - **Registration order is preserved.** New modules are appended at the END of
+ *     the `@Module` `imports` array, after the existing entries.
+ *   - **Nested array literals are respected.** The array's closing `]` is found
+ *     by bracket-matching (skipping strings/comments), so a nested
+ *     `ThrottlerModule.forRoot([...])` never captures the insertion point.
+ *   - **No double registration.** A module already present as an entry in the
+ *     imports array is not added again.
+ *   - **No double import.** An `import { XModule } …` line is added only if one
+ *     isn't already present.
  */
-const updateAppModule = () => {
-    let appModuleContent = fs.readFileSync(appModulePath, 'utf8');
-    /**
-     * Regex to extract existing module imports from the AppModule
-     */
-    const importRegex = /import { (\w+)Module } from '.\/modules\/\w+\/\w+.module';/g;
-    const existingImports = new Set();
+function addModulesToAppModuleSource(content, modelNames) {
+    // Locate the @Module imports array and its true bounds.
+    const moduleIdx = content.indexOf('@Module(');
+    if (moduleIdx === -1)
+        throw new Error('app.module.ts: @Module decorator not found');
+    const importsKeyIdx = content.indexOf('imports:', moduleIdx);
+    if (importsKeyIdx === -1)
+        throw new Error('app.module.ts: `imports:` not found in @Module');
+    const openIdx = content.indexOf('[', importsKeyIdx);
+    if (openIdx === -1)
+        throw new Error('app.module.ts: `imports` is not an array literal');
+    const closeIdx = matchingBracket(content, openIdx);
+    const inner = content.slice(openIdx + 1, closeIdx);
+    // Modules already registered in the imports array (any `XxxModule` token).
+    const registered = new Set((inner.match(/\b\w+Module\b/g) ?? []));
+    // Modules already imported (by `import { XModule } from './modules/…'`).
+    const imported = new Set();
+    const importRegex = /import\s*{\s*(\w+Module)\s*}\s*from\s*'\.\/modules\/[\w-]+\/[\w-]+\.module'/g;
     let match;
-    while ((match = importRegex.exec(appModuleContent)) !== null) {
-        existingImports.add(match[1]);
-    }
+    while ((match = importRegex.exec(content)) !== null)
+        imported.add(match[1]);
+    const added = [];
     const newImports = [];
-    const newModules = [];
-    /**
-     * Regex to extract the imports array from the AppModule to prevent duplicates
-     */
-    const importsArrayRegex = /(imports:\s*\[)([^]*?)(\])/;
-    const importsArrayMatch = appModuleContent.match(importsArrayRegex);
-    const existingModuleNames = new Set();
-    if (importsArrayMatch) {
-        const currentImportsArray = importsArrayMatch[2]
-            .split(',')
-            .map((m) => m.trim().replace(/\s/g, ''))
-            .filter((m) => m);
-        currentImportsArray.forEach((moduleName) => {
-            existingModuleNames.add(moduleName);
-        });
-    }
-    /**
-     * Iterate over the modules directory and add new imports to the AppModule
-     */
-    fs.readdirSync(modulesOutputPath).forEach((folder) => {
-        if (utils_1.IGNORE_FOLDERS.includes(folder))
-            return;
-        const modelName = (0, utils_1.kebabToPascalCase)(folder);
+    for (const modelName of modelNames) {
         const moduleName = `${modelName}Module`;
-        // Ensure no duplicate imports and no duplicate entries in the imports array
-        if (!existingImports.has(moduleName) && !existingModuleNames.has(moduleName)) {
-            newImports.push(`import { ${modelName}Module } from './modules/${folder}/${folder}.module';`);
-            newModules.push(moduleName);
+        if (registered.has(moduleName))
+            continue; // already in the imports array
+        added.push(moduleName);
+        if (!imported.has(moduleName)) {
+            const folder = (0, utils_1.modelFolder)(modelName);
+            newImports.push(`import { ${moduleName} } from './modules/${folder}/${folder}.module';`);
         }
-    });
-    if (newImports.length === 0) {
-        console.log('No new modules to add.');
-        return;
     }
-    // Add new imports to AppModule and update the imports array without duplicates
-    appModuleContent = appModuleContent.replace(/(imports:\s*\[)([^]*?)(\])/, (_, prefix, currentImports, suffix) => {
-        const currentModules = currentImports
-            .split(',')
-            .map((m) => m.trim())
-            .filter((m) => m);
-        newModules.forEach((newModule) => {
-            if (!currentModules.includes(newModule)) {
-                currentModules.push(newModule);
-            }
-        });
-        return `${prefix}${currentModules.join(', ')}${suffix}`;
-    });
-    const finalContent = newImports.join('\n') + '\n' + appModuleContent;
-    fs.writeFileSync(appModulePath, finalContent);
-    console.log('AppModule updated successfully.');
-};
+    if (added.length === 0)
+        return { content, added };
+    // Append after the last existing entry, before the array's closing `]`
+    // (preserving order and the existing trailing whitespace / indentation).
+    let lastContentIdx = closeIdx - 1;
+    while (lastContentIdx > openIdx && /\s/.test(content[lastContentIdx]))
+        lastContentIdx--;
+    const arrayIsEmpty = lastContentIdx === openIdx;
+    const list = added.join(', ');
+    let withArray;
+    if (arrayIsEmpty) {
+        withArray = content.slice(0, openIdx + 1) + list + content.slice(openIdx + 1);
+    }
+    else {
+        const insertAt = lastContentIdx + 1;
+        const needsComma = content[lastContentIdx] !== ',';
+        const insertion = `${needsComma ? ',' : ''} ${list}`;
+        withArray = content.slice(0, insertAt) + insertion + content.slice(insertAt);
+    }
+    const withImports = newImports.length ? newImports.join('\n') + '\n' + withArray : withArray;
+    return { content: withImports, added };
+}
+exports.addModulesToAppModuleSource = addModulesToAppModuleSource;
 /**
- * Generate modules for each model
+ * Register the given models' modules in `src/app.module.ts` — the ONE code
+ * mutation in the generator, performed only by the module wizard (never by the
+ * deploy-safe pass). Idempotent (already-imported modules are skipped) and scoped
+ * to the models passed in — it does NOT scan `src/modules`, so it never registers
+ * something the caller didn't ask for.
  */
-fs.readdirSync(modelsPath).forEach((folder) => {
-    if (utils_1.IGNORE_FOLDERS.includes(folder))
+function registerModulesInAppModule(modelNames) {
+    if (modelNames.length === 0)
+        return;
+    const { content, added } = addModulesToAppModuleSource(fs.readFileSync(appModulePath, 'utf8'), modelNames);
+    if (added.length === 0) {
+        console.log('No new modules to register in AppModule.');
         return;
-    const modelName = (0, utils_1.kebabToPascalCase)(folder);
-    const modelOutputPath = path.join(modulesOutputPath, folder);
-    if (!fs.existsSync(modelOutputPath)) {
-        fs.mkdirSync(modelOutputPath, { recursive: true });
-        console.log(`Folder for model ${modelName} created.`);
-    }
-    const modulePath = path.join(modelOutputPath, `${folder}.module.ts`);
-    if (!fs.existsSync(modulePath)) {
-        createModuleFile(modelName, modulePath, folder);
-    }
-    else {
-        console.log(`Module for ${modelName} already exists, skipping.`);
     }
-});
-updateAppModule();
+    fs.writeFileSync(appModulePath, content);
+    console.log(`AppModule updated: registered ${added.join(', ')}.`);
+}
+exports.registerModulesInAppModule = registerModulesInAppModule;

package/dist/config/generate-resolvers.d.ts

@@ -1,2 +1,8 @@
-export {};
+/**
+ * Scaffold the (read-only) GraphQL resolver file for a single model (once;
+ * never overwritten). Imports the prisma-nestjs-graphql artifacts under
+ * `src/generated/<folder>/`, so the deploy-safe pass (`prisma generate`) must
+ * have produced them first.
+ */
+export declare function scaffoldResolver(modelName: string): void;
 //# sourceMappingURL=generate-resolvers.d.ts.map

package/dist/config/generate-resolvers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-resolvers.d.ts","sourceRoot":"","sources":["../../src/config/generate-resolvers.ts"],"names":[],"mappings":""}
+{"version":3,"file":"generate-resolvers.d.ts","sourceRoot":"","sources":["../../src/config/generate-resolvers.ts"],"names":[],"mappings":"AA8CA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAIxD"}