suparisma 1.0.0 → 1.0.1

package/README.md

@@ -1,4 +1,4 @@
-# Suparisma  
+# Suparisma
 Supabase + Prisma!
 
 ![Suparisma Logo](https://vg-bunny-cdn.b-cdn.net/random/suparisma-banner.png)

package/dist/generators/coreGenerator.js

@@ -155,6 +155,37 @@ export type SearchState = {
   clearQueries: () => void;
 };
 
+/**
+ * Compare two values for sorting with proper type handling
+ */
+function compareValues(a: any, b: any, direction: 'asc' | 'desc'): number {
+  // Handle undefined/null values
+  if (a === undefined || a === null) return direction === 'asc' ? -1 : 1;
+  if (b === undefined || b === null) return direction === 'asc' ? 1 : -1;
+  
+  // Handle numbers properly to ensure numeric comparison
+  if (typeof a === 'number' && typeof b === 'number') {
+    return direction === 'asc' 
+      ? a - b
+      : b - a;
+  }
+  
+  // Handle dates (convert to timestamps for comparison)
+  if (a instanceof Date && b instanceof Date) {
+    return direction === 'asc' 
+      ? a.getTime() - b.getTime()
+      : b.getTime() - a.getTime();
+  }
+  
+  // Handle strings or mixed types with string conversion
+  const aStr = String(a);
+  const bStr = String(b);
+  
+  return direction === 'asc'
+    ? aStr.localeCompare(bStr)
+    : bStr.localeCompare(aStr);
+}
+
 /**
  * Convert a type-safe where filter to Supabase filter string
  */
@@ -316,11 +347,17 @@ export function applyOrderBy<T>(
   
   // Apply each order by clause
   let orderedQuery = query;
-  for (const [key, direction] of Object.entries(orderBy)) {
-    // @ts-ignore: Supabase typing issue
-    orderedQuery = orderedQuery.order(key, {
-      ascending: direction === 'asc'
-    });
+  
+  // Handle orderBy as array or single object
+  const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+  
+  for (const orderByClause of orderByArray) {
+    for (const [key, direction] of Object.entries(orderByClause)) {
+      // @ts-ignore: Supabase typing issue
+      orderedQuery = orderedQuery.order(key, {
+        ascending: direction === 'asc'
+      });
+    }
   }
   
   return orderedQuery;
@@ -387,9 +424,29 @@ export function createSuparismaHook<
       offset,
     } = options;
     
-    // Compute the actual filter string from the type-safe where object or use legacy filter
-    const computedFilter = where ? buildFilterString(where) : realtimeFilter;
-    
+    // Refs to store the latest options for realtime handlers
+    const whereRef = useRef(where);
+    const orderByRef = useRef(orderBy);
+    const limitRef = useRef(limit);
+    const offsetRef = useRef(offset);
+
+    // Update refs whenever options change
+    useEffect(() => {
+      whereRef.current = where;
+    }, [where]);
+
+    useEffect(() => {
+      orderByRef.current = orderBy;
+    }, [orderBy]);
+
+    useEffect(() => {
+      limitRef.current = limit;
+    }, [limit]);
+
+    useEffect(() => {
+      offsetRef.current = offset;
+    }, [offset]);
+
     // Single data collection for holding results
     const [data, setData] = useState<TWithRelations[]>([]);
     const [error, setError] = useState<Error | null>(null);
@@ -773,14 +830,11 @@ export function createSuparismaHook<
       
       const channelId = channelName || \`changes_to_\${tableName}_\${Math.random().toString(36).substring(2, 15)}\`;
       
-      // Store the current filter and options for closure
-      const currentFilter = computedFilter;
-      const currentWhere = where;
-      const currentOrderBy = orderBy;
-      const currentLimit = limit;
-      const currentOffset = offset;
-      
-      console.log(\`Setting up subscription for \${tableName} with filter: \${currentFilter}\`);
+      // Use a dynamic filter string builder inside the event handler or rely on Supabase
+      // For the subscription filter, we must use the initial computedFilter or a stable one.
+      // However, for client-side logic (sorting, adding/removing from list), we use refs.
+      const initialComputedFilter = where ? buildFilterString(where) : realtimeFilter;
+      console.log(\`Setting up subscription for \${tableName} with initial filter: \${initialComputedFilter}\`);
       
       const channel = supabase
         .channel(channelId)
@@ -790,11 +844,17 @@ export function createSuparismaHook<
             event: '*',
             schema: 'public',
             table: tableName,
-            filter: currentFilter,
+            filter: initialComputedFilter, // Subscription filter uses initial state
           },
           (payload) => {
             console.log(\`Received \${payload.eventType} event for \${tableName}\`, payload);
             
+            // Access current options via refs inside the event handler
+            const currentWhere = whereRef.current;
+            const currentOrderBy = orderByRef.current;
+            const currentLimit = limitRef.current;
+            const currentOffset = offsetRef.current; // Not directly used in handlers but good for consistency
+
             // Skip realtime updates when search is active
             if (isSearchingRef.current) return;
             
@@ -806,7 +866,7 @@ export function createSuparismaHook<
                   console.log(\`Processing INSERT for \${tableName}\`, { newRecord });
                   
                   // Check if this record matches our filter if we have one
-                  if (currentWhere) {
+                  if (currentWhere) { // Use ref value
                     let matchesFilter = true;
                     
                     // Check each filter condition
@@ -838,27 +898,43 @@ export function createSuparismaHook<
                   }
                   
                   // Add the new record to the data
-                  let newData = [newRecord, ...prev];
+                  let newData = [...prev, newRecord]; // Changed: Use spread on prev for immutability
                   
                   // Apply ordering if specified
-                  if (currentOrderBy) {
-                    const [orderField, direction] = Object.entries(currentOrderBy)[0] || [];
-                    if (orderField) {
-                      newData = [...newData].sort((a, b) => {
-                        const aValue = a[orderField as keyof typeof a] ?? '';
-                        const bValue = b[orderField as keyof typeof b] ?? '';
-                        
-                        if (direction === 'asc') {
-                          return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
-                        } else {
-                          return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
+                  if (currentOrderBy) { // Use ref value
+                    // Convert orderBy to array format for consistency if it's an object
+                    const orderByArray = Array.isArray(currentOrderBy) 
+                      ? currentOrderBy 
+                      : [currentOrderBy];
+                      
+                    // Apply each sort in sequence
+                    newData = [...newData].sort((a, b) => {
+                      // Check each orderBy clause in sequence
+                      for (const orderByClause of orderByArray) {
+                        for (const [field, direction] of Object.entries(orderByClause)) {
+                          const aValue = a[field as keyof typeof a];
+                          const bValue = b[field as keyof typeof b];
+                          
+                          // Skip if values are equal and move to next criterion
+                          if (aValue === bValue) continue;
+                          
+                          // Use the compareValues function for proper type handling
+                          return compareValues(aValue, bValue, direction as 'asc' | 'desc');
                         }
-                      });
-                    }
+                      }
+                      return 0; // Equal if all criteria match
+                    });
+                  } else if (hasCreatedAt) {
+                    // Default sort by createdAt desc if no explicit sort but has timestamp
+                    newData = [...newData].sort((a, b) => {
+                      const aValue = a[createdAtField as keyof typeof a];
+                      const bValue = b[createdAtField as keyof typeof b];
+                      return compareValues(aValue, bValue, 'desc');
+                    });
                   }
                   
                   // Apply limit if specified
-                  if (currentLimit && currentLimit > 0) {
+                  if (currentLimit && currentLimit > 0) { // Use ref value
                     newData = newData.slice(0, currentLimit);
                   }
                   
@@ -874,6 +950,10 @@ export function createSuparismaHook<
             } else if (payload.eventType === 'UPDATE') {
               // Process update event 
               setData((prev) => {
+                // Access current options via refs
+                const currentOrderBy = orderByRef.current; 
+                const currentLimit = limitRef.current; // If needed for re-fetch logic on update
+
                 // Skip if search is active
                 if (isSearchingRef.current) {
                   return prev;
@@ -886,15 +966,57 @@ export function createSuparismaHook<
                     : item
                 );
                 
+                // Apply ordering again after update to ensure consistency
+                let sortedData = [...newData];
+                
+                // Apply ordering if specified
+                if (currentOrderBy) { // Use ref value
+                  // Convert orderBy to array format for consistency if it's an object
+                  const orderByArray = Array.isArray(currentOrderBy) 
+                    ? currentOrderBy 
+                    : [currentOrderBy];
+                    
+                  // Apply each sort in sequence
+                  sortedData = sortedData.sort((a, b) => {
+                    // Check each orderBy clause in sequence
+                    for (const orderByClause of orderByArray) {
+                      for (const [field, direction] of Object.entries(orderByClause)) {
+                        const aValue = a[field as keyof typeof a];
+                        const bValue = b[field as keyof typeof b];
+                        
+                        // Skip if values are equal and move to next criterion
+                        if (aValue === bValue) continue;
+                        
+                        // Use the compareValues function for proper type handling
+                        return compareValues(aValue, bValue, direction as 'asc' | 'desc');
+                      }
+                    }
+                    return 0; // Equal if all criteria match
+                  });
+                } else if (hasCreatedAt) {
+                  // Default sort by createdAt desc if no explicit sort but has timestamp
+                  sortedData = sortedData.sort((a, b) => {
+                    const aValue = a[createdAtField as keyof typeof a];
+                    const bValue = b[createdAtField as keyof typeof b];
+                    return compareValues(aValue, bValue, 'desc');
+                  });
+                }
+                
                 // 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;
+                return sortedData;
               });
             } else if (payload.eventType === 'DELETE') {
               // Process delete event
               setData((prev) => {
+                // Access current options via refs
+                const currentWhere = whereRef.current;
+                const currentOrderBy = orderByRef.current;
+                const currentLimit = limitRef.current;
+                const currentOffset = offsetRef.current;
+
                 // Skip if search is active
                 if (isSearchingRef.current) {
                   return prev;
@@ -913,21 +1035,61 @@ export function createSuparismaHook<
                 setTimeout(() => fetchTotalCount(), 0);
                 
                 // If we need to maintain the size with a limit
-                if (currentLimit && currentLimit > 0 && filteredData.length < currentSize && currentSize === currentLimit) {
+                if (currentLimit && currentLimit > 0 && filteredData.length < currentSize && currentSize === currentLimit) { // Use ref value
                   console.log(\`Record deleted with limit \${currentLimit}, will fetch additional record to maintain size\`);
                   
                   // Use setTimeout to ensure this state update completes first
                   setTimeout(() => {
                     findMany({
-                      where: currentWhere,
-                      orderBy: currentOrderBy,
-                      take: currentLimit,
-                      skip: currentOffset
+                      where: currentWhere, // Use ref value
+                      orderBy: currentOrderBy, // Use ref value
+                      take: currentLimit, // Use ref value
+                      skip: currentOffset // Use ref value (passed as skip to findMany)
                     });
                   }, 0);
+                  
+                  // Return the filtered data without resizing for now
+                  // The findMany call above will update the data later
+                  return filteredData;
+                }
+                
+                // Re-apply ordering to maintain consistency
+                let sortedData = [...filteredData];
+                
+                // Apply ordering if specified
+                if (currentOrderBy) { // Use ref value
+                  // Convert orderBy to array format for consistency if it's an object
+                  const orderByArray = Array.isArray(currentOrderBy) 
+                    ? currentOrderBy 
+                    : [currentOrderBy];
+                    
+                  // Apply each sort in sequence
+                  sortedData = sortedData.sort((a, b) => {
+                    // Check each orderBy clause in sequence
+                    for (const orderByClause of orderByArray) {
+                      for (const [field, direction] of Object.entries(orderByClause)) {
+                        const aValue = a[field as keyof typeof a];
+                        const bValue = b[field as keyof typeof b];
+                        
+                        // Skip if values are equal and move to next criterion
+                        if (aValue === bValue) continue;
+                        
+                        // Use the compareValues function for proper type handling
+                        return compareValues(aValue, bValue, direction as 'asc' | 'desc');
+                      }
+                    }
+                    return 0; // Equal if all criteria match
+                  });
+                } else if (hasCreatedAt) {
+                  // Default sort by createdAt desc if no explicit sort but has timestamp
+                  sortedData = sortedData.sort((a, b) => {
+                    const aValue = a[createdAtField as keyof typeof a];
+                    const bValue = b[createdAtField as keyof typeof b];
+                    return compareValues(aValue, bValue, 'desc');
+                  });
                 }
                 
-                return filteredData;
+                return sortedData;
               });
             }
           }
@@ -942,7 +1104,7 @@ export function createSuparismaHook<
       return () => {
         console.log(\`Unsubscribing from \${channelId}\`);
         if (channelRef.current) {
-          channelRef.current.unsubscribe();
+          supabase.removeChannel(channelRef.current); // Correct way to remove channel
           channelRef.current = null;
         }
         
@@ -951,7 +1113,7 @@ export function createSuparismaHook<
           searchTimeoutRef.current = null;
         }
       };
-    }, [realtime, channelName, computedFilter]);
+    }, [realtime, channelName, tableName, initialLoadRef]); // Removed where, orderBy, limit, offset from deps
 
     // Create a memoized options object to prevent unnecessary re-renders
     const optionsRef = useRef({ where, orderBy, limit, offset });

package/package.json

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

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;