@stndrds/schema 0.1.0-alpha.46 → 0.1.0-alpha.48

package/dist/{chunk-I6VF7DOR.js → chunk-JSSSRT57.js}

@@ -369,6 +369,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 +414,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 +479,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 +513,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 +4430,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 = _nullishCoalesce(_nullishCoalesce(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 +7805,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 +9534,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 +9550,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 = _nullishCoalesce(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 = _optionalChain([attribute, 'optionalAccess', _201 => _201.targets, 'optionalAccess', _202 => _202.find, 'call', _203 => _203((t) => t.object === objectSchema.name)]);
+      const customTemplate = _optionalChain([targetConfig, 'optionalAccess', _204 => _204.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) {
@@ -9478,8 +9714,8 @@ var RelationService = class extends BaseService {
       if (!objectSchema) {
         continue;
       }
-      const targetConfig = _optionalChain([attribute, 'optionalAccess', _201 => _201.targets, 'optionalAccess', _202 => _202.find, 'call', _203 => _203((t) => t.object === objectSchema.name)]);
-      const customTemplate = _optionalChain([targetConfig, 'optionalAccess', _204 => _204.displayTemplate]);
+      const targetConfig = _optionalChain([attribute, 'optionalAccess', _205 => _205.targets, 'optionalAccess', _206 => _206.find, 'call', _207 => _207((t) => t.object === objectSchema.name)]);
+      const customTemplate = _optionalChain([targetConfig, 'optionalAccess', _208 => _208.displayTemplate]);
       for (const record of objectRecords) {
         let label;
         if (customTemplate) {
@@ -9487,8 +9723,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]));
             }
           );
@@ -9624,14 +9860,14 @@ var RollupService = class extends BaseService {
     const sourceSchema = getSchemaByNameFromContext(sourceObjectName);
     let sourceObjectId;
     let reverseRelationAttrName;
-    if (_optionalChain([sourceSchema, 'optionalAccess', _205 => _205.id])) {
+    if (_optionalChain([sourceSchema, 'optionalAccess', _209 => _209.id])) {
       sourceObjectId = sourceSchema.id;
       const reverseRelationAttr = sourceSchema.attributes.find((attr) => {
         if (attr.type !== "relation") return false;
         const relationConfig = attr;
-        return _optionalChain([relationConfig, 'optionalAccess', _206 => _206.targets, 'optionalAccess', _207 => _207.some, 'call', _208 => _208((t) => t.object === schema.name)]);
+        return _optionalChain([relationConfig, 'optionalAccess', _210 => _210.targets, 'optionalAccess', _211 => _211.some, 'call', _212 => _212((t) => t.object === schema.name)]);
       });
-      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _209 => _209.name]);
+      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _213 => _213.name]);
     } else {
       const sourceObject = await this.adapter.objects.findByName(sourceObjectName);
       if (!sourceObject) {
@@ -9642,9 +9878,9 @@ var RollupService = class extends BaseService {
       const reverseRelationAttr = sourceAttributes.find((attr) => {
         if (attr.type !== "relation") return false;
         const relationConfig = attr.config;
-        return _optionalChain([relationConfig, 'optionalAccess', _210 => _210.targets, 'optionalAccess', _211 => _211.some, 'call', _212 => _212((t) => t.object === schema.name)]);
+        return _optionalChain([relationConfig, 'optionalAccess', _214 => _214.targets, 'optionalAccess', _215 => _215.some, 'call', _216 => _216((t) => t.object === schema.name)]);
       });
-      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _213 => _213.name]);
+      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _217 => _217.name]);
     }
     if (!reverseRelationAttrName) {
       return { value: null, recordCount: 0 };
@@ -9881,7 +10117,7 @@ var RollupService = class extends BaseService {
       }
       for (const rollupDbAttr of rollupAttrs) {
         const rollupConfig = rollupDbAttr.config;
-        if (!_optionalChain([rollupConfig, 'optionalAccess', _214 => _214.relationAttribute])) {
+        if (!_optionalChain([rollupConfig, 'optionalAccess', _218 => _218.relationAttribute])) {
           continue;
         }
         const relationAttr = attributes.find(
@@ -9891,7 +10127,7 @@ var RollupService = class extends BaseService {
           continue;
         }
         const relationConfig = relationAttr.config;
-        const targetsChangedObject = _optionalChain([relationConfig, 'optionalAccess', _215 => _215.targets, 'optionalAccess', _216 => _216.some, 'call', _217 => _217(
+        const targetsChangedObject = _optionalChain([relationConfig, 'optionalAccess', _219 => _219.targets, 'optionalAccess', _220 => _220.some, 'call', _221 => _221(
           (t) => t.object === changedSchema.name
         )]);
         if (!targetsChangedObject) {
@@ -9918,11 +10154,11 @@ var RecordService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
     this.schemaService = new ObjectSchemaService(adapter, registry, {
-      auditService: _optionalChain([options, 'optionalAccess', _218 => _218.auditService])
+      auditService: _optionalChain([options, 'optionalAccess', _222 => _222.auditService])
     });
-    this.permissionService = _optionalChain([options, 'optionalAccess', _219 => _219.permissionService]);
-    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _220 => _220.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
-    this.policyRegistry = _optionalChain([options, 'optionalAccess', _221 => _221.policyRegistry]) === null ? null : _nullishCoalesce(_optionalChain([options, 'optionalAccess', _222 => _222.policyRegistry]), () => ( defaultPolicyRegistry));
+    this.permissionService = _optionalChain([options, 'optionalAccess', _223 => _223.permissionService]);
+    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _224 => _224.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
+    this.policyRegistry = _optionalChain([options, 'optionalAccess', _225 => _225.policyRegistry]) === null ? null : _nullishCoalesce(_optionalChain([options, 'optionalAccess', _226 => _226.policyRegistry]), () => ( defaultPolicyRegistry));
     this.queryService = new RecordQueryService(adapter, this.schemaService, {
       permissionService: this.permissionService,
       policyRegistry: this.policyRegistry
@@ -9932,7 +10168,7 @@ var RecordService = class extends BaseService {
     });
     this.userService = new UserService(adapter);
     this.rollupService = new RollupService(adapter);
-    this.hookRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _223 => _223.hookRegistry]), () => ( new NoopHookRegistry()));
+    this.hookRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _227 => _227.hookRegistry]), () => ( new NoopHookRegistry()));
     this.labelResolver = {
       resolveRelationIds: (ids, attrId) => this.relationService.resolveIds(ids, attrId),
       findRecordLabels: (ids) => this.adapter.objectRecords.findByIds(ids)
@@ -9964,21 +10200,21 @@ var RecordService = class extends BaseService {
       schema,
       this.tenantId,
       dataWithDefaults,
-      _optionalChain([options, 'optionalAccess', _224 => _224.hookMetadata])
+      _optionalChain([options, 'optionalAccess', _228 => _228.hookMetadata])
     );
-    if (!_optionalChain([options, 'optionalAccess', _225 => _225.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _229 => _229.skipHooks])) {
       await this.hookRegistry.execute("beforeCreate", schema.name, hookCtx);
     }
-    if (_optionalChain([options, 'optionalAccess', _226 => _226.validate]) !== false) {
-      if (_optionalChain([options, 'optionalAccess', _227 => _227.allowDraft])) {
+    if (_optionalChain([options, 'optionalAccess', _230 => _230.validate]) !== false) {
+      if (_optionalChain([options, 'optionalAccess', _231 => _231.allowDraft])) {
         validateDraftOrThrow(schema, dataWithDefaults);
       } else {
         validateObjectOrThrow(schema, dataWithDefaults);
       }
-      if (!_optionalChain([options, 'optionalAccess', _228 => _228.skipRelationValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _232 => _232.skipRelationValidation])) {
         await this.relationService.validateRelationsOrThrow(schema, dataWithDefaults);
       }
-      if (!_optionalChain([options, 'optionalAccess', _229 => _229.skipUserValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _233 => _233.skipUserValidation])) {
         await this.userService.validateUsersOrThrow(schema, dataWithDefaults);
       }
     }
@@ -9989,10 +10225,10 @@ var RecordService = class extends BaseService {
       data: dataWithDefaults,
       label,
       completionStatus,
-      metadata: _optionalChain([options, 'optionalAccess', _230 => _230.metadata]),
+      metadata: _optionalChain([options, 'optionalAccess', _234 => _234.metadata]),
       createdBy: this.userId
     });
-    if (!_optionalChain([options, 'optionalAccess', _231 => _231.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _235 => _235.skipHooks])) {
       const afterCtx = {
         ...hookCtx,
         recordId: record.id,
@@ -10012,7 +10248,7 @@ var RecordService = class extends BaseService {
         objectId: schema.id,
         recordId: record.id,
         recordLabel: record.label,
-        metadata: _optionalChain([options, 'optionalAccess', _232 => _232.hookMetadata])
+        metadata: _optionalChain([options, 'optionalAccess', _236 => _236.hookMetadata])
       });
     }
     return record;
@@ -10033,7 +10269,7 @@ var RecordService = class extends BaseService {
       return null;
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
-    if (!_optionalChain([options, 'optionalAccess', _233 => _233.skipPolicyCheck])) {
+    if (!_optionalChain([options, 'optionalAccess', _237 => _237.skipPolicyCheck])) {
       const policy = getPolicy(this.policyRegistry, this.userId, schema.name);
       if (policy) {
         const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
@@ -10043,10 +10279,10 @@ var RecordService = class extends BaseService {
       }
     }
     let enrichedRecord = record;
-    if (!_optionalChain([options, 'optionalAccess', _234 => _234.skipFormulas])) {
+    if (!_optionalChain([options, 'optionalAccess', _238 => _238.skipFormulas])) {
       enrichedRecord = enrichWithFormulas(record, schema);
     }
-    if (_optionalChain([options, 'optionalAccess', _235 => _235.includeSchema])) {
+    if (_optionalChain([options, 'optionalAccess', _239 => _239.includeSchema])) {
       const recordWithSchema = enrichedRecord;
       recordWithSchema.schema = schema;
       return recordWithSchema;
@@ -10089,9 +10325,9 @@ var RecordService = class extends BaseService {
       existing,
       mergedData,
       changedAttributes,
-      _optionalChain([options, 'optionalAccess', _236 => _236.hookMetadata])
+      _optionalChain([options, 'optionalAccess', _240 => _240.hookMetadata])
     );
-    if (!_optionalChain([options, 'optionalAccess', _237 => _237.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _241 => _241.skipHooks])) {
       await this.hookRegistry.execute("beforeUpdate", schema.name, hookCtx);
     }
     const hookModifiedValues = {};
@@ -10100,19 +10336,19 @@ var RecordService = class extends BaseService {
         hookModifiedValues[key] = hookCtx.newValues[key];
       }
     }
-    if (_optionalChain([options, 'optionalAccess', _238 => _238.validate]) !== false) {
-      if (_optionalChain([options, 'optionalAccess', _239 => _239.partial])) {
+    if (_optionalChain([options, 'optionalAccess', _242 => _242.validate]) !== false) {
+      if (_optionalChain([options, 'optionalAccess', _243 => _243.partial])) {
         validateDraftOrThrow(schema, mergedData);
       } else {
         validateObjectOrThrow(schema, mergedData);
       }
-      if (!_optionalChain([options, 'optionalAccess', _240 => _240.skipRelationValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _244 => _244.skipRelationValidation])) {
         await this.relationService.validateRelationsOrThrow(schema, {
           ...data,
           ...hookModifiedValues
         });
       }
-      if (!_optionalChain([options, 'optionalAccess', _241 => _241.skipUserValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _245 => _245.skipUserValidation])) {
         await this.userService.validateUsersOrThrow(schema, {
           ...data,
           ...hookModifiedValues
@@ -10128,7 +10364,7 @@ var RecordService = class extends BaseService {
       __label: label,
       __lastUpdatedBy: this.userId
     };
-    if (_optionalChain([options, 'optionalAccess', _242 => _242.metadata]) !== void 0) {
+    if (_optionalChain([options, 'optionalAccess', _246 => _246.metadata]) !== void 0) {
       const existingMetadata = _nullishCoalesce(existing.metadata, () => ( {}));
       const mergedMetadata = { ...existingMetadata, ...options.metadata };
       const cleanedMetadata = Object.fromEntries(
@@ -10140,7 +10376,8 @@ 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);
-    if (!_optionalChain([options, 'optionalAccess', _243 => _243.skipHooks])) {
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+    if (!_optionalChain([options, 'optionalAccess', _247 => _247.skipHooks])) {
       const afterCtx = {
         ...hookCtx,
         record: updated
@@ -10155,7 +10392,7 @@ var RecordService = class extends BaseService {
     if (this.auditService && this.userId && allChangedAttributes.length > 0) {
       const changes = allChangedAttributes.map((attr) => ({
         field: attr,
-        oldValue: _optionalChain([hookCtx, 'access', _244 => _244.oldValues, 'optionalAccess', _245 => _245[attr]]),
+        oldValue: _optionalChain([hookCtx, 'access', _248 => _248.oldValues, 'optionalAccess', _249 => _249[attr]]),
         newValue: hookCtx.newValues[attr]
       }));
       await this.auditService.logRecordAction({
@@ -10166,7 +10403,7 @@ var RecordService = class extends BaseService {
         recordId: updated.id,
         recordLabel: updated.label,
         changes,
-        metadata: _optionalChain([options, 'optionalAccess', _246 => _246.hookMetadata])
+        metadata: _optionalChain([options, 'optionalAccess', _250 => _250.hookMetadata])
       });
     }
     return updated;
@@ -10189,17 +10426,17 @@ var RecordService = class extends BaseService {
       const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
       checkRecordDeleteOrThrow(policy, record, ctx);
     }
-    if (_optionalChain([options, 'optionalAccess', _247 => _247.checkSystem]) && schema.system) {
+    if (_optionalChain([options, 'optionalAccess', _251 => _251.checkSystem]) && schema.system) {
       throw new ProtectedResourceError("object", schema.name, "delete");
     }
-    if (!_optionalChain([options, 'optionalAccess', _248 => _248.skipReferenceCheck])) {
+    if (!_optionalChain([options, 'optionalAccess', _252 => _252.skipReferenceCheck])) {
       const references = await this.adapter.objectRecords.countRecordsReferencingId(recordId);
       if (references.length > 0) {
         throw new RecordReferencedError(recordId, references);
       }
     }
-    const hookCtx = createContextForDelete(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _249 => _249.hookMetadata]));
-    if (!_optionalChain([options, 'optionalAccess', _250 => _250.skipHooks])) {
+    const hookCtx = createContextForDelete(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _253 => _253.hookMetadata]));
+    if (!_optionalChain([options, 'optionalAccess', _254 => _254.skipHooks])) {
       await this.hookRegistry.execute("beforeDelete", schema.name, hookCtx);
     }
     await this.adapter.objectRecords.delete(recordId);
@@ -10207,7 +10444,8 @@ var RecordService = class extends BaseService {
     await this.invalidateLists("allRecordLists", record.objectId);
     await this.invalidateLists("allSearchResults", record.objectId);
     await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
-    if (!_optionalChain([options, 'optionalAccess', _251 => _251.skipHooks])) {
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+    if (!_optionalChain([options, 'optionalAccess', _255 => _255.skipHooks])) {
       await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
     }
     await recalculateParentRollups(record, schema, this.rollupContext);
@@ -10219,7 +10457,7 @@ var RecordService = class extends BaseService {
         objectId: schema.id,
         recordId: record.id,
         recordLabel: record.label,
-        metadata: _optionalChain([options, 'optionalAccess', _252 => _252.hookMetadata])
+        metadata: _optionalChain([options, 'optionalAccess', _256 => _256.hookMetadata])
       });
     }
   }
@@ -10235,6 +10473,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
@@ -10253,8 +10492,8 @@ var RecordService = class extends BaseService {
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
     await checkPermission(this.permissionService, this.userId, schema.name, "update");
-    const hookCtx = createContextForRestore(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _253 => _253.hookMetadata]));
-    if (!_optionalChain([options, 'optionalAccess', _254 => _254.skipHooks])) {
+    const hookCtx = createContextForRestore(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _257 => _257.hookMetadata]));
+    if (!_optionalChain([options, 'optionalAccess', _258 => _258.skipHooks])) {
       await this.hookRegistry.execute("beforeRestore", schema.name, hookCtx);
     }
     const restored = await this.adapter.objectRecords.restore(recordId);
@@ -10262,7 +10501,8 @@ var RecordService = class extends BaseService {
     await this.invalidateLists("allRecordLists", record.objectId);
     await this.invalidateLists("allSearchResults", record.objectId);
     await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
-    if (!_optionalChain([options, 'optionalAccess', _255 => _255.skipHooks])) {
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+    if (!_optionalChain([options, 'optionalAccess', _259 => _259.skipHooks])) {
       const afterCtx = {
         ...hookCtx,
         record: restored
@@ -10277,7 +10517,7 @@ var RecordService = class extends BaseService {
         objectId: schema.id,
         recordId: restored.id,
         recordLabel: restored.label,
-        metadata: _optionalChain([options, 'optionalAccess', _256 => _256.hookMetadata])
+        metadata: _optionalChain([options, 'optionalAccess', _260 => _260.hookMetadata])
       });
     }
     return restored;
@@ -10480,8 +10720,8 @@ var RollupScheduler = class {
     this.getSchemaById = getSchemaById;
     this.pending = /* @__PURE__ */ new Map();
     this.rollupService = new RollupService(adapter);
-    this.debounceMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _257 => _257.debounceMs]), () => ( 100));
-    this.maxPending = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _258 => _258.maxPending]), () => ( 100));
+    this.debounceMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _261 => _261.debounceMs]), () => ( 100));
+    this.maxPending = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _262 => _262.maxPending]), () => ( 100));
   }
   /**
    * Schedule a rollup recalculation for a parent record.
@@ -10559,7 +10799,7 @@ var WorkflowService = class extends BaseService {
     if (Array.isArray(options)) {
       this.systemWorkflows = new Map(options.map((w) => [w.name, w]));
     } else {
-      this.systemWorkflows = new Map((_nullishCoalesce(_optionalChain([options, 'optionalAccess', _259 => _259.systemWorkflows]), () => ( []))).map((w) => [w.name, w]));
+      this.systemWorkflows = new Map((_nullishCoalesce(_optionalChain([options, 'optionalAccess', _263 => _263.systemWorkflows]), () => ( []))).map((w) => [w.name, w]));
     }
   }
   // ============================================================================
@@ -10862,9 +11102,9 @@ var WorkflowInstanceService = class extends BaseService {
   constructor(adapter, workflowService, options) {
     super(adapter);
     this.workflowService = workflowService;
-    this.executorRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _260 => _260.executorRegistry]), () => ( getDefaultExecutorRegistry()));
-    this.schemaService = _optionalChain([options, 'optionalAccess', _261 => _261.schemaService]);
-    this.recordService = _optionalChain([options, 'optionalAccess', _262 => _262.recordService]);
+    this.executorRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _264 => _264.executorRegistry]), () => ( getDefaultExecutorRegistry()));
+    this.schemaService = _optionalChain([options, 'optionalAccess', _265 => _265.schemaService]);
+    this.recordService = _optionalChain([options, 'optionalAccess', _266 => _266.recordService]);
   }
   /**
    * Start a new workflow instance
@@ -10990,7 +11230,7 @@ var WorkflowInstanceService = class extends BaseService {
     if (!this.adapter.workflowInstances) {
       return { instances: [], total: 0 };
     }
-    if (_optionalChain([options, 'optionalAccess', _263 => _263.workflowName])) {
+    if (_optionalChain([options, 'optionalAccess', _267 => _267.workflowName])) {
       const instances2 = await this.getInstancesByWorkflow(options.workflowName);
       let filtered = instances2;
       if (options.status) {
@@ -11004,11 +11244,11 @@ var WorkflowInstanceService = class extends BaseService {
       return { instances: paginated, total: total2 };
     }
     const { instances: dbInstances, total } = await this.adapter.workflowInstances.list({
-      limit: _optionalChain([options, 'optionalAccess', _264 => _264.limit]),
-      offset: _optionalChain([options, 'optionalAccess', _265 => _265.offset])
+      limit: _optionalChain([options, 'optionalAccess', _268 => _268.limit]),
+      offset: _optionalChain([options, 'optionalAccess', _269 => _269.offset])
     });
     let instances = dbInstances.map((db) => this.convertDBInstanceToInstance(db));
-    if (_optionalChain([options, 'optionalAccess', _266 => _266.status])) {
+    if (_optionalChain([options, 'optionalAccess', _270 => _270.status])) {
       instances = instances.filter((i) => i.status === options.status);
     }
     return { instances, total };
@@ -11028,9 +11268,9 @@ var WorkflowInstanceService = class extends BaseService {
       return { instances: [], total: 0 };
     }
     const { instances: dbInstances, total } = await this.adapter.workflowInstances.findByRecordInSlots(objectName, recordId, {
-      status: _optionalChain([options, 'optionalAccess', _267 => _267.status]),
-      limit: _optionalChain([options, 'optionalAccess', _268 => _268.limit]),
-      offset: _optionalChain([options, 'optionalAccess', _269 => _269.offset])
+      status: _optionalChain([options, 'optionalAccess', _271 => _271.status]),
+      limit: _optionalChain([options, 'optionalAccess', _272 => _272.limit]),
+      offset: _optionalChain([options, 'optionalAccess', _273 => _273.offset])
     });
     const instances = dbInstances.map((db) => this.convertDBInstanceToInstance(db));
     return { instances, total };
@@ -11406,7 +11646,7 @@ var WorkflowParticipationService = class extends BaseService {
         SchemaErrorCode.RECORD_NOT_FOUND
       );
     }
-    const template = _optionalChain([instance, 'access', _270 => _270.workflowSnapshot, 'access', _271 => _271.participants, 'optionalAccess', _272 => _272.find, 'call', _273 => _273(
+    const template = _optionalChain([instance, 'access', _274 => _274.workflowSnapshot, 'access', _275 => _275.participants, 'optionalAccess', _276 => _276.find, 'call', _277 => _277(
       (p) => p.id === input.participantTemplateId
     )]);
     if (!template) {
@@ -11708,7 +11948,7 @@ var WorkflowRelationService = class extends BaseService {
         if (attr.type !== "relation") continue;
         for (const slot of slots) {
           const slotData = context.slots[slot.id];
-          const slotRecordId = _optionalChain([slotData, 'optionalAccess', _274 => _274.id]);
+          const slotRecordId = _optionalChain([slotData, 'optionalAccess', _278 => _278.id]);
           if (!slotRecordId) continue;
           const targetsSlotObject = attr.targets.some(
             (t) => t.object === slot.objectName
@@ -11773,7 +12013,7 @@ var WorkflowRelationService = class extends BaseService {
 var UserProfileService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
-    this.auditService = _optionalChain([options, 'optionalAccess', _275 => _275.auditService]);
+    this.auditService = _optionalChain([options, 'optionalAccess', _279 => _279.auditService]);
   }
   // ============================================================================
   // CACHE MANAGEMENT
@@ -11936,7 +12176,7 @@ var UserProfileService = class extends BaseService {
    */
   async deleteProfile(profileId, options) {
     const profile = await this.getProfileOrThrow(profileId);
-    if (_optionalChain([options, 'optionalAccess', _276 => _276.checkAdmin])) {
+    if (_optionalChain([options, 'optionalAccess', _280 => _280.checkAdmin])) {
       if (profile.role === "admin") {
         const adminCount = await this.adapter.userProfiles.countByRole("admin");
         if (adminCount <= 1) {
@@ -12011,7 +12251,7 @@ var UserProfileService = class extends BaseService {
    */
   async hasRole(profileId, role) {
     const profile = await this.getProfile(profileId);
-    return _optionalChain([profile, 'optionalAccess', _277 => _277.role]) === role;
+    return _optionalChain([profile, 'optionalAccess', _281 => _281.role]) === role;
   }
   /**
    * Check if user is admin
@@ -12068,7 +12308,7 @@ var UserProfileService = class extends BaseService {
 var FileService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
-    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _278 => _278.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
+    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _282 => _282.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
   }
   // ============================================================================
   // UPLOAD (requires StorageAdapter)
@@ -12200,7 +12440,7 @@ var FileService = class extends BaseService {
    */
   async getFile(fileId) {
     const file2 = await this.adapter.files.findById(fileId);
-    if (_optionalChain([file2, 'optionalAccess', _279 => _279.deletedAt])) {
+    if (_optionalChain([file2, 'optionalAccess', _283 => _283.deletedAt])) {
       return null;
     }
     return file2;
@@ -12262,12 +12502,12 @@ var FileService = class extends BaseService {
    */
   async deleteFile(fileId, options) {
     const file2 = await this.getFileOrThrow(fileId);
-    if (_optionalChain([options, 'optionalAccess', _280 => _280.checkOwnership]) && options.userId) {
+    if (_optionalChain([options, 'optionalAccess', _284 => _284.checkOwnership]) && options.userId) {
       if (file2.uploadedBy !== options.userId) {
         throw new Error("You can only delete files you uploaded");
       }
     }
-    if (_optionalChain([options, 'optionalAccess', _281 => _281.hard])) {
+    if (_optionalChain([options, 'optionalAccess', _285 => _285.hard])) {
       await this.adapter.files.hardDelete(fileId);
     } else {
       await this.adapter.files.delete(fileId);
@@ -12298,7 +12538,7 @@ var FileService = class extends BaseService {
     }
     const file2 = await this.getFileOrThrow(fileId);
     await this.adapter.storage.delete(file2.storagePath);
-    if (_optionalChain([options, 'optionalAccess', _282 => _282.hard])) {
+    if (_optionalChain([options, 'optionalAccess', _286 => _286.hard])) {
       await this.adapter.files.hardDelete(fileId);
     } else {
       await this.adapter.files.delete(fileId);
@@ -12325,10 +12565,10 @@ var FileService = class extends BaseService {
       if (!file2) {
         continue;
       }
-      if (_optionalChain([options, 'optionalAccess', _283 => _283.deleteFromStorage]) && this.adapter.storage) {
+      if (_optionalChain([options, 'optionalAccess', _287 => _287.deleteFromStorage]) && this.adapter.storage) {
         await this.adapter.storage.delete(file2.storagePath);
       }
-      if (_optionalChain([options, 'optionalAccess', _284 => _284.hard])) {
+      if (_optionalChain([options, 'optionalAccess', _288 => _288.hard])) {
         await this.adapter.files.hardDelete(fileId);
       } else {
         await this.adapter.files.delete(fileId);
@@ -12339,7 +12579,7 @@ var FileService = class extends BaseService {
           actorId: this.userId,
           fileId,
           fileName: file2.name,
-          metadata: { deletedFromStorage: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _285 => _285.deleteFromStorage]), () => ( false)) }
+          metadata: { deletedFromStorage: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _289 => _289.deleteFromStorage]), () => ( false)) }
         });
       }
     }
@@ -12423,7 +12663,7 @@ var FileService = class extends BaseService {
       return true;
     }
     if (file2.visibility === "restricted") {
-      return _nullishCoalesce(_optionalChain([file2, 'access', _286 => _286.allowedUsers, 'optionalAccess', _287 => _287.includes, 'call', _288 => _288(userId)]), () => ( false));
+      return _nullishCoalesce(_optionalChain([file2, 'access', _290 => _290.allowedUsers, 'optionalAccess', _291 => _291.includes, 'call', _292 => _292(userId)]), () => ( false));
     }
     return false;
   }
@@ -12588,10 +12828,10 @@ var GlobalSearchService = class extends BaseService {
    */
   async executeSearch(query, options) {
     return await this.adapter.objectRecords.globalSearch(query, {
-      limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _289 => _289.limit]), () => ( 20)),
-      offset: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _290 => _290.offset]), () => ( 0)),
-      objectNames: _optionalChain([options, 'optionalAccess', _291 => _291.objectNames]),
-      includeObjectInfo: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _292 => _292.includeObjectInfo]), () => ( true))
+      limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _293 => _293.limit]), () => ( 20)),
+      offset: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _294 => _294.offset]), () => ( 0)),
+      objectNames: _optionalChain([options, 'optionalAccess', _295 => _295.objectNames]),
+      includeObjectInfo: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _296 => _296.includeObjectInfo]), () => ( true))
     });
   }
   /**
@@ -12641,7 +12881,7 @@ var PermissionService = class extends BaseService {
     }
     this.permissionsRepo = adapter.permissions;
     this.permissionCache = _nullishCoalesce(adapter.cache, () => ( new NoopCacheAdapter()));
-    this.auditService = _optionalChain([options, 'optionalAccess', _293 => _293.auditService]);
+    this.auditService = _optionalChain([options, 'optionalAccess', _297 => _297.auditService]);
   }
   // ============================================================================
   // PERMISSION CHECKS
@@ -12660,11 +12900,11 @@ var PermissionService = class extends BaseService {
       return true;
     }
     const wildcardPerms = permissions.objectPermissions["*"];
-    if (_optionalChain([wildcardPerms, 'optionalAccess', _294 => _294.includes, 'call', _295 => _295(action)])) {
+    if (_optionalChain([wildcardPerms, 'optionalAccess', _298 => _298.includes, 'call', _299 => _299(action)])) {
       return true;
     }
     const objectPerms = permissions.objectPermissions[objectName];
-    return _nullishCoalesce(_optionalChain([objectPerms, 'optionalAccess', _296 => _296.includes, 'call', _297 => _297(action)]), () => ( false));
+    return _nullishCoalesce(_optionalChain([objectPerms, 'optionalAccess', _300 => _300.includes, 'call', _301 => _301(action)]), () => ( false));
   }
   /**
    * Check if user can access an object, throw ForbiddenError if not.
@@ -12719,12 +12959,12 @@ var PermissionService = class extends BaseService {
     if (permissions.isAdmin) {
       return true;
     }
-    const wildcardPerms = _optionalChain([permissions, 'access', _298 => _298.systemPermissions, 'optionalAccess', _299 => _299["*"]]);
-    if (_optionalChain([wildcardPerms, 'optionalAccess', _300 => _300.includes, 'call', _301 => _301(action)])) {
+    const wildcardPerms = _optionalChain([permissions, 'access', _302 => _302.systemPermissions, 'optionalAccess', _303 => _303["*"]]);
+    if (_optionalChain([wildcardPerms, 'optionalAccess', _304 => _304.includes, 'call', _305 => _305(action)])) {
       return true;
     }
-    const resourcePerms = _optionalChain([permissions, 'access', _302 => _302.systemPermissions, 'optionalAccess', _303 => _303[resource]]);
-    return _nullishCoalesce(_optionalChain([resourcePerms, 'optionalAccess', _304 => _304.includes, 'call', _305 => _305(action)]), () => ( false));
+    const resourcePerms = _optionalChain([permissions, 'access', _306 => _306.systemPermissions, 'optionalAccess', _307 => _307[resource]]);
+    return _nullishCoalesce(_optionalChain([resourcePerms, 'optionalAccess', _308 => _308.includes, 'call', _309 => _309(action)]), () => ( false));
   }
   /**
    * Check if user can access a system resource, throw ForbiddenError if not.
@@ -12753,8 +12993,8 @@ var PermissionService = class extends BaseService {
     if (permissions.isAdmin) {
       return { canRead: true, canCreate: true, canUpdate: true, canDelete: true };
     }
-    const wildcardPerms = _nullishCoalesce(_optionalChain([permissions, 'access', _306 => _306.systemPermissions, 'optionalAccess', _307 => _307["*"]]), () => ( []));
-    const resourcePerms = _nullishCoalesce(_optionalChain([permissions, 'access', _308 => _308.systemPermissions, 'optionalAccess', _309 => _309[resource]]), () => ( []));
+    const wildcardPerms = _nullishCoalesce(_optionalChain([permissions, 'access', _310 => _310.systemPermissions, 'optionalAccess', _311 => _311["*"]]), () => ( []));
+    const resourcePerms = _nullishCoalesce(_optionalChain([permissions, 'access', _312 => _312.systemPermissions, 'optionalAccess', _313 => _313[resource]]), () => ( []));
     const allPerms = /* @__PURE__ */ new Set([...wildcardPerms, ...resourcePerms]);
     return {
       canRead: allPerms.has("read"),
@@ -12896,7 +13136,7 @@ var PermissionService = class extends BaseService {
         action: "role.updated",
         actorId: this.userId,
         roleId,
-        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _310 => _310.label]), () => ( roleId)),
+        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _314 => _314.label]), () => ( roleId)),
         metadata: { permissionsUpdated: true, permissionCount: permissions.length }
       });
     }
@@ -12926,7 +13166,7 @@ var PermissionService = class extends BaseService {
         action: "role.assigned",
         actorId: this.userId,
         roleId,
-        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _311 => _311.label]), () => ( roleId)),
+        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _315 => _315.label]), () => ( roleId)),
         targetUserId: userProfileId
       });
     }
@@ -12944,7 +13184,7 @@ var PermissionService = class extends BaseService {
         action: "role.revoked",
         actorId: this.userId,
         roleId,
-        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _312 => _312.label]), () => ( roleId)),
+        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _316 => _316.label]), () => ( roleId)),
         targetUserId: userProfileId
       });
     }