@based/db 0.0.28 → 0.0.30

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

@@ -20,7 +20,6 @@ export const walkDefs = (db, def, f) => {
                     def.edges.lang = def.lang;
                 }
                 const edgeProp = def.edges.props[p];
-                // console.log(p, !!edgeProp, Object.keys(def.edges.props), def.target)
                 if (edgeProp.typeIndex === REFERENCE ||
                     edgeProp.typeIndex === REFERENCES) {
                     const refDef = createOrGetRefQueryDef(db, def.edges, edgeProp);

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

@@ -135,7 +135,7 @@ const handleUndefinedProps = (id, q, item) => {
     if (q.aggregation == 0 /* AggFlag.NONE */ || q.aggregation == null) {
         for (const k in q.include.propsRead) {
             if (q.include.propsRead[k] !== id) {
-                // Only relvant for seperate props
+                // Only relevant for seperate props
                 const prop = q.schema.reverseProps[k];
                 if (prop.typeIndex === CARDINALITY) {
                     addField(prop, 0, item);
@@ -146,7 +146,8 @@ const handleUndefinedProps = (id, q, item) => {
                     if (lang.has(0)) {
                         for (const locale in q.schema.locales) {
                             if (!lan[locale]) {
-                                lan[locale] = '';
+                                // console.log('???', locale, prop.default)
+                                lan[locale] = prop.default[locale] || '';
                             }
                         }
                     }
@@ -154,13 +155,24 @@ const handleUndefinedProps = (id, q, item) => {
                         for (const code of lang) {
                             const locale = inverseLangMap.get(code);
                             if (!lan[locale]) {
-                                lan[locale] = '';
+                                lan[locale] = prop.default[locale] || '';
                             }
                         }
                     }
                 }
+                else if (prop.typeIndex === BINARY) {
+                    addField(prop, prop.default, item);
+                }
+                else if (prop.typeIndex === TEXT) {
+                    // q.lang
+                    // console.log('???')
+                    addField(prop, '', item);
+                }
                 else {
-                    addField(prop, prop.typeIndex === JSON ? null : '', item);
+                    1;
+                    if (prop.default !== undefined) {
+                        addField(prop, prop.default, item);
+                    }
                 }
             }
         }
@@ -314,9 +326,6 @@ export const readAllFields = (q, result, offset, end, item, id) => {
         }
         else {
             const prop = q.schema.reverseProps[index];
-            if (!prop) {
-                console.log({ prop: !!prop }, index);
-            }
             if (prop.typeIndex === CARDINALITY) {
                 q.include.propsRead[index] = id;
                 const size = readUint32(result, i);

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

@@ -12,8 +12,7 @@ export const vectorSearch = (def, q, field, opts) => {
     if (prop.typeIndex !== VECTOR) {
         searchIncorrectType(def, prop);
     }
-    // [isVec] [q len] [q len] [field] [fn] [score] [score] [score] [score] [q..]
-    let size = 9;
+    let size = 17;
     const vec = new Uint8Array(q.buffer, 0, q.byteLength);
     size += vec.byteLength;
     def.search = {
@@ -32,21 +31,17 @@ export const search = (def, q, s) => {
         searchIncorrecQueryValue(def, q);
         q = '';
     }
-    const x = q
-        .toLowerCase()
-        .normalize('NFKD')
-        .trim()
-        .split(' ')
-        .map((s) => `  ${s}`);
+    const x = q.toLowerCase().normalize('NFKD').trim().split(' ');
     for (const s of x) {
         if (s) {
             const buf = ENCODER.encode(s);
-            let len = buf.byteLength - 2;
-            buf[0] = len;
-            buf[1] = len >>> 8;
-            bufs.push(buf);
+            const lenBuf = new Uint8Array(2);
+            let len = buf.byteLength;
+            lenBuf[0] = len;
+            lenBuf[1] = len >>> 8;
+            bufs.push(lenBuf, buf);
             nrBlocks++;
-            totalByteLength += len + 2;
+            totalByteLength += buf.byteLength + 2;
         }
     }
     bufs.unshift(Uint8Array.from([nrBlocks]));
@@ -119,7 +114,8 @@ export const searchToBuffer = (search) => {
         | 3      | field    | 1            | Field identifier                                |
         | 4      | func     | 1            | Function identifier (enum)                      |
         | 5      | score    | 4            | Score value (f32)                               |
-        | 9      | query    | queryLen     | Query data (array of f32 values)                |
+        | 9      | align    | 8            | Space for alignment                             |
+        | 17     | query    | queryLen     | Query data (array of f32 values)                |
         */
         const result = new Uint8Array(search.size);
         result[0] = 1; // search.isVector 1
@@ -128,7 +124,7 @@ export const searchToBuffer = (search) => {
         result[3] = search.prop;
         result[4] = getVectorFn(search.opts.fn);
         result.set(new Uint8Array(new Float32Array([search.opts.score ?? 0.5]).buffer), 5);
-        result.set(search.query, 9);
+        result.set(search.query, 17);
         return result;
     }
     else {

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

@@ -1,5 +1,4 @@
 import { BasedDbQuery } from '../BasedDbQuery.js';
 import { OnData, OnError, OnClose } from './types.js';
+export declare const subscribe: (q: BasedDbQuery, onData: OnData, onError?: OnError) => OnClose;
 export * from './types.js';
-export * from './markers.js';
-export declare const subscribe: (q: BasedDbQuery, onData: OnData, onError: OnError) => OnClose;

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

@@ -1,58 +1,11 @@
 import { includeField } from '../query.js';
 import { registerQuery } from '../registerQuery.js';
-import { runSubscription } from './run.js';
-import { addSubscriptionMarkers, deleteSubscriptionMarkers } from './markers.js';
-export * from './types.js';
-export * from './markers.js';
 export const subscribe = (q, onData, onError) => {
-    let closed = false;
     if (!q.def.include.stringFields.size && !q.def.references.size) {
         includeField(q.def, '*');
     }
-    try {
-        registerQuery(q);
-    }
-    catch (err) {
-        onError(err);
-        return () => q;
-    }
-    if (!q.db.subscriptions.has(q.id)) {
-        const subscription = {
-            query: q,
-            subs: new Set(),
-            inProgress: false,
-            closed: false,
-        };
-        q.db.subscriptions.set(q.id, subscription);
-        addSubscriptionMarkers(q, subscription);
-    }
-    const fn = (res, err) => {
-        if (!closed) {
-            if (err) {
-                onError(err);
-            }
-            else {
-                onData(res);
-            }
-        }
-    };
-    const sub = q.db.subscriptions.get(q.id);
-    const close = () => {
-        sub.subs.delete(fn);
-        if (sub.subs.size === 0) {
-            q.db.subscriptions.delete(q.id);
-            deleteSubscriptionMarkers(q);
-        }
-        closed = true;
-        return q;
-    };
-    sub.subs.add(fn);
-    if (sub.res) {
-        onData(sub.res);
-    }
-    if (!sub.inProgress) {
-        runSubscription(sub);
-    }
-    return close;
+    registerQuery(q);
+    return q.db.hooks.subscribe(q, onData, onError);
 };
+export * from './types.js';
 //# sourceMappingURL=index.js.map

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

@@ -95,7 +95,7 @@ const getFilterFields = (filter, results = {
         conditions.forEach((v, k) => {
             if (k === 0) {
                 for (const buf of v) {
-                    const x = buf[4] | buf[5] << 8;
+                    const x = buf[4] | (buf[5] << 8);
                     results.main.add(x);
                 }
             }
@@ -209,6 +209,5 @@ export const resetSubscriptionMarkers = (db) => {
 };
 export const deleteSubscriptionMarkers = (q) => {
     // derp
-    console.log('delete markers!');
 };
 //# sourceMappingURL=markers.js.map

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

@@ -61,11 +61,9 @@ export const runSubscription = (subscription) => {
     }
 };
 export const startSubscription = (db) => {
-    console.log('start subscription');
     if (!db.subscriptionsInProgress) {
         db.subscriptionsInProgress = true;
         setTimeout(() => {
-            console.log('run it');
             db.subscriptionsToRun.forEach((s) => {
                 runSubscription(s);
             });

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

@@ -1,33 +1,5 @@
 import { BasedQueryResponse } from '../BasedIterable.js';
-import { BasedDbQuery } from '../BasedDbQuery.js';
 export type OnData = (res: BasedQueryResponse) => any;
 export type OnError = (err: Error) => any;
-export type OnClose = () => BasedDbQuery;
+export type OnClose = () => any;
 export type OnSubscription = (res: any, err?: Error) => void;
-export type Subscription = {
-    query: BasedDbQuery;
-    subs: Set<OnSubscription>;
-    res?: BasedQueryResponse;
-    closed: boolean;
-    inProgress: boolean;
-};
-export type SubscriptionsMap = Map<number, Subscription>;
-export type SubscriptionsToRun = Subscription[];
-export type SubscriptionMarkers = {
-    main: {
-        [start: string]: Subscription[];
-    };
-    props: {
-        [prop: string]: Subscription[];
-    };
-};
-export type SubscriptionMarkerMap = {
-    [typeID: string]: {
-        ids: Map<number, SubscriptionMarkers>;
-        collection: SubscriptionMarkers;
-    };
-};
-export type SubscriptionMarkersCheck = {
-    collection: SubscriptionMarkers | false;
-    ids: SubscriptionMarkers | false;
-};

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

@@ -1,3 +1,10 @@
 export {};
-// has sub
+// export type Subscription = {
+//   query: BasedDbQuery
+//   subs: Set<OnSubscription>
+//   res?: BasedQueryResponse
+//   closed: boolean
+//   inProgress: boolean // dont need to check
+//   // filter - realy nice to add
+// }
 //# sourceMappingURL=types.js.map

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

@@ -1,6 +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 MAX_ID = 4294967295;
 export declare const MIN_ID_VALUE = 1;
-export declare const MAX_ID_VALUE: number;

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

@@ -2,8 +2,6 @@
 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 MAX_ID = 4294967295;
 // Data validation thresholds
 export const MIN_ID_VALUE = 1; // Minimum allowed value for an ID (id array stared)
-export const MAX_ID_VALUE = 2 ** 32 - 1; /// Maximum allowed value for an ID (Uint32)
 //# sourceMappingURL=thresholds.js.map

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

@@ -13,6 +13,7 @@ const byteSize = (arr) => {
 export function defToBuffer(db, def) {
     const result = [];
     const include = includeToBuffer(db, def);
+    // ---------------------------------------
     def.references.forEach((ref) => {
         include.push(...defToBuffer(db, ref));
         if (ref.errors) {
@@ -32,27 +33,21 @@ export function defToBuffer(db, def) {
         edgesSize = byteSize(edges);
     }
     const size = (edges ? edgesSize + 3 : 0) + byteSize(include);
+    // ---------------------------------------
+    // move down and will handle size after store the size Var
+    // only for references | edges
     if (def.type === QueryDefType.Root) {
-        let filter;
-        let filterSize = 0;
         let search;
         let searchSize = 0;
+        const filterSize = def.filter.size || 0;
         if (def.search) {
             search = searchToBuffer(def.search);
             searchSize = def.search.size;
         }
-        if (def.filter.size) {
-            filter = filterToBuffer(def.filter);
-            filterSize = filter.byteLength;
-        }
-        // [type,type]
-        // [q type] 0 == id, 1 === ids, 2 === type only
         if (def.target.resolvedAlias) {
-            // put this somehwere else at some point
             const alias = def.target.resolvedAlias;
             const aliasStr = ENCODER.encode(alias.value);
             const aliasLen = aliasStr.byteLength;
-            // filter is nice for things like access
             const buf = new Uint8Array(8 + filterSize + aliasLen);
             buf[0] = 3;
             buf[1] = def.schema.idUint8[0];
@@ -64,14 +59,11 @@ export function defToBuffer(db, def) {
             buf[6 + aliasLen] = filterSize;
             buf[7 + aliasLen] = filterSize >>> 8;
             if (filterSize) {
-                buf.set(filter, 8 + aliasLen);
+                buf.set(filterToBuffer(def.filter), 8 + aliasLen);
             }
             result.push(buf);
         }
         else if (def.target.id) {
-            // type 0
-            // 0: 4 [id]
-            // 0: 2 [filterSize]
             const buf = new Uint8Array(9 + filterSize);
             buf[0] = 0;
             buf[1] = def.schema.idUint8[0];
@@ -83,7 +75,7 @@ export function defToBuffer(db, def) {
             buf[7] = filterSize;
             buf[8] = filterSize >>> 8;
             if (filterSize) {
-                buf.set(filter, 9);
+                buf.set(filterToBuffer(def.filter), 9);
             }
             result.push(buf);
         }
@@ -95,15 +87,10 @@ export function defToBuffer(db, def) {
                 sortSize = sort.byteLength;
             }
             let aggregation;
-            aggregation = createAggFlagBuffer(def.aggregation);
+            if (def.aggregation) {
+                aggregation = createAggFlagBuffer(def.aggregation);
+            }
             if (def.target.ids) {
-                // type 1
-                // 1: 4 + ids * 4 [ids len] [id,id,id]
-                // 1: 8 [offset, limit]
-                // 1: 2 [filter size]
-                // ?filter
-                // 1: 2 [sort size]
-                // ?sort
                 if (!sortSize &&
                     (def.range.offset || def.range.limit < def.target.ids.length)) {
                     def.target.ids = def.target.ids.slice(def.range.offset, def.range.offset + def.range.limit);
@@ -129,7 +116,8 @@ export function defToBuffer(db, def) {
                 buf[idsSize + 15] = filterSize;
                 buf[idsSize + 16] = filterSize >>> 8;
                 if (filterSize) {
-                    buf.set(filter, idsSize + 17);
+                    // just write it here dont do set
+                    buf.set(filterToBuffer(def.filter), idsSize + 17);
                 }
                 buf[17 + filterSize + idsSize] = sortSize;
                 buf[18 + filterSize + idsSize] = sortSize >>> 8;
@@ -145,13 +133,6 @@ export function defToBuffer(db, def) {
                 result.push(buf);
             }
             else {
-                // type 2
-                // 2: 0
-                // 2: 8 [offset, limit]
-                // 2: 2 [filter size]
-                // ?filter
-                // 2: 2 [sort size]
-                // ?sort
                 const buf = new Uint8Array(18 + filterSize + sortSize + searchSize);
                 buf[0] = 2;
                 buf[1] = def.schema.idUint8[0];
@@ -167,7 +148,7 @@ export function defToBuffer(db, def) {
                 buf[11] = filterSize;
                 buf[12] = filterSize >>> 8;
                 if (filterSize) {
-                    buf.set(filter, 13);
+                    buf.set(filterToBuffer(def.filter), 13);
                 }
                 buf[13 + filterSize] = sortSize;
                 buf[14 + filterSize] = sortSize >>> 8;
@@ -187,19 +168,12 @@ export function defToBuffer(db, def) {
         }
     }
     else if (def.type === QueryDefType.References) {
-        // TODO filter edge
-        let filter;
-        if (def.filter.size) {
-            filter = filterToBuffer(def.filter);
-        }
+        const filterSize = def.filter.size || 0;
         let sort;
         if (def.sort) {
             sort = createSortBuffer(def.sort);
         }
-        // ADD IT
-        // TODO: ADD RANGE [offset,limit] (8 bytes)
         const sortSize = sort?.byteLength ?? 0;
-        const filterSize = filter?.byteLength ?? 0;
         const modsSize = filterSize + sortSize;
         const meta = new Uint8Array(modsSize + 10 + 8);
         const sz = size + 7 + modsSize + 8;
@@ -218,8 +192,8 @@ export function defToBuffer(db, def) {
         meta[12] = def.range.limit >>> 8;
         meta[13] = def.range.limit >>> 16;
         meta[14] = def.range.limit >>> 24;
-        if (filter) {
-            meta.set(filter, 15);
+        if (filterSize) {
+            meta.set(filterToBuffer(def.filter), 15);
         }
         if (sort) {
             meta.set(sort, 15 + filterSize);

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

@@ -27,9 +27,10 @@ export type Target = {
     };
 };
 export declare const isRefDef: (def: QueryDef) => def is QueryDefRest;
+export type FilterCondition = Uint8Array;
 export type QueryDefFilter = {
     size: number;
-    conditions: Map<number, Uint8Array[]>;
+    conditions: Map<number, FilterCondition[]>;
     exists?: {
         prop: PropDef | PropDefEdge;
         negate: boolean;
@@ -37,7 +38,7 @@ export type QueryDefFilter = {
     references?: Map<number, QueryDefFilter>;
     fromRef?: PropDef;
     schema?: SchemaTypeDef;
-    edges?: Map<number, Uint8Array[]>;
+    edges?: Map<number, FilterCondition[]>;
     or?: QueryDefFilter;
     and?: QueryDefFilter;
 };

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

@@ -61,9 +61,7 @@ export declare const searchIncorrecQueryValue: (def: QueryDef, payload: any) =>
 export declare const searchIncorrectType: (def: QueryDef, payload: PropDef | PropDefEdge) => void;
 export declare const searchDoesNotExist: (def: QueryDef, field: string, isVector: boolean) => PropDef;
 export declare const validateRange: (def: QueryDef, offset: number, limit: number) => boolean;
-export declare const isValidId: (id: number) => boolean;
-export declare const isValidString: (v: any) => boolean;
-export declare const validateVal: (def: QueryDef, f: Filter, validate: (v: any) => boolean) => boolean;
+export declare const validateVal: (def: QueryDef, f: Filter, validate: (v: any, p: PropDef | PropDefEdge) => boolean) => boolean;
 export declare const validateFilter: (def: QueryDef, prop: PropDef | PropDefEdge, f: Filter) => boolean;
 export declare const validateType: (db: DbClient, def: QueryDef, type: string) => SchemaTypeDef;
 export declare const filterOperatorDoesNotExist: (def: QueryDef, field: string) => void;

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

@@ -1,9 +1,9 @@
 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 { MAX_ID, MAX_ID_VALUE, MAX_IDS_PER_QUERY, MIN_ID_VALUE, } from './thresholds.js';
+import { MAX_IDS_PER_QUERY } from './thresholds.js';
 import { displayTarget, safeStringify } from './display.js';
-import { langCodesMap } from '@based/schema';
+import { isValidId, isValidString, langCodesMap, MAX_ID, } from '@based/schema';
 export const ERR_TARGET_INVAL_TYPE = 1;
 export const ERR_TARGET_INVAL_ALIAS = 2;
 export const ERR_TARGET_EXCEED_MAX_IDS = 3;
@@ -85,18 +85,6 @@ export const validateRange = (def, offset, limit) => {
     }
     return r;
 };
-export const isValidId = (id) => {
-    if (typeof id != 'number' || id < MIN_ID_VALUE || id > MAX_ID_VALUE) {
-        return false;
-    }
-    return true;
-};
-export const isValidString = (v) => {
-    const isVal = typeof v === 'string' ||
-        v instanceof Uint8Array ||
-        ArrayBuffer.isView(v);
-    return isVal;
-};
 export const validateVal = (def, f, validate) => {
     if (def.skipValidation) {
         return false;
@@ -104,13 +92,13 @@ export const validateVal = (def, f, validate) => {
     const value = f[2];
     if (Array.isArray(value)) {
         for (const v of value) {
-            if (!validate(v)) {
+            if (!validate(v, f[2])) {
                 def.errors.push({ code: ERR_FILTER_INVALID_VAL, payload: f });
                 return true;
             }
         }
     }
-    else if (!validate(value)) {
+    else if (!validate(value, f[2])) {
         def.errors.push({
             code: ERR_FILTER_INVALID_VAL,
             payload: f,
@@ -147,7 +135,7 @@ export const validateFilter = (def, prop, f) => {
             });
             return true;
         }
-        if (validateVal(def, f, isValidId)) {
+        if (validateVal(def, f, prop.validation)) {
             return true;
         }
     }
@@ -287,7 +275,7 @@ export const validateSort = (def, field, orderInput) => {
         }
     }
     const type = propDef.typeIndex;
-    if (type === REFERENCES || type === REFERENCE) {
+    if (type === REFERENCES || type === REFERENCE || type === VECTOR) {
         def.errors.push({
             code: ERR_SORT_TYPE,
             payload: propDef,

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

@@ -1,4 +1,6 @@
 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;
 export declare const compress: (str: string) => Uint8Array;
 export declare const decompress: (val: Uint8Array) => string;

package/dist/src/client/string.js

@@ -3,23 +3,19 @@ import { readUint32 } from './../utils.js';
 import makeTmpBuffer from './tmpBuffer.js';
 import { DECODER, ENCODER } from '../utils.js';
 const { getUint8Array: getTmpBuffer } = makeTmpBuffer(4096); // the usual page size?
-// type 0 = no compression; 1 = deflate
-// [lang] [type] [uncompressed size 4] [compressed string] [crc32]
-// var cnt = 0
-// var bytesSaved = 0
-// make this into a package
-// write the type Byte
+export const COMPRESSED = 1;
+export const NOT_COMPRESSED = 0;
 export const write = (buf, value, offset, noCompression, lang) => {
     value = value.normalize('NFKD');
     buf[offset] = lang || 0;
     const { written: l } = ENCODER.encodeInto(value, buf.subarray(offset + 2));
     let crc = native.crc32(buf.subarray(offset + 2, offset + 2 + l));
-    // 50 maybe if lvl 1
+    // 50 len maybe if lvl 1
     if (value.length > 200 && !noCompression) {
         buf.copyWithin(offset + 6 + l, offset + 2, offset + 2 + l);
         const size = native.compress(buf, offset + 6, l);
         if (size === 0) {
-            buf[offset + 1] = 0; // not compressed
+            buf[offset + 1] = NOT_COMPRESSED;
             ENCODER.encodeInto(value, buf.subarray(offset + 2));
             buf[offset + l + 2] = crc;
             buf[offset + l + 3] = crc >>>= 8;
@@ -29,7 +25,7 @@ export const write = (buf, value, offset, noCompression, lang) => {
         }
         else {
             let len = l;
-            buf[offset + 1] = 1; // compressed
+            buf[offset + 1] = COMPRESSED;
             buf[offset + 2] = len;
             buf[offset + 3] = len >>>= 8;
             buf[offset + 4] = len >>>= 8;
@@ -38,11 +34,11 @@ export const write = (buf, value, offset, noCompression, lang) => {
             buf[offset + size + 7] = crc >>>= 8;
             buf[offset + size + 8] = crc >>>= 8;
             buf[offset + size + 9] = crc >>>= 8;
-            return size + 10; // 0 C 4 4
+            return size + 10;
         }
     }
     else {
-        buf[offset + 1] = 0; // not compressed
+        buf[offset + 1] = NOT_COMPRESSED;
         buf[offset + l + 2] = crc;
         buf[offset + l + 3] = crc >>>= 8;
         buf[offset + l + 4] = crc >>>= 8;
@@ -63,14 +59,14 @@ export const decompress = (val) => {
 };
 export const read = (val, offset, len) => {
     const type = val[offset + 1];
-    if (type == 1) {
+    if (type == COMPRESSED) {
         const origSize = readUint32(val, offset + 2);
         const newBuffer = getTmpBuffer(origSize);
-        // deflate in browser for this...
+        // Browser fallback required for this
         native.decompress(val, newBuffer, offset + 6, len - 6);
         return DECODER.decode(newBuffer);
     }
-    else if (type == 0) {
+    else if (type == NOT_COMPRESSED) {
         return DECODER.decode(val.subarray(offset + 2, len + offset - 4));
     }
     return '';

package/dist/src/index.d.ts

@@ -22,7 +22,7 @@ export declare class BasedDb {
     constructor(opts: {
         path: string;
         maxModifySize?: number;
-        debug?: boolean;
+        debug?: boolean | 'server';
     });
     create: DbClient['create'];
     copy: DbClient['copy'];