@carlonicora/nestjs-neo4jsonapi 1.31.2 → 1.32.0

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

@@ -154,14 +154,25 @@ class EntityMigrator {
                 });
             }
         }
-        // 6. Write meta file first
+        // 6. Write meta file first (preserve additional exports if they exist)
+        let finalMetaContent = metaContent;
+        if (fs.existsSync(metaTargetPath)) {
+            const existingMeta = fs.readFileSync(metaTargetPath, "utf-8");
+            // Check if existing file has additional exports beyond the primary meta
+            const primaryMetaName = `${parsed.meta.nodeName}Meta`;
+            const additionalExports = this.extractAdditionalMetaExports(existingMeta, primaryMetaName);
+            if (additionalExports) {
+                // Append additional exports to the new meta content
+                finalMetaContent = metaContent.trimEnd() + "\n" + additionalExports;
+            }
+        }
         changes.push({
             type: fs.existsSync(metaTargetPath) ? "update" : "create",
             path: metaTargetPath,
-            content: metaContent,
+            content: finalMetaContent,
         });
         if (!this.options.dryRun) {
-            fs.writeFileSync(metaTargetPath, metaContent);
+            fs.writeFileSync(metaTargetPath, finalMetaContent);
             this.log(`    Created: ${path.relative(process.cwd(), metaTargetPath)}`);
         }
         else {
@@ -180,9 +191,10 @@ class EntityMigrator {
         else {
             this.log(`    Would create: ${path.relative(process.cwd(), targetPath)}`);
         }
-        // 8. Find and update external references
+        // 8. Find and update external references (exclude the entity files we just created)
         this.log(`    Finding external references...`);
-        const references = await (0, reference_updater_1.findExternalReferences)(oldFiles.entityName, parsed.meta.labelName, "src");
+        const references = await (0, reference_updater_1.findExternalReferences)(oldFiles.entityName, parsed.meta.labelName, "src", [targetPath, metaTargetPath], // Exclude the entity files being migrated
+        parsed.aliasModels);
         if (this.options.verbose) {
             this.log((0, reference_updater_1.summarizeReferences)(references));
         }
@@ -204,7 +216,7 @@ class EntityMigrator {
         // 9. Update module file
         const moduleFile = await (0, module_updater_1.findModuleFile)(modulePath);
         if (moduleFile) {
-            const moduleUpdate = (0, module_updater_1.updateModule)(moduleFile, oldFiles.entityName, parsed.meta.labelName);
+            const moduleUpdate = (0, module_updater_1.updateModule)(moduleFile, oldFiles.entityName, parsed.meta.labelName, parsed.aliasModels);
             if (moduleUpdate) {
                 const formattedContent = (0, module_updater_1.formatModuleContent)(moduleUpdate.updatedContent);
                 changes.push({
@@ -224,7 +236,27 @@ class EntityMigrator {
                 }
             }
         }
-        // 10. Delete old files (model, map, serialiser - not meta since we're using the same path)
+        // 10. Update module's index.ts to export new descriptor instead of old model
+        const indexPath = path.join(modulePath, "index.ts");
+        if (fs.existsSync(indexPath)) {
+            const indexContent = fs.readFileSync(indexPath, "utf-8");
+            const updatedIndexContent = this.updateIndexExports(indexContent, oldFiles.entityName, parsed.meta.labelName, parsed.aliasModels);
+            if (updatedIndexContent !== indexContent) {
+                changes.push({
+                    type: "update",
+                    path: indexPath,
+                    content: updatedIndexContent,
+                });
+                if (!this.options.dryRun) {
+                    fs.writeFileSync(indexPath, updatedIndexContent);
+                    this.log(`    Updated index: ${path.relative(process.cwd(), indexPath)}`);
+                }
+                else {
+                    this.log(`    Would update index: ${path.relative(process.cwd(), indexPath)}`);
+                }
+            }
+        }
+        // 12. Delete old files (model, map, serialiser - not meta since we're using the same path)
         const filesToDelete = [oldFiles.model, oldFiles.map, oldFiles.serialiser].filter((f) => f !== null);
         // Don't delete the old meta file if it's the same as our target meta file
         if (oldFiles.meta && oldFiles.meta !== metaTargetPath) {
@@ -250,9 +282,9 @@ class EntityMigrator {
                 this.log(`    Would delete: ${path.relative(process.cwd(), fileToDelete)}`);
             }
         }
-        // 11. Clean up empty directories
+        // 13. Clean up empty directories
         await this.cleanupEmptyDirectories(modulePath);
-        // 12. Detect and warn about custom cypher.service.ts logic
+        // 14. Detect and warn about custom cypher.service.ts logic
         const cypherWarnings = (0, ast_parser_1.detectCypherServiceWarnings)(modulePath);
         if (cypherWarnings.length > 0) {
             this.log(`\n    ⚠️  PHASE 2 WARNING: Custom cypher.service.ts logic detected:`);
@@ -283,6 +315,77 @@ class EntityMigrator {
         const baseName = oldFiles.entityName;
         return path.join(oldFiles.entityDir, `${baseName}.meta.ts`);
     }
+    /**
+     * Updates the module's index.ts to export the new descriptor instead of old model.
+     * - Changes ./entities/entity.entity -> ./entities/entity
+     * - Replaces EntityModel export with EntityDescriptor (and alias descriptors)
+     * - Keeps Entity type export
+     * - Reorders exports so entity/descriptor comes BEFORE module (avoids circular dependency)
+     */
+    updateIndexExports(content, entityName, labelName, aliasModels = []) {
+        const modelName = `${labelName}Model`;
+        const descriptorName = `${labelName}Descriptor`;
+        const moduleName = `${labelName}Module`;
+        // Build the list of all descriptors to export (base + aliases)
+        const allDescriptors = [descriptorName, ...aliasModels.map(a => a.descriptorName)];
+        const descriptorsExport = allDescriptors.join(", ");
+        let updated = content;
+        // Pattern 1: export { Entity } from "./entities/entity.entity"
+        // -> export { Entity, EntityDescriptor, AliasDescriptors... } from "./entities/entity"
+        const entityExportPattern = new RegExp(`export\\s*\\{\\s*(${labelName})\\s*\\}\\s*from\\s*["']\\./entities/${entityName}\\.entity["']`, "g");
+        updated = updated.replace(entityExportPattern, `export { ${labelName}, ${descriptorsExport} } from "./entities/${entityName}"`);
+        // Pattern 2: export { EntityModel } from "./entities/entity.model"
+        // -> remove this line (descriptor is exported from entity file now)
+        // Also handles lines with multiple models like: export { AssigneeModel, AuthorModel, UserModel } from ...
+        const modelExportPattern = new RegExp(`export\\s*\\{[^}]*${modelName}[^}]*\\}\\s*from\\s*["']\\./entities/${entityName}\\.model["'];?\\n?`, "g");
+        updated = updated.replace(modelExportPattern, "");
+        // Pattern 2b: export * from "./entities/entity.map" -> remove (file deleted)
+        const mapStarExportPattern = new RegExp(`export\\s*\\*\\s*from\\s*["']\\./entities/${entityName}\\.map["'];?\\n?`, "g");
+        updated = updated.replace(mapStarExportPattern, "");
+        // Pattern 2c: export { EntitySerialiser } from "./serialisers/entity.serialiser" -> remove (file deleted)
+        const serialiserExportPattern = new RegExp(`export\\s*\\{[^}]*\\}\\s*from\\s*["']\\./serialisers/${entityName}\\.serialiser["'];?\\n?`, "g");
+        updated = updated.replace(serialiserExportPattern, "");
+        // Pattern 3: If Entity is exported separately and we haven't handled it yet
+        // Handle case where entity and model are on separate lines
+        const simpleEntityExport = new RegExp(`(export\\s*\\{\\s*${labelName}\\s*\\}\\s*from\\s*["']\\./entities/${entityName}["'])`, "g");
+        if (simpleEntityExport.test(updated) && !updated.includes(descriptorName)) {
+            updated = updated.replace(simpleEntityExport, `export { ${labelName}, ${descriptorsExport} } from "./entities/${entityName}"`);
+        }
+        // Reorder exports: entity/descriptor must come BEFORE module to avoid circular dependency
+        // Find the module export line and entity export line
+        const lines = updated.split("\n");
+        const moduleExportIndex = lines.findIndex(line => line.includes(moduleName) && line.includes("./") && line.includes("module"));
+        const entityExportIndex = lines.findIndex(line => line.includes(descriptorName) || (line.includes(labelName) && line.includes("./entities/")));
+        // If module export comes before entity export, swap them
+        if (moduleExportIndex !== -1 && entityExportIndex !== -1 && moduleExportIndex < entityExportIndex) {
+            const moduleExportLine = lines[moduleExportIndex];
+            const entityExportLine = lines[entityExportIndex];
+            lines[moduleExportIndex] = entityExportLine;
+            lines[entityExportIndex] = moduleExportLine;
+            updated = lines.join("\n");
+        }
+        return updated;
+    }
+    /**
+     * Extracts additional meta exports from an existing meta file.
+     * Returns the additional exports (everything after the primary meta) or null if none exist.
+     */
+    extractAdditionalMetaExports(existingContent, primaryMetaName) {
+        // Find where the primary meta export ends
+        const primaryMetaPattern = new RegExp(`export\\s+const\\s+${primaryMetaName}\\s*:\\s*DataMeta\\s*=\\s*\\{[^}]+\\};`, "s");
+        const match = existingContent.match(primaryMetaPattern);
+        if (!match)
+            return null;
+        // Get everything after the primary meta
+        const afterPrimary = existingContent.slice(match.index + match[0].length).trim();
+        if (!afterPrimary)
+            return null;
+        // Check if there are additional exports
+        if (afterPrimary.includes("export const")) {
+            return "\n" + afterPrimary;
+        }
+        return null;
+    }
     /**
      * Cleans up empty directories after file deletion.
      */

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

@@ -56,23 +56,23 @@ async function findModuleFile(modulePath) {
 /**
  * Updates the module file to use the new descriptor pattern.
  */
-function updateModule(modulePath, entityName, labelName) {
+function updateModule(modulePath, entityName, labelName, aliasModels = []) {
     const content = fs.readFileSync(modulePath, "utf-8");
     const changes = [];
     const descriptorName = `${labelName}Descriptor`;
     const modelName = `${labelName}Model`;
     const serialiserName = `${labelName}Serialiser`;
+    // Build list of all descriptors (base + aliases)
+    const allDescriptors = [descriptorName, ...aliasModels.map(a => a.descriptorName)];
     let updatedContent = content;
-    // 1. Update import: EntityModel -> EntityDescriptor
-    const modelImportPattern = new RegExp(`import\\s*\\{\\s*${modelName}\\s*\\}\\s*from\\s*["'][^"']+\\.model["'];?`, "g");
+    // 1. Update import: EntityModel, AliasModel... -> EntityDescriptor, AliasDescriptor...
+    // Handle imports that may include multiple models on one line
+    const modelImportPattern = new RegExp(`import\\s*\\{[^}]*${modelName}[^}]*\\}\\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", "");
+        // Replace the entire import with the new descriptors
+        const newImportPath = `import { ${allDescriptors.join(", ")} } from "./entities/${entityName}";`;
         updatedContent = updatedContent.replace(modelImportPattern, newImportPath);
-        changes.push(`Updated import: ${modelName} -> ${descriptorName}`);
+        changes.push(`Updated import: models -> ${allDescriptors.join(", ")}`);
     }
     // 2. Remove serialiser import (it's now auto-generated)
     const serialiserImportPattern = new RegExp(`import\\s*\\{\\s*${serialiserName}\\s*\\}\\s*from\\s*["'][^"']+["'];?\\n?`, "g");
@@ -92,12 +92,28 @@ function updateModule(modulePath, entityName, labelName) {
         updatedContent = updatedContent.replace(registryPattern, `modelRegistry.register(${descriptorName}.model)`);
         changes.push(`Updated registry: modelRegistry.register(${modelName}) -> modelRegistry.register(${descriptorName}.model)`);
     }
+    // 4b. Update alias model registry registrations
+    for (const alias of aliasModels) {
+        const aliasRegistryPattern = new RegExp(`modelRegistry\\.register\\(${alias.modelName}\\)`, "g");
+        if (aliasRegistryPattern.test(updatedContent)) {
+            updatedContent = updatedContent.replace(aliasRegistryPattern, `modelRegistry.register(${alias.descriptorName}.model)`);
+            changes.push(`Updated registry: modelRegistry.register(${alias.modelName}) -> modelRegistry.register(${alias.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`);
     }
+    // 5b. Update any other standalone alias model usages
+    for (const alias of aliasModels) {
+        const standaloneAliasPattern = new RegExp(`\\b${alias.modelName}\\b(?!\\.)`, "g");
+        if (standaloneAliasPattern.test(updatedContent)) {
+            updatedContent = updatedContent.replace(standaloneAliasPattern, `${alias.descriptorName}.model`);
+            changes.push(`Updated standalone ${alias.modelName} usages`);
+        }
+    }
     if (changes.length === 0) {
         return null;
     }

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

@@ -42,38 +42,51 @@ exports.findExternalReferences = findExternalReferences;
 exports.updateFileReferences = updateFileReferences;
 exports.summarizeReferences = summarizeReferences;
 const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
 const glob_1 = require("glob");
+const path = __importStar(require("path"));
 /**
  * Finds all external files that reference the old entity exports.
  */
-async function findExternalReferences(entityName, labelName, srcDir = "src") {
+async function findExternalReferences(entityName, labelName, srcDir = "src", excludePaths = [], aliasModels = []) {
     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() });
+    // Build list of all model names (base + aliases) for pattern matching
+    const allModelNames = [modelName, ...aliasModels.map((a) => a.modelName)];
+    // Normalize exclude paths for comparison
+    const normalizedExcludePaths = new Set(excludePaths.map((p) => path.normalize(path.resolve(process.cwd(), p))));
+    // Find all TypeScript files (including test files - they may import entities)
+    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 absolutePath = path.normalize(path.resolve(process.cwd(), filePath));
+        // Skip excluded paths (the entity files being migrated)
+        if (normalizedExcludePaths.has(absolutePath)) {
+            continue;
+        }
         const content = fs.readFileSync(absolutePath, "utf-8");
-        // Check if file imports or uses the old exports
-        const hasOldPatterns = content.includes(metaName) ||
-            content.includes(modelName) ||
+        // Check if file imports or uses the old exports (model/entity files that will be deleted)
+        // Note: We DON'T include ${entityName}.meta because meta files are preserved
+        const hasOldPatterns = allModelNames.some((name) => content.includes(name)) ||
             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);
+        // Check if file imports from the meta file - if so, skip metaName replacements
+        // since companyMeta is still available from company.meta.ts
+        const importsFromMetaFile = content.includes(`${entityName}.meta"`);
+        const usages = findUsagesInFile(content, metaName, modelName, labelName, importsFromMetaFile, aliasModels);
+        // Find all old imports that need updating (excluding meta file imports)
+        const oldImports = extractAllOldImports(content, entityName, metaName, modelName, entityTypeName, aliasModels);
         if (usages.length === 0 && oldImports.length === 0)
             continue;
-        // Calculate new import
-        const newImport = calculateNewImport(oldImports, entityName, labelName);
+        // Calculate new import (pass content to detect entity type usage in return types etc.)
+        const newImport = calculateNewImport(oldImports, entityName, labelName, aliasModels, content);
         references.push({
             filePath: absolutePath,
             oldImport: oldImports.join("\n"), // Store all old imports
@@ -85,8 +98,9 @@ async function findExternalReferences(entityName, labelName, srcDir = "src") {
 }
 /**
  * Finds all usages of old exports within a file (excluding import lines).
+ * @param skipMetaReplacements - If true, don't replace metaName usages (file imports from .meta.ts)
  */
-function findUsagesInFile(content, metaName, modelName, labelName) {
+function findUsagesInFile(content, metaName, modelName, labelName, skipMetaReplacements = false, aliasModels = []) {
     const usages = [];
     const lines = content.split("\n");
     const descriptorName = `${labelName}Descriptor`;
@@ -96,8 +110,11 @@ function findUsagesInFile(content, metaName, modelName, labelName) {
         // Skip import lines (handled separately)
         if (line.trim().startsWith("import "))
             continue;
-        // Check for meta usage patterns
-        if (line.includes(metaName)) {
+        // Skip export lines (these are definitions, not usages)
+        if (line.trim().startsWith("export "))
+            continue;
+        // Check for meta usage patterns (only if not importing from .meta.ts file)
+        if (!skipMetaReplacements && line.includes(metaName)) {
             // Pattern: entityMeta.property -> EntityDescriptor.model.property
             const metaPattern = new RegExp(`${metaName}\\.(\\w+)`, "g");
             let match;
@@ -159,24 +176,70 @@ function findUsagesInFile(content, metaName, modelName, labelName) {
                 }
             }
         }
+        // Check for alias model usage patterns (OwnerModel, AuthorModel, etc.)
+        for (const alias of aliasModels) {
+            if (line.includes(alias.modelName)) {
+                // Pattern: serialiserFactory.create(AliasModel) -> serialiserFactory.create(AliasDescriptor.model)
+                if (line.includes(`serialiserFactory.create(${alias.modelName})`)) {
+                    usages.push({
+                        line: lineNumber,
+                        oldText: `serialiserFactory.create(${alias.modelName})`,
+                        newText: `serialiserFactory.create(${alias.descriptorName}.model)`,
+                    });
+                }
+                // Pattern: modelRegistry.register(AliasModel) -> modelRegistry.register(AliasDescriptor.model)
+                if (line.includes(`modelRegistry.register(${alias.modelName})`)) {
+                    usages.push({
+                        line: lineNumber,
+                        oldText: `modelRegistry.register(${alias.modelName})`,
+                        newText: `modelRegistry.register(${alias.descriptorName}.model)`,
+                    });
+                }
+                // Pattern: AliasModel.property -> AliasDescriptor.model.property
+                const aliasPropertyPattern = new RegExp(`${alias.modelName}\\.(\\w+)`, "g");
+                let match;
+                while ((match = aliasPropertyPattern.exec(line)) !== null) {
+                    usages.push({
+                        line: lineNumber,
+                        oldText: `${alias.modelName}.${match[1]}`,
+                        newText: `${alias.descriptorName}.model.${match[1]}`,
+                    });
+                }
+                // Pattern: standalone AliasModel usage (not followed by .)
+                if (!line.includes(`${alias.modelName}.`)) {
+                    const standaloneAliasPattern = new RegExp(`\\b${alias.modelName}\\b`, "g");
+                    if (standaloneAliasPattern.test(line)) {
+                        usages.push({
+                            line: lineNumber,
+                            oldText: alias.modelName,
+                            newText: `${alias.descriptorName}.model`,
+                        });
+                    }
+                }
+            }
+        }
     }
     // Deduplicate usages for the same line and text
     return deduplicateUsages(usages);
 }
 /**
  * Extracts ALL old import statements related to the entity.
+ * Note: Excludes imports from .meta.ts files since those are preserved.
  */
-function extractAllOldImports(content, entityName, metaName, modelName, entityTypeName) {
+function extractAllOldImports(content, entityName, metaName, modelName, entityTypeName, aliasModels = []) {
     const imports = [];
     const lines = content.split("\n");
+    // Build list of all model names (base + aliases) for pattern matching
+    const allModelNames = [modelName, ...aliasModels.map((a) => a.modelName)];
     for (const line of lines) {
         if (!line.trim().startsWith("import "))
             continue;
-        // Check for various import patterns
-        const isEntityImport = line.includes(metaName) ||
-            line.includes(modelName) ||
+        // Skip imports from .meta.ts files - those are preserved and still valid
+        if (line.includes(`${entityName}.meta"`))
+            continue;
+        // Check for various import patterns (entity/model files that will be deleted)
+        const isEntityImport = allModelNames.some((name) => line.includes(name)) ||
             (line.includes(`${entityName}.entity`) && line.includes(entityTypeName)) ||
-            line.includes(`${entityName}.meta`) ||
             line.includes(`${entityName}.model`);
         if (isEntityImport) {
             imports.push(line);
@@ -187,18 +250,25 @@ function extractAllOldImports(content, entityName, metaName, modelName, entityTy
 /**
  * Calculates the new import statement, consolidating all old imports.
  */
-function calculateNewImport(oldImports, entityName, labelName) {
+function calculateNewImport(oldImports, entityName, labelName, aliasModels = [], fileContent = "") {
     const descriptorName = `${labelName}Descriptor`;
     const imports = [];
     let importPath = null;
     // Determine what to import
     let needsDescriptor = false;
     let needsEntityType = false;
+    const neededAliasDescriptors = new Set();
     for (const oldImport of oldImports) {
         // Check what's being imported
-        if (oldImport.includes("Meta") || oldImport.includes("Model")) {
+        if (oldImport.includes("Meta") || oldImport.includes(`${labelName}Model`)) {
             needsDescriptor = true;
         }
+        // Check for alias models
+        for (const alias of aliasModels) {
+            if (oldImport.includes(alias.modelName)) {
+                neededAliasDescriptors.add(alias.descriptorName);
+            }
+        }
         // 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")) {
@@ -213,6 +283,18 @@ function calculateNewImport(oldImports, entityName, labelName) {
             importPath = extractedPath;
         }
     }
+    // Also check if the entity type is used in the file content (e.g., in return types like Promise<User[]>)
+    // This catches cases where the type is used but wasn't in the old imports
+    if (!needsEntityType && fileContent) {
+        // Look for entity type usage outside of import lines
+        const lines = fileContent.split("\n").filter((line) => !line.trim().startsWith("import "));
+        const contentWithoutImports = lines.join("\n");
+        // Match the entity type followed by common type patterns: [], >, ), :, |, &, etc.
+        const typeUsagePattern = new RegExp(`\\b${labelName}\\s*[\\[\\]>\\):\\|&,]`, "g");
+        if (typeUsagePattern.test(contentWithoutImports)) {
+            needsEntityType = true;
+        }
+    }
     if (!importPath) {
         // Fallback: construct path from entity name
         importPath = `src/features/${entityName}/entities/${entityName}`;
@@ -224,6 +306,10 @@ function calculateNewImport(oldImports, entityName, labelName) {
     if (needsEntityType) {
         imports.push(labelName);
     }
+    // Add alias descriptors
+    for (const aliasDescriptor of neededAliasDescriptors) {
+        imports.push(aliasDescriptor);
+    }
     if (imports.length === 0) {
         imports.push(descriptorName); // Default to descriptor
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carlonicora/nestjs-neo4jsonapi",
-  "version": "1.31.2",
+  "version": "1.32.0",
   "description": "NestJS foundation package with JSON:API, Neo4j, Redis, LangChain agents, and common utilities",
   "author": "Carlo Nicora",
   "license": "GPL-3.0-or-later",
@@ -49,7 +49,7 @@
     }
   },
   "scripts": {
-    "build": "tsc && tsc -p tools/migrate-entity/tsconfig.json && tsc -p scripts/generate-module/tsconfig.json",
+    "build": "tsc && tsc -p tools/migrate-entity/tsconfig.json && tsc -p scripts/generate-module/tsconfig.json && cp -R src/core/email/templates dist/core/email/",
     "dev": "tsc --watch",
     "clean": "rm -rf dist",
     "lint": "eslint \"src/**/*.ts\" --fix",

package/dist/foundations/company/entities/company.entity.d.ts

@@ -1,18 +0,0 @@
-import { Entity } from "../../../common/abstracts/entity";
-import { Feature } from "../../feature/entities/feature.entity";
-import { Module } from "../../module/entities/module.entity";
-export type Company = Entity & {
-    name: string;
-    logo?: string;
-    logoUrl?: string;
-    isActiveSubscription: boolean;
-    ownerEmail: string;
-    monthlyTokens: number;
-    availableMonthlyTokens: number;
-    availableExtraTokens: number;
-    configurations?: string;
-    feature: Feature[];
-    module: Module[];
-    configuration?: any;
-};
-//# sourceMappingURL=company.entity.d.ts.map

package/dist/foundations/company/entities/company.entity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"company.entity.d.ts","sourceRoot":"","sources":["../../../../src/foundations/company/entities/company.entity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAE7D,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,CAAC,EAAE,GAAG,CAAC;CACrB,CAAC"}

package/dist/foundations/company/entities/company.entity.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=company.entity.js.map

package/dist/foundations/company/entities/company.entity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"company.entity.js","sourceRoot":"","sources":["../../../../src/foundations/company/entities/company.entity.ts"],"names":[],"mappings":""}

package/dist/foundations/company/entities/company.map.d.ts

@@ -1,8 +0,0 @@
-import { EntityFactory } from "../../../core/neo4j/factories/entity.factory";
-import { Company } from "../../company/entities/company.entity";
-export declare const mapCompany: (params: {
-    data: any;
-    record: any;
-    entityFactory: EntityFactory;
-}) => Company;
-//# sourceMappingURL=company.map.d.ts.map

package/dist/foundations/company/entities/company.map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"company.map.d.ts","sourceRoot":"","sources":["../../../../src/foundations/company/entities/company.map.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAEhE,eAAO,MAAM,UAAU,GAAI,QAAQ;IAAE,IAAI,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,aAAa,EAAE,aAAa,CAAA;CAAE,KAAG,OAiB7F,CAAC"}

package/dist/foundations/company/entities/company.map.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapCompany = void 0;
-const entity_1 = require("../../../common/abstracts/entity");
-const mapCompany = (params) => {
-    return {
-        ...(0, entity_1.mapEntity)({ record: params.data }),
-        name: params.data.name,
-        configurations: params.data.configurations,
-        logo: params.data.logo,
-        logoUrl: params.data.logoUrl,
-        monthlyTokens: params.data.monthlyTokens ?? 0,
-        availableMonthlyTokens: params.data.availableMonthlyTokens ?? 0,
-        availableExtraTokens: params.data.availableExtraTokens ?? 0,
-        ownerEmail: params.data.ownerEmail,
-        isActiveSubscription: params.data.isActiveSubscription,
-        feature: [],
-        module: [],
-        configuration: undefined,
-    };
-};
-exports.mapCompany = mapCompany;
-//# sourceMappingURL=company.map.js.map

package/dist/foundations/company/entities/company.map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"company.map.js","sourceRoot":"","sources":["../../../../src/foundations/company/entities/company.map.ts"],"names":[],"mappings":";;;AAAA,6DAA6D;AAItD,MAAM,UAAU,GAAG,CAAC,MAAgE,EAAW,EAAE;IACtG,OAAO;QACL,GAAG,IAAA,kBAAS,EAAC,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;QACrC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI;QACtB,cAAc,EAAE,MAAM,CAAC,IAAI,CAAC,cAAc;QAC1C,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI;QACtB,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO;QAC5B,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC;QAC7C,sBAAsB,EAAE,MAAM,CAAC,IAAI,CAAC,sBAAsB,IAAI,CAAC;QAC/D,oBAAoB,EAAE,MAAM,CAAC,IAAI,CAAC,oBAAoB,IAAI,CAAC;QAC3D,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU;QAClC,oBAAoB,EAAE,MAAM,CAAC,IAAI,CAAC,oBAAoB;QAEtD,OAAO,EAAE,EAAE;QACX,MAAM,EAAE,EAAE;QACV,aAAa,EAAE,SAAS;KACzB,CAAC;AACJ,CAAC,CAAC;AAjBW,QAAA,UAAU,cAiBrB"}

package/dist/foundations/company/entities/company.model.d.ts

@@ -1,4 +0,0 @@
-import { DataModelInterface } from "../../../common/interfaces/datamodel.interface";
-import { Company } from "../../company/entities/company.entity";
-export declare const CompanyModel: DataModelInterface<Company>;
-//# sourceMappingURL=company.model.d.ts.map

package/dist/foundations/company/entities/company.model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"company.model.d.ts","sourceRoot":"","sources":["../../../../src/foundations/company/entities/company.model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAOhE,eAAO,MAAM,YAAY,EAAE,kBAAkB,CAAC,OAAO,CAOpD,CAAC"}

package/dist/foundations/company/entities/company.model.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompanyModel = void 0;
-const company_map_1 = require("../../company/entities/company.map");
-const company_meta_1 = require("../../company/entities/company.meta");
-const company_serialiser_1 = require("../../company/serialisers/company.serialiser");
-const feature_meta_1 = require("../../feature/entities/feature.meta");
-const module_meta_1 = require("../../module/entities/module.meta");
-exports.CompanyModel = {
-    ...company_meta_1.companyMeta,
-    entity: undefined,
-    mapper: company_map_1.mapCompany,
-    serialiser: company_serialiser_1.CompanySerialiser,
-    singleChildrenTokens: [`configuration`],
-    childrenTokens: [feature_meta_1.featureMeta.nodeName, module_meta_1.moduleMeta.nodeName],
-};
-//# sourceMappingURL=company.model.js.map

package/dist/foundations/company/entities/company.model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"company.model.js","sourceRoot":"","sources":["../../../../src/foundations/company/entities/company.model.ts"],"names":[],"mappings":";;;AAEA,oEAAgE;AAChE,sEAAkE;AAClE,qFAAiF;AACjF,sEAAkE;AAClE,mEAA+D;AAElD,QAAA,YAAY,GAAgC;IACvD,GAAG,0BAAW;IACd,MAAM,EAAE,SAA+B;IACvC,MAAM,EAAE,wBAAU;IAClB,UAAU,EAAE,sCAAiB;IAC7B,oBAAoB,EAAE,CAAC,eAAe,CAAC;IACvC,cAAc,EAAE,CAAC,0BAAW,CAAC,QAAQ,EAAE,wBAAU,CAAC,QAAQ,CAAC;CAC5D,CAAC"}

package/dist/foundations/company/serialisers/company.serialiser.d.ts

@@ -1,14 +0,0 @@
-import { ConfigService } from "@nestjs/config";
-import { BaseConfigInterface } from "../../../config/interfaces";
-import { AbstractJsonApiSerialiser } from "../../../core/jsonapi/abstracts/abstract.jsonapi.serialiser";
-import { JsonApiSerialiserFactory } from "../../../core/jsonapi/factories/jsonapi.serialiser.factory";
-import { JsonApiDataInterface } from "../../../core/jsonapi/interfaces/jsonapi.data.interface";
-import { JsonApiServiceInterface } from "../../../core/jsonapi/interfaces/jsonapi.service.interface";
-import { S3Service } from "../../s3/services/s3.service";
-export declare class CompanySerialiser extends AbstractJsonApiSerialiser implements JsonApiServiceInterface {
-    protected readonly s3Service: S3Service;
-    constructor(serialiserFactory: JsonApiSerialiserFactory, s3Service: S3Service, configService: ConfigService<BaseConfigInterface>);
-    get type(): string;
-    create(): JsonApiDataInterface;
-}
-//# sourceMappingURL=company.serialiser.d.ts.map

package/dist/foundations/company/serialisers/company.serialiser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"company.serialiser.d.ts","sourceRoot":"","sources":["../../../../src/foundations/company/serialisers/company.serialiser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,yBAAyB,EAAE,MAAM,6DAA6D,CAAC;AACxG,OAAO,EAAE,wBAAwB,EAAE,MAAM,4DAA4D,CAAC;AACtG,OAAO,EAAE,oBAAoB,EAAE,MAAM,yDAAyD,CAAC;AAC/F,OAAO,EAAE,uBAAuB,EAAE,MAAM,4DAA4D,CAAC;AAKrG,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD,qBACa,iBAAkB,SAAQ,yBAA0B,YAAW,uBAAuB;IAG/F,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS;gBADvC,iBAAiB,EAAE,wBAAwB,EACxB,SAAS,EAAE,SAAS,EACvC,aAAa,EAAE,aAAa,CAAC,mBAAmB,CAAC;IAKnD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,MAAM,IAAI,oBAAoB;CAsC/B"}