@carlonicora/nestjs-neo4jsonapi 0.0.1

package/dist/tools/migrate-entity/lib/file-discovery.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Entity Migration CLI - File Discovery Module
+ *
+ * Discovers old-style entity files within a module path.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverOldFiles = discoverOldFiles;
+exports.getModulePath = getModulePath;
+exports.discoverAllModulePaths = discoverAllModulePaths;
+exports.isAlreadyMigrated = isAlreadyMigrated;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+/**
+ * Discovers all old-style entity files within a module path.
+ *
+ * @param modulePath - Path to the module folder (e.g., "src/features/article")
+ * @param entityName - Optional specific entity name to filter by
+ * @returns Array of discovered entity file sets
+ */
+async function discoverOldFiles(modulePath, entityName) {
+    const absolutePath = path.isAbsolute(modulePath) ? modulePath : path.resolve(process.cwd(), modulePath);
+    // Find all *.meta.ts files to identify entities
+    const metaPattern = path.join(absolutePath, "**/*.meta.ts");
+    const metaFiles = await (0, glob_1.glob)(metaPattern, { nodir: true });
+    // Filter by entity name if provided
+    const filtered = entityName ? metaFiles.filter((f) => f.includes(`${entityName}.meta.ts`)) : metaFiles;
+    return filtered.map((metaFile) => {
+        const baseName = metaFile.replace(".meta.ts", "");
+        const dir = path.dirname(metaFile);
+        const name = path.basename(baseName);
+        // Entity file can be either {name}.ts or {name}.entity.ts
+        const entityFile = fs.existsSync(`${baseName}.entity.ts`)
+            ? `${baseName}.entity.ts`
+            : fs.existsSync(`${baseName}.ts`)
+                ? `${baseName}.ts`
+                : null;
+        return {
+            entityName: name,
+            entityDir: dir,
+            entity: entityFile,
+            meta: metaFile,
+            model: fs.existsSync(`${baseName}.model.ts`) ? `${baseName}.model.ts` : null,
+            map: fs.existsSync(`${baseName}.map.ts`) ? `${baseName}.map.ts` : null,
+            serialiser: findSerialiserFile(absolutePath, name),
+        };
+    });
+}
+/**
+ * Finds the serialiser file for an entity, checking common locations.
+ */
+function findSerialiserFile(modulePath, entityName) {
+    const candidates = [
+        path.join(modulePath, "serialisers", `${entityName}.serialiser.ts`),
+        path.join(modulePath, `${entityName}.serialiser.ts`),
+        path.join(modulePath, "entities", `${entityName}.serialiser.ts`),
+    ];
+    return candidates.find((c) => fs.existsSync(c)) || null;
+}
+/**
+ * Gets the module path from a file path.
+ * Extracts the feature/foundation module directory.
+ */
+function getModulePath(filePath) {
+    // Match patterns like src/features/article/... or src/foundations/user/...
+    const match = filePath.match(/(src\/(features|foundations)\/[^/]+)/);
+    return match ? match[1] : path.dirname(filePath);
+}
+/**
+ * Discovers all module paths in the codebase that contain old-style entities.
+ */
+async function discoverAllModulePaths() {
+    const metaPattern = "src/**/*.meta.ts";
+    const metaFiles = await (0, glob_1.glob)(metaPattern, { nodir: true, cwd: process.cwd() });
+    const modulePaths = new Set();
+    for (const metaFile of metaFiles) {
+        modulePaths.add(getModulePath(metaFile));
+    }
+    return Array.from(modulePaths);
+}
+/**
+ * Checks if an entity has already been migrated to the new descriptor pattern.
+ */
+function isAlreadyMigrated(files) {
+    if (!files.entity)
+        return false;
+    const entityContent = fs.readFileSync(files.entity, "utf-8");
+    return entityContent.includes("defineEntity<");
+}

package/dist/tools/migrate-entity/lib/module-updater.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Entity Migration CLI - Module Updater
+ *
+ * Updates the entity's module file to use the new descriptor pattern.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findModuleFile = findModuleFile;
+exports.updateModule = updateModule;
+exports.formatModuleContent = formatModuleContent;
+exports.findModuleFiles = findModuleFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+/**
+ * Finds the module file for an entity.
+ */
+async function findModuleFile(modulePath) {
+    const pattern = path.join(modulePath, "*.module.ts");
+    const files = await (0, glob_1.glob)(pattern, { nodir: true });
+    return files.length > 0 ? files[0] : null;
+}
+/**
+ * Updates the module file to use the new descriptor pattern.
+ */
+function updateModule(modulePath, entityName, labelName) {
+    const content = fs.readFileSync(modulePath, "utf-8");
+    const changes = [];
+    const descriptorName = `${labelName}Descriptor`;
+    const modelName = `${labelName}Model`;
+    const serialiserName = `${labelName}Serialiser`;
+    let updatedContent = content;
+    // 1. Update import: EntityModel -> EntityDescriptor
+    const modelImportPattern = new RegExp(`import\\s*\\{\\s*${modelName}\\s*\\}\\s*from\\s*["'][^"']+\\.model["'];?`, "g");
+    if (modelImportPattern.test(updatedContent)) {
+        // Replace the import path
+        const oldImport = updatedContent.match(modelImportPattern)?.[0] || "";
+        const newImportPath = oldImport
+            .replace(`{ ${modelName} }`, `{ ${descriptorName} }`)
+            .replace(".model", "");
+        updatedContent = updatedContent.replace(modelImportPattern, newImportPath);
+        changes.push(`Updated import: ${modelName} -> ${descriptorName}`);
+    }
+    // 2. Remove serialiser import (it's now auto-generated)
+    const serialiserImportPattern = new RegExp(`import\\s*\\{\\s*${serialiserName}\\s*\\}\\s*from\\s*["'][^"']+["'];?\\n?`, "g");
+    if (serialiserImportPattern.test(updatedContent)) {
+        updatedContent = updatedContent.replace(serialiserImportPattern, "");
+        changes.push(`Removed import: ${serialiserName} (now auto-generated)`);
+    }
+    // 3. Update providers: EntitySerialiser -> EntityDescriptor.model.serialiser
+    const serialiserProviderPattern = new RegExp(`\\b${serialiserName}\\b(?!\\.)`, "g");
+    if (serialiserProviderPattern.test(updatedContent)) {
+        updatedContent = updatedContent.replace(serialiserProviderPattern, `${descriptorName}.model.serialiser`);
+        changes.push(`Updated provider: ${serialiserName} -> ${descriptorName}.model.serialiser`);
+    }
+    // 4. Update modelRegistry.register(EntityModel) -> modelRegistry.register(EntityDescriptor.model)
+    const registryPattern = new RegExp(`modelRegistry\\.register\\(${modelName}\\)`, "g");
+    if (registryPattern.test(updatedContent)) {
+        updatedContent = updatedContent.replace(registryPattern, `modelRegistry.register(${descriptorName}.model)`);
+        changes.push(`Updated registry: modelRegistry.register(${modelName}) -> modelRegistry.register(${descriptorName}.model)`);
+    }
+    // 5. Update any other standalone EntityModel usages
+    const standaloneModelPattern = new RegExp(`\\b${modelName}\\b(?!\\.)`, "g");
+    if (standaloneModelPattern.test(updatedContent)) {
+        updatedContent = updatedContent.replace(standaloneModelPattern, `${descriptorName}.model`);
+        changes.push(`Updated standalone ${modelName} usages`);
+    }
+    if (changes.length === 0) {
+        return null;
+    }
+    return {
+        modulePath,
+        changes,
+        updatedContent,
+    };
+}
+/**
+ * Generates the updated module content with proper formatting.
+ */
+function formatModuleContent(content) {
+    // Remove duplicate empty lines
+    let formatted = content.replace(/\n{3,}/g, "\n\n");
+    // Ensure single newline at end of file
+    formatted = formatted.trimEnd() + "\n";
+    return formatted;
+}
+/**
+ * Finds all files in the module that need updating.
+ * This includes controllers, services, repositories, etc.
+ */
+async function findModuleFiles(modulePath) {
+    const pattern = path.join(modulePath, "**/*.ts");
+    const files = await (0, glob_1.glob)(pattern, { nodir: true });
+    // Exclude node_modules, dist, and test files
+    return files.filter((f) => {
+        return !f.includes("node_modules") && !f.includes("/dist/") && !f.endsWith(".spec.ts");
+    });
+}

package/dist/tools/migrate-entity/lib/reference-updater.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Entity Migration CLI - Reference Updater Module
+ *
+ * Finds and updates external references to old-style entity exports.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExternalReferences = findExternalReferences;
+exports.updateFileReferences = updateFileReferences;
+exports.summarizeReferences = summarizeReferences;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+/**
+ * Finds all external files that reference the old entity exports.
+ */
+async function findExternalReferences(entityName, labelName, srcDir = "src") {
+    const references = [];
+    // Patterns to search for
+    const metaName = `${entityName}Meta`;
+    const modelName = `${labelName}Model`;
+    const entityTypeName = labelName; // e.g., "Article"
+    // Find all TypeScript files
+    const tsFiles = await (0, glob_1.glob)(`${srcDir}/**/*.ts`, { nodir: true, cwd: process.cwd() });
+    for (const filePath of tsFiles) {
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        const content = fs.readFileSync(absolutePath, "utf-8");
+        // Check if file imports or uses the old exports
+        const hasOldPatterns = content.includes(metaName) ||
+            content.includes(modelName) ||
+            content.includes(`${entityName}.entity`) ||
+            content.includes(`${entityName}.meta`) ||
+            content.includes(`${entityName}.model`);
+        if (!hasOldPatterns) {
+            continue;
+        }
+        const usages = findUsagesInFile(content, metaName, modelName, labelName);
+        // Find all old imports that need updating
+        const oldImports = extractAllOldImports(content, entityName, metaName, modelName, entityTypeName);
+        if (usages.length === 0 && oldImports.length === 0)
+            continue;
+        // Calculate new import
+        const newImport = calculateNewImport(oldImports, entityName, labelName);
+        references.push({
+            filePath: absolutePath,
+            oldImport: oldImports.join("\n"), // Store all old imports
+            newImport,
+            usages,
+        });
+    }
+    return references;
+}
+/**
+ * Finds all usages of old exports within a file (excluding import lines).
+ */
+function findUsagesInFile(content, metaName, modelName, labelName) {
+    const usages = [];
+    const lines = content.split("\n");
+    const descriptorName = `${labelName}Descriptor`;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+        // Skip import lines (handled separately)
+        if (line.trim().startsWith("import "))
+            continue;
+        // Check for meta usage patterns
+        if (line.includes(metaName)) {
+            // Pattern: entityMeta.property -> EntityDescriptor.model.property
+            const metaPattern = new RegExp(`${metaName}\\.(\\w+)`, "g");
+            let match;
+            while ((match = metaPattern.exec(line)) !== null) {
+                usages.push({
+                    line: lineNumber,
+                    oldText: `${metaName}.${match[1]}`,
+                    newText: `${descriptorName}.model.${match[1]}`,
+                });
+            }
+            // Pattern: standalone metaName usage (not followed by .)
+            const standaloneMetaPattern = new RegExp(`\\b${metaName}\\b(?!\\.)`, "g");
+            if (standaloneMetaPattern.test(line)) {
+                usages.push({
+                    line: lineNumber,
+                    oldText: metaName,
+                    newText: `${descriptorName}.model`,
+                });
+            }
+        }
+        // Check for model usage patterns
+        if (line.includes(modelName)) {
+            // Pattern: EntityModel.property -> EntityDescriptor.model.property
+            const modelPropertyPattern = new RegExp(`${modelName}\\.(\\w+)`, "g");
+            let match;
+            while ((match = modelPropertyPattern.exec(line)) !== null) {
+                usages.push({
+                    line: lineNumber,
+                    oldText: `${modelName}.${match[1]}`,
+                    newText: `${descriptorName}.model.${match[1]}`,
+                });
+            }
+            // Pattern: serialiserFactory.create(EntityModel) -> serialiserFactory.create(EntityDescriptor.model)
+            if (line.includes(`serialiserFactory.create(${modelName})`)) {
+                usages.push({
+                    line: lineNumber,
+                    oldText: `serialiserFactory.create(${modelName})`,
+                    newText: `serialiserFactory.create(${descriptorName}.model)`,
+                });
+            }
+            // Pattern: modelRegistry.register(EntityModel) -> modelRegistry.register(EntityDescriptor.model)
+            if (line.includes(`modelRegistry.register(${modelName})`)) {
+                usages.push({
+                    line: lineNumber,
+                    oldText: `modelRegistry.register(${modelName})`,
+                    newText: `modelRegistry.register(${descriptorName}.model)`,
+                });
+            }
+            // Pattern: standalone EntityModel usage (not followed by .)
+            // But NOT inside a property access pattern we already handled
+            if (!line.includes(`${modelName}.`)) {
+                const standalonePattern = new RegExp(`\\b${modelName}\\b`, "g");
+                if (standalonePattern.test(line)) {
+                    usages.push({
+                        line: lineNumber,
+                        oldText: modelName,
+                        newText: `${descriptorName}.model`,
+                    });
+                }
+            }
+        }
+    }
+    // Deduplicate usages for the same line and text
+    return deduplicateUsages(usages);
+}
+/**
+ * Extracts ALL old import statements related to the entity.
+ */
+function extractAllOldImports(content, entityName, metaName, modelName, entityTypeName) {
+    const imports = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+        if (!line.trim().startsWith("import "))
+            continue;
+        // Check for various import patterns
+        const isEntityImport = line.includes(metaName) ||
+            line.includes(modelName) ||
+            (line.includes(`${entityName}.entity`) && line.includes(entityTypeName)) ||
+            line.includes(`${entityName}.meta`) ||
+            line.includes(`${entityName}.model`);
+        if (isEntityImport) {
+            imports.push(line);
+        }
+    }
+    return imports;
+}
+/**
+ * Calculates the new import statement, consolidating all old imports.
+ */
+function calculateNewImport(oldImports, entityName, labelName) {
+    const descriptorName = `${labelName}Descriptor`;
+    const imports = [];
+    let importPath = null;
+    // Determine what to import
+    let needsDescriptor = false;
+    let needsEntityType = false;
+    for (const oldImport of oldImports) {
+        // Check what's being imported
+        if (oldImport.includes("Meta") || oldImport.includes("Model")) {
+            needsDescriptor = true;
+        }
+        // Check if the entity type itself is imported
+        const entityTypePattern = new RegExp(`\\b${labelName}\\b`);
+        if (entityTypePattern.test(oldImport) && !oldImport.includes("Model") && !oldImport.includes("Meta")) {
+            needsEntityType = true;
+        }
+        // Extract path for the new import
+        const pathMatch = oldImport.match(/from\s+["']([^"']+)["']/);
+        if (pathMatch && !importPath) {
+            let extractedPath = pathMatch[1];
+            // Remove suffixes to get base path
+            extractedPath = extractedPath.replace(/\.(meta|model|entity)$/, "");
+            importPath = extractedPath;
+        }
+    }
+    if (!importPath) {
+        // Fallback: construct path from entity name
+        importPath = `src/features/${entityName}/entities/${entityName}`;
+    }
+    // Build import list
+    if (needsDescriptor) {
+        imports.push(descriptorName);
+    }
+    if (needsEntityType) {
+        imports.push(labelName);
+    }
+    if (imports.length === 0) {
+        imports.push(descriptorName); // Default to descriptor
+    }
+    return `import { ${imports.join(", ")} } from "${importPath}";`;
+}
+/**
+ * Updates a file with the new references.
+ */
+function updateFileReferences(filePath, reference) {
+    let content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const newLines = [];
+    // Track which old imports we need to remove
+    const oldImportLines = new Set(reference.oldImport.split("\n"));
+    let newImportAdded = false;
+    // First pass: handle imports
+    for (const line of lines) {
+        if (oldImportLines.has(line)) {
+            // Replace first old import with new import, skip rest
+            if (!newImportAdded) {
+                newLines.push(reference.newImport);
+                newImportAdded = true;
+            }
+            // Skip this old import line
+        }
+        else {
+            newLines.push(line);
+        }
+    }
+    content = newLines.join("\n");
+    // Second pass: apply usage replacements (only to non-import lines)
+    // Sort by length descending to replace longer patterns first
+    const sortedUsages = [...reference.usages].sort((a, b) => b.oldText.length - a.oldText.length);
+    for (const usage of sortedUsages) {
+        // Use a regex that doesn't match inside import statements
+        const lines2 = content.split("\n");
+        const updatedLines = [];
+        for (const line of lines2) {
+            if (line.trim().startsWith("import ")) {
+                // Don't modify import lines
+                updatedLines.push(line);
+            }
+            else {
+                // Replace in non-import lines
+                updatedLines.push(line.split(usage.oldText).join(usage.newText));
+            }
+        }
+        content = updatedLines.join("\n");
+    }
+    return content;
+}
+/**
+ * Deduplicates usages that have the same oldText.
+ */
+function deduplicateUsages(usages) {
+    const seen = new Set();
+    return usages.filter((usage) => {
+        // Dedupe by oldText only (not line) to avoid multiple replacements
+        if (seen.has(usage.oldText))
+            return false;
+        seen.add(usage.oldText);
+        return true;
+    });
+}
+/**
+ * Generates a summary of all reference changes.
+ */
+function summarizeReferences(references) {
+    if (references.length === 0) {
+        return "No external references found.";
+    }
+    let summary = `Found ${references.length} files with references:\n`;
+    for (const ref of references) {
+        const relativePath = path.relative(process.cwd(), ref.filePath);
+        summary += `  - ${relativePath} (${ref.usages.length} changes)\n`;
+    }
+    return summary;
+}

package/dist/tools/migrate-entity/lib/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Entity Migration CLI - Shared Types
+ *
+ * Types used across the migration tool modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });