@carlonicora/nestjs-neo4jsonapi 1.31.2 → 1.32.0

package/dist/tools/migrate-entity/lib/ast-parser.js

@@ -44,6 +44,7 @@ exports.parseMetaFile = parseMetaFile;
 exports.parseEntityFile = parseEntityFile;
 exports.parseMapFile = parseMapFile;
 exports.parseSerialiserFile = parseSerialiserFile;
+exports.parseAliasModels = parseAliasModels;
 exports.parseCypherRelationships = parseCypherRelationships;
 exports.findAndParseCypherRelationships = findAndParseCypherRelationships;
 exports.detectCypherServiceWarnings = detectCypherServiceWarnings;
@@ -56,7 +57,8 @@ function parseOldFiles(files) {
     const entityType = files.entity ? parseEntityFile(files.entity) : createEmptyEntityType(meta.labelName);
     const mapper = files.map ? parseMapFile(files.map) : null;
     const serialiser = files.serialiser ? parseSerialiserFile(files.serialiser) : null;
-    return { meta, entityType, mapper, serialiser };
+    const aliasModels = files.model ? parseAliasModels(files.model, meta.labelName) : [];
+    return { meta, entityType, mapper, serialiser, aliasModels };
 }
 /**
  * Parses the meta.ts file to extract type, endpoint, nodeName, labelName.
@@ -112,7 +114,7 @@ function parseMapFile(filePath) {
     return { fields, imports };
 }
 /**
- * Parses the serialiser.ts file to extract attributes, meta, and relationships.
+ * Parses the serialiser.ts file to extract attributes, meta, relationships, services, and custom methods.
  */
 function parseSerialiserFile(filePath) {
     const content = fs.readFileSync(filePath, "utf-8");
@@ -120,7 +122,11 @@ function parseSerialiserFile(filePath) {
     const meta = extractSerialiserMeta(content);
     const relationships = extractSerialiserRelationships(content);
     const imports = extractImports(content);
-    return { attributes, meta, relationships, imports };
+    const services = extractSerialiserServices(content);
+    const customMethods = extractSerialiserCustomMethods(content);
+    // Detect S3 transforms by parsing function-based attributes that use S3Service
+    const s3Transforms = detectS3Transforms(content);
+    return { attributes, meta, relationships, imports, services, customMethods, s3Transforms };
 }
 /**
  * Extracts type fields from entity type definition.
@@ -189,23 +195,56 @@ function extractImports(content) {
 }
 /**
  * Extracts serialiser attributes from this.attributes = {...}.
+ * Handles both simple string mappings and function-based computed attributes.
  */
 function extractSerialiserAttributes(content) {
     const attributes = [];
-    // Match: this.attributes = { name: "name", content: "content", ... }
-    const attrMatch = content.match(/this\.attributes\s*=\s*\{([^}]+)\}/s);
-    if (!attrMatch)
+    // Find the start of this.attributes = {
+    const attrStart = content.indexOf("this.attributes");
+    if (attrStart === -1)
         return attributes;
-    const attrBlock = attrMatch[1];
-    const fieldPattern = /(\w+):\s*["'](\w+)["']/g;
+    // Find the opening brace
+    const braceStart = content.indexOf("{", attrStart);
+    if (braceStart === -1)
+        return attributes;
+    // Find matching closing brace (handle nested braces)
+    let depth = 1;
+    let i = braceStart + 1;
+    while (i < content.length && depth > 0) {
+        if (content[i] === "{")
+            depth++;
+        else if (content[i] === "}")
+            depth--;
+        i++;
+    }
+    const attrBlock = content.substring(braceStart + 1, i - 1);
+    // Match simple string mappings: name: "name", or name: 'name',
+    const simplePattern = /(\w+):\s*["'](\w+)["']/g;
     let match;
-    while ((match = fieldPattern.exec(attrBlock)) !== null) {
+    while ((match = simplePattern.exec(attrBlock)) !== null) {
         attributes.push({
             name: match[1],
             mapping: match[2],
             isMeta: false,
         });
     }
+    // Match function-based computed attributes (arrow functions that return data properties)
+    // Pattern: fieldName: (data: Type) => { ... return data.property; }
+    // Or: fieldName: (data: Type) => data.property
+    const funcPattern = /(\w+):\s*(?:async\s+)?\([^)]*\)\s*=>\s*(?:\{[^}]*return\s+(?:data\.)?(\w+)[^}]*\}|(?:data\.)?(\w+))/g;
+    while ((match = funcPattern.exec(attrBlock)) !== null) {
+        const fieldName = match[1];
+        // Skip if already added as simple mapping
+        if (attributes.some((a) => a.name === fieldName))
+            continue;
+        // The mapping is either from the function body return or simple arrow return
+        const mapping = match[2] || match[3] || fieldName;
+        attributes.push({
+            name: fieldName,
+            mapping: mapping,
+            isMeta: false,
+        });
+    }
     return attributes;
 }
 /**
@@ -251,12 +290,164 @@ function extractSerialiserRelationships(content) {
         const dtoKeyMatch = block.match(/name:\s*[`"'](\w+)[`"']/);
         const dtoKey = dtoKeyMatch ? dtoKeyMatch[1] : undefined;
         // Extract model from this.serialiserFactory.create(UserModel)
-        const modelMatch = block.match(/this\.serialiserFactory\.create\((\w+)\)/);
+        // Also handles already-migrated entities: this.serialiserFactory.create(CompanyDescriptor.model)
+        const modelMatch = block.match(/this\.serialiserFactory\.create\((\w+)(?:\.model)?\)/);
         const modelImport = modelMatch ? modelMatch[1] : "";
         relationships.push({ name, dtoKey, modelImport });
     }
     return relationships;
 }
+/**
+ * Extracts injected services from the serialiser constructor.
+ * Matches patterns like: private readonly s3Service: S3Service
+ */
+function extractSerialiserServices(content) {
+    const services = [];
+    // Match: private readonly xxxService: XxxService (but not SerialiserFactory)
+    const pattern = /private\s+readonly\s+\w+:\s+(\w+Service)/g;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        const serviceName = match[1];
+        // Skip SerialiserFactory - it's framework infrastructure, not app service
+        if (serviceName !== "SerialiserFactory") {
+            services.push(serviceName);
+        }
+    }
+    return services;
+}
+/**
+ * Extracts custom method names from the serialiser class.
+ * These methods may contain transform logic that needs manual migration.
+ */
+function extractSerialiserCustomMethods(content) {
+    const customMethods = [];
+    // Match method definitions: async methodName(...) or methodName(...)
+    // Skip constructor, standard lifecycle methods, and standard serialiser methods
+    const methodPattern = /(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*[^{]+)?\s*\{/g;
+    const standardMethods = new Set([
+        "constructor",
+        "onModuleInit",
+        "onModuleDestroy",
+        // Standard serialiser methods from AbstractJsonApiSerialiser
+        "type",
+        "create",
+        "endpoint",
+        "endpointParameters",
+        "id",
+        "attributes",
+        "meta",
+        "links",
+        "relationships",
+    ]);
+    let match;
+    while ((match = methodPattern.exec(content)) !== null) {
+        const methodName = match[1];
+        if (!standardMethods.has(methodName)) {
+            customMethods.push(methodName);
+        }
+    }
+    return customMethods;
+}
+/**
+ * Detects S3 transforms by parsing function-based attributes that use S3Service.
+ *
+ * Looks for patterns like:
+ * ```typescript
+ * avatar: async (data: User) => {
+ *   return await this.s3Service.generateSignedUrl({ key: data.avatar });
+ * }
+ * ```
+ *
+ * Also detects array transforms using Promise.all with map.
+ */
+function detectS3Transforms(content) {
+    const transforms = [];
+    // Find the this.attributes = { ... } block
+    const attrStart = content.indexOf("this.attributes");
+    if (attrStart === -1)
+        return transforms;
+    const braceStart = content.indexOf("{", attrStart);
+    if (braceStart === -1)
+        return transforms;
+    // Find matching closing brace (handle nested braces)
+    let depth = 1;
+    let i = braceStart + 1;
+    while (i < content.length && depth > 0) {
+        if (content[i] === "{")
+            depth++;
+        else if (content[i] === "}")
+            depth--;
+        i++;
+    }
+    const attrBlock = content.substring(braceStart + 1, i - 1);
+    // Find function-based attributes that use s3Service.generateSignedUrl
+    // Pattern: fieldName: async (data) => { ... s3Service.generateSignedUrl ... }
+    // We need to match the field name and check if the function body uses S3
+    // Split by top-level commas to get individual attribute definitions
+    const attrDefs = splitAttributeDefinitions(attrBlock);
+    for (const def of attrDefs) {
+        // Check if this definition uses s3Service.generateSignedUrl
+        if (!def.includes("s3Service") && !def.includes("generateSignedUrl")) {
+            continue;
+        }
+        // Extract field name (first identifier before the colon)
+        const fieldNameMatch = def.match(/^\s*(\w+)\s*:/);
+        if (!fieldNameMatch)
+            continue;
+        const fieldName = fieldNameMatch[1];
+        // Check if it's an array transform (uses Promise.all or .map)
+        const isArray = def.includes("Promise.all") || def.includes(".map(");
+        transforms.push({ fieldName, isArray });
+    }
+    return transforms;
+}
+/**
+ * Splits the attributes block into individual attribute definitions,
+ * respecting nested braces and arrow functions.
+ */
+function splitAttributeDefinitions(attrBlock) {
+    const definitions = [];
+    let current = "";
+    let depth = 0;
+    let inString = false;
+    let stringChar = "";
+    for (let i = 0; i < attrBlock.length; i++) {
+        const char = attrBlock[i];
+        const prevChar = i > 0 ? attrBlock[i - 1] : "";
+        // Track string state
+        if ((char === '"' || char === "'" || char === "`") && prevChar !== "\\") {
+            if (!inString) {
+                inString = true;
+                stringChar = char;
+            }
+            else if (char === stringChar) {
+                inString = false;
+            }
+        }
+        if (!inString) {
+            if (char === "{" || char === "(" || char === "[") {
+                depth++;
+            }
+            else if (char === "}" || char === ")" || char === "]") {
+                depth--;
+            }
+            else if (char === "," && depth === 0) {
+                // Top-level comma - end of attribute definition
+                if (current.trim()) {
+                    definitions.push(current.trim());
+                }
+                current = "";
+                continue;
+            }
+        }
+        current += char;
+    }
+    // Add the last definition
+    if (current.trim()) {
+        definitions.push(current.trim());
+    }
+    return definitions;
+}
 /**
  * Creates an empty entity type when entity file doesn't exist.
  */
@@ -268,6 +459,60 @@ function createEmptyEntityType(labelName) {
         imports: [],
     };
 }
+/**
+ * Parses alias models from the model file.
+ *
+ * Alias models are additional model exports that spread from the base model
+ * but use a different meta. Example:
+ *
+ * ```typescript
+ * export const UserModel: DataModelInterface<User> = {
+ *   ...userMeta,
+ *   // ...
+ * };
+ *
+ * export const OwnerModel: DataModelInterface<User> = {
+ *   ...UserModel,
+ *   ...ownerMeta,
+ * };
+ * ```
+ *
+ * @param filePath Path to the model file
+ * @param baseLabelName The label name of the base model (e.g., "User")
+ * @returns Array of alias model info
+ */
+function parseAliasModels(filePath, baseLabelName) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const aliasModels = [];
+    // Pattern to match alias model definitions:
+    // export const XxxModel: DataModelInterface<Entity> = {
+    //   ...BaseModel,
+    //   ...xxxMeta,
+    // };
+    // Note: Alias models spread from the base model AND override with their own meta
+    const aliasPattern = /export\s+const\s+(\w+Model)\s*:\s*DataModelInterface<\w+>\s*=\s*\{[^}]*\.\.\.(\w+Model)[^}]*\.\.\.(\w+Meta)[^}]*\}/gs;
+    let match;
+    while ((match = aliasPattern.exec(content)) !== null) {
+        const modelName = match[1];
+        const baseModel = match[2];
+        const metaName = match[3];
+        // Skip the base model itself (it doesn't spread from another model)
+        // Only include models that spread from the base model
+        if (baseModel === `${baseLabelName}Model`) {
+            // Derive descriptor name from model name: OwnerModel -> OwnerDescriptor
+            const descriptorName = modelName.replace(/Model$/, "Descriptor");
+            aliasModels.push({
+                modelName,
+                metaName,
+                descriptorName,
+            });
+        }
+    }
+    return aliasModels;
+}
 /**
  * Parses Cypher MATCH patterns from a repository or cypher.service file
  * to extract actual relationship types and directions.