suparisma 0.0.1 → 0.0.3

package/README.md

@@ -1,4 +1,157 @@
-This package combines supabase and prisma to easily generate realtime CRUD hooks for all your tables to be used seamlessly in react.
+# Suparisma
 
-To install first do:
-pnpm install suparisma
+A React hook generator for Supabase that is driven by your Prisma schema, giving you type-safe, real-time enabled hooks to interact with your Supabase database.
+
+## Why?
+CRUD typesafetey with Supabase should be easy, currently it is not with a lot of issues that can rise easily espeically if you're not using Prisma.
+
+Prisma solved supabase typesafely issue on the server, and TRPC helped making the client even more type safe but realtime capabilites from the DB to the browser was still lacking and that lead to a lot of unnecessary GET, POST requests if you just simply need to have realtime support.
+
+Supabase's rules are also powerful and if you're using TRPC or any server solution you're easily missing out on them.
+
+This package solves all this focusing, it lets you:
+- Create typesafe CRUD hooks for all your supabase tables.
+- Enables you to easily paginate, search and query in each table.
+- Uses Prisma and Supabase official SDKs.
+- Respects Supabase's auth rules enabling an easy way to secure your DB.
+- Works with any React env. like NextJS/Remix/Tanstack Start/Router/etc..
+
+## Features
+
+- 🚀 **Auto-generated React hooks** based on your Prisma schema
+- 🔄 **Real-time updates by default** for all tables (opt-out available)
+- 🔒 **Type-safe interfaces** for all database operations
+- 🔍 **Full-text search** capabilities with optional annotations
+- 🔄 **Prisma-like API** that feels familiar if you use Prisma
+
+## Installation
+
+```bash
+npm install suparisma
+# or
+yarn add suparisma
+# or
+pnpm install suparisma
+```
+
+## Quick Start
+
+1. **Add a Prisma schema**: Make sure you have a valid `prisma/schema.prisma` file in your project.
+
+2. **Set up required environment variables** in a `.env` file:
+
+```
+# Required for Prisma and Supabase
+DATABASE_URL="postgresql://user:password@host:port/database"
+DIRECT_URL="postgresql://user:password@host:port/database"  # Direct Postgres connection
+NEXT_PUBLIC_SUPABASE_URL="https://your-project.supabase.co"
+NEXT_PUBLIC_SUPABASE_ANON_KEY="your-anon-key"
+```
+
+3. **Generate hooks** with a single command:
+
+```bash
+npx suparisma generate
+```
+
+This will:
+- Read your Prisma schema from the current directory
+- Configure your database for realtime functionality and search
+- Generate type-safe React hooks in `src/suparisma/generated` (configurable)
+
+4. **Use the hooks** in your React components:
+
+```tsx
+import useSuparisma from './src/suparisma/generated';
+
+function UserList() {
+  const users = useSuparisma.user();
+  
+  if (users.loading) return <div>Loading...</div>;
+  if (users.error) return <div>Error: {users.error.message}</div>;
+  
+  return (
+    <div>
+      <h1>Users</h1>
+      <ul>
+        {users.data?.map(user => (
+          <li key={user.id}>{user.name}</li>
+        ))}
+      </ul>
+      
+      <button onClick={() => users.create({ name: "New User" })}>
+        Add User
+      </button>
+    </div>
+  );
+}
+```
+
+## Annotations in Your Prisma Schema
+
+Add annotations directly in your Prisma schema as comments:
+
+```prisma
+// Realtime is enabled by default for this model
+model User {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  name      String?  // @enableSearch
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+// @disableRealtime - Opt out of realtime for this model
+model AuditLog {
+  id        String   @id @default(uuid())
+  action    String
+  details   String?
+  createdAt DateTime @default(now())
+}
+```
+
+## Stale Models Cleanup
+
+When you delete a model from your Prisma schema and run the generation command, Suparisma automatically:
+- Detects changes to your schema
+- Deletes the entire generated directory
+- Regenerates all hooks and types based on your current schema
+
+This ensures you don't have stale files lingering around for models that no longer exist in your schema.
+
+## CLI Commands
+
+Suparisma provides a simple CLI with the following commands:
+
+```bash
+# Generate hooks based on your Prisma schema
+npx suparisma generate
+
+# Show help information
+npx suparisma help
+```
+
+## Configuration
+
+You can customize the behavior using environment variables:
+
+```
+# Optional: Customize output directory
+SUPARISMA_OUTPUT_DIR="src/hooks/generated"
+
+# Optional: Specify custom schema path 
+SUPARISMA_PRISMA_SCHEMA_PATH="path/to/schema.prisma"
+```
+
+## Environment Variables
+
+The following environment variables are required:
+
+- `DATABASE_URL` - Your Postgres database URL (used by Prisma)
+- `DIRECT_URL` - Direct URL to your Postgres database (for setting up realtime)
+- `NEXT_PUBLIC_SUPABASE_URL` - Your Supabase project URL
+- `NEXT_PUBLIC_SUPABASE_ANON_KEY` - Your Supabase anonymous key
+
+## License
+
+MIT

package/dist/config.js

@@ -1,7 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HOOK_NAME_PREFIX = exports.OUTPUT_DIR = exports.PRISMA_SCHEMA_PATH = void 0;
+exports.HOOK_NAME_PREFIX = exports.UTILS_DIR = exports.HOOKS_DIR = exports.TYPES_DIR = exports.OUTPUT_DIR = exports.PRISMA_SCHEMA_PATH = void 0;
 // Configuration
-exports.PRISMA_SCHEMA_PATH = 'prisma/schema.prisma';
-exports.OUTPUT_DIR = 'src/hooks/generated';
+const path_1 = __importDefault(require("path"));
+// Use current working directory for all paths
+const CWD = process.cwd();
+exports.PRISMA_SCHEMA_PATH = process.env.SUPARISMA_PRISMA_SCHEMA_PATH || path_1.default.join(CWD, 'prisma/schema.prisma');
+exports.OUTPUT_DIR = process.env.SUPARISMA_OUTPUT_DIR || path_1.default.join(CWD, 'src/suparisma/generated');
+exports.TYPES_DIR = `${exports.OUTPUT_DIR}/types`;
+exports.HOOKS_DIR = `${exports.OUTPUT_DIR}/hooks`;
+exports.UTILS_DIR = `${exports.OUTPUT_DIR}/utils`;
 exports.HOOK_NAME_PREFIX = 'useSuparisma';

package/dist/generators/coreGenerator.js

@@ -15,7 +15,8 @@ function generateCoreFile() {
 // Edit the generator script instead: scripts/generate-realtime-hooks.ts
 
 import { useEffect, useState, useCallback, useRef } from 'react';
-import { supabase } from '../supabase-client-generated';
+// This import should be relative to its new location in utils/
+import { supabase } from './supabase-client'; 
 
 /**
  * Represents a single search query against a field
@@ -301,13 +302,14 @@ export function applyFilter<T>(
 export function applyOrderBy<T>(
   query: SupabaseQueryBuilder,
   orderBy?: T,
-  hasCreatedAt?: boolean
+  hasCreatedAt?: boolean,
+  createdAtField: string = 'createdAt'
 ): SupabaseQueryBuilder {
   if (!orderBy) {
-    // By default, sort by created_at if available
+    // By default, sort by createdAt if available, using the actual field name from Prisma
     if (hasCreatedAt) {
       // @ts-ignore: Supabase typing issue
-      return query.order('created_at', { ascending: false });
+      return query.order(createdAtField, { ascending: false });
     }
     return query;
   }
@@ -341,9 +343,19 @@ export function createSuparismaHook<
   hasCreatedAt: boolean;
   hasUpdatedAt: boolean;
   searchFields?: string[];
-  defaultValues?: Record<string, string>; // Added parameter for default values
+  defaultValues?: Record<string, string>;
+  createdAtField?: string;
+  updatedAtField?: string;
 }) {
-  const { tableName, hasCreatedAt, hasUpdatedAt, searchFields = [], defaultValues = {} } = config;
+  const { 
+    tableName, 
+    hasCreatedAt, 
+    hasUpdatedAt, 
+    searchFields = [], 
+    defaultValues = {},
+    createdAtField = 'createdAt',
+    updatedAtField = 'updatedAt'
+  } = config;
   
   /**
    * The main hook function that provides all data access methods for a model.
@@ -383,6 +395,9 @@ export function createSuparismaHook<
     const [error, setError] = useState<Error | null>(null);
     const [loading, setLoading] = useState<boolean>(false);
     
+    // This is the total count, unaffected by pagination limits
+    const [count, setCount] = useState<number>(0);
+    
     // Search state
     const [searchQueries, setSearchQueries] = useState<SearchQuery[]>([]);
     const [searchLoading, setSearchLoading] = useState<boolean>(false);
@@ -391,6 +406,34 @@ export function createSuparismaHook<
     const channelRef = useRef<ReturnType<typeof supabase.channel> | null>(null);
     const searchTimeoutRef = useRef<NodeJS.Timeout | null>(null);
     const isSearchingRef = useRef<boolean>(false);
+
+    // Function to fetch the total count from Supabase with current filters
+    const fetchTotalCount = useCallback(async () => {
+      try {
+        // Skip count updates during search
+        if (isSearchingRef.current) return;
+        
+        let countQuery = supabase.from(tableName).select('*', { count: 'exact', head: true });
+        
+        // Apply where conditions if provided
+        if (where) {
+          countQuery = applyFilter(countQuery, where);
+        }
+        
+        const { count: totalCount, error: countError } = await countQuery;
+        
+        if (!countError) {
+          setCount(totalCount || 0);
+        }
+      } catch (err) {
+        console.error(\`Error fetching count for \${tableName}:\`, err);
+      }
+    }, [where, tableName]);
+    
+    // Update total count whenever where filter changes
+    useEffect(() => {
+      fetchTotalCount();
+    }, [fetchTotalCount]);
     
     // Create the search state object with all required methods
     const search: SearchState = {
@@ -537,6 +580,9 @@ export function createSuparismaHook<
             });
           }
           
+          // Set count directly for search results
+          setCount(results.length);
+          
           // Apply ordering if needed
           if (orderBy) {
             const orderEntries = Object.entries(orderBy);
@@ -556,16 +602,17 @@ export function createSuparismaHook<
           }
           
           // Apply pagination if needed
+          let paginatedResults = results;
           if (limit && limit > 0) {
-            results = results.slice(0, limit);
+            paginatedResults = results.slice(0, limit);
           }
           
           if (offset && offset > 0) {
-            results = results.slice(offset);
+            paginatedResults = paginatedResults.slice(offset);
           }
           
           // Update data with search results
-          setData(results);
+          setData(paginatedResults);
         } catch (err) {
           console.error('Search error:', err);
           setError(err as Error);
@@ -620,11 +667,11 @@ export function createSuparismaHook<
         
         // Apply order by if provided
         if (params?.orderBy) {
-          query = applyOrderBy(query, params.orderBy, hasCreatedAt);
+          query = applyOrderBy(query, params.orderBy, hasCreatedAt, createdAtField);
         } else if (hasCreatedAt) {
-          // Default ordering if available
+          // Use the actual createdAt field name from Prisma
           // @ts-ignore: Supabase typing issue
-          query = query.order('created_at', { ascending: false });
+          query = query.order(createdAtField, { ascending: false });
         }
         
         // Apply limit if provided
@@ -646,6 +693,12 @@ export function createSuparismaHook<
         // Only update data if not currently searching
         if (!isSearchingRef.current) {
           setData(typedData);
+          
+          // If the where filter changed, update the total count
+          if (JSON.stringify(params?.where) !== JSON.stringify(where)) {
+            // Use our standard count fetching function instead of duplicating logic
+            setTimeout(() => fetchTotalCount(), 0);
+          }
         }
         
         return { data: typedData, error: null };
@@ -656,7 +709,7 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, []);
+    }, [fetchTotalCount, where, tableName, hasCreatedAt, createdAtField]);
 
     /**
      * Find a single record by its unique identifier (usually ID).
@@ -809,6 +862,9 @@ export function createSuparismaHook<
                     newData = newData.slice(0, currentLimit);
                   }
                   
+                  // Fetch the updated count after the data changes
+                  setTimeout(() => fetchTotalCount(), 0);
+                  
                   return newData;
                 } catch (error) {
                   console.error('Error processing INSERT event:', error);
@@ -816,19 +872,25 @@ export function createSuparismaHook<
                 }
               });
             } else if (payload.eventType === 'UPDATE') {
-              // Process update event
+              // Process update event 
               setData((prev) => {
                 // Skip if search is active
                 if (isSearchingRef.current) {
                   return prev;
                 }
                 
-                return prev.map((item) =>
+                const newData = prev.map((item) =>
                   // @ts-ignore: Supabase typing issue
                   'id' in item && 'id' in payload.new && item.id === payload.new.id 
                     ? (payload.new as TWithRelations) 
                     : item
                 );
+                
+                // Fetch the updated count after the data changes
+                // For updates, the count might not change but we fetch anyway to be consistent
+                setTimeout(() => fetchTotalCount(), 0);
+                
+                return newData;
               });
             } else if (payload.eventType === 'DELETE') {
               // Process delete event
@@ -847,6 +909,9 @@ export function createSuparismaHook<
                   return !('id' in item && 'id' in payload.old && item.id === payload.old.id);
                 });
                 
+                // Fetch the updated count after the data changes
+                setTimeout(() => fetchTotalCount(), 0);
+                
                 // If we need to maintain the size with a limit
                 if (currentLimit && currentLimit > 0 && filteredData.length < currentSize && currentSize === currentLimit) {
                   console.log(\`Record deleted with limit \${currentLimit}, will fetch additional record to maintain size\`);
@@ -931,6 +996,9 @@ export function createSuparismaHook<
             take: limit,
             skip: offset
           });
+          
+          // Also update the total count
+          fetchTotalCount();
         }
         return;
       }
@@ -943,7 +1011,10 @@ export function createSuparismaHook<
         take: limit,
         skip: offset
       });
-    }, [findMany, where, orderBy, limit, offset, optionsChanged]);
+      
+      // Initial count fetch
+      fetchTotalCount();
+    }, [findMany, where, orderBy, limit, offset, optionsChanged, fetchTotalCount]);
 
     /**
      * Create a new record with the provided data.
@@ -1008,8 +1079,9 @@ export function createSuparismaHook<
         const itemWithDefaults = {
           ...appliedDefaults, // Apply schema defaults first
           ...data, // Then user data (overrides defaults)
-          ...(hasCreatedAt ? { created_at: now } : {}), // Always set timestamps
-          ...(hasUpdatedAt ? { updated_at: now } : {})
+          // Use the actual field names from Prisma
+          ...(hasCreatedAt ? { [createdAtField]: now } : {}), 
+          ...(hasUpdatedAt ? { [updatedAtField]: now } : {})
         };
         
         const { data: result, error } = await supabase
@@ -1019,6 +1091,9 @@ export function createSuparismaHook<
         
         if (error) throw error;
         
+        // Update the total count after a successful creation
+        setTimeout(() => fetchTotalCount(), 0);
+        
         // Return created record
         return { data: result?.[0] as TWithRelations, error: null };
       } catch (err: any) {
@@ -1028,7 +1103,7 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, []);
+    }, [fetchTotalCount]);
 
     /**
      * Update an existing record identified by a unique identifier.
@@ -1081,7 +1156,8 @@ export function createSuparismaHook<
         
         const itemWithDefaults = {
           ...params.data,
-          ...(hasUpdatedAt ? { updated_at: now } : {})
+          // Use the actual updatedAt field name from Prisma
+          ...(hasUpdatedAt ? { [updatedAtField]: now } : {})
         };
         
         const { data, error } = await supabase
@@ -1092,6 +1168,11 @@ export function createSuparismaHook<
         
         if (error) throw error;
         
+        // Update the total count after a successful update
+        // This is for consistency with other operations, and because
+        // updates can sometimes affect filtering based on updated values
+        setTimeout(() => fetchTotalCount(), 0);
+        
         // Return updated record
         return { data: data?.[0] as TWithRelations, error: null };
       } catch (err: any) {
@@ -1101,7 +1182,7 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, []);
+    }, [fetchTotalCount]);
 
     /**
      * Delete a record by its unique identifier.
@@ -1154,6 +1235,9 @@ export function createSuparismaHook<
         
         if (error) throw error;
         
+        // Update the total count after a successful deletion
+        setTimeout(() => fetchTotalCount(), 0);
+        
         // Return the deleted record
         return { data: recordToDelete as TWithRelations, error: null };
       } catch (err: any) {
@@ -1163,7 +1247,7 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, []);
+    }, [fetchTotalCount]);
 
     /**
      * Delete multiple records matching the filter criteria.
@@ -1220,6 +1304,9 @@ export function createSuparismaHook<
         
         if (deleteError) throw deleteError;
         
+        // Update the total count after a successful bulk deletion
+        setTimeout(() => fetchTotalCount(), 0);
+        
         // Return the count of deleted records
         return { count: recordsToDelete.length, error: null };
       } catch (err: any) {
@@ -1229,7 +1316,7 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, []);
+    }, [fetchTotalCount]);
 
     /**
      * Find the first record matching the filter criteria.
@@ -1312,21 +1399,13 @@ export function createSuparismaHook<
 
     /**
      * Count the number of records matching the filter criteria.
+     * This is a manual method to get the count with a different filter
+     * than the main hook's filter.
      * 
      * @param params - Query parameters for filtering
      * @returns A promise with the count of matching records
-     * 
-     * @example
-     * // Count all users
-     * const count = await users.count();
-     * 
-     * @example
-     * // Count active users
-     * const activeCount = await users.count({
-     *   where: { active: true }
-     * });
      */
-    const count = useCallback(async (params?: {
+    const countFn = useCallback(async (params?: {
       where?: TWhereInput;
     }): Promise<number> => {
       try {
@@ -1395,6 +1474,7 @@ export function createSuparismaHook<
       data,
       error,
       loading,
+      count, // Now including count as a reactive state value
       
       // Finder methods
       findUnique,
@@ -1408,9 +1488,6 @@ export function createSuparismaHook<
       deleteMany,
       upsert,
       
-      // Utilities
-      count,
-      
       // Manual refresh
       refresh
     };
@@ -1423,8 +1500,13 @@ export function createSuparismaHook<
         } 
       : api;
   };
-}`;
-    const outputPath = path_1.default.join(config_1.OUTPUT_DIR, 'core.ts');
+}
+`; // Ensure template literal is closed
+    // Output to the UTILS_DIR
+    const outputPath = path_1.default.join(config_1.UTILS_DIR, 'core.ts');
+    if (!fs_1.default.existsSync(config_1.UTILS_DIR)) {
+        fs_1.default.mkdirSync(config_1.UTILS_DIR, { recursive: true });
+    }
     fs_1.default.writeFileSync(outputPath, coreContent);
-    console.log(`Updated core hook factory with improved refresh and count functions at ${outputPath}`);
+    console.log(`Generated core utility file at ${outputPath}`);
 }

package/dist/generators/hookGenerator.js

@@ -16,7 +16,9 @@ const config_1 = require("../config");
  * @param modelInfo - Processed model information with metadata
  */
 function generateModelHookFile(modelInfo) {
-    const { modelName, tableName, hasCreatedAt, hasUpdatedAt, searchFields, defaultValues } = modelInfo;
+    const { modelName, tableName, hasCreatedAt, hasUpdatedAt, searchFields, defaultValues, createdAtField = 'createdAt', // Default to camelCase but use actual field name if provided
+    updatedAtField = 'updatedAt' // Default to camelCase but use actual field name if provided
+     } = modelInfo;
     // Configure search fields if available
     const searchConfig = searchFields && searchFields.length > 0
         ? `,\n  // Configure search for fields with @enableSearch annotation\n  searchFields: ${JSON.stringify(searchFields)}`
@@ -25,11 +27,14 @@ function generateModelHookFile(modelInfo) {
     const defaultValuesConfig = defaultValues
         ? `,\n  // Default values from schema\n  defaultValues: ${JSON.stringify(defaultValues)}`
         : '';
+    // Add createdAt/updatedAt field name config
+    const fieldNamesConfig = `${hasCreatedAt ? `,\n  // Field name for createdAt from Prisma schema\n  createdAtField: "${createdAtField}"` : ''}${hasUpdatedAt ? `,\n  // Field name for updatedAt from Prisma schema\n  updatedAtField: "${updatedAtField}"` : ''}`;
     // Generate the hook content
     const hookContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
 // Edit the generator script instead: scripts/generate-realtime-hooks.ts
 
-import { createSuparismaHook } from './core';
+// Corrected import for core hook factory
+import { createSuparismaHook } from '../utils/core';
 import type {
   ${modelName}WithRelations,
   ${modelName}CreateInput,
@@ -39,7 +44,7 @@ import type {
   ${modelName}OrderByInput,
   ${modelName}HookApi,
   Use${modelName}Options
-} from './${modelName}Types';
+} from '../types/${modelName}Types';
 
 /**
  * A Prisma-like hook for interacting with ${modelName} records with real-time capabilities.
@@ -58,7 +63,7 @@ import type {
  * // With filtering and ordering
  * const ${modelName.toLowerCase()} = ${config_1.HOOK_NAME_PREFIX}${modelName}({
  *   where: { active: true },
- *   orderBy: { created_at: 'desc' },
+ *   orderBy: { createdAt: 'desc' }, // Note: Using actual Prisma field name
  *   limit: 10
  * });
  * 
@@ -99,10 +104,14 @@ export const ${config_1.HOOK_NAME_PREFIX}${modelName} = createSuparismaHook<
 >({
   tableName: '${tableName}',
   hasCreatedAt: ${hasCreatedAt},
-  hasUpdatedAt: ${hasUpdatedAt}${searchConfig}${defaultValuesConfig}
-}) as (options?: Use${modelName}Options) => ${modelName}HookApi;
+  hasUpdatedAt: ${hasUpdatedAt}${searchConfig}${defaultValuesConfig}${fieldNamesConfig}
+}) as unknown as (options?: Use${modelName}Options) => ${modelName}HookApi;
 `;
-    const outputPath = path_1.default.join(config_1.OUTPUT_DIR, `${config_1.HOOK_NAME_PREFIX}${modelName}.ts`);
+    // Output to the HOOKS_DIR
+    const outputPath = path_1.default.join(config_1.HOOKS_DIR, `${config_1.HOOK_NAME_PREFIX}${modelName}.ts`);
+    if (!fs_1.default.existsSync(config_1.HOOKS_DIR)) {
+        fs_1.default.mkdirSync(config_1.HOOKS_DIR, { recursive: true });
+    }
     fs_1.default.writeFileSync(outputPath, hookContent);
     console.log(`Generated hook for ${modelName} at ${outputPath}`);
 }

package/dist/generators/indexGenerator.js

@@ -17,22 +17,22 @@ const config_1 = require("../config");
  *
  * @example
  * // The generated index allows imports like:
- * import useSuparisma from './hooks/generated';
+ * import useSuparisma from './your-output-dir'; // e.g., from './suparisma/generated'
  * // or
- * import { useSuparismaUser } from './hooks/generated';
+ * import { useSuparismaUser } from './your-output-dir';
  */
 function generateMainIndexFile(modelInfos) {
     // Import statements for hooks
     const imports = modelInfos
-        .map((info) => `import { ${config_1.HOOK_NAME_PREFIX}${info.modelName} } from './${config_1.HOOK_NAME_PREFIX}${info.modelName}';`)
+        .map((info) => `import { ${config_1.HOOK_NAME_PREFIX}${info.modelName} } from './hooks/${config_1.HOOK_NAME_PREFIX}${info.modelName}';`)
         .join('\n');
     // Import all required types
     const typeImports = modelInfos
-        .map((info) => `import type { Use${info.modelName}Options, ${info.modelName}HookApi } from './${info.modelName}Types';`)
+        .map((info) => `import type { Use${info.modelName}Options, ${info.modelName}HookApi } from './types/${info.modelName}Types';`)
         .join('\n');
     // Model-specific type exports
     const modelTypeExports = modelInfos
-        .map((info) => `export type { ${info.modelName}WithRelations, ${info.modelName}CreateInput, ${info.modelName}UpdateInput, ${info.modelName}WhereInput, ${info.modelName}WhereUniqueInput, ${info.modelName}OrderByInput, ${info.modelName}HookApi, Use${info.modelName}Options } from './${info.modelName}Types';`)
+        .map((info) => `export type { ${info.modelName}WithRelations, ${info.modelName}CreateInput, ${info.modelName}UpdateInput, ${info.modelName}WhereInput, ${info.modelName}WhereUniqueInput, ${info.modelName}OrderByInput, ${info.modelName}HookApi, Use${info.modelName}Options } from './types/${info.modelName}Types';`)
         .join('\n');
     // Create hook interface properties
     const hookProperties = modelInfos
@@ -48,7 +48,7 @@ function generateMainIndexFile(modelInfos) {
 
 ${imports}
 ${typeImports}
-export type { SuparismaOptions, SearchQuery, SearchState, FilterOperators } from './core';
+export type { SuparismaOptions, SearchQuery, SearchState, FilterOperators } from './utils/core';
 ${modelTypeExports}
 
 /**
@@ -69,7 +69,7 @@ ${hookProperties}
  * 
  * @example
  * // Get hooks for different models
- * import useSuparisma from './hooks/generated';
+ * import useSuparisma from './your-output-dir'; // e.g., from './suparisma/generated'
  * 
  * // Access user model with all hook methods
  * const users = useSuparisma.user();
@@ -94,7 +94,12 @@ ${hookAssignments}
 
 export default useSuparisma;
 `;
+    // Output to OUTPUT_DIR (root of generated files)
     const outputPath = path_1.default.join(config_1.OUTPUT_DIR, 'index.ts');
+    // Ensure the main output directory exists (it should have been created by other generators for subdirs too)
+    if (!fs_1.default.existsSync(config_1.OUTPUT_DIR)) {
+        fs_1.default.mkdirSync(config_1.OUTPUT_DIR, { recursive: true });
+    }
     fs_1.default.writeFileSync(outputPath, content);
     console.log(`Generated main module file at ${outputPath}`);
 }