@stndrds/schema 0.1.0-alpha.47 → 0.1.0-alpha.49

package/dist/{chunk-CVMMZRH6.mjs → chunk-FDWX5X6L.mjs}

@@ -323,7 +323,14 @@ function initializePinCodeService(salt) {
 }
 
 // src/runtime/cache.ts
-import { createHash } from "crypto";
+function fnv1aHash(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
 function hashOptions(options) {
   if (options === null || options === void 0 || typeof options === "object" && Object.keys(options).length === 0) {
     return "default";
@@ -340,7 +347,7 @@ function hashOptions(options) {
     }
     return value;
   });
-  return createHash("md5").update(sortedJson).digest("hex").slice(0, 8);
+  return fnv1aHash(sortedJson);
 }
 var cacheKeys = {
   // -------------------------------------------------------------------------
@@ -369,6 +376,12 @@ var cacheKeys = {
   // -------------------------------------------------------------------------
   /** Relation options for an attribute */
   relationOptions: (tenantId, attrId, hash) => `rel:${tenantId}:${attrId}:${hash}`,
+  /**
+   * Resolved relation by composite ID.
+   * Composite ID format: `${attributeId}:${recordId}`
+   * Used by cachedByMany in RelationService.resolveIds()
+   */
+  resolvedRelation: (tenantId, compositeId) => `relres:${tenantId}:${compositeId}`,
   // -------------------------------------------------------------------------
   // Rollups - TTL: 2 minutes (high volatility)
   // -------------------------------------------------------------------------
@@ -408,6 +421,19 @@ var cacheKeys = {
   allPermissions: (tenantId) => `perms:${tenantId}:*`,
   /** All relation cache for a tenant */
   allRelations: (tenantId) => `rel:${tenantId}:*`,
+  /** All resolved relations cache for a tenant */
+  allResolvedRelations: (tenantId) => `relres:${tenantId}:*`,
+  /**
+   * Resolved relations for a specific record (all attributeId variants).
+   * Pattern matches `relres:${tenantId}:*:${recordId}` to invalidate
+   * all cached labels for a record regardless of which attribute resolved it.
+   */
+  resolvedRelationsByRecord: (tenantId, recordId) => `relres:${tenantId}:*:${recordId}`,
+  /**
+   * Resolved relations for a specific attribute.
+   * Invalidates when a relation's displayTemplate changes.
+   */
+  resolvedRelationsByAttr: (tenantId, attributeId) => `relres:${tenantId}:${attributeId}:*`,
   /** All rollup cache for a tenant */
   allRollups: (tenantId) => `rollup:${tenantId}:*`,
   /** All rollups for a specific record */
@@ -460,6 +486,8 @@ var cacheTtl = {
   permissions: 15 * 60 * 1e3,
   /** Relation options - medium volatility (5 minutes) */
   relations: 5 * 60 * 1e3,
+  /** Resolved relations - medium volatility (5 minutes) */
+  resolvedRelations: 5 * 60 * 1e3,
   /** Rollup values - high volatility (2 minutes) */
   rollup: 2 * 60 * 1e3,
   /** Individual records - high volatility (1 minute) */
@@ -492,6 +520,7 @@ var defaultTtl = {
   workflowById: cacheTtl.workflows,
   workflowList: cacheTtl.workflows,
   relationOptions: cacheTtl.relations,
+  resolvedRelation: cacheTtl.resolvedRelations,
   rollupValue: cacheTtl.rollup,
   userPermissions: cacheTtl.permissions,
   recordList: cacheTtl.recordList,
@@ -4408,6 +4437,72 @@ var BaseService = class {
     const pattern = patternFn(this.tenantId, id);
     await this.cache.deletePattern(pattern);
   }
+  /**
+   * Cache multiple resources by ID, fetching only missing ones.
+   * Useful for batch operations with individual caching (e.g., resolveIds).
+   *
+   * Unlike `cachedBy` which caches a single resource, this method:
+   * 1. Checks the cache for each ID in parallel
+   * 2. Collects cache misses
+   * 3. Fetches only missing items via the fetcher
+   * 4. Caches new results individually
+   * 5. Returns all results (cached + freshly fetched)
+   *
+   * @param keyType - Type of cache key (e.g., "resolvedRelation")
+   * @param ids - Resource identifiers to fetch
+   * @param fetcher - Function to fetch missing items (receives only cache-miss IDs)
+   * @param getId - Function to extract ID from a fetched item
+   * @param ttlMs - Optional TTL override
+   *
+   * @example
+   * ```typescript
+   * // Cache relations by composite ID (attributeId:recordId)
+   * return this.cachedByMany(
+   *   "resolvedRelation",
+   *   ids.map(id => `${attributeId}:${id}`),
+   *   async (missingCompositeIds) => {
+   *     const missingRecordIds = missingCompositeIds.map(c => c.split(":")[1]);
+   *     return this.fetchRelations(missingRecordIds, attributeId);
+   *   },
+   *   (item) => `${attributeId}:${item.id}`
+   * );
+   * ```
+   */
+  async cachedByMany(keyType, ids, fetcher, getId, ttlMs) {
+    const cache = this.cache;
+    if (!cache || ids.length === 0) {
+      return fetcher(ids);
+    }
+    const keyFn = cacheKeys[keyType];
+    const ttl = ttlMs ?? defaultTtl[keyType] ?? 6e4;
+    const cacheChecks = await Promise.all(
+      ids.map(async (id) => {
+        const key = keyFn(this.tenantId, id);
+        const cached = await cache.get(key);
+        return { id, cached };
+      })
+    );
+    const results = [];
+    const missingIds = [];
+    for (const { id, cached } of cacheChecks) {
+      if (cached !== null) {
+        results.push(cached);
+      } else {
+        missingIds.push(id);
+      }
+    }
+    if (missingIds.length > 0) {
+      const fetched = await fetcher(missingIds);
+      await Promise.all(
+        fetched.map(async (item) => {
+          const key = keyFn(this.tenantId, getId(item));
+          await cache.set(key, item, ttl);
+        })
+      );
+      results.push(...fetched);
+    }
+    return results;
+  }
 };
 var BaseRepository = class {
   /**
@@ -7717,6 +7812,7 @@ var ObjectSchemaService = class extends BaseService {
           return new Map(records.map((r) => [r.id, r.label]));
         });
       });
+      await this.invalidateCachePattern(cacheKeys.allResolvedRelations(this.tenantId));
     }
     return this.convertDBObjectToDefinition(updatedDbObject, dbAttributes);
   }
@@ -9445,8 +9541,8 @@ var RelationService = class extends BaseService {
    * Resolve record IDs to their display labels.
    * Useful for displaying current values in the UI.
    *
-   * Uses batch fetching for performance - fetches all records in one query,
-   * then groups by objectId to minimize schema lookups.
+   * Uses caching per individual record ID for optimal performance.
+   * Cache key format: `${attributeId}:${recordId}` to handle different displayTemplates.
    *
    * @param ids - Record IDs to resolve
    * @param attributeId - Relation attribute ID to use its displayTemplate for label rendering
@@ -9461,6 +9557,153 @@ 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
+    );
+  }
+  /**
+   * Resolve multiple attribute/IDs batches in a single operation.
+   * Optimized for DataGrid scenarios with multiple relation columns.
+   *
+   * Benefits over multiple resolveIds() calls:
+   * - Single DB query for all records across all attributes
+   * - Deduplication of records referenced by multiple attributes
+   * - Single schema lookup per objectId
+   *
+   * Uses caching per individual record ID for optimal performance.
+   *
+   * @param requests - Array of { attributeId, ids } to resolve
+   * @returns Map of attributeId to resolved options
+   *
+   * @example
+   * ```typescript
+   * const results = await relationService.resolveIdsBatch([
+   *   { attributeId: "attr-company", ids: ["rec-1", "rec-2"] },
+   *   { attributeId: "attr-contact", ids: ["rec-3", "rec-4"] },
+   * ]);
+   * // { "attr-company": [...], "attr-contact": [...] }
+   * ```
+   */
+  async resolveIdsBatch(requests) {
+    if (!requests || requests.length === 0) {
+      return {};
+    }
+    const validRequests = requests.filter((r) => r.ids && r.ids.length > 0);
+    if (validRequests.length === 0) {
+      return {};
+    }
+    const allCompositeIds = [];
+    const compositeIdsByAttr = /* @__PURE__ */ new Map();
+    for (const req of validRequests) {
+      const composites = req.ids.map((id) => `${req.attributeId}:${id}`);
+      allCompositeIds.push(...composites);
+      compositeIdsByAttr.set(req.attributeId, composites);
+    }
+    const allResolved = await this.cachedByMany(
+      "resolvedRelation",
+      allCompositeIds,
+      (missingCompositeIds) => this.fetchResolveIdsBatch(missingCompositeIds),
+      (item) => item._compositeId,
+      cacheTtl.resolvedRelations
+    );
+    const response = {};
+    const resolvedMap = new Map(allResolved.map((item) => [item._compositeId, item]));
+    for (const req of validRequests) {
+      const composites = compositeIdsByAttr.get(req.attributeId) ?? [];
+      const options = [];
+      for (const compositeId of composites) {
+        const resolved = resolvedMap.get(compositeId);
+        if (resolved) {
+          const { _compositeId, ...option } = resolved;
+          options.push(option);
+        }
+      }
+      response[req.attributeId] = options;
+    }
+    return response;
+  }
+  /**
+   * Internal method to fetch and resolve multiple composite IDs at once.
+   * Optimized for batch operations - single DB query for all records.
+   */
+  async fetchResolveIdsBatch(compositeIds) {
+    if (compositeIds.length === 0) {
+      return [];
+    }
+    const parsed = compositeIds.map((c) => {
+      const [attributeId, recordId] = c.split(":");
+      return { compositeId: c, attributeId, recordId };
+    });
+    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);
+    if (records.length === 0) {
+      return [];
+    }
+    const recordMap = new Map(records.map((r) => [r.id, r]));
+    const attributePromises = uniqueAttributeIds.map((id) => this.findAttributeById(id));
+    const attributes = await Promise.all(attributePromises);
+    const attributeMap = new Map(uniqueAttributeIds.map((id, i) => [id, attributes[i]]));
+    const uniqueObjectIds = [...new Set(records.map((r) => r.objectId))];
+    const schemaPromises = uniqueObjectIds.map((id) => this.schemaService.getObjectSchema(id));
+    const schemas = await Promise.all(schemaPromises);
+    const schemaMap = new Map(uniqueObjectIds.map((id, i) => [id, schemas[i]]));
+    const resolved = [];
+    for (const { compositeId, attributeId, recordId } of parsed) {
+      const record = recordMap.get(recordId);
+      if (!record) {
+        continue;
+      }
+      const objectSchema = schemaMap.get(record.objectId);
+      if (!objectSchema) {
+        continue;
+      }
+      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;
+      }
+      resolved.push({
+        _compositeId: compositeId,
+        id: record.id,
+        objectId: record.objectId,
+        objectName: objectSchema.name,
+        objectLabel: objectSchema.label,
+        objectIcon: objectSchema.icon,
+        label
+      });
+    }
+    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.
+   */
+  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) {
@@ -9487,8 +9730,8 @@ var RelationService = class extends BaseService {
             customTemplate,
             record.values,
             objectSchema.attributes,
-            async (ids2) => {
-              const linkedRecords = await this.adapter.objectRecords.findByIds(ids2);
+            async (nestedIds) => {
+              const linkedRecords = await this.adapter.objectRecords.findByIds(nestedIds);
               return new Map(linkedRecords.map((r) => [r.id, r.label]));
             }
           );
@@ -10140,6 +10383,7 @@ var RecordService = class extends BaseService {
     await this.invalidateCache(cacheKeys.record(this.tenantId, recordId));
     await this.invalidateLists("allRecordLists", existing.objectId);
     await this.invalidateLists("allSearchResults", existing.objectId);
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -10207,6 +10451,7 @@ var RecordService = class extends BaseService {
     await this.invalidateLists("allRecordLists", record.objectId);
     await this.invalidateLists("allSearchResults", record.objectId);
     await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
     }
@@ -10235,6 +10480,7 @@ var RecordService = class extends BaseService {
     await this.invalidateLists("allRecordLists", record.objectId);
     await this.invalidateLists("allSearchResults", record.objectId);
     await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
   }
   // ============================================================================
   // RESTORE
@@ -10262,6 +10508,7 @@ var RecordService = class extends BaseService {
     await this.invalidateLists("allRecordLists", record.objectId);
     await this.invalidateLists("allSearchResults", record.objectId);
     await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,