WIP - using objection base model to handle objects operations

backend/src/object/models/base.model.ts

@@ -0,0 +1,35 @@
+import { Model } from 'objection';
+
+/**
+ * Base model for all dynamic and system models
+ * Provides common functionality for all objects
+ */
+export class BaseModel extends Model {
+  // Common fields
+  id?: string;
+  tenantId?: string;
+  ownerId?: string;
+  name?: string;
+  created_at?: Date;
+  updated_at?: Date;
+
+  // Hook to set system-managed fields
+  $beforeInsert() {
+    // created_at and updated_at are handled by the database
+    // ownerId should be set by the controller/service
+  }
+
+  $beforeUpdate() {
+    // updated_at is handled by the database
+  }
+
+
+
+  /**
+   * Get the API name for this object
+   * Override in subclasses
+   */
+  static get objectApiName(): string {
+    return 'BaseModel';
+  }
+}

backend/src/object/models/dynamic-model.factory.ts

@@ -0,0 +1,162 @@
+import { randomUUID } from 'crypto';
+import { ModelClass, JSONSchema, RelationMappings, Model } from 'objection';
+import { BaseModel } from './base.model';
+
+export interface FieldDefinition {
+  apiName: string;
+  label: string;
+  type: string;
+  isRequired?: boolean;
+  isUnique?: boolean;
+  referenceObject?: string;
+  defaultValue?: string;
+}
+
+export interface RelationDefinition {
+  name: string;
+  type: 'belongsTo' | 'hasMany' | 'hasManyThrough';
+  targetObjectApiName: string;
+  fromColumn: string;
+  toColumn: string;
+}
+
+export interface ObjectMetadata {
+  apiName: string;
+  tableName: string;
+  fields: FieldDefinition[];
+  relations?: RelationDefinition[];
+}
+
+export class DynamicModelFactory {
+  /**
+   * Create a dynamic model class from object metadata
+   */
+  static createModel(meta: ObjectMetadata): ModelClass<any> {
+    const { tableName, fields, apiName, relations = [] } = meta;
+
+    // Build JSON schema properties
+    const properties: Record<string, any> = {
+      id: { type: 'string' },
+      tenantId: { type: 'string' },
+      ownerId: { type: 'string' },
+      name: { type: 'string' },
+      created_at: { type: 'string', format: 'date-time' },
+      updated_at: { type: 'string', format: 'date-time' },
+    };
+
+    const required: string[] = ['id', 'tenantId'];
+
+    // Add custom fields
+    for (const field of fields) {
+      properties[field.apiName] = this.fieldToJsonSchema(field);
+
+      // Only mark as required if explicitly required AND not a system field
+      const systemFields = ['id', 'tenantId', 'ownerId', 'name', 'created_at', 'updated_at'];
+      if (field.isRequired && !systemFields.includes(field.apiName)) {
+        required.push(field.apiName);
+      }
+    }
+
+    // Build relation mappings
+    const relationMappings: RelationMappings = {};
+    for (const rel of relations) {
+      // Relations are resolved dynamically, skipping for now
+      // Will be handled by ModelRegistry.getModel()
+    }
+
+    // Create the dynamic model class extending Model directly
+    class DynamicModel extends Model {
+      id?: string;
+      tenantId?: string;
+      ownerId?: string;
+      name?: string;
+      created_at?: string;
+      updated_at?: string;
+
+      static tableName = tableName;
+
+      static objectApiName = apiName;
+
+      static relationMappings = relationMappings;
+
+      static get jsonSchema() {
+        return {
+          type: 'object',
+          required,
+          properties,
+        };
+      }
+
+      async $beforeInsert() {
+        if (!this.id) {
+          this.id = randomUUID();
+        }
+        if (!this.created_at) {
+          this.created_at = new Date().toISOString();
+        }
+        if (!this.updated_at) {
+          this.updated_at = new Date().toISOString();
+        }
+      }
+
+      async $beforeUpdate() {
+        this.updated_at = new Date().toISOString();
+      }
+    }
+
+    return DynamicModel as any;
+  }
+
+  /**
+   * Convert a field definition to JSON schema property
+   */
+  private static fieldToJsonSchema(field: FieldDefinition): Record<string, any> {
+    switch (field.type.toUpperCase()) {
+      case 'TEXT':
+      case 'STRING':
+      case 'EMAIL':
+      case 'URL':
+      case 'PHONE':
+      case 'PICKLIST':
+      case 'MULTI_PICKLIST':
+        return {
+          type: 'string',
+          ...(field.isUnique && { uniqueItems: true }),
+        };
+
+      case 'LONG_TEXT':
+        return { type: 'string' };
+
+      case 'NUMBER':
+      case 'DECIMAL':
+      case 'CURRENCY':
+      case 'PERCENT':
+        return {
+          type: 'number',
+          ...(field.isUnique && { uniqueItems: true }),
+        };
+
+      case 'INTEGER':
+        return {
+          type: 'integer',
+          ...(field.isUnique && { uniqueItems: true }),
+        };
+
+      case 'BOOLEAN':
+        return { type: 'boolean', default: false };
+
+      case 'DATE':
+        return { type: 'string', format: 'date' };
+
+      case 'DATE_TIME':
+        return { type: 'string', format: 'date-time' };
+
+      case 'LOOKUP':
+      case 'BELONGS_TO':
+        return { type: 'string' };
+
+      default:
+        return { type: 'string' };
+    }
+  }
+}

backend/src/object/models/model.registry.ts

@@ -0,0 +1,63 @@
+import { Injectable } from '@nestjs/common';
+import { ModelClass } from 'objection';
+import { BaseModel } from './base.model';
+import { DynamicModelFactory, ObjectMetadata } from './dynamic-model.factory';
+
+/**
+ * Registry to store and retrieve dynamic models
+ * One registry per tenant
+ */
+@Injectable()
+export class ModelRegistry {
+  private registry = new Map<string, ModelClass<BaseModel>>();
+
+  /**
+   * Register a model in the registry
+   */
+  registerModel(apiName: string, modelClass: ModelClass<BaseModel>): void {
+    this.registry.set(apiName, modelClass);
+  }
+
+  /**
+   * Get a model from the registry
+   */
+  getModel(apiName: string): ModelClass<BaseModel> {
+    const model = this.registry.get(apiName);
+    if (!model) {
+      throw new Error(`Model for ${apiName} not found in registry`);
+    }
+    return model;
+  }
+
+  /**
+   * Check if a model exists in the registry
+   */
+  hasModel(apiName: string): boolean {
+    return this.registry.has(apiName);
+  }
+
+  /**
+   * Create and register a model from metadata
+   */
+  createAndRegisterModel(
+    metadata: ObjectMetadata,
+  ): ModelClass<BaseModel> {
+    const model = DynamicModelFactory.createModel(metadata);
+    this.registerModel(metadata.apiName, model);
+    return model;
+  }
+
+  /**
+   * Get all registered model names
+   */
+  getAllModelNames(): string[] {
+    return Array.from(this.registry.keys());
+  }
+
+  /**
+   * Clear the registry (useful for testing)
+   */
+  clear(): void {
+    this.registry.clear();
+  }
+}

backend/src/object/models/model.service.ts

@@ -0,0 +1,81 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Knex } from 'knex';
+import { ModelClass } from 'objection';
+import { BaseModel } from './base.model';
+import { ModelRegistry } from './model.registry';
+import { ObjectMetadata } from './dynamic-model.factory';
+import { TenantDatabaseService } from '../../tenant/tenant-database.service';
+
+/**
+ * Service to manage dynamic models for a specific tenant
+ */
+@Injectable()
+export class ModelService {
+  private readonly logger = new Logger(ModelService.name);
+  private tenantRegistries = new Map<string, ModelRegistry>();
+
+  constructor(private tenantDbService: TenantDatabaseService) {}
+
+  /**
+   * Get or create a registry for a tenant
+   */
+  getTenantRegistry(tenantId: string): ModelRegistry {
+    if (!this.tenantRegistries.has(tenantId)) {
+      this.tenantRegistries.set(tenantId, new ModelRegistry());
+    }
+    return this.tenantRegistries.get(tenantId)!;
+  }
+
+  /**
+   * Create and register a model for a tenant
+   */
+  async createModelForObject(
+    tenantId: string,
+    objectMetadata: ObjectMetadata,
+  ): Promise<ModelClass<BaseModel>> {
+    const registry = this.getTenantRegistry(tenantId);
+    const model = registry.createAndRegisterModel(objectMetadata);
+
+    this.logger.log(
+      `Registered model for ${objectMetadata.apiName} in tenant ${tenantId}`,
+    );
+
+    return model;
+  }
+
+  /**
+   * Get a model for a tenant and object
+   */
+  getModel(tenantId: string, objectApiName: string): ModelClass<BaseModel> {
+    const registry = this.getTenantRegistry(tenantId);
+    return registry.getModel(objectApiName);
+  }
+
+  /**
+   * Get a bound model (with knex connection) for a tenant and object
+   */
+  async getBoundModel(
+    tenantId: string,
+    objectApiName: string,
+  ): Promise<ModelClass<BaseModel>> {
+    const knex = await this.tenantDbService.getTenantKnexById(tenantId);
+    const model = this.getModel(tenantId, objectApiName);
+    return model.bindKnex(knex);
+  }
+
+  /**
+   * Check if a model exists for a tenant
+   */
+  hasModel(tenantId: string, objectApiName: string): boolean {
+    const registry = this.getTenantRegistry(tenantId);
+    return registry.hasModel(objectApiName);
+  }
+
+  /**
+   * Get all model names for a tenant
+   */
+  getAllModelNames(tenantId: string): string[] {
+    const registry = this.getTenantRegistry(tenantId);
+    return registry.getAllModelNames();
+  }
+}

backend/src/object/object.module.ts

@@ -6,11 +6,19 @@ import { SchemaManagementService } from './schema-management.service';
 import { FieldMapperService } from './field-mapper.service';
 import { TenantModule } from '../tenant/tenant.module';
 import { MigrationModule } from '../migration/migration.module';
+import { ModelRegistry } from './models/model.registry';
+import { ModelService } from './models/model.service';
 
 @Module({
   imports: [TenantModule, MigrationModule],
-  providers: [ObjectService, SchemaManagementService, FieldMapperService],
+  providers: [
+    ObjectService,
+    SchemaManagementService,
+    FieldMapperService,
+    ModelRegistry,
+    ModelService,
+  ],
   controllers: [RuntimeObjectController, SetupObjectController],
-  exports: [ObjectService, SchemaManagementService, FieldMapperService],
+  exports: [ObjectService, SchemaManagementService, FieldMapperService, ModelService],
 })
 export class ObjectModule {}

backend/src/object/object.service.ts

@@ -1,12 +1,15 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { TenantDatabaseService } from '../tenant/tenant-database.service';
 import { CustomMigrationService } from '../migration/custom-migration.service';
+import { ModelService } from './models/model.service';
+import { ObjectMetadata } from './models/dynamic-model.factory';
 
 @Injectable()
 export class ObjectService {
   constructor(
     private tenantDbService: TenantDatabaseService,
     private customMigrationService: CustomMigrationService,
+    private modelService: ModelService,
   ) {}
 
   // Setup endpoints - Object metadata management
@@ -49,6 +52,9 @@ export class ObjectService {
       .where({ objectDefinitionId: obj.id })
       .orderBy('label', 'asc');
 
+    // Normalize all fields to ensure system fields are properly marked
+    const normalizedFields = fields.map((field: any) => this.normalizeField(field));
+
     // Get app information if object belongs to an app
     let app = null;
     if (obj.app_id) {
@@ -60,7 +66,7 @@ export class ObjectService {
 
     return {
       ...obj,
-      fields,
+      fields: normalizedFields,
       app,
     };
   }
@@ -99,36 +105,44 @@ export class ObjectService {
         label: 'Owner',
         type: 'LOOKUP',
         description: 'The user who owns this record',
-        isRequired: true,
+        isRequired: false,  // Auto-set by system
         isUnique: false,
         referenceObject: null,
+        isSystem: true,
+        isCustom: false,
       },
       {
         apiName: 'name',
         label: 'Name',
         type: 'TEXT',
         description: 'The primary name field for this record',
-        isRequired: true,
+        isRequired: false,  // Optional field
         isUnique: false,
         referenceObject: null,
+        isSystem: false,
+        isCustom: false,
       },
       {
         apiName: 'created_at',
         label: 'Created At',
         type: 'DATE_TIME',
         description: 'The timestamp when this record was created',
-        isRequired: true,
+        isRequired: false,  // Auto-set by system
         isUnique: false,
         referenceObject: null,
+        isSystem: true,
+        isCustom: false,
       },
       {
         apiName: 'updated_at',
         label: 'Updated At',
         type: 'DATE_TIME',
         description: 'The timestamp when this record was last updated',
-        isRequired: true,
+        isRequired: false,  // Auto-set by system
         isUnique: false,
         referenceObject: null,
+        isSystem: true,
+        isCustom: false,
       },
     ];
 
@@ -171,10 +185,36 @@ export class ObjectService {
       // Log the error but don't fail - migration is recorded for future retry
       console.error(`Failed to execute table creation migration: ${error.message}`);
     }
+
+    // Create and register the Objection model for this object
+    try {
+      const allFields = await knex('field_definitions')
+        .where({ objectDefinitionId: objectDef.id })
+        .select('apiName', 'label', 'type', 'isRequired', 'isUnique', 'referenceObject');
+
+      const objectMetadata: ObjectMetadata = {
+        apiName: data.apiName,
+        tableName,
+        fields: allFields.map((f: any) => ({
+          apiName: f.apiName,
+          label: f.label,
+          type: f.type,
+          isRequired: f.isRequired,
+          isUnique: f.isUnique,
+          referenceObject: f.referenceObject,
+        })),
+        relations: [],
+      };
+
+      await this.modelService.createModelForObject(resolvedTenantId, objectMetadata);
+    } catch (error) {
+      console.error(`Failed to create model for object ${data.apiName}:`, error.message);
+    }
     
     return objectDef;
   }
 
+
   async createFieldDefinition(
     tenantId: string,
     objectApiName: string,
@@ -223,6 +263,22 @@ export class ObjectService {
     }
   }
 
+  /**
+   * Normalize field definition to ensure system fields are properly marked
+   */
+  private normalizeField(field: any): any {
+    const systemFieldNames = ['id', 'tenantId', 'ownerId', 'created_at', 'updated_at', 'createdAt', 'updatedAt'];
+    const isSystemField = systemFieldNames.includes(field.apiName);
+    
+    return {
+      ...field,
+      // Ensure system fields are marked correctly
+      isSystem: isSystemField ? true : field.isSystem,
+      isRequired: isSystemField ? false : field.isRequired,
+      isCustom: isSystemField ? false : field.isCustom ?? true,
+    };
+  }
+
   // Runtime endpoints - CRUD operations
   async getRecords(
     tenantId: string,
@@ -238,9 +294,33 @@ export class ObjectService {
     
     const tableName = this.getTableName(objectApiName);
     
+    // Try to use the Objection model if available
+    try {
+      const Model = this.modelService.getModel(resolvedTenantId, objectApiName);
+      if (Model) {
+        const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
+        let query = boundModel.query();
+        
+        // Add ownership filter if ownerId field exists
+        const hasOwner = await knex.schema.hasColumn(tableName, 'ownerId');
+        if (hasOwner) {
+          query = query.where({ ownerId: userId });
+        }
+        
+        // Apply additional filters
+        if (filters) {
+          query = query.where(filters);
+        }
+        
+        return query.select('*');
+      }
+    } catch (error) {
+      console.warn(`Could not use Objection model for ${objectApiName}:`, error.message);
+    }
+    
+    // Fallback to raw Knex
     let query = knex(tableName);
     
-    // Add ownership filter if ownerId field exists
     const hasOwner = await knex.schema.hasColumn(tableName, 'ownerId');
     if (hasOwner) {
       query = query.where({ ownerId: userId });
@@ -268,9 +348,32 @@ export class ObjectService {
     
     const tableName = this.getTableName(objectApiName);
     
+    // Try to use the Objection model if available
+    try {
+      const Model = this.modelService.getModel(resolvedTenantId, objectApiName);
+      if (Model) {
+        const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
+        let query = boundModel.query().where({ id: recordId });
+        
+        // Add ownership filter if ownerId field exists
+        const hasOwner = await knex.schema.hasColumn(tableName, 'ownerId');
+        if (hasOwner) {
+          query = query.where({ ownerId: userId });
+        }
+        
+        const record = await query.first();
+        if (!record) {
+          throw new NotFoundException('Record not found');
+        }
+        return record;
+      }
+    } catch (error) {
+      console.warn(`Could not use Objection model for ${objectApiName}:`, error.message);
+    }
+    
+    // Fallback to raw Knex
     let query = knex(tableName).where({ id: recordId });
     
-    // Add ownership filter if ownerId field exists
     const hasOwner = await knex.schema.hasColumn(tableName, 'ownerId');
     if (hasOwner) {
       query = query.where({ ownerId: userId });
@@ -297,9 +400,24 @@ export class ObjectService {
     // Verify object exists
     await this.getObjectDefinition(tenantId, objectApiName);
     
-    const tableName = this.getTableName(objectApiName);
+    // Try to use the Objection model if available
+    try {
+      const Model = this.modelService.getModel(resolvedTenantId, objectApiName);
+      if (Model) {
+        const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
+        const recordData = {
+          ...data,
+          ownerId: userId, // Auto-set owner
+        };
+        const record = await boundModel.query().insert(recordData);
+        return record;
+      }
+    } catch (error) {
+      console.warn(`Could not use Objection model for ${objectApiName}:`, error.message);
+    }
     
-    // Check if table has ownerId column
+    // Fallback to raw Knex if model not available
+    const tableName = this.getTableName(objectApiName);
     const hasOwner = await knex.schema.hasColumn(tableName, 'ownerId');
     
     const recordData: any = {
@@ -333,6 +451,26 @@ export class ObjectService {
     
     const tableName = this.getTableName(objectApiName);
 
+    // Try to use the Objection model if available
+    try {
+      const Model = this.modelService.getModel(resolvedTenantId, objectApiName);
+      if (Model) {
+        const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
+        // Don't allow updating ownerId or system fields
+        const allowedData = { ...data };
+        delete allowedData.ownerId;
+        delete allowedData.id;
+        delete allowedData.created_at;
+        delete allowedData.tenantId;
+        
+        await boundModel.query().where({ id: recordId }).update(allowedData);
+        return boundModel.query().where({ id: recordId }).first();
+      }
+    } catch (error) {
+      console.warn(`Could not use Objection model for ${objectApiName}:`, error.message);
+    }
+    
+    // Fallback to raw Knex
     await knex(tableName)
       .where({ id: recordId })
       .update({ ...data, updated_at: knex.fn.now() });
@@ -354,6 +492,19 @@ export class ObjectService {
     
     const tableName = this.getTableName(objectApiName);
 
+    // Try to use the Objection model if available
+    try {
+      const Model = this.modelService.getModel(resolvedTenantId, objectApiName);
+      if (Model) {
+        const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
+        await boundModel.query().where({ id: recordId }).delete();
+        return { success: true };
+      }
+    } catch (error) {
+      console.warn(`Could not use Objection model for ${objectApiName}:`, error.message);
+    }
+    
+    // Fallback to raw Knex
     await knex(tableName).where({ id: recordId }).delete();
     
     return { success: true };