suparisma 1.0.5 → 1.0.7

package/dist/generators/coreGenerator.js

@@ -532,7 +532,7 @@ export function createSuparismaHook<
     // Single data collection for holding results
     const [data, setData] = useState<TWithRelations[]>([]);
     const [error, setError] = useState<Error | null>(null);
-    const [loading, setLoading] = useState<boolean>(false);
+    const [loading, setLoading] = useState<boolean>(true);
     
     // This is the total count, unaffected by pagination limits
     const [count, setCount] = useState<number>(0);

package/dist/generators/typeGenerator.js

@@ -41,12 +41,25 @@ function generateModelTypesFile(model) {
     // Find the actual field names for createdAt and updatedAt
     const createdAtField = model.fields.find(field => field.isCreatedAt)?.name || 'createdAt';
     const updatedAtField = model.fields.find(field => field.isUpdatedAt)?.name || 'updatedAt';
-    // Create a manual property list for WithRelations interface
-    const withRelationsProps = model.fields
-        .filter((field) => !relationObjectFields.includes(field.name) && !foreignKeyFields.includes(field.name))
-        .map((field) => {
-        const isOptional = field.isOptional;
+    // Helper function to get TypeScript type for a field, considering zod directives
+    const getFieldType = (field) => {
         let baseType;
+        // Check if field has a custom zod directive
+        if (field.zodDirective && field.type === 'Json') {
+            // For Json fields with zod directives, we need to infer the type from the zod schema
+            // This is a simplified approach - you might want to make this more sophisticated
+            if (field.zodDirective.includes('z.array(') && field.zodDirective.includes('LLMNodeSchema')) {
+                // Handle z.array(LLMNodeSchema).nullable() case
+                return field.zodDirective.includes('.nullable()') ? 'LLMNode[] | null' : 'LLMNode[]';
+            }
+            else if (field.zodDirective.includes('LLMNodeSchema')) {
+                // Handle single LLMNodeSchema case
+                return field.zodDirective.includes('.nullable()') ? 'LLMNode | null' : 'LLMNode';
+            }
+            // For other custom zod directives on Json fields, default to any for now
+            return 'any';
+        }
+        // Standard type mapping
         switch (field.type) {
             case 'Int':
             case 'Float':
@@ -65,7 +78,14 @@ function generateModelTypesFile(model) {
                 // Covers String, Enum names (e.g., "SomeEnum"), Bytes, Decimal, etc.
                 baseType = 'string';
         }
-        const finalType = field.isList ? `${baseType}[]` : baseType;
+        return field.isList ? `${baseType}[]` : baseType;
+    };
+    // Create a manual property list for WithRelations interface
+    const withRelationsProps = model.fields
+        .filter((field) => !relationObjectFields.includes(field.name) && !foreignKeyFields.includes(field.name))
+        .map((field) => {
+        const isOptional = field.isOptional;
+        const finalType = getFieldType(field);
         return `  ${field.name}${isOptional ? '?' : ''}: ${finalType};`;
     });
     // Add foreign key fields
@@ -83,26 +103,7 @@ function generateModelTypesFile(model) {
         .map((field) => {
         // Make fields with default values optional in CreateInput
         const isOptional = field.isOptional || defaultValueFields.includes(field.name);
-        let baseType;
-        switch (field.type) {
-            case 'Int':
-            case 'Float':
-                baseType = 'number';
-                break;
-            case 'Boolean':
-                baseType = 'boolean';
-                break;
-            case 'DateTime':
-                baseType = 'string'; // ISO date string
-                break;
-            case 'Json':
-                baseType = 'any'; // Or a more specific structured type if available
-                break;
-            default:
-                // Covers String, Enum names (e.g., "SomeEnum"), Bytes, Decimal, etc.
-                baseType = 'string';
-        }
-        const finalType = field.isList ? `${baseType}[]` : baseType;
+        const finalType = getFieldType(field);
         return `  ${field.name}${isOptional ? '?' : ''}: ${finalType};`;
     });
     // Add foreign key fields to CreateInput
@@ -114,11 +115,50 @@ function generateModelTypesFile(model) {
             createInputProps.push(`  ${field}${isOptional ? '?' : ''}: ${fieldInfo.type === 'Int' ? 'number' : 'string'};`);
         }
     });
+    // Generate imports section for zod custom types
+    let customImports = '';
+    if (model.zodImports && model.zodImports.length > 0) {
+        // Add zod import for type inference
+        customImports = 'import { z } from \'zod\';\n';
+        // Get the zod schemas file path from environment variable
+        const zodSchemasPath = process.env.ZOD_SCHEMAS_FILE_PATH || '../commonTypes';
+        // Add custom imports with environment variable path
+        customImports += model.zodImports
+            .map(zodImport => {
+            // Extract the types from the original import statement
+            const typeMatch = zodImport.importStatement.match(/import\s+{\s*([^}]+)\s*}\s+from/);
+            if (typeMatch) {
+                const types = typeMatch[1].trim();
+                return `import { ${types} } from '${zodSchemasPath}'`;
+            }
+            // Fallback to original import if parsing fails
+            return zodImport.importStatement;
+        })
+            .join('\n') + '\n\n';
+        // Add type definitions for imported zod schemas if needed
+        // This is a simplified approach - you might want to make this more sophisticated
+        const customTypeDefinitions = model.zodImports
+            .flatMap(zodImport => zodImport.types)
+            .filter((type, index, array) => array.indexOf(type) === index) // Remove duplicates
+            .map(type => {
+            // If it ends with 'Schema', create a corresponding type
+            if (type.endsWith('Schema')) {
+                const typeName = type.replace('Schema', '');
+                return `export type ${typeName} = z.infer<typeof ${type}>;`;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+        if (customTypeDefinitions) {
+            customImports += customTypeDefinitions + '\n\n';
+        }
+    }
     // Generate the type content with TSDoc comments
     const typeContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
 // Edit the generator script instead
 
-import type { ${modelName} } from '@prisma/client';
+${customImports}import type { ${modelName} } from '@prisma/client';
 import type { ModelResult, SuparismaOptions, SearchQuery, SearchState, FilterOperators } from '../utils/core';
 
 /**
@@ -230,26 +270,7 @@ ${model.fields
         .filter((field) => !relationObjectFields.includes(field.name) && !foreignKeyFields.includes(field.name))
         .map((field) => {
         const isOptional = true; // All where fields are optional
-        let baseType;
-        switch (field.type) {
-            case 'Int':
-            case 'Float':
-                baseType = 'number';
-                break;
-            case 'Boolean':
-                baseType = 'boolean';
-                break;
-            case 'DateTime':
-                baseType = 'string'; // ISO date string
-                break;
-            case 'Json':
-                baseType = 'any'; // Or a more specific structured type if available
-                break;
-            default:
-                // Covers String, Enum names (e.g., "SomeEnum"), Bytes, Decimal, etc.
-                baseType = 'string';
-        }
-        const finalType = field.isList ? `${baseType}[]` : baseType;
+        const finalType = getFieldType(field);
         const filterType = `${finalType} | FilterOperators<${finalType}>`;
         return `  ${field.name}${isOptional ? '?' : ''}: ${filterType};`;
     })
@@ -643,6 +664,7 @@ ${createInputProps
         searchFields,
         defaultValues: Object.keys(defaultValues).length > 0 ? defaultValues : undefined,
         createdAtField,
-        updatedAtField
+        updatedAtField,
+        zodImports: model.zodImports // Pass through zod imports
     };
 }

package/dist/parser.js

@@ -6,7 +6,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePrismaSchema = parsePrismaSchema;
 const fs_1 = __importDefault(require("fs"));
 /**
- * Parse Prisma schema to extract model information including search annotations
+ * Parse zod directive from comment
+ * Supports formats like:
+ * /// @zod.custom.use(z.string().refine(...))
+ * /// @zod.string.min(3).max(10)
+ */
+function parseZodDirective(comment) {
+    // Remove leading /// and whitespace
+    const cleanComment = comment.replace(/^\/\/\/?\s*/, '').trim();
+    // Look for @zod.custom.use() format
+    const customUseMatch = cleanComment.match(/@zod\.custom\.use\((.+)\)$/);
+    if (customUseMatch) {
+        return customUseMatch[1].trim();
+    }
+    // Look for other @zod patterns like @zod.string.min(3)
+    const zodMatch = cleanComment.match(/@zod\.(.+)$/);
+    if (zodMatch) {
+        const zodChain = zodMatch[1].trim();
+        // Convert to actual zod syntax - this is a basic implementation
+        // For more complex cases, you might want to build a more sophisticated parser
+        return `z.${zodChain}`;
+    }
+    return undefined;
+}
+/**
+ * Parse zod import from comment
+ * Supports format like:
+ * /// @zod.import(["import { LLMNodeSchema } from '../commonTypes'"])
+ */
+function parseZodImport(comment) {
+    const cleanComment = comment.replace(/^\/\/\/?\s*/, '').trim();
+    // Look for @zod.import([...]) format
+    const importMatch = cleanComment.match(/@zod\.import\(\[(.*)\]\)/);
+    if (!importMatch) {
+        return [];
+    }
+    const importsString = importMatch[1];
+    const imports = [];
+    // Parse individual import statements within the array
+    // Handle nested quotes properly - look for quoted strings that start with "import"
+    const importRegex = /"(import\s+[^"]+)"|'(import\s+[^']+)'/g;
+    let match;
+    while ((match = importRegex.exec(importsString)) !== null) {
+        // Get the import statement from either the double-quoted or single-quoted group
+        const importStatement = match[1] || match[2];
+        // Extract types from import statement
+        // e.g., "import { LLMNodeSchema, AnotherType } from '../commonTypes'"
+        const typeMatch = importStatement.match(/import\s+{\s*([^}]+)\s*}\s+from/);
+        const types = [];
+        if (typeMatch) {
+            // Split by comma and clean up whitespace
+            types.push(...typeMatch[1].split(',').map(t => t.trim()));
+        }
+        imports.push({
+            importStatement,
+            types
+        });
+    }
+    return imports;
+}
+/**
+ * Parse Prisma schema to extract model information including search annotations and zod directives
  */
 function parsePrismaSchema(schemaPath) {
     const schema = fs_1.default.readFileSync(schemaPath, 'utf-8');
@@ -33,9 +93,12 @@ function parsePrismaSchema(schemaPath) {
         const fields = [];
         // Track fields with @enableSearch annotation
         const searchFields = [];
+        // Track zod imports at model level
+        const zodImports = [];
         const lines = modelBody.split('\n');
         let lastFieldName = '';
         let lastFieldType = '';
+        let pendingZodDirective;
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i]?.trim();
             // Skip blank lines and non-field lines
@@ -52,6 +115,14 @@ function parsePrismaSchema(schemaPath) {
             }
             // Check if line is a comment
             if (line.startsWith('//')) {
+                // Parse zod directives from comments
+                const zodDirective = parseZodDirective(line);
+                if (zodDirective) {
+                    pendingZodDirective = zodDirective;
+                }
+                // Parse zod imports from comments
+                const zodImportInfos = parseZodImport(line);
+                zodImports.push(...zodImportInfos);
                 continue;
             }
             // Parse field definition - Updated to handle array types
@@ -91,6 +162,14 @@ function parsePrismaSchema(schemaPath) {
                         type: baseFieldType || '',
                     });
                 }
+                // Check for inline zod directive
+                let fieldZodDirective = pendingZodDirective;
+                if (line.includes('/// @zod.')) {
+                    const inlineZodDirective = parseZodDirective(line);
+                    if (inlineZodDirective) {
+                        fieldZodDirective = inlineZodDirective;
+                    }
+                }
                 if (fieldName && baseFieldType) {
                     fields.push({
                         name: fieldName,
@@ -105,8 +184,11 @@ function parsePrismaSchema(schemaPath) {
                         defaultValue, // Add the extracted default value
                         isRelation,
                         isList: isArray, // Add the isList property
+                        zodDirective: fieldZodDirective, // Add zod directive
                     });
                 }
+                // Clear pending zod directive after using it
+                pendingZodDirective = undefined;
             }
         }
         // Check for model-level @enableSearch before the model definition
@@ -122,11 +204,30 @@ function parsePrismaSchema(schemaPath) {
                 }
             });
         }
+        // Also check for model-level zod imports before the model definition
+        const modelStartIndex = schema.indexOf(`model ${modelName}`);
+        if (modelStartIndex !== -1) {
+            // Look backwards for any /// @zod.import directives before this model
+            const beforeModel = schema.substring(0, modelStartIndex);
+            const lines = beforeModel.split('\n').reverse(); // Start from model and go backwards
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                if (trimmedLine.startsWith('///') && trimmedLine.includes('@zod.import')) {
+                    const modelLevelImports = parseZodImport(trimmedLine);
+                    zodImports.push(...modelLevelImports);
+                }
+                else if (trimmedLine && !trimmedLine.startsWith('///') && !trimmedLine.startsWith('//')) {
+                    // Stop if we hit a non-comment line (another model or other content)
+                    break;
+                }
+            }
+        }
         models.push({
             name: modelName,
             mappedName: mappedName || '',
             fields,
             searchFields: searchFields.length > 0 ? searchFields : undefined,
+            zodImports: zodImports.length > 0 ? zodImports : undefined,
         });
     }
     return models;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suparisma",
-	"version": "1.0.5",
+	"version": "1.0.7",
 	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
 	"main": "dist/index.js",
 	"repository": {

package/prisma/schema.prisma

@@ -28,6 +28,7 @@ model User {
   updatedAt DateTime @updatedAt
 }
 
+/// @zod.import(["import { LLMNodeSchema } from '../commonTypes'"])
 model Thing {
   id        String   @id @default(uuid())
   // @enableSearch
@@ -35,6 +36,9 @@ model Thing {
   stringArray String[]
   someEnum  SomeEnum @default(ONE)
   someNumber Int?
+
+  /// [Json]
+  someJson Json? /// @zod.custom.use(z.array(LLMNodeSchema).nullable())
   userId    String?
   user      User?    @relation(fields: [userId], references: [id])
   createdAt DateTime @default(now())