@stndrds/schema 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/index.js

@@ -201,7 +201,6 @@ __export(index_exports, {
   createPhoneValidator: () => createPhoneValidator,
   createRatingValidator: () => createRatingValidator,
   createRelationValidator: () => createRelationValidator,
-  createRollupHooks: () => createRollupHooks,
   createRollupValidator: () => createRollupValidator,
   createSelectValidator: () => createSelectValidator,
   createSingleRelationValidator: () => createSingleRelationValidator,
@@ -273,7 +272,6 @@ __export(index_exports, {
   phoneConfigSchema: () => phoneConfigSchema,
   rating: () => rating,
   ratingConfigSchema: () => ratingConfigSchema,
-  registerAllRollupHooks: () => registerAllRollupHooks,
   registry: () => registry,
   relation: () => relation,
   relationConfigSchema: () => relationConfigSchema,
@@ -1628,6 +1626,14 @@ var RollupAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.decimals = value;
     return this;
   }
+  /**
+   * Display the rollup value using the target attribute's type formatter
+   * instead of the default rollup-specific formatting
+   */
+  showAsOriginal() {
+    this.attr.showAsOriginal = true;
+    return this;
+  }
   /**
    * Set multi-level path for traversing nested relations (Phase 4+)
    * @param path - Dot notation path (e.g., "orders.items")
@@ -2965,10 +2971,12 @@ var rollupConfigSchema = baseConfigSchema.extend({
     "countValues",
     "countEmpty",
     "percentEmpty",
-    "percentFilled"
+    "percentFilled",
+    "collect"
   ]),
   decimals: import_zod4.z.number().int().min(0).max(10).optional(),
-  materialize: import_zod4.z.boolean().optional()
+  showAsOriginal: import_zod4.z.boolean().optional(),
+  targetAttributeType: import_zod4.z.string().optional()
 });
 var attributeConfigSchemas = {
   text: textConfigSchema,
@@ -3712,260 +3720,6 @@ var NoopHookRegistry = class {
   }
 };
 
-// src/runtime/services/rollup.service.ts
-var RollupService = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  /**
-   * Calculate a rollup value for a record
-   *
-   * @param recordId - ID of the parent record
-   * @param rollupAttr - Rollup attribute definition
-   * @param schema - Schema of the parent object
-   * @returns Computed rollup value
-   *
-   * @example
-   * ```typescript
-   * // Sum all order amounts for a company
-   * const totalOrders = await rollupService.calculate(
-   *   "company-123",
-   *   {
-   *     type: "rollup",
-   *     name: "totalOrders",
-   *     relationAttribute: "orders",
-   *     targetAttribute: "amount",
-   *     function: "sum",
-   *     ...
-   *   },
-   *   companySchema
-   * );
-   * ```
-   */
-  async calculate(recordId, rollupAttr, schema, tenantId) {
-    const relationAttr = schema.attributes.find(
-      (a) => a.type === "relation" && a.name === rollupAttr.relationAttribute
-    );
-    if (!relationAttr) {
-      return { value: null, recordCount: 0 };
-    }
-    const targetObjectName = relationAttr.targets[0]?.object;
-    if (!targetObjectName) {
-      return { value: null, recordCount: 0 };
-    }
-    const targetObject = await this.adapter.objects.findByName(tenantId, targetObjectName);
-    if (!targetObject) {
-      return { value: null, recordCount: 0 };
-    }
-    const relatedRecords = await this.adapter.objectRecords.findByRelation(
-      tenantId,
-      targetObject.id,
-      rollupAttr.relationAttribute,
-      recordId
-    );
-    if (relatedRecords.length === 0) {
-      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
-    }
-    const values = relatedRecords.map((r) => r.values[rollupAttr.targetAttribute]).filter((v) => v !== void 0);
-    const aggregated = this.aggregate(values, rollupAttr.function);
-    const result = typeof aggregated === "number" && rollupAttr.decimals !== void 0 ? Number(aggregated.toFixed(rollupAttr.decimals)) : aggregated;
-    return { value: result, recordCount: relatedRecords.length };
-  }
-  /**
-   * Calculate rollup values for multiple records (batched)
-   *
-   * More efficient than calling calculate() for each record individually.
-   */
-  async calculateForMany(recordIds, rollupAttr, schema, tenantId) {
-    const results = /* @__PURE__ */ new Map();
-    for (const id of recordIds) {
-      results.set(id, { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 });
-    }
-    await Promise.all(
-      recordIds.map(async (id) => {
-        const result = await this.calculate(id, rollupAttr, schema, tenantId);
-        results.set(id, result);
-      })
-    );
-    return results;
-  }
-  /**
-   * Apply aggregation function to a set of values
-   */
-  aggregate(values, fn) {
-    switch (fn) {
-      case "sum":
-        return this.sumNumbers(values);
-      case "avg":
-        return this.averageNumbers(values);
-      case "min":
-        return this.minNumbers(values);
-      case "max":
-        return this.maxNumbers(values);
-      case "count":
-        return values.length;
-      case "countValues":
-        return values.filter((v) => v != null && v !== "").length;
-      case "countEmpty":
-        return values.filter((v) => v == null || v === "").length;
-      case "percentFilled": {
-        if (values.length === 0) return 0;
-        const filled = values.filter((v) => v != null && v !== "").length;
-        return filled / values.length * 100;
-      }
-      case "percentEmpty": {
-        if (values.length === 0) return 0;
-        const empty = values.filter((v) => v == null || v === "").length;
-        return empty / values.length * 100;
-      }
-    }
-  }
-  /**
-   * Get the default empty value for a rollup function
-   */
-  getEmptyValue(fn) {
-    switch (fn) {
-      case "sum":
-      case "count":
-      case "countValues":
-      case "countEmpty":
-      case "percentEmpty":
-      case "percentFilled":
-        return 0;
-      case "avg":
-      case "min":
-      case "max":
-        return null;
-    }
-  }
-  /**
-   * Sum numeric values
-   */
-  sumNumbers(values) {
-    return values.filter((v) => typeof v === "number" && !Number.isNaN(v)).reduce((sum, n) => sum + n, 0);
-  }
-  /**
-   * Average numeric values
-   */
-  averageNumbers(values) {
-    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
-    if (nums.length === 0) return null;
-    return nums.reduce((sum, n) => sum + n, 0) / nums.length;
-  }
-  /**
-   * Minimum numeric value
-   */
-  minNumbers(values) {
-    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
-    if (nums.length === 0) return null;
-    return Math.min(...nums);
-  }
-  /**
-   * Maximum numeric value
-   */
-  maxNumbers(values) {
-    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
-    if (nums.length === 0) return null;
-    return Math.max(...nums);
-  }
-  /**
-   * Recalculate all rollup attributes for a record and update it
-   *
-   * Called after related records change to keep rollups up-to-date.
-   */
-  async recalculateAndUpdate(record, schema, tenantId) {
-    const rollupAttrs = schema.attributes.filter((a) => a.type === "rollup");
-    if (rollupAttrs.length === 0) {
-      return record;
-    }
-    const updates = {};
-    for (const attr of rollupAttrs) {
-      const result = await this.calculate(record.id, attr, schema, tenantId);
-      updates[attr.name] = result.value;
-    }
-    return await this.adapter.objectRecords.update(record.id, updates);
-  }
-  /**
-   * Find parent records that need rollup recalculation when a child record changes
-   *
-   * Used by hooks to determine which parent records to recalculate after
-   * a child record is created, updated, or deleted.
-   *
-   * @param changedRecord - The record that was modified
-   * @param changedSchema - Schema of the changed record's object
-   * @returns Array of parent record IDs that need recalculation
-   */
-  async findAffectedParentRecords(changedRecord, changedSchema) {
-    const affectedIds = [];
-    const relationAttrs = changedSchema.attributes.filter(
-      (a) => a.type === "relation"
-    );
-    for (const attr of relationAttrs) {
-      const relatedId = changedRecord.values[attr.name];
-      if (typeof relatedId === "string" && relatedId.length > 0) {
-        affectedIds.push(relatedId);
-      } else if (Array.isArray(relatedId)) {
-        affectedIds.push(...relatedId.filter((id) => typeof id === "string"));
-      }
-    }
-    return [...new Set(affectedIds)];
-  }
-};
-
-// src/runtime/hooks/rollup.hooks.ts
-function createRollupHooks(objectName, config) {
-  const rollupService = new RollupService(config.adapter);
-  async function recalculateParentRollups(ctx) {
-    const schema = await config.getSchemaById(ctx.objectId);
-    if (!schema) return;
-    const affectedParentIds = await rollupService.findAffectedParentRecords(ctx.record, schema);
-    if (affectedParentIds.length === 0) return;
-    const parentRecords = await config.adapter.objectRecords.findByIds(affectedParentIds);
-    for (const parentRecord of parentRecords) {
-      const parentSchema = await config.getSchemaById(parentRecord.objectId);
-      if (!parentSchema) continue;
-      const hasRollups = parentSchema.attributes.some(
-        (a) => a.type === "rollup"
-      );
-      if (hasRollups) {
-        await rollupService.recalculateAndUpdate(parentRecord, parentSchema, config.tenantId);
-      }
-    }
-  }
-  return [
-    {
-      type: "afterCreate",
-      objectName,
-      handler: recalculateParentRollups,
-      priority: 100
-      // Run after other hooks
-    },
-    {
-      type: "afterUpdate",
-      objectName,
-      handler: recalculateParentRollups,
-      priority: 100
-    },
-    {
-      type: "afterDelete",
-      objectName,
-      handler: recalculateParentRollups,
-      priority: 100
-    }
-  ];
-}
-function registerAllRollupHooks(hookRegistry, schemas, config) {
-  for (const schema of schemas) {
-    const hasRelations = schema.attributes.some((a) => a.type === "relation");
-    if (hasRelations && hookRegistry.register) {
-      const hooks = createRollupHooks(schema.name, config);
-      for (const hook of hooks) {
-        hookRegistry.register(hook);
-      }
-    }
-  }
-}
-
 // src/runtime/template.ts
 var pipes = {
   /** Convert to uppercase */
@@ -7492,6 +7246,263 @@ var RelationService = class {
   }
 };
 
+// src/runtime/services/rollup.service.ts
+var RollupService = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Calculate a rollup value for a record
+   *
+   * @param recordId - ID of the parent record
+   * @param rollupAttr - Rollup attribute definition
+   * @param schema - Schema of the parent object
+   * @returns Computed rollup value
+   *
+   * @example
+   * ```typescript
+   * // Sum all order amounts for a company
+   * const totalOrders = await rollupService.calculate(
+   *   "company-123",
+   *   {
+   *     type: "rollup",
+   *     name: "totalOrders",
+   *     relationAttribute: "orders",
+   *     targetAttribute: "amount",
+   *     function: "sum",
+   *     ...
+   *   },
+   *   companySchema
+   * );
+   * ```
+   */
+  async calculate(recordId, rollupAttr, schema) {
+    const relationAttr = schema.attributes.find(
+      (a) => a.type === "relation" && a.name === rollupAttr.relationAttribute
+    );
+    if (relationAttr) {
+      return this.calculateForward(recordId, rollupAttr);
+    }
+    return this.calculateReverse(recordId, rollupAttr, schema);
+  }
+  /**
+   * Forward pattern: this record has a relation attribute pointing to other records
+   * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
+   */
+  async calculateForward(recordId, rollupAttr) {
+    const record = await this.adapter.objectRecords.findById(recordId);
+    if (!record) {
+      return { value: null, recordCount: 0 };
+    }
+    const relationValue = record.values[rollupAttr.relationAttribute];
+    let relatedIds = [];
+    if (typeof relationValue === "string" && relationValue.length > 0) {
+      relatedIds = [relationValue];
+    } else if (Array.isArray(relationValue)) {
+      relatedIds = relationValue.filter((id) => typeof id === "string" && id.length > 0);
+    }
+    if (relatedIds.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByIds(relatedIds);
+    if (relatedRecords.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    return this.aggregateValues(relatedRecords, rollupAttr);
+  }
+  /**
+   * Reverse pattern: other records have a relation pointing to this record
+   * Example: Company has rollup on "orders", Order has relation "company" → companies
+   */
+  async calculateReverse(recordId, rollupAttr, schema) {
+    const record = await this.adapter.objectRecords.findById(recordId);
+    if (!record) {
+      return { value: null, recordCount: 0 };
+    }
+    const parentObject = await this.adapter.objects.findById(record.objectId);
+    if (!parentObject) {
+      return { value: null, recordCount: 0 };
+    }
+    const tenantId = parentObject.tenantId;
+    const sourceObjectName = rollupAttr.relationAttribute;
+    const sourceObject = await this.adapter.objects.findByName(tenantId, sourceObjectName);
+    if (!sourceObject) {
+      return { value: null, recordCount: 0 };
+    }
+    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) {
+      return { value: null, recordCount: 0 };
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByRelation(
+      tenantId,
+      sourceObject.id,
+      reverseRelationAttr.name,
+      recordId
+    );
+    if (relatedRecords.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    return this.aggregateValues(relatedRecords, rollupAttr);
+  }
+  /**
+   * Extract and aggregate values from related records
+   */
+  aggregateValues(relatedRecords, rollupAttr) {
+    const values = relatedRecords.map((r) => r.values[rollupAttr.targetAttribute]).filter((v) => v !== void 0 && v !== null);
+    const aggregated = this.aggregate(values, rollupAttr.function);
+    const result = typeof aggregated === "number" && rollupAttr.decimals !== void 0 ? Number(aggregated.toFixed(rollupAttr.decimals)) : aggregated;
+    return { value: result, recordCount: relatedRecords.length };
+  }
+  /**
+   * Calculate rollup values for multiple records (batched)
+   *
+   * More efficient than calling calculate() for each record individually.
+   */
+  async calculateForMany(recordIds, rollupAttr, schema) {
+    const results = /* @__PURE__ */ new Map();
+    for (const id of recordIds) {
+      results.set(id, { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 });
+    }
+    await Promise.all(
+      recordIds.map(async (id) => {
+        const result = await this.calculate(id, rollupAttr, schema);
+        results.set(id, result);
+      })
+    );
+    return results;
+  }
+  /**
+   * Apply aggregation function to a set of values
+   */
+  aggregate(values, fn) {
+    switch (fn) {
+      case "sum":
+        return this.sumNumbers(values);
+      case "avg":
+        return this.averageNumbers(values);
+      case "min":
+        return this.minNumbers(values);
+      case "max":
+        return this.maxNumbers(values);
+      case "count":
+        return values.length;
+      case "countValues":
+        return values.filter((v) => v != null && v !== "").length;
+      case "countEmpty":
+        return values.filter((v) => v == null || v === "").length;
+      case "percentFilled": {
+        if (values.length === 0) return 0;
+        const filled = values.filter((v) => v != null && v !== "").length;
+        return filled / values.length * 100;
+      }
+      case "percentEmpty": {
+        if (values.length === 0) return 0;
+        const empty = values.filter((v) => v == null || v === "").length;
+        return empty / values.length * 100;
+      }
+      case "collect":
+        return values;
+    }
+  }
+  /**
+   * Get the default empty value for a rollup function
+   */
+  getEmptyValue(fn) {
+    switch (fn) {
+      case "sum":
+      case "count":
+      case "countValues":
+      case "countEmpty":
+      case "percentEmpty":
+      case "percentFilled":
+        return 0;
+      case "avg":
+      case "min":
+      case "max":
+        return null;
+      case "collect":
+        return [];
+    }
+  }
+  /**
+   * Sum numeric values
+   */
+  sumNumbers(values) {
+    return values.filter((v) => typeof v === "number" && !Number.isNaN(v)).reduce((sum, n) => sum + n, 0);
+  }
+  /**
+   * Average numeric values
+   */
+  averageNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return nums.reduce((sum, n) => sum + n, 0) / nums.length;
+  }
+  /**
+   * Minimum numeric value
+   */
+  minNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return Math.min(...nums);
+  }
+  /**
+   * Maximum numeric value
+   */
+  maxNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return Math.max(...nums);
+  }
+  /**
+   * Recalculate all rollup attributes for a record and update it
+   *
+   * Called after related records change to keep rollups up-to-date.
+   */
+  async recalculateAndUpdate(record, schema) {
+    const rollupAttrs = schema.attributes.filter((a) => a.type === "rollup");
+    if (rollupAttrs.length === 0) {
+      return record;
+    }
+    const updates = {};
+    for (const attr of rollupAttrs) {
+      const result = await this.calculate(record.id, attr, schema);
+      updates[attr.name] = result.value;
+    }
+    return await this.adapter.objectRecords.update(record.id, updates);
+  }
+  /**
+   * Find parent records that need rollup recalculation when a child record changes
+   *
+   * Used by hooks to determine which parent records to recalculate after
+   * a child record is created, updated, or deleted.
+   *
+   * @param changedRecord - The record that was modified
+   * @param changedSchema - Schema of the changed record's object
+   * @returns Array of parent record IDs that need recalculation
+   */
+  async findAffectedParentRecords(changedRecord, changedSchema) {
+    const affectedIds = [];
+    const relationAttrs = changedSchema.attributes.filter(
+      (a) => a.type === "relation"
+    );
+    for (const attr of relationAttrs) {
+      const relatedId = changedRecord.values[attr.name];
+      if (typeof relatedId === "string" && relatedId.length > 0) {
+        affectedIds.push(relatedId);
+      } else if (Array.isArray(relatedId)) {
+        affectedIds.push(...relatedId.filter((id) => typeof id === "string"));
+      }
+    }
+    return [...new Set(affectedIds)];
+  }
+};
+
 // src/runtime/services/user.service.ts
 var UserService = class {
   constructor(adapter, tenantId) {
@@ -7617,6 +7628,7 @@ var RecordService = class {
     this.schemaService = new ObjectSchemaService(adapter, registry);
     this.relationService = new RelationService(adapter, registry);
     this.userService = new UserService(adapter, tenantId);
+    this.rollupService = new RollupService(adapter);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
     this.permissionService = options?.permissionService;
     this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
@@ -7778,6 +7790,7 @@ var RecordService = class {
       };
       await this.hookRegistry.execute("afterCreate", schema.name, afterCtx);
     }
+    await this.recalculateParentRollups(record, schema);
     if (this.auditService && this.userId) {
       await this.auditService.logRecordAction({
         action: "record.created",
@@ -7893,6 +7906,7 @@ var RecordService = class {
       };
       await this.hookRegistry.execute("afterUpdate", schema.name, afterCtx);
     }
+    await this.recalculateParentRollups(updated, schema);
     if (this.auditService && this.userId && changedAttributes.length > 0) {
       const changes = changedAttributes.map((attr) => ({
         field: attr,
@@ -8020,6 +8034,7 @@ var RecordService = class {
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
     }
+    await this.recalculateParentRollups(record, schema);
     if (this.auditService && this.userId) {
       await this.auditService.logRecordAction({
         action: "record.deleted",
@@ -8149,6 +8164,39 @@ var RecordService = class {
     }
     return records.map((record) => this.enrichWithFormulas(record, schema));
   }
+  /**
+   * Recalculate rollups after a record changes
+   *
+   * This handles two 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
+   *
+   * @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) {
+      return;
+    }
+    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);
+      }
+    }
+  }
   /**
    * Permanently delete a record (hard delete)
    *
@@ -8422,7 +8470,7 @@ var RollupScheduler = class {
       clearTimeout(existing.timeout);
     }
     const timeout = setTimeout(async () => {
-      await this.executeRecalculation(parentId, parentObjectId, tenantId);
+      await this.executeRecalculation(parentId, parentObjectId);
       this.pending.delete(key);
     }, this.debounceMs);
     this.pending.set(key, { parentId, parentObjectId, tenantId, timeout });
@@ -8449,19 +8497,19 @@ var RollupScheduler = class {
       const schema = await this.getSchemaById(record.objectId);
       const tenantId = tenantMap.get(record.id);
       if (schema && tenantId) {
-        await this.rollupService.recalculateAndUpdate(record, schema, tenantId);
+        await this.rollupService.recalculateAndUpdate(record, schema);
       }
     }
   }
   /**
    * Execute a single recalculation
    */
-  async executeRecalculation(parentId, parentObjectId, tenantId) {
+  async executeRecalculation(parentId, parentObjectId) {
     const record = await this.adapter.objectRecords.findById(parentId);
     if (!record) return;
     const schema = await this.getSchemaById(parentObjectId);
     if (!schema) return;
-    await this.rollupService.recalculateAndUpdate(record, schema, tenantId);
+    await this.rollupService.recalculateAndUpdate(record, schema);
   }
   /**
    * Get number of pending recalculations
@@ -9317,7 +9365,6 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   createPhoneValidator,
   createRatingValidator,
   createRelationValidator,
-  createRollupHooks,
   createRollupValidator,
   createSelectValidator,
   createSingleRelationValidator,
@@ -9389,7 +9436,6 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   phoneConfigSchema,
   rating,
   ratingConfigSchema,
-  registerAllRollupHooks,
   registry,
   relation,
   relationConfigSchema,