@proseql/core 0.1.0

package/dist/operations/crud/upsert.js

@@ -0,0 +1,386 @@
+/**
+ * Effect-based upsert operations for entities.
+ *
+ * Uses Ref<ReadonlyMap> for atomic state mutation, Effect Schema for validation,
+ * and typed errors (ValidationError, ForeignKeyError).
+ *
+ * Upsert = find by `where` clause → update if exists, create if not.
+ */
+import { Effect, PubSub, Ref } from "effect";
+import { runAfterCreateHooks, runAfterUpdateHooks, runBeforeCreateHooks, runBeforeUpdateHooks, runOnChangeHooks, } from "../../hooks/hook-runner.js";
+import { addManyToIndex, addToIndex, updateInIndex, } from "../../indexes/index-manager.js";
+import { addToSearchIndex, updateInSearchIndex, } from "../../indexes/search-index.js";
+import { generateId } from "../../utils/id-generator.js";
+import { validateForeignKeysEffect } from "../../validators/foreign-key.js";
+import { validateEntity } from "../../validators/schema-validator.js";
+import { checkBatchUniqueConstraints, checkUniqueConstraints, validateUpsertWhere, } from "./unique-check.js";
+import { applyUpdates } from "./update.js";
+// ============================================================================
+// Find by Where Clause
+// ============================================================================
+/**
+ * Find an entity in a ReadonlyMap matching all fields in the where clause.
+ * If `where` contains `id`, uses O(1) lookup. Otherwise scans all values.
+ */
+const findByWhere = (map, where) => {
+    // Fast path: if where has `id`, use direct lookup
+    if ("id" in where && typeof where.id === "string") {
+        const candidate = map.get(where.id);
+        if (candidate === undefined)
+            return undefined;
+        // Verify all other where fields match
+        for (const [key, value] of Object.entries(where)) {
+            if (candidate[key] !== value) {
+                return undefined;
+            }
+        }
+        return candidate;
+    }
+    // Slow path: scan all entities
+    for (const entity of map.values()) {
+        let matches = true;
+        for (const [key, value] of Object.entries(where)) {
+            if (entity[key] !== value) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return entity;
+    }
+    return undefined;
+};
+// ============================================================================
+// Upsert Single Entity
+// ============================================================================
+/**
+ * Upsert a single entity: find by `where`, update if exists, create if not.
+ *
+ * Steps:
+ * 1. Look up entity by where clause in Ref state
+ * 2a. If found: run beforeUpdate hooks, apply update operators, validate, update in state, run afterUpdate/onChange
+ * 2b. If not found: merge where + create data, generate ID/timestamps, validate, run beforeCreate hooks, add to state, run afterCreate/onChange
+ * 3. Validate foreign key constraints
+ * 4. Return entity with __action metadata
+ */
+export const upsert = (collectionName, schema, relationships, ref, stateRefs, indexes, hooks, uniqueFields = [], searchIndexRef, searchIndexFields, changePubSub) => (input) => Effect.gen(function* () {
+    const where = input.where;
+    // Validate that the where clause targets a unique field or id
+    yield* validateUpsertWhere(where, uniqueFields, collectionName);
+    const currentMap = yield* Ref.get(ref);
+    const existing = findByWhere(currentMap, where);
+    if (existing !== undefined) {
+        // === UPDATE PATH ===
+        // Run beforeUpdate hooks (can transform the update payload)
+        const transformedUpdates = yield* runBeforeUpdateHooks(hooks?.beforeUpdate, {
+            operation: "update",
+            collection: collectionName,
+            id: existing.id,
+            existing,
+            update: input.update,
+        });
+        const updated = applyUpdates(existing, transformedUpdates);
+        // Validate through Effect Schema
+        const validated = yield* validateEntity(schema, updated);
+        // Validate foreign keys if relationship fields were updated
+        const relationshipFields = Object.keys(relationships).map((field) => relationships[field].foreignKey || `${field}Id`);
+        const hasRelationshipUpdate = Object.keys(transformedUpdates).some((key) => relationshipFields.includes(key));
+        if (hasRelationshipUpdate) {
+            yield* validateForeignKeysEffect(validated, collectionName, relationships, stateRefs);
+        }
+        // Atomically update in state
+        yield* Ref.update(ref, (map) => {
+            const next = new Map(map);
+            next.set(existing.id, validated);
+            return next;
+        });
+        // Update indexes if provided
+        if (indexes && indexes.size > 0) {
+            yield* updateInIndex(indexes, existing, validated);
+        }
+        // Update search index if configured
+        if (searchIndexRef &&
+            searchIndexFields &&
+            searchIndexFields.length > 0) {
+            yield* updateInSearchIndex(searchIndexRef, existing, validated, searchIndexFields);
+        }
+        // Run afterUpdate hooks (fire-and-forget, errors swallowed)
+        yield* runAfterUpdateHooks(hooks?.afterUpdate, {
+            operation: "update",
+            collection: collectionName,
+            id: existing.id,
+            previous: existing,
+            current: validated,
+            update: transformedUpdates,
+        });
+        // Run onChange hooks with type: "update" (fire-and-forget, errors swallowed)
+        yield* runOnChangeHooks(hooks?.onChange, {
+            type: "update",
+            collection: collectionName,
+            id: existing.id,
+            previous: existing,
+            current: validated,
+        });
+        // Publish change event to reactive subscribers
+        if (changePubSub) {
+            yield* PubSub.publish(changePubSub, {
+                collection: collectionName,
+                operation: "update",
+            });
+        }
+        return { ...validated, __action: "updated" };
+    }
+    // === CREATE PATH ===
+    const id = (typeof where.id === "string" ? where.id : undefined) || generateId();
+    const now = new Date().toISOString();
+    const createData = {
+        ...where,
+        ...input.create,
+        id,
+        createdAt: now,
+        updatedAt: now,
+    };
+    // Validate through Effect Schema
+    const validated = yield* validateEntity(schema, createData);
+    // Run beforeCreate hooks (can transform the entity)
+    const entity = yield* runBeforeCreateHooks(hooks?.beforeCreate, {
+        operation: "create",
+        collection: collectionName,
+        data: validated,
+    });
+    // Check unique constraints
+    yield* checkUniqueConstraints(entity, currentMap, uniqueFields, collectionName);
+    // Validate foreign keys
+    yield* validateForeignKeysEffect(entity, collectionName, relationships, stateRefs);
+    // Atomically add to state
+    yield* Ref.update(ref, (map) => {
+        const next = new Map(map);
+        next.set(id, entity);
+        return next;
+    });
+    // Update indexes if provided
+    if (indexes && indexes.size > 0) {
+        yield* addToIndex(indexes, entity);
+    }
+    // Update search index if configured
+    if (searchIndexRef && searchIndexFields && searchIndexFields.length > 0) {
+        yield* addToSearchIndex(searchIndexRef, entity, searchIndexFields);
+    }
+    // Run afterCreate hooks (fire-and-forget, errors swallowed)
+    yield* runAfterCreateHooks(hooks?.afterCreate, {
+        operation: "create",
+        collection: collectionName,
+        entity,
+    });
+    // Run onChange hooks with type: "create" (fire-and-forget, errors swallowed)
+    yield* runOnChangeHooks(hooks?.onChange, {
+        type: "create",
+        collection: collectionName,
+        entity,
+    });
+    // Publish change event to reactive subscribers
+    if (changePubSub) {
+        yield* PubSub.publish(changePubSub, {
+            collection: collectionName,
+            operation: "create",
+        });
+    }
+    return { ...entity, __action: "created" };
+});
+// ============================================================================
+// Upsert Multiple Entities
+// ============================================================================
+/**
+ * Upsert multiple entities efficiently.
+ *
+ * For each input:
+ * - If entity matches where clause: apply updates (or skip if unchanged)
+ * - If no match: create new entity
+ *
+ * All changes validated and applied atomically.
+ * Returns categorized results: created, updated, unchanged.
+ *
+ * Runs hooks per entity:
+ * - Create path: beforeCreate → mutation → afterCreate → onChange("create")
+ * - Update path: beforeUpdate → mutation → afterUpdate → onChange("update")
+ */
+export const upsertMany = (collectionName, schema, relationships, ref, stateRefs, indexes, hooks, uniqueFields = [], searchIndexRef, searchIndexFields, changePubSub) => (inputs) => Effect.gen(function* () {
+    // Validate all where clauses target unique fields or id
+    for (const input of inputs) {
+        const where = input.where;
+        yield* validateUpsertWhere(where, uniqueFields, collectionName);
+    }
+    const currentMap = yield* Ref.get(ref);
+    const created = [];
+    const updated = [];
+    const unchanged = [];
+    const now = new Date().toISOString();
+    // Phase 1: Process all inputs, validate, run before-hooks, and categorize
+    const toCreate = [];
+    const toUpdate = [];
+    for (let i = 0; i < inputs.length; i++) {
+        const input = inputs[i];
+        if (!input)
+            continue;
+        const where = input.where;
+        const existing = findByWhere(currentMap, where);
+        if (existing !== undefined) {
+            // === UPDATE PATH ===
+            // Check if update would change anything
+            const wouldChange = Object.keys(input.update).some((key) => {
+                const updateValue = input.update[key];
+                const currentValue = existing[key];
+                // Operator-based updates always cause a change
+                if (typeof updateValue === "object" &&
+                    updateValue !== null &&
+                    !Array.isArray(updateValue)) {
+                    return true;
+                }
+                return updateValue !== currentValue;
+            });
+            if (!wouldChange) {
+                unchanged.push(existing);
+                continue;
+            }
+            // Run beforeUpdate hooks (can transform the update payload)
+            const transformedUpdates = yield* runBeforeUpdateHooks(hooks?.beforeUpdate, {
+                operation: "update",
+                collection: collectionName,
+                id: existing.id,
+                existing,
+                update: input.update,
+            });
+            // Apply updates with (possibly transformed) payload
+            const updatedEntity = applyUpdates(existing, transformedUpdates);
+            // Validate
+            const validated = yield* validateEntity(schema, updatedEntity);
+            toUpdate.push({
+                oldEntity: existing,
+                newEntity: validated,
+                transformedUpdates,
+            });
+        }
+        else {
+            // === CREATE PATH ===
+            const id = (typeof where.id === "string" ? where.id : undefined) ||
+                generateId();
+            const createData = {
+                ...where,
+                ...input.create,
+                id,
+                createdAt: now,
+                updatedAt: now,
+            };
+            // Validate through schema first
+            const validated = yield* validateEntity(schema, createData);
+            // Run beforeCreate hooks (can transform the entity)
+            const entity = yield* runBeforeCreateHooks(hooks?.beforeCreate, {
+                operation: "create",
+                collection: collectionName,
+                data: validated,
+            });
+            toCreate.push(entity);
+        }
+    }
+    // Phase 2: Check unique constraints for entities being created
+    // This checks against existing data and also inter-batch conflicts
+    if (toCreate.length > 0) {
+        yield* checkBatchUniqueConstraints(toCreate, currentMap, uniqueFields, collectionName);
+    }
+    // Phase 3: Validate foreign keys for all entities being created or updated
+    for (const entity of toCreate) {
+        yield* validateForeignKeysEffect(entity, collectionName, relationships, stateRefs);
+    }
+    for (const { newEntity } of toUpdate) {
+        yield* validateForeignKeysEffect(newEntity, collectionName, relationships, stateRefs);
+    }
+    // Phase 4: Atomically apply all changes to state
+    if (toCreate.length > 0 || toUpdate.length > 0) {
+        yield* Ref.update(ref, (map) => {
+            const next = new Map(map);
+            for (const entity of toCreate) {
+                next.set(entity.id, entity);
+            }
+            for (const { newEntity } of toUpdate) {
+                next.set(newEntity.id, newEntity);
+            }
+            return next;
+        });
+    }
+    // Phase 5: Update indexes if provided
+    if (indexes && indexes.size > 0) {
+        // Use batch operation for created entities
+        if (toCreate.length > 0) {
+            yield* addManyToIndex(indexes, toCreate);
+        }
+        // Update indexes for updated entities
+        for (const { oldEntity, newEntity } of toUpdate) {
+            yield* updateInIndex(indexes, oldEntity, newEntity);
+        }
+    }
+    // Update search index if configured
+    if (searchIndexRef && searchIndexFields && searchIndexFields.length > 0) {
+        // Add created entities to search index
+        for (const entity of toCreate) {
+            yield* addToSearchIndex(searchIndexRef, entity, searchIndexFields);
+        }
+        // Update search index for updated entities
+        for (const { oldEntity, newEntity } of toUpdate) {
+            yield* updateInSearchIndex(searchIndexRef, oldEntity, newEntity, searchIndexFields);
+        }
+    }
+    // Phase 6: Run after-hooks and onChange hooks for created entities
+    for (const entity of toCreate) {
+        // Run afterCreate hooks (fire-and-forget, errors swallowed)
+        yield* runAfterCreateHooks(hooks?.afterCreate, {
+            operation: "create",
+            collection: collectionName,
+            entity,
+        });
+        // Run onChange hooks with type: "create" (fire-and-forget, errors swallowed)
+        yield* runOnChangeHooks(hooks?.onChange, {
+            type: "create",
+            collection: collectionName,
+            entity,
+        });
+    }
+    // Phase 7: Run after-hooks and onChange hooks for updated entities
+    for (const { oldEntity, newEntity, transformedUpdates } of toUpdate) {
+        // Run afterUpdate hooks (fire-and-forget, errors swallowed)
+        yield* runAfterUpdateHooks(hooks?.afterUpdate, {
+            operation: "update",
+            collection: collectionName,
+            id: newEntity.id,
+            previous: oldEntity,
+            current: newEntity,
+            update: transformedUpdates,
+        });
+        // Run onChange hooks with type: "update" (fire-and-forget, errors swallowed)
+        yield* runOnChangeHooks(hooks?.onChange, {
+            type: "update",
+            collection: collectionName,
+            id: newEntity.id,
+            previous: oldEntity,
+            current: newEntity,
+        });
+    }
+    created.push(...toCreate);
+    updated.push(...toUpdate.map(({ newEntity }) => newEntity));
+    // Publish change events to reactive subscribers
+    // Publish a "create" event if any entities were created
+    if (changePubSub && toCreate.length > 0) {
+        yield* PubSub.publish(changePubSub, {
+            collection: collectionName,
+            operation: "create",
+        });
+    }
+    // Publish an "update" event if any entities were updated
+    if (changePubSub && toUpdate.length > 0) {
+        yield* PubSub.publish(changePubSub, {
+            collection: collectionName,
+            operation: "update",
+        });
+    }
+    return { created, updated, unchanged };
+});
+//# sourceMappingURL=upsert.js.map

package/dist/operations/crud/upsert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upsert.js","sourceRoot":"","sources":["../../../src/operations/crud/upsert.ts"],"names":[],"mappings":"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"}

package/dist/operations/query/aggregate.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Aggregate operations for computing scalar values from entity collections.
+ *
+ * Implements count, sum, avg, min, max aggregations in a single pass.
+ * All aggregates are computed simultaneously for efficiency.
+ */
+import type { AggregateResult, GroupedAggregateConfig, GroupedAggregateResult, ScalarAggregateConfig } from "../../types/aggregate-types.js";
+/**
+ * Compute scalar aggregates over an array of entities.
+ *
+ * Performs a single-pass reduction computing all requested aggregates simultaneously.
+ * This is O(n * k) where n is entities and k is aggregate operations — effectively O(n).
+ *
+ * @param entities - Array of entities to aggregate
+ * @param config - Aggregate configuration specifying which operations to perform
+ * @returns AggregateResult with only the requested aggregations
+ */
+export declare const computeAggregates: (entities: ReadonlyArray<Record<string, unknown>>, config: ScalarAggregateConfig) => AggregateResult;
+/**
+ * Compute grouped aggregates over an array of entities.
+ *
+ * Partitions entities into groups based on groupBy fields, then applies
+ * computeAggregates within each group. Groups are ordered by first encounter.
+ *
+ * @param entities - Array of entities to aggregate
+ * @param config - Grouped aggregate configuration specifying groupBy and operations
+ * @returns GroupedAggregateResult array with group objects
+ */
+export declare const computeGroupedAggregates: (entities: ReadonlyArray<Record<string, unknown>>, config: GroupedAggregateConfig) => GroupedAggregateResult;
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/operations/query/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../src/operations/query/aggregate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACX,eAAe,EACf,sBAAsB,EACtB,sBAAsB,EAEtB,qBAAqB,EACrB,MAAM,gCAAgC,CAAC;AAwNxC;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAC7B,UAAU,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAChD,QAAQ,qBAAqB,KAC3B,eASF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GACpC,UAAU,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAChD,QAAQ,sBAAsB,KAC5B,sBA8CF,CAAC"}

package/dist/operations/query/aggregate.js

@@ -0,0 +1,227 @@
+/**
+ * Aggregate operations for computing scalar values from entity collections.
+ *
+ * Implements count, sum, avg, min, max aggregations in a single pass.
+ * All aggregates are computed simultaneously for efficiency.
+ */
+import { getNestedValue } from "../../utils/nested-path.js";
+/**
+ * Normalize a field spec (string or array) to an array.
+ */
+const normalizeFields = (fields) => {
+    if (fields === undefined)
+        return [];
+    if (typeof fields === "string")
+        return [fields];
+    return fields;
+};
+/**
+ * Sentinel value to distinguish undefined from null in group keys.
+ * JSON.stringify converts both null and undefined to "null", so we need
+ * a custom approach to maintain strict equality semantics (null !== undefined).
+ */
+const UNDEFINED_SENTINEL = "__PTDB_UNDEFINED__";
+/**
+ * Create a group key from field values that distinguishes null from undefined.
+ * Uses a sentinel value to represent undefined since JSON.stringify([undefined])
+ * produces "[null]" which would collide with JSON.stringify([null]).
+ */
+const createGroupKey = (values) => {
+    const mapped = values.map((v) => (v === undefined ? UNDEFINED_SENTINEL : v));
+    return JSON.stringify(mapped);
+};
+/**
+ * Parse a group key back into field values, restoring undefined from sentinel.
+ */
+const parseGroupKey = (key) => {
+    const values = JSON.parse(key);
+    return values.map((v) => (v === UNDEFINED_SENTINEL ? undefined : v));
+};
+/**
+ * Check if a value is numeric (finite number, not NaN).
+ */
+const isNumeric = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+ * Check if a value is valid for comparison (not null/undefined).
+ */
+const isComparable = (value) => value !== null && value !== undefined;
+/**
+ * Create initial accumulators based on config.
+ */
+const createAccumulators = (config) => {
+    const sumFields = normalizeFields(config.sum);
+    const avgFields = normalizeFields(config.avg);
+    const minFields = normalizeFields(config.min);
+    const maxFields = normalizeFields(config.max);
+    const sum = {};
+    for (const field of sumFields) {
+        sum[field] = 0;
+    }
+    const avg = {};
+    for (const field of avgFields) {
+        avg[field] = { sum: 0, count: 0 };
+    }
+    const min = {};
+    for (const field of minFields) {
+        min[field] = undefined;
+    }
+    const max = {};
+    for (const field of maxFields) {
+        max[field] = undefined;
+    }
+    return { count: 0, sum, avg, min, max };
+};
+/**
+ * Update accumulators with a single entity.
+ */
+const updateAccumulators = (acc, entity, config) => {
+    const sumFields = normalizeFields(config.sum);
+    const avgFields = normalizeFields(config.avg);
+    const minFields = normalizeFields(config.min);
+    const maxFields = normalizeFields(config.max);
+    // Count
+    const newCount = config.count ? acc.count + 1 : acc.count;
+    // Sum: accumulate numeric values, skip non-numeric
+    const newSum = { ...acc.sum };
+    for (const field of sumFields) {
+        const value = getNestedValue(entity, field);
+        if (isNumeric(value)) {
+            newSum[field] = (newSum[field] ?? 0) + value;
+        }
+    }
+    // Avg: track sum and count of numeric values
+    const newAvg = { ...acc.avg };
+    for (const field of avgFields) {
+        const value = getNestedValue(entity, field);
+        if (isNumeric(value)) {
+            const current = newAvg[field] ?? { sum: 0, count: 0 };
+            newAvg[field] = {
+                sum: current.sum + value,
+                count: current.count + 1,
+            };
+        }
+    }
+    // Min: track minimum comparable value
+    const newMin = { ...acc.min };
+    for (const field of minFields) {
+        const value = getNestedValue(entity, field);
+        if (isComparable(value)) {
+            const current = newMin[field];
+            // Type-safe comparison: we check current is undefined or compare as primitives
+            if (current === undefined ||
+                value < current) {
+                newMin[field] = value;
+            }
+        }
+    }
+    // Max: track maximum comparable value
+    const newMax = { ...acc.max };
+    for (const field of maxFields) {
+        const value = getNestedValue(entity, field);
+        if (isComparable(value)) {
+            const current = newMax[field];
+            // Type-safe comparison: we check current is undefined or compare as primitives
+            if (current === undefined ||
+                value > current) {
+                newMax[field] = value;
+            }
+        }
+    }
+    return {
+        count: newCount,
+        sum: newSum,
+        avg: newAvg,
+        min: newMin,
+        max: newMax,
+    };
+};
+/**
+ * Convert accumulators to final result.
+ */
+const accumulatorsToResult = (acc, config) => {
+    const result = {};
+    // Include only requested aggregations
+    if (config.count) {
+        result.count = acc.count;
+    }
+    if (config.sum !== undefined) {
+        result.sum = acc.sum;
+    }
+    if (config.avg !== undefined) {
+        const avgResult = {};
+        for (const [field, { sum, count }] of Object.entries(acc.avg)) {
+            avgResult[field] = count > 0 ? sum / count : null;
+        }
+        result.avg = avgResult;
+    }
+    if (config.min !== undefined) {
+        result.min = acc.min;
+    }
+    if (config.max !== undefined) {
+        result.max = acc.max;
+    }
+    return result;
+};
+/**
+ * Compute scalar aggregates over an array of entities.
+ *
+ * Performs a single-pass reduction computing all requested aggregates simultaneously.
+ * This is O(n * k) where n is entities and k is aggregate operations — effectively O(n).
+ *
+ * @param entities - Array of entities to aggregate
+ * @param config - Aggregate configuration specifying which operations to perform
+ * @returns AggregateResult with only the requested aggregations
+ */
+export const computeAggregates = (entities, config) => {
+    const initialAcc = createAccumulators(config);
+    const finalAcc = entities.reduce((acc, entity) => updateAccumulators(acc, entity, config), initialAcc);
+    return accumulatorsToResult(finalAcc, config);
+};
+/**
+ * Compute grouped aggregates over an array of entities.
+ *
+ * Partitions entities into groups based on groupBy fields, then applies
+ * computeAggregates within each group. Groups are ordered by first encounter.
+ *
+ * @param entities - Array of entities to aggregate
+ * @param config - Grouped aggregate configuration specifying groupBy and operations
+ * @returns GroupedAggregateResult array with group objects
+ */
+export const computeGroupedAggregates = (entities, config) => {
+    // Normalize groupBy to array
+    const groupByFields = normalizeFields(config.groupBy);
+    // Partition entities into groups using Map for first-encounter ordering
+    const groups = new Map();
+    for (const entity of entities) {
+        // Build group key from grouping field values
+        const groupKey = createGroupKey(groupByFields.map((f) => getNestedValue(entity, f)));
+        const existing = groups.get(groupKey);
+        if (existing !== undefined) {
+            existing.push(entity);
+        }
+        else {
+            groups.set(groupKey, [entity]);
+        }
+    }
+    // Build result for each group
+    const result = [];
+    for (const [groupKey, groupEntities] of groups) {
+        // Parse back the group values
+        const groupValues = parseGroupKey(groupKey);
+        // Build the group field object
+        const group = {};
+        for (let i = 0; i < groupByFields.length; i++) {
+            group[groupByFields[i]] = groupValues[i];
+        }
+        // Compute aggregates for this group (exclude groupBy from config passed to computeAggregates)
+        const { groupBy: _, ...scalarConfig } = config;
+        const aggregates = computeAggregates(groupEntities, scalarConfig);
+        // Combine group info with aggregates
+        result.push({
+            group,
+            ...aggregates,
+        });
+    }
+    return result;
+};
+//# sourceMappingURL=aggregate.js.map