WIP - custom migrations when object is created

backend/src/migration/custom-migration.service.ts

@@ -0,0 +1,306 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Knex } from 'knex';
+
+export interface CustomMigrationRecord {
+  id: string;
+  tenantId: string;
+  name: string;
+  description: string;
+  type: 'create_table' | 'add_column' | 'alter_column' | 'add_index' | 'drop_table' | 'custom';
+  sql: string;
+  status: 'pending' | 'executed' | 'failed';
+  executedAt?: Date;
+  error?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+@Injectable()
+export class CustomMigrationService {
+  private readonly logger = new Logger(CustomMigrationService.name);
+
+  /**
+   * Generate SQL to create a table with standard fields
+   */
+  generateCreateTableSQL(
+    tableName: string,
+    fields: {
+      apiName: string;
+      type: string;
+      isRequired?: boolean;
+      isUnique?: boolean;
+      defaultValue?: string;
+    }[] = [],
+  ): string {
+    // Start with standard fields
+    const columns: string[] = [
+      '`id` VARCHAR(36) PRIMARY KEY',
+      '`ownerId` VARCHAR(36)',
+      '`name` VARCHAR(255)',
+      '`created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP',
+      '`updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP',
+    ];
+
+    // Add custom fields
+    for (const field of fields) {
+      const column = this.fieldToColumn(field);
+      columns.push(column);
+    }
+
+    // Add foreign key and index for ownerId
+    columns.push('INDEX `idx_owner` (`ownerId`)');
+
+    return `CREATE TABLE IF NOT EXISTS \`${tableName}\` (
+  ${columns.join(',\n  ')}
+)`;
+  }
+
+  /**
+   * Convert field definition to SQL column definition
+   */
+  private fieldToColumn(field: {
+    apiName: string;
+    type: string;
+    isRequired?: boolean;
+    isUnique?: boolean;
+    defaultValue?: string;
+  }): string {
+    const columnName = field.apiName;
+    let columnDef = `\`${columnName}\``;
+
+    // Map field types to SQL types
+    switch (field.type.toUpperCase()) {
+      case 'TEXT':
+      case 'STRING':
+        columnDef += ' VARCHAR(255)';
+        break;
+      case 'LONG_TEXT':
+        columnDef += ' LONGTEXT';
+        break;
+      case 'NUMBER':
+      case 'DECIMAL':
+        columnDef += ' DECIMAL(18, 2)';
+        break;
+      case 'INTEGER':
+        columnDef += ' INT';
+        break;
+      case 'BOOLEAN':
+        columnDef += ' BOOLEAN DEFAULT FALSE';
+        break;
+      case 'DATE':
+        columnDef += ' DATE';
+        break;
+      case 'DATE_TIME':
+        columnDef += ' DATETIME';
+        break;
+      case 'EMAIL':
+        columnDef += ' VARCHAR(255)';
+        break;
+      case 'URL':
+        columnDef += ' VARCHAR(2048)';
+        break;
+      case 'PHONE':
+        columnDef += ' VARCHAR(20)';
+        break;
+      case 'CURRENCY':
+        columnDef += ' DECIMAL(18, 2)';
+        break;
+      case 'PERCENT':
+        columnDef += ' DECIMAL(5, 2)';
+        break;
+      case 'PICKLIST':
+      case 'MULTI_PICKLIST':
+        columnDef += ' VARCHAR(255)';
+        break;
+      case 'LOOKUP':
+      case 'BELONGS_TO':
+        columnDef += ' VARCHAR(36)';
+        break;
+      default:
+        columnDef += ' VARCHAR(255)';
+    }
+
+    // Add constraints
+    if (field.isRequired) {
+      columnDef += ' NOT NULL';
+    } else {
+      columnDef += ' NULL';
+    }
+
+    if (field.isUnique) {
+      columnDef += ' UNIQUE';
+    }
+
+    if (field.defaultValue !== undefined && field.defaultValue !== null) {
+      columnDef += ` DEFAULT '${field.defaultValue}'`;
+    }
+
+    return columnDef;
+  }
+
+  /**
+   * Create a custom migration record in the database
+   */
+  async createMigrationRecord(
+    tenantKnex: Knex,
+    data: {
+      tenantId: string;
+      name: string;
+      description: string;
+      type: 'create_table' | 'add_column' | 'alter_column' | 'add_index' | 'drop_table' | 'custom';
+      sql: string;
+    },
+  ): Promise<CustomMigrationRecord> {
+    // Ensure custom_migrations table exists
+    await this.ensureMigrationsTable(tenantKnex);
+
+    const id = require('crypto').randomUUID();
+    const now = new Date();
+
+    await tenantKnex('custom_migrations').insert({
+      id,
+      tenantId: data.tenantId,
+      name: data.name,
+      description: data.description,
+      type: data.type,
+      sql: data.sql,
+      status: 'pending',
+      created_at: now,
+      updated_at: now,
+    });
+
+    return tenantKnex('custom_migrations').where({ id }).first();
+  }
+
+  /**
+   * Execute a pending migration and update its status
+   */
+  async executeMigration(
+    tenantKnex: Knex,
+    migrationId: string,
+  ): Promise<CustomMigrationRecord> {
+    try {
+      // Get the migration record
+      const migration = await tenantKnex('custom_migrations')
+        .where({ id: migrationId })
+        .first();
+
+      if (!migration) {
+        throw new Error(`Migration ${migrationId} not found`);
+      }
+
+      if (migration.status === 'executed') {
+        this.logger.log(`Migration ${migrationId} already executed`);
+        return migration;
+      }
+
+      // Execute the SQL
+      this.logger.log(`Executing migration: ${migration.name}`);
+      await tenantKnex.raw(migration.sql);
+
+      // Update status
+      const now = new Date();
+      await tenantKnex('custom_migrations')
+        .where({ id: migrationId })
+        .update({
+          status: 'executed',
+          executedAt: now,
+          updated_at: now,
+        });
+
+      this.logger.log(`Migration ${migration.name} executed successfully`);
+      return tenantKnex('custom_migrations').where({ id: migrationId }).first();
+    } catch (error) {
+      this.logger.error(`Failed to execute migration ${migrationId}:`, error);
+
+      // Update status with error
+      const now = new Date();
+      await tenantKnex('custom_migrations')
+        .where({ id: migrationId })
+        .update({
+          status: 'failed',
+          error: error.message,
+          updated_at: now,
+        });
+
+      throw error;
+    }
+  }
+
+  /**
+   * Create and execute a migration in one step
+   */
+  async createAndExecuteMigration(
+    tenantKnex: Knex,
+    tenantId: string,
+    data: {
+      name: string;
+      description: string;
+      type: 'create_table' | 'add_column' | 'alter_column' | 'add_index' | 'drop_table' | 'custom';
+      sql: string;
+    },
+  ): Promise<CustomMigrationRecord> {
+    // Create the migration record
+    const migration = await this.createMigrationRecord(tenantKnex, {
+      tenantId,
+      ...data,
+    });
+
+    // Execute it immediately
+    return this.executeMigration(tenantKnex, migration.id);
+  }
+
+  /**
+   * Ensure the custom_migrations table exists in the tenant database
+   */
+  private async ensureMigrationsTable(tenantKnex: Knex): Promise<void> {
+    const hasTable = await tenantKnex.schema.hasTable('custom_migrations');
+
+    if (!hasTable) {
+      await tenantKnex.schema.createTable('custom_migrations', (table) => {
+        table.uuid('id').primary();
+        table.uuid('tenantId').notNullable();
+        table.string('name', 255).notNullable();
+        table.text('description');
+        table.enum('type', ['create_table', 'add_column', 'alter_column', 'add_index', 'drop_table', 'custom']).notNullable();
+        table.text('sql').notNullable();
+        table.enum('status', ['pending', 'executed', 'failed']).defaultTo('pending');
+        table.timestamp('executedAt').nullable();
+        table.text('error').nullable();
+        table.timestamps(true, true);
+
+        table.index(['tenantId']);
+        table.index(['status']);
+        table.index(['created_at']);
+      });
+
+      this.logger.log('Created custom_migrations table');
+    }
+  }
+
+  /**
+   * Get all migrations for a tenant
+   */
+  async getMigrations(
+    tenantKnex: Knex,
+    tenantId: string,
+    filter?: {
+      status?: 'pending' | 'executed' | 'failed';
+      type?: string;
+    },
+  ): Promise<CustomMigrationRecord[]> {
+    await this.ensureMigrationsTable(tenantKnex);
+
+    let query = tenantKnex('custom_migrations').where({ tenantId });
+
+    if (filter?.status) {
+      query = query.where({ status: filter.status });
+    }
+
+    if (filter?.type) {
+      query = query.where({ type: filter.type });
+    }
+
+    return query.orderBy('created_at', 'asc');
+  }
+}

backend/src/migration/migration.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { CustomMigrationService } from './custom-migration.service';
+import { TenantModule } from '../tenant/tenant.module';
+
+@Module({
+  imports: [TenantModule],
+  providers: [CustomMigrationService],
+  exports: [CustomMigrationService],
+})
+export class MigrationModule {}

backend/src/object/object.module.ts

@@ -5,9 +5,10 @@ import { SetupObjectController } from './setup-object.controller';
 import { SchemaManagementService } from './schema-management.service';
 import { FieldMapperService } from './field-mapper.service';
 import { TenantModule } from '../tenant/tenant.module';
+import { MigrationModule } from '../migration/migration.module';
 
 @Module({
-  imports: [TenantModule],
+  imports: [TenantModule, MigrationModule],
   providers: [ObjectService, SchemaManagementService, FieldMapperService],
   controllers: [RuntimeObjectController, SetupObjectController],
   exports: [ObjectService, SchemaManagementService, FieldMapperService],

backend/src/object/object.service.ts

@@ -1,13 +1,18 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { TenantDatabaseService } from '../tenant/tenant-database.service';
+import { CustomMigrationService } from '../migration/custom-migration.service';
 
 @Injectable()
 export class ObjectService {
-  constructor(private tenantDbService: TenantDatabaseService) {}
+  constructor(
+    private tenantDbService: TenantDatabaseService,
+    private customMigrationService: CustomMigrationService,
+  ) {}
 
   // Setup endpoints - Object metadata management
   async getObjectDefinitions(tenantId: string) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     
     const objects = await knex('object_definitions')
       .select('object_definitions.*')
@@ -28,7 +33,8 @@ export class ObjectService {
   }
 
   async getObjectDefinition(tenantId: string, apiName: string) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     
     const obj = await knex('object_definitions')
       .where({ apiName })
@@ -69,15 +75,104 @@ export class ObjectService {
       isSystem?: boolean;
     },
   ) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
-    const [id] = await knex('object_definitions').insert({
-      id: knex.raw('(UUID())'),
+    // Resolve tenant ID in case a slug was passed
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
+    
+    // Generate UUID for the new object
+    const objectId = require('crypto').randomUUID();
+    
+    // Create the object definition record
+    await knex('object_definitions').insert({
+      id: objectId,
       ...data,
       created_at: knex.fn.now(),
       updated_at: knex.fn.now(),
     });
     
-    return knex('object_definitions').where({ id }).first();
+    const objectDef = await knex('object_definitions').where({ id: objectId }).first();
+    
+    // Create standard field definitions (only if they don't already exist)
+    const standardFields = [
+      {
+        apiName: 'ownerId',
+        label: 'Owner',
+        type: 'LOOKUP',
+        description: 'The user who owns this record',
+        isRequired: true,
+        isUnique: false,
+        referenceObject: null,
+      },
+      {
+        apiName: 'name',
+        label: 'Name',
+        type: 'TEXT',
+        description: 'The primary name field for this record',
+        isRequired: true,
+        isUnique: false,
+        referenceObject: null,
+      },
+      {
+        apiName: 'created_at',
+        label: 'Created At',
+        type: 'DATE_TIME',
+        description: 'The timestamp when this record was created',
+        isRequired: true,
+        isUnique: false,
+        referenceObject: null,
+      },
+      {
+        apiName: 'updated_at',
+        label: 'Updated At',
+        type: 'DATE_TIME',
+        description: 'The timestamp when this record was last updated',
+        isRequired: true,
+        isUnique: false,
+        referenceObject: null,
+      },
+    ];
+
+    // Insert standard field definitions that don't already exist
+    for (const field of standardFields) {
+      const existingField = await knex('field_definitions')
+        .where({
+          objectDefinitionId: objectDef.id,
+          apiName: field.apiName,
+        })
+        .first();
+
+      if (!existingField) {
+        await knex('field_definitions').insert({
+          id: knex.raw('(UUID())'),
+          objectDefinitionId: objectDef.id,
+          ...field,
+          created_at: knex.fn.now(),
+          updated_at: knex.fn.now(),
+        });
+      }
+    }
+    
+    // Create a migration to create the table
+    const tableName = this.getTableName(data.apiName);
+    const createTableSQL = this.customMigrationService.generateCreateTableSQL(tableName);
+    
+    try {
+      await this.customMigrationService.createAndExecuteMigration(
+        knex,
+        resolvedTenantId,
+        {
+          name: `create_${tableName}_table`,
+          description: `Create table for ${data.label} object`,
+          type: 'create_table',
+          sql: createTableSQL,
+        },
+      );
+    } catch (error) {
+      // Log the error but don't fail - migration is recorded for future retry
+      console.error(`Failed to execute table creation migration: ${error.message}`);
+    }
+    
+    return objectDef;
   }
 
   async createFieldDefinition(
@@ -94,7 +189,8 @@ export class ObjectService {
       defaultValue?: string;
     },
   ) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     const obj = await this.getObjectDefinition(tenantId, objectApiName);
 
     const [id] = await knex('field_definitions').insert({
@@ -134,7 +230,8 @@ export class ObjectService {
     userId: string,
     filters?: any,
   ) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     
     // Verify object exists
     await this.getObjectDefinition(tenantId, objectApiName);
@@ -163,7 +260,8 @@ export class ObjectService {
     recordId: string,
     userId: string,
   ) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     
     // Verify object exists
     await this.getObjectDefinition(tenantId, objectApiName);
@@ -193,7 +291,8 @@ export class ObjectService {
     data: any,
     userId: string,
   ) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     
     // Verify object exists
     await this.getObjectDefinition(tenantId, objectApiName);
@@ -226,7 +325,8 @@ export class ObjectService {
     data: any,
     userId: string,
   ) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     
     // Verify object exists and user has access
     await this.getRecord(tenantId, objectApiName, recordId, userId);
@@ -246,7 +346,8 @@ export class ObjectService {
     recordId: string,
     userId: string,
   ) {
-    const knex = await this.tenantDbService.getTenantKnex(tenantId);
+    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
+    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
     
     // Verify object exists and user has access
     await this.getRecord(tenantId, objectApiName, recordId, userId);

backend/src/tenant/tenant-database.service.ts

@@ -169,6 +169,36 @@ export class TenantDatabaseService {
     return domainRecord.tenant;
   }
 
+  /**
+   * Resolve tenant by ID or slug
+   * Tries ID first, then falls back to slug
+   */
+  async resolveTenantId(idOrSlug: string): Promise<string> {
+    const centralPrisma = getCentralPrisma();
+    
+    // Try by ID first
+    let tenant = await centralPrisma.tenant.findUnique({
+      where: { id: idOrSlug },
+    });
+
+    // If not found, try by slug
+    if (!tenant) {
+      tenant = await centralPrisma.tenant.findUnique({
+        where: { slug: idOrSlug },
+      });
+    }
+
+    if (!tenant) {
+      throw new Error(`Tenant ${idOrSlug} not found`);
+    }
+
+    if (tenant.status !== 'active') {
+      throw new Error(`Tenant ${tenant.name} is not active`);
+    }
+
+    return tenant.id;
+  }
+
   async disconnectTenant(tenantId: string) {
     const connection = this.tenantConnections.get(tenantId);
     if (connection) {