WIP - using objection base model to handle objects operations

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' };
+    }
+  }
+}