@stndrds/schema 0.1.0-alpha.35 → 0.1.0-alpha.37

package/dist/{chunk-EIRY4I7Q.mjs → chunk-OXPVVEZS.mjs}

@@ -2,6 +2,93 @@ import {
   __require
 } from "./chunk-Y6FXYEAI.mjs";
 
+// src/runtime/cache.ts
+var cacheKeys = {
+  // -------------------------------------------------------------------------
+  // Schemas - TTL: 1 hour (rarely change)
+  // -------------------------------------------------------------------------
+  /** Object schema by ID */
+  objectSchema: (tenantId, objectId) => `schema:${tenantId}:obj:${objectId}`,
+  /** Object schema by name */
+  objectSchemaByName: (tenantId, name) => `schema:${tenantId}:name:${name}`,
+  /** List of all object schemas */
+  objectSchemaList: (tenantId) => `schema:${tenantId}:list`,
+  // -------------------------------------------------------------------------
+  // Attributes - TTL: 1 hour (rarely change)
+  // -------------------------------------------------------------------------
+  /** Attributes for an object */
+  objectAttributes: (tenantId, objectId) => `attrs:${tenantId}:${objectId}`,
+  // -------------------------------------------------------------------------
+  // Permissions - TTL: 15 minutes (medium volatility)
+  // -------------------------------------------------------------------------
+  /** Effective permissions for a user */
+  userPermissions: (tenantId, userId) => `perms:${tenantId}:user:${userId}`,
+  // -------------------------------------------------------------------------
+  // Relations - TTL: 5 minutes (medium volatility)
+  // -------------------------------------------------------------------------
+  /** Relation options for an attribute */
+  relationOptions: (tenantId, attrId, hash) => `rel:${tenantId}:${attrId}:${hash}`,
+  // -------------------------------------------------------------------------
+  // Rollups - TTL: 2 minutes (high volatility)
+  // -------------------------------------------------------------------------
+  /** Computed rollup value for a record */
+  rollupValue: (tenantId, recordId, attrName) => `rollup:${tenantId}:${recordId}:${attrName}`,
+  // -------------------------------------------------------------------------
+  // Invalidation Patterns
+  // -------------------------------------------------------------------------
+  /** All schema cache for a tenant */
+  allSchemas: (tenantId) => `schema:${tenantId}:*`,
+  /** All attribute cache for a tenant */
+  allAttributes: (tenantId) => `attrs:${tenantId}:*`,
+  /** All permission cache for a tenant */
+  allPermissions: (tenantId) => `perms:${tenantId}:*`,
+  /** All relation cache for a tenant */
+  allRelations: (tenantId) => `rel:${tenantId}:*`,
+  /** All rollup cache for a tenant */
+  allRollups: (tenantId) => `rollup:${tenantId}:*`,
+  /** All rollups for a specific record */
+  rollupsByRecord: (tenantId, recordId) => `rollup:${tenantId}:${recordId}:*`,
+  /** All cache for a tenant (nuclear option) */
+  allForTenant: (tenantId) => `*:${tenantId}:*`
+};
+var cacheTtl = {
+  /** Object schemas - rarely change (1 hour) */
+  schema: 60 * 60 * 1e3,
+  /** Schema list - new objects more frequent (5 minutes) */
+  schemaList: 5 * 60 * 1e3,
+  /** Object attributes - rarely change (1 hour) */
+  attributes: 60 * 60 * 1e3,
+  /** User permissions - medium volatility (15 minutes) */
+  permissions: 15 * 60 * 1e3,
+  /** Relation options - medium volatility (5 minutes) */
+  relations: 5 * 60 * 1e3,
+  /** Rollup values - high volatility (2 minutes) */
+  rollup: 2 * 60 * 1e3
+};
+var NoopCacheAdapter = class {
+  get() {
+    return Promise.resolve(null);
+  }
+  set() {
+    return Promise.resolve();
+  }
+  delete() {
+    return Promise.resolve();
+  }
+  deletePattern() {
+    return Promise.resolve();
+  }
+  has() {
+    return Promise.resolve(false);
+  }
+  clear() {
+    return Promise.resolve();
+  }
+  getOrSet(_key, fetcher) {
+    return fetcher();
+  }
+};
+
 // src/runtime/client/types.ts
 function formatRecord(record) {
   return {
@@ -6284,6 +6371,7 @@ var ObjectSchemaService = class extends TenantAwareService {
     this.adapter = adapter;
     this.nativeRegistry = nativeRegistry;
     this.auditService = options?.auditService;
+    this.cache = options?.cache ?? adapter.cache;
   }
   /**
    * Create a new custom object.
@@ -6359,6 +6447,7 @@ var ObjectSchemaService = class extends TenantAwareService {
       attributes: createdAttributes,
       system: false
     };
+    await this.invalidateSchemaCache();
     if (this.auditService && this.userId) {
       await this.auditService.logSchemaAction({
         action: "object.created",
@@ -6406,6 +6495,7 @@ var ObjectSchemaService = class extends TenantAwareService {
       // Always false for attributes added via API
       config
     });
+    await this.invalidateSchemaCache();
     if (this.auditService && this.userId) {
       await this.auditService.logSchemaAction({
         action: "attribute.created",
@@ -6485,6 +6575,7 @@ var ObjectSchemaService = class extends TenantAwareService {
         });
       }
     }
+    await this.invalidateSchemaCache();
     if (updates.required !== void 0 && updates.required !== oldValues.required) {
       const schema = await this.getObjectSchema(dbAttr.objectId);
       await this.adapter.objectRecords.batchRefreshStatus(
@@ -6519,6 +6610,7 @@ var ObjectSchemaService = class extends TenantAwareService {
     }
     await this.adapter.attributes.delete(attributeId);
     await this.adapter.objectRecords.removeAttributeData(dbAttr.objectId, dbAttr.name);
+    await this.invalidateSchemaCache();
     if (this.auditService && this.userId) {
       await this.auditService.logSchemaAction({
         action: "attribute.deleted",
@@ -6619,6 +6711,7 @@ var ObjectSchemaService = class extends TenantAwareService {
     }
     const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
     const attributes = dbAttributes.map((attr) => this.convertDBAttributeToAttribute(attr));
+    await this.invalidateSchemaCache();
     if (updates.labelExpression !== void 0 && updates.labelExpression !== oldValues.labelExpression) {
       const newExpression = updates.labelExpression;
       await this.adapter.objectRecords.batchRefreshLabels(objectId, (values) => {
@@ -6656,6 +6749,7 @@ var ObjectSchemaService = class extends TenantAwareService {
       throw new ObjectReferencedError(dbObject.name, referencingObjects);
     }
     await this.adapter.objects.delete(objectId);
+    await this.invalidateSchemaCache();
     if (this.auditService && this.userId) {
       await this.auditService.logSchemaAction({
         action: "object.deleted",
@@ -6699,10 +6793,26 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
    * Get complete object schema (object attributes + system attributes)
    * Includes system attributes (createdAt, updatedAt, createdBy, lastUpdatedBy)
    *
+   * Results are cached if a CacheAdapter is configured.
+   *
    * @param objectId - Object UUID from database
    * @returns Complete ObjectDefinition with all attributes including system attributes
    */
   async getObjectSchema(objectId) {
+    if (this.cache) {
+      const cacheKey = cacheKeys.objectSchema(this.tenantId, objectId);
+      return this.cache.getOrSet(
+        cacheKey,
+        () => this.fetchObjectSchemaById(objectId),
+        cacheTtl.schema
+      );
+    }
+    return this.fetchObjectSchemaById(objectId);
+  }
+  /**
+   * Internal method to fetch object schema by ID (no caching)
+   */
+  async fetchObjectSchemaById(objectId) {
     const dbObject = await this.adapter.objects.findById(objectId);
     if (!dbObject) {
       throw new Error(`Object with id "${objectId}" not found`);
@@ -6723,8 +6833,24 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
   /**
    * Get object schema by name (supports both native and custom objects).
    * Automatically uses tenant context from AsyncLocalStorage.
+   *
+   * Results are cached if a CacheAdapter is configured.
    */
   async getObjectSchemaByNameForTenant(name) {
+    if (this.cache) {
+      const cacheKey = cacheKeys.objectSchemaByName(this.tenantId, name);
+      return this.cache.getOrSet(
+        cacheKey,
+        () => this.fetchObjectSchemaByName(name),
+        cacheTtl.schema
+      );
+    }
+    return this.fetchObjectSchemaByName(name);
+  }
+  /**
+   * Internal method to fetch object schema by name (no caching)
+   */
+  async fetchObjectSchemaByName(name) {
     let dbObject = await this.adapter.objects.findByName(name);
     if (!dbObject) {
       dbObject = await this.adapter.objects.findSystemByName(name);
@@ -6737,11 +6863,32 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
   /**
    * List all object schemas.
    * Automatically uses tenant context from AsyncLocalStorage.
+   *
+   * Results are cached if a CacheAdapter is configured.
    */
   async listObjectSchemas() {
+    if (this.cache) {
+      const cacheKey = cacheKeys.objectSchemaList(this.tenantId);
+      return this.cache.getOrSet(cacheKey, () => this.fetchObjectSchemaList(), cacheTtl.schemaList);
+    }
+    return this.fetchObjectSchemaList();
+  }
+  /**
+   * Internal method to fetch all object schemas (no caching)
+   */
+  async fetchObjectSchemaList() {
     const dbObjects = await this.adapter.objects.list();
     return Promise.all(dbObjects.map((dbObject) => this.buildObjectDefinition(dbObject)));
   }
+  /**
+   * Invalidate all schema-related cache for the current tenant.
+   * Called automatically after schema mutations.
+   */
+  async invalidateSchemaCache() {
+    if (!this.cache) return;
+    await this.cache.deletePattern(cacheKeys.allSchemas(this.tenantId));
+    await this.cache.deletePattern(cacheKeys.allAttributes(this.tenantId));
+  }
   // ============================================================================
   // PRIVATE HELPERS - SCHEMA BUILDING
   // ============================================================================
@@ -6951,17 +7098,13 @@ var PermissionService = class extends TenantAwareService {
   constructor(adapter, options) {
     super();
     this.adapter = adapter;
-    this.cache = /* @__PURE__ */ new Map();
-    /** Track pending permission fetches to prevent duplicate concurrent requests */
-    this.pendingFetches = /* @__PURE__ */ new Map();
     if (!adapter.permissions) {
       throw new Error(
         "PermissionService requires a DatabaseAdapter with permissions repository. Make sure your adapter implements the permissions property."
       );
     }
     this.permissionsRepo = adapter.permissions;
-    this.cacheTtlMs = options?.cacheTtlMs ?? 6e4;
-    this.maxCacheSize = options?.maxCacheSize ?? 1e4;
+    this.cache = options?.cache ?? adapter.cache ?? new NoopCacheAdapter();
     this.auditService = options?.auditService;
   }
   // ============================================================================
@@ -7089,46 +7232,18 @@ var PermissionService = class extends TenantAwareService {
   // ============================================================================
   /**
    * Get effective permissions for a user.
-   * Results are cached with TTL and size limit.
+   * Results are cached using CacheAdapter with TTL.
    *
    * @param userProfileId - User profile ID
    * @returns Merged permissions from all user's roles
    */
   async getEffectivePermissions(userProfileId) {
-    const cacheKey = this.getCacheKey(userProfileId);
-    const cached = this.cache.get(cacheKey);
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.permissions;
-    }
-    const pendingFetch = this.pendingFetches.get(cacheKey);
-    if (pendingFetch) {
-      return pendingFetch;
-    }
-    const fetchPromise = this.fetchAndCachePermissions(userProfileId, cacheKey);
-    this.pendingFetches.set(cacheKey, fetchPromise);
-    try {
-      return await fetchPromise;
-    } finally {
-      this.pendingFetches.delete(cacheKey);
-    }
-  }
-  /**
-   * Fetch permissions from database and cache the result
-   * @internal
-   */
-  async fetchAndCachePermissions(userProfileId, cacheKey) {
-    const permissions = await this.permissionsRepo.getEffectivePermissions(userProfileId);
-    if (this.cache.size >= this.maxCacheSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(cacheKey, {
-      permissions,
-      expiresAt: Date.now() + this.cacheTtlMs
-    });
-    return permissions;
+    const cacheKey = cacheKeys.userPermissions(this.tenantId, userProfileId);
+    return this.cache.getOrSet(
+      cacheKey,
+      () => this.permissionsRepo.getEffectivePermissions(userProfileId),
+      cacheTtl.permissions
+    );
   }
   // ============================================================================
   // CACHE MANAGEMENT
@@ -7137,24 +7252,15 @@ var PermissionService = class extends TenantAwareService {
    * Invalidate cached permissions for a specific user.
    * Call this after role/permission changes.
    */
-  invalidateCache(userProfileId) {
-    this.cache.delete(this.getCacheKey(userProfileId));
+  async invalidateCache(userProfileId) {
+    await this.cache.delete(cacheKeys.userPermissions(this.tenantId, userProfileId));
   }
   /**
-   * Invalidate all cached permissions.
+   * Invalidate all cached permissions for the current tenant.
    * Call this after bulk role/permission changes.
    */
-  invalidateAllCache() {
-    this.cache.clear();
-  }
-  /**
-   * Get current cache size (for monitoring).
-   */
-  getCacheSize() {
-    return this.cache.size;
-  }
-  getCacheKey(userProfileId) {
-    return `${this.tenantId}:${userProfileId}`;
+  async invalidateAllCache() {
+    await this.cache.deletePattern(cacheKeys.allPermissions(this.tenantId));
   }
   // ============================================================================
   // ROLE MANAGEMENT
@@ -7516,10 +7622,11 @@ var registry = new NativeObjectRegistryClass();
 
 // src/runtime/services/relation.service.ts
 var RelationService = class extends TenantAwareService {
-  constructor(adapter, nativeRegistry) {
+  constructor(adapter, nativeRegistry, options) {
     super();
     this.adapter = adapter;
-    this.schemaService = new ObjectSchemaService(adapter, nativeRegistry);
+    this.cache = options?.cache ?? adapter.cache;
+    this.schemaService = new ObjectSchemaService(adapter, nativeRegistry, { cache: this.cache });
   }
   /**
    * Validate all relation attributes in the data
@@ -7786,12 +7893,15 @@ var RelationService = class extends TenantAwareService {
 
 // src/runtime/services/rollup.service.ts
 var RollupService = class {
-  constructor(adapter) {
+  constructor(adapter, options) {
     this.adapter = adapter;
+    this.cache = options?.cache ?? adapter.cache;
   }
   /**
    * Calculate a rollup value for a record
    *
+   * Results are cached if a CacheAdapter is configured.
+   *
    * @param recordId - ID of the parent record
    * @param rollupAttr - Rollup attribute definition
    * @param schema - Schema of the parent object
@@ -7815,6 +7925,21 @@ var RollupService = class {
    * ```
    */
   async calculate(recordId, rollupAttr, schema) {
+    if (this.cache) {
+      const tenantId = getTenantId();
+      const cacheKey = cacheKeys.rollupValue(tenantId, recordId, rollupAttr.name);
+      return this.cache.getOrSet(
+        cacheKey,
+        () => this.computeRollup(recordId, rollupAttr, schema),
+        cacheTtl.rollup
+      );
+    }
+    return this.computeRollup(recordId, rollupAttr, schema);
+  }
+  /**
+   * Internal method to compute rollup value (no caching)
+   */
+  async computeRollup(recordId, rollupAttr, schema) {
     const relationAttr = schema.attributes.find(
       (a) => a.type === "relation" && a.name === rollupAttr.relationAttribute
     );
@@ -8017,9 +8142,14 @@ var RollupService = class {
       return record;
     }
     const updates = {};
-    for (const attr of rollupAttrs) {
-      const result = await this.calculate(record.id, attr, schema);
-      updates[attr.name] = result.value;
+    const results = await Promise.all(
+      rollupAttrs.map(async (attr) => {
+        const result = await this.calculate(record.id, attr, schema);
+        return { name: attr.name, value: result.value };
+      })
+    );
+    for (const { name, value } of results) {
+      updates[name] = value;
     }
     return await this.adapter.objectRecords.update(record.id, updates);
   }
@@ -8048,6 +8178,31 @@ var RollupService = class {
     }
     return [...new Set(affectedIds)];
   }
+  /**
+   * Invalidate cached rollups for affected parent records.
+   * Call this after a child record is created, updated, or deleted.
+   *
+   * @param affectedParentIds - Array of parent record IDs whose rollups need invalidation
+   */
+  async invalidateAffectedRollups(affectedParentIds) {
+    if (!this.cache || affectedParentIds.length === 0) return;
+    const tenantId = getTenantId();
+    const cache = this.cache;
+    await Promise.all(
+      affectedParentIds.map(
+        (parentId) => cache.deletePattern(cacheKeys.rollupsByRecord(tenantId, parentId))
+      )
+    );
+  }
+  /**
+   * Invalidate all cached rollups for the current tenant.
+   * Use sparingly - prefer targeted invalidation.
+   */
+  async invalidateAllRollups() {
+    if (!this.cache) return;
+    const tenantId = getTenantId();
+    await this.cache.deletePattern(cacheKeys.allRollups(tenantId));
+  }
   /**
    * Find records that have forward rollups pointing to the modified record.
    *
@@ -8910,24 +9065,28 @@ var RecordService = class extends TenantAwareService {
     const affectedParentIds = await this.rollupService.findAffectedParentRecords(record, schema);
     if (affectedParentIds.length > 0) {
       const parentRecords = await this.adapter.objectRecords.findByIds(affectedParentIds);
-      for (const parentRecord of parentRecords) {
-        const parentSchema = await this.schemaService.getObjectSchema(parentRecord.objectId);
-        const rollupAttrs = parentSchema.attributes.filter(
-          (a) => a.type === "rollup"
-        );
-        if (rollupAttrs.length > 0) {
-          await this.rollupService.recalculateAndUpdate(parentRecord, parentSchema);
-        }
-      }
+      await Promise.all(
+        parentRecords.map(async (parentRecord) => {
+          const parentSchema = await this.schemaService.getObjectSchema(parentRecord.objectId);
+          const rollupAttrs = parentSchema.attributes.filter(
+            (a) => a.type === "rollup"
+          );
+          if (rollupAttrs.length > 0) {
+            await this.rollupService.recalculateAndUpdate(parentRecord, parentSchema);
+          }
+        })
+      );
     }
     const affectedForwardRecords = await this.rollupService.findRecordsWithForwardRollup(
       record,
       schema
     );
-    for (const forwardRecord of affectedForwardRecords) {
-      const forwardSchema = await this.schemaService.getObjectSchema(forwardRecord.objectId);
-      await this.rollupService.recalculateAndUpdate(forwardRecord, forwardSchema);
-    }
+    await Promise.all(
+      affectedForwardRecords.map(async (forwardRecord) => {
+        const forwardSchema = await this.schemaService.getObjectSchema(forwardRecord.objectId);
+        await this.rollupService.recalculateAndUpdate(forwardRecord, forwardSchema);
+      })
+    );
   }
   /**
    * Permanently delete a record (hard delete)
@@ -10237,6 +10396,9 @@ export {
   getMissingRequiredAttributes,
   isRecordComplete,
   computeRecordStatus,
+  cacheKeys,
+  cacheTtl,
+  NoopCacheAdapter,
   formatRecord,
   formatRecords,
   createDefaultState,