@based/db 0.0.69 → 0.0.70

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

@@ -11,6 +11,7 @@ import { writeString } from './string.js';
 import { writeText } from './text.js';
 import { writeJson } from './json.js';
 import { writeAlias } from './alias.js';
+import { getByPath } from '@saulx/utils';
 const appendCreate = (ctx, schema, obj, res, unsafe) => {
     const len = ctx.len;
     let err = modify(ctx, res, obj, schema, CREATE, schema.tree, true, unsafe);
@@ -26,6 +27,9 @@ const appendCreate = (ctx, schema, obj, res, unsafe) => {
     if (schema.createTs) {
         const createTs = Date.now();
         for (const prop of schema.createTs) {
+            if (getByPath(obj, prop.path) !== undefined) {
+                continue;
+            }
             if (ctx.lastMain === -1) {
                 let mainLenU32 = schema.mainLen;
                 setCursor(ctx, schema, prop.prop, MICRO_BUFFER, res.tmpId, CREATE);

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

@@ -5,6 +5,7 @@ import { modify } from './modify.js';
 import { ModifyState } from './ModifyRes.js';
 import { RANGE_ERR, UPDATE } from './types.js';
 import { appendFixedValue } from './fixed.js';
+import { getByPath } from '@saulx/utils';
 const appendUpdate = (ctx, def, obj, res, overwrite) => {
     const err = modify(ctx, res, obj, def, UPDATE, def.tree, overwrite);
     if (err) {
@@ -13,6 +14,9 @@ const appendUpdate = (ctx, def, obj, res, overwrite) => {
     if (def.updateTs) {
         const updateTs = Date.now();
         for (const prop of def.updateTs) {
+            if (getByPath(obj, prop.path) !== undefined) {
+                continue;
+            }
             if (ctx.mergeMain) {
                 ctx.mergeMain.push(prop, updateTs);
                 ctx.mergeMainSize += prop.len + 4;

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

@@ -7,6 +7,7 @@ import { foreachDirtyBlock } from '../blocks.js';
 import { fileURLToPath } from 'url';
 import { setNativeSchema, setSchemaOnServer, writeSchemaFile, } from '../schema.js';
 import { setToAwake, waitUntilSleeping } from './utils.js';
+import { serialize } from '@based/schema';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const workerPath = join(__dirname, 'worker.js');
@@ -74,8 +75,14 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
             isDbMigrateWorker: true,
             from: fromAddress,
             to: toAddress,
-            fromSchema,
-            toSchema,
+            fromSchema: serialize(fromSchema, {
+                stripMetaInformation: true,
+                stripTransform: true,
+            }),
+            toSchema: serialize(toSchema, {
+                stripMetaInformation: true,
+                stripTransform: true,
+            }),
             channel: port2,
             workerState,
             transformFns,
@@ -83,9 +90,12 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
         transferList: [port2],
     });
     // handle?
-    worker.on('error', (err) => {
-        killed = true;
-        console.error(`Error in migration ${err.message}`);
+    const errorPromise = new Promise((resolve) => {
+        worker.once('error', (err) => {
+            killed = true;
+            console.error(`Error in migration ${err.message}, aborting migration`);
+            resolve();
+        });
     });
     // Block handling
     let i = 0;
@@ -107,7 +117,7 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
         const leafData = rangesToMigrate[i++];
         port1.postMessage(leafData);
         setToAwake(workerState, true);
-        await waitUntilSleeping(workerState);
+        await Promise.race([errorPromise, waitUntilSleeping(workerState)]);
         // exec queued modifies
         server.activeReaders--;
         server.onQueryEnd();
@@ -156,7 +166,11 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
         return;
     }
     native.membarSyncRead();
-    await save(server, { forceFullDump: true, skipDirtyCheck: true, skipMigrationCheck: true });
+    await save(server, {
+        forceFullDump: true,
+        skipDirtyCheck: true,
+        skipMigrationCheck: true,
+    });
     await writeSchemaFile(server, toSchema);
     server.migrating = 0;
     process.nextTick(() => server.emit('schema', server.schema));

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

@@ -6,6 +6,7 @@ import { isTypedArray } from 'node:util/types';
 import { setSchemaOnServer } from '../schema.js';
 import { setToSleep } from './utils.js';
 import { setLocalClientSchema } from '../../client/setLocalClientSchema.js';
+import { deSerialize } from '@based/schema';
 if (isMainThread) {
     console.warn('running worker.ts in mainthread');
 }
@@ -41,80 +42,87 @@ else if (workerData?.isDbMigrateWorker) {
     };
     fromDb.server.dbCtxExternal = fromCtx;
     toDb.server.dbCtxExternal = toCtx;
-    setSchemaOnServer(fromDb.server, fromSchema);
-    setSchemaOnServer(toDb.server, toSchema);
+    setSchemaOnServer(fromDb.server, deSerialize(fromSchema));
+    setSchemaOnServer(toDb.server, deSerialize(toSchema));
     setLocalClientSchema(fromDb.client, fromDb.server.schema);
     setLocalClientSchema(toDb.client, toDb.server.schema);
-    const map = {};
-    for (const type in fromDb.server.schemaTypesParsed) {
-        const { id, props } = fromDb.server.schemaTypesParsed[type];
-        const include = Object.keys(props);
-        let i = include.length;
-        while (i--) {
-            const path = include[i];
-            if (props[path].typeIndex === REFERENCE ||
-                props[path].typeIndex === REFERENCES) {
-                include[i] = `${path}.id`;
-                if (props[path].edges) {
-                    for (const key in props[path].edges) {
-                        const prop = props[path].edges[key];
-                        if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
-                            include.push(`${path}.${key}.id`);
-                        }
-                        else {
-                            include.push(`${path}.${key}`);
+    try {
+        const map = {};
+        for (const type in fromDb.server.schemaTypesParsed) {
+            const { id, props } = fromDb.server.schemaTypesParsed[type];
+            const include = Object.keys(props);
+            let i = include.length;
+            while (i--) {
+                const path = include[i];
+                if (props[path].typeIndex === REFERENCE ||
+                    props[path].typeIndex === REFERENCES) {
+                    include[i] = `${path}.id`;
+                    if (props[path].edges) {
+                        for (const key in props[path].edges) {
+                            const prop = props[path].edges[key];
+                            if (prop.typeIndex === REFERENCE ||
+                                prop.typeIndex === REFERENCES) {
+                                include.push(`${path}.${key}.id`);
+                            }
+                            else {
+                                include.push(`${path}.${key}`);
+                            }
                         }
                     }
                 }
             }
+            map[id] = { type, include };
         }
-        map[id] = { type, include };
-    }
-    for (const type in transformFns) {
-        const fnOrNull = transformFns[type];
-        transformFns[type] = eval(`(${fnOrNull})`);
-    }
-    while (true) {
-        let msg;
-        while ((msg = receiveMessageOnPort(channel))) {
-            const leafData = msg.message;
-            const { type, include } = map[leafData.typeId];
-            const typeTransformFn = transformFns[type];
-            if (typeTransformFn) {
-                const nodes = fromDb
-                    .query(type)
-                    .include(include)
-                    .range(leafData.start - 1, leafData.end)
-                    ._getSync(fromCtx);
-                for (const node of nodes) {
-                    const res = typeTransformFn(node);
-                    if (res === null) {
-                        continue;
-                    }
-                    if (Array.isArray(res)) {
-                        toDb.create(res[0], res[1] || node, { unsafe: true });
-                    }
-                    else {
-                        toDb.create(type, res || node, { unsafe: true });
+        for (const type in transformFns) {
+            const fnOrNull = transformFns[type];
+            transformFns[type] = eval(`(${fnOrNull})`);
+        }
+        while (true) {
+            let msg;
+            while ((msg = receiveMessageOnPort(channel))) {
+                const leafData = msg.message;
+                const { type, include } = map[leafData.typeId];
+                const typeTransformFn = transformFns[type];
+                if (typeTransformFn) {
+                    const nodes = fromDb
+                        .query(type)
+                        .include(include)
+                        .range(leafData.start - 1, leafData.end)
+                        ._getSync(fromCtx);
+                    for (const node of nodes) {
+                        const res = typeTransformFn(node);
+                        if (res === null) {
+                            continue;
+                        }
+                        if (Array.isArray(res)) {
+                            toDb.create(res[0], res[1] || node, { unsafe: true });
+                        }
+                        else {
+                            toDb.create(type, res || node, { unsafe: true });
+                        }
                     }
                 }
-            }
-            else if (type in toDb.server.schemaTypesParsed) {
-                const nodes = fromDb
-                    .query(type)
-                    .include(include)
-                    .range(leafData.start - 1, leafData.end)
-                    ._getSync(fromCtx);
-                for (const node of nodes) {
-                    toDb.create(type, node, { unsafe: true });
+                else if (type in toDb.server.schemaTypesParsed) {
+                    const nodes = fromDb
+                        .query(type)
+                        .include(include)
+                        .range(leafData.start - 1, leafData.end)
+                        ._getSync(fromCtx);
+                    for (const node of nodes) {
+                        toDb.create(type, node, { unsafe: true });
+                    }
                 }
             }
+            await toDb.drain();
+            native.membarSyncWrite();
+            // WE ARE ONLY GOING TO SEND { type: lastNodeId }
+            channel.postMessage(cp(toDb.server.schemaTypesParsed));
+            setToSleep(workerState);
         }
-        await toDb.drain();
-        native.membarSyncWrite();
-        // WE ARE ONLY GOING TO SEND { type: lastNodeId }
-        channel.postMessage(cp(toDb.server.schemaTypesParsed));
-        setToSleep(workerState);
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
     }
 }
 else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.69",
+  "version": "0.0.70",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -39,7 +39,7 @@
     "basedDbNative.cjs"
   ],
   "dependencies": {
-    "@based/schema": "5.0.0-alpha.25",
+    "@based/schema": "5.0.0-alpha.26",
     "@saulx/hash": "^3.0.0",
     "@saulx/utils": "^6.7.2",
     "exit-hook": "^4.0.0",
@@ -56,6 +56,7 @@
     "axios": "^1.7.9",
     "rimraf": "^3.0.2",
     "tar": "^7.4.3",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "fs-extra": "^11.1.1"
   }
 }