@javalabs/prisma-client 1.0.16 → 1.0.19

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

@@ -1,146 +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();
-  }
-}
-
+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);