@stndrds/schema 0.1.0-alpha.40 → 0.1.0-alpha.42

package/dist/{chunk-2C24E4Q2.mjs → chunk-MXYJTCA3.mjs}

@@ -482,7 +482,7 @@ var TenantContextError = class _TenantContextError extends Error {
   }
 };
 
-// src/runtime/context/tenant-context.ts
+// src/runtime/context/schema-context.ts
 var browserStub = {
   getStore: () => void 0,
   run: (_store, callback) => callback()
@@ -520,8 +520,102 @@ function getStorage() {
   storageInstance = browserStub;
   return storageInstance;
 }
-function getContext() {
+function getSchemaFromContext(objectId) {
+  const ctx = getStorage().getStore();
+  return ctx?.objectsById.get(objectId);
+}
+function getSchemaByNameFromContext(objectName) {
+  const ctx = getStorage().getStore();
+  return ctx?.objectsByName.get(objectName);
+}
+function hasSchemaContext() {
+  return getStorage().getStore() !== void 0;
+}
+function getSchemaContext() {
+  return getStorage().getStore();
+}
+function addSchemaToContext(schema) {
   const ctx = getStorage().getStore();
+  if (!ctx) {
+    return;
+  }
+  if (schema.id) {
+    ctx.objectsById.set(schema.id, schema);
+  }
+  ctx.objectsByName.set(schema.name, schema);
+}
+function buildSchemaContext(schemas) {
+  const objectsById = /* @__PURE__ */ new Map();
+  const objectsByName = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    if (schema.id) {
+      objectsById.set(schema.id, schema);
+    }
+    objectsByName.set(schema.name, schema);
+  }
+  return { objectsById, objectsByName };
+}
+function runWithSchemaContext(schemas, fn) {
+  const context = buildSchemaContext(schemas);
+  return getStorage().run(context, fn);
+}
+function runWithMergedSchemaContext(schemas, fn) {
+  const existing = getStorage().getStore();
+  const objectsById = new Map(existing?.objectsById);
+  const objectsByName = new Map(existing?.objectsByName);
+  for (const schema of schemas) {
+    if (schema.id) {
+      objectsById.set(schema.id, schema);
+    }
+    objectsByName.set(schema.name, schema);
+  }
+  const context = {
+    objectsById,
+    objectsByName
+  };
+  return getStorage().run(context, fn);
+}
+
+// src/runtime/context/tenant-context.ts
+var browserStub2 = {
+  getStore: () => void 0,
+  run: (_store, callback) => callback()
+};
+var AsyncLocalStorageClass2 = null;
+if (typeof process !== "undefined" && process.versions?.node) {
+  try {
+    if (typeof __require !== "undefined") {
+      const asyncHooks = __require("async_hooks");
+      AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+    }
+  } catch {
+    try {
+      const dynamicRequire = new Function(
+        "m",
+        'return typeof require!=="undefined"?require(m):null'
+      );
+      const asyncHooks = dynamicRequire("node:async_hooks");
+      if (asyncHooks) {
+        AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+      }
+    } catch {
+    }
+  }
+}
+var storageInstance2 = null;
+function getStorage2() {
+  if (storageInstance2 !== null) {
+    return storageInstance2;
+  }
+  if (AsyncLocalStorageClass2) {
+    storageInstance2 = new AsyncLocalStorageClass2();
+    return storageInstance2;
+  }
+  storageInstance2 = browserStub2;
+  return storageInstance2;
+}
+function getContext() {
+  const ctx = getStorage2().getStore();
   if (!ctx) {
     throw new TenantContextError();
   }
@@ -534,11 +628,11 @@ function getUserId() {
   return getContext().userId;
 }
 function hasContext() {
-  return getStorage().getStore() !== void 0;
+  return getStorage2().getStore() !== void 0;
 }
 function runWithContext(context, fn) {
   const frozenContext = Object.freeze({ ...context });
-  return getStorage().run(frozenContext, fn);
+  return getStorage2().run(frozenContext, fn);
 }
 function withTenantContext(tenantId, fn, userId) {
   return runWithContext({ tenantId, userId }, fn);
@@ -2315,8 +2409,14 @@ function formatCheckbox(value) {
 function formatNumber(value, attribute) {
   if (typeof value !== "number") return String(value);
   const decimals = attribute.decimals;
-  if (attribute.unit === "percentage") {
+  if (attribute.unit === "integer") {
     return value.toLocaleString(void 0, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 0
+    });
+  }
+  if (attribute.unit === "percentage") {
+    return (value / 100).toLocaleString(void 0, {
       style: "percent",
       minimumFractionDigits: decimals,
       maximumFractionDigits: decimals
@@ -3200,11 +3300,11 @@ function createMockObjectRecordsRepository(stores) {
       }
       return Promise.resolve(updated);
     },
-    async batchRefreshLabels(objectId, computeLabel) {
+    async batchRefreshLabels(objectId, computeLabel2) {
       let updated = 0;
       for (const record of stores.objectRecords.values()) {
         if (record.objectId === objectId) {
-          const newLabel = await computeLabel(record.values);
+          const newLabel = await computeLabel2(record.values);
           if (newLabel !== record.label) {
             record.label = newLabel;
             record.updatedAt = /* @__PURE__ */ new Date();
@@ -4122,6 +4222,20 @@ var TenantAwareRepository = class {
     return getUserId();
   }
 };
+var SchemaContextAwareRepository = class extends TenantAwareRepository {
+  /**
+   * Get an ObjectDefinition from context by its ID.
+   */
+  getSchemaFromContext(objectId) {
+    return getSchemaFromContext(objectId);
+  }
+  /**
+   * Get an ObjectDefinition from context by its name.
+   */
+  getSchemaByNameFromContext(objectName) {
+    return getSchemaByNameFromContext(objectName);
+  }
+};
 
 // src/runtime/services/audit.service.ts
 var SENSITIVE_PATTERNS = [
@@ -9349,6 +9463,8 @@ var RelationService = class extends TenantAwareService {
   }
   /**
    * Validate a single relation attribute value
+   *
+   * Uses batch fetching (findByIds) to avoid N+1 query pattern.
    */
   async validateRelationAttribute(attr, value) {
     const errors = [];
@@ -9365,9 +9481,11 @@ var RelationService = class extends TenantAwareService {
       });
       return errors;
     }
+    const records = await this.adapter.objectRecords.findByIds(ids);
+    const recordMap = new Map(records.map((r) => [r.id, r]));
     const invalidIds = [];
     for (const id of ids) {
-      const record = await this.adapter.objectRecords.findById(id);
+      const record = recordMap.get(id);
       if (!record) {
         invalidIds.push(id);
         continue;
@@ -9681,22 +9799,37 @@ var RollupService = class {
       return { value: null, recordCount: 0 };
     }
     const sourceObjectName = rollupAttr.relationAttribute;
-    const sourceObject = await this.adapter.objects.findByName(sourceObjectName);
-    if (!sourceObject) {
-      return { value: null, recordCount: 0 };
+    const sourceSchema = getSchemaByNameFromContext(sourceObjectName);
+    let sourceObjectId;
+    let reverseRelationAttrName;
+    if (sourceSchema?.id) {
+      sourceObjectId = sourceSchema.id;
+      const reverseRelationAttr = sourceSchema.attributes.find((attr) => {
+        if (attr.type !== "relation") return false;
+        const relationConfig = attr;
+        return relationConfig?.targets?.some((t) => t.object === schema.name);
+      });
+      reverseRelationAttrName = reverseRelationAttr?.name;
+    } else {
+      const sourceObject = await this.adapter.objects.findByName(sourceObjectName);
+      if (!sourceObject) {
+        return { value: null, recordCount: 0 };
+      }
+      sourceObjectId = sourceObject.id;
+      const sourceAttributes = await this.adapter.attributes.findByObjectId(sourceObject.id);
+      const reverseRelationAttr = sourceAttributes.find((attr) => {
+        if (attr.type !== "relation") return false;
+        const relationConfig = attr.config;
+        return relationConfig?.targets?.some((t) => t.object === schema.name);
+      });
+      reverseRelationAttrName = reverseRelationAttr?.name;
     }
-    const sourceAttributes = await this.adapter.attributes.findByObjectId(sourceObject.id);
-    const reverseRelationAttr = sourceAttributes.find((attr) => {
-      if (attr.type !== "relation") return false;
-      const relationConfig = attr.config;
-      return relationConfig?.targets?.some((t) => t.object === schema.name);
-    });
-    if (!reverseRelationAttr) {
+    if (!reverseRelationAttrName) {
       return { value: null, recordCount: 0 };
     }
     const relatedRecords = await this.adapter.objectRecords.findByRelation(
-      sourceObject.id,
-      reverseRelationAttr.name,
+      sourceObjectId,
+      reverseRelationAttrName,
       recordId
     );
     if (relatedRecords.length === 0) {
@@ -10079,7 +10212,7 @@ var UserService = class extends TenantAwareService {
   }
 };
 
-// src/runtime/services/record.service.ts
+// src/runtime/services/record/defaults.ts
 function applyDefaultValues(schema, data) {
   const result = { ...data };
   for (const attr of schema.attributes) {
@@ -10092,170 +10225,267 @@ function applyDefaultValues(schema, data) {
   }
   return result;
 }
-var RecordService = class extends TenantAwareService {
-  constructor(adapter, options) {
-    super();
-    this.adapter = adapter;
-    this.schemaService = new ObjectSchemaService(adapter, registry, {
-      auditService: options?.auditService
-    });
-    this.relationService = new RelationService(adapter, registry);
-    this.userService = new UserService(adapter);
-    this.rollupService = new RollupService(adapter);
-    this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
-    this.permissionService = options?.permissionService;
-    this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter) : void 0);
-    this.policyRegistry = options?.policyRegistry === null ? null : options?.policyRegistry ?? defaultPolicyRegistry;
+
+// src/runtime/services/record/access.ts
+async function checkPermission(permissionService, userId, objectName, action) {
+  if (permissionService && userId) {
+    await permissionService.checkObjectAccess(userId, objectName, action);
   }
-  /**
-   * Check permission for an action on an object.
-   * Only checks if permissionService and userId are configured.
-   * @internal
-   */
-  async checkPermission(objectName, action) {
-    if (this.permissionService && this.userId) {
-      await this.permissionService.checkObjectAccess(this.userId, objectName, action);
-    }
+}
+function getPolicy(policyRegistry, userId, objectName) {
+  if (!(policyRegistry && userId)) {
+    return void 0;
   }
-  /**
-   * Get policy for an object if one exists and userId is configured.
-   * @internal
-   */
-  getPolicy(objectName) {
-    if (!(this.policyRegistry && this.userId)) {
-      return void 0;
-    }
-    return this.policyRegistry.get(objectName);
+  return policyRegistry.get(objectName);
+}
+function buildPolicyContext(objectName, userId, tenantId) {
+  return { userId, tenantId, objectName };
+}
+function checkRecordAccess(policy, record, context) {
+  if (!policy.canAccessRecord) {
+    return true;
   }
-  /**
-   * Build policy context for the current request.
-   * @internal
-   */
-  buildPolicyContext(objectName) {
-    return {
-      // biome-ignore lint/style/noNonNullAssertion: userId is guaranteed to be set
-      userId: this.userId,
-      tenantId: this.tenantId,
-      objectName
-    };
+  return policy.canAccessRecord(context, record);
+}
+function checkRecordModifyOrThrow(policy, record, context) {
+  if (!policy.canModifyRecord) {
+    return;
   }
-  /**
-   * Check if user can access a record based on policy.
-   * Returns true if no policy exists or user can access.
-   * @internal
-   */
-  checkRecordAccess(policy, record) {
-    if (!policy.canAccessRecord) {
-      return true;
-    }
-    return policy.canAccessRecord(this.buildPolicyContext(policy.objectName), record);
+  if (!policy.canModifyRecord(context, record)) {
+    throw new PolicyViolationError(policy.objectName, "update", record.id);
   }
-  /**
-   * Check if user can modify a record based on policy.
-   * Throws PolicyViolationError if denied.
-   * @internal
-   */
-  checkRecordModify(policy, record) {
-    if (!policy.canModifyRecord) {
-      return;
-    }
-    const canModify = policy.canModifyRecord(this.buildPolicyContext(policy.objectName), record);
-    if (!canModify) {
-      throw new PolicyViolationError(policy.objectName, "update", record.id);
-    }
+}
+function checkRecordDeleteOrThrow(policy, record, context) {
+  if (!policy.canDeleteRecord) {
+    return;
   }
-  /**
-   * Check if user can delete a record based on policy.
-   * Throws PolicyViolationError if denied.
-   * @internal
-   */
-  checkRecordDelete(policy, record) {
-    if (!policy.canDeleteRecord) {
-      return;
-    }
-    const canDelete = policy.canDeleteRecord(this.buildPolicyContext(policy.objectName), record);
-    if (!canDelete) {
-      throw new PolicyViolationError(policy.objectName, "delete", record.id);
+  if (!policy.canDeleteRecord(context, record)) {
+    throw new PolicyViolationError(policy.objectName, "delete", record.id);
+  }
+}
+
+// src/runtime/services/record/label.ts
+function extractRelationIds2(val) {
+  if (typeof val === "string") return [val];
+  if (Array.isArray(val) && typeof val[0] === "string") return [val[0]];
+  return [];
+}
+async function resolveRelationLabels(relationAttrs, values, resolver) {
+  const resolvedMap = /* @__PURE__ */ new Map();
+  const idsWithAttrId = [];
+  const idsWithoutAttrId = [];
+  for (const attr of relationAttrs) {
+    const ids = extractRelationIds2(values[attr.name]);
+    if (ids.length > 0) {
+      if (attr.id) {
+        idsWithAttrId.push({ attrId: attr.id, ids });
+      } else {
+        idsWithoutAttrId.push(...ids);
+      }
     }
   }
-  /**
-   * Resolve relation IDs to their display labels
-   * @internal
-   */
-  async resolveRelationLabels(relationAttrs, values) {
-    const resolvedMap = /* @__PURE__ */ new Map();
-    const idsWithAttrId = [];
-    const idsWithoutAttrId = [];
-    for (const attr of relationAttrs) {
-      const val = values[attr.name];
-      const ids = this.extractRelationIds(val);
-      if (ids.length > 0) {
-        if (attr.id) {
-          idsWithAttrId.push({ attrId: attr.id, ids });
-        } else {
-          idsWithoutAttrId.push(...ids);
+  await Promise.all(
+    idsWithAttrId.map(async ({ attrId, ids }) => {
+      const resolved = await resolver.resolveRelationIds(ids, attrId);
+      for (const r of resolved) {
+        resolvedMap.set(r.id, r.label);
+      }
+    })
+  );
+  if (idsWithoutAttrId.length > 0) {
+    const uniqueIds = [...new Set(idsWithoutAttrId)].filter((id) => !resolvedMap.has(id));
+    if (uniqueIds.length > 0) {
+      const records = await resolver.findRecordLabels(uniqueIds);
+      for (const record of records) {
+        if (record.label) {
+          resolvedMap.set(record.id, record.label);
         }
       }
     }
+  }
+  return resolvedMap;
+}
+async function computeLabel(schema, values, resolver) {
+  const attrNames = extractAttributeNames(schema.labelExpression);
+  let enrichedValues = enrichValuesForDisplay(values, schema.attributes);
+  const relationAttrs = schema.attributes.filter(
+    (attr) => attr.type === "relation" && attrNames.includes(attr.name)
+  );
+  if (relationAttrs.length === 0) {
+    return renderLabelExpression(schema.labelExpression, enrichedValues);
+  }
+  const resolvedMap = await resolveRelationLabels(relationAttrs, values, resolver);
+  if (resolvedMap.size === 0) {
+    return renderLabelExpression(schema.labelExpression, enrichedValues);
+  }
+  enrichedValues = { ...enrichedValues };
+  for (const attr of relationAttrs) {
+    const ids = extractRelationIds2(values[attr.name]);
+    if (ids.length > 0 && resolvedMap.has(ids[0])) {
+      enrichedValues[attr.name] = resolvedMap.get(ids[0]);
+    }
+  }
+  return renderLabelExpression(schema.labelExpression, enrichedValues);
+}
+
+// src/runtime/services/record/formula.ts
+function enrichWithFormulas(record, schema) {
+  const formulaAttrs = schema.attributes.filter((a) => a.type === "formula");
+  if (formulaAttrs.length === 0) {
+    return record;
+  }
+  const enrichedValues = { ...record.values };
+  for (const attr of formulaAttrs) {
+    enrichedValues[attr.name] = evaluateFormulaAttribute(attr, record.values);
+  }
+  return {
+    ...record,
+    values: enrichedValues
+  };
+}
+function enrichRecordsWithFormulas(records, schema) {
+  const formulaAttrs = schema.attributes.filter((a) => a.type === "formula");
+  if (formulaAttrs.length === 0) {
+    return records;
+  }
+  return records.map((record) => enrichWithFormulas(record, schema));
+}
+
+// src/runtime/services/record/hook-context.ts
+function createGetChange(oldValues, newValues, changedAttributes) {
+  return (attr) => ({
+    oldValue: oldValues[attr],
+    newValue: newValues[attr],
+    changed: changedAttributes.includes(attr)
+  });
+}
+function createContextForCreate(schema, tenantId, data, metadata) {
+  const attributeNames = Object.keys(data);
+  return {
+    objectId: schema.id,
+    objectName: schema.name,
+    recordId: "",
+    // Will be set after creation
+    tenantId,
+    record: null,
+    // Will be set after creation
+    oldValues: {},
+    newValues: data,
+    changedAttributes: attributeNames,
+    // All attributes are "new"
+    getChange: createGetChange({}, data, attributeNames),
+    metadata: metadata ?? {},
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createContextForUpdate(schema, tenantId, existing, mergedData, changedAttributes, metadata) {
+  const oldValuesSnapshot = { ...existing.values };
+  return {
+    objectId: schema.id,
+    objectName: schema.name,
+    recordId: existing.id,
+    tenantId,
+    record: existing,
+    oldValues: oldValuesSnapshot,
+    newValues: mergedData,
+    changedAttributes,
+    getChange: createGetChange(oldValuesSnapshot, mergedData, changedAttributes),
+    metadata: metadata ?? {},
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createContextForDelete(schema, tenantId, record, metadata) {
+  const attributeNames = Object.keys(record.values);
+  return {
+    objectId: schema.id,
+    objectName: schema.name,
+    recordId: record.id,
+    tenantId,
+    record,
+    oldValues: record.values,
+    newValues: {},
+    changedAttributes: attributeNames,
+    // All attributes are being "removed"
+    getChange: createGetChange(record.values, {}, attributeNames),
+    metadata: metadata ?? {},
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createContextForRestore(schema, tenantId, record, metadata) {
+  return {
+    objectId: schema.id,
+    objectName: schema.name,
+    recordId: record.id,
+    tenantId,
+    record,
+    oldValues: record.values,
+    newValues: record.values,
+    changedAttributes: [],
+    getChange: createGetChange(record.values, record.values, []),
+    metadata: metadata ?? {},
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+
+// src/runtime/services/record/rollup-cascade.ts
+async function recalculateParentRollups(record, schema, ctx) {
+  const { rollupService, schemaService, findRecordsByIds } = ctx;
+  const ownRollupAttrs = schema.attributes.filter((a) => a.type === "rollup");
+  if (ownRollupAttrs.length > 0) {
+    await rollupService.recalculateAndUpdate(record, schema);
+  }
+  const affectedParentIds = await rollupService.findAffectedParentRecords(record, schema);
+  if (affectedParentIds.length > 0) {
+    const parentRecords = await findRecordsByIds(affectedParentIds);
     await Promise.all(
-      idsWithAttrId.map(async ({ attrId, ids }) => {
-        const resolved = await this.relationService.resolveIds(ids, attrId);
-        for (const r of resolved) {
-          resolvedMap.set(r.id, r.label);
+      parentRecords.map(async (parentRecord) => {
+        const parentSchema = await schemaService.getObjectSchema(parentRecord.objectId);
+        const rollupAttrs = parentSchema.attributes.filter(
+          (a) => a.type === "rollup"
+        );
+        if (rollupAttrs.length > 0) {
+          await rollupService.recalculateAndUpdate(parentRecord, parentSchema);
         }
       })
     );
-    if (idsWithoutAttrId.length > 0) {
-      const uniqueIds = [...new Set(idsWithoutAttrId)].filter((id) => !resolvedMap.has(id));
-      if (uniqueIds.length > 0) {
-        const records = await this.adapter.objectRecords.findByIds(uniqueIds);
-        for (const record of records) {
-          if (record.label) {
-            resolvedMap.set(record.id, record.label);
-          }
-        }
-      }
-    }
-    return resolvedMap;
-  }
-  /**
-   * Extract relation IDs from a value (string or array)
-   * @internal
-   */
-  extractRelationIds(val) {
-    if (typeof val === "string") return [val];
-    if (Array.isArray(val) && typeof val[0] === "string") return [val[0]];
-    return [];
   }
-  /**
-   * Compute display label from schema expression
-   * Automatically resolves relation attribute values to their labels
-   * and select/multiselect values to their option labels
-   * @internal
-   */
-  async computeLabel(schema, values) {
-    const attrNames = extractAttributeNames(schema.labelExpression);
-    let enrichedValues = enrichValuesForDisplay(values, schema.attributes);
-    const relationAttrs = schema.attributes.filter(
-      (attr) => attr.type === "relation" && attrNames.includes(attr.name)
-    );
-    if (relationAttrs.length === 0) {
-      return renderLabelExpression(schema.labelExpression, enrichedValues);
-    }
-    const resolvedMap = await this.resolveRelationLabels(relationAttrs, values);
-    if (resolvedMap.size === 0) {
-      return renderLabelExpression(schema.labelExpression, enrichedValues);
-    }
-    enrichedValues = { ...enrichedValues };
-    for (const attr of relationAttrs) {
-      const val = values[attr.name];
-      const ids = this.extractRelationIds(val);
-      if (ids.length > 0 && resolvedMap.has(ids[0])) {
-        enrichedValues[attr.name] = resolvedMap.get(ids[0]);
-      }
-    }
-    return renderLabelExpression(schema.labelExpression, enrichedValues);
+  const affectedForwardRecords = await rollupService.findRecordsWithForwardRollup(record, schema);
+  await Promise.all(
+    affectedForwardRecords.map(async (forwardRecord) => {
+      const forwardSchema = await schemaService.getObjectSchema(forwardRecord.objectId);
+      await rollupService.recalculateAndUpdate(forwardRecord, forwardSchema);
+    })
+  );
+}
+
+// src/runtime/services/record.service.ts
+var RecordService = class extends TenantAwareService {
+  constructor(adapter, options) {
+    super();
+    this.adapter = adapter;
+    this.schemaService = new ObjectSchemaService(adapter, registry, {
+      auditService: options?.auditService
+    });
+    this.relationService = new RelationService(adapter, registry);
+    this.userService = new UserService(adapter);
+    this.rollupService = new RollupService(adapter);
+    this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
+    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.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)
+    };
   }
+  // ============================================================================
+  // CREATE
+  // ============================================================================
   /**
    * Create a new record with validation
    *
@@ -10265,31 +10495,17 @@ var RecordService = class extends TenantAwareService {
    * @param data - Record data (attribute values)
    * @param options - Creation options
    * @returns Created record with computed completionStatus
-   *
-   * @example
-   * ```typescript
-   * const service = new RecordService(adapter, "tenant-123");
-   *
-   * // Create a complete record (strict validation)
-   * const product = await service.createRecord("obj-product", {
-   *   name: "Nike Air Max",
-   *   price: 129.99,
-   *   status: "active"
-   * });
-   * // → product.completionStatus = "complete"
-   *
-   * // Create a draft record (allows missing required fields)
-   * const draft = await service.createRecord("obj-product", {
-   *   name: "Draft Product"
-   * }, { allowDraft: true });
-   * // → draft.completionStatus = "draft"
-   * ```
    */
   async createRecord(objectId, data, options) {
     const schema = await this.schemaService.getObjectSchema(objectId);
     const dataWithDefaults = applyDefaultValues(schema, data);
-    await this.checkPermission(schema.name, "create");
-    const hookCtx = this.buildCreateHookContext(schema, dataWithDefaults, options?.hookMetadata);
+    await checkPermission(this.permissionService, this.userId, schema.name, "create");
+    const hookCtx = createContextForCreate(
+      schema,
+      this.tenantId,
+      dataWithDefaults,
+      options?.hookMetadata
+    );
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("beforeCreate", schema.name, hookCtx);
     }
@@ -10307,7 +10523,7 @@ var RecordService = class extends TenantAwareService {
       }
     }
     const completionStatus = computeRecordStatus(schema, dataWithDefaults);
-    const label = await this.computeLabel(schema, dataWithDefaults);
+    const label = await computeLabel(schema, dataWithDefaults, this.labelResolver);
     const record = await this.adapter.objectRecords.create({
       objectId,
       data: dataWithDefaults,
@@ -10324,7 +10540,7 @@ var RecordService = class extends TenantAwareService {
       };
       await this.hookRegistry.execute("afterCreate", schema.name, afterCtx);
     }
-    await this.recalculateParentRollups(record, schema);
+    await recalculateParentRollups(record, schema, this.rollupContext);
     if (this.auditService && this.userId) {
       await this.auditService.logRecordAction({
         action: "record.created",
@@ -10338,12 +10554,11 @@ var RecordService = class extends TenantAwareService {
     }
     return record;
   }
+  // ============================================================================
+  // READ
+  // ============================================================================
   /**
    * Get a record by ID
-   *
-   * @param recordId - Record UUID
-   * @param options - Query options
-   * @returns Record or null if not found
    */
   async getRecord(recordId, options) {
     const record = await this.adapter.objectRecords.findById(recordId);
@@ -10352,14 +10567,17 @@ var RecordService = class extends TenantAwareService {
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
     if (!options?.skipPolicyCheck) {
-      const policy = this.getPolicy(schema.name);
-      if (policy && !this.checkRecordAccess(policy, record)) {
-        return null;
+      const policy = getPolicy(this.policyRegistry, this.userId, schema.name);
+      if (policy) {
+        const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
+        if (!checkRecordAccess(policy, record, ctx)) {
+          return null;
+        }
       }
     }
     let enrichedRecord = record;
     if (!options?.skipFormulas) {
-      enrichedRecord = this.enrichWithFormulas(record, schema);
+      enrichedRecord = enrichWithFormulas(record, schema);
     }
     if (options?.includeSchema) {
       const recordWithSchema = enrichedRecord;
@@ -10378,28 +10596,11 @@ var RecordService = class extends TenantAwareService {
     }
     return record;
   }
+  // ============================================================================
+  // UPDATE
+  // ============================================================================
   /**
    * Update a record with validation
-   *
-   * The completion status is automatically recalculated after each update.
-   * A draft record becomes complete when all required fields are filled.
-   *
-   * Triggers beforeUpdate and afterUpdate hooks if a HookRegistry is configured.
-   *
-   * @param recordId - Record UUID
-   * @param data - Partial data to update
-   * @param options - Update options
-   * @returns Updated record with recalculated completionStatus
-   *
-   * @example
-   * ```typescript
-   * // Update a draft record to make it complete
-   * const updated = await service.updateRecord(draftId, {
-   *   price: 99.99,
-   *   status: "active"
-   * });
-   * // → updated.completionStatus = "complete" if all required fields now present
-   * ```
    */
   async updateRecord(recordId, data, options) {
     const existing = await this.adapter.objectRecords.findById(recordId);
@@ -10407,17 +10608,18 @@ var RecordService = class extends TenantAwareService {
       throw new RecordNotFoundError(recordId);
     }
     const schema = await this.schemaService.getObjectSchema(existing.objectId);
-    await this.checkPermission(schema.name, "update");
-    const policy = this.getPolicy(schema.name);
-    if (policy) {
-      this.checkRecordModify(policy, existing);
+    await checkPermission(this.permissionService, this.userId, schema.name, "update");
+    const policy = getPolicy(this.policyRegistry, this.userId, schema.name);
+    if (policy && this.userId) {
+      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
+      checkRecordModifyOrThrow(policy, existing, ctx);
     }
     const mergedData = { ...existing.values, ...data };
     const changedAttributes = Object.keys(data).filter((key) => existing.values[key] !== data[key]);
-    const hookCtx = this.buildHookContext(
+    const hookCtx = createContextForUpdate(
       schema,
+      this.tenantId,
       existing,
-      data,
       mergedData,
       changedAttributes,
       options?.hookMetadata
@@ -10451,7 +10653,7 @@ var RecordService = class extends TenantAwareService {
       }
     }
     const completionStatus = computeRecordStatus(schema, mergedData);
-    const label = await this.computeLabel(schema, mergedData);
+    const label = await computeLabel(schema, mergedData, this.labelResolver);
     const updatePayload = {
       ...data,
       ...hookModifiedValues,
@@ -10475,7 +10677,7 @@ var RecordService = class extends TenantAwareService {
       };
       await this.hookRegistry.execute("afterUpdate", schema.name, afterCtx);
     }
-    await this.recalculateParentRollups(updated, schema);
+    await recalculateParentRollups(updated, schema, this.rollupContext);
     const allChangedAttributes = [
       ...changedAttributes,
       ...Object.keys(hookModifiedValues).filter((k) => !changedAttributes.includes(k))
@@ -10499,89 +10701,11 @@ var RecordService = class extends TenantAwareService {
     }
     return updated;
   }
+  // ============================================================================
+  // DELETE
+  // ============================================================================
   /**
-   * Build hook context for update operations
-   * @internal
-   */
-  buildHookContext(schema, existing, newData, mergedData, changedAttributes, metadata) {
-    const oldValuesSnapshot = { ...existing.values };
-    return {
-      objectId: schema.id,
-      objectName: schema.name,
-      recordId: existing.id,
-      tenantId: this.tenantId,
-      record: existing,
-      oldValues: oldValuesSnapshot,
-      newValues: mergedData,
-      changedAttributes,
-      getChange: (attr) => ({
-        oldValue: oldValuesSnapshot[attr],
-        newValue: newData[attr] ?? oldValuesSnapshot[attr],
-        changed: changedAttributes.includes(attr)
-      }),
-      metadata: metadata ?? {},
-      timestamp: /* @__PURE__ */ new Date()
-    };
-  }
-  /**
-   * Build hook context for create operations (no existing record)
-   * @internal
-   */
-  buildCreateHookContext(schema, data, metadata) {
-    const attributeNames = Object.keys(data);
-    return {
-      objectId: schema.id,
-      objectName: schema.name,
-      recordId: "",
-      // Will be set after creation
-      tenantId: this.tenantId,
-      record: null,
-      // Will be set after creation
-      oldValues: {},
-      newValues: data,
-      changedAttributes: attributeNames,
-      // All attributes are "new"
-      getChange: (attr) => ({
-        oldValue: void 0,
-        newValue: data[attr],
-        changed: attributeNames.includes(attr)
-      }),
-      metadata: metadata ?? {},
-      timestamp: /* @__PURE__ */ new Date()
-    };
-  }
-  /**
-   * Build hook context for delete operations
-   * @internal
-   */
-  buildDeleteHookContext(schema, record, metadata) {
-    const attributeNames = Object.keys(record.values);
-    return {
-      objectId: schema.id,
-      objectName: schema.name,
-      recordId: record.id,
-      tenantId: this.tenantId,
-      record,
-      oldValues: record.values,
-      newValues: {},
-      changedAttributes: attributeNames,
-      // All attributes are being "removed"
-      getChange: (attr) => ({
-        oldValue: record.values[attr],
-        newValue: void 0,
-        changed: attributeNames.includes(attr)
-      }),
-      metadata: metadata ?? {},
-      timestamp: /* @__PURE__ */ new Date()
-    };
-  }
-  /**
-   * Delete a record
-   *
-   * Triggers beforeDelete and afterDelete hooks if a HookRegistry is configured.
-   *
-   * @param recordId - Record UUID
-   * @param options - Delete options
+   * Delete a record (soft delete)
    */
   async deleteRecord(recordId, options) {
     const record = await this.adapter.objectRecords.findById(recordId);
@@ -10589,15 +10713,14 @@ var RecordService = class extends TenantAwareService {
       throw new RecordNotFoundError(recordId);
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
-    await this.checkPermission(schema.name, "delete");
-    const policy = this.getPolicy(schema.name);
-    if (policy) {
-      this.checkRecordDelete(policy, record);
+    await checkPermission(this.permissionService, this.userId, schema.name, "delete");
+    const policy = getPolicy(this.policyRegistry, this.userId, schema.name);
+    if (policy && this.userId) {
+      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
+      checkRecordDeleteOrThrow(policy, record, ctx);
     }
-    if (options?.checkSystem) {
-      if (schema.system) {
-        throw new ProtectedResourceError("object", schema.name, "delete");
-      }
+    if (options?.checkSystem && schema.system) {
+      throw new ProtectedResourceError("object", schema.name, "delete");
     }
     if (!options?.skipReferenceCheck) {
       const references = await this.adapter.objectRecords.countRecordsReferencingId(recordId);
@@ -10605,7 +10728,7 @@ var RecordService = class extends TenantAwareService {
         throw new RecordReferencedError(recordId, references);
       }
     }
-    const hookCtx = this.buildDeleteHookContext(schema, record, options?.hookMetadata);
+    const hookCtx = createContextForDelete(schema, this.tenantId, record, options?.hookMetadata);
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("beforeDelete", schema.name, hookCtx);
     }
@@ -10613,7 +10736,7 @@ var RecordService = class extends TenantAwareService {
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
     }
-    await this.recalculateParentRollups(record, schema);
+    await recalculateParentRollups(record, schema, this.rollupContext);
     if (this.auditService && this.userId) {
       await this.auditService.logRecordAction({
         action: "record.deleted",
@@ -10626,21 +10749,20 @@ var RecordService = class extends TenantAwareService {
       });
     }
   }
+  /**
+   * Permanently delete a record (hard delete)
+   */
+  async hardDeleteRecord(recordId) {
+    const record = await this.getRecordOrThrow(recordId);
+    const schema = await this.schemaService.getObjectSchema(record.objectId);
+    await checkPermission(this.permissionService, this.userId, schema.name, "delete");
+    await this.adapter.objectRecords.hardDelete(recordId);
+  }
+  // ============================================================================
+  // RESTORE
+  // ============================================================================
   /**
    * Restore a soft-deleted record
-   *
-   * Triggers beforeRestore and afterRestore hooks if a HookRegistry is configured.
-   *
-   * @param recordId - Record UUID
-   * @param options - Restore options
-   * @returns Restored record
-   *
-   * @example
-   * ```typescript
-   * // Restore a deleted record
-   * const restored = await service.restoreRecord("rec-123");
-   * console.log(restored.deletedAt); // null
-   * ```
    */
   async restoreRecord(recordId, options) {
     const record = await this.getRecordOrThrow(recordId);
@@ -10652,8 +10774,8 @@ var RecordService = class extends TenantAwareService {
       );
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
-    await this.checkPermission(schema.name, "update");
-    const hookCtx = this.buildRestoreHookContext(schema, record, options?.hookMetadata);
+    await checkPermission(this.permissionService, this.userId, schema.name, "update");
+    const hookCtx = createContextForRestore(schema, this.tenantId, record, options?.hookMetadata);
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("beforeRestore", schema.name, hookCtx);
     }
@@ -10678,162 +10800,37 @@ var RecordService = class extends TenantAwareService {
     }
     return restored;
   }
-  /**
-   * Build hook context for restore operations
-   * @internal
-   */
-  buildRestoreHookContext(schema, record, metadata) {
-    return {
-      objectId: schema.id,
-      objectName: schema.name,
-      recordId: record.id,
-      tenantId: this.tenantId,
-      record,
-      oldValues: record.values,
-      newValues: record.values,
-      changedAttributes: [],
-      getChange: (attr) => ({
-        oldValue: record.values[attr],
-        newValue: record.values[attr],
-        changed: false
-      }),
-      metadata: metadata ?? {},
-      timestamp: /* @__PURE__ */ new Date()
-    };
-  }
-  /**
-   * Enrich a record with computed formula values
-   *
-   * Formula attributes are calculated at read-time from the record's values.
-   * This method adds the computed values to the record's values object.
-   *
-   * @param record - The record to enrich
-   * @param schema - The object schema containing attribute definitions
-   * @returns Record with formula values computed
-   * @internal
-   */
-  enrichWithFormulas(record, schema) {
-    const formulaAttrs = schema.attributes.filter(
-      (a) => a.type === "formula"
-    );
-    if (formulaAttrs.length === 0) {
-      return record;
-    }
-    const enrichedValues = { ...record.values };
-    for (const attr of formulaAttrs) {
-      enrichedValues[attr.name] = evaluateFormulaAttribute(attr, record.values);
-    }
-    return {
-      ...record,
-      values: enrichedValues
-    };
-  }
-  /**
-   * Enrich multiple records with computed formula values
-   * @internal
-   */
-  enrichRecordsWithFormulas(records, schema) {
-    const formulaAttrs = schema.attributes.filter(
-      (a) => a.type === "formula"
-    );
-    if (formulaAttrs.length === 0) {
-      return records;
-    }
-    return records.map((record) => this.enrichWithFormulas(record, schema));
-  }
-  /**
-   * Recalculate rollups after a record changes
-   *
-   * This handles three cases:
-   * 1. The record itself has rollups (e.g., aggregating from related records it points to)
-   * 2. Parent records have rollups that aggregate from this record (reverse pattern)
-   * 3. Records that have forward rollups pointing to this record (forward pattern)
-   *
-   * @param record - The record that was modified
-   * @param schema - Schema of the record's object
-   * @internal
-   */
-  async recalculateParentRollups(record, schema) {
-    const ownRollupAttrs = schema.attributes.filter(
-      (a) => a.type === "rollup"
-    );
-    if (ownRollupAttrs.length > 0) {
-      await this.rollupService.recalculateAndUpdate(record, schema);
-    }
-    const affectedParentIds = await this.rollupService.findAffectedParentRecords(record, schema);
-    if (affectedParentIds.length > 0) {
-      const parentRecords = await this.adapter.objectRecords.findByIds(affectedParentIds);
-      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
-    );
-    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)
-   *
-   * This cannot be undone. Use with caution - prefer soft delete for data safety.
-   * Does NOT trigger delete hooks (already triggered on soft delete).
-   *
-   * @param recordId - Record UUID
-   *
-   * @example
-   * ```typescript
-   * // Permanently delete a record
-   * await service.hardDeleteRecord("rec-123");
-   * ```
-   */
-  async hardDeleteRecord(recordId) {
-    const record = await this.getRecordOrThrow(recordId);
-    const schema = await this.schemaService.getObjectSchema(record.objectId);
-    await this.checkPermission(schema.name, "delete");
-    await this.adapter.objectRecords.hardDelete(recordId);
-  }
+  // ============================================================================
+  // LIST & SEARCH
+  // ============================================================================
   /**
    * List records for an object with pagination
-   *
-   * @param objectId - Object UUID
-   * @param options - List options
-   * @returns Records and total count
    */
   async listRecords(objectId, options) {
     const schema = await this.schemaService.getObjectSchema(objectId);
     if (this.permissionService && this.userId) {
-      await this.checkPermission(schema.name, "read");
+      await checkPermission(this.permissionService, this.userId, schema.name, "read");
     }
-    const policy = options?.skipPolicyFilter ? void 0 : this.getPolicy(schema.name);
+    const policy = options?.skipPolicyFilter ? void 0 : getPolicy(this.policyRegistry, this.userId, schema.name);
     let effectiveOptions = options;
-    if (policy?.applyListFilter) {
-      effectiveOptions = policy.applyListFilter(this.buildPolicyContext(schema.name), options);
+    if (policy?.applyListFilter && this.userId) {
+      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
+      effectiveOptions = policy.applyListFilter(ctx, options);
     }
-    const result = await this.adapter.objectRecords.list(objectId, effectiveOptions);
+    const result = await runWithSchemaContext(
+      [schema],
+      () => this.adapter.objectRecords.list(objectId, effectiveOptions)
+    );
     let filteredRecords = result.records;
     let effectiveTotal = result.total;
-    if (policy?.canAccessRecord) {
-      const ctx = this.buildPolicyContext(schema.name);
+    if (policy?.canAccessRecord && this.userId) {
+      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
       filteredRecords = result.records.filter((record) => policy.canAccessRecord?.(ctx, record));
       effectiveTotal = filteredRecords.length;
     }
     if (!options?.skipFormulas) {
       return {
-        records: this.enrichRecordsWithFormulas(filteredRecords, schema),
+        records: enrichRecordsWithFormulas(filteredRecords, schema),
         total: effectiveTotal
       };
     }
@@ -10844,55 +10841,43 @@ var RecordService = class extends TenantAwareService {
   }
   /**
    * Search records using full-text search
-   *
-   * @param objectId - Object UUID
-   * @param query - Search query
-   * @param options - Search options
-   * @returns Matching records and total count
    */
   async searchRecords(objectId, query, options) {
     const schema = await this.schemaService.getObjectSchema(objectId);
     if (this.permissionService && this.userId) {
-      await this.checkPermission(schema.name, "read");
+      await checkPermission(this.permissionService, this.userId, schema.name, "read");
     }
-    const result = await this.adapter.objectRecords.search(objectId, query, options);
+    const result = await runWithSchemaContext(
+      [schema],
+      () => this.adapter.objectRecords.search(objectId, query, options)
+    );
     if (!options?.skipFormulas) {
       return {
-        records: this.enrichRecordsWithFormulas(result.records, schema),
+        records: enrichRecordsWithFormulas(result.records, schema),
         total: result.total
       };
     }
     return result;
   }
+  // ============================================================================
+  // VALIDATION & STATUS
+  // ============================================================================
   /**
    * Validate data against object schema without saving
-   *
-   * @param objectId - Object UUID
-   * @param data - Data to validate
-   * @returns Validation result
    */
   async validateData(objectId, data) {
     const schema = await this.schemaService.getObjectSchema(objectId);
     return validateObject(schema, data);
   }
   /**
-   * Compute the completion status for given data without saving.
-   * Useful for UI to show draft/complete status before submitting.
-   *
-   * @param objectId - Object UUID
-   * @param data - Data to check
-   * @returns Computed completion status
+   * Compute the completion status for given data without saving
    */
   async computeStatus(objectId, data) {
     const schema = await this.schemaService.getObjectSchema(objectId);
     return computeRecordStatus(schema, data);
   }
   /**
-   * Refresh the completion status of an existing record.
-   * Useful when schema changes and you need to recompute statuses.
-   *
-   * @param recordId - Record UUID
-   * @returns Updated completion status
+   * Refresh the completion status of an existing record
    */
   async refreshRecordStatus(recordId) {
     const record = await this.getRecordOrThrow(recordId);
@@ -13362,6 +13347,13 @@ export {
   QueryNoResultError,
   QueryMultipleResultsError,
   TenantContextError,
+  getSchemaFromContext,
+  getSchemaByNameFromContext,
+  hasSchemaContext,
+  getSchemaContext,
+  addSchemaToContext,
+  runWithSchemaContext,
+  runWithMergedSchemaContext,
   getContext,
   getTenantId,
   getUserId,
@@ -13423,6 +13415,7 @@ export {
   buildAuditChanges,
   TenantAwareService,
   TenantAwareRepository,
+  SchemaContextAwareRepository,
   AuditService,
   FileService,
   GeocodingService,