suparisma 1.0.0 → 1.0.2

package/dist/index.js

@@ -90,32 +90,41 @@ function analyzePrismaSchema(schemaPath) {
     try {
         const schemaContent = fs_1.default.readFileSync(schemaPath, 'utf8');
         const modelInfos = [];
-        // Regular expression to match model definitions with comments
         const modelRegex = /(?:\/\/\s*@disableRealtime\s*)?\s*model\s+(\w+)\s*{([\s\S]*?)}/g;
         let modelMatch;
         while ((modelMatch = modelRegex.exec(schemaContent)) !== null) {
             const modelName = modelMatch[1];
-            const modelBody = modelMatch[2];
+            const modelBodyWithComments = modelMatch[0]; // Includes the model keyword and its comments
+            const modelBody = modelMatch[2]; // Just the content within {}
             if (!modelName || !modelBody) {
                 console.error('Model name or body not found');
                 continue;
             }
-            const tableName = modelMatch[0].includes('@map')
-                ? modelMatch[0].match(/@map\s*\(\s*["'](.+?)["']\s*\)/)?.at(1) || modelName
+            const tableName = modelBodyWithComments.includes('@map')
+                ? modelBodyWithComments.match(/@map\s*\(\s*["'](.+?)["']\s*\)/)?.at(1) || modelName
                 : modelName;
-            // Check if model has @disableRealtime comment
-            // Default is to enable realtime unless explicitly disabled
-            const enableRealtime = !modelMatch[0].includes('// @disableRealtime');
-            // Find fields with @enableSearch comment
+            const enableRealtime = !modelBodyWithComments.includes('// @disableRealtime');
             const searchFields = [];
-            const fieldRegex = /(\w+)\s+(\w+)(?:\?.+?)?\s+(?:@.+?)?\s*(?:\/\/\s*@enableSearch)?/g;
-            let fieldMatch;
-            while ((fieldMatch = fieldRegex.exec(modelBody)) !== null) {
-                if (fieldMatch[0].includes('// @enableSearch')) {
-                    searchFields.push({
-                        name: fieldMatch[1] || '',
-                        type: fieldMatch[2] || '',
-                    });
+            // Split model body into lines to check preceding line for @enableSearch
+            const bodyLines = modelBody.trim().split('\n');
+            for (let i = 0; i < bodyLines.length; i++) {
+                const currentLine = bodyLines[i].trim();
+                const previousLine = i > 0 ? bodyLines[i - 1].trim() : "";
+                // Check if the PREVIOUS line contains the @enableSearch comment
+                if (previousLine.includes('// @enableSearch')) {
+                    // Try to parse the CURRENT line as a field definition
+                    // Basic regex: fieldName fieldType (optional attributes/comments)
+                    const fieldMatch = currentLine.match(/^(\w+)\s+(\w+)/);
+                    if (fieldMatch) {
+                        const fieldName = fieldMatch[1];
+                        const fieldType = fieldMatch[2];
+                        if (fieldName && fieldType) {
+                            searchFields.push({
+                                name: fieldName,
+                                type: fieldType,
+                            });
+                        }
+                    }
                 }
             }
             modelInfos.push({
@@ -150,123 +159,109 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
         }
         // Analyze Prisma schema for models, realtime and search annotations
         const modelInfos = analyzePrismaSchema(schemaPath);
-        // Dynamically import pg package
         const pg = await Promise.resolve().then(() => __importStar(require('pg')));
         const { Pool } = pg.default || pg;
-        // Connect to PostgreSQL database
-        const pool = new Pool({ connectionString: directUrl });
-        console.log('🔌 Connected to PostgreSQL database');
-        // Get all tables from database directly
-        const { rows: allTables } = await pool.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = 'public'
-    `);
-        console.log(`📋 Found ${allTables.length} tables in the 'public' schema`);
-        allTables.forEach((t) => console.log(`   - ${t.table_name}`));
-        // DIRECT APPROACH: Hardcode SQL for each known Prisma model type
+        const pool = new Pool({ connectionString: process.env.DIRECT_URL });
+        console.log('🔌 Connected to PostgreSQL database for configuration.');
+        const { rows: allTables } = await pool.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`);
         for (const model of modelInfos) {
-            try {
-                // Find the matching table regardless of case
-                const matchingTable = allTables.find((t) => t.table_name.toLowerCase() === model.tableName.toLowerCase());
-                if (!matchingTable) {
-                    console.warn(`⚠️ Could not find a table for model ${model.name}. Skipping.`);
-                    continue;
+            const matchingTable = allTables.find((t) => t.table_name.toLowerCase() === model.tableName.toLowerCase());
+            if (!matchingTable) {
+                console.warn(`🟠 Skipping model ${model.name}: Corresponding table ${model.tableName} not found in database.`);
+                continue;
+            }
+            const actualTableName = matchingTable.table_name;
+            console.log(`Processing model ${model.name} (table: "${actualTableName}")`);
+            // Realtime setup (existing logic)
+            if (model.enableRealtime) {
+                const alterPublicationQuery = `ALTER PUBLICATION supabase_realtime ADD TABLE "${actualTableName}";`;
+                try {
+                    await pool.query(alterPublicationQuery);
+                    console.log(`  ✅ Added "${actualTableName}" to supabase_realtime publication for real-time updates.`);
                 }
-                // Use the exact case of the table as it exists in the database
-                const actualTableName = matchingTable.table_name;
-                console.log(`🔍 Model ${model.name} -> Actual table: ${actualTableName}`);
-                console.log(`ℹ️ Model ${model.name}: enableRealtime is ${model.enableRealtime}`);
-                if (model.enableRealtime) {
-                    // Explicitly use double quotes for mixed case identifiers
-                    // try {
-                    //   await pool.query(`ALTER TABLE "${actualTableName}" REPLICA IDENTITY FULL;`);
-                    //   console.log(`✅ Set REPLICA IDENTITY FULL on "${actualTableName}"`);
-                    // } catch (err: any ) {
-                    //   console.error(`❌ Failed to set REPLICA IDENTITY on "${actualTableName}": ${err.message}`);
-                    // }
-                    // Directly add the table to Supabase Realtime publication
-                    const alterPublicationQuery = `ALTER PUBLICATION supabase_realtime ADD TABLE "${actualTableName}";`;
-                    console.log(`ℹ️ Executing SQL: ${alterPublicationQuery}`);
-                    try {
-                        await pool.query(alterPublicationQuery);
-                        console.log(`✅ Added "${actualTableName}" to supabase_realtime publication`);
+                catch (err) {
+                    if (err.message.includes('already member')) {
+                        console.log(`  ℹ️ Table "${actualTableName}" was already in supabase_realtime publication.`);
                     }
-                    catch (err) {
-                        // If error contains "already exists", this is fine
-                        if (err.message.includes('already member')) {
-                            console.log(`ℹ️ Table "${actualTableName}" was already in supabase_realtime publication`);
-                        }
-                        else {
-                            console.error(`❌ Failed to add "${actualTableName}" to supabase_realtime. Full error:`, err);
-                        }
+                    else {
+                        console.error(`  ❌ Failed to add "${actualTableName}" to supabase_realtime: ${err.message}`);
                     }
                 }
-                // Handle search fields if any
-                if (model.searchFields.length > 0) {
-                    // Get all columns for this table
-                    const { rows: columns } = await pool.query(`
-            SELECT column_name
-            FROM information_schema.columns
-            WHERE table_schema = 'public' AND table_name = $1
-          `, [actualTableName]);
-                    for (const searchField of model.searchFields) {
-                        // Find matching column regardless of case
-                        const matchingColumn = columns.find((c) => c.column_name.toLowerCase() === searchField.name.toLowerCase());
-                        if (!matchingColumn) {
-                            console.warn(`⚠️ Could not find column ${searchField.name} in table ${actualTableName}. Skipping search function.`);
-                            continue;
-                        }
-                        const actualColumnName = matchingColumn.column_name;
-                        const functionName = `search_${actualTableName.toLowerCase()}_by_${actualColumnName.toLowerCase()}_prefix`;
-                        const indexName = `idx_search_${actualTableName.toLowerCase()}_${actualColumnName.toLowerCase()}`;
-                        try {
-                            // Create search function with exact column case
-                            await pool.query(`
-                CREATE OR REPLACE FUNCTION "public"."${functionName}"(prefix text)
-                RETURNS SETOF "public"."${actualTableName}" AS $$
-                BEGIN
-                  RETURN QUERY
-                  SELECT * FROM "public"."${actualTableName}"
-                  WHERE to_tsvector('english', "${actualColumnName}") @@ to_tsquery('english', prefix || ':*');
-                END;
-                $$ LANGUAGE plpgsql;
-              `);
-                            console.log(`✅ Created search function for ${actualTableName}.${actualColumnName}`);
-                            // FIXED: Properly quote identifiers in the index creation query
-                            await pool.query(`
-                DO $$
-                BEGIN
-                  IF NOT EXISTS (
-                    SELECT 1 FROM pg_indexes 
-                    WHERE schemaname = 'public' 
-                    AND tablename = '${actualTableName}'
-                    AND indexname = '${indexName}'
-                  ) THEN
-                    CREATE INDEX "${indexName}" ON "public"."${actualTableName}" 
-                    USING GIN (to_tsvector('english', "${actualColumnName}"));
-                  END IF;
-                END;
-                $$;
-              `);
-                            console.log(`✅ Created search index for ${actualTableName}.${actualColumnName}`);
+            }
+            else {
+                console.log(`  ℹ️ Realtime disabled for model ${model.name}.`);
+            }
+            // Search setup
+            if (model.searchFields.length > 0) {
+                console.log(`  🔍 Setting up full-text search for model ${model.name}:`);
+                const { rows: columns } = await pool.query(`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = $1`, [actualTableName]);
+                for (const searchField of model.searchFields) {
+                    const matchingColumn = columns.find((c) => c.column_name.toLowerCase() === searchField.name.toLowerCase());
+                    if (!matchingColumn) {
+                        console.warn(`    🟠 Skipping search for field ${searchField.name}: Column not found in table "${actualTableName}".`);
+                        continue;
+                    }
+                    const actualColumnName = matchingColumn.column_name;
+                    const functionName = `search_${actualTableName.toLowerCase()}_by_${actualColumnName.toLowerCase()}_prefix`;
+                    const indexName = `idx_gin_search_${actualTableName.toLowerCase()}_${actualColumnName.toLowerCase()}`;
+                    console.log(`    ➡️ Configuring field "${actualColumnName}":`);
+                    try {
+                        // Create search function
+                        const createFunctionQuery = `
+              CREATE OR REPLACE FUNCTION "public"."${functionName}"(search_prefix text)
+              RETURNS SETOF "public"."${actualTableName}" AS $$
+              BEGIN
+                RETURN QUERY
+                SELECT * FROM "public"."${actualTableName}"
+                WHERE to_tsvector('english', "${actualColumnName}") @@ to_tsquery('english', search_prefix || ':*');
+              END;
+              $$ LANGUAGE plpgsql STABLE;`; // Added STABLE for potential performance benefits
+                        await pool.query(createFunctionQuery);
+                        console.log(`      ✅ Created/Replaced RPC function: "${functionName}"(search_prefix text)`);
+                        // Create GIN index
+                        const createIndexQuery = `
+              DO $$
+              BEGIN
+                IF NOT EXISTS (
+                  SELECT 1 FROM pg_indexes 
+                  WHERE schemaname = 'public' 
+                  AND tablename = '${actualTableName}'
+                  AND indexname = '${indexName}'
+                ) THEN
+                  CREATE INDEX "${indexName}" ON "public"."${actualTableName}" USING GIN (to_tsvector('english', "${actualColumnName}"));
+                  RAISE NOTICE '      ✅ Created GIN index: "${indexName}" on "${actualTableName}"("${actualColumnName}")';
+                ELSE
+                  RAISE NOTICE '      ℹ️ GIN index "${indexName}" on "${actualTableName}"("${actualColumnName}") already exists.';
+                END IF;
+              END;
+              $$;`;
+                        const indexResult = await pool.query(createIndexQuery);
+                        // Output notices from the DO $$ block (PostgreSQL specific)
+                        if (indexResult.rows.length > 0 && indexResult.rows[0].notice) {
+                            console.log(indexResult.rows[0].notice.replace(/^NOTICE:  /, ''));
                         }
-                        catch (err) {
-                            console.error(`❌ Failed to set up search for "${actualTableName}.${actualColumnName}": ${err.message}`);
+                        else if (!indexResult.rows.find((r) => r.notice?.includes('Created GIN index'))) {
+                            // If DO $$ block doesn't emit specific notice for creation and it didn't say exists.
+                            // This is a fallback log, actual creation/existence is handled by the DO block.
+                            // The important part is that the index will be there.
                         }
                     }
+                    catch (err) {
+                        console.error(`      ❌ Failed to set up search for "${actualTableName}"."${actualColumnName}": ${err.message}`);
+                    }
                 }
             }
-            catch (err) {
-                console.error(`❌ Error processing model ${model.name}: ${err.message}`);
+            else {
+                console.log(`  ℹ️ No fields marked with // @enableSearch for model ${model.name}.`);
             }
+            console.log('---------------------------------------------------');
         }
         await pool.end();
-        console.log('🎉 Database configuration complete');
+        console.log('🎉 Database configuration complete.');
     }
     catch (err) {
-        console.error('❌ Error configuring database:', err);
-        console.log('⚠️ Continuing with hook generation anyway...');
+        console.error('❌ Error during database configuration:', err);
+        console.log('⚠️ Hook generation will continue, but database features like search or realtime might not be fully configured.');
     }
 }
 /**

package/dist/parser.js

@@ -44,15 +44,16 @@ function parsePrismaSchema(schemaPath) {
             if (line.startsWith('//')) {
                 continue;
             }
-            // Parse field definition
-            const fieldMatch = line.match(/\s*(\w+)\s+(\w+)(\?)?\s*(?:@[^)]+)?/);
+            // Parse field definition - Updated to handle array types
+            const fieldMatch = line.match(/\s*(\w+)\s+(\w+)(\[\])?\??(\?)?\s*(?:@[^)]+)?/);
             if (fieldMatch) {
                 const fieldName = fieldMatch[1];
-                const fieldType = fieldMatch[2];
-                const isOptional = !!fieldMatch[3]; // ? makes it optional
+                const baseFieldType = fieldMatch[2]; // e.g., "String" from "String[]"
+                const isArray = !!fieldMatch[3]; // [] makes it an array
+                const isOptional = !!fieldMatch[4]; // ? makes it optional
                 // Store for potential standalone @enableSearch comment
                 lastFieldName = fieldName || '';
-                lastFieldType = fieldType || '';
+                lastFieldType = baseFieldType || '';
                 // Detect special fields
                 const isId = line.includes('@id');
                 const isCreatedAt = fieldName === 'created_at' || fieldName === 'createdAt';
@@ -73,13 +74,13 @@ function parsePrismaSchema(schemaPath) {
                 if (line.includes('// @enableSearch')) {
                     searchFields.push({
                         name: fieldName || '',
-                        type: fieldType || '',
+                        type: baseFieldType || '',
                     });
                 }
-                if (fieldName && fieldType) {
+                if (fieldName && baseFieldType) {
                     fields.push({
                         name: fieldName,
-                        type: fieldType,
+                        type: baseFieldType, // Store the base type (String, not String[])
                         isRequired: false,
                         isOptional,
                         isId,
@@ -89,6 +90,7 @@ function parsePrismaSchema(schemaPath) {
                         hasDefaultValue,
                         defaultValue, // Add the extracted default value
                         isRelation,
+                        isList: isArray, // Add the isList property
                     });
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suparisma",
-	"version": "1.0.0",
+	"version": "1.0.2",
 	"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

@@ -19,10 +19,12 @@ enum SomeEnum {
   THREE
 }
 
-// Realtime is enabled by default for all models
+
 model Thing {
   id        String   @id @default(uuid())
-  name      String?
+  // @enableSearch
+  name      String? 
+  stringArray String[]
   someEnum  SomeEnum @default(ONE)
   someNumber Int?
   createdAt DateTime @default(now())

package/generated/hooks/useSuparismaAuditLog.ts

@@ -1,80 +0,0 @@
-// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
-// Edit the generator script instead: scripts/generate-realtime-hooks.ts
-
-// Corrected import for core hook factory
-import { createSuparismaHook } from '../utils/core';
-import type {
-  AuditLogWithRelations,
-  AuditLogCreateInput,
-  AuditLogUpdateInput,
-  AuditLogWhereInput,
-  AuditLogWhereUniqueInput,
-  AuditLogOrderByInput,
-  AuditLogHookApi,
-  UseAuditLogOptions
-} from '../types/AuditLogTypes';
-
-/**
- * A Prisma-like hook for interacting with AuditLog records with real-time capabilities.
- * 
- * This hook provides CRUD operations, real-time updates, and search functionality.
- *
- * @param options - Optional configuration options for the hook
- * @returns An object with data state and methods for interacting with AuditLog records
- * 
- * @example
- * // Basic usage - get all AuditLog records with realtime updates
- * const auditlog = useSuparismaAuditLog();
- * const { data, loading, error } = auditlog;
- * 
- * @example
- * // With filtering and ordering
- * const auditlog = useSuparismaAuditLog({
- *   where: { active: true },
- *   orderBy: { createdAt: 'desc' }, // Note: Using actual Prisma field name
- *   limit: 10
- * });
- * 
- * @example
- * // Create a new record
- * const result = await auditlog.create({
- *   name: "Example Name",
- *   // other fields...
- * });
- * 
- * @example
- * // Update a record
- * const result = await auditlog.update({
- *   where: { id: "123" },
- *   data: { name: "Updated Name" }
- * });
- * 
- * @example
- * // Delete a record
- * const result = await auditlog.delete({ id: "123" });
- * 
- * @example
- * // Find records with specific criteria
- * const result = await auditlog.findMany({
- *   where: { // filters },
- *   orderBy: { // ordering },
- *   take: 20 // limit
- * });
- */
-export const useSuparismaAuditLog = createSuparismaHook<
-  AuditLogWithRelations,
-  AuditLogWithRelations,
-  AuditLogCreateInput,
-  AuditLogUpdateInput,
-  AuditLogWhereInput,
-  AuditLogWhereUniqueInput,
-  AuditLogOrderByInput
->({
-  tableName: 'AuditLog',
-  hasCreatedAt: true,
-  hasUpdatedAt: false,
-  // Default values from schema
-  defaultValues: {"id":"uuid(","createdAt":"now("},
-  // Field name for createdAt from Prisma schema
-  createdAtField: "createdAt"
-}) as unknown as (options?: UseAuditLogOptions) => AuditLogHookApi;

package/generated/hooks/useSuparismaThing.ts

@@ -1,82 +0,0 @@
-// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
-// Edit the generator script instead: scripts/generate-realtime-hooks.ts
-
-// Corrected import for core hook factory
-import { createSuparismaHook } from '../utils/core';
-import type {
-  ThingWithRelations,
-  ThingCreateInput,
-  ThingUpdateInput,
-  ThingWhereInput,
-  ThingWhereUniqueInput,
-  ThingOrderByInput,
-  ThingHookApi,
-  UseThingOptions
-} from '../types/ThingTypes';
-
-/**
- * A Prisma-like hook for interacting with Thing records with real-time capabilities.
- * 
- * This hook provides CRUD operations, real-time updates, and search functionality.
- *
- * @param options - Optional configuration options for the hook
- * @returns An object with data state and methods for interacting with Thing records
- * 
- * @example
- * // Basic usage - get all Thing records with realtime updates
- * const thing = useSuparismaThing();
- * const { data, loading, error } = thing;
- * 
- * @example
- * // With filtering and ordering
- * const thing = useSuparismaThing({
- *   where: { active: true },
- *   orderBy: { createdAt: 'desc' }, // Note: Using actual Prisma field name
- *   limit: 10
- * });
- * 
- * @example
- * // Create a new record
- * const result = await thing.create({
- *   name: "Example Name",
- *   // other fields...
- * });
- * 
- * @example
- * // Update a record
- * const result = await thing.update({
- *   where: { id: "123" },
- *   data: { name: "Updated Name" }
- * });
- * 
- * @example
- * // Delete a record
- * const result = await thing.delete({ id: "123" });
- * 
- * @example
- * // Find records with specific criteria
- * const result = await thing.findMany({
- *   where: { // filters },
- *   orderBy: { // ordering },
- *   take: 20 // limit
- * });
- */
-export const useSuparismaThing = createSuparismaHook<
-  ThingWithRelations,
-  ThingWithRelations,
-  ThingCreateInput,
-  ThingUpdateInput,
-  ThingWhereInput,
-  ThingWhereUniqueInput,
-  ThingOrderByInput
->({
-  tableName: 'Thing',
-  hasCreatedAt: true,
-  hasUpdatedAt: true,
-  // Default values from schema
-  defaultValues: {"id":"uuid(","someEnum":"ONE","createdAt":"now("},
-  // Field name for createdAt from Prisma schema
-  createdAtField: "createdAt",
-  // Field name for updatedAt from Prisma schema
-  updatedAtField: "updatedAt"
-}) as unknown as (options?: UseThingOptions) => ThingHookApi;

package/generated/index.ts

@@ -1,55 +0,0 @@
-// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
-// Edit the generator script instead: scripts/generate-realtime-hooks.ts
-
-import { useSuparismaThing } from './hooks/useSuparismaThing';
-import { useSuparismaAuditLog } from './hooks/useSuparismaAuditLog';
-import type { UseThingOptions, ThingHookApi } from './types/ThingTypes';
-import type { UseAuditLogOptions, AuditLogHookApi } from './types/AuditLogTypes';
-export type { SuparismaOptions, SearchQuery, SearchState, FilterOperators } from './utils/core';
-export type { ThingWithRelations, ThingCreateInput, ThingUpdateInput, ThingWhereInput, ThingWhereUniqueInput, ThingOrderByInput, ThingHookApi, UseThingOptions } from './types/ThingTypes';
-export type { AuditLogWithRelations, AuditLogCreateInput, AuditLogUpdateInput, AuditLogWhereInput, AuditLogWhereUniqueInput, AuditLogOrderByInput, AuditLogHookApi, UseAuditLogOptions } from './types/AuditLogTypes';
-
-/**
- * Interface for all Suparisma hooks with dot notation access.
- * This provides IntelliSense for all available models.
- * 
- * @example
- * // Access hooks for different models
- * const users = useSuparisma.user();
- * const posts = useSuparisma.post();
- */
-export interface SuparismaHooks {
-  thing: (options?: UseThingOptions) => ThingHookApi;
-  auditLog: (options?: UseAuditLogOptions) => AuditLogHookApi;
-}
-
-/**
- * Main Suparisma hook object with dot notation access to all model hooks.
- * 
- * @example
- * // Get hooks for different models
- * import useSuparisma from './your-output-dir'; // e.g., from './suparisma/generated'
- * 
- * // Access user model with all hook methods
- * const users = useSuparisma.user();
- * const { data, loading, error } = users;
- * 
- * // Create a new record
- * await users.create({ name: "John" });
- * 
- * // Delete a record
- * await users.delete({ id: "123" });
- * 
- * @example
- * // Use with filtering and options
- * const admins = useSuparisma.user({
- *   where: { role: 'admin' },
- *   orderBy: { created_at: 'desc' }
- * });
- */
-const useSuparisma: SuparismaHooks = {
-  thing: useSuparismaThing,
-  auditLog: useSuparismaAuditLog,
-};
-
-export default useSuparisma;