@based/db 0.0.70 → 0.1.0

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

@@ -1,19 +1,18 @@
-import { filter, sort, filterOr, isAlias, includeField, includeFields, addAggregate, groupBy, } from './query.js';
-import { BasedQueryResponse } from './BasedIterable.js';
-import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef, } from './include/utils.js';
+import { filter, sort, filterOr, isAlias, addAggregate, groupBy, } from './query.js';
+import { BasedQueryResponse } from './BasedQueryResponse.js';
 import { FilterBranch } from './filter/FilterBranch.js';
 import { search, vectorSearch } from './search/index.js';
 import native from '../../native.js';
-import { REFERENCE, REFERENCES } from '@based/schema/def';
 import { subscribe } from './subscription/index.js';
 import { registerQuery } from './registerQuery.js';
 import { langCodesMap } from '@based/schema';
 import { convertFilter } from './filter/convertFilter.js';
 import { validateLocale, validateRange } from './validation.js';
 import { DEF_RANGE_PROP_LIMIT } from './thresholds.js';
-import { AggregateType } from './aggregates/types.js';
 import { displayTarget } from './display.js';
 import picocolors from 'picocolors';
+import { include } from './include/include.js';
+import { AggregateType } from '@based/protocol/db-read';
 export class QueryBranch {
     db;
     def;
@@ -43,7 +42,7 @@ export class QueryBranch {
             });
         }
         else {
-            const f = convertFilter(this.def, field, operator, value, opts);
+            const f = convertFilter(this, field, operator, value, opts);
             if (!f) {
                 // @ts-ignore
                 return this;
@@ -53,19 +52,6 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
-    filterBatch(f) {
-        if (this.queryCommands) {
-            this.queryCommands.push({
-                method: 'filterBatch',
-                args: [f],
-            });
-        }
-        else {
-            filter(this.db, this.def, f, this.def.filter);
-        }
-        // @ts-ignore
-        return this;
-    }
     search(query, field, opts, ...fields) {
         if (this.queryCommands) {
             this.queryCommands.push({
@@ -102,7 +88,7 @@ export class QueryBranch {
             }
             if (fields.length) {
                 if (fields.length === 1) {
-                    search(this.def, query, fields[0]);
+                    search(this, query, fields[0]);
                 }
                 else {
                     const s = {};
@@ -119,31 +105,37 @@ export class QueryBranch {
                             Object.assign(s, f);
                         }
                     }
-                    search(this.def, query, s);
+                    search(this, query, s);
                 }
             }
             else {
-                search(this.def, query);
+                search(this, query);
             }
         }
         // @ts-ignore
         return this;
     }
-    groupBy(field) {
+    groupBy(field, step) {
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'groupBy',
-                args: [field],
+                args: [field, step],
             });
         }
         else {
-            groupBy(this.def, field);
+            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);
         }
         // only works with aggregates for now
         // @ts-ignore
         return this;
     }
-    count(field = '$count') {
+    count(field = 'count') {
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'count',
@@ -152,7 +144,7 @@ export class QueryBranch {
         }
         else {
             const p = field.split('.');
-            addAggregate(AggregateType.COUNT, this.def, p);
+            addAggregate(this, AggregateType.COUNT, p);
         }
         // @ts-ignore
         return this;
@@ -168,55 +160,77 @@ export class QueryBranch {
             });
         }
         else {
-            addAggregate(AggregateType.SUM, this.def, fields);
+            addAggregate(this, AggregateType.SUM, fields);
         }
         // @ts-ignore
         return this;
     }
-    cardinality(...fields) {
-        if (fields.length === 0) {
+    cardinality(field) {
+        if (field.length === 0) {
             throw new Error('Empty cardinality() called');
         }
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'cardinality',
-                args: fields,
+                args: [field],
             });
         }
         else {
-            addAggregate(AggregateType.CARDINALITY, this.def, fields);
+            addAggregate(this, AggregateType.CARDINALITY, [field]);
         }
         // @ts-ignore
         return this;
     }
-    stddev(...fields) {
-        if (fields.length === 0) {
-            throw new Error('Empty standard deviation function called');
-        }
+    stddev(...args) {
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'stddev',
-                args: fields,
+                args,
             });
         }
         else {
-            addAggregate(AggregateType.STDDEV, this.def, fields);
+            let option = {};
+            let fields;
+            const lastArg = args[args.length - 1];
+            const lastArgIsOptions = typeof lastArg === 'object' && lastArg !== null;
+            if (lastArgIsOptions) {
+                option = lastArg;
+                fields = args.slice(0, -1);
+            }
+            else {
+                fields = args;
+            }
+            if (fields.length === 0) {
+                throw new Error('Empty standard deviation function called');
+            }
+            addAggregate(this, AggregateType.STDDEV, fields, option);
         }
         // @ts-ignore
         return this;
     }
-    var(...fields) {
-        if (fields.length === 0) {
-            throw new Error('Empty variance function called');
-        }
+    var(...args) {
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'var',
-                args: fields,
+                args,
             });
         }
         else {
-            addAggregate(AggregateType.VARIANCE, this.def, fields);
+            let option = {};
+            let fields = [];
+            const lastArg = args[args.length - 1];
+            const lastArgIsOptions = typeof lastArg === 'object' && lastArg !== null;
+            if (lastArgIsOptions) {
+                option = lastArg;
+                fields = args.slice(0, -1);
+            }
+            else {
+                fields = args;
+            }
+            if (fields.length === 0) {
+                throw new Error('Empty variance called');
+            }
+            addAggregate(this, AggregateType.VARIANCE, fields, option);
         }
         // @ts-ignore
         return this;
@@ -232,7 +246,23 @@ export class QueryBranch {
             });
         }
         else {
-            addAggregate(AggregateType.AVERAGE, this.def, fields);
+            addAggregate(this, AggregateType.AVERAGE, fields);
+        }
+        // @ts-ignore
+        return this;
+    }
+    harmonicMean(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty harmonic mean function called');
+        }
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'harmonicMean',
+                args: fields,
+            });
+        }
+        else {
+            addAggregate(this, AggregateType.HMEAN, fields);
         }
         // @ts-ignore
         return this;
@@ -248,7 +278,7 @@ export class QueryBranch {
             });
         }
         else {
-            addAggregate(AggregateType.MAX, this.def, fields);
+            addAggregate(this, AggregateType.MAX, fields);
         }
         // @ts-ignore
         return this;
@@ -264,7 +294,7 @@ export class QueryBranch {
             });
         }
         else {
-            addAggregate(AggregateType.MIN, this.def, fields);
+            addAggregate(this, AggregateType.MIN, fields);
         }
         // @ts-ignore
         return this;
@@ -283,7 +313,7 @@ export class QueryBranch {
                 this.def.filter.size += f.filterBranch.size;
             }
             else {
-                const f = convertFilter(this.def, field, operator, value, opts);
+                const f = convertFilter(this, field, operator, value, opts);
                 if (f) {
                     filterOr(this.db, this.def, f, this.def.filter);
                 }
@@ -316,49 +346,12 @@ export class QueryBranch {
             this.queryCommands.push({ method: 'include', args: fields });
         }
         else {
-            for (const f of fields) {
-                if (typeof f === 'string') {
-                    includeField(this.def, f);
-                }
-                else if (typeof f === 'function') {
-                    f((field) => {
-                        if (field[0] == '$') {
-                            // @ts-ignore
-                            const prop = this.def.target?.propDef?.edges[field];
-                            if (prop &&
-                                (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
-                                const refDef = createOrGetEdgeRefQueryDef(this.db, this.def, prop);
-                                // @ts-ignore
-                                return new QueryBranch(this.db, refDef);
-                            }
-                            throw new Error(`No edge reference or edge references field named "${field}"`);
-                        }
-                        else {
-                            const prop = field[0] == '$'
-                                ? // @ts-ignore
-                                    this.def.target?.propDef?.edges[field]
-                                : this.def.props[field];
-                            if (prop &&
-                                (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
-                                const refDef = createOrGetRefQueryDef(this.db, this.def, prop);
-                                // @ts-ignore
-                                return new QueryBranch(this.db, refDef);
-                            }
-                            throw new Error(`No reference or references field named "${field}"`);
-                        }
-                    });
-                }
-                else if (Array.isArray(f)) {
-                    if (f.length === 0) {
-                        includeFields(this.def, ['id']);
-                    }
-                    else {
-                        includeFields(this.def, f);
-                    }
-                }
-                else if (f !== undefined) {
-                    throw new Error('Invalid include statement: expected props, refs and edges (string or array) or function');
-                }
+            include(this, fields);
+            const includeHook = this.def.schema.hooks?.include;
+            if (includeHook) {
+                this.def.schema.hooks.include = null;
+                includeHook(this, this.def.include.stringFields);
+                this.def.schema.hooks.include = includeHook;
             }
         }
         // @ts-ignore
@@ -367,14 +360,14 @@ export class QueryBranch {
 }
 export class BasedDbReferenceQuery extends QueryBranch {
 }
-const resToJSON = (res) => res.toJSON();
+const resToJSON = (res, replacer, space) => res.toJSON(replacer, space);
 const resToObject = (res) => res.toObject();
 class GetPromise extends Promise {
     toObject() {
         return this.then(resToObject);
     }
-    toJSON() {
-        return this.then(resToJSON);
+    toJSON(replacer, space) {
+        return this.then((res) => resToJSON(res, replacer, space));
     }
     inspect(depth, raw) {
         return this.then((res) => new GetPromise((resolve) => resolve(res.inspect(depth, raw))));
@@ -383,6 +376,7 @@ class GetPromise extends Promise {
 export class BasedDbQuery extends QueryBranch {
     skipValidation = false;
     target;
+    readSchema;
     constructor(db, type, rawTarget, skipValidation) {
         const target = {
             type,
@@ -419,6 +413,9 @@ export class BasedDbQuery extends QueryBranch {
             if (!this.db.schema) {
                 await this.db.once('schema');
             }
+            if ('id' in this.target) {
+                this.target.id = await this.target.id;
+            }
             buf = registerQuery(this);
         }
         catch (err) {
@@ -456,7 +453,7 @@ export class BasedDbQuery extends QueryBranch {
             reject(res);
         }
         else {
-            resolve(new BasedQueryResponse(this.id, this.def, res, performance.now() - d));
+            resolve(new BasedQueryResponse(this.def, res, performance.now() - d));
         }
     };
     // if !id not initialized yet
@@ -514,7 +511,7 @@ export class BasedDbQuery extends QueryBranch {
         const buf = registerQuery(this);
         const d = performance.now();
         const res = native.getQueryBuf(buf, dbCtxExternal);
-        return new BasedQueryResponse(this.id, this.def, new Uint8Array(res), performance.now() - d);
+        return new BasedQueryResponse(this.def, new Uint8Array(res), performance.now() - d);
     }
 }
 //# sourceMappingURL=BasedDbQuery.js.map

package/dist/src/client/query/{BasedIterable.d.ts → BasedQueryResponse.d.ts}

@@ -1,15 +1,16 @@
 import { inspect } from 'node:util';
 import { QueryDef } from './types.js';
-import { Item } from './query.js';
 import { size, time, inspectData } from './display.js';
+import { Item } from '@based/protocol/db-read';
 export { time, size, inspectData };
 export declare class BasedQueryResponse {
     result: Uint8Array;
     def: QueryDef;
     execTime: number;
     end: number;
-    id: number;
-    constructor(id: number, def: QueryDef, result: Uint8Array, execTime: number, 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;
@@ -22,6 +23,6 @@ export declare class BasedQueryResponse {
     get checksum(): number;
     get length(): number;
     toObject(): any;
-    toJSON(): string;
+    toJSON(replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
     toString(): string;
 }

package/dist/src/client/query/{BasedIterable.js → BasedQueryResponse.js}

@@ -1,8 +1,9 @@
 import { inspect } from 'node:util';
 import picocolors from 'picocolors';
-import { debug, resultToObject, readAllFields } from './query.js';
+import { debug } from './query.js';
 import { size, time, inspectData, defHasId, displayTarget } from './display.js';
-import { readFloatLE, readUint32 } from '@saulx/utils';
+import { readFloatLE, readUint32 } from '@based/utils';
+import { resultToObject, readProps, readId, } from '@based/protocol/db-read';
 export { time, size, inspectData };
 const BITS_FOR_BYTE_LEN = 21;
 const FACTOR = 2 ** BITS_FOR_BYTE_LEN;
@@ -12,14 +13,18 @@ export class BasedQueryResponse {
     def;
     execTime;
     end;
-    id;
-    constructor(id, def, result, execTime, end = result.length) {
-        this.id = id;
+    constructor(def, result, execTime, end = result.length) {
         this.def = def;
         this.result = result;
         this.execTime = execTime;
         this.end = end;
     }
+    get id() {
+        return readId(this.def.readSchema, this.result);
+    }
+    get queryId() {
+        return this.def.queryId;
+    }
     get version() {
         return (this.checksum >>> 0) * FACTOR + (this.result.byteLength & MASK_B);
     }
@@ -72,7 +77,7 @@ export class BasedQueryResponse {
                 item.$searchScore = readFloatLE(result, i);
                 i += 4;
             }
-            const l = readAllFields(this.def, result, i, result.byteLength - 4, item, id);
+            const l = readProps(this.def.readSchema, result, i, result.byteLength - 4, item);
             i += l;
             yield item;
         }
@@ -110,14 +115,14 @@ export class BasedQueryResponse {
         return l;
     }
     toObject() {
-        return resultToObject(this.def, this.result, this.end - 4, 0);
+        return resultToObject(this.def.readSchema, this.result, this.end - 4, 0);
     }
-    toJSON() {
+    toJSON(replacer, space) {
         // TODO: optimize
-        return JSON.stringify(this.toObject());
+        return JSON.stringify(this.toObject(), replacer, space);
     }
     toString() {
         return this.toJSON();
     }
 }
-//# sourceMappingURL=BasedIterable.js.map
+//# sourceMappingURL=BasedQueryResponse.js.map

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

@@ -1,6 +1,8 @@
 import { QueryDef, QueryDefAggregation } from '../types.js';
-import { AggregateType } from './types.js';
+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) => void;
-export declare const addAggregate: (type: AggregateType, def: QueryDef, fields: (string | string[])[]) => void;
+export declare const groupBy: (def: QueryDef, 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

@@ -1,9 +1,10 @@
-import { writeUint16 } from '@saulx/utils';
+import { writeUint16, writeInt16, writeUint32 } from '@based/utils';
 import { QueryDefType } from '../types.js';
-import { AggregateType } from './types.js';
+import { setMode } from './types.js';
 import { UINT32 } from '@based/schema/def';
-import { aggregationFieldDoesNotExist } from '../validation.js';
-import { aggregateTypeMap } from '../aggregates/types.js';
+import { aggregationFieldDoesNotExist, validateStepRange, } from '../validation.js';
+import { aggregateTypeMap, Interval, } from '../aggregates/types.js';
+import { AggregateType } from '@based/protocol/db-read';
 export const aggregateToBuffer = (aggregates) => {
     const aggBuffer = new Uint8Array(aggregates.size);
     let i = 0;
@@ -18,6 +19,12 @@ export const aggregateToBuffer = (aggregates) => {
         i += 2;
         writeUint16(aggBuffer, aggregates.groupBy.len, i);
         i += 2;
+        aggBuffer[i] = aggregates.groupBy.stepType || 0;
+        i += 1;
+        writeUint32(aggBuffer, aggregates.groupBy.stepRange || 0, i);
+        i += 4;
+        writeInt16(aggBuffer, aggregates.groupBy.tz || 0, i);
+        i += 2;
     }
     else {
         aggBuffer[i] = 0 /* GroupBy.NONE */;
@@ -27,6 +34,8 @@ export const aggregateToBuffer = (aggregates) => {
     i += 2;
     writeUint16(aggBuffer, aggregates.totalAccumulatorSize, i);
     i += 2;
+    aggBuffer[i] = setMode[aggregates?.option?.mode] || 0;
+    i += 1;
     for (const [prop, aggregatesArray] of aggregates.aggregates.entries()) {
         aggBuffer[i] = prop;
         i += 1;
@@ -54,71 +63,100 @@ export const aggregateToBuffer = (aggregates) => {
 const ensureAggregate = (def) => {
     if (!def.aggregate) {
         def.aggregate = {
-            size: 5,
+            size: 7,
             aggregates: new Map(),
             totalResultsSize: 0,
             totalAccumulatorSize: 0,
         };
     }
 };
-export const groupBy = (def, field) => {
+export const groupBy = (def, field, StepInput) => {
     const fieldDef = def.schema.props[field];
     if (!fieldDef) {
         aggregationFieldDoesNotExist(def, field);
     }
     ensureAggregate(def);
     if (!def.aggregate.groupBy) {
-        def.aggregate.size += 6;
+        def.aggregate.size += 12;
     }
     def.aggregate.groupBy = fieldDef;
+    def.aggregate.groupBy.stepRange = undefined;
+    def.aggregate.groupBy.stepType = undefined;
+    def.aggregate.groupBy.tz = undefined;
+    def.aggregate.groupBy.display = undefined;
+    if (typeof StepInput === 'object' &&
+        StepInput !== null &&
+        'step' in StepInput) {
+        if (typeof StepInput.timeZone == 'string') {
+            def.aggregate.groupBy.tz = getTimeZoneOffsetInMinutes(StepInput.timeZone);
+        }
+        if (typeof StepInput?.step == 'string') {
+            const intervalEnumKey = StepInput.step;
+            def.aggregate.groupBy.stepType = Interval[intervalEnumKey];
+        }
+        else {
+            validateStepRange(def, StepInput?.step);
+            def.aggregate.groupBy.stepRange = StepInput.step;
+        }
+    }
+    else if (typeof StepInput == 'number') {
+        validateStepRange(def, StepInput);
+        def.aggregate.groupBy.stepRange = StepInput;
+    }
+    else {
+        const intervalEnumKey = StepInput;
+        def.aggregate.groupBy.stepType = Interval[intervalEnumKey];
+    }
+    if (typeof StepInput === 'object' && StepInput?.display) {
+        def.aggregate.groupBy.display = StepInput?.display;
+    }
 };
-export const addAggregate = (type, def, fields) => {
+export const addAggregate = (query, type, fields, option) => {
+    const def = query.def;
+    def.schema.hooks?.aggregate?.(def, new Set(fields));
     ensureAggregate(def);
+    if (option?.mode)
+        def.aggregate.option = option;
     const aggregates = def.aggregate.aggregates;
     for (const field of fields) {
-        if (Array.isArray(field)) {
-            addAggregate(type, def, field);
+        const fieldDef = type === AggregateType.COUNT
+            ? {
+                prop: 255,
+                path: [field],
+                __isPropDef: true,
+                len: 4,
+                start: 0,
+                typeIndex: UINT32,
+                separate: true,
+                validation: () => true,
+                default: 0,
+            }
+            : def.schema.props[field];
+        if (!fieldDef) {
+            aggregationFieldDoesNotExist(def, field);
+        }
+        if (!aggregates.get(fieldDef.prop)) {
+            aggregates.set(fieldDef.prop, []);
+            def.aggregate.size += 3;
+        }
+        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;
         }
         else {
-            const fieldDef = type === AggregateType.COUNT
-                ? {
-                    prop: 255,
-                    path: [field],
-                    __isPropDef: true,
-                    len: 4,
-                    start: 0,
-                    typeIndex: UINT32,
-                    separate: true,
-                    validation: () => true,
-                    default: 0,
-                }
-                : def.schema.props[field];
-            if (!fieldDef) {
-                aggregationFieldDoesNotExist(def, field);
-            }
-            if (!aggregates.get(fieldDef.prop)) {
-                aggregates.set(fieldDef.prop, []);
-                def.aggregate.size += 3;
-            }
-            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;
-            }
-            else {
-                def.aggregate.totalResultsSize += 8;
-                def.aggregate.totalAccumulatorSize += 8;
-            }
-            // needs to add an extra field WRITE TO
-            def.aggregate.size += 8;
+            def.aggregate.totalResultsSize += 8;
+            def.aggregate.totalAccumulatorSize += 8;
         }
+        // needs to add an extra field WRITE TO
+        def.aggregate.size += 8;
     }
 };
 export const isRootCountOnly = (def, filterSize) => {
@@ -149,4 +187,23 @@ export const isRootCountOnly = (def, filterSize) => {
     }
     return true;
 };
+function getTimeZoneOffsetInMinutes(timeZone, date = new Date()) {
+    const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric',
+        hour12: false,
+    });
+    const parts = formatter.formatToParts(date);
+    const getPart = (partName) => parseInt(parts.find((p) => p.type === partName)?.value || '0', 10);
+    const targetTimeAsUTC = Date.UTC(getPart('year'), getPart('month') - 1, getPart('day'), getPart('hour'), getPart('minute'), getPart('second'));
+    const originalUTCTime = date.getTime();
+    const offsetInMilliseconds = targetTimeAsUTC - originalUTCTime;
+    const offsetInMinutes = offsetInMilliseconds / (1000 * 60);
+    return Math.round(offsetInMinutes);
+}
 //# sourceMappingURL=aggregation.js.map