@based/db 0.1.5 → 0.2.0

package/dist/src/client/modify/error.js

@@ -63,4 +63,14 @@ export const handleError = (db, ctx, fn, args, e) => {
     }
     throw e;
 };
+export const errors = {
+    NotExists: class extends Error {
+        constructor(id, schema) {
+            super(`Target ${schema.type}:${id} does not exist`);
+        }
+    },
+};
+export const errorMap = {
+    1: errors.NotExists,
+};
 //# sourceMappingURL=error.js.map

package/dist/src/client/modify/props/alias.js

@@ -10,7 +10,7 @@ export const writeAlias = (ctx, def, val) => {
         deleteProp(ctx, def);
         return;
     }
-    validate(def, val);
+    validate(val, def);
     const buf = ENCODER.encode(val);
     if (buf.byteLength === 0) {
         deleteProp(ctx, def);

package/dist/src/client/modify/props/binary.js

@@ -38,7 +38,7 @@ export const writeBinary = (ctx, def, val, validated) => {
         throw [def, val];
     }
     if (!validated) {
-        validate(def, buf);
+        validate(buf, def);
     }
     if (!buf.byteLength) {
         deleteProp(ctx, def);

package/dist/src/client/modify/props/cardinality.js

@@ -10,7 +10,7 @@ import { writeBinary } from './binary.js';
 export const writeCardinalityRaw = (ctx, def, val, sizeFixBecauseEdgeIsDifferent = val.length) => {
     writeU32(ctx, sizeFixBecauseEdgeIsDifferent);
     for (const item of val) {
-        validate(def, item);
+        validate(item, def);
         if (typeof item === 'string') {
             xxHash64(ENCODER.encode(item), ctx.array, ctx.index);
             ctx.index += 8;

package/dist/src/client/modify/props/fixed.js

@@ -1,5 +1,5 @@
 import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, } from '@based/schema/def';
-import { convertToTimestamp, ENCODER } from '@based/utils';
+import { convertToTimestamp, ENCODER, writeDoubleLE } from '@based/utils';
 import { getBuffer } from './binary.js';
 import { reserve } from '../resize.js';
 import { writeU16, writeU32, writeU64, writeU8, writeU8Array } from '../uint.js';
@@ -7,7 +7,7 @@ import { validate } from '../validate.js';
 const map = {};
 map[BINARY] = (ctx, val, def) => {
     val = getBuffer(val);
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, val.byteLength + 1);
     writeU8(ctx, val.byteLength);
     writeU8Array(ctx, val);
@@ -18,7 +18,7 @@ map[STRING] = (ctx, val, def) => {
     if (size + 1 > def.len) {
         throw [def, val, `max length of ${def.len - 1},`];
     }
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, size + 1);
     const fullSize = def.len - 1;
     ctx.array[ctx.index] = size;
@@ -30,12 +30,12 @@ map[STRING] = (ctx, val, def) => {
 };
 map[BOOLEAN] = (ctx, val, def) => {
     val ??= def.default;
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, 1);
     writeU8(ctx, val ? 1 : 0);
 };
 map[ENUM] = (ctx, val, def) => {
-    validate(def, val);
+    validate(val, def);
     if (val === null) {
         reserve(ctx, 1);
         writeU8(ctx, def.default);
@@ -50,46 +50,45 @@ map[ENUM] = (ctx, val, def) => {
 };
 map[NUMBER] = (ctx, val, def) => {
     val ??= def.default;
-    validate(def, val);
-    const view = new DataView(ctx.array.buffer, ctx.array.byteOffset + ctx.index, 8);
+    validate(val, def);
     reserve(ctx, 8);
-    view.setFloat64(0, val, true);
+    writeDoubleLE(ctx.array, val, ctx.array.byteOffset + ctx.index);
     ctx.index += 8;
 };
 map[TIMESTAMP] = (ctx, val, def) => {
     val ??= def.default;
     const parsedValue = convertToTimestamp(val);
-    validate(def, parsedValue);
+    validate(parsedValue, def);
     reserve(ctx, 8);
     writeU64(ctx, parsedValue);
 };
 map[UINT32] = (ctx, val, def) => {
     val ??= def.default;
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, 4);
     writeU32(ctx, val);
 };
 map[UINT16] = (ctx, val, def) => {
     val ??= def.default;
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, 2);
     writeU16(ctx, val);
 };
 map[UINT8] = map[INT8] = (ctx, val, def) => {
     val ??= def.default;
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, 1);
     writeU8(ctx, val);
 };
 map[INT32] = (ctx, val, def) => {
     val ??= def.default;
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, 4);
     writeU32(ctx, val);
 };
 map[INT16] = (ctx, val, def) => {
     val ??= def.default;
-    validate(def, val);
+    validate(val, def);
     reserve(ctx, 2);
     writeU16(ctx, val);
 };

package/dist/src/client/modify/props/reference.js

@@ -19,7 +19,7 @@ export const writeReference = (ctx, def, val) => {
         return;
     }
     if (typeof val === 'number') {
-        validate(def, val);
+        validate(val, def);
         if (def.hasDefaultEdges) {
             writeReferenceId(ctx, def, val, EDGE_NOINDEX_REALID);
             writeEdges(ctx, def, {}, true);
@@ -44,7 +44,7 @@ export const writeReference = (ctx, def, val) => {
             }
         }
         if (typeof val.id === 'number') {
-            validate(def, val.id);
+            validate(val.id, def);
             if (!def.edges || val instanceof Tmp || val instanceof Promise) {
                 writeReferenceId(ctx, def, val.id, NOEDGE_NOINDEX_REALID);
             }

package/dist/src/client/modify/props/references.js

@@ -41,7 +41,7 @@ const putReferences = (ctx, def, val, refOp) => {
     let index = 0;
     for (const id of val) {
         if (typeof id === 'number') {
-            validate(def, id);
+            validate(id, def);
             writeU32(ctx, id);
             index++;
             continue;
@@ -50,7 +50,7 @@ const putReferences = (ctx, def, val, refOp) => {
             if (hasEdgeOrIndex(def, id)) {
                 return index;
             }
-            validate(def, id.id);
+            validate(id.id, def);
             writeU32(ctx, id.id);
             index++;
             continue;
@@ -78,7 +78,7 @@ const updateReferences = (ctx, def, val, index, length, refOp) => {
             }
         }
         if (typeof id === 'number') {
-            validate(def, id);
+            validate(id, def);
             writeU8(ctx, NOEDGE_NOINDEX_REALID);
             writeU32(ctx, id);
             continue;
@@ -88,7 +88,7 @@ const updateReferences = (ctx, def, val, index, length, refOp) => {
         }
         if (typeof id.then === 'function') {
             if (id.id) {
-                validate(def, id.id);
+                validate(id.id, def);
                 writeU8(ctx, NOEDGE_NOINDEX_REALID);
                 writeU32(ctx, id.id);
                 continue;
@@ -101,7 +101,7 @@ const updateReferences = (ctx, def, val, index, length, refOp) => {
             throw id;
         }
         if (typeof id.id === 'number') {
-            validate(def, id.id);
+            validate(id.id, def);
             writeReferenceObj(ctx, def, id.id, id, false);
             continue;
         }
@@ -110,7 +110,7 @@ const updateReferences = (ctx, def, val, index, length, refOp) => {
         }
         if (typeof id.id.then === 'function') {
             if (id.id.id) {
-                validate(def, id.id.id);
+                validate(id.id.id, def);
                 writeReferenceObj(ctx, def, id.id.id, id, false);
                 continue;
             }
@@ -185,7 +185,7 @@ const deleteReferences = (ctx, def, val) => {
     writeU8(ctx, REF_OP_DELETE);
     for (const id of val) {
         if (typeof id === 'number') {
-            validate(def, id);
+            validate(id, def);
             writeU32(ctx, id);
             continue;
         }

package/dist/src/client/modify/props/string.js

@@ -28,7 +28,7 @@ export const writeString = (ctx, def, val, lang) => {
         deleteString(ctx, def, lang);
         return;
     }
-    validate(def, val);
+    validate(val, def);
     let size = isUint8 ? val.byteLength : ENCODER.encode(val).byteLength + 6;
     reserve(ctx, FULL_CURSOR_SIZE + 11 + size);
     writePropCursor(ctx, def);

package/dist/src/client/modify/props/vector.js

@@ -8,7 +8,7 @@ export const writeVector = (ctx, def, val) => {
         deleteProp(ctx, def);
         return;
     }
-    validate(def, val);
+    validate(val, def);
     if (val.byteLength === 0) {
         deleteProp(ctx, def);
         return;
@@ -34,15 +34,5 @@ export const writeVector = (ctx, def, val) => {
     ctx.array[ctx.index++] = 0;
     ctx.array.set(new Uint8Array(val.buffer).subarray(0, size), ctx.index - padding);
     ctx.index += size;
-    // let size = Math.min(val.byteLength, def.len)
-    // let padding = 0
-    // if (ctx.index % 4 !== 0) {
-    //   padding = ctx.index % 4
-    //   size -= padding
-    // }
-    // writeU32(ctx, size + 4)
-    // writeU8(ctx, padding)
-    // writePadding(ctx, 3 - padding)
-    // writeU8Array(ctx, new Uint8Array(val.buffer).subarray(0, size))
 };
 //# sourceMappingURL=vector.js.map

package/dist/src/client/modify/types.d.ts

@@ -16,6 +16,7 @@ export declare const PADDING = 255;
 export declare const SWITCH_TYPE = 2;
 export declare const SWITCH_FIELD = 0;
 export declare const SWITCH_ID_CREATE = 9;
+export declare const SWITCH_ID_CREATE_RING = 19;
 export declare const SWITCH_ID_CREATE_UNSAFE = 8;
 export declare const SWITCH_ID_UPDATE = 1;
 export declare const UPSERT = 17;

package/dist/src/client/modify/types.js

@@ -15,6 +15,7 @@ export const PADDING = 255;
 export const SWITCH_TYPE = 2;
 export const SWITCH_FIELD = 0;
 export const SWITCH_ID_CREATE = 9;
+export const SWITCH_ID_CREATE_RING = 19;
 export const SWITCH_ID_CREATE_UNSAFE = 8;
 export const SWITCH_ID_UPDATE = 1;
 export const UPSERT = 17;

package/dist/src/client/modify/validate.d.ts

@@ -1,6 +1,6 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { DbClient } from '../../index.js';
-export declare const validate: (def: PropDef | PropDefEdge, val: any) => void;
+export declare const validate: (val: any, def: PropDef | PropDefEdge) => void;
 export declare const validatePayload: (payload: any) => void;
 export declare const validateId: (id: number) => void;
 export declare const getValidSchema: (db: DbClient, type: string) => import("@based/schema/def").SchemaTypeDef;

package/dist/src/client/modify/validate.js

@@ -1,7 +1,8 @@
 import { isValidId } from '@based/schema/def';
-export const validate = (def, val) => {
-    if (!def.validation(val, def)) {
-        throw [def, val];
+export const validate = (val, def) => {
+    const msg = def.validation(val, def.schema);
+    if (msg !== true) {
+        throw [def, val, msg];
     }
 };
 export const validatePayload = (payload) => {

package/dist/src/client/query/BasedDbQuery.d.ts

@@ -24,9 +24,9 @@ export declare class QueryBranch<T> {
     search(query: string, ...fields: Search[]): T;
     search(query: ArrayBufferView, field: string, opts?: Omit<FilterOpts, 'lowerCase'>): T;
     groupBy(field: string, step?: StepInput): T;
-    count(field?: string): T;
+    count(): T;
     sum(...fields: string[]): T;
-    cardinality(field: string): T;
+    cardinality(...fields: string[]): T;
     stddev(...args: (string | aggFnOptions)[]): T;
     var(...args: (string | aggFnOptions)[]): T;
     avg(...fields: string[]): T;
@@ -52,9 +52,9 @@ export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     readSchema: ReaderSchema;
     constructor(db: DbClient, type: string, rawTarget?: QueryByAliasObj | number | Promise<number> | Uint32Array | (QueryByAliasObj | number)[], skipValidation?: boolean);
     reset(): void;
-    id: number;
     get(): GetPromise;
-    buffer: Uint8Array;
+    buffer?: Uint8Array;
+    subscriptionBuffer?: Uint8Array;
     register(): void;
     locale(locale: LangName, fallBack?: LangFallback): this;
     subscribe(onData: OnData, onError?: OnError): import("./subscription/types.js").OnClose;

package/dist/src/client/query/BasedDbQuery.js

@@ -129,16 +129,16 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
-    count(field = 'count') {
+    count() {
+        const fields = ['count'];
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'count',
-                args: [field],
+                args: fields,
             });
         }
         else {
-            const p = field.split('.');
-            addAggregate(this, AggregateType.COUNT, p);
+            addAggregate(this, AggregateType.COUNT, fields);
         }
         // @ts-ignore
         return this;
@@ -159,18 +159,18 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
-    cardinality(field) {
-        if (field.length === 0) {
+    cardinality(...fields) {
+        if (fields.length === 0) {
             throw new Error('Empty cardinality() called');
         }
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'cardinality',
-                args: [field],
+                args: fields,
             });
         }
         else {
-            addAggregate(this, AggregateType.CARDINALITY, [field]);
+            addAggregate(this, AggregateType.CARDINALITY, fields);
         }
         // @ts-ignore
         return this;
@@ -335,6 +335,18 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
+    // first() {
+    //   if (this.queryCommands) {
+    //     this.queryCommands.push({ method: 'first', args: [] })
+    //   } else {
+    //     const offset = 0
+    //     const limit = 1
+    //     this.def.range.offset = offset
+    //     this.def.range.limit = limit
+    //   }
+    //   // @ts-ignore
+    //   return this
+    // }
     include(...fields) {
         if (this.queryCommands) {
             this.queryCommands.push({ method: 'include', args: fields });
@@ -408,7 +420,7 @@ export class BasedDbQuery extends QueryBranch {
         this.target = target;
     }
     reset() {
-        this.id = undefined;
+        this.subscriptionBuffer = undefined;
         this.buffer = undefined;
         this.def = undefined;
     }
@@ -427,12 +439,12 @@ export class BasedDbQuery extends QueryBranch {
             reject(err);
             return;
         }
-        const d = performance.now();
         await this.db.isModified();
         if (this.db.schema?.hash !== this.def.schemaChecksum) {
             this.reset();
             return this.#getInternal(resolve, reject);
         }
+        const d = performance.now();
         const res = await this.db.hooks.getQueryBuf(buf);
         if (res.byteLength === 1) {
             if (res[0] === 0) {
@@ -461,12 +473,11 @@ export class BasedDbQuery extends QueryBranch {
             resolve(new BasedQueryResponse(this.def, res, performance.now() - d));
         }
     };
-    // if !id not initialized yet
-    id;
     get() {
         return new GetPromise(this.#getInternal);
     }
     buffer;
+    subscriptionBuffer;
     register() {
         registerQuery(this);
     }

package/dist/src/client/query/BasedQueryResponse.d.ts

@@ -10,7 +10,6 @@ export declare class BasedQueryResponse {
     end: number;
     constructor(def: QueryDef, result: Uint8Array, execTime: number, end?: number);
     get id(): number;
-    get queryId(): number;
     get version(): number;
     get size(): number;
     [inspect.custom](depth: number): string;

package/dist/src/client/query/BasedQueryResponse.js

@@ -19,9 +19,6 @@ export class BasedQueryResponse {
     get id() {
         return readId(this.def.readSchema, this.result);
     }
-    get queryId() {
-        return this.def.queryId;
-    }
     get version() {
         return readVersion(this.result);
     }

package/dist/src/client/query/aggregates/aggregation.d.ts

@@ -4,5 +4,5 @@ import { QueryBranch } from '../BasedDbQuery.js';
 import { AggregateType } from '@based/protocol/db-read';
 export declare const aggregateToBuffer: (aggregates: QueryDefAggregation) => Uint8Array;
 export declare const groupBy: (q: QueryBranch<any>, field: string, StepInput: StepInput) => void;
-export declare const addAggregate: (query: QueryBranch<any>, type: AggregateType, fields: string[], option?: aggFnOptions) => void;
+export declare const addAggregate: (query: QueryBranch<any>, type: AggregateType, propNames: string[], option?: aggFnOptions) => void;
 export declare const isRootCountOnly: (def: QueryDef, filterSize: number) => boolean;

package/dist/src/client/query/aggregates/aggregation.js

@@ -1,8 +1,8 @@
 import { writeUint16, writeInt16, writeUint32 } from '@based/utils';
 import { QueryDefType } from '../types.js';
 import { setMode } from './types.js';
-import { UINT32 } from '@based/schema/def';
-import { aggregationFieldDoesNotExist, validateStepRange, } from '../validation.js';
+import { REFERENCE, REFERENCES, isPropDef, } from '@based/schema/def';
+import { aggregationFieldDoesNotExist, validateStepRange, edgeNotImplemented, } from '../validation.js';
 import { aggregateTypeMap, Interval, } from '../aggregates/types.js';
 import { AggregateType } from '@based/protocol/db-read';
 export const aggregateToBuffer = (aggregates) => {
@@ -54,16 +54,19 @@ export const aggregateToBuffer = (aggregates) => {
             i += 2;
             writeUint16(aggBuffer, agg.accumulatorPos, i);
             i += 2;
+            aggBuffer[i] = agg.propDef.__isEdge ? 1 : 0;
+            i += 1;
             size += i - startI;
         }
         writeUint16(aggBuffer, size, sizeIndex);
     }
+    // console.log('aggBuffer', aggBuffer)
     return aggBuffer;
 };
 const ensureAggregate = (def) => {
     if (!def.aggregate) {
         def.aggregate = {
-            size: 7,
+            size: 6, // groupBy + resultSize, accumulatorSize, mode,
             aggregates: new Map(),
             totalResultsSize: 0,
             totalAccumulatorSize: 0,
@@ -88,9 +91,11 @@ export const groupBy = (q, field, StepInput) => {
         groupByHook(q, field);
         def.schema.hooks.groupBy = groupByHook;
     }
-    ensureAggregate(def);
+    if (!def.aggregate) {
+        ensureAggregate(def);
+    }
     if (!def.aggregate.groupBy) {
-        def.aggregate.size += 12;
+        def.aggregate.size += 13; // field, srcPropType, start, len, stepType, stepRange, timezone
     }
     def.aggregate.groupBy = fieldDef;
     def.aggregate.groupBy.stepRange = undefined;
@@ -124,60 +129,127 @@ export const groupBy = (q, field, StepInput) => {
         def.aggregate.groupBy.display = StepInput?.display;
     }
 };
-export const addAggregate = (query, type, fields, option) => {
-    const def = query.def;
-    let hookFields;
-    ensureAggregate(def);
-    if (option?.mode) {
-        def.aggregate.option = option;
-    }
+const updateAggregateDefs = (def, propDef, aggType) => {
     const aggregates = def.aggregate.aggregates;
-    for (const field of fields) {
-        const fieldDef = type === AggregateType.COUNT
-            ? {
-                prop: 255,
-                path: [field],
-                __isPropDef: true,
-                len: 4,
-                start: 0,
-                typeIndex: UINT32,
-                separate: true,
-                validation: () => true,
-                default: 0,
+    if (!aggregates.get(propDef.prop)) {
+        aggregates.set(propDef.prop, []);
+        def.aggregate.size += 3; // field + fieldAggSize
+    }
+    const aggregateField = aggregates.get(propDef.prop);
+    aggregateField.push({
+        type: aggType,
+        propDef: propDef,
+        resultPos: def.aggregate.totalResultsSize,
+        accumulatorPos: def.aggregate.totalAccumulatorSize,
+        isEdge: isEdge(propDef.path[0]),
+    });
+    const specificSizes = aggregateTypeMap.get(aggType);
+    if (specificSizes) {
+        def.aggregate.totalResultsSize += specificSizes.resultsSize;
+        def.aggregate.totalAccumulatorSize += specificSizes.accumulatorSize;
+    }
+    else {
+        def.aggregate.totalResultsSize += 8;
+        def.aggregate.totalAccumulatorSize += 8;
+    }
+    // needs to add an extra field WRITE TO
+    def.aggregate.size += 9; // aggType + propType + start + resultPos + accumulatorPos + isEdge
+};
+const isCount = (propString, aggType) => {
+    return propString === 'count' || aggType === AggregateType.COUNT;
+};
+const isEdge = (propString) => {
+    return propString.startsWith('$');
+};
+const isReferenceOrReferences = (typeIndex) => {
+    return typeIndex === REFERENCE || typeIndex === REFERENCES;
+};
+const getPropDefinition = (def, propName, type, resolvedPropDef) => {
+    if (isCount(propName, type)) {
+        return {
+            schema: null,
+            prop: 255,
+            path: [propName],
+            __isPropDef: true,
+            len: 4,
+            start: 0,
+            typeIndex: 1,
+            separate: true,
+            validation: () => true,
+            default: 0,
+        };
+    }
+    return resolvedPropDef || def.schema.props[propName];
+};
+const IN_RECURSION = Symbol('IN_RECURSION');
+// process references, nested, edges
+// return undefined if skip to recursive call (refs)
+const processPropPath = (query, path, originalPropName, type) => {
+    let t = query.def.schema.tree;
+    for (let i = 0; i < path.length; i++) {
+        const propName = path[i];
+        if (isEdge(propName)) {
+            // @ts-ignore
+            const edgePropDef = query.def.target?.propDef?.edges[propName];
+            if (edgePropDef) {
+                return edgePropDef;
+            }
+            else {
+                edgeNotImplemented(query.def, propName);
+                return undefined;
             }
-            : def.schema.props[field];
-        if (!fieldDef) {
-            aggregationFieldDoesNotExist(def, field);
         }
-        if (fieldDef.hooks?.aggregate) {
-            hookFields ??= new Set(fields);
-            fieldDef.hooks.aggregate(query, hookFields);
+        if (!t) {
+            return undefined; // end
         }
-        if (!aggregates.get(fieldDef.prop)) {
-            aggregates.set(fieldDef.prop, []);
-            def.aggregate.size += 3;
+        t = t[propName];
+        if (!t) {
+            return undefined; // path nor exist
         }
-        const aggregateField = aggregates.get(fieldDef.prop);
-        aggregateField.push({
-            propDef: fieldDef,
-            type,
-            resultPos: def.aggregate.totalResultsSize,
-            accumulatorPos: def.aggregate.totalAccumulatorSize,
-        });
-        const specificSizes = aggregateTypeMap.get(type);
-        if (specificSizes) {
-            def.aggregate.totalResultsSize += specificSizes.resultsSize;
-            def.aggregate.totalAccumulatorSize += specificSizes.accumulatorSize;
+        if (isPropDef(t) && isReferenceOrReferences(t.typeIndex)) {
+            const remainingPath = path.slice(i + 1).join('.');
+            if (isEdge(remainingPath)) {
+                return t; // let the calling handle it
+            }
+            if (remainingPath) {
+                addAggregate(query, type, [remainingPath], query.def.aggregate.option);
+            }
+            return IN_RECURSION;
+        }
+    }
+    return isPropDef(t) ? t : undefined;
+};
+export const addAggregate = (query, type, propNames, option) => {
+    const def = query.def;
+    let hookPropNames;
+    ensureAggregate(def);
+    if (option?.mode) {
+        def.aggregate.option = option;
+    }
+    for (const propName of propNames) {
+        if (Array.isArray(propName)) {
+            addAggregate(query, type, propName, option);
         }
         else {
-            def.aggregate.totalResultsSize += 8;
-            def.aggregate.totalAccumulatorSize += 8;
+            const path = propName.split('.');
+            let resolvedPropDef = processPropPath(query, path, propName, type);
+            if (resolvedPropDef === IN_RECURSION) {
+                continue;
+            }
+            let propDef = getPropDefinition(def, propName, type, resolvedPropDef);
+            if (!propDef) {
+                aggregationFieldDoesNotExist(def, propName);
+                return;
+            }
+            if (propDef.hooks?.aggregate) {
+                hookPropNames ??= new Set(propNames);
+                propDef.hooks.aggregate(query, hookPropNames);
+            }
+            updateAggregateDefs(def, propDef, type);
+            if (def.schema.hooks?.aggregate) {
+                def.schema.hooks.aggregate(query, hookPropNames || new Set(propNames));
+            }
         }
-        // needs to add an extra field WRITE TO
-        def.aggregate.size += 8;
-    }
-    if (def.schema.hooks?.aggregate) {
-        def.schema.hooks.aggregate(query, hookFields || new Set(fields));
     }
 };
 export const isRootCountOnly = (def, filterSize) => {