@based/db 0.0.47 → 0.0.49

package/dist/src/client/index.js

@@ -10,7 +10,8 @@ import { deleteFn } from './modify/delete.js';
 import { wait } from '@saulx/utils';
 import { hash } from '@saulx/hash';
 import { expire } from './modify/expire.js';
-import { debugMode, schemaLooseEqual } from '../utils.js';
+import { debugMode } from '../utils.js';
+import { parseSchema, schemaLooseEqual } from '../schema.js';
 const makeFlushIsReady = (dbClient) => {
     dbClient.flushIsReady = new Promise((resolve) => {
         dbClient.flushReady = () => {
@@ -48,8 +49,9 @@ export class DbClient {
     schemaPromise;
     async setSchema(schema, fromStart, transformFns) {
         const strictSchema = fromStart ? schema : parse(schema).schema;
+        const parsedSchema = parseSchema(strictSchema);
         // this one excludes all the ids
-        if (schemaLooseEqual(strictSchema, this.schema)) {
+        if (schemaLooseEqual(parsedSchema, this.schema)) {
             return this.schema;
         }
         // drain current things

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

@@ -325,6 +325,10 @@ export class BasedDbQuery extends QueryBranch {
         const res = await this.db.hooks.getQueryBuf(buf);
         if (res.byteLength === 1) {
             if (res[0] === 0) {
+                if (this.db.schema?.hash !== this.def.schemaChecksum) {
+                    this.reBuildQuery();
+                    return this.#getInternal(resolve, reject);
+                }
                 reject(new Error('schema mismatch'));
             }
             else {

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

@@ -3,6 +3,7 @@ import { TypeIndex } from '@based/schema/def';
 import { BasedQueryResponse } from './BasedIterable.js';
 export declare const size: (size: number) => string;
 export declare const time: (time: number) => string;
+export declare const printNumber: (nr: number) => string;
 export declare const prettyPrintVal: (v: any, type: TypeIndex) => string;
 export declare const parseUint8Array: (p: any) => any;
 export declare const safeStringify: (p: any, nr?: number) => string;

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

@@ -35,6 +35,12 @@ export const time = (time) => {
         return picocolors.green(str);
     }
 };
+export const printNumber = (nr) => {
+    if (nr > 1000) {
+        return picocolors.blue(nr.toLocaleString());
+    }
+    return picocolors.blue(nr);
+};
 export const prettyPrintVal = (v, type) => {
     if (type === BINARY) {
         const nr = 12;
@@ -151,12 +157,12 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
         else if (!def) {
             if (typeof v === 'number') {
                 if (q.aggregate) {
-                    str += picocolors.blue(v);
+                    str += printNumber(v);
                     str += picocolors.italic(picocolors.dim(` ${key.indexOf('count') >= 0 ? ' count' : ' sum'}`));
                     str += ',\n';
                 }
                 else {
-                    str += picocolors.blue(v) + '\n';
+                    str += printNumber(v) + '\n';
                 }
             }
             else {
@@ -212,11 +218,11 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
             else {
                 if (typeof v === 'number') {
                     if (q.aggregate) {
-                        str += picocolors.blue(v);
+                        str += printNumber(v);
                         str += picocolors.italic(picocolors.dim(` ${key.indexOf('count') >= 0 ? ' count' : ' sum'}`));
                     }
                     else {
-                        str += picocolors.blue(v);
+                        str += printNumber(v);
                     }
                 }
                 else if (typeof v === 'object' && v) {

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

@@ -1,3 +1,4 @@
 import { QueryDefFilter } from '../types.js';
 export declare const fillConditionsBuffer: (result: Uint8Array, conditions: QueryDefFilter, offset: number) => number;
+export declare const isSimpleMainFilter: (conditions: QueryDefFilter) => boolean;
 export declare const filterToBuffer: (conditions: QueryDefFilter) => Uint8Array;

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

@@ -81,7 +81,18 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
     }
     return lastWritten - offset;
 };
+export const isSimpleMainFilter = (conditions) => {
+    if (!conditions.references &&
+        !conditions.edges &&
+        conditions.conditions.size === 1 &&
+        conditions.conditions.has(0) &&
+        !conditions.or) {
+        return true;
+    }
+    return false;
+};
 export const filterToBuffer = (conditions) => {
+    // add extra byte IS SINGLE CONDITION
     let result;
     if (conditions.size > 0) {
         result = new Uint8Array(conditions.size);

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

@@ -2,7 +2,7 @@ export * from './queryDef.js';
 export * from './types.js';
 export * from './include/props.js';
 export * from './include/toBuffer.js';
-export * from './toBuffer.js';
+export * from './toByteCode/toBuffer.js';
 export * from './filter/filter.js';
 export * from './filter/toBuffer.js';
 export * from './sort.js';

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

@@ -2,7 +2,7 @@ export * from './queryDef.js';
 export * from './types.js';
 export * from './include/props.js';
 export * from './include/toBuffer.js';
-export * from './toBuffer.js';
+export * from './toByteCode/toBuffer.js';
 export * from './filter/filter.js';
 export * from './filter/toBuffer.js';
 export * from './sort.js';

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

@@ -1,6 +1,6 @@
 import native from '../../native.js';
 import { concatUint8Arr } from '@saulx/utils';
-import { defToBuffer } from './toBuffer.js';
+import { defToBuffer } from './toByteCode/toBuffer.js';
 import { handleErrors } from './validation.js';
 export const registerQuery = (q) => {
     if (!q.id) {

package/dist/src/client/query/toByteCode/default.d.ts

@@ -0,0 +1,2 @@
+import { QueryDef } from '../types.js';
+export declare const defaultQuery: (def: QueryDef, filterSize: number, sortSize: number, searchSize: number, sort: Uint8Array, search: Uint8Array) => Uint8Array;

package/dist/src/client/query/toByteCode/default.js

@@ -0,0 +1,40 @@
+import { filterToBuffer, isSimpleMainFilter } from '../query.js';
+import { QueryType } from '../types.js';
+export const defaultQuery = (def, filterSize, sortSize, searchSize, sort, search) => {
+    const buf = new Uint8Array(18 + filterSize + sortSize + searchSize);
+    let index = 0;
+    buf[index++] = QueryType.default;
+    buf[index++] = def.schema.idUint8[0];
+    buf[index++] = def.schema.idUint8[1];
+    buf[index++] = def.range.offset;
+    buf[index++] = def.range.offset >>> 8;
+    buf[index++] = def.range.offset >>> 16;
+    buf[index++] = def.range.offset >>> 24;
+    buf[index++] = def.range.limit;
+    buf[index++] = def.range.limit >>> 8;
+    buf[index++] = def.range.limit >>> 16;
+    buf[index++] = def.range.limit >>> 24;
+    buf[index++] = filterSize;
+    buf[index++] = filterSize >>> 8;
+    buf[index++] = filterSize && isSimpleMainFilter(def.filter) ? 1 : 0;
+    // if (filterSize && isSimpleMainFilter(def.filter)) {
+    // console.log('SIMPLE FILTER!')
+    if (filterSize) {
+        buf.set(filterToBuffer(def.filter), index);
+        index += filterSize;
+    }
+    buf[index++] = sortSize;
+    buf[index++] = sortSize >>> 8;
+    if (sortSize) {
+        buf.set(sort, index);
+        index += sortSize;
+    }
+    buf[index++] = searchSize;
+    buf[index++] = searchSize >>> 8;
+    if (searchSize) {
+        buf.set(search, index);
+        index += searchSize;
+    }
+    return buf;
+};
+//# sourceMappingURL=default.js.map

package/dist/src/client/query/toByteCode/toBuffer.d.ts

@@ -0,0 +1,3 @@
+import { QueryDef } from '../types.js';
+import { DbClient } from '../../index.js';
+export declare function defToBuffer(db: DbClient, def: QueryDef): Uint8Array[];

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

@@ -1,10 +1,11 @@
-import { createSortBuffer } from './sort.js';
-import { QueryDefType, QueryType } from './types.js';
-import { includeToBuffer } from './include/toBuffer.js';
-import { filterToBuffer } from './query.js';
-import { searchToBuffer } from './search/index.js';
+import { createSortBuffer } from '../sort.js';
+import { QueryDefType, QueryType } from '../types.js';
+import { includeToBuffer } from '../include/toBuffer.js';
+import { filterToBuffer } from '../query.js';
+import { searchToBuffer } from '../search/index.js';
 import { ENCODER, writeUint64 } from '@saulx/utils';
-import { aggregateToBuffer, isRootCountOnly } from './aggregates/aggregation.js';
+import { aggregateToBuffer, isRootCountOnly, } from '../aggregates/aggregation.js';
+import { defaultQuery } from './default.js';
 const byteSize = (arr) => {
     return arr.reduce((a, b) => {
         return a + b.byteLength;
@@ -173,6 +174,8 @@ export function defToBuffer(db, def) {
                 buf[idsSize + 12] = def.range.limit >>> 8;
                 buf[idsSize + 13] = def.range.limit >>> 16;
                 buf[idsSize + 14] = def.range.limit >>> 24;
+                // if (filterSize && isSimpleMainFilter(def.filter)) {
+                // console.log('SIMPLE FILTER!')
                 buf[idsSize + 15] = filterSize;
                 buf[idsSize + 16] = filterSize >>> 8;
                 if (filterSize) {
@@ -193,34 +196,7 @@ export function defToBuffer(db, def) {
                 result.push(buf);
             }
             else {
-                const buf = new Uint8Array(17 + filterSize + sortSize + searchSize);
-                buf[0] = QueryType.default;
-                buf[1] = def.schema.idUint8[0];
-                buf[2] = def.schema.idUint8[1];
-                buf[3] = def.range.offset;
-                buf[4] = def.range.offset >>> 8;
-                buf[5] = def.range.offset >>> 16;
-                buf[6] = def.range.offset >>> 24;
-                buf[7] = def.range.limit;
-                buf[8] = def.range.limit >>> 8;
-                buf[9] = def.range.limit >>> 16;
-                buf[10] = def.range.limit >>> 24;
-                buf[11] = filterSize;
-                buf[12] = filterSize >>> 8;
-                if (filterSize) {
-                    buf.set(filterToBuffer(def.filter), 13);
-                }
-                buf[13 + filterSize] = sortSize;
-                buf[14 + filterSize] = sortSize >>> 8;
-                if (sortSize) {
-                    buf.set(sort, 15 + filterSize);
-                }
-                buf[15 + filterSize + sortSize] = searchSize;
-                buf[16 + filterSize + sortSize] = searchSize >>> 8;
-                if (searchSize) {
-                    buf.set(search, 17 + filterSize + sortSize);
-                }
-                result.push(buf);
+                result.push(defaultQuery(def, filterSize, sortSize, searchSize, sort, search));
             }
         }
     }

package/dist/src/hooks.d.ts

@@ -0,0 +1,16 @@
+import { StrictSchema } from '@based/schema';
+import { BasedDbQuery } from './client/query/BasedDbQuery.js';
+import { OnError } from './client/query/subscription/types.js';
+import { DbServer } from './server/index.js';
+export declare const getDefaultHooks: (server: DbServer, subInterval?: number) => {
+    subscribe(q: BasedDbQuery, onData: (res: Uint8Array) => void, onError: OnError): () => void;
+    setSchema(schema: StrictSchema, fromStart: boolean): Promise<StrictSchema & {
+        lastId: number;
+        hash?: number;
+    }>;
+    flushModify(buf: Uint8Array): Promise<{
+        offsets: Record<number, number>;
+        dbWriteTime: number;
+    }>;
+    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
+};

package/dist/src/hooks.js

@@ -0,0 +1,47 @@
+export const getDefaultHooks = (server, subInterval = 200) => {
+    return {
+        subscribe(q, onData, onError) {
+            let timer;
+            let killed = false;
+            const poll = async () => {
+                const res = await server.getQueryBuf(q.buffer);
+                if (killed) {
+                    return;
+                }
+                if (res.byteLength >= 8) {
+                    onData(res);
+                }
+                else if (res.byteLength === 1 && res[0] === 0) {
+                    console.info('schema mismatch, should resolve after update');
+                    // ignore update and stop polling
+                    return;
+                }
+                else {
+                    onError(new Error('unexpected error'));
+                }
+                timer = setTimeout(poll, subInterval);
+            };
+            poll();
+            return () => {
+                clearTimeout(timer);
+                killed = true;
+            };
+        },
+        setSchema(schema, fromStart) {
+            return Promise.resolve(server.setSchema(schema, fromStart));
+        },
+        flushModify(buf) {
+            const d = performance.now();
+            const offsets = server.modify(buf);
+            const dbWriteTime = performance.now() - d;
+            return Promise.resolve({
+                offsets,
+                dbWriteTime,
+            });
+        },
+        getQueryBuf(buf) {
+            return Promise.resolve(server.getQueryBuf(buf));
+        },
+    };
+};
+//# sourceMappingURL=hooks.js.map

package/dist/src/index.d.ts

@@ -2,6 +2,7 @@ import { compress, decompress } from './client/string.js';
 import { ModifyCtx } from './client/flushModify.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
+import { getDefaultHooks } from './hooks.js';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx };
@@ -15,6 +16,7 @@ export * from './client/query/query.js';
 export * from './client/query/BasedDbQuery.js';
 export * from './client/query/BasedIterable.js';
 export * from './server/save.js';
+export { getDefaultHooks };
 export declare class BasedDb {
     #private;
     client: DbClient;

package/dist/src/index.js

@@ -3,7 +3,8 @@ import { ModifyCtx } from './client/flushModify.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import { wait } from '@saulx/utils';
-import { debugMode, debugServer, getDefaultHooks } from './utils.js';
+import { debugMode, debugServer } from './utils.js';
+import { getDefaultHooks } from './hooks.js';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx }; // TODO move this somewhere
@@ -17,6 +18,7 @@ export * from './client/query/query.js';
 export * from './client/query/BasedDbQuery.js';
 export * from './client/query/BasedIterable.js';
 export * from './server/save.js';
+export { getDefaultHooks };
 export class BasedDb {
     client;
     server;

package/dist/src/schema.d.ts

@@ -0,0 +1,3 @@
+import { StrictSchema } from '@based/schema';
+export declare const schemaLooseEqual: (a: any, b: any, key?: string) => boolean;
+export declare const parseSchema: (strictSchema: StrictSchema) => StrictSchema;

package/dist/src/schema.js

@@ -0,0 +1,94 @@
+import { getPropType } from '@based/schema';
+const exclude = new Set(['id', 'lastId', 'hash']);
+export const schemaLooseEqual = (a, b, key) => {
+    if (a === b) {
+        return true;
+    }
+    const typeofA = typeof a;
+    if (typeofA !== 'object') {
+        return exclude.has(key);
+    }
+    const typeofB = typeof b;
+    if (typeofA !== typeofB) {
+        return exclude.has(key);
+    }
+    if (a === null || b === null) {
+        return false;
+    }
+    if (a.constructor !== b.constructor) {
+        return false;
+    }
+    if (Array.isArray(a)) {
+        let i = a.length;
+        if (i !== b.length) {
+            return false;
+        }
+        while (i--) {
+            if (!schemaLooseEqual(a[i], b[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        for (const k in a) {
+            if (!schemaLooseEqual(a[k], b[k], k)) {
+                return false;
+            }
+        }
+        for (const k in b) {
+            if (k in a) {
+                continue;
+            }
+            if (!schemaLooseEqual(a[k], b[k], k)) {
+                return false;
+            }
+        }
+    }
+    return true;
+};
+export const parseSchema = (strictSchema) => {
+    let parsedSchema = strictSchema;
+    if (strictSchema.props) {
+        parsedSchema = {
+            ...strictSchema,
+            types: { ...parsedSchema.types },
+        };
+        const props = { ...strictSchema.props };
+        for (const key in props) {
+            const prop = props[key];
+            const propType = getPropType(prop);
+            let refProp;
+            if (propType === 'reference') {
+                refProp = prop;
+            }
+            else if (propType === 'references') {
+                refProp = prop.items;
+            }
+            if (refProp) {
+                const type = parsedSchema.types[refProp.ref];
+                const inverseKey = '_' + key;
+                parsedSchema.types[refProp.ref] = {
+                    ...type,
+                    props: {
+                        ...type.props,
+                        [inverseKey]: {
+                            items: {
+                                ref: '_root',
+                                prop: key,
+                            },
+                        },
+                    },
+                };
+                refProp.prop = inverseKey;
+            }
+        }
+        // @ts-ignore This creates an internal type to use for root props
+        parsedSchema.types._root = {
+            id: 1,
+            props,
+        };
+        delete parsedSchema.props;
+    }
+    return parsedSchema;
+};
+//# sourceMappingURL=schema.js.map

package/dist/src/server/index.js

@@ -2,7 +2,7 @@ import native from '../native.js';
 import createDbHash from './dbHash.js';
 import { rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { getPropType, langCodesMap, } from '@based/schema';
+import { langCodesMap } from '@based/schema';
 import { updateTypeDefs, schemaToSelvaBuffer, } from '@based/schema/def';
 import { start } from './start.js';
 import { initCsmt, makeCsmtKey, makeCsmtKeyFromNodeId, } from './tree.js';
@@ -11,8 +11,10 @@ import { Worker, MessageChannel } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import { setTimeout } from 'node:timers/promises';
 import { migrate } from './migrate/index.js';
-import { debugServer, schemaLooseEqual } from '../utils.js';
+import { debugServer } from '../utils.js';
 import { readUint16, readUint32, readUint64, writeUint64 } from '@saulx/utils';
+import { QueryType } from '../client/query/types.js';
+import { parseSchema, schemaLooseEqual } from '../schema.js';
 import { hash } from '@saulx/hash';
 export const SCHEMA_FILE = 'schema.json';
 export const WRITELOG_FILE = 'writelog.json';
@@ -36,6 +38,7 @@ export class DbWorker {
         this.channel = port1;
         this.worker = new Worker(workerPath, {
             workerData: {
+                isDbWorker: true,
                 channel: port2,
                 address,
             },
@@ -279,64 +282,26 @@ export class DbServer {
         return sortIndex;
     }
     setSchema(strictSchema, fromStart = false, transformFns) {
+        const parsedSchema = parseSchema(strictSchema);
         if (!fromStart && Object.keys(this.schema.types).length > 0) {
-            if (schemaLooseEqual(strictSchema, this.schema)) {
+            if (schemaLooseEqual(parsedSchema, this.schema)) {
                 return this.schema;
             }
             return this.migrateSchema(strictSchema, transformFns);
         }
-        const { lastId } = this.schema;
         this.schema = {
-            lastId,
-            ...strictSchema,
+            lastId: this.schema.lastId,
+            ...parsedSchema,
         };
-        if (strictSchema.props) {
-            this.schema.types ??= {};
-            const props = { ...strictSchema.props };
-            for (const key in props) {
-                const prop = props[key];
-                const propType = getPropType(prop);
-                let refProp;
-                if (propType === 'reference') {
-                    refProp = prop;
-                }
-                else if (propType === 'references') {
-                    refProp = prop.items;
-                }
-                if (refProp) {
-                    const type = this.schema.types[refProp.ref];
-                    const inverseKey = '_' + key;
-                    this.schema.types[refProp.ref] = {
-                        ...type,
-                        props: {
-                            ...type.props,
-                            [inverseKey]: {
-                                items: {
-                                    ref: '_root',
-                                    prop: key,
-                                },
-                            },
-                        },
-                    };
-                    refProp.prop = inverseKey;
-                }
-            }
-            // @ts-ignore This creates an internal type to use for root props
-            this.schema.types._root = {
-                id: 1,
-                props,
-            };
-            delete this.schema.props;
-        }
         for (const field in this.schema.types) {
             if (!('id' in this.schema.types[field])) {
                 this.schema.lastId++;
                 this.schema.types[field].id = this.schema.lastId;
             }
         }
+        const { hash: _, ...rest } = this.schema;
+        this.schema.hash = hash(rest);
         updateTypeDefs(this.schema, this.schemaTypesParsed, this.schemaTypesParsedById);
-        const { hash: _, ...schemaWithoutHash } = this.schema;
-        this.schema.hash = hash(schemaWithoutHash);
         if (!fromStart) {
             writeFile(join(this.fileSystemPath, SCHEMA_FILE), JSON.stringify(this.schema)).catch((err) => console.error('!!!', SCHEMA_FILE, err));
             let types = Object.keys(this.schemaTypesParsed);
@@ -352,7 +317,7 @@ export class DbServer {
                     console.error('Cannot update schema on selva', type.type, err, s[i]);
                 }
             }
-            if (strictSchema.props) {
+            if (strictSchema.props || strictSchema.types?._root) {
                 // insert a root node
                 // TODO fix this add it in schema at least
                 const data = [2, 1, 0, 0, 0, 1, 9, 1, 0, 0, 0, 7, 1, 0, 1];
@@ -480,10 +445,12 @@ export class DbServer {
         }
         else {
             const queryType = buf[0];
-            if (queryType == 2) {
-                const s = 13 + readUint16(buf, 11);
+            if (queryType == QueryType.default) {
+                // TODO: make a function for this!
+                const s = 14 + readUint16(buf, 11);
                 const sortLen = readUint16(buf, s);
                 if (sortLen) {
+                    // make function for this
                     const typeId = readUint16(buf, 1);
                     const sort = buf.slice(s + 2, s + 2 + sortLen);
                     const field = sort[1];

package/dist/src/server/migrate/index.d.ts

@@ -1,5 +1,4 @@
 import { StrictSchema } from '@based/schema';
-import './worker.js';
 import { DbServer } from '../index.js';
 type TransformFn = (node: Record<string, any>) => Record<string, any> | [string, Record<string, any>];
 export type TransformFns = Record<string, TransformFn>;

package/dist/src/server/migrate/index.js

@@ -3,7 +3,6 @@ import { dirname, join } from 'path';
 import { tmpdir } from 'os';
 import { Worker, MessageChannel, receiveMessageOnPort, } from 'node:worker_threads';
 import native from '../../native.js';
-import './worker.js';
 import { destructureCsmtKey, foreachDirtyBlock, specialBlock } from '../tree.js';
 import { SCHEMA_FILE } from '../index.js';
 import { fileURLToPath } from 'url';
@@ -58,6 +57,7 @@ export const migrate = async (fromDbServer, toSchema, transform) => {
     atomics[0] = 1;
     const worker = new Worker(workerPath, {
         workerData: {
+            isDbMigrateWorker: true,
             from: fromAddress,
             to: toAddress,
             fromSchema,

package/dist/src/server/migrate/worker.js

@@ -6,7 +6,7 @@ import { isTypedArray } from 'node:util/types';
 if (isMainThread) {
     console.warn('running worker.ts in mainthread');
 }
-else {
+else if (workerData?.isDbMigrateWorker) {
     const { from, to, fromSchema, toSchema, channel, atomics, transformFns } = workerData;
     const fromCtx = native.externalFromInt(from);
     const toCtx = native.externalFromInt(to);
@@ -114,4 +114,7 @@ else {
         Atomics.wait(atomics, 0, 0);
     }
 }
+else {
+    console.info('incorrect worker db migrate');
+}
 //# sourceMappingURL=worker.js.map

package/dist/src/server/start.d.ts

@@ -1,5 +1,4 @@
 import { DbServer } from './index.js';
-import './worker.js';
 export declare function start(db: DbServer, opts: {
     clean?: boolean;
     hosted?: boolean;

package/dist/src/server/start.js

@@ -6,7 +6,6 @@ import { hashEq } from './csmt/index.js';
 import { foreachBlock, initCsmt, makeCsmtKey } from './tree.js';
 import { availableParallelism } from 'node:os';
 import exitHook from 'exit-hook';
-import './worker.js';
 import { save } from './save.js';
 import { DEFAULT_BLOCK_CAPACITY } from '@based/schema/def';
 import { bufToHex, hexToBuf } from '@saulx/utils';

package/dist/src/server/worker.js

@@ -1,9 +1,9 @@
 import { isMainThread, receiveMessageOnPort, workerData, } from 'node:worker_threads';
 import native from '../native.js';
 if (isMainThread) {
-    console.warn('running query worker.ts in mainthread');
+    console.warn('running query worker.ts in mainthread - incorrect');
 }
-else {
+else if (workerData?.isDbWorker) {
     let { address, channel } = workerData;
     let dbCtx = native.externalFromInt(address);
     native.workerCtxInit();
@@ -32,4 +32,7 @@ else {
         handleMsg(msg.message);
     }
 }
+else {
+    console.info('incorrect worker db query');
+}
 //# sourceMappingURL=worker.js.map

package/dist/src/utils.d.ts

@@ -1,21 +1,5 @@
 import { DbServer } from './server/index.js';
-import { BasedDbQuery } from './client/query/BasedDbQuery.js';
-import { OnError } from './client/query/subscription/types.js';
-import { StrictSchema } from '@based/schema';
 export declare const DECODER: TextDecoder;
 export declare const ENCODER: TextEncoder;
 export declare const debugMode: (target: any, getInfo?: any) => void;
 export declare const debugServer: (server: DbServer) => void;
-export declare const schemaLooseEqual: (a: any, b: any, key?: string) => boolean;
-export declare const getDefaultHooks: (server: DbServer, subInterval?: number) => {
-    subscribe(q: BasedDbQuery, onData: (res: Uint8Array) => void, onError: OnError): () => void;
-    setSchema(schema: StrictSchema, fromStart: boolean): Promise<StrictSchema & {
-        lastId: number;
-        hash?: number;
-    }>;
-    flushModify(buf: Uint8Array): Promise<{
-        offsets: Record<number, number>;
-        dbWriteTime: number;
-    }>;
-    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
-};

package/dist/src/utils.js

@@ -43,97 +43,4 @@ export const debugMode = (target, getInfo = null) => {
     }
 };
 export const debugServer = (server) => debugMode(server, () => `p: ${server.processingQueries} m: ${server.modifyQueue.length} q: ${server.queryQueue.size}`);
-const exclude = new Set(['id', 'lastId', 'hash']);
-export const schemaLooseEqual = (a, b, key) => {
-    if (a === b) {
-        return true;
-    }
-    const typeofA = typeof a;
-    if (typeofA !== 'object') {
-        return exclude.has(key);
-    }
-    const typeofB = typeof b;
-    if (typeofA !== typeofB) {
-        return exclude.has(key);
-    }
-    if (a === null || b === null) {
-        return false;
-    }
-    if (a.constructor !== b.constructor) {
-        return false;
-    }
-    if (Array.isArray(a)) {
-        let i = a.length;
-        if (i !== b.length) {
-            return false;
-        }
-        while (i--) {
-            if (!schemaLooseEqual(a[i], b[i])) {
-                return false;
-            }
-        }
-    }
-    else {
-        for (const k in a) {
-            if (!schemaLooseEqual(a[k], b[k], k)) {
-                return false;
-            }
-        }
-        for (const k in b) {
-            if (k in a) {
-                continue;
-            }
-            if (!schemaLooseEqual(a[k], b[k], k)) {
-                return false;
-            }
-        }
-    }
-    return true;
-};
-export const getDefaultHooks = (server, subInterval = 200) => {
-    return {
-        subscribe(q, onData, onError) {
-            let timer;
-            let killed = false;
-            const poll = async () => {
-                const res = await server.getQueryBuf(q.buffer);
-                if (killed) {
-                    return;
-                }
-                if (res.byteLength >= 8) {
-                    onData(res);
-                }
-                else if (res.byteLength === 1 && res[0] === 0) {
-                    console.info('schema mismatch, should resolve after update');
-                    // ignore update and stop polling
-                    return;
-                }
-                else {
-                    onError(new Error('unexpected error'));
-                }
-                timer = setTimeout(poll, subInterval);
-            };
-            poll();
-            return () => {
-                clearTimeout(timer);
-                killed = true;
-            };
-        },
-        setSchema(schema, fromStart) {
-            return Promise.resolve(server.setSchema(schema, fromStart));
-        },
-        flushModify(buf) {
-            const d = performance.now();
-            const offsets = server.modify(buf);
-            const dbWriteTime = performance.now() - d;
-            return Promise.resolve({
-                offsets,
-                dbWriteTime,
-            });
-        },
-        getQueryBuf(buf) {
-            return Promise.resolve(server.getQueryBuf(buf));
-        },
-    };
-};
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",

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

@@ -1,3 +0,0 @@
-import { QueryDef } from './types.js';
-import { DbClient } from '../index.js';
-export declare function defToBuffer(db: DbClient, def: QueryDef): Uint8Array[];