@based/db 0.0.61 → 0.0.63

package/dist/src/client/query/BasedDbQuery.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 { wait } from '@saulx/utils';
 import { displayTarget } from './display.js';
 import picocolors from 'picocolors';
 export class QueryBranch {
@@ -305,9 +306,6 @@ export class BasedDbQuery extends QueryBranch {
                 }
             }
         }
-        // const def = createQueryDef(db, QueryDefType.Root, target, skipValidation)
-        // def.schemaChecksum = db.schema?.hash || 0
-        //  def: QueryDef
         super(db);
         this.db = db;
         this.skipValidation = skipValidation;
@@ -340,17 +338,13 @@ export class BasedDbQuery extends QueryBranch {
         const res = await this.db.hooks.getQueryBuf(buf);
         if (res.byteLength === 1) {
             if (res[0] === 0) {
-                if (this.def && this.db.schema?.hash !== this.def.schemaChecksum) {
-                    this.reset();
-                    this.db.emit('info', 'query get schema mismatch - awaiting new schema');
-                    await this.db.once('schema');
-                    return this.#getInternal(resolve, reject);
-                }
-                else {
-                    this.db.emit('info', 'query get schema mismatch - got the same already');
-                    this.reset();
-                    return this.#getInternal(resolve, reject);
+                this.reset();
+                this.db.emit('info', 'query get schema mismatch - awaiting new schema (max 15s)');
+                const ok = await Promise.race([wait(15e3), this.db.once('schema')]);
+                if (!ok) {
+                    reject(new Error('schema mismath'));
                 }
+                return this.#getInternal(resolve, reject);
             }
             else {
                 reject(new Error('unexpected error'));

package/dist/src/server/DbWorker.js

@@ -1,6 +1,7 @@
 import { MessageChannel, Worker } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { readUint64 } from '@saulx/utils';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const workerPath = join(__dirname, 'worker.js');
@@ -60,6 +61,10 @@ export class DbWorker {
         return new Promise(this.callback);
     }
     getQueryBuf(buf) {
+        const schemaChecksum = readUint64(buf, buf.byteLength - 8);
+        if (schemaChecksum !== this.db.schema?.hash) {
+            return Promise.resolve(new Uint8Array(1));
+        }
         this.channel.postMessage(buf);
         return new Promise(this.callback);
     }

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

@@ -67,10 +67,10 @@ export declare class DbServer extends DbShared {
     getSortIndex(typeId: number, field: number, start: number, lang: number): SortIndex;
     createSortIndexBuffer(typeId: number, field: number, start: number, lang: number): SortIndex;
     setSchema(strictSchema: StrictSchema, transformFns?: TransformFns): Promise<SchemaChecksum>;
-    modify(buf: Uint8Array): Record<number, number> | null;
-    addToQueryQueue(resolve: any, buf: any): void;
+    modify(bufWithHash: Uint8Array): Record<number, number> | null;
+    addToQueryQueue(resolve: any, buf: any): Promise<Uint8Array>;
     getQueryBuf(buf: Uint8Array, fromQueue?: boolean): Promise<Uint8Array>;
-    onQueryEnd(): void;
+    onQueryEnd(): any;
     stop(noSave?: boolean): Promise<void>;
     destroy(): Promise<void>;
 }

package/dist/src/server/index.js

@@ -242,14 +242,13 @@ export class DbServer extends DbShared {
         });
         return schema.hash;
     }
-    modify(buf) {
-        const schemaHash = readUint64(buf, 0);
-        // if !schema
+    modify(bufWithHash) {
+        const schemaHash = readUint64(bufWithHash, 0);
         if (schemaHash !== this.schema?.hash) {
             this.emit('info', 'Schema mismatch in modify');
             return null;
         }
-        buf = buf.subarray(8);
+        const buf = bufWithHash.subarray(8);
         const offsets = {};
         const dataLen = readUint32(buf, buf.length - 4);
         let typesSize = readUint16(buf, dataLen);
@@ -277,7 +276,7 @@ export class DbServer extends DbShared {
             offsets[typeId] = offset;
         }
         if (this.processingQueries) {
-            this.modifyQueue.push(new Uint8Array(buf));
+            this.modifyQueue.push(new Uint8Array(bufWithHash));
         }
         else {
             this.#modify(buf);
@@ -334,6 +333,11 @@ export class DbServer extends DbShared {
             resolve(new Error('Query queue exceeded'));
             return;
         }
+        // TODO should we check here as well? Already will check in DbWorker
+        const schemaChecksum = readUint64(buf, buf.byteLength - 8);
+        if (schemaChecksum !== this.schema?.hash) {
+            return Promise.resolve(new Uint8Array(1));
+        }
         this.queryQueue.set(resolve, buf);
     }
     getQueryBuf(buf, fromQueue = false) {
@@ -341,10 +345,6 @@ export class DbServer extends DbShared {
             console.error('Db is stopped - trying to query', buf.byteLength);
             return Promise.resolve(new Uint8Array(8));
         }
-        const schemaChecksum = readUint64(buf, buf.byteLength - 8);
-        if (schemaChecksum !== this.schema?.hash) {
-            return Promise.resolve(new Uint8Array(1));
-        }
         if (this.modifyQueue.length) {
             return new Promise((resolve) => {
                 this.addToQueryQueue(resolve, buf);
@@ -393,7 +393,13 @@ export class DbServer extends DbShared {
             if (this.modifyQueue.length) {
                 const modifyQueue = this.modifyQueue;
                 this.modifyQueue = [];
-                for (const buf of modifyQueue) {
+                for (const bufWithHash of modifyQueue) {
+                    const schemaHash = readUint64(bufWithHash, 0);
+                    if (schemaHash !== this.schema?.hash) {
+                        this.emit('info', 'Schema mismatch in modify');
+                        return null;
+                    }
+                    const buf = bufWithHash.subarray(8);
                     this.#modify(buf);
                 }
             }
@@ -437,13 +443,15 @@ export class DbServer extends DbShared {
     }
     async destroy() {
         await this.stop(true);
-        await rm(this.fileSystemPath, { recursive: true }).catch((err) => {
-            // console.warn(
-            //   'Error removing dump folder',
-            //   this.fileSystemPath,
-            //   err.message,
-            // ),
-        });
+        if (this.fileSystemPath) {
+            await rm(this.fileSystemPath, { recursive: true }).catch((err) => {
+                // console.warn(
+                //   'Error removing dump folder',
+                //   this.fileSystemPath,
+                //   err.message,
+                // ),
+            });
+        }
     }
 }
 //# sourceMappingURL=index.js.map

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

@@ -55,8 +55,7 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
         return;
     }
     setSchemaOnServer(tmpDb.server, toSchema);
-    // await writeSchemaFile(this, toSchema)
-    await setNativeSchema(tmpDb.server, toSchema);
+    setNativeSchema(tmpDb.server, toSchema);
     if (abort()) {
         await tmpDb.destroy();
         return;

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

@@ -13,6 +13,7 @@ else if (workerData?.isDbMigrateWorker) {
     const { from, to, fromSchema, toSchema, channel, workerState, transformFns } = workerData;
     const fromCtx = native.externalFromInt(from);
     const toCtx = native.externalFromInt(to);
+    native.workerCtxInit();
     const fromDb = new BasedDb({ path: null });
     const toDb = new BasedDb({ path: null });
     const cp = (obj) => {

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

@@ -3,5 +3,5 @@ import { DbSchema } from '../schema.js';
 import { StrictSchema } from '@based/schema';
 export declare const setSchemaOnServer: (server: DbServer, schema: DbSchema) => void;
 export declare const writeSchemaFile: (server: DbServer, schema: DbSchema) => Promise<void>;
-export declare const setNativeSchema: (server: DbServer, schema: DbSchema) => Promise<void>;
+export declare const setNativeSchema: (server: DbServer, schema: DbSchema) => void;
 export declare const strictSchemaToDbSchema: (schema: StrictSchema) => DbSchema;

package/dist/src/server/schema.js

@@ -22,7 +22,7 @@ export const writeSchemaFile = async (server, schema) => {
         throw new Error(`Error writing schema to a file path ${schemaFilePath}}`);
     }
 };
-export const setNativeSchema = async (server, schema) => {
+export const setNativeSchema = (server, schema) => {
     const types = Object.keys(server.schemaTypesParsed);
     const s = schemaToSelvaBuffer(server.schemaTypesParsed);
     for (let i = 0; i < s.length; i++) {

package/package.json

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