suparisma 1.2.3 → 1.2.6

package/dist/generators/coreGenerator.js

@@ -194,11 +194,14 @@ export type SelectInput<T> = {
  * // Include a relation with specific fields
  * { posts: { select: { id: true, title: true } } }
  */
-export type IncludeInput = {
-  [key: string]: boolean | { select?: Record<string, boolean> };
-};
+export type IncludeValue = boolean | { select?: Record<string, boolean> };
 
-export type SuparismaOptions<TWhereInput, TOrderByInput, TSelectInput = Record<string, boolean>> = {
+export type SuparismaOptions<
+  TWhereInput,
+  TOrderByInput,
+  TSelectInput = Record<string, boolean>,
+  TIncludeInput = Record<never, never>
+> = {
   /** Whether to enable realtime updates (default: true) */
   realtime?: boolean;
   /** Custom channel name for realtime subscription */
@@ -222,7 +225,14 @@ export type SuparismaOptions<TWhereInput, TOrderByInput, TSelectInput = Record<s
    * Include related records (foreign key relations).
    * @example { posts: true } or { posts: { select: { id: true, title: true } } }
    */
-  include?: IncludeInput;
+  include?: TIncludeInput;
+  /**
+   * Whether to enable the hook (default: true).
+   * When false, the hook will not fetch data or set up realtime subscriptions.
+   * Useful for conditional fetching, e.g., waiting for auth/user data to be ready.
+   * @example enabled: !!user?.id
+   */
+  enabled?: boolean;
 };
 
 /**
@@ -794,7 +804,8 @@ function matchesFilter<T>(record: any, filter: T): boolean {
  */
 export function buildSelectString<TSelect, TInclude>(
   select?: TSelect,
-  include?: TInclude
+  include?: TInclude,
+  relationMappings?: Record<string, string>
 ): string {
   const parts: string[] = [];
   
@@ -812,9 +823,16 @@ export function buildSelectString<TSelect, TInclude>(
   // Handle include - add related records
   if (include && typeof include === 'object') {
     for (const [relationName, relationValue] of Object.entries(include)) {
+      const relatedTableName = relationMappings?.[relationName] || relationName;
+      // If mapping exists, use PostgREST alias syntax: alias:foreignTable(...)
+      const embedName =
+        relationMappings?.[relationName] && relatedTableName !== relationName
+          ? \`\${relationName}:\${relatedTableName}\`
+          : relationName;
+
       if (relationValue === true) {
         // Include all fields from the relation
-        parts.push(\`\${relationName}(*)\`);
+        parts.push(\`\${embedName}(*)\`);
       } else if (typeof relationValue === 'object' && relationValue !== null) {
         // Include specific fields from the relation
         const relationOptions = relationValue as { select?: Record<string, boolean> };
@@ -824,12 +842,12 @@ export function buildSelectString<TSelect, TInclude>(
             .map(([key]) => key);
           
           if (relationFields.length > 0) {
-            parts.push(\`\${relationName}(\${relationFields.join(',')})\`);
+            parts.push(\`\${embedName}(\${relationFields.join(',')})\`);
           } else {
-            parts.push(\`\${relationName}(*)\`);
+            parts.push(\`\${embedName}(*)\`);
           }
         } else {
-          parts.push(\`\${relationName}(*)\`);
+          parts.push(\`\${embedName}(*)\`);
         }
       }
     }
@@ -904,6 +922,7 @@ export function createSuparismaHook<
   defaultValues?: Record<string, string>;
   createdAtField?: string;
   updatedAtField?: string;
+  relationMappings?: Record<string, string>;
 }) {
   const { 
     tableName, 
@@ -912,7 +931,8 @@ export function createSuparismaHook<
     searchFields = [], 
     defaultValues = {},
     createdAtField = 'createdAt',
-    updatedAtField = 'updatedAt'
+    updatedAtField = 'updatedAt',
+    relationMappings = {}
   } = config;
   
   /**
@@ -945,10 +965,11 @@ export function createSuparismaHook<
       offset,
       select,
       include,
+      enabled = true,
     } = options;
     
     // Build the select string once for reuse
-    const selectString = buildSelectString(select, include);
+    const selectString = buildSelectString(select, include, relationMappings);
     
     // Refs to store the latest options for realtime handlers
     const whereRef = useRef(where);
@@ -956,6 +977,7 @@ export function createSuparismaHook<
     const limitRef = useRef(limit);
     const offsetRef = useRef(offset);
     const selectStringRef = useRef(selectString);
+    const enabledRef = useRef(enabled);
 
     // Update refs whenever options change
     useEffect(() => {
@@ -978,6 +1000,10 @@ export function createSuparismaHook<
       selectStringRef.current = selectString;
     }, [selectString]);
 
+    useEffect(() => {
+      enabledRef.current = enabled;
+    }, [enabled]);
+
     // Single data collection for holding results
     const [data, setData] = useState<TWithRelations[]>([]);
     const [error, setError] = useState<Error | null>(null);
@@ -998,7 +1024,8 @@ export function createSuparismaHook<
     // Function to fetch the total count from Supabase with current filters
     const fetchTotalCount = useCallback(async () => {
       try {
-        // Skip count updates during search
+        // Skip count updates when disabled or during search
+        if (!enabledRef.current) return;
         if (isSearchingRef.current) return;
         
         let countQuery = supabase.from(tableName).select('*', { count: 'exact', head: true });
@@ -1429,7 +1456,8 @@ export function createSuparismaHook<
 
         // Set up realtime subscription for the list - ONCE and listen to ALL events
     useEffect(() => {
-      if (!realtime) return;
+      // Skip subscription if not enabled or realtime is off
+      if (!enabled || !realtime) return;
       
       // Clean up previous subscription if it exists
       if (channelRef.current) {
@@ -1731,7 +1759,7 @@ export function createSuparismaHook<
           searchTimeoutRef.current = null;
         }
       };
-    }, [realtime, channelName, tableName]); // NEVER include 'where' - subscription should persist
+    }, [realtime, channelName, tableName, enabled]); // NEVER include 'where' - subscription should persist
 
     // Create a memoized options object to prevent unnecessary re-renders
     const optionsRef = useRef({ where, orderBy, limit, offset, selectString });
@@ -1763,6 +1791,12 @@ export function createSuparismaHook<
 
     // Load initial data and refetch when options change (BUT NEVER TOUCH SUBSCRIPTION)
     useEffect(() => {
+      // Skip fetching if not enabled
+      if (!enabled) {
+        setLoading(false); // Don't show loading spinner when disabled
+        return;
+      }
+      
       // Skip if search is active
       if (isSearchingRef.current) return;
       
@@ -1795,7 +1829,31 @@ export function createSuparismaHook<
       
       // Initial count fetch
       fetchTotalCount();
-    }, [findMany, where, orderBy, limit, offset, optionsChanged, fetchTotalCount]);
+    }, [findMany, where, orderBy, limit, offset, optionsChanged, fetchTotalCount, enabled]);
+
+    // Track previous enabled state to detect changes from false to true
+    const prevEnabledRef = useRef(enabled);
+    
+    // Fetch when enabled changes from false to true
+    useEffect(() => {
+      const wasDisabled = !prevEnabledRef.current;
+      const isNowEnabled = enabled;
+      
+      // Update the previous value
+      prevEnabledRef.current = enabled;
+      
+      // If we just became enabled and have already done initial load, refetch
+      if (wasDisabled && isNowEnabled && initialLoadRef.current) {
+        console.log(\`Hook enabled for \${tableName}, fetching data\`);
+        findMany({
+          where,
+          orderBy,
+          take: limit,
+          skip: offset
+        });
+        fetchTotalCount();
+      }
+    }, [enabled, findMany, where, orderBy, limit, offset, fetchTotalCount]);
 
     /**
      * Create a new record with the provided data.

package/dist/generators/hookGenerator.js

@@ -16,7 +16,7 @@ const config_1 = require("../config");
  * @param modelInfo - Processed model information with metadata
  */
 function generateModelHookFile(modelInfo) {
-    const { modelName, tableName, hasCreatedAt, hasUpdatedAt, searchFields, defaultValues, createdAtField = 'createdAt', // Default to camelCase but use actual field name if provided
+    const { modelName, tableName, hasCreatedAt, hasUpdatedAt, searchFields, defaultValues, relationMappings, 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
@@ -29,6 +29,10 @@ function generateModelHookFile(modelInfo) {
         : '';
     // 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}"` : ''}`;
+    // Relation mappings config (Prisma relation field -> related table name for PostgREST embedding)
+    const relationMappingsConfig = relationMappings && Object.keys(relationMappings).length > 0
+        ? `,\n  // Relation mappings for PostgREST embedding\n  relationMappings: ${JSON.stringify(relationMappings)}`
+        : '';
     // 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
@@ -118,7 +122,7 @@ export const ${config_1.HOOK_NAME_PREFIX}${modelName} = createSuparismaHook<
 >({
   tableName: '${tableName}',
   hasCreatedAt: ${hasCreatedAt},
-  hasUpdatedAt: ${hasUpdatedAt}${searchConfig}${defaultValuesConfig}${fieldNamesConfig}
+  hasUpdatedAt: ${hasUpdatedAt}${searchConfig}${defaultValuesConfig}${fieldNamesConfig}${relationMappingsConfig}
 }) as unknown as (options?: Use${modelName}Options) => ${modelName}HookApi;
 `;
     // Output to the HOOKS_DIR

package/dist/generators/typeGenerator.js

@@ -10,7 +10,7 @@ const config_1 = require("../config");
 /**
  * Generate model-specific types for a model
  */
-function generateModelTypesFile(model) {
+function generateModelTypesFile(model, modelNameToTableName = {}) {
     const modelName = model.name || '';
     const tableName = model.mappedName || modelName;
     // Identify foreign key fields (these end with _id)
@@ -21,6 +21,13 @@ function generateModelTypesFile(model) {
     const relationObjectFields = model.fields
         .filter((field) => field.isRelation && !foreignKeyFields.includes(field.name))
         .map((field) => field.name);
+    // Collect relation fields with their target model types (for include + WithRelations typing)
+    const relationFields = model.fields.filter((field) => relationObjectFields.includes(field.name) && field.type !== modelName);
+    // Map relation field name -> actual related table name (for PostgREST embedding)
+    const relationMappings = {};
+    for (const rel of relationFields) {
+        relationMappings[rel.name] = modelNameToTableName[rel.type] || rel.type;
+    }
     // Fields that have default values (should be optional in CreateInput)
     const defaultValueFields = model.fields
         .filter((field) => field.hasDefaultValue)
@@ -82,7 +89,7 @@ function generateModelTypesFile(model) {
     };
     // Create a manual property list for WithRelations interface
     const withRelationsProps = model.fields
-        .filter((field) => !relationObjectFields.includes(field.name) && !foreignKeyFields.includes(field.name))
+        .filter((field) => !relationObjectFields.includes(field.name))
         .map((field) => {
         const isOptional = field.isOptional;
         const finalType = getFieldType(field);
@@ -95,6 +102,20 @@ function generateModelTypesFile(model) {
             withRelationsProps.push(`  ${field}${fieldInfo.isOptional ? '?' : ''}: ${fieldInfo.type === 'Int' ? 'number' : 'string'};`);
         }
     });
+    // Add relation object fields as OPTIONAL (only present when included via include/select)
+    relationFields.forEach((field) => {
+        const relatedModel = field.type;
+        const relatedType = field.isList
+            ? `${relatedModel}WithRelations[]`
+            : `${relatedModel}WithRelations${field.isOptional ? ' | null' : ''}`;
+        withRelationsProps.push(`  ${field.name}?: ${relatedType};`);
+    });
+    // Build type-only imports for related model types (to type relations and include.select)
+    const relatedModelImports = Array.from(new Set(relationFields.map((f) => f.type).filter((t) => t && t !== modelName)));
+    // Note: We can't import multiple files in one statement. We'll generate one per model below.
+    const relationTypeImportStatements = relatedModelImports
+        .map((m) => `import type { ${m}WithRelations, ${m}SelectInput } from './${m}Types';`)
+        .join('\n');
     // Create a manual property list for CreateInput
     const createInputProps = model.fields
         .filter((field) => !relationObjectFields.includes(field.name) &&
@@ -142,7 +163,8 @@ function generateModelTypesFile(model) {
 // Edit the generator script instead
 
 ${customImports}import type { ${modelName} } from '@prisma/client';
-import type { ModelResult, SuparismaOptions, SearchQuery, SearchState, FilterOperators } from '../utils/core';
+import type { ModelResult, SuparismaOptions, SearchQuery, SearchState, FilterOperators, IncludeValue } from '../utils/core';
+${relationTypeImportStatements}
 
 /**
  * Extended ${modelName} type that includes relation fields.
@@ -349,41 +371,28 @@ export type ${modelName}WhereUniqueInput = {
  * });
  */
 export type ${modelName}OrderByInput = {
-  [key in keyof ${modelName}WithRelations]?: 'asc' | 'desc';
+  [key in keyof ${modelName}SelectInput]?: 'asc' | 'desc';
 };
 
 /**
- * Select specific fields to return from ${modelName} queries.
- * Set fields to \`true\` to include them in the response.
- * 
- * @example
- * // Only return id and name
- * ${modelName.toLowerCase()}.findMany({
- *   select: { id: true, name: true }
- * });
+ * Select specific scalar fields to return from ${modelName} queries.
+ * Relation fields are intentionally excluded; use \`include\` for relations.
  */
 export type ${modelName}SelectInput = {
-  [key in keyof ${modelName}WithRelations]?: boolean;
+  ${model.fields
+        .filter((f) => !relationObjectFields.includes(f.name))
+        .map((f) => `  ${f.name}?: boolean;`)
+        .join('\n')}
 };
 
 /**
  * Include related records when querying ${modelName}.
- * Set relation names to \`true\` to include all fields, or use an object to select specific fields.
- * 
- * @example
- * // Include all fields from a relation
- * ${modelName.toLowerCase()}.findMany({
- *   include: { relatedModel: true }
- * });
- * 
- * @example
- * // Include specific fields from a relation
- * ${modelName.toLowerCase()}.findMany({
- *   include: { relatedModel: { select: { id: true, name: true } } }
- * });
+ * Only real Prisma relation fields are allowed here.
  */
 export type ${modelName}IncludeInput = {
-  [key: string]: boolean | { select?: Record<string, boolean> };
+  ${relationFields
+        .map((f) => `  ${f.name}?: IncludeValue | { select?: ${f.type}SelectInput };`)
+        .join('\n')}
 };
 
 /**
@@ -400,10 +409,12 @@ export type ${modelName}ManyResult = ModelResult<${modelName}WithRelations[]>;
  * Configuration options for the ${modelName} hook.
  * Includes where filters, ordering, pagination, and field selection.
  */
-export type Use${modelName}Options = SuparismaOptions<${modelName}WhereInput, ${modelName}OrderByInput, ${modelName}SelectInput> & {
-  /** Include related records (foreign key relations) */
-  include?: ${modelName}IncludeInput;
-};
+export type Use${modelName}Options = SuparismaOptions<
+  ${modelName}WhereInput,
+  ${modelName}OrderByInput,
+  ${modelName}SelectInput,
+  ${modelName}IncludeInput
+>;
 
 /**
  * The complete API for interacting with ${modelName} records.
@@ -726,6 +737,7 @@ ${createInputProps
         defaultValues: Object.keys(defaultValues).length > 0 ? defaultValues : undefined,
         createdAtField,
         updatedAtField,
+        relationMappings: Object.keys(relationMappings).length > 0 ? relationMappings : undefined,
         zodImports: model.zodImports // Pass through zod imports
     };
 }

package/dist/index.js

@@ -484,9 +484,14 @@ async function generateHooks() {
         (0, coreGenerator_1.generateCoreFile)();
         const models = (0, parser_1.parsePrismaSchema)(config_1.PRISMA_SCHEMA_PATH);
         await configurePrismaTablesForSuparisma(config_1.PRISMA_SCHEMA_PATH);
+        // Map Prisma model name -> actual table name (respects @@map)
+        const modelNameToTableName = {};
+        for (const m of models) {
+            modelNameToTableName[m.name] = m.mappedName || m.name;
+        }
         const modelInfos = [];
         for (const model of models) {
-            const modelInfo = (0, typeGenerator_1.generateModelTypesFile)(model);
+            const modelInfo = (0, typeGenerator_1.generateModelTypesFile)(model, modelNameToTableName);
             (0, hookGenerator_1.generateModelHookFile)(modelInfo);
             modelInfos.push(modelInfo);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suparisma",
-	"version": "1.2.3",
+	"version": "1.2.6",
 	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma. Works with Next.js, Remix, React Native, and Expo.",
 	"main": "dist/index.js",
 	"repository": {

package/tmp/generated-test/hooks/useSuparismaAsset.ts

@@ -0,0 +1,94 @@
+// 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 {
+  AssetWithRelations,
+  AssetCreateInput,
+  AssetUpdateInput,
+  AssetWhereInput,
+  AssetWhereUniqueInput,
+  AssetOrderByInput,
+  AssetSelectInput,
+  AssetIncludeInput,
+  AssetHookApi,
+  UseAssetOptions
+} from '../types/AssetTypes';
+
+/**
+ * A Prisma-like hook for interacting with Asset 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 Asset records
+ * 
+ * @example
+ * // Basic usage - get all Asset records with realtime updates
+ * const asset = useSuparismaAsset();
+ * const { data, loading, error } = asset;
+ * 
+ * @example
+ * // With filtering and ordering
+ * const asset = useSuparismaAsset({
+ *   where: { active: true },
+ *   orderBy: { createdAt: 'desc' }, // Note: Using actual Prisma field name
+ *   limit: 10
+ * });
+ * 
+ * @example
+ * // Create a new record
+ * const result = await asset.create({
+ *   name: "Example Name",
+ *   // other fields...
+ * });
+ * 
+ * @example
+ * // Update a record
+ * const result = await asset.update({
+ *   where: { id: "123" },
+ *   data: { name: "Updated Name" }
+ * });
+ * 
+ * @example
+ * // Delete a record
+ * const result = await asset.delete({ id: "123" });
+ * 
+ * @example
+ * // Find records with specific criteria
+ * const result = await asset.findMany({
+ *   where: { // filters },
+ *   orderBy: { // ordering },
+ *   take: 20 // limit
+ * });
+ * 
+ * @example
+ * // Select specific fields only
+ * const asset = useSuparismaAsset({
+ *   select: { id: true, name: true }
+ * });
+ * 
+ * @example
+ * // Include related records
+ * const asset = useSuparismaAsset({
+ *   include: { relatedModel: true }
+ * });
+ */
+export const useSuparismaAsset = createSuparismaHook<
+  AssetWithRelations,
+  AssetWithRelations,
+  AssetCreateInput,
+  AssetUpdateInput,
+  AssetWhereInput,
+  AssetWhereUniqueInput,
+  AssetOrderByInput
+>({
+  tableName: 'Asset',
+  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?: UseAssetOptions) => AssetHookApi;

package/tmp/generated-test/hooks/useSuparismaChapter.ts

@@ -0,0 +1,96 @@
+// 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 {
+  ChapterWithRelations,
+  ChapterCreateInput,
+  ChapterUpdateInput,
+  ChapterWhereInput,
+  ChapterWhereUniqueInput,
+  ChapterOrderByInput,
+  ChapterSelectInput,
+  ChapterIncludeInput,
+  ChapterHookApi,
+  UseChapterOptions
+} from '../types/ChapterTypes';
+
+/**
+ * A Prisma-like hook for interacting with Chapter 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 Chapter records
+ * 
+ * @example
+ * // Basic usage - get all Chapter records with realtime updates
+ * const chapter = useSuparismaChapter();
+ * const { data, loading, error } = chapter;
+ * 
+ * @example
+ * // With filtering and ordering
+ * const chapter = useSuparismaChapter({
+ *   where: { active: true },
+ *   orderBy: { createdAt: 'desc' }, // Note: Using actual Prisma field name
+ *   limit: 10
+ * });
+ * 
+ * @example
+ * // Create a new record
+ * const result = await chapter.create({
+ *   name: "Example Name",
+ *   // other fields...
+ * });
+ * 
+ * @example
+ * // Update a record
+ * const result = await chapter.update({
+ *   where: { id: "123" },
+ *   data: { name: "Updated Name" }
+ * });
+ * 
+ * @example
+ * // Delete a record
+ * const result = await chapter.delete({ id: "123" });
+ * 
+ * @example
+ * // Find records with specific criteria
+ * const result = await chapter.findMany({
+ *   where: { // filters },
+ *   orderBy: { // ordering },
+ *   take: 20 // limit
+ * });
+ * 
+ * @example
+ * // Select specific fields only
+ * const chapter = useSuparismaChapter({
+ *   select: { id: true, name: true }
+ * });
+ * 
+ * @example
+ * // Include related records
+ * const chapter = useSuparismaChapter({
+ *   include: { relatedModel: true }
+ * });
+ */
+export const useSuparismaChapter = createSuparismaHook<
+  ChapterWithRelations,
+  ChapterWithRelations,
+  ChapterCreateInput,
+  ChapterUpdateInput,
+  ChapterWhereInput,
+  ChapterWhereUniqueInput,
+  ChapterOrderByInput
+>({
+  tableName: 'Chapter',
+  hasCreatedAt: true,
+  hasUpdatedAt: true,
+  // Default values from schema
+  defaultValues: {"id":"uuid(","order":"0","createdAt":"now("},
+  // Field name for createdAt from Prisma schema
+  createdAtField: "createdAt",
+  // Field name for updatedAt from Prisma schema
+  updatedAtField: "updatedAt"
+}) as unknown as (options?: UseChapterOptions) => ChapterHookApi;

package/tmp/generated-test/hooks/useSuparismaCourse.ts

@@ -0,0 +1,96 @@
+// 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 {
+  CourseWithRelations,
+  CourseCreateInput,
+  CourseUpdateInput,
+  CourseWhereInput,
+  CourseWhereUniqueInput,
+  CourseOrderByInput,
+  CourseSelectInput,
+  CourseIncludeInput,
+  CourseHookApi,
+  UseCourseOptions
+} from '../types/CourseTypes';
+
+/**
+ * A Prisma-like hook for interacting with Course 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 Course records
+ * 
+ * @example
+ * // Basic usage - get all Course records with realtime updates
+ * const course = useSuparismaCourse();
+ * const { data, loading, error } = course;
+ * 
+ * @example
+ * // With filtering and ordering
+ * const course = useSuparismaCourse({
+ *   where: { active: true },
+ *   orderBy: { createdAt: 'desc' }, // Note: Using actual Prisma field name
+ *   limit: 10
+ * });
+ * 
+ * @example
+ * // Create a new record
+ * const result = await course.create({
+ *   name: "Example Name",
+ *   // other fields...
+ * });
+ * 
+ * @example
+ * // Update a record
+ * const result = await course.update({
+ *   where: { id: "123" },
+ *   data: { name: "Updated Name" }
+ * });
+ * 
+ * @example
+ * // Delete a record
+ * const result = await course.delete({ id: "123" });
+ * 
+ * @example
+ * // Find records with specific criteria
+ * const result = await course.findMany({
+ *   where: { // filters },
+ *   orderBy: { // ordering },
+ *   take: 20 // limit
+ * });
+ * 
+ * @example
+ * // Select specific fields only
+ * const course = useSuparismaCourse({
+ *   select: { id: true, name: true }
+ * });
+ * 
+ * @example
+ * // Include related records
+ * const course = useSuparismaCourse({
+ *   include: { relatedModel: true }
+ * });
+ */
+export const useSuparismaCourse = createSuparismaHook<
+  CourseWithRelations,
+  CourseWithRelations,
+  CourseCreateInput,
+  CourseUpdateInput,
+  CourseWhereInput,
+  CourseWhereUniqueInput,
+  CourseOrderByInput
+>({
+  tableName: 'Course',
+  hasCreatedAt: true,
+  hasUpdatedAt: true,
+  // Default values from schema
+  defaultValues: {"id":"uuid(","published":"false","createdAt":"now(","allowIndividualLessonPurchase":"false","blockScreenRecording":"true","maxDevices":"0","price":"0","pricingType":"\"paid\"","defaultLessonPrice":"0"},
+  // Field name for createdAt from Prisma schema
+  createdAtField: "createdAt",
+  // Field name for updatedAt from Prisma schema
+  updatedAtField: "updatedAt"
+}) as unknown as (options?: UseCourseOptions) => CourseHookApi;