@based/db 0.0.71 → 0.1.0

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

@@ -0,0 +1,126 @@
+// import type { IncludeOpts, QueryDef, Target } from '@based/db'
+import { inverseLangMap, langCodesMap } from '@based/schema';
+import { COLVEC, ENUM, TEXT, VECTOR, } from '@based/schema/def';
+import { ReaderMeta, ReaderSchemaEnum, } from '@based/protocol/db-read';
+const createReaderPropDef = (p, locales, opts) => {
+    const readerPropDef = {
+        path: p.__isEdge ? p.path.slice(1) : p.path,
+        typeIndex: p.typeIndex,
+        readBy: 0,
+    };
+    if (opts?.meta) {
+        readerPropDef.meta =
+            opts?.meta === 'only' ? ReaderMeta.only : ReaderMeta.combined;
+    }
+    if (p.typeIndex === ENUM) {
+        readerPropDef.enum = p.enum;
+    }
+    if (p.typeIndex === VECTOR || p.typeIndex === COLVEC) {
+        readerPropDef.vectorBaseType = p.vectorBaseType;
+        readerPropDef.len = p.len;
+    }
+    if (p.typeIndex === TEXT) {
+        if (opts.codes.has(0)) {
+            readerPropDef.locales = locales;
+        }
+        else {
+            if (opts.codes.size === 1 && opts.codes.has(opts.localeFromDef)) {
+                // dont add locales - interpets it as a normal prop
+            }
+            else {
+                readerPropDef.locales = {};
+                for (const code of opts.codes) {
+                    readerPropDef.locales[code] = inverseLangMap.get(code);
+                }
+            }
+        }
+    }
+    return readerPropDef;
+};
+export const convertToReaderSchema = (q, locales) => {
+    if (!locales) {
+        locales = {};
+        for (const lang in q.schema.locales) {
+            locales[langCodesMap.get(lang)] = lang;
+        }
+    }
+    const t = q.type;
+    const isRoot = t === 4; // QueryDefType.Root (cant import type enum ofc)
+    const isSingle = isRoot && ('id' in q.target || 'alias' in q.target);
+    const isEdge = t === 1; // QueryDefType.Edge (cant import type enum ofc)
+    const readerSchema = {
+        readId: 0,
+        props: {},
+        main: { len: 0, props: {} },
+        refs: {},
+        type: isEdge
+            ? ReaderSchemaEnum.edge
+            : isSingle
+                ? q.target.type === '_root'
+                    ? ReaderSchemaEnum.rootProps
+                    : ReaderSchemaEnum.single
+                : ReaderSchemaEnum.default,
+    };
+    if (q.aggregate) {
+        readerSchema.aggregate = {
+            aggregates: [],
+            totalResultsSize: q.aggregate.totalResultsSize,
+        };
+        const a = readerSchema.aggregate;
+        for (const aggArray of q.aggregate.aggregates.values()) {
+            for (const agg of aggArray) {
+                a.aggregates.push({
+                    path: agg.propDef.path,
+                    type: agg.type,
+                    resultPos: agg.resultPos,
+                });
+            }
+        }
+        if (q.aggregate.groupBy) {
+            a.groupBy = {
+                typeIndex: q.aggregate.groupBy.typeIndex,
+            };
+            if (q.aggregate.groupBy.stepRange) {
+                a.groupBy.stepRange = q.aggregate.groupBy.stepRange;
+            }
+            if (q.aggregate.groupBy.display) {
+                a.groupBy.display = q.aggregate.groupBy.display;
+            }
+            if (q.aggregate.groupBy.enum) {
+                a.groupBy.enum = q.aggregate.groupBy.enum;
+            }
+            if (q.aggregate.groupBy.stepType) {
+                a.groupBy.stepType = true;
+            }
+        }
+    }
+    else {
+        if (q.schema?.hooks?.read) {
+            readerSchema.hook = q.schema.hooks.read;
+        }
+        if (isRoot && q.search) {
+            readerSchema.search = true;
+        }
+        for (const [k, v] of q.include.props) {
+            readerSchema.props[k] = createReaderPropDef(v.def, locales, v.opts);
+        }
+        readerSchema.main.len = q.include.main.len;
+        for (const k in q.include.main.include) {
+            const [start, p, opts] = q.include.main.include[k];
+            readerSchema.main.props[start] = createReaderPropDef(p, locales, opts);
+        }
+        for (const [k, v] of q.references.entries()) {
+            const target = v.target;
+            const propDef = target.propDef;
+            readerSchema.refs[k] = {
+                schema: convertToReaderSchema(v, locales),
+                prop: createReaderPropDef(propDef, locales),
+            };
+        }
+        if (q.edges) {
+            readerSchema.edges = convertToReaderSchema(q.edges, locales);
+        }
+    }
+    return readerSchema;
+};
+//# sourceMappingURL=queryDefToReadSchema.js.map

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

@@ -1,15 +1,18 @@
 import native from '../../native.js';
-import { concatUint8Arr } from '@saulx/utils';
-import { defToBuffer } from './toByteCode/toBuffer.js';
+import { concatUint8Arr } from '@based/utils';
+import { defToBuffer } from './toByteCode/toByteCode.js';
 import { handleErrors } from './validation.js';
 import { createQueryDef } from './queryDef.js';
 import { QueryDefType } from './types.js';
 import { includeField } from './query.js';
+import { convertToReaderSchema } from './queryDefToReadSchema.js';
 export const registerQuery = (q) => {
     if (!q.id) {
         const commands = q.queryCommands;
         q.queryCommands = null;
-        const def = createQueryDef(q.db, QueryDefType.Root, q.target, q.skipValidation);
+        const def = createQueryDef(q.db, QueryDefType.Root, 
+        // @ts-ignore
+        q.target, q.skipValidation);
         def.schemaChecksum = q.db.schema?.hash || 0;
         q.def = def;
         // proposal:
@@ -18,14 +21,22 @@ export const registerQuery = (q) => {
         }
         // locale first...
         if (!q.def.include.stringFields.size && !q.def.references.size) {
-            includeField(q.def, '*');
+            includeField(q.def, { field: '*' });
         }
         q.queryCommands = commands;
         const b = defToBuffer(q.db, q.def);
         const buf = concatUint8Arr(b);
         let id = native.crc32(buf);
         q.id = id;
+        def.queryId = q.id;
         q.buffer = buf;
+        // console.log('--------------------------------------------------')
+        // console.dir(convertToReaderSchema(q.def), { depth: 100 })
+        // console.log(deSerializeSchema(serialize(convertToReaderSchema(q.def))))
+        // q.def.readSchema = deSerializeSchema(
+        //   serialize(convertToReaderSchema(q.def)),
+        // )
+        q.def.readSchema = convertToReaderSchema(q.def);
         handleErrors(q.def);
         return buf;
     }

package/dist/src/client/query/search/index.d.ts

@@ -1,8 +1,9 @@
 import { QueryDefSearch, QueryDef } from '../types.js';
 import { FilterOpts } from '../filter/types.js';
+import { QueryBranch } from '../BasedDbQuery.js';
 export type Search = string[] | {
     [field: string]: number;
 } | string;
 export declare const vectorSearch: (def: QueryDef, q: ArrayBufferView, field: string, opts: Omit<FilterOpts, "lowerCase">) => void;
-export declare const search: (def: QueryDef, q: string, s?: Search) => void;
+export declare const search: (queryBranch: QueryBranch<any>, q: string, s?: Search) => void;
 export declare const searchToBuffer: (search: QueryDefSearch) => Uint8Array<ArrayBuffer>;

package/dist/src/client/query/search/index.js

@@ -2,7 +2,7 @@ import { langCodesMap } from '@based/schema';
 import { STRING, TEXT, VECTOR } from '@based/schema/def';
 import { getVectorFn } from '../filter/types.js';
 import { searchDoesNotExist, searchIncorrecQueryValue, searchIncorrectType, } from '../validation.js';
-import { ENCODER, concatUint8Arr } from '@saulx/utils';
+import { ENCODER, concatUint8Arr } from '@based/utils';
 // vector
 export const vectorSearch = (def, q, field, opts) => {
     let prop = def.props[field];
@@ -23,7 +23,8 @@ export const vectorSearch = (def, q, field, opts) => {
         opts,
     };
 };
-export const search = (def, q, s) => {
+export const search = (queryBranch, q, s) => {
+    const def = queryBranch.def;
     const bufs = [];
     let nrBlocks = 0;
     let totalByteLength = 1;
@@ -110,6 +111,12 @@ export const search = (def, q, s) => {
             start: prop.start ?? 0, // also need lang ofc if you have start
         });
     }
+    const searchHook = def.schema.hooks?.search;
+    if (searchHook) {
+        def.schema.hooks.search = null;
+        searchHook(queryBranch, new Set(Object.keys(s)));
+        def.schema.hooks.search = searchHook;
+    }
 };
 export const searchToBuffer = (search) => {
     if (search.isVector) {

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

@@ -14,6 +14,9 @@ export const createSortBuffer = (sort) => {
 };
 // NO REF / REFERENCES SUPPORT
 export const sort = (def, field, order) => {
+    if (field === 'id' && order === 'asc') {
+        return;
+    }
     def.sort = validateSort(def, field, order);
 };
 //# sourceMappingURL=sort.js.map

package/dist/src/client/query/subscription/index.d.ts

@@ -1,5 +1,5 @@
 import { BasedDbQuery } from '../BasedDbQuery.js';
-import { BasedQueryResponse } from '../BasedIterable.js';
+import { BasedQueryResponse } from '../BasedQueryResponse.js';
 import { OnData, OnError, OnClose } from './types.js';
 export declare class SubStore {
     listeners: Map<OnData, OnError>;

package/dist/src/client/query/subscription/index.js

@@ -1,4 +1,4 @@
-import { BasedQueryResponse } from '../BasedIterable.js';
+import { BasedQueryResponse } from '../BasedQueryResponse.js';
 import { registerQuery } from '../registerQuery.js';
 export class SubStore {
     listeners;
@@ -9,7 +9,7 @@ export class SubStore {
     subscribe(q) {
         const onData = (res) => {
             if (!this.response) {
-                this.response = new BasedQueryResponse(q.id, q.def, res, 0);
+                this.response = new BasedQueryResponse(q.def, res, 0);
             }
             else {
                 this.response.result = res;

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

@@ -1,4 +1,4 @@
-import { BasedQueryResponse } from '../BasedIterable.js';
+import { BasedQueryResponse } from '../BasedQueryResponse.js';
 export type OnData = (res: BasedQueryResponse) => any;
 export type OnError = (err: Error) => any;
 export type OnClose = () => any;

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

@@ -1,4 +1,4 @@
 export declare const MAX_IDS_PER_QUERY = 1000000;
 export declare const DEF_RANGE_PROP_LIMIT = 1000;
-export declare const DEF_RANGE_REF_LIMIT = 10000;
+export declare const DEF_RANGE_REF_LIMIT = 1000;
 export declare const MIN_ID_VALUE = 1;

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

@@ -1,7 +1,7 @@
 // Query thresholds
 export const MAX_IDS_PER_QUERY = 1e6; // Max number of IDs that can be queried at once
 export const DEF_RANGE_PROP_LIMIT = 1e3;
-export const DEF_RANGE_REF_LIMIT = 1e4;
+export const DEF_RANGE_REF_LIMIT = 1e3;
 // Data validation thresholds
 export const MIN_ID_VALUE = 1; // Minimum allowed value for an ID (id array stared)
 //# sourceMappingURL=thresholds.js.map

package/dist/src/client/query/toByteCode/{toBuffer.js → toByteCode.js}

@@ -1,9 +1,9 @@
 import { createSortBuffer } from '../sort.js';
 import { QueryDefType, QueryType } from '../types.js';
-import { includeToBuffer } from '../include/toBuffer.js';
+import { includeToBuffer } from '../include/toByteCode.js';
 import { filterToBuffer } from '../query.js';
 import { searchToBuffer } from '../search/index.js';
-import { ENCODER, writeUint64 } from '@saulx/utils';
+import { ENCODER, writeUint64 } from '@based/utils';
 import { aggregateToBuffer, isRootCountOnly, } from '../aggregates/aggregation.js';
 import { defaultQuery } from './default.js';
 const byteSize = (arr) => {
@@ -42,7 +42,7 @@ export function defToBuffer(db, def) {
         if (def.type === QueryDefType.References) {
             const buf = new Uint8Array(13 + filterSize + aggregateSize);
             const sz = 10 + filterSize + aggregateSize;
-            buf[0] = 251 /* includeOp.REFERENCES_AGGREGATION */;
+            buf[0] = 2 /* includeOp.REFERENCES_AGGREGATION */;
             buf[1] = sz;
             buf[2] = sz >>> 8;
             buf[3] = filterSize;
@@ -122,7 +122,7 @@ export function defToBuffer(db, def) {
             }
             result.push(buf);
         }
-        else if (def.target.id) {
+        else if (typeof def.target.id === 'number') {
             const buf = new Uint8Array(9 + filterSize);
             buf[0] = QueryType.id;
             buf[1] = def.schema.idUint8[0];
@@ -203,7 +203,7 @@ export function defToBuffer(db, def) {
         const modsSize = filterSize + sortSize;
         const meta = new Uint8Array(modsSize + 10 + 8);
         const sz = size + 7 + modsSize + 8;
-        meta[0] = 254 /* includeOp.REFERENCES */;
+        meta[0] = 4 /* includeOp.REFERENCES */;
         meta[1] = sz;
         meta[2] = sz >>> 8;
         meta[3] = filterSize;
@@ -232,7 +232,7 @@ export function defToBuffer(db, def) {
     else if (def.type === QueryDefType.Reference) {
         const meta = new Uint8Array(6);
         const sz = size + 3;
-        meta[0] = 255 /* includeOp.REFERENCE */;
+        meta[0] = 5 /* includeOp.REFERENCE */;
         meta[1] = sz;
         meta[2] = sz >>> 8;
         meta[3] = def.schema.idUint8[0];
@@ -243,7 +243,7 @@ export function defToBuffer(db, def) {
     result.push(...include);
     if (edges) {
         const metaEdgeBuffer = new Uint8Array(3);
-        metaEdgeBuffer[0] = 252 /* includeOp.EDGE */;
+        metaEdgeBuffer[0] = 3 /* includeOp.EDGE */;
         metaEdgeBuffer[1] = edgesSize;
         metaEdgeBuffer[2] = edgesSize >>> 8;
         result.push(metaEdgeBuffer, ...edges);
@@ -255,4 +255,4 @@ export function defToBuffer(db, def) {
     }
     return result;
 }
-//# sourceMappingURL=toBuffer.js.map
+//# sourceMappingURL=toByteCode.js.map

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

@@ -2,9 +2,24 @@ import { LangCode, LangName } from '@based/schema';
 import { PropDef, PropDefEdge, SchemaTypeDef } from '@based/schema/def';
 import { FilterOpts } from './filter/types.js';
 import { QueryError } from './validation.js';
-import { AggregateType } from './aggregates/types.js';
+import { Interval, aggFnOptions } from './aggregates/types.js';
+import { AggregateType, ReaderSchema } from '@based/protocol/db-read';
+export type IncludeOpts = {
+    end?: {
+        [langCode: string]: number;
+    } | number;
+    bytes?: boolean;
+    meta?: 'only' | true | false;
+    codes?: Set<LangCode>;
+    fallBacks?: LangCode[];
+    localeFromDef?: LangCode;
+};
+export type IncludeField = {
+    field: string;
+    opts?: IncludeOpts;
+};
 export type MainIncludes = {
-    [start: string]: [number, PropDef];
+    [start: string]: [number, PropDef, IncludeOpts];
 };
 export type IncludeTreeArr = (string | PropDef | IncludeTreeArr)[];
 export declare enum QueryType {
@@ -26,7 +41,7 @@ export type EdgeTarget = {
 };
 export type Target = {
     type: string;
-    id?: number | void;
+    id?: number | void | Promise<number>;
     ids?: Uint32Array | void;
     propDef?: PropDef | PropDefEdge;
     alias?: QueryByAliasObj;
@@ -85,13 +100,21 @@ export type Aggregation = {
 };
 export type QueryDefAggregation = {
     size: number;
-    groupBy?: PropDef;
+    groupBy?: aggPropDef;
     aggregates: Map<number, Aggregation[]>;
+    option?: aggFnOptions;
     totalResultsSize: number;
     totalAccumulatorSize: number;
 };
+export interface aggPropDef extends PropDef {
+    stepType?: Interval;
+    stepRange?: number;
+    tz?: number;
+    display?: Intl.DateTimeFormat;
+}
 export type LangFallback = LangName | false;
 export type QueryDefShared = {
+    queryId?: number;
     schemaChecksum?: number;
     errors: QueryError[];
     lang: {
@@ -108,31 +131,25 @@ export type QueryDefShared = {
         limit: number;
     };
     include: {
-        langTextFields: Map<number, // prop name
-        {
+        stringFields: Map<string, IncludeField>;
+        props: Map<number, {
             def: PropDef | PropDefEdge;
-            codes: Set<LangCode>;
-            fallBacks: LangCode[];
+            opts?: IncludeOpts;
         }>;
-        stringFields: Set<string>;
-        props: Map<number, PropDef | PropDefEdge>;
-        propsRead: {
-            [propName: number]: number;
-        };
         main: {
             include: MainIncludes;
             len: number;
         };
     };
     references: Map<number, QueryDef>;
-    edges?: QueryDef;
+    edges?: QueryDefEdges;
+    readSchema?: ReaderSchema;
 };
 export type QueryDefEdges = {
     type: QueryDefType.Edge;
     target: EdgeTarget;
     schema: null;
     props: PropDef['edges'];
-    reverseProps: PropDef['edges'];
 } & QueryDefShared;
 export type QueryDefRest = {
     type: QueryDefType.References | QueryDefType.Reference | QueryDefType.Root;
@@ -146,15 +163,13 @@ export { QueryDefType };
 export type QueryByAliasObj = {
     [key: string]: string | QueryByAliasObj;
 };
-export declare const isAlias: (id: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[]) => id is QueryByAliasObj;
-export declare const READ_ID = 255;
-export declare const READ_EDGE = 252;
-export declare const READ_REFERENCES = 253;
-export declare const READ_REFERENCE = 254;
-export declare const READ_AGGREGATION = 250;
+export declare const isAlias: (id: Promise<number> | QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number | Promise<number>)[]) => id is QueryByAliasObj;
 export declare const enum includeOp {
-    REFERENCES_AGGREGATION = 251,
-    EDGE = 252,
-    REFERENCES = 254,
-    REFERENCE = 255
+    DEFAULT = 1,
+    REFERENCES_AGGREGATION = 2,
+    EDGE = 3,
+    REFERENCES = 4,
+    REFERENCE = 5,
+    META = 6,// this can be a small buffer as well
+    PARTIAL = 7
 }

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

@@ -25,11 +25,7 @@ export const isAlias = (id) => {
     return (typeof id === 'object' &&
         id !== null &&
         !Array.isArray(id) &&
-        !ArrayBuffer.isView(id));
+        !ArrayBuffer.isView(id) &&
+        typeof id.then !== 'function');
 };
-export const READ_ID = 255;
-export const READ_EDGE = 252;
-export const READ_REFERENCES = 253;
-export const READ_REFERENCE = 254;
-export const READ_AGGREGATION = 250;
 //# sourceMappingURL=types.js.map

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

@@ -2,6 +2,7 @@ import { PropDef, PropDefEdge, SchemaTypeDef } from '@based/schema/def';
 import { DbClient } from '../index.js';
 import { Filter } from './query.js';
 import { QueryByAliasObj, QueryDef } from './types.js';
+import { StepInput } from './aggregates/types.js';
 export type QueryError = {
     code: number;
     payload: any;
@@ -32,6 +33,8 @@ export declare const ERR_SEARCH_INCORRECT_VALUE = 23;
 export declare const ERR_SORT_LANG = 24;
 export declare const ERR_AGG_ENOENT = 25;
 export declare const ERR_AGG_TYPE = 26;
+export declare const ERR_AGG_INVALID_STEP_TYPE = 27;
+export declare const ERR_AGG_INVALID_STEP_RANGE = 28;
 declare const messages: {
     1: (p: any) => string;
     2: (p: any) => string;
@@ -59,6 +62,8 @@ declare const messages: {
     24: (p: any) => string;
     25: (p: any) => string;
     26: (p: any) => string;
+    27: (p: any) => string;
+    28: (p: any) => string;
 };
 export type ErrorCode = keyof typeof messages;
 export declare const searchIncorrecQueryValue: (def: QueryDef, payload: any) => void;
@@ -88,4 +93,5 @@ export declare const ERROR_VECTOR: PropDef;
 export declare const EMPTY_SCHEMA_DEF: SchemaTypeDef;
 export declare const aggregationFieldDoesNotExist: (def: QueryDef, field: string) => void;
 export declare const aggregationFieldNotNumber: (def: QueryDef, field: string) => void;
+export declare const validateStepRange: (def: QueryDef, step: StepInput) => void;
 export {};

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

@@ -1,6 +1,6 @@
 import picocolors from 'picocolors';
-import { ALIAS, BINARY, BOOLEAN, REFERENCE, REFERENCES, REVERSE_TYPE_INDEX_MAP, STRING, TEXT, TIMESTAMP, VECTOR, propIsNumerical, createEmptyDef, DEFAULT_MAP, } from '@based/schema/def';
-import { EQUAL, EXISTS, HAS, isNumerical, LIKE, operatorReverseMap, VECTOR_FNS, } from './filter/types.js';
+import { ALIAS, BINARY, BOOLEAN, REFERENCE, REFERENCES, REVERSE_TYPE_INDEX_MAP, STRING, TEXT, TIMESTAMP, VECTOR, propIsNumerical, createEmptyDef, DEFAULT_MAP, ID_FIELD_DEF, } from '@based/schema/def';
+import { EQUAL, EXISTS, INCLUDES, isNumerical, LIKE, operatorReverseMap, VECTOR_FNS, } from './filter/types.js';
 import { MAX_IDS_PER_QUERY } from './thresholds.js';
 import { displayTarget, safeStringify } from './display.js';
 import { isValidId, isValidString, langCodesMap, MAX_ID, } from '@based/schema';
@@ -30,6 +30,8 @@ export const ERR_SEARCH_INCORRECT_VALUE = 23;
 export const ERR_SORT_LANG = 24;
 export const ERR_AGG_ENOENT = 25;
 export const ERR_AGG_TYPE = 26;
+export const ERR_AGG_INVALID_STEP_TYPE = 27;
+export const ERR_AGG_INVALID_STEP_RANGE = 28;
 const messages = {
     [ERR_TARGET_INVAL_TYPE]: (p) => `Type "${p}" does not exist`,
     [ERR_TARGET_INVAL_ALIAS]: (p) => {
@@ -54,8 +56,8 @@ const messages = {
     [ERR_SORT_WRONG_TARGET]: (p) => `Sort: incorrect qeury target "${displayTarget(p)}"`,
     [ERR_SORT_ORDER]: (p) => `Sort: incorrect order option "${safeStringify(p.order)}" passed to sort "${p.field}"`,
     [ERR_SORT_TYPE]: (p) => `Sort: cannot sort on type "${REVERSE_TYPE_INDEX_MAP[p.typeIndex]}" on field "${p.path.join('.')}"`,
-    [ERR_RANGE_INVALID_OFFSET]: (p) => `Range: incorrect offset "${safeStringify(p)}"`,
-    [ERR_RANGE_INVALID_LIMIT]: (p) => `Range: incorrect limit "${safeStringify(p)}"`,
+    [ERR_RANGE_INVALID_OFFSET]: (p) => `Range: incorrect start "${safeStringify(p)}"`,
+    [ERR_RANGE_INVALID_LIMIT]: (p) => `Range: incorrect end "${safeStringify(p)}"`,
     [ERR_INVALID_LANG]: (p) => `Invalid locale "${p}"`,
     [ERR_SEARCH_ENOENT]: (p) => `Search: field does not exist "${p}"`,
     [ERR_SEARCH_TYPE]: (p) => `Search: incorrect type "${p.path.join('.')}"`,
@@ -63,6 +65,8 @@ const messages = {
     [ERR_SORT_LANG]: (p) => `Sort: invalid lang`,
     [ERR_AGG_ENOENT]: (p) => `Field \"${p}\" in the aggregate function is invalid or unreacheable.`,
     [ERR_AGG_TYPE]: (p) => `Aggregate: incorrect type "${p.path.join('.')}"`,
+    [ERR_AGG_INVALID_STEP_TYPE]: (p) => `Aggregate: Incorrect step type "${p}"`,
+    [ERR_AGG_INVALID_STEP_RANGE]: (p) => `Aggregate: Incorrect step range "${p}". Step ranges are limited to uint32 max value in seconds => group by ~136 years.`,
 };
 export const searchIncorrecQueryValue = (def, payload) => {
     def.errors.push({ code: ERR_SEARCH_INCORRECT_VALUE, payload });
@@ -87,6 +91,18 @@ export const validateRange = (def, offset, limit) => {
         def.errors.push({ code: ERR_RANGE_INVALID_LIMIT, payload: limit });
         r = true;
     }
+    if (limit === 0) {
+        def.errors.push({ code: ERR_RANGE_INVALID_OFFSET, payload: offset });
+        r = true;
+    }
+    if (limit % 1 !== 0) {
+        def.errors.push({ code: ERR_RANGE_INVALID_LIMIT, payload: limit });
+        r = true;
+    }
+    if (offset % 1 !== 0) {
+        def.errors.push({ code: ERR_RANGE_INVALID_OFFSET, payload: offset });
+        r = true;
+    }
     return r;
 };
 export const validateVal = (def, f, validate) => {
@@ -166,7 +182,7 @@ export const validateFilter = (def, prop, f) => {
         }
     }
     else if (t === VECTOR) {
-        if (isNumerical(op) || op === HAS) {
+        if (isNumerical(op) || op === INCLUDES) {
             def.errors.push({ code: ERR_FILTER_OP_FIELD, payload: f });
             return true;
         }
@@ -266,7 +282,7 @@ export const validateLocale = (def, lang) => {
     }
 };
 export const validateSort = (def, field, orderInput) => {
-    let propDef = def.props[field];
+    let propDef = field === 'id' ? ID_FIELD_DEF : def.props[field];
     if (orderInput && orderInput !== 'asc' && orderInput !== 'desc') {
         def.errors.push({
             code: ERR_SORT_ORDER,
@@ -274,7 +290,6 @@ export const validateSort = (def, field, orderInput) => {
         });
     }
     const order = orderInput === 'asc' || orderInput === undefined ? 0 : 1;
-    // IF ! FIX
     let lang = 0;
     if (!propDef) {
         let isText = false;
@@ -483,4 +498,13 @@ export const aggregationFieldNotNumber = (def, field) => {
     });
     handleErrors(def);
 };
+export const validateStepRange = (def, step) => {
+    if (typeof step !== 'number' || step >= 4294967296) {
+        def.errors.push({
+            code: ERR_AGG_INVALID_STEP_RANGE,
+            payload: step,
+        });
+        handleErrors(def);
+    }
+};
 //# sourceMappingURL=validation.js.map

package/dist/src/client/setLocalClientSchema.js

@@ -1,5 +1,6 @@
-import { schemaToSelvaBuffer, updateTypeDefs } from '@based/schema/def';
-import { execCtxQueue } from './flushModify.js';
+import { updateTypeDefs } from '@based/schema/def';
+import { cancel } from './modify/drain.js';
+import { Ctx } from './modify/Ctx.js';
 export const setLocalClientSchema = (client, schema) => {
     if (client.schema && client.schema.hash === schema.hash) {
         return client.schema;
@@ -8,16 +9,11 @@ export const setLocalClientSchema = (client, schema) => {
     client.schema = schema;
     client.schemaTypesParsed = schemaTypesParsed;
     client.schemaTypesParsedById = schemaTypesParsedById;
-    // Adds bidrectional refs on defs
-    schemaToSelvaBuffer(client.schemaTypesParsed);
-    // this has to happen before the listeners
-    if (client.modifyCtx.len > 8) {
+    if (client.modifyCtx.index > 8) {
         console.info('Modify cancelled - schema updated');
     }
-    // cancel modify queue
-    const resCtx = client.modifyCtx.ctx;
-    client.modifyCtx.reset();
-    execCtxQueue(resCtx, true);
+    cancel(client.modifyCtx, Error('Schema changed - in-flight modify cancelled'));
+    client.modifyCtx = new Ctx(schema.hash, client.modifyCtx.array);
     // resubscribe
     for (const [q, store] of client.subs) {
         store.resubscribe(q);

package/dist/src/client/string.d.ts

@@ -1,8 +1,4 @@
-import { LangCode } from '@based/schema';
-export declare const COMPRESSED = 1;
-export declare const NOT_COMPRESSED = 0;
-export declare const write: (buf: Uint8Array, value: string, offset: number, noCompression: boolean, lang?: LangCode) => number;
+import type { LangCode } from '@based/schema';
+import { Ctx } from './modify/Ctx.js';
+export declare const write: (ctx: Ctx, value: string, offset: number, noCompression: boolean, lang?: LangCode) => number | null;
 export declare const compress: (str: string) => Uint8Array;
-export declare const decompress: (val: Uint8Array) => string;
-export declare const read: (val: Uint8Array, offset: number, len: number, stripCrc32: boolean) => string;
-export declare const readUtf8: (val: Uint8Array, offset: number, len: number) => string;