@igniter-js/cli 0.1.0 → 0.1.3

package/dist/utils/prisma-schema-parser.js

@@ -49,7 +49,17 @@ class PrismaSchemaParser {
             return [];
         }
         const fieldsContent = modelMatch[1].trim();
-        return this.parseFields(fieldsContent);
+        const fields = this.parseFields(fieldsContent);
+        // Transform parsed fields to include relationship info
+        return fields.map(field => {
+            var _a, _b;
+            return ({
+                ...field,
+                isRelation: !!field.relations || this.schemaContent.includes(`model ${field.type} {`),
+                isList: field.isList || (((_a = field.relations) === null || _a === void 0 ? void 0 : _a.type) === 'one-to-many' || ((_b = field.relations) === null || _b === void 0 ? void 0 : _b.type) === 'many-to-many'),
+                isOptional: field.hasDefault || field.isOptional
+            });
+        });
     }
     /**
      * Parses field strings into structured field objects
@@ -64,6 +74,7 @@ class PrismaSchemaParser {
                 continue;
             const field = this.parseFieldLine(trimmedLine);
             if (field) {
+                console.log(field);
                 fields.push(field);
             }
         }
@@ -75,7 +86,7 @@ class PrismaSchemaParser {
     parseFieldLine(line) {
         this.loadSchema();
         // Basic field pattern: name type modifiers
-        const fieldPattern = /^(\w+)\s+(\w+)(\?|\[\])?\s*(@\w+(?:\([^)]*\))?)*$/;
+        const fieldPattern = /^(\w+)\s+(\w+)(?:\?|\[\])?\s*(@[^\n]+)?$/;
         const match = line.match(fieldPattern);
         if (!match)
             return null;
@@ -83,31 +94,42 @@ class PrismaSchemaParser {
         const modifiers = line.slice(match[0].length).trim();
         const isOptional = line.includes('?');
         const isList = line.includes('[]');
-        const hasDefault = modifiers.includes('@default');
-        // Skip internal Prisma fields
-        if (['id', 'createdAt', 'updatedAt'].includes(name)) {
-            return null;
-        }
-        // Verifica se é um enum
-        const isEnum = this.schemaContent.includes(`enum ${type} {`);
+        const hasDefault = line.includes('@default');
+        // Check if type is a model (potential relation)
+        const isModelType = this.schemaContent.includes(`model ${type} {`);
         // Parse relations
         let relations = undefined;
-        if (line.includes('@relation')) {
+        let isRelation = false;
+        if (line.includes('@relation') || isModelType) {
             const relationMatch = line.match(/@relation\([^)]*\)/);
             if (relationMatch) {
                 relations = this.parseRelation(relationMatch[0], isList);
+                isRelation = true;
+            }
+            else if (isModelType) {
+                // If it's a model type but doesn't have @relation, create a default relation
+                relations = {
+                    type: isList ? 'one-to-many' : 'one-to-one',
+                    model: type,
+                    fields: [name + 'Id'],
+                    references: ['id']
+                };
+                isRelation = true;
             }
         }
+        // Verifica se é um enum
+        const isEnum = this.schemaContent.includes(`enum ${type} {`);
         return {
             name,
             type,
-            zodType: this.getZodType(type, isOptional, isList),
+            zodType: this.getZodType(type, isOptional || hasDefault, isList),
             description: `${name} field`,
-            isOptional,
+            isOptional: isOptional || hasDefault,
             isList,
             hasDefault,
             isEnum,
-            relations
+            relations,
+            isRelation
         };
     }
     /**
@@ -115,22 +137,63 @@ class PrismaSchemaParser {
      */
     parseRelation(relationString, isList) {
         var _a;
-        const relationDetails = (_a = relationString.match(/@relation\(([^)]+)\)/)) === null || _a === void 0 ? void 0 : _a[1].split(',');
-        if (!relationDetails)
-            return undefined;
-        const nameMatch = relationDetails.find(detail => detail.trim().startsWith('name:'));
-        const fieldsMatch = relationDetails.find(detail => detail.trim().startsWith('fields:'));
-        const referencesMatch = relationDetails.find(detail => detail.trim().startsWith('references:'));
-        if (nameMatch && fieldsMatch && referencesMatch) {
-            const model = nameMatch.split(':')[1].trim().replace(/['"]/g, '');
-            const fields = fieldsMatch.split(':')[1].trim().replace(/\[|\]/g, '').split(',').map(f => f.trim());
-            const references = referencesMatch.split(':')[1].trim().replace(/\[|\]/g, '').split(',').map(f => f.trim());
-            return {
-                type: fields.length > 1 || references.length > 1 ? 'many-to-many' : (isList ? 'one-to-many' : 'one-to-one'),
-                model,
-                fields,
-                references
-            };
+        try {
+            // Extract details from @relation(...) string
+            const relationDetails = (_a = relationString.match(/@relation\(([^)]+)\)/)) === null || _a === void 0 ? void 0 : _a[1].trim();
+            if (!relationDetails)
+                return undefined;
+            // Extract fields and references from the relation
+            const fieldsMatch = relationDetails.match(/fields:\s*\[\s*([^\]]+)\s*\]/);
+            const referencesMatch = relationDetails.match(/references:\s*\[\s*([^\]]+)\s*\]/);
+            if (fieldsMatch && referencesMatch) {
+                // Get fields and references
+                const fields = fieldsMatch[1].split(',').map(f => f.trim().replace(/['"]/g, ''));
+                const references = referencesMatch[1].split(',').map(r => r.trim().replace(/['"]/g, ''));
+                // Try to find referenced model from the context
+                let model = '';
+                // Check if there's an explicit model name attribute
+                const modelMatch = relationDetails.match(/name:\s*['"]?(\w+)['"]?/);
+                if (modelMatch) {
+                    model = modelMatch[1];
+                }
+                else {
+                    // Infer model from schema by looking at field references
+                    // This is a simplification - in a real implementation you might need to look at
+                    // the other side of the relation in the schema
+                    const referenceField = references[0].replace(/['"]/g, '');
+                    if (referenceField === 'id') {
+                        // Try to find "@relation(fields: [categoryId], references: [id])"
+                        // Where categoryId indicates a Category model
+                        const possibleModelField = fields[0];
+                        if (possibleModelField && possibleModelField.toLowerCase().endsWith('id')) {
+                            // Extract model name by removing the 'Id' suffix
+                            model = possibleModelField.substring(0, possibleModelField.length - 2);
+                            // Convert first letter to uppercase for proper model name format
+                            model = model.charAt(0).toUpperCase() + model.slice(1);
+                        }
+                    }
+                }
+                // Determine relation type based on list status and fields/references count
+                let relationType;
+                if (fields.length > 1 || references.length > 1) {
+                    relationType = 'many-to-many';
+                }
+                else if (isList) {
+                    relationType = 'one-to-many';
+                }
+                else {
+                    relationType = 'one-to-one';
+                }
+                return {
+                    type: relationType,
+                    model,
+                    fields,
+                    references
+                };
+            }
+        }
+        catch (error) {
+            console.log(`Error parsing relation: ${error}`);
         }
         return undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igniter-js/cli",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Igniter CLI for projects using Igniter Framework",
   "main": "dist/index.js",
   "homepage": "https://felipebarcelospro.github.io/igniter",