@javalabs/prisma-client 1.0.0

package/src/scripts/create-tenant-schemas.ts

@@ -0,0 +1,146 @@
+import { PrismaClient } from '@prisma/client';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+async function createTenantSchemas() {
+  // Crear cliente para la base de datos de origen
+  const sourcePrisma = new PrismaClient({
+    datasources: {
+      db: {
+        url: process.env.SOURCE_DATABASE_URL,
+      },
+    },
+  });
+  
+  // Crear cliente para la base de datos de destino
+  const targetPrisma = new PrismaClient({
+    datasources: {
+      db: {
+        url: process.env.DATABASE_URL,
+      },
+    },
+  });
+  
+  try {
+    console.log('Fetching API keys from source database to create tenant schemas...');
+    
+    // Obtener todos los api_keys existentes de la base de datos de origen
+    const apiKeys = await sourcePrisma.api_keys.findMany({
+      select: {
+        api_key: true,
+        providers: {
+          select: {
+            name: true,
+          },
+        },
+      },
+    });
+    
+    console.log(`Found ${apiKeys.length} API keys to create schemas for.`);
+    
+    // Crear un archivo SQL para ejecutar las migraciones
+    const sqlCommands: string[] = [];
+    
+    // Añadir comando para asegurar que el schema public existe
+    sqlCommands.push('CREATE SCHEMA IF NOT EXISTS public;');
+    
+    // Para cada API key, crear un schema y migrar la estructura
+    for (const apiKey of apiKeys) {
+      const schemaName = apiKey.api_key;
+      const providerName = apiKey.providers?.name || 'unknown';
+      
+      console.log(`Creating schema for ${providerName} with key ${schemaName}`);
+      
+      // Crear el schema si no existe
+      sqlCommands.push(`CREATE SCHEMA IF NOT EXISTS "${schemaName}";`);
+      
+      // También crear el API key en la base de datos de destino si no existe
+      try {
+        const existingApiKey = await targetPrisma.api_keys.findUnique({
+          where: { api_key: schemaName },
+        });
+        
+        if (!existingApiKey) {
+          console.log(`Creating API key record in target database for ${schemaName}`);
+          
+          // Obtener el registro completo de la base de datos de origen
+          const sourceApiKeyFull = await sourcePrisma.api_keys.findUnique({
+            where: { api_key: schemaName },
+            include: {
+              providers: true,
+              users: true,
+            },
+          });
+          
+          if (sourceApiKeyFull) {
+            // Primero asegurarse de que el provider existe
+            let providerId = null;
+            if (sourceApiKeyFull.provider_id) {
+              const existingProvider = await targetPrisma.providers.findUnique({
+                where: { provider_id: sourceApiKeyFull.provider_id },
+              });
+              
+              if (!existingProvider && sourceApiKeyFull.providers) {
+                // Crear el provider si no existe
+                const newProvider = await targetPrisma.providers.create({
+                  data: {
+                    provider_id: sourceApiKeyFull.providers.provider_id,
+                    name: sourceApiKeyFull.providers.name,
+                    api_key: sourceApiKeyFull.providers.api_key,
+                    country_id: sourceApiKeyFull.providers.country_id,
+                    contact_email: sourceApiKeyFull.providers.contact_email,
+                    is_active: sourceApiKeyFull.providers.is_active,
+                    agreement: sourceApiKeyFull.providers.agreement,
+                    image: sourceApiKeyFull.providers.image,
+                  },
+                });
+                providerId = newProvider.provider_id;
+              } else if (existingProvider) {
+                providerId = existingProvider.provider_id;
+              }
+            }
+            
+            // Crear el API key en la base de datos de destino
+            await targetPrisma.api_keys.create({
+              data: {
+                api_key: sourceApiKeyFull.api_key,
+                name: sourceApiKeyFull.name,
+                is_active: sourceApiKeyFull.is_active,
+                user_id: sourceApiKeyFull.user_id,
+                provider_id: providerId,
+              },
+            });
+          }
+        }
+      } catch (error) {
+        console.error(`Error creating API key in target database for ${schemaName}:`, error);
+      }
+    }
+    
+    // Ensure the directory exists
+    const migrationsDir = path.join(__dirname, '../../../prisma/migrations');
+    if (!fs.existsSync(migrationsDir)) {
+      console.log(`Creating migrations directory: ${migrationsDir}`);
+      fs.mkdirSync(migrationsDir, { recursive: true });
+    }
+    
+    // Save SQL commands to file with absolute path for clarity
+    const sqlFilePath = path.join(migrationsDir, 'tenant-schemas.sql');
+    fs.writeFileSync(sqlFilePath, sqlCommands.join('\n'));
+    
+    // Log the absolute path for debugging
+    console.log(`SQL commands written to ${path.resolve(sqlFilePath)}`);
+    console.log('Run this SQL file against your database to create the schemas.');
+    
+  } catch (error) {
+    console.error('Error creating tenant schemas:', error);
+  } finally {
+    await sourcePrisma.$disconnect();
+    await targetPrisma.$disconnect();
+  }
+}
+
+createTenantSchemas().catch(console.error);