@based/db 0.0.21 → 0.0.23

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

@@ -1,7 +1,7 @@
 import { ModifyError, ModifyState } from '../ModifyRes.js';
 import { setCursor } from '../setCursor.js';
 import { DELETE, RANGE_ERR } from '../types.js';
-import { getEdgeSize, writeEdges } from './edge.js';
+import { writeEdges } from './edge.js';
 import { dbUpdateFromUpsert } from './references.js';
 function writeRef(id, ctx, schema, def, parentId, modifyOp, hasEdges, isTmpId) {
     if (ctx.len + 16 > ctx.max) {
@@ -29,36 +29,46 @@ function singleReferenceEdges(ref, ctx, schema, def, parentId, modifyOp) {
             if (id.error) {
                 return id.error;
             }
-            isTmpId = !id.resolved;
-            id = id.tmpId;
+            const resolvedId = id.getId();
+            if (resolvedId) {
+                id = resolvedId;
+            }
+            else {
+                isTmpId = !true;
+                id = id.tmpId;
+            }
         }
     }
+    // TODO SINGLE REF
     if (id > 0) {
-        const edgesLen = def.edgesTotalLen || getEdgeSize(def, ref);
-        if (edgesLen === 0) {
+        if (def.edgesSeperateCnt === 0 && def.edgeMainLen === 0) {
+            // edgeMainLen, edgesSeperateCnt
             return writeRef(id, ctx, schema, def, parentId, modifyOp, false, isTmpId);
         }
-        let err = writeRef(id, ctx, schema, def, parentId, modifyOp, true, isTmpId);
-        if (err) {
-            return err;
-        }
-        if (ctx.len + 4 + edgesLen > ctx.max) {
-            return RANGE_ERR;
-        }
-        let sizepos = ctx.len;
-        ctx.len += 4;
-        err = writeEdges(def, ref, ctx);
-        if (err) {
-            return err;
+        else {
+            let err = writeRef(id, ctx, schema, def, parentId, modifyOp, true, isTmpId);
+            if (err) {
+                return err;
+            }
+            // def.edgeMainLen
+            // const edgesLen = getEdgeSize(def, ref)
+            // edgeMainLen can be done better
+            // TODO REOMVE - SEEMS REDUNDANT
+            if (ctx.len + 4 > ctx.max) {
+                return RANGE_ERR;
+            }
+            let sizepos = ctx.len;
+            ctx.len += 4;
+            err = writeEdges(def, ref, ctx);
+            if (err) {
+                return err;
+            }
+            let size = ctx.len - sizepos;
+            ctx.buf[sizepos++] = size;
+            ctx.buf[sizepos++] = size >>>= 8;
+            ctx.buf[sizepos++] = size >>>= 8;
+            ctx.buf[sizepos] = size >>>= 8;
         }
-        let size = ctx.len - sizepos;
-        ctx.buf[sizepos++] = size;
-        ctx.buf[sizepos++] = size >>>= 8;
-        ctx.buf[sizepos++] = size >>>= 8;
-        ctx.buf[sizepos] = size >>>= 8;
-    }
-    else {
-        return new ModifyError(def, ref);
     }
 }
 export function writeReference(value, ctx, schema, def, res, modifyOp) {
@@ -76,7 +86,11 @@ export function writeReference(value, ctx, schema, def, res, modifyOp) {
         if (value.error) {
             return value.error;
         }
-        return writeRef(value.tmpId, ctx, schema, def, res.tmpId, modifyOp, false, !value.resolved);
+        const id = value.getId();
+        if (id) {
+            return writeRef(id, ctx, schema, def, res.tmpId, modifyOp, false, false);
+        }
+        return writeRef(value.tmpId, ctx, schema, def, res.tmpId, modifyOp, false, true);
     }
     else if (typeof value === 'object' && value !== null) {
         if (def.edges) {

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

@@ -136,16 +136,28 @@ function appendRefs(def, ctx, modifyOp, refs, op, remaining) {
                 if (ref.error) {
                     return ref.error;
                 }
-                id = ref.tmpId;
-                isTmpId = !ref.resolved;
+                const resolvedId = ref.getId();
+                if (resolvedId) {
+                    id = resolvedId;
+                }
+                else {
+                    id = ref.tmpId;
+                    isTmpId = true;
+                }
             }
             else if (ref.id instanceof ModifyState) {
                 if (ref.id.error) {
                     return ref.id.error;
                 }
-                id = ref.id.tmpId;
+                const resolvedId = ref.id.getId();
+                if (resolvedId) {
+                    id = resolvedId;
+                }
+                else {
+                    id = ref.id.tmpId;
+                    isTmpId = true;
+                }
                 index = ref.$index;
-                isTmpId = !ref.id.resolved;
             }
             else if (ref.id > 0) {
                 id = ref.id;
@@ -258,10 +270,10 @@ function putRefs(def, ctx, modifyOp, refs, op) {
             if (ref.error) {
                 return ref.error;
             }
-            if (!ref.resolved) {
+            ref = ref.getId();
+            if (!ref) {
                 break;
             }
-            ref = ref.tmpId;
             ctx.buf[ctx.len++] = ref;
             ctx.buf[ctx.len++] = ref >>>= 8;
             ctx.buf[ctx.len++] = ref >>>= 8;

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

@@ -1,3 +1,4 @@
+import { ENCODER } from '../../index.js';
 import { CREATE, UPDATE, RANGE_ERR, DELETE, } from './types.js';
 import { ModifyError } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
@@ -23,7 +24,7 @@ export function writeString(lang, value, ctx, def, t, parentId, modifyOp) {
     else {
         let size = isBuffer
             ? value.byteLength
-            : Buffer.byteLength(value, 'utf8') + 6;
+            : ENCODER.encode(value).byteLength + 6;
         if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 11 + size > ctx.max) {
             // +10 OR +11, teh original check was +20 but
             // there are 10 addtional bytes in this scope

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

@@ -2,6 +2,7 @@ import { LangName } from '@based/schema';
 import { ModifyError } from './ModifyRes.js';
 export declare const CREATE = 3;
 export declare const UPDATE = 6;
+export declare const UPDATE_PARTIAL = 5;
 export declare const DELETE = 11;
 export declare const DELETE_SORT_INDEX = 4;
 export declare const DELETE_NODE = 10;

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

@@ -1,5 +1,6 @@
 export const CREATE = 3;
 export const UPDATE = 6;
+export const UPDATE_PARTIAL = 5;
 export const DELETE = 11;
 export const DELETE_SORT_INDEX = 4;
 export const DELETE_NODE = 10;

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

@@ -1,5 +1,5 @@
 import { MICRO_BUFFER } from '@based/schema/def';
-import { startDrain, flushBuffer } from '../operations.js';
+import { startDrain, flushBuffer } from '../flushModify.js';
 import { setCursor } from './setCursor.js';
 import { modify } from './modify.js';
 import { ModifyState } from './ModifyRes.js';
@@ -71,9 +71,8 @@ export const update = (db, type, id, obj, opts) => {
             flushBuffer(db);
             return update(db, type, id, obj, opts);
         }
-        res.error = err;
-        // @ts-ignore
-        return res;
+        // res.error = err
+        throw err;
     }
     if (!db.isDraining) {
         startDrain(db);

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

@@ -15,6 +15,7 @@ export async function upsert(db, type, obj, opts) {
         }
     }
     if (!q) {
+        // fix with promise
         throw new Error('no alias found for upsert operation');
     }
     if (db.upserting.has(id)) {

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

@@ -26,7 +26,6 @@ export function writeVector(value, ctx, schema, t, parentId, modifyOp) {
     if (size === 0) {
         if (modifyOp === UPDATE) {
             if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 1 > ctx.max) {
-                // TODO ???
                 return RANGE_ERR;
             }
             setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);
@@ -35,7 +34,6 @@ export function writeVector(value, ctx, schema, t, parentId, modifyOp) {
     }
     else {
         if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 5 + size > ctx.max) {
-            // TODO ???
             return RANGE_ERR;
         }
         setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);

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

@@ -17,9 +17,10 @@ export declare class QueryBranch<T> {
     filterBatch(f: FilterAst): this;
     search(query: string, ...fields: Search[]): T;
     search(query: ArrayBufferView, field: string, opts?: Omit<FilterOpts, 'lowerCase'>): T;
+    count(): T;
     or(fn: FilterBranchFn): T;
     or(field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts): T;
-    range(offset: number, limit?: number): T;
+    range(start: number, end?: number): T;
     include(...fields: (string | BranchInclude | string[])[]): T;
 }
 export declare class BasedDbReferenceQuery extends QueryBranch<BasedDbReferenceQuery> {
@@ -35,10 +36,10 @@ export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     constructor(db: DbClient, type: string, id?: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[], skipValidation?: boolean);
     id: number;
     get(): GetPromise;
-    buffer: Buffer;
+    buffer: Uint8Array;
     register(): void;
     locale(locale: LangName): this;
     subscribe(onData: OnData, onError?: OnError): import("./subscription/types.js").OnClose;
     _getSync(dbCtxExternal: any): BasedQueryResponse;
-    toBuffer(): Buffer;
+    toBuffer(): Uint8Array;
 }

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

@@ -1,4 +1,4 @@
-import { createQueryDef, QueryDefType, filter, sort, defToBuffer, filterOr, isAlias, includeField, includeFields, } from './query.js';
+import { createQueryDef, QueryDefType, filter, sort, defToBuffer, filterOr, isAlias, includeField, includeFields, count, } from './query.js';
 import { BasedQueryResponse } from './BasedIterable.js';
 import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef, } from './include/utils.js';
 import { FilterBranch } from './filter/FilterBranch.js';
@@ -11,6 +11,7 @@ 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 { concatUint8Arr } from '../../utils.js';
 export class QueryBranch {
     db;
     def;
@@ -93,6 +94,11 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
+    count() {
+        count(this.def);
+        // @ts-ignore
+        return this;
+    }
     or(field, operator, value, opts) {
         if (typeof field === 'function') {
             const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.def.filter), this.def);
@@ -108,7 +114,9 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
-    range(offset, limit = DEF_RANGE_PROP_LIMIT) {
+    range(start, end = DEF_RANGE_PROP_LIMIT) {
+        const offset = start;
+        const limit = end - start;
         if (validateRange(this.def, offset, limit)) {
             this.def.range.offset = 0;
             this.def.range.limit = DEF_RANGE_PROP_LIMIT;
@@ -216,6 +224,7 @@ export class BasedDbQuery extends QueryBranch {
             return;
         }
         const d = performance.now();
+        await this.db.isModified();
         const res = await this.db.hooks.getQueryBuf(buf);
         if (res instanceof Error) {
             reject(res);
@@ -258,7 +267,7 @@ export class BasedDbQuery extends QueryBranch {
             includeField(this.def, '*');
         }
         const b = defToBuffer(this.db, this.def);
-        return Buffer.concat(b);
+        return concatUint8Arr(b);
     }
 }
 //# sourceMappingURL=BasedDbQuery.js.map

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

@@ -0,0 +1,3 @@
+import { QueryDef, AggFn } from './types.js';
+export declare const createAggFnBuffer: (aggregation: AggFn) => Uint8Array;
+export declare const count: (def: QueryDef) => void;

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

@@ -0,0 +1,9 @@
+export const createAggFnBuffer = (aggregation) => {
+    const buf = new Uint8Array(1);
+    buf[0] = aggregation;
+    return buf;
+};
+export const count = (def) => {
+    def.aggregation = 4 /* AggFn.COUNT */;
+};
+//# sourceMappingURL=aggregationFn.js.map

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

@@ -1,18 +1,14 @@
 import picocolors from 'picocolors';
 import { isPropDef, REVERSE_TYPE_INDEX_MAP } from '@based/schema/def';
 import { QueryDefType } from './types.js';
-import { concatUint8Arr } from '../bitWise.js';
+import { concatUint8Arr } from '../../utils.js';
 export const debugQueryDef = (q, returnIt) => {
     const loggableObject = { type: 'bla', schema: null };
     const f = (a) => {
         if (a === null) {
             return null;
         }
-        // if (a instanceof BasedNode) {
-        //   // will be changed
-        //   return 'basedNode'
-        // }
-        if (a instanceof Buffer) {
+        if (a instanceof Buffer) { // RFE is this necessary?
             return new Uint8Array(a);
         }
         if (a instanceof Uint8Array) {

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

@@ -1,5 +1,6 @@
 import picocolors from 'picocolors';
 import { BINARY, CARDINALITY, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, } from '@based/schema/def';
+import { ENCODER } from '../../utils.js';
 const decimals = (v) => ~~(v * 100) / 100;
 const sizeCalc = (size) => {
     if (size > 1e6) {
@@ -38,16 +39,18 @@ export const prettyPrintVal = (v, type) => {
     if (type === BINARY) {
         const nr = 12;
         const isLarger = v.length > nr;
+        // RFE Doesn't slice make a new alloc? subarray would be probably sufficient here.
         const x = [...v.slice(0, nr)].map((v) => {
             return `${v}`.padStart(3, '0') + ' ';
         });
         return (picocolors.blue(x.join('')) +
             (isLarger ? picocolors.dim('... ') : '') +
-            picocolors.italic(picocolors.dim(`${~~((Buffer.byteLength(v, 'utf8') / 1e3) * 100) / 100}kb`)));
+            picocolors.italic(picocolors.dim(`${~~((v.byteLength / 1e3) * 100) / 100}kb`)));
     }
     if (type === STRING || type === TEXT) {
         if (v.length > 50) {
-            const chars = picocolors.italic(picocolors.dim(`${~~((Buffer.byteLength(v, 'utf8') / 1e3) * 100) / 100}kb`));
+            const byteLength = ENCODER.encode(v).byteLength;
+            const chars = picocolors.italic(picocolors.dim(`${~~((byteLength / 1e3) * 100) / 100}kb`));
             v =
                 v.slice(0, 50).replace(/\n/g, '\\n ') +
                     picocolors.dim('...') +

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

@@ -1,4 +1,4 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { FilterCtx } from './types.js';
-export declare const writeFixed: (prop: PropDef | PropDefEdge, buf: Buffer, value: any, size: number, offset: number) => void;
-export declare const createFixedFilterBuffer: (prop: PropDef | PropDefEdge, size: number, ctx: FilterCtx, value: any, sort: boolean) => Buffer;
+export declare const writeFixed: (prop: PropDef | PropDefEdge, buf: Uint8Array, value: any, size: number, offset: number) => void;
+export declare const createFixedFilterBuffer: (prop: PropDef | PropDefEdge, size: number, ctx: FilterCtx, value: any, sort: boolean) => Uint8Array;

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

@@ -1,6 +1,7 @@
-import { BINARY, STRING, REFERENCES, propIsSigned, } from '@based/schema/def';
+import { BINARY, STRING, REFERENCES, } from '@based/schema/def';
 import { EQUAL, MODE_AND_FIXED, MODE_DEFAULT, MODE_OR_FIXED, } from './types.js';
 import { parseFilterValue } from './parseFilterValue.js';
+import { ENCODER } from '../../../utils.js';
 // -------------------------------------------
 // conditions normal
 // field, [size 2]
@@ -17,8 +18,8 @@ import { parseFilterValue } from './parseFilterValue.js';
 export const writeFixed = (prop, buf, value, size, offset) => {
     if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
         if (typeof value === 'string') {
-            const size = buf.write(value, offset + 1, 'utf8');
-            buf[offset] = size;
+            const { written } = ENCODER.encodeInto(value, buf.subarray(offset + 1));
+            buf[offset] = written;
         }
         else if (value instanceof Uint8Array) {
             buf.set(value, offset);
@@ -31,25 +32,22 @@ export const writeFixed = (prop, buf, value, size, offset) => {
         buf[offset] = value;
     }
     else {
-        if (size === 8) {
-            buf.writeDoubleLE(value, offset);
-        }
-        else if (propIsSigned(prop)) {
-            if (size === 4) {
-                buf.writeInt32LE(value, offset);
-            }
-            else if (size === 2) {
-                buf.writeInt16LE(value, offset);
-            }
-            else if (size === 1) {
-                buf[offset] = value;
-            }
+        if (size === 8) { // RFE no int64 for u?
+            const view = new DataView(buf.buffer, buf.byteOffset);
+            view.setFloat64(offset, value, true);
         }
         else if (size === 4) {
-            buf.writeUInt32LE(value, offset);
+            buf[offset] = value;
+            buf[offset + 1] = value >>> 8;
+            buf[offset + 2] = value >>> 16;
+            buf[offset + 3] = value >>> 24;
         }
         else if (size === 2) {
-            buf.writeUInt16LE(value, offset);
+            buf[offset] = value;
+            buf[offset + 1] = value >>> 8;
+        }
+        else if (size === 1) {
+            buf[offset] = value;
         }
     }
 };
@@ -63,23 +61,31 @@ export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
     if (Array.isArray(value)) {
         // [or = 1] [size 2] [start 2] [op], [repeat 2], value[size] value[size] value[size]
         const len = value.length;
-        buf = Buffer.allocUnsafe(10 + len * size);
+        buf = new Uint8Array(10 + len * size);
         buf[0] = ctx.type;
         buf[1] =
             prop.typeIndex === REFERENCES && ctx.operation === EQUAL
                 ? MODE_AND_FIXED
                 : MODE_OR_FIXED;
         buf[2] = prop.typeIndex;
-        buf.writeUInt16LE(size, 3);
-        buf.writeUInt16LE(start, 5);
+        buf[3] = size;
+        buf[4] = size >>> 8;
+        buf[5] = start;
+        buf[6] = start >>> 8;
         buf[7] = ctx.operation;
         // buf[7] = prop.typeIndex
-        buf.writeUInt16LE(len, 8);
+        buf[8] = len;
+        buf[9] = len >>> 8;
         if (sort) {
             value = new Uint32Array(value.map((v) => parseFilterValue(prop, v)));
             value.sort();
             for (let i = 0; i < len; i++) {
-                buf.writeUInt32LE(value[i], 10 + i * size);
+                const off = 10 + i * size;
+                const val = value[i];
+                buf[off] = val;
+                buf[off + 1] = val >>> 8;
+                buf[off + 2] = val >>> 16;
+                buf[off + 3] = val >>> 24;
             }
         }
         else {
@@ -90,12 +96,14 @@ export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
     }
     else {
         // [or = 0] [size 2] [start 2], [op], value[size]
-        buf = Buffer.allocUnsafe(8 + size);
+        buf = new Uint8Array(8 + size);
         buf[0] = ctx.type;
         buf[1] = MODE_DEFAULT;
         buf[2] = prop.typeIndex;
-        buf.writeUInt16LE(size, 3);
-        buf.writeUInt16LE(start, 5);
+        buf[3] = size;
+        buf[4] = size >>> 8;
+        buf[5] = start;
+        buf[6] = start >>> 8;
         buf[7] = ctx.operation;
         writeFixed(prop, buf, parseFilterValue(prop, value), size, 8);
     }

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

@@ -1,3 +1,3 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { FilterCtx } from './types.js';
-export declare const createReferenceFilter: (prop: PropDef | PropDefEdge, ctx: FilterCtx, value: any) => Buffer;
+export declare const createReferenceFilter: (prop: PropDef | PropDefEdge, ctx: FilterCtx, value: any) => Uint8Array;

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

@@ -1,25 +1,35 @@
 import { MODE_REFERENCE } from './types.js';
 export const createReferenceFilter = (prop, ctx, value) => {
-    let buf;
     const len = Array.isArray(value) ? value.length : 1;
-    buf = Buffer.allocUnsafe(11 + len * 8);
+    const buf = new Uint8Array(11 + len * 8);
     buf[0] = ctx.type;
     buf[1] = MODE_REFERENCE;
     buf[2] = prop.typeIndex;
-    buf.writeUInt16LE(8, 3);
-    buf.writeUInt16LE(len, 5);
+    buf[3] = 8;
+    buf[4] = 8 >>> 8;
+    buf[5] = len;
+    buf[6] = len >>> 8;
     buf[7] = ctx.operation;
     // buf[7] = prop.typeIndex
     // REF TYPE (only 1 exists now...)
     buf[8] = 0;
-    buf.writeUInt16LE(prop.inverseTypeId, 9);
+    buf[9] = prop.inverseTypeId;
+    buf[10] = prop.inverseTypeId >>> 8;
     if (Array.isArray(value)) {
         for (let i = 0; i < len; i++) {
-            buf.writeUInt32LE(value[i], 11 + i * 8);
+            let off = 11 + i * 8;
+            const v = value[i];
+            buf[off++] = v;
+            buf[off++] = v >>> 8;
+            buf[off++] = v >>> 16;
+            buf[off++] = v >>> 24;
         }
     }
     else {
-        buf.writeUInt32LE(value, 11);
+        buf[11] = value;
+        buf[12] = value >>> 8;
+        buf[13] = value >>> 16;
+        buf[14] = value >>> 24;
     }
     return buf;
 };

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

@@ -1,4 +1,4 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
 import { FilterCtx } from './types.js';
 import { LangCode } from '@based/schema';
-export declare const createVariableFilterBuffer: (value: any, prop: PropDef | PropDefEdge, ctx: FilterCtx, lang: LangCode) => Buffer;
+export declare const createVariableFilterBuffer: (value: any, prop: PropDef | PropDefEdge, ctx: FilterCtx, lang: LangCode) => Uint8Array;