suparisma 0.0.1 → 0.0.3

package/src/index.ts

@@ -1,339 +0,0 @@
-#!/usr/bin/env node
-import fs from 'fs';
-import path from 'path';
-import * as dotenv from 'dotenv';
-dotenv.config();
-
-// Import configuration
-import { PRISMA_SCHEMA_PATH, OUTPUT_DIR, TYPES_DIR, HOOKS_DIR, UTILS_DIR } from './config';
-
-// Import type definitions
-import { ProcessedModelInfo } from './types';
-
-// Import parsers and generators
-import { parsePrismaSchema } from './parser';
-import { generateCoreFile } from './generators/coreGenerator';
-import { generateModelTypesFile } from './generators/typeGenerator';
-import { generateModelHookFile } from './generators/hookGenerator';
-import { generateMainIndexFile } from './generators/indexGenerator';
-import { generateSupabaseClientFile } from './generators/supabaseClientGenerator';
-
-/**
- * Checks for essential environment variables and throws an error if any are missing.
- */
-function checkEnvironmentVariables() {
-  const requiredEnvVars = [
-    'DATABASE_URL',
-    'NEXT_PUBLIC_SUPABASE_URL',
-    'NEXT_PUBLIC_SUPABASE_ANON_KEY',
-  ];
-  const missingVars = requiredEnvVars.filter(varName => !process.env[varName]);
-
-  if (missingVars.length > 0) {
-    let errorMessage = 'Error: Missing required environment variables:\n';
-    missingVars.forEach(varName => {
-      errorMessage += `- ${varName}: This variable is essential for the generator to function correctly. `;      
-      if (varName === 'DATABASE_URL') {
-        errorMessage += 'It is used by Prisma to connect to your database. Please ensure it is set in your .env file or as an environment variable (e.g., postgresql://user:password@host:port/database).\n';
-      } else if (varName === 'NEXT_PUBLIC_SUPABASE_URL') {
-        errorMessage += 'This is your Supabase project URL. It is required by the Supabase client. Please set it in your .env file or as an environment variable (e.g., https://your-project-id.supabase.co).\n';
-      } else if (varName === 'NEXT_PUBLIC_SUPABASE_ANON_KEY') {
-        errorMessage += 'This is your Supabase project public anonymous key. It is required by the Supabase client. Please set it in your .env file or as an environment variable.\n';
-      }
-    });
-    errorMessage += '\nPlease add these variables to your .env file or ensure they are available in your environment and try again.';
-    throw new Error(errorMessage);
-  }
-  console.log('✅ All required environment variables are set.');
-}
-
-/**
- * Extracts comments from a Prisma schema
- * Looks for // @enableRealtime and // @enableSearch
- */
-interface ModelInfo {
-  name: string;
-  tableName: string;
-  enableRealtime: boolean;
-  searchFields: Array<{
-    name: string;
-    type: string;
-  }>;
-}
-
-function analyzePrismaSchema(schemaPath: string): ModelInfo[] {
-  try {
-    const schemaContent = fs.readFileSync(schemaPath, 'utf8');
-    const modelInfos: ModelInfo[] = [];
-
-    // 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: Array<{ name: string; type: string }> = [];
-      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: string) {
-  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 import('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: any) => 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: any) => 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: any) {
-            // 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: any) {
-              console.error(
-                `❌ Failed to set up search for "${actualTableName}.${actualColumnName}": ${err.message}`
-              );
-            }
-          }
-        }
-      } catch (err: any) {
-        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('🚀 Starting Suparisma hook generation...');
-    
-    // Check for required environment variables first
-    checkEnvironmentVariables();
-
-    console.log(`Prisma schema path: ${PRISMA_SCHEMA_PATH}`);
-    console.log(`Output directory: ${OUTPUT_DIR}`);
-
-    // Ensure output directories exist
-    [OUTPUT_DIR, TYPES_DIR, HOOKS_DIR, UTILS_DIR].forEach(dir => {
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-    });
-
-    // Generate Supabase client file first
-    generateSupabaseClientFile();
-
-    // First, generate the core hook factory
-    generateCoreFile();
-
-    // Parse models from Prisma schema
-    const models = parsePrismaSchema(PRISMA_SCHEMA_PATH);
-
-    // Configure database tables for real-time and search functionality
-    await configurePrismaTablesForSuparisma(PRISMA_SCHEMA_PATH);
-
-    // Generate type definitions and hooks for each model
-    const modelInfos: ProcessedModelInfo[] = [];
-    for (const model of models) {
-      const modelInfo = generateModelTypesFile(model);
-      generateModelHookFile(modelInfo);
-      modelInfos.push(modelInfo);
-    }
-
-    // Generate the main module file
-    generateMainIndexFile(modelInfos);
-
-    console.log(`✅ Successfully generated all suparisma hooks and types in "${OUTPUT_DIR}"!`);
-  } catch (error) {
-    console.error('❌ Error generating hooks:', error);
-    process.exit(1);
-  }
-}
-
-// Execute main function
-main();

package/src/parser.ts

@@ -1,134 +0,0 @@
-import fs from 'fs';
-import { ModelInfo, FieldInfo, SearchFieldInfo } from './types';
-
-/**
- * Parse Prisma schema to extract model information including search annotations
- */
-export function parsePrismaSchema(schemaPath: string): ModelInfo[] {
-  const schema = fs.readFileSync(schemaPath, 'utf-8');
-  const modelRegex = /model\s+(\w+)\s+{([^}]*)}/gs;
-  const models: ModelInfo[] = [];
-
-  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: FieldInfo[] = [];
-    // Track fields with @enableSearch annotation
-    const searchFields: SearchFieldInfo[] = [];
-
-    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;
-}