@based/db 0.1.3-alpha.1 → 0.1.4

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

@@ -1,11 +1,9 @@
-import { writeUint16, writeUint32 } from '@based/utils';
 import { rejectTmp, resolveTmp } from './Tmp.js';
 export const reset = (ctx) => {
     ctx.index = 8;
     ctx.max = ctx.array.buffer.maxByteLength - 4;
     ctx.size = ctx.array.buffer.byteLength - 4;
     ctx.cursor = {};
-    ctx.created = {};
     ctx.batch = {};
 };
 export const cancel = (ctx, error) => {
@@ -18,17 +16,7 @@ export const consume = (ctx) => {
     if (ctx.index > ctx.array.byteLength) {
         throw new Error('Invalid size - modify buffer length mismatch');
     }
-    const typeIds = Object.keys(ctx.created);
-    const typeSize = typeIds.length * 6 + 4;
-    const payload = ctx.array.subarray(0, ctx.index + typeSize);
-    let i = payload.byteLength - 4;
-    writeUint32(payload, ctx.index, i);
-    for (const typeId of typeIds) {
-        const count = ctx.created[typeId];
-        i -= 6;
-        writeUint16(payload, Number(typeId), i);
-        writeUint32(payload, count, i + 2);
-    }
+    const payload = ctx.array.subarray(0, ctx.index);
     reset(ctx);
     return payload;
 };
@@ -36,21 +24,30 @@ export const drain = (db, ctx) => {
     if (ctx.index > 8) {
         const { batch } = ctx;
         const payload = consume(ctx);
+        let start;
         ctx.draining = db.hooks
             .flushModify(payload)
-            .then(({ offsets, dbWriteTime }) => {
-            db.writeTime += dbWriteTime ?? 0;
-            batch.ready = true;
-            batch.offsets = offsets;
-            batch.promises?.forEach(resolveTmp);
-            batch.promises = null;
+            .then((res) => {
+            if (res === null) {
+                throw Error('Schema mismatch');
+            }
+            batch.res = res;
         })
             .catch((e) => {
-            console.error(e);
-            batch.ready = true;
             batch.error = e;
-            batch.promises?.forEach(rejectTmp);
-            batch.promises = null;
+        })
+            .finally(() => {
+            batch.ready = true;
+            if (batch.promises) {
+                start = ctx.index;
+                batch.promises.forEach(batch.error ? rejectTmp : resolveTmp);
+                batch.promises = null;
+            }
+        })
+            .then(() => {
+            if (start && start !== ctx.index) {
+                return drain(db, ctx);
+            }
         });
     }
     return ctx.draining;

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

@@ -1,6 +1,6 @@
 import { REFERENCES } from '@based/schema/def';
 import { reserve } from '../resize.js';
-import { writeU32 } from '../uint.js';
+import { writePadding, writeU32 } from '../uint.js';
 import { writeEdgeHeader } from './header.js';
 export const writeReferencesEdge = (ctx, edge, vals) => {
     if (vals === null) {
@@ -12,7 +12,7 @@ export const writeReferencesEdge = (ctx, edge, vals) => {
     if (!Array.isArray(vals)) {
         throw [edge, vals];
     }
-    const size = vals.length * 4;
+    const size = vals.length * 4 + 3; // add 3 padding
     reserve(ctx, 3 + 4 + size);
     writeEdgeHeader(ctx, edge, REFERENCES);
     writeU32(ctx, size);
@@ -34,5 +34,6 @@ export const writeReferencesEdge = (ctx, edge, vals) => {
         }
         throw [edge, vals];
     }
+    writePadding(ctx, 3);
 };
 //# sourceMappingURL=references.js.map

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

@@ -4,4 +4,5 @@ import { Ctx } from './Ctx.js';
 import { del } from './delete/index.js';
 import { expire } from './expire/index.js';
 import { update } from './update/index.js';
-export declare const handleError: (db: DbClient, ctx: Ctx, fn: typeof create | typeof update | typeof del | typeof expire, args: IArguments, e: any) => Promise<number>;
+import { upsert } from './upsert/index.js';
+export declare const handleError: (db: DbClient, ctx: Ctx, fn: typeof create | typeof update | typeof del | typeof expire | typeof upsert, args: IArguments, e: any) => Promise<number>;

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

@@ -27,7 +27,7 @@ const parseVal = (val) => {
     }
     return val;
 };
-const parseErrorMsg = (prop, val, msg) => {
+const parseErrorArr = (prop, val, msg) => {
     if (isPropDef(prop)) {
         if (msg) {
             return `Invalid value at '${prop.path.join('.')}'. Expected ${msg} received '${parseVal(val)}'`;
@@ -59,7 +59,7 @@ export const handleError = (db, ctx, fn, args, e) => {
     }
     if (Array.isArray(e)) {
         const [def, val, msg] = e;
-        throw Error(parseErrorMsg(def, val, msg));
+        throw Error(parseErrorArr(def, val, msg));
     }
     throw e;
 };

package/dist/src/client/modify/expire/index.js

@@ -1,8 +1,8 @@
 import { getValidSchema, validateId } from '../validate.js';
 import { handleError } from '../error.js';
 import { reserve } from '../resize.js';
-import { NODE_CURSOR_SIZE, TYPE_CURSOR_SIZE, writeNodeCursor, writeTypeCursor, } from '../cursor.js';
-import { EXPIRE } from '../types.js';
+import { NODE_CURSOR_SIZE, TYPE_CURSOR_SIZE, writeTypeCursor, } from '../cursor.js';
+import { EXPIRE, SWITCH_ID_UPDATE } from '../types.js';
 import { schedule } from '../drain.js';
 import { Tmp } from '../Tmp.js';
 import { writeU32, writeU8 } from '../uint.js';
@@ -10,17 +10,16 @@ export function expire(db, type, id, seconds) {
     const ctx = db.modifyCtx;
     const schema = getValidSchema(db, type);
     try {
-        ctx.id = id;
         ctx.start = ctx.index;
         ctx.schema = schema;
-        ctx.operation = EXPIRE;
         validateId(id);
         reserve(ctx, TYPE_CURSOR_SIZE + NODE_CURSOR_SIZE + 5);
         writeTypeCursor(ctx);
-        writeNodeCursor(ctx);
+        writeU8(ctx, SWITCH_ID_UPDATE);
+        writeU32(ctx, id);
         writeU8(ctx, EXPIRE);
         writeU32(ctx, seconds);
-        const tmp = new Tmp(ctx, id);
+        const tmp = new Tmp(ctx);
         schedule(db, ctx);
         return tmp;
     }

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

@@ -2,11 +2,12 @@ import { isPropDef } from '@based/schema/def';
 import { writeSeparate } from './separate.js';
 import { writeMainValue } from './main.js';
 import { writeIncrement } from './increment.js';
+import { CREATE } from '../types.js';
 const writeProp = (ctx, def, val) => {
     if (def.separate) {
         writeSeparate(ctx, def, val);
     }
-    else if (ctx.overwrite) {
+    else if (ctx.operation === CREATE) {
         writeMainValue(ctx, def, val);
     }
     else if (typeof val === 'object' && val !== null) {
@@ -24,7 +25,7 @@ export const writeObjectSafe = (ctx, tree, obj) => {
         }
         const def = tree[key];
         if (def === undefined) {
-            throw [def, val];
+            throw [tree, val];
         }
         if (isPropDef(def)) {
             writeProp(ctx, def, val);

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

@@ -5,10 +5,8 @@ import { EDGE_NOINDEX_REALID, EDGE_NOINDEX_TMPID, NOEDGE_NOINDEX_REALID, NOEDGE_
 import { writeEdges } from '../edges/index.js';
 import { deleteProp } from './delete.js';
 import { writeU32, writeU8 } from '../uint.js';
+import { validate } from '../validate.js';
 const writeReferenceId = (ctx, def, val, refOp) => {
-    if (!def.validation(val, def)) {
-        throw [def, val];
-    }
     reserve(ctx, PROP_CURSOR_SIZE + 6);
     writePropCursor(ctx, def);
     writeU8(ctx, ctx.operation);
@@ -21,6 +19,7 @@ export const writeReference = (ctx, def, val) => {
         return;
     }
     if (typeof val === 'number') {
+        validate(def, val);
         if (def.hasDefaultEdges) {
             writeReferenceId(ctx, def, val, EDGE_NOINDEX_REALID);
             writeEdges(ctx, def, {}, true);
@@ -45,6 +44,7 @@ export const writeReference = (ctx, def, val) => {
             }
         }
         if (typeof val.id === 'number') {
+            validate(def, val.id);
             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

@@ -101,6 +101,7 @@ const updateReferences = (ctx, def, val, index, length, refOp) => {
             throw id;
         }
         if (typeof id.id === 'number') {
+            validate(def, id.id);
             writeReferenceObj(ctx, def, id.id, id, false);
             continue;
         }
@@ -109,6 +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);
                 writeReferenceObj(ctx, def, id.id.id, id, false);
                 continue;
             }
@@ -151,7 +153,6 @@ const putOrUpdateReferences = (ctx, def, val, refOp) => {
 const writeReferenceObj = (ctx, def, id, obj, isTmp) => {
     const hasIndex = typeof obj.$index === 'number';
     const hasEdges = hasAnEdge(def, obj);
-    validate(def, id);
     if (hasIndex) {
         if (hasEdges) {
             writeU8(ctx, isTmp ? EDGE_INDEX_TMPID : EDGE_INDEX_REALID);

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

@@ -12,10 +12,14 @@ export declare const EXPIRE = 14;
 export declare const ADD_EMPTY_SORT_TEXT = 15;
 export declare const ADD_EMPTY_SORT = 7;
 export declare const DELETE_TEXT_FIELD = 16;
+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_UNSAFE = 8;
 export declare const SWITCH_ID_UPDATE = 1;
+export declare const UPSERT = 17;
+export declare const INSERT = 18;
 export type ModifyOp = typeof CREATE | typeof UPDATE | typeof INCREMENT | typeof EXPIRE;
 export declare const MOD_OPS_TO_STRING: Record<ModifyOp, 'create' | 'update'>;
 export declare const enum SIZE {
@@ -24,7 +28,6 @@ export declare const enum SIZE {
 export type ModifyOpts = {
     unsafe?: boolean;
     locale?: LangName;
-    overwrite?: boolean;
 };
 export declare const NOEDGE_NOINDEX_REALID = 0;
 export declare const EDGE_NOINDEX_REALID = 1;

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

@@ -11,10 +11,14 @@ export const EXPIRE = 14;
 export const ADD_EMPTY_SORT_TEXT = 15;
 export const ADD_EMPTY_SORT = 7;
 export const DELETE_TEXT_FIELD = 16;
+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_UNSAFE = 8;
 export const SWITCH_ID_UPDATE = 1;
+export const UPSERT = 17;
+export const INSERT = 18;
 export const MOD_OPS_TO_STRING = {
     [CREATE]: 'create',
     [UPDATE]: 'update',

package/dist/src/client/modify/update/index.d.ts

@@ -1,3 +1,6 @@
+import { Ctx } from '../Ctx.js';
 import { ModifyOpts } from '../types.js';
 import { DbClient } from '../../../index.js';
+import { SchemaTypeDef } from '@based/schema/def';
+export declare const writeUpdate: (ctx: Ctx, schema: SchemaTypeDef, id: number, payload: any, opts: ModifyOpts) => void;
 export declare function update(db: DbClient, type: string, id: number, payload: any, opts: ModifyOpts): Promise<number>;

package/dist/src/client/modify/update/index.js

@@ -1,13 +1,13 @@
-import { UPDATE, UPDATE_PARTIAL } from '../types.js';
+import { SWITCH_ID_UPDATE, UPDATE, UPDATE_PARTIAL, } from '../types.js';
 import { getValidSchema, validateId, validatePayload } from '../validate.js';
 import { langCodesMap } from '@based/schema';
 import { handleError } from '../error.js';
 import { Tmp } from '../Tmp.js';
 import { writeObject } from '../props/object.js';
 import { reserve } from '../resize.js';
-import { FULL_CURSOR_SIZE, PROP_CURSOR_SIZE, writeMainCursor, writeNodeCursor, writeTypeCursor, } from '../cursor.js';
+import { FULL_CURSOR_SIZE, PROP_CURSOR_SIZE, writeMainCursor, writeTypeCursor, } from '../cursor.js';
 import { getByPath, writeUint32 } from '@based/utils';
-import { writeU16, writeU8 } from '../uint.js';
+import { writeU16, writeU32, writeU8 } from '../uint.js';
 import { writeFixed } from '../props/fixed.js';
 import { schedule } from '../drain.js';
 const writeUpdateTs = (ctx, payload) => {
@@ -37,10 +37,35 @@ const writeMergeMain = (ctx) => {
         writeUint32(ctx.array, ctx.index - start, index);
     }
 };
-const writeUpdate = (ctx, payload) => {
+export const writeUpdate = (ctx, schema, id, payload, opts) => {
+    validatePayload(payload);
+    if (schema.propHooks?.update) {
+        for (const def of schema.propHooks.update) {
+            let val = payload;
+            let obj;
+            let key;
+            for (key of def.path) {
+                obj = val;
+                val = val?.[key];
+            }
+            if (val !== undefined) {
+                obj[key] = def.hooks.update(val, obj);
+            }
+        }
+    }
+    if (schema.hooks?.update) {
+        payload = schema.hooks.update(payload) || payload;
+    }
+    ctx.schema = schema;
+    ctx.operation = UPDATE;
+    ctx.locale = opts?.locale && langCodesMap.get(opts.locale);
+    if (ctx.main.size) {
+        ctx.main.clear();
+    }
     reserve(ctx, FULL_CURSOR_SIZE);
     writeTypeCursor(ctx);
-    writeNodeCursor(ctx);
+    writeU8(ctx, SWITCH_ID_UPDATE);
+    writeU32(ctx, id);
     writeObject(ctx, ctx.schema.tree, payload);
     writeUpdateTs(ctx, payload);
     writeMergeMain(ctx);
@@ -48,23 +73,11 @@ const writeUpdate = (ctx, payload) => {
 export function update(db, type, id, payload, opts) {
     const schema = getValidSchema(db, type);
     const ctx = db.modifyCtx;
+    ctx.start = ctx.index;
     try {
-        validatePayload(payload);
         validateId(id);
-        if (schema.hooks?.update) {
-            payload = schema.hooks.update(payload) || payload;
-        }
-        ctx.id = id;
-        ctx.schema = schema;
-        ctx.operation = UPDATE;
-        ctx.overwrite = opts?.overwrite;
-        ctx.locale = opts?.locale && langCodesMap.get(opts.locale);
-        ctx.start = ctx.index;
-        if (ctx.main.size) {
-            ctx.main.clear();
-        }
-        writeUpdate(ctx, payload);
-        const tmp = new Tmp(ctx, id);
+        writeUpdate(ctx, schema, id, payload, opts);
+        const tmp = new Tmp(ctx);
         schedule(db, ctx);
         return tmp;
     }

package/dist/src/client/modify/upsert/index.d.ts

@@ -1,3 +1,4 @@
 import { DbClient } from '../../../index.js';
 import { ModifyOpts } from '../types.js';
-export declare const upsert: (db: DbClient, type: string, obj: any, opts: ModifyOpts) => Promise<number>;
+export declare function upsert(db: DbClient, type: string, payload: any, opts: ModifyOpts): Promise<number>;
+export declare function insert(db: DbClient, type: string, payload: any, opts: ModifyOpts): Promise<number>;

package/dist/src/client/modify/upsert/index.js

@@ -1,54 +1,77 @@
 import { ALIAS, isPropDef } from '@based/schema/def';
-import { deepMerge } from '@based/utils';
-const filterAliases = (obj, tree) => {
-    let aliases;
+import { INSERT, UPSERT } from '../types.js';
+import { getValidSchema } from '../validate.js';
+import { writeU32, writeU8, writeU8Array } from '../uint.js';
+import { reserve } from '../resize.js';
+import { ENCODER, writeUint32 } from '@based/utils';
+import { writeCreate } from '../create/index.js';
+import { handleError } from '../error.js';
+import { writeUpdate } from '../update/index.js';
+import { schedule } from '../drain.js';
+import { TYPE_CURSOR_SIZE, writeTypeCursor } from '../cursor.js';
+import { Tmp } from '../Tmp.js';
+const writeAliases = (ctx, tree, obj) => {
     for (const key in obj) {
         const def = tree[key];
-        if (def === undefined) {
-            return;
+        const val = obj[key];
+        if (def === undefined || val === undefined) {
+            continue;
         }
-        if (isPropDef(def)) {
-            if (def.typeIndex === ALIAS) {
-                aliases ??= {};
-                aliases[key] = obj[key];
-            }
+        if (!isPropDef(def)) {
+            writeAliases(ctx, def, val);
         }
-        else {
-            const nested = filterAliases(obj[key], def);
-            if (nested) {
-                aliases ??= {};
-                aliases[key] = nested;
-            }
+        else if (def.typeIndex === ALIAS) {
+            const buf = ENCODER.encode(val);
+            reserve(ctx, 1 + 4 + buf.byteLength);
+            writeU8(ctx, def.prop);
+            writeU32(ctx, buf.byteLength);
+            writeU8Array(ctx, buf);
         }
     }
-    return aliases;
 };
-export const upsert = (db, type, obj, opts) => {
-    const tree = db.schemaTypesParsed[type].tree;
-    const aliases = filterAliases(obj, tree);
-    const q = db.query(type, aliases);
-    q.register();
-    if (db.upserting.has(q.id)) {
-        const store = db.upserting.get(q.id);
-        deepMerge(store.o, obj);
-        return store.p;
+export function upsert(db, type, payload, opts) {
+    const schema = getValidSchema(db, type);
+    const ctx = db.modifyCtx;
+    ctx.start = ctx.index;
+    ctx.schema = schema;
+    try {
+        reserve(ctx, TYPE_CURSOR_SIZE + 1 + 4 + 4);
+        writeTypeCursor(ctx);
+        writeU8(ctx, UPSERT);
+        const start = ctx.index;
+        ctx.index += 8;
+        writeAliases(ctx, schema.tree, payload);
+        writeUint32(ctx.array, ctx.index - start, start);
+        writeCreate(ctx, schema, {}, opts);
+        writeUint32(ctx.array, ctx.index - start, start + 4);
+        writeUpdate(ctx, schema, 0, payload, opts);
+        schedule(db, ctx);
+        return new Tmp(ctx);
     }
-    const store = {
-        o: obj,
-        p: q.get().then((res) => {
-            db.upserting.delete(q.id);
-            if (res.length === 0) {
-                return db.create(type, store.o, opts);
-            }
-            else {
-                const obj = res.toObject();
-                const id = Array.isArray(obj) ? obj[0].id : obj.id;
-                // don't call update if it's not necessary
-                return db.update(type, id, store.o, opts);
-            }
-        }),
-    };
-    db.upserting.set(q.id, store);
-    return store.p;
-};
+    catch (e) {
+        return handleError(db, ctx, upsert, arguments, e);
+    }
+}
+export function insert(db, type, payload, opts) {
+    const schema = getValidSchema(db, type);
+    const ctx = db.modifyCtx;
+    ctx.start = ctx.index;
+    ctx.schema = schema;
+    try {
+        reserve(ctx, TYPE_CURSOR_SIZE + 1 + 4 + 4);
+        writeTypeCursor(ctx);
+        writeU8(ctx, INSERT);
+        const start = ctx.index;
+        ctx.index += 8;
+        writeAliases(ctx, schema.tree, payload);
+        writeUint32(ctx.array, ctx.index - start, start);
+        writeCreate(ctx, schema, payload, opts);
+        writeUint32(ctx.array, ctx.index - start, start + 4);
+        schedule(db, ctx);
+        return new Tmp(ctx);
+    }
+    catch (e) {
+        return handleError(db, ctx, insert, arguments, e);
+    }
+}
 //# sourceMappingURL=index.js.map

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

@@ -123,13 +123,7 @@ export class QueryBranch {
             });
         }
         else {
-            const groupByHook = this.def.schema.hooks?.groupBy;
-            if (groupByHook) {
-                this.def.schema.hooks.groupBy = null;
-                groupByHook(this, field);
-                this.def.schema.hooks.groupBy = groupByHook;
-            }
-            groupBy(this.def, field, step);
+            groupBy(this, field, step);
         }
         // only works with aggregates for now
         // @ts-ignore
@@ -347,6 +341,17 @@ export class QueryBranch {
         }
         else {
             include(this, fields);
+            if (this.def.schema.propHooks?.include) {
+                for (const field of this.def.include.stringFields.keys()) {
+                    const hooks = this.def.schema.props[field]?.hooks;
+                    const includeHook = hooks?.include;
+                    if (includeHook) {
+                        hooks.include = null;
+                        includeHook(this, this.def.include.stringFields);
+                        hooks.include = includeHook;
+                    }
+                }
+            }
             const includeHook = this.def.schema.hooks?.include;
             if (includeHook) {
                 this.def.schema.hooks.include = null;

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

@@ -3,6 +3,6 @@ import { StepInput, aggFnOptions } from './types.js';
 import { QueryBranch } from '../BasedDbQuery.js';
 import { AggregateType } from '@based/protocol/db-read';
 export declare const aggregateToBuffer: (aggregates: QueryDefAggregation) => Uint8Array;
-export declare const groupBy: (def: QueryDef, field: string, StepInput: StepInput) => void;
+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 isRootCountOnly: (def: QueryDef, filterSize: number) => boolean;

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

@@ -70,11 +70,24 @@ const ensureAggregate = (def) => {
         };
     }
 };
-export const groupBy = (def, field, StepInput) => {
+export const groupBy = (q, field, StepInput) => {
+    const def = q.def;
     const fieldDef = def.schema.props[field];
     if (!fieldDef) {
         aggregationFieldDoesNotExist(def, field);
     }
+    const groupByPropHook = fieldDef.hooks?.groupBy;
+    if (groupByPropHook) {
+        fieldDef.hooks.groupBy = null;
+        groupByPropHook(q, field);
+        fieldDef.hooks.groupBy = groupByPropHook;
+    }
+    const groupByHook = def.schema.hooks?.groupBy;
+    if (groupByHook) {
+        def.schema.hooks.groupBy = null;
+        groupByHook(q, field);
+        def.schema.hooks.groupBy = groupByHook;
+    }
     ensureAggregate(def);
     if (!def.aggregate.groupBy) {
         def.aggregate.size += 12;
@@ -113,10 +126,11 @@ export const groupBy = (def, field, StepInput) => {
 };
 export const addAggregate = (query, type, fields, option) => {
     const def = query.def;
-    def.schema.hooks?.aggregate?.(def, new Set(fields));
+    let hookFields;
     ensureAggregate(def);
-    if (option?.mode)
+    if (option?.mode) {
         def.aggregate.option = option;
+    }
     const aggregates = def.aggregate.aggregates;
     for (const field of fields) {
         const fieldDef = type === AggregateType.COUNT
@@ -135,6 +149,10 @@ export const addAggregate = (query, type, fields, option) => {
         if (!fieldDef) {
             aggregationFieldDoesNotExist(def, field);
         }
+        if (fieldDef.hooks?.aggregate) {
+            hookFields ??= new Set(fields);
+            fieldDef.hooks.aggregate(query, hookFields);
+        }
         if (!aggregates.get(fieldDef.prop)) {
             aggregates.set(fieldDef.prop, []);
             def.aggregate.size += 3;
@@ -158,6 +176,9 @@ export const addAggregate = (query, type, fields, option) => {
         // 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) => {
     if (filterSize != 0) {

package/dist/src/client/query/filter/convertFilter.js

@@ -8,16 +8,29 @@ const normalizeNeedle = (s) => {
 };
 export const convertFilter = (query, field, operator, value, opts) => {
     const def = query.def;
-    const filterHook = def.schema.hooks?.filter;
+    const propHooks = def.schema.props[field]?.hooks;
+    const hooks = def.schema.hooks;
+    const propFilterHook = propHooks?.filter;
+    const filterHook = hooks?.filter;
+    if (propFilterHook) {
+        propHooks.filter = null;
+        if (typeof operator === 'boolean') {
+            propFilterHook(query, field, '=', operator);
+        }
+        else {
+            propFilterHook(query, field, operator, value);
+        }
+        propHooks.filter = propFilterHook;
+    }
     if (filterHook) {
-        def.schema.hooks.filter = null;
+        hooks.filter = null;
         if (typeof operator === 'boolean') {
             filterHook(query, field, '=', operator);
         }
         else {
             filterHook(query, field, operator, value);
         }
-        def.schema.hooks.filter = filterHook;
+        hooks.filter = filterHook;
     }
     if (operator === undefined) {
         operator = '=';

package/dist/src/client/query/filter/types.d.ts

@@ -54,7 +54,7 @@ export declare const VECTOR_DOT_PRODUCT = 0;
 export declare const VECTOR_MANHATTAN_DIST = 1;
 export declare const VECTOR_COSTINE_SIMILARITY = 2;
 export declare const VECTOR_EUCLIDEAN_DIST = 3;
-export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 0 | 1 | 3 | 2;
+export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 1 | 0 | 3 | 2;
 export declare const toFilterCtx: (def: QueryDef, op: Operator, opts?: FilterOpts) => FilterCtx;
 export declare const operatorReverseMap: Record<OPERATOR, string>;
 export declare const ALIGNMENT_NOT_SET = 255;

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

@@ -16,7 +16,7 @@ export const include = (query, fields) => {
         }
         else if (typeof f === 'function') {
             f((field) => {
-                if (field[0] == '$') {
+                if (field[0] === '$') {
                     // @ts-ignore
                     const prop = query.def.target?.propDef?.edges[field];
                     if (prop &&
@@ -28,10 +28,7 @@ export const include = (query, fields) => {
                     throw new Error(`No edge reference or edge references field named "${field}"`);
                 }
                 else {
-                    const prop = field[0] == '$'
-                        ? // @ts-ignore
-                            query.def.target?.propDef?.edges[field]
-                        : query.def.props[field];
+                    const prop = query.def.props[field];
                     if (prop &&
                         (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
                         const refDef = createOrGetRefQueryDef(query.db, query.def, prop);