@stndrds/schema 0.1.0-alpha.51 → 0.1.0-alpha.52

package/dist/{chunk-EK56IQJ7.mjs → chunk-D4AFKFAX.mjs}

@@ -9596,12 +9596,105 @@ var RecordQueryService = class extends BaseService {
   }
 };
 
+// src/runtime/services/record/record-resolver.service.ts
+var RecordResolverService = class extends BaseService {
+  constructor(adapter) {
+    super(adapter);
+  }
+  // ============================================================================
+  // CACHED RECORD ACCESS
+  // ============================================================================
+  /**
+   * Find a record by ID with caching.
+   *
+   * Uses the shared record cache for optimal performance.
+   * Delegates to findByIds for consistent cache handling.
+   *
+   * @param id - Record ID
+   * @returns Record or null if not found
+   */
+  async findById(id) {
+    if (!id) return null;
+    const results = await this.findByIds([id]);
+    return results[0] ?? null;
+  }
+  /**
+   * Find multiple records by IDs with caching.
+   *
+   * Each record is cached individually for reuse across services.
+   * Only fetches records not already in cache.
+   *
+   * @param ids - Record IDs to fetch
+   * @returns Array of found records (missing IDs are not included)
+   */
+  async findByIds(ids) {
+    if (!ids || ids.length === 0) {
+      return [];
+    }
+    const uniqueIds = [...new Set(ids)];
+    return this.cachedByMany(
+      "record",
+      uniqueIds,
+      (missingIds) => this.adapter.objectRecords.findByIds(missingIds),
+      (record) => record.id,
+      cacheTtl.records
+    );
+  }
+  // ============================================================================
+  // FACTORY METHODS
+  // ============================================================================
+  /**
+   * Create a RelationLabelResolver callback for computeLabelWithRelations.
+   *
+   * Used by RelationService.resolveLabel() and ObjectSchemaService.
+   *
+   * @returns Callback that resolves record IDs to their labels (cached)
+   */
+  createRelationLabelResolver() {
+    return async (ids) => {
+      const records = await this.findByIds(ids);
+      return new Map(records.map((r) => [r.id, r.label]));
+    };
+  }
+  /**
+   * Create a LabelResolver interface for label computation helpers.
+   *
+   * Used by RecordService for computing record labels.
+   *
+   * @param relationService - RelationService for resolving relation display labels
+   * @returns LabelResolver interface with cached record fetching
+   */
+  createLabelResolver(relationService) {
+    return {
+      resolveRelationIds: (ids, attrId) => relationService.resolveIds(ids, attrId),
+      findRecordLabels: (ids) => this.findByIds(ids)
+    };
+  }
+  /**
+   * Create a RollupCascadeContext for rollup recalculation.
+   *
+   * Used by RecordService after create/update/delete operations.
+   *
+   * @param rollupService - RollupService for recalculating rollups
+   * @param schemaService - ObjectSchemaService for fetching schemas
+   * @returns Context with cached record fetching
+   */
+  createRollupContext(rollupService, schemaService) {
+    return {
+      rollupService,
+      schemaService,
+      findRecordsByIds: (ids) => this.findByIds(ids)
+    };
+  }
+};
+
 // src/runtime/services/record/relation.service.ts
 var RelationService = class extends BaseService {
   constructor(adapter, nativeRegistry, options) {
     super(adapter);
     this.schemaService = new ObjectSchemaService(adapter, nativeRegistry);
-    this.queryService = options?.queryService;
+    this.queryService = options.queryService;
+    this.recordResolver = options.recordResolver;
   }
   /**
    * Set the query service after construction.
@@ -9679,7 +9772,7 @@ var RelationService = class extends BaseService {
       });
       return errors;
     }
-    const records = await this.adapter.objectRecords.findByIds(ids);
+    const records = await this.recordResolver.findByIds(ids);
     const recordMap = new Map(records.map((r) => [r.id, r]));
     const invalidIds = [];
     for (const id of ids) {
@@ -9801,20 +9894,7 @@ var RelationService = class extends BaseService {
       const result = query ? await queryService.searchRecords(objectSchema.id, query, queryOptions) : await queryService.listRecords(objectSchema.id, queryOptions);
       totalCount += result.total;
       for (const record of result.records) {
-        let label;
-        if (target.displayTemplate) {
-          label = await computeLabelWithRelations(
-            target.displayTemplate,
-            record.values,
-            objectSchema.attributes,
-            async (ids) => {
-              const linkedRecords = await this.adapter.objectRecords.findByIds(ids);
-              return new Map(linkedRecords.map((r) => [r.id, r.label]));
-            }
-          );
-        } else {
-          label = record.label;
-        }
+        const label = await this.resolveLabel(record, objectSchema, target.displayTemplate);
         allOptions.push({
           id: record.id,
           objectId: objectSchema.id,
@@ -9852,17 +9932,8 @@ var RelationService = class extends BaseService {
     if (!ids || ids.length === 0) {
       return [];
     }
-    const compositeIds = ids.map((id) => `${attributeId}:${id}`);
-    return this.cachedByMany(
-      "resolvedRelation",
-      compositeIds,
-      async (missingCompositeIds) => {
-        const missingRecordIds = missingCompositeIds.map((c) => c.split(":")[1]);
-        return this.fetchResolveIds(missingRecordIds, attributeId);
-      },
-      (item) => `${attributeId}:${item.id}`,
-      cacheTtl.resolvedRelations
-    );
+    const result = await this.resolveIdsBatch([{ attributeId, ids }]);
+    return result[attributeId] ?? [];
   }
   /**
    * Resolve multiple attribute/IDs batches in a single operation.
@@ -9905,7 +9976,7 @@ var RelationService = class extends BaseService {
     const allResolved = await this.cachedByMany(
       "resolvedRelation",
       allCompositeIds,
-      (missingCompositeIds) => this.fetchResolveIdsBatch(missingCompositeIds),
+      (missingCompositeIds) => this.resolveCompositeIds(missingCompositeIds),
       (item) => item._compositeId,
       cacheTtl.resolvedRelations
     );
@@ -9926,10 +9997,12 @@ var RelationService = class extends BaseService {
     return response;
   }
   /**
-   * Internal method to fetch and resolve multiple composite IDs at once.
+   * Internal method to resolve multiple composite IDs at once.
    * Optimized for batch operations - single DB query for all records.
+   *
+   * @param compositeIds - Array of composite IDs in format "attributeId:recordId"
    */
-  async fetchResolveIdsBatch(compositeIds) {
+  async resolveCompositeIds(compositeIds) {
     if (compositeIds.length === 0) {
       return [];
     }
@@ -9939,7 +10012,7 @@ var RelationService = class extends BaseService {
     });
     const uniqueRecordIds = [...new Set(parsed.map((p) => p.recordId))];
     const uniqueAttributeIds = [...new Set(parsed.map((p) => p.attributeId))];
-    const records = await this.adapter.objectRecords.findByIds(uniqueRecordIds);
+    const records = await this.recordResolver.findByIds(uniqueRecordIds);
     if (records.length === 0) {
       return [];
     }
@@ -9964,20 +10037,7 @@ var RelationService = class extends BaseService {
       const attribute = attributeMap.get(attributeId);
       const targetConfig = attribute?.targets?.find((t) => t.object === objectSchema.name);
       const customTemplate = targetConfig?.displayTemplate;
-      let label;
-      if (customTemplate) {
-        label = await computeLabelWithRelations(
-          customTemplate,
-          record.values,
-          objectSchema.attributes,
-          async (nestedIds) => {
-            const linkedRecords = await this.adapter.objectRecords.findByIds(nestedIds);
-            return new Map(linkedRecords.map((r) => [r.id, r.label]));
-          }
-        );
-      } else {
-        label = record.label;
-      }
+      const label = await this.resolveLabel(record, objectSchema, customTemplate);
       resolved.push({
         _compositeId: compositeId,
         id: record.id,
@@ -9991,59 +10051,22 @@ var RelationService = class extends BaseService {
     return resolved;
   }
   /**
-   * Internal method to fetch and resolve relation IDs (no caching).
-   * Uses batch fetching for performance - fetches all records in one query,
-   * then groups by objectId to minimize schema lookups.
+   * Resolve the display label for a record.
+   * Uses custom template if provided, otherwise falls back to pre-computed label.
    */
-  async fetchResolveIds(ids, attributeId) {
-    if (ids.length === 0) {
-      return [];
-    }
-    const attribute = await this.findAttributeById(attributeId);
-    const records = await this.adapter.objectRecords.findByIds(ids);
-    if (records.length === 0) {
-      return [];
-    }
-    const recordsByObjectId = /* @__PURE__ */ new Map();
-    for (const record of records) {
-      const existing = recordsByObjectId.get(record.objectId) ?? [];
-      existing.push(record);
-      recordsByObjectId.set(record.objectId, existing);
-    }
-    const resolved = [];
-    for (const [objectId, objectRecords] of recordsByObjectId) {
-      const objectSchema = await this.schemaService.getObjectSchema(objectId);
-      if (!objectSchema) {
-        continue;
-      }
-      const targetConfig = attribute?.targets?.find((t) => t.object === objectSchema.name);
-      const customTemplate = targetConfig?.displayTemplate;
-      for (const record of objectRecords) {
-        let label;
-        if (customTemplate) {
-          label = await computeLabelWithRelations(
-            customTemplate,
-            record.values,
-            objectSchema.attributes,
-            async (nestedIds) => {
-              const linkedRecords = await this.adapter.objectRecords.findByIds(nestedIds);
-              return new Map(linkedRecords.map((r) => [r.id, r.label]));
-            }
-          );
-        } else {
-          label = record.label;
+  async resolveLabel(record, objectSchema, customTemplate) {
+    if (customTemplate) {
+      return computeLabelWithRelations(
+        customTemplate,
+        record.values,
+        objectSchema.attributes,
+        async (nestedIds) => {
+          const linkedRecords = await this.recordResolver.findByIds(nestedIds);
+          return new Map(linkedRecords.map((r) => [r.id, r.label]));
         }
-        resolved.push({
-          id: record.id,
-          objectId: record.objectId,
-          objectName: objectSchema.name,
-          objectLabel: objectSchema.label,
-          objectIcon: objectSchema.icon,
-          label
-        });
-      }
+      );
     }
-    return resolved;
+    return record.label;
   }
   /**
    * Find a relation attribute by ID.
@@ -10074,8 +10097,9 @@ var RelationService = class extends BaseService {
 
 // src/runtime/services/record/rollup.service.ts
 var RollupService = class extends BaseService {
-  constructor(adapter) {
+  constructor(adapter, options) {
     super(adapter);
+    this.recordResolver = options.recordResolver;
   }
   /**
    * Calculate a rollup value for a record
@@ -10129,7 +10153,7 @@ var RollupService = class extends BaseService {
    * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
    */
   async calculateForward(recordId, rollupAttr) {
-    const record = await this.adapter.objectRecords.findById(recordId);
+    const record = await this.recordResolver.findById(recordId);
     if (!record) {
       return { value: null, recordCount: 0 };
     }
@@ -10143,7 +10167,7 @@ var RollupService = class extends BaseService {
     if (relatedIds.length === 0) {
       return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
     }
-    const relatedRecords = await this.adapter.objectRecords.findByIds(relatedIds);
+    const relatedRecords = await this.recordResolver.findByIds(relatedIds);
     if (relatedRecords.length === 0) {
       return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
     }
@@ -10154,7 +10178,7 @@ var RollupService = class extends BaseService {
    * Example: Company has rollup on "orders", Order has relation "company" → companies
    */
   async calculateReverse(recordId, rollupAttr, schema) {
-    const record = await this.adapter.objectRecords.findById(recordId);
+    const record = await this.recordResolver.findById(recordId);
     if (!record) {
       return { value: null, recordCount: 0 };
     }
@@ -10461,25 +10485,25 @@ var RecordService = class extends BaseService {
     this.permissionService = options?.permissionService;
     this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter) : void 0);
     this.policyRegistry = options?.policyRegistry === null ? null : options?.policyRegistry ?? defaultPolicyRegistry;
+    this.recordResolver = new RecordResolverService(adapter);
     this.queryService = new RecordQueryService(adapter, this.schemaService, {
       permissionService: this.permissionService,
       policyRegistry: this.policyRegistry
     });
     this.relationService = new RelationService(adapter, registry, {
-      queryService: this.queryService
+      queryService: this.queryService,
+      recordResolver: this.recordResolver
+    });
+    this.rollupService = new RollupService(adapter, {
+      recordResolver: this.recordResolver
     });
     this.userService = new UserService(adapter);
-    this.rollupService = new RollupService(adapter);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
-    this.labelResolver = {
-      resolveRelationIds: (ids, attrId) => this.relationService.resolveIds(ids, attrId),
-      findRecordLabels: (ids) => this.adapter.objectRecords.findByIds(ids)
-    };
-    this.rollupContext = {
-      rollupService: this.rollupService,
-      schemaService: this.schemaService,
-      findRecordsByIds: (ids) => this.adapter.objectRecords.findByIds(ids)
-    };
+    this.labelResolver = this.recordResolver.createLabelResolver(this.relationService);
+    this.rollupContext = this.recordResolver.createRollupContext(
+      this.rollupService,
+      this.schemaService
+    );
   }
   // ============================================================================
   // CREATE
@@ -10874,15 +10898,19 @@ var RecordService = class extends BaseService {
   }
 };
 
-// src/runtime/services/record/relation-resolver.service.ts
-var RelationResolverService = class {
-  constructor(adapter) {
-    this.adapter = adapter;
+// src/runtime/services/record/formula-resolver.service.ts
+var FormulaResolverService = class extends BaseService {
+  constructor(adapter, options) {
+    super(adapter);
+    this.recordResolver = options.recordResolver;
   }
+  // ============================================================================
+  // RESOLUTION
+  // ============================================================================
   /**
    * Resolve values from related records for formula evaluation
    *
-   * Phase 2: Supports 1 level of relation traversal only
+   * Supports 1 level of relation traversal only.
    *
    * @param record - The source record
    * @param schema - Schema of the source object
@@ -10891,7 +10919,6 @@ var RelationResolverService = class {
    *
    * @example
    * ```typescript
-   * // For an order with company relation
    * const resolved = await resolver.resolveRelationValues(
    *   orderRecord,
    *   orderSchema,
@@ -10920,7 +10947,7 @@ var RelationResolverService = class {
     if (idsToFetch.length === 0) {
       return result;
     }
-    const relatedRecords = await this.adapter.objectRecords.findByIds(idsToFetch);
+    const relatedRecords = await this.recordResolver.findByIds(idsToFetch);
     for (const relatedRecord of relatedRecords) {
       const attrName = attrIdMap.get(relatedRecord.id);
       if (attrName) {
@@ -10966,7 +10993,7 @@ var RelationResolverService = class {
     if (allIdsToFetch.size === 0) {
       return resultMap;
     }
-    const relatedRecords = await this.adapter.objectRecords.findByIds([...allIdsToFetch]);
+    const relatedRecords = await this.recordResolver.findByIds([...allIdsToFetch]);
     const relatedRecordMap = new Map(relatedRecords.map((r) => [r.id, r]));
     for (const record of records) {
       const result = resultMap.get(record.id);
@@ -10999,10 +11026,12 @@ var RelationResolverService = class {
     }
     return flat;
   }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
   /**
    * Extract a single relation ID from a value
    * Handles both single (string) and multi (array) relations
-   * @internal
    */
   extractSingleId(value) {
     if (typeof value === "string" && value.length > 0) {
@@ -11021,9 +11050,9 @@ var RollupScheduler = class {
     this.adapter = adapter;
     this.getSchemaById = getSchemaById;
     this.pending = /* @__PURE__ */ new Map();
-    this.rollupService = new RollupService(adapter);
-    this.debounceMs = options?.debounceMs ?? 100;
-    this.maxPending = options?.maxPending ?? 100;
+    this.rollupService = new RollupService(adapter, { recordResolver: options.recordResolver });
+    this.debounceMs = options.debounceMs ?? 100;
+    this.maxPending = options.maxPending ?? 100;
   }
   /**
    * Schedule a rollup recalculation for a parent record.
@@ -14458,10 +14487,11 @@ export {
   createContextForRestore,
   recalculateParentRollups,
   RecordQueryService,
+  RecordResolverService,
   RelationService,
   RollupService,
   RecordService,
-  RelationResolverService,
+  FormulaResolverService,
   RollupScheduler,
   WorkflowService,
   WorkflowInstanceService,