suparisma 0.0.1

package/dist/hooks/generated/index.js

@@ -0,0 +1,33 @@
+"use strict";
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Edit the generator script instead: scripts/generate-realtime-hooks.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+const useSuparismaUser_1 = require("./useSuparismaUser");
+/**
+ * Main Suparisma hook object with dot notation access to all model hooks.
+ *
+ * @example
+ * // Get hooks for different models
+ * import useSuparisma from './hooks/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 = {
+    user: useSuparismaUser_1.useSuparismaUser,
+};
+exports.default = useSuparisma;

package/dist/hooks/generated/useSuparismaUser.js

@@ -0,0 +1,60 @@
+"use strict";
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Edit the generator script instead: scripts/generate-realtime-hooks.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSuparismaUser = void 0;
+const core_1 = require("./core");
+/**
+ * A Prisma-like hook for interacting with User 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 User records
+ *
+ * @example
+ * // Basic usage - get all User records with realtime updates
+ * const user = useSuparismaUser();
+ * const { data, loading, error } = user;
+ *
+ * @example
+ * // With filtering and ordering
+ * const user = useSuparismaUser({
+ *   where: { active: true },
+ *   orderBy: { created_at: 'desc' },
+ *   limit: 10
+ * });
+ *
+ * @example
+ * // Create a new record
+ * const result = await user.create({
+ *   name: "Example Name",
+ *   // other fields...
+ * });
+ *
+ * @example
+ * // Update a record
+ * const result = await user.update({
+ *   where: { id: "123" },
+ *   data: { name: "Updated Name" }
+ * });
+ *
+ * @example
+ * // Delete a record
+ * const result = await user.delete({ id: "123" });
+ *
+ * @example
+ * // Find records with specific criteria
+ * const result = await user.findMany({
+ *   where: { // filters },
+ *   orderBy: { // ordering },
+ *   take: 20 // limit
+ * });
+ */
+exports.useSuparismaUser = (0, core_1.createSuparismaHook)({
+    tableName: 'User',
+    hasCreatedAt: true,
+    hasUpdatedAt: true,
+    // Default values from schema
+    defaultValues: { "id": "uuid(", "createdAt": "now(" }
+});

package/dist/index.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+// Import configuration
+const config_1 = require("./config");
+// Import parsers and generators
+const parser_1 = require("./parser");
+const coreGenerator_1 = require("./generators/coreGenerator");
+const typeGenerator_1 = require("./generators/typeGenerator");
+const hookGenerator_1 = require("./generators/hookGenerator");
+const indexGenerator_1 = require("./generators/indexGenerator");
+const supabaseClientGenerator_1 = require("./generators/supabaseClientGenerator");
+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*@enableRealtime\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];
+            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
+                : modelName;
+            // Check if model has @enableRealtime comment
+            const enableRealtime = modelMatch[0].includes('// @enableRealtime');
+            // Find fields with @enableSearch comment
+            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] || '',
+                    });
+                }
+            }
+            modelInfos.push({
+                name: modelName,
+                tableName,
+                enableRealtime,
+                searchFields,
+            });
+        }
+        return modelInfos;
+    }
+    catch (error) {
+        console.error('Error analyzing Prisma schema:', error);
+        return [];
+    }
+}
+/**
+ * Configure database tables for proper realtime functionality and search
+ * 1. Sets REPLICA IDENTITY FULL and enables realtime for models with @enableRealtime
+ * 2. Creates search functions for fields with @enableSearch
+ */
+async function configurePrismaTablesForSuparisma(schemaPath) {
+    try {
+        // COMPLETELY BYPASS NORMAL OPERATION FOR SIMPLICITY
+        console.log('🔧 Using direct SQL approach to avoid PostgreSQL case sensitivity issues...');
+        // Load environment variables
+        dotenv.config();
+        // Get direct PostgreSQL connection URL
+        const directUrl = process.env.DIRECT_URL;
+        if (!directUrl) {
+            console.warn('⚠️ DIRECT_URL environment variable not found. Skipping database configuration.');
+            return;
+        }
+        // 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
+        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;
+                }
+                // 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}`);
+                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
+                    try {
+                        await pool.query(`
+              ALTER PUBLICATION supabase_realtime ADD TABLE "${actualTableName}";
+            `);
+                        console.log(`✅ Added "${actualTableName}" to 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: ${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}`);
+                        }
+                        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}`);
+            }
+        }
+        await pool.end();
+        console.log('🎉 Database configuration complete');
+    }
+    catch (err) {
+        console.error('❌ Error configuring database:', err);
+        console.log('⚠️ Continuing with hook generation anyway...');
+    }
+}
+/**
+ * Main execution function
+ */
+async function main() {
+    try {
+        console.log('Generating Supabase realtime hooks with improved architecture...');
+        // Ensure output directory exists
+        if (!fs_1.default.existsSync(config_1.OUTPUT_DIR)) {
+            fs_1.default.mkdirSync(config_1.OUTPUT_DIR, { recursive: true });
+        }
+        // Generate Supabase client file first
+        (0, supabaseClientGenerator_1.generateSupabaseClientFile)();
+        // First, generate the core hook factory
+        (0, coreGenerator_1.generateCoreFile)();
+        // Parse models from Prisma schema
+        const models = (0, parser_1.parsePrismaSchema)(config_1.PRISMA_SCHEMA_PATH);
+        // Configure database tables for real-time and search functionality
+        await configurePrismaTablesForSuparisma(config_1.PRISMA_SCHEMA_PATH);
+        // Generate type definitions and hooks for each model
+        const modelInfos = [];
+        for (const model of models) {
+            const modelInfo = (0, typeGenerator_1.generateModelTypesFile)(model);
+            (0, hookGenerator_1.generateModelHookFile)(modelInfo);
+            modelInfos.push(modelInfo);
+        }
+        // Generate the main module file
+        (0, indexGenerator_1.generateMainIndexFile)(modelInfos);
+        console.log('✅ Successfully generated all suparisma hooks!');
+    }
+    catch (error) {
+        console.error('❌ Error generating hooks:', error);
+        process.exit(1);
+    }
+}
+// Execute main function
+main();

package/dist/parser.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrismaSchema = parsePrismaSchema;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Parse Prisma schema to extract model information including search annotations
+ */
+function parsePrismaSchema(schemaPath) {
+    const schema = fs_1.default.readFileSync(schemaPath, 'utf-8');
+    const modelRegex = /model\s+(\w+)\s+{([^}]*)}/gs;
+    const models = [];
+    let match;
+    while ((match = modelRegex.exec(schema)) !== null) {
+        const modelName = match[1] || '';
+        const modelBody = match[2] || '';
+        // Extract custom table name if provided with @@map
+        const mapMatch = modelBody.match(/@@map\("([^"]+)"\)/);
+        const mappedName = mapMatch ? mapMatch[1] : modelName;
+        // Extract field info
+        const fields = [];
+        // Track fields with @enableSearch annotation
+        const searchFields = [];
+        const lines = modelBody.split('\n');
+        let lastFieldName = '';
+        let lastFieldType = '';
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i]?.trim();
+            // Skip blank lines and non-field lines
+            if (!line || line.startsWith('@@')) {
+                continue;
+            }
+            // Check for standalone @enableSearch comment
+            if (line === '// @enableSearch' && lastFieldName) {
+                searchFields.push({
+                    name: lastFieldName,
+                    type: lastFieldType,
+                });
+                continue;
+            }
+            // Check if line is a comment
+            if (line.startsWith('//')) {
+                continue;
+            }
+            // Parse field definition
+            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
+                // Store for potential standalone @enableSearch comment
+                lastFieldName = fieldName || '';
+                lastFieldType = fieldType || '';
+                // Detect special fields
+                const isId = line.includes('@id');
+                const isCreatedAt = fieldName === 'created_at' || fieldName === 'createdAt';
+                const isUpdatedAt = fieldName === 'updated_at' || fieldName === 'updatedAt';
+                const hasDefaultValue = line.includes('@default');
+                // Extract default value if present
+                let defaultValue;
+                if (hasDefaultValue) {
+                    const defaultMatch = line.match(/@default\(\s*(.+?)\s*\)/);
+                    if (defaultMatch) {
+                        defaultValue = defaultMatch[1];
+                    }
+                }
+                const isRelation = line.includes('@relation') ||
+                    (!!fieldName &&
+                        (fieldName.endsWith('_id') || fieldName === 'userId' || fieldName === 'user_id'));
+                // Check for inline @enableSearch comment
+                if (line.includes('// @enableSearch')) {
+                    searchFields.push({
+                        name: fieldName || '',
+                        type: fieldType || '',
+                    });
+                }
+                if (fieldName && fieldType) {
+                    fields.push({
+                        name: fieldName,
+                        type: fieldType,
+                        isRequired: false,
+                        isOptional,
+                        isId,
+                        isUnique: false,
+                        isUpdatedAt,
+                        isCreatedAt,
+                        hasDefaultValue,
+                        defaultValue, // Add the extracted default value
+                        isRelation,
+                    });
+                }
+            }
+        }
+        // Check for model-level @enableSearch before the model definition
+        if (schema.includes(`// @enableSearch\nmodel ${modelName}`)) {
+            // Add all string fields as searchable
+            fields.forEach((field) => {
+                if (field.type.toLowerCase() === 'string' &&
+                    !searchFields.some((sf) => sf.name === field.name)) {
+                    searchFields.push({
+                        name: field.name,
+                        type: field.type,
+                    });
+                }
+            });
+        }
+        models.push({
+            name: modelName,
+            mappedName: mappedName || '',
+            fields,
+            searchFields: searchFields.length > 0 ? searchFields : undefined,
+        });
+    }
+    return models;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "suparisma",
+	"version": "0.0.1",
+	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
+	"main": "dist/index.js",
+	"scripts": {
+		"build": "tsc",
+		"start": "node dist/index.js",
+		"test": "jest",
+		"generate-prisma-types": "prisma generate",
+		"generate-hooks": "ts-node --transpile-only src/index.ts"
+	},
+	"dependencies": {
+		"@supabase/supabase-js": "^2.49.4",
+		"dotenv": "^16.5.0",
+		"fs": "0.0.1-security",
+		"path": "^0.12.7",
+		"pg": "^8.16.0",
+		"react": "^19.1.0"
+	},
+	"devDependencies": {
+		"@types/node": "^22.15.18",
+		"@types/pg": "^8.15.2",
+		"@types/react": "^19.1.4",
+		"prisma": "^6.8.2",
+		"supabase-js": "link:@types/@supabase/supabase-js"
+	}
+}

package/prisma/schema.prisma

@@ -0,0 +1,22 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}

package/src/config.ts

@@ -0,0 +1,7 @@
+// Configuration
+export const PRISMA_SCHEMA_PATH = process.env.SUPARISMA_PRISMA_SCHEMA_PATH || 'prisma/schema.prisma';
+export const OUTPUT_DIR = process.env.SUPARISMA_OUTPUT_DIR || 'src/suparisma/generated';
+export const TYPES_DIR = `${OUTPUT_DIR}/types`;
+export const HOOKS_DIR = `${OUTPUT_DIR}/hooks`;
+export const UTILS_DIR = `${OUTPUT_DIR}/utils`;
+export const HOOK_NAME_PREFIX = 'useSuparisma';

package/src/generated/hooks/useSuparismaUser.ts

@@ -0,0 +1,77 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Edit the generator script instead: scripts/generate-realtime-hooks.ts
+
+import { createSuparismaHook } from '../utils/core';
+import type {
+  UserWithRelations,
+  UserCreateInput,
+  UserUpdateInput,
+  UserWhereInput,
+  UserWhereUniqueInput,
+  UserOrderByInput,
+  UserHookApi,
+  UseUserOptions
+} from '../types/UserTypes';
+
+/**
+ * A Prisma-like hook for interacting with User 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 User records
+ * 
+ * @example
+ * // Basic usage - get all User records with realtime updates
+ * const user = useSuparismaUser();
+ * const { data, loading, error } = user;
+ * 
+ * @example
+ * // With filtering and ordering
+ * const user = useSuparismaUser({
+ *   where: { active: true },
+ *   orderBy: { created_at: 'desc' },
+ *   limit: 10
+ * });
+ * 
+ * @example
+ * // Create a new record
+ * const result = await user.create({
+ *   name: "Example Name",
+ *   // other fields...
+ * });
+ * 
+ * @example
+ * // Update a record
+ * const result = await user.update({
+ *   where: { id: "123" },
+ *   data: { name: "Updated Name" }
+ * });
+ * 
+ * @example
+ * // Delete a record
+ * const result = await user.delete({ id: "123" });
+ * 
+ * @example
+ * // Find records with specific criteria
+ * const result = await user.findMany({
+ *   where: { // filters },
+ *   orderBy: { // ordering },
+ *   take: 20 // limit
+ * });
+ */
+export const useSuparismaUser = createSuparismaHook<
+  UserWithRelations,
+  UserWithRelations,
+  UserCreateInput,
+  UserUpdateInput,
+  UserWhereInput,
+  UserWhereUniqueInput,
+  UserOrderByInput
+>({
+  tableName: 'User',
+  hasCreatedAt: true,
+  hasUpdatedAt: true,
+  // Default values from schema
+  defaultValues: {"id":"uuid(","createdAt":"now("}
+}) as (options?: UseUserOptions) => UserHookApi;

package/src/generated/index.ts

@@ -0,0 +1,50 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Edit the generator script instead: scripts/generate-realtime-hooks.ts
+
+import { useSuparismaUser } from './hooks/useSuparismaUser';
+import type { UseUserOptions, UserHookApi } from './types/UserTypes';
+export type { SuparismaOptions, SearchQuery, SearchState, FilterOperators } from './utils/core';
+export type { UserWithRelations, UserCreateInput, UserUpdateInput, UserWhereInput, UserWhereUniqueInput, UserOrderByInput, UserHookApi, UseUserOptions } from './types/UserTypes';
+
+/**
+ * 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 {
+  user: (options?: UseUserOptions) => UserHookApi;
+}
+
+/**
+ * Main Suparisma hook object with dot notation access to all model hooks.
+ * 
+ * @example
+ * // Get hooks for different models
+ * import useSuparisma from './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 = {
+  user: useSuparismaUser,
+};
+
+export default useSuparisma;