@stndrds/schema 0.1.0-alpha.41 → 0.1.0-alpha.43

package/dist/{chunk-4ZUAND4E.mjs → chunk-MXYJTCA3.mjs}

@@ -3300,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();
@@ -10212,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) {
@@ -10225,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
    *
@@ -10398,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);
     }
@@ -10440,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,
@@ -10457,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",
@@ -10471,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);
@@ -10485,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;
@@ -10511,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);
@@ -10540,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
@@ -10584,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,
@@ -10608,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))
@@ -10632,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);
@@ -10722,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);
@@ -10738,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);
     }
@@ -10746,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",
@@ -10759,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);
@@ -10785,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);
     }
@@ -10811,150 +10800,22 @@ 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 runWithSchemaContext(
       [schema],
@@ -10962,14 +10823,14 @@ var RecordService = class extends TenantAwareService {
     );
     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
       };
     }
@@ -10980,16 +10841,11 @@ 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 runWithSchemaContext(
       [schema],
@@ -10997,41 +10853,31 @@ var RecordService = class extends TenantAwareService {
     );
     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);