vite-plugin-ferry 0.1.2 → 0.1.4

package/dist/utils/php-parser.js

@@ -1,96 +1,271 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { readFileSafe } from './file.js';
+import { mapPhpTypeToTs } from './type-mapper.js';
+// Import php-parser (CommonJS module with constructor)
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const PhpParser = require('php-parser');
+// Initialize the PHP parser (PHP 8+ only)
+const parser = new PhpParser({
+    parser: {
+        extractDoc: true,
+        php8: true,
+    },
+    ast: {
+        withPositions: false,
+    },
+});
 /**
- * Parse a PHP enum file and extract its definition.
+ * Parse PHP content and return the AST.
+ * Uses parseEval which doesn't require <?php tags or filenames.
  */
-export function parseEnumFile(enumPath) {
-    const content = readFileSafe(enumPath);
-    if (!content)
+function parsePhp(content) {
+    try {
+        // Strip <?php tag if present (parseEval expects raw PHP code)
+        let code = content.trimStart();
+        if (code.startsWith('<?php')) {
+            code = code.slice(5);
+        }
+        else if (code.startsWith('<?')) {
+            code = code.slice(2);
+        }
+        return parser.parseEval(code);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Walk all child nodes in an AST node.
+ */
+function walkChildren(node, callback) {
+    const obj = node;
+    for (const key of Object.keys(obj)) {
+        const val = obj[key];
+        if (val && typeof val === 'object' && val.kind) {
+            if (callback(val))
+                return true;
+        }
+        else if (Array.isArray(val)) {
+            for (const item of val) {
+                if (item && typeof item === 'object' && item.kind) {
+                    if (callback(item))
+                        return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Find a node by kind in the AST.
+ */
+function findNodeByKind(ast, kind) {
+    if (ast.kind === kind)
+        return ast;
+    let result = null;
+    walkChildren(ast, (child) => {
+        const found = findNodeByKind(child, kind);
+        if (found) {
+            result = found;
+            return true;
+        }
+        return false;
+    });
+    return result;
+}
+/**
+ * Find all nodes of a specific kind in the AST.
+ */
+function findAllNodesByKind(ast, kind) {
+    const results = [];
+    function walk(node) {
+        if (node.kind === kind) {
+            results.push(node);
+        }
+        walkChildren(node, (child) => {
+            walk(child);
+            return false;
+        });
+    }
+    walk(ast);
+    return results;
+}
+/**
+ * Extract string value from a PHP literal node.
+ */
+function getStringValue(node) {
+    if (node.kind === 'string') {
+        return node.value;
+    }
+    if (node.kind === 'number') {
+        return String(node.value);
+    }
+    return null;
+}
+/**
+ * Parse PHP enum content and extract its definition.
+ * This is a pure function that takes PHP source code as input.
+ */
+export function parseEnumContent(phpContent) {
+    const ast = parsePhp(phpContent);
+    if (!ast)
         return null;
-    // Extract enum name and backing type
-    const enumMatch = content.match(/enum\s+([A-Za-z0-9_]+)\s*(?:\:\s*([A-Za-z0-9_]+))?/);
-    if (!enumMatch)
+    // Find the enum declaration
+    const enumNode = findNodeByKind(ast, 'enum');
+    if (!enumNode)
         return null;
-    const name = enumMatch[1];
-    const backing = enumMatch[2] ? enumMatch[2].toLowerCase() : null;
+    const name = typeof enumNode.name === 'string' ? enumNode.name : enumNode.name.name;
+    const backing = enumNode.valueType ? enumNode.valueType.name.toLowerCase() : null;
     // Extract enum cases
     const cases = [];
-    const explicitCases = [...content.matchAll(/case\s+([A-Za-z0-9_]+)\s*=\s*'([^']*)'\s*;/g)];
-    if (explicitCases.length) {
-        for (const match of explicitCases) {
-            cases.push({ key: match[1], value: match[2] });
+    const enumCases = findAllNodesByKind(enumNode, 'enumcase');
+    for (const enumCase of enumCases) {
+        // Name can be an Identifier or string
+        const key = typeof enumCase.name === 'string'
+            ? enumCase.name
+            : enumCase.name.name;
+        let value;
+        if (enumCase.value !== null && enumCase.value !== undefined) {
+            // Value is a String or Number node (types say string|number but runtime is Node)
+            const valueNode = enumCase.value;
+            if (typeof valueNode === 'object' && valueNode.kind) {
+                if (valueNode.kind === 'number') {
+                    // php-parser returns number values as strings, convert to actual number
+                    value = Number(valueNode.value);
+                }
+                else {
+                    const extracted = getStringValue(valueNode);
+                    value = extracted !== null ? extracted : key;
+                }
+            }
+            else {
+                value = String(enumCase.value);
+            }
         }
-    }
-    else {
-        const implicitCases = [...content.matchAll(/case\s+([A-Za-z0-9_]+)\s*;/g)];
-        for (const match of implicitCases) {
-            cases.push({ key: match[1], value: match[1] });
+        else {
+            value = key;
         }
+        cases.push({ key, value });
     }
-    // Parse getLabel() method if it exists
-    const labelMethodMatch = content.match(/function\s+getLabel\s*\(\s*\)\s*:\s*string\s*\{[\s\S]*?return\s+match\s*\(\s*\$this\s*\)\s*\{([\s\S]*?)\};/);
-    if (labelMethodMatch) {
-        const matchBody = labelMethodMatch[1];
-        const labelMatches = [...matchBody.matchAll(/self::([A-Za-z0-9_]+)\s*=>\s*'([^']*)'/g)];
-        for (const labelMatch of labelMatches) {
-            const caseKey = labelMatch[1];
-            const labelValue = labelMatch[2];
-            const enumCase = cases.find((c) => c.key === caseKey);
-            if (enumCase) {
-                enumCase.label = labelValue;
+    // Parse label() method if it exists
+    const methods = findAllNodesByKind(enumNode, 'method');
+    const labelMethod = methods.find((m) => {
+        const methodName = typeof m.name === 'string' ? m.name : m.name.name;
+        return methodName === 'label';
+    });
+    if (labelMethod && labelMethod.body) {
+        // Find match expression in the method
+        const matchNode = findNodeByKind(labelMethod.body, 'match');
+        if (matchNode && matchNode.arms) {
+            for (const arm of matchNode.arms) {
+                if (arm.conds) {
+                    for (const cond of arm.conds) {
+                        // Handle self::CASE_NAME
+                        if (cond.kind === 'staticlookup') {
+                            const lookup = cond;
+                            const offset = lookup.offset;
+                            const caseName = typeof offset === 'string'
+                                ? offset
+                                : offset.kind === 'identifier'
+                                    ? offset.name
+                                    : null;
+                            if (caseName) {
+                                const labelValue = getStringValue(arm.body);
+                                if (labelValue !== null) {
+                                    const enumCase = cases.find((c) => c.key === caseName);
+                                    if (enumCase) {
+                                        enumCase.label = labelValue;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
     }
     return { name, backing, cases };
 }
 /**
- * Parse PHP array pairs from a string like "'key' => 'value'".
+ * Extract key-value pairs from a PHP array node.
  */
-export function parsePhpArrayPairs(inside) {
+function extractArrayPairs(arrayNode) {
     const pairs = {};
-    const re = /["'](?<key>[A-Za-z0-9_]+)["']\s*=>\s*(?<val>[^,\n]+)/g;
-    for (const m of inside.matchAll(re)) {
-        let val = m.groups.val.trim();
-        val = val.replace(/[,\s]*$/g, '');
-        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-            val = val.slice(1, -1);
-        }
-        if (val.endsWith('::class')) {
-            val = val.slice(0, -7);
+    for (const item of arrayNode.items) {
+        if (item.kind === 'entry') {
+            const entry = item;
+            const key = entry.key ? getStringValue(entry.key) : null;
+            if (!key)
+                continue;
+            const value = entry.value;
+            let strValue = null;
+            if (value.kind === 'string' || value.kind === 'number') {
+                strValue = getStringValue(value);
+            }
+            else if (value.kind === 'staticlookup') {
+                // Handle Foo::class
+                const lookup = value;
+                const offset = lookup.offset;
+                if (offset &&
+                    offset.kind === 'identifier' &&
+                    offset.name === 'class') {
+                    const what = lookup.what;
+                    if (what.kind === 'name') {
+                        strValue = what.name.replace(/^\\+/, '');
+                    }
+                }
+            }
+            if (strValue !== null) {
+                pairs[key] = strValue;
+            }
         }
-        pairs[m.groups.key] = val;
     }
     return pairs;
 }
 /**
- * Extract model casts from a PHP model file.
+ * Parse model casts from PHP model content.
+ * This is a pure function that takes PHP source code as input.
  */
-export function getModelCasts(modelPath) {
-    const content = readFileSafe(modelPath);
-    if (!content)
+export function parseModelCasts(phpContent) {
+    const ast = parsePhp(phpContent);
+    if (!ast)
         return {};
-    // Try protected $casts property
-    const castsMatch = content.match(/protected\s+\$casts\s*=\s*\[([^\]]*)\]/s);
-    if (castsMatch) {
-        return parsePhpArrayPairs(castsMatch[1]);
-    }
-    // Try casts() method
-    const castsMethodMatch = content.match(/function\s+casts\s*\([^)]*\)\s*\{[^}]*return\s*\[([^\]]*)\]/s);
-    if (castsMethodMatch) {
-        return parsePhpArrayPairs(castsMethodMatch[1]);
+    // Find the class
+    const classNode = findNodeByKind(ast, 'class');
+    if (!classNode)
+        return {};
+    // Look for protected $casts property
+    const propertyStatements = findAllNodesByKind(classNode, 'propertystatement');
+    for (const propStmt of propertyStatements) {
+        for (const prop of propStmt.properties) {
+            // prop.name can be a string or Identifier
+            const propName = typeof prop.name === 'string'
+                ? prop.name
+                : prop.name.name;
+            if (propName === 'casts' && prop.value && prop.value.kind === 'array') {
+                return extractArrayPairs(prop.value);
+            }
+        }
     }
-    // Try class-based casts
-    const matches = [...content.matchAll(/["'](?<key>[A-Za-z0-9_]+)["']\s*=>\s*(?<class>[A-Za-z0-9_\\]+)::class/g)];
-    const res = {};
-    for (const m of matches) {
-        const k = m.groups.key;
-        let v = m.groups.class;
-        v = v.replace(/^\\+/, '');
-        res[k] = v;
+    // Look for casts() method
+    const methods = findAllNodesByKind(classNode, 'method');
+    const castsMethod = methods.find((m) => {
+        const methodName = typeof m.name === 'string' ? m.name : m.name.name;
+        return methodName === 'casts';
+    });
+    if (castsMethod && castsMethod.body) {
+        // Find return statement with array
+        const returnNode = findNodeByKind(castsMethod.body, 'return');
+        if (returnNode && returnNode.expr && returnNode.expr.kind === 'array') {
+            return extractArrayPairs(returnNode.expr);
+        }
     }
-    return res;
+    return {};
 }
 /**
- * Extract docblock array shape from PHP file content.
+ * Extract docblock array shape from PHP content.
+ * This is a pure function that takes PHP source code as input.
  */
 export function extractDocblockArrayShape(phpContent) {
     const match = phpContent.match(/@return\s+array\s*\{/s);
@@ -119,7 +294,9 @@ export function extractDocblockArrayShape(phpContent) {
     }
     if (endPos === null)
         return null;
-    const inside = phpContent.slice(openBracePos + 1, endPos);
+    // Extract content and strip docblock asterisks from multiline format
+    let inside = phpContent.slice(openBracePos + 1, endPos);
+    inside = inside.replace(/^\s*\*\s?/gm, '');
     const pairs = {};
     let i = 0;
     while (i < inside.length) {
@@ -166,15 +343,289 @@ export function extractDocblockArrayShape(phpContent) {
     return pairs;
 }
 /**
- * Extract the return array block from a toArray() method in a PHP resource.
+ * Check if an AST node contains a whenLoaded call.
  */
-export function extractReturnArrayBlock(phpContent) {
-    const match = phpContent.match(/function\s+toArray\s*\([^)]*\)\s*:\s*array\s*\{([\s\S]*?)\n\s*\}/);
-    if (!match)
+function containsWhenLoaded(node) {
+    if (node.kind === 'call') {
+        const call = node;
+        if (call.what.kind === 'propertylookup') {
+            const lookup = call.what;
+            const offset = lookup.offset;
+            const name = offset.kind === 'identifier' ? offset.name : null;
+            if (name === 'whenLoaded')
+                return true;
+        }
+    }
+    // Check arguments recursively
+    const obj = node;
+    for (const key of Object.keys(obj)) {
+        const val = obj[key];
+        if (val && typeof val === 'object') {
+            if (val.kind && containsWhenLoaded(val))
+                return true;
+            if (Array.isArray(val)) {
+                for (const item of val) {
+                    if (item && item.kind && containsWhenLoaded(item))
+                        return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Extract resource name from a static call like Resource::make() or Resource::collection().
+ */
+function extractStaticCallResource(call) {
+    if (call.what.kind !== 'staticlookup')
+        return null;
+    const lookup = call.what;
+    if (lookup.what.kind !== 'name')
         return null;
-    const body = match[1];
-    const returnMatch = body.match(/return\s*\[\s*([\s\S]*?)\s*\];/);
-    if (!returnMatch)
+    const resource = lookup.what.name;
+    const offset = lookup.offset;
+    const method = offset.kind === 'identifier' ? offset.name : null;
+    if (!method)
         return null;
-    return returnMatch[1];
+    return { resource, method };
+}
+/**
+ * Extract resource name from a new expression like new Resource().
+ */
+function extractNewResource(newExpr) {
+    if (newExpr.what.kind !== 'name')
+        return null;
+    return newExpr.what.name;
+}
+/**
+ * Extract property name from $this->resource->property.
+ */
+function extractResourceProperty(node) {
+    if (node.kind !== 'propertylookup')
+        return null;
+    const lookup = node;
+    const what = lookup.what;
+    // Check for $this->resource
+    if (what.kind === 'propertylookup') {
+        const inner = what;
+        if (inner.what.kind === 'variable' && inner.what.name === 'this') {
+            const innerOffset = inner.offset;
+            const innerName = innerOffset.kind === 'identifier' ? innerOffset.name : null;
+            if (innerName === 'resource') {
+                const offset = lookup.offset;
+                return offset.kind === 'identifier' ? offset.name : null;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Map a PHP cast to a TypeScript type, potentially collecting enum references.
+ */
+function mapCastToType(cast, enumsDir, collectedEnums) {
+    const original = cast;
+    // Try to find enum in app/Enums
+    const match = original.match(/([A-Za-z0-9_\\]+)$/);
+    const short = match ? match[1].replace(/^\\+/, '') : original;
+    const enumPath = join(enumsDir, `${short}.php`);
+    if (existsSync(enumPath)) {
+        const content = readFileSafe(enumPath);
+        if (content) {
+            const def = parseEnumContent(content);
+            if (def) {
+                collectedEnums[def.name] = def;
+                return def.name;
+            }
+        }
+    }
+    return mapPhpTypeToTs(cast);
+}
+/**
+ * Check if a resource file exists.
+ */
+function resourceExists(resourceName, resourcesDir) {
+    if (!resourcesDir)
+        return true; // Trust the name if no dir provided
+    return existsSync(join(resourcesDir, `${resourceName}.php`));
+}
+/**
+ * Infer TypeScript type from an AST value node.
+ */
+function inferTypeFromAstNode(node, key, options = {}) {
+    const { resourcesDir, modelsDir, enumsDir, docShape, collectedEnums = {}, resourceClass = '' } = options;
+    const optional = containsWhenLoaded(node);
+    // Use docblock type if available
+    if (docShape && docShape[key]) {
+        return { type: docShape[key], optional };
+    }
+    // Boolean heuristics from key name
+    const lowerKey = key.toLowerCase();
+    if (lowerKey.startsWith('is_') || lowerKey.startsWith('has_') || /^(is|has)[A-Z]/.test(key)) {
+        return { type: 'boolean', optional };
+    }
+    // Handle static calls: Resource::collection() or Resource::make()
+    if (node.kind === 'call') {
+        const call = node;
+        const staticInfo = extractStaticCallResource(call);
+        if (staticInfo) {
+            const { resource, method } = staticInfo;
+            // Collection or Collection::make returns any[]
+            if (resource === 'Collection') {
+                return { type: 'any[]', optional };
+            }
+            // Resource::collection or Resource::make returns Resource[]
+            if (method === 'collection' || method === 'make') {
+                if (resourceExists(resource, resourcesDir)) {
+                    return { type: `${resource}[]`, optional };
+                }
+                return { type: 'any[]', optional };
+            }
+        }
+        // Check if it's a whenLoaded call without a wrapper resource
+        if (call.what.kind === 'propertylookup') {
+            const lookup = call.what;
+            const offset = lookup.offset;
+            const name = offset.kind === 'identifier' ? offset.name : null;
+            if (name === 'whenLoaded') {
+                // Try to find matching resource (only if resourcesDir is provided)
+                if (resourcesDir) {
+                    const args = call.arguments;
+                    if (args.length > 0 && args[0].kind === 'string') {
+                        const relationName = args[0].value;
+                        const candidate = `${relationName[0].toUpperCase()}${relationName.slice(1)}Resource`;
+                        if (existsSync(join(resourcesDir, `${candidate}.php`))) {
+                            return { type: candidate, optional: true };
+                        }
+                    }
+                }
+                return { type: 'Record<string, any>', optional: true };
+            }
+        }
+    }
+    // Handle new Resource()
+    if (node.kind === 'new') {
+        const newExpr = node;
+        const resource = extractNewResource(newExpr);
+        if (resource) {
+            if (resourceExists(resource, resourcesDir)) {
+                return { type: resource, optional };
+            }
+            return { type: 'any', optional };
+        }
+        return { type: 'any', optional };
+    }
+    // Handle $this->resource->property
+    const prop = extractResourceProperty(node);
+    if (prop) {
+        const lower = prop.toLowerCase();
+        // Boolean checks
+        if (lower.startsWith('is_') || lower.startsWith('has_') || /^(is|has)[A-Z]/.test(prop)) {
+            return { type: 'boolean', optional: false };
+        }
+        // IDs and UUIDs
+        if (prop === 'id' || prop.endsWith('_id') || lower === 'uuid' || prop.endsWith('Id')) {
+            return { type: 'string', optional: false };
+        }
+        // Check model casts
+        if (modelsDir && resourceClass) {
+            const modelCandidate = resourceClass.replace(/Resource$/, '');
+            const modelPath = join(modelsDir, `${modelCandidate}.php`);
+            if (existsSync(modelPath)) {
+                const modelContent = readFileSafe(modelPath);
+                if (modelContent) {
+                    const casts = parseModelCasts(modelContent);
+                    if (casts[prop]) {
+                        const cast = casts[prop];
+                        const trim = cast.trim();
+                        const tsType = trim.startsWith('{') || trim.includes(':') || /array\s*\{/.test(trim)
+                            ? trim
+                            : mapCastToType(cast, enumsDir || '', collectedEnums);
+                        return { type: tsType, optional: false };
+                    }
+                }
+            }
+        }
+        // Timestamps
+        if (prop.endsWith('_at') || prop.endsWith('At')) {
+            return { type: 'string', optional: false };
+        }
+        return { type: 'string', optional: false };
+    }
+    // Handle nested arrays
+    if (node.kind === 'array') {
+        const arrayNode = node;
+        const nestedFields = parseArrayEntries(arrayNode.items, options);
+        if (Object.keys(nestedFields).length > 0) {
+            const props = Object.entries(nestedFields).map(([k, v]) => {
+                const opt = v.fieldInfo.optional ? '?' : '';
+                return `${k}${opt}: ${v.fieldInfo.type}`;
+            });
+            return { type: `{ ${props.join('; ')} }`, optional };
+        }
+        return { type: 'any[]', optional };
+    }
+    return { type: 'any', optional };
+}
+/**
+ * Parse array entries from AST array items.
+ */
+function parseArrayEntries(items, options = {}) {
+    const result = {};
+    for (const item of items) {
+        if (item.kind !== 'entry')
+            continue;
+        const entry = item;
+        if (!entry.key)
+            continue;
+        const key = getStringValue(entry.key);
+        if (!key)
+            continue;
+        const fieldInfo = inferTypeFromAstNode(entry.value, key, options);
+        result[key] = { key, fieldInfo };
+        // Handle nested arrays
+        if (entry.value.kind === 'array') {
+            const nested = parseArrayEntries(entry.value.items, options);
+            if (Object.keys(nested).length > 0) {
+                result[key].nested = nested;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Parse resource fields from PHP content using AST.
+ * Returns null if parsing fails or no toArray method is found.
+ */
+export function parseResourceFieldsAst(phpContent, options = {}) {
+    const ast = parsePhp(phpContent);
+    if (!ast)
+        return null;
+    // Find the class
+    const classNode = findNodeByKind(ast, 'class');
+    if (!classNode)
+        return null;
+    // Extract class name for model cast lookups
+    const className = typeof classNode.name === 'string'
+        ? classNode.name
+        : classNode.name.name;
+    // Find toArray method
+    const methods = findAllNodesByKind(classNode, 'method');
+    const toArrayMethod = methods.find((m) => {
+        const methodName = typeof m.name === 'string' ? m.name : m.name.name;
+        return methodName === 'toArray';
+    });
+    if (!toArrayMethod || !toArrayMethod.body)
+        return null;
+    // Find return statement with array
+    const returnNode = findNodeByKind(toArrayMethod.body, 'return');
+    if (!returnNode || !returnNode.expr || returnNode.expr.kind !== 'array')
+        return null;
+    const arrayNode = returnNode.expr;
+    const entries = parseArrayEntries(arrayNode.items, { ...options, resourceClass: className });
+    // Convert to flat field info
+    const result = {};
+    for (const [key, entry] of Object.entries(entries)) {
+        result[key] = entry.fieldInfo;
+    }
+    return result;
 }