Add Contact standard object, related lists, meilisearch, pagination, search, AI assistant

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

@@ -119,6 +119,47 @@ export class DynamicModelFactory {
           };
         }
 
+        // Add additional relation mappings (e.g., hasMany)
+        for (const relation of relations) {
+          if (mappings[relation.name]) {
+            continue;
+          }
+
+          let modelClass: any = relation.targetObjectApiName;
+          if (getModel) {
+            const resolvedModel = getModel(relation.targetObjectApiName);
+            if (resolvedModel) {
+              modelClass = resolvedModel;
+            } else {
+              continue;
+            }
+          }
+
+          const targetTable = DynamicModelFactory.getTableName(relation.targetObjectApiName);
+
+          if (relation.type === 'belongsTo') {
+            mappings[relation.name] = {
+              relation: Model.BelongsToOneRelation,
+              modelClass,
+              join: {
+                from: `${tableName}.${relation.fromColumn}`,
+                to: `${targetTable}.${relation.toColumn}`,
+              },
+            };
+          }
+
+          if (relation.type === 'hasMany') {
+            mappings[relation.name] = {
+              relation: Model.HasManyRelation,
+              modelClass,
+              join: {
+                from: `${tableName}.${relation.fromColumn}`,
+                to: `${targetTable}.${relation.toColumn}`,
+              },
+            };
+          }
+        }
+
         return mappings;
       }
 
@@ -138,7 +179,8 @@ export class DynamicModelFactory {
    * Convert a field definition to JSON schema property
    */
   private static fieldToJsonSchema(field: FieldDefinition): Record<string, any> {
-    switch (field.type.toUpperCase()) {
+    const baseSchema = () => {
+      switch (field.type.toUpperCase()) {
       case 'TEXT':
       case 'STRING':
       case 'EMAIL':
@@ -146,45 +188,57 @@ export class DynamicModelFactory {
       case 'PHONE':
       case 'PICKLIST':
       case 'MULTI_PICKLIST':
-        return {
-          type: 'string',
-          ...(field.isUnique && { uniqueItems: true }),
-        };
+          return {
+            type: 'string',
+            ...(field.isUnique && { uniqueItems: true }),
+          };
 
       case 'LONG_TEXT':
-        return { type: 'string' };
+          return { type: 'string' };
 
       case 'NUMBER':
       case 'DECIMAL':
       case 'CURRENCY':
       case 'PERCENT':
-        return {
-          type: 'number',
-          ...(field.isUnique && { uniqueItems: true }),
-        };
+          return {
+            type: 'number',
+            ...(field.isUnique && { uniqueItems: true }),
+          };
 
       case 'INTEGER':
-        return {
-          type: 'integer',
-          ...(field.isUnique && { uniqueItems: true }),
-        };
+          return {
+            type: 'integer',
+            ...(field.isUnique && { uniqueItems: true }),
+          };
 
       case 'BOOLEAN':
-        return { type: 'boolean', default: false };
+          return { type: 'boolean', default: false };
 
       case 'DATE':
-        return { type: 'string', format: 'date' };
+          return { type: 'string', format: 'date' };
 
       case 'DATE_TIME':
-        return { type: 'string', format: 'date-time' };
+          return { type: 'string', format: 'date-time' };
 
       case 'LOOKUP':
       case 'BELONGS_TO':
-        return { type: 'string' };
+          return { type: 'string' };
 
       default:
-        return { type: 'string' };
+          return { type: 'string' };
+      }
+    };
+
+    const schema = baseSchema();
+
+    // Allow null for non-required fields so optional strings/numbers don't fail validation
+    if (!field.isRequired) {
+      return {
+        anyOf: [schema, { type: 'null' }],
+      };
     }
+
+    return schema;
   }
 
   /**
@@ -196,6 +250,9 @@ export class DynamicModelFactory {
       .replace(/([A-Z])/g, '_$1')
       .toLowerCase()
       .replace(/^_/, '');
+    if (snakeCase.endsWith('y')) {
+      return `${snakeCase.slice(0, -1)}ies`;
+    }
     return snakeCase.endsWith('s') ? snakeCase : `${snakeCase}s`;
   }
 }

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

@@ -16,13 +16,17 @@ export class ModelRegistry {
    */
   registerModel(apiName: string, modelClass: ModelClass<BaseModel>): void {
     this.registry.set(apiName, modelClass);
+    const lowerKey = apiName.toLowerCase();
+    if (lowerKey !== apiName && !this.registry.has(lowerKey)) {
+      this.registry.set(lowerKey, modelClass);
+    }
   }
 
   /**
    * Get a model from the registry
    */
   getModel(apiName: string): ModelClass<BaseModel> {
-    const model = this.registry.get(apiName);
+    const model = this.registry.get(apiName) || this.registry.get(apiName.toLowerCase());
     if (!model) {
       throw new Error(`Model for ${apiName} not found in registry`);
     }
@@ -33,7 +37,7 @@ export class ModelRegistry {
    * Check if a model exists in the registry
    */
   hasModel(apiName: string): boolean {
-    return this.registry.has(apiName);
+    return this.registry.has(apiName) || this.registry.has(apiName.toLowerCase());
   }
 
   /**
@@ -46,7 +50,8 @@ export class ModelRegistry {
     // Returns undefined if model not found (for models not yet registered)
     const model = DynamicModelFactory.createModel(
       metadata,
-      (apiName: string) => this.registry.get(apiName),
+      (apiName: string) =>
+        this.registry.get(apiName) || this.registry.get(apiName.toLowerCase()),
     );
     this.registerModel(metadata.apiName, model);
     return model;

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

@@ -171,6 +171,25 @@ export class ModelService {
         }
       }
 
+      if (objectMetadata.relations) {
+        for (const relation of objectMetadata.relations) {
+          if (relation.targetObjectApiName) {
+            try {
+              await this.ensureModelWithDependencies(
+                tenantId,
+                relation.targetObjectApiName,
+                fetchMetadata,
+                visited,
+              );
+            } catch (error) {
+              this.logger.debug(
+                `Skipping registration of related model ${relation.targetObjectApiName}: ${error.message}`
+              );
+            }
+          }
+        }
+      }
+
       // Now create and register this model (all dependencies are ready)
       await this.createModelForObject(tenantId, objectMetadata);
       this.logger.log(`Registered model for ${objectApiName} in tenant ${tenantId}`);