WIP - use objection and working lookup field to owner

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

@@ -30,8 +30,13 @@ export interface ObjectMetadata {
 export class DynamicModelFactory {
   /**
    * Create a dynamic model class from object metadata
+   * @param meta Object metadata
+   * @param getModel Function to retrieve model classes from registry
    */
-  static createModel(meta: ObjectMetadata): ModelClass<any> {
+  static createModel(
+    meta: ObjectMetadata,
+    getModel?: (apiName: string) => ModelClass<any>,
+  ): ModelClass<any> {
     const { tableName, fields, apiName, relations = [] } = meta;
 
     // Build JSON schema properties
@@ -57,12 +62,16 @@ export class DynamicModelFactory {
       }
     }
 
-    // Build relation mappings
-    const relationMappings: RelationMappings = {};
-    for (const rel of relations) {
-      // Relations are resolved dynamically, skipping for now
-      // Will be handled by ModelRegistry.getModel()
-    }
+    // Build relation mappings from lookup fields
+    const lookupFields = fields.filter(f => f.type === 'LOOKUP' && f.referenceObject);
+
+    // Store lookup fields metadata for later use
+    const lookupFieldsInfo = lookupFields.map(f => ({
+      apiName: f.apiName,
+      relationName: f.apiName.replace(/Id$/, '').toLowerCase(),
+      referenceObject: f.referenceObject,
+      targetTable: this.getTableName(f.referenceObject),
+    }));
 
     // Create the dynamic model class extending Model directly
     class DynamicModel extends Model {
@@ -76,8 +85,41 @@ export class DynamicModelFactory {
       static tableName = tableName;
 
       static objectApiName = apiName;
+      
+      static lookupFields = lookupFieldsInfo;
 
-      static relationMappings = relationMappings;
+      static get relationMappings(): RelationMappings {
+        const mappings: RelationMappings = {};
+
+        // Build relation mappings from lookup fields
+        for (const lookupInfo of lookupFieldsInfo) {
+          // Use getModel function if provided, otherwise use string reference
+          let modelClass: any = lookupInfo.referenceObject;
+          
+          if (getModel) {
+            const resolvedModel = getModel(lookupInfo.referenceObject);
+            // Only use resolved model if it exists, otherwise skip this relation
+            // It will be resolved later when the model is registered
+            if (resolvedModel) {
+              modelClass = resolvedModel;
+            } else {
+              // Skip this relation if model not found yet
+              continue;
+            }
+          }
+
+          mappings[lookupInfo.relationName] = {
+            relation: Model.BelongsToOneRelation,
+            modelClass,
+            join: {
+              from: `${tableName}.${lookupInfo.apiName}`,
+              to: `${lookupInfo.targetTable}.id`,
+            },
+          };
+        }
+
+        return mappings;
+      }
 
       static get jsonSchema() {
         return {
@@ -159,4 +201,16 @@ export class DynamicModelFactory {
         return { type: 'string' };
     }
   }
+
+  /**
+   * Get table name from object API name
+   */
+  private static getTableName(objectApiName: string): string {
+    // Convert PascalCase/camelCase to snake_case and pluralize
+    const snakeCase = objectApiName
+      .replace(/([A-Z])/g, '_$1')
+      .toLowerCase()
+      .replace(/^_/, '');
+    return snakeCase.endsWith('s') ? snakeCase : `${snakeCase}s`;
+  }
 }