@based/db 0.1.3 → 0.1.5

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

@@ -10,101 +10,104 @@ if (isMainThread) {
     console.warn('running worker.ts in mainthread');
 }
 else if (workerData?.isDbMigrateWorker) {
-    const { from, to, fromSchema, toSchema, channel, workerState, transformFns } = workerData;
-    const fromCtx = native.externalFromInt(from);
-    const toCtx = native.externalFromInt(to);
-    native.createThreadCtx(fromCtx, native.getThreadId());
-    native.createThreadCtx(toCtx, native.getThreadId());
-    const fromDb = new BasedDb({ path: null });
-    const toDb = new BasedDb({ path: null });
-    fromDb.server.dbCtxExternal = fromCtx;
-    toDb.server.dbCtxExternal = toCtx;
-    setSchemaOnServer(fromDb.server, deSerialize(fromSchema));
-    setSchemaOnServer(toDb.server, deSerialize(toSchema));
-    setLocalClientSchema(fromDb.client, fromDb.server.schema);
-    setLocalClientSchema(toDb.client, toDb.server.schema);
-    try {
-        const map = {};
-        for (const type in fromDb.server.schemaTypesParsed) {
-            const { id, props } = fromDb.server.schemaTypesParsed[type];
-            const include = [];
-            const includeRaw = [];
-            for (const path in props) {
-                const prop = props[path];
-                if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
-                    include.push(`${path}.id`);
-                    if (prop.edges) {
-                        for (const key in prop.edges) {
-                            const edge = prop.edges[key];
-                            if (edge.typeIndex === REFERENCE ||
-                                edge.typeIndex === REFERENCES) {
-                                include.push(`${path}.${key}.id`);
-                            }
-                            else if (edge.typeIndex === CARDINALITY) {
-                                includeRaw.push(`${path}.${key}`);
-                            }
-                            else {
-                                include.push(`${path}.${key}`);
+    ;
+    (async () => {
+        const { from, to, fromSchema, toSchema, channel, workerState, transformFns, } = workerData;
+        const fromCtx = native.externalFromInt(from);
+        const toCtx = native.externalFromInt(to);
+        native.createThreadCtx(fromCtx, native.getThreadId());
+        native.createThreadCtx(toCtx, native.getThreadId());
+        const fromDb = new BasedDb({ path: null });
+        const toDb = new BasedDb({ path: null });
+        fromDb.server.dbCtxExternal = fromCtx;
+        toDb.server.dbCtxExternal = toCtx;
+        setSchemaOnServer(fromDb.server, deSerialize(fromSchema));
+        setSchemaOnServer(toDb.server, deSerialize(toSchema));
+        setLocalClientSchema(fromDb.client, fromDb.server.schema);
+        setLocalClientSchema(toDb.client, toDb.server.schema);
+        try {
+            const map = {};
+            for (const type in fromDb.server.schemaTypesParsed) {
+                const { id, props } = fromDb.server.schemaTypesParsed[type];
+                const include = [];
+                const includeRaw = [];
+                for (const path in props) {
+                    const prop = props[path];
+                    if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
+                        include.push(`${path}.id`);
+                        if (prop.edges) {
+                            for (const key in prop.edges) {
+                                const edge = prop.edges[key];
+                                if (edge.typeIndex === REFERENCE ||
+                                    edge.typeIndex === REFERENCES) {
+                                    include.push(`${path}.${key}.id`);
+                                }
+                                else if (edge.typeIndex === CARDINALITY) {
+                                    includeRaw.push(`${path}.${key}`);
+                                }
+                                else {
+                                    include.push(`${path}.${key}`);
+                                }
                             }
                         }
                     }
+                    else if (prop.typeIndex === CARDINALITY) {
+                        includeRaw.push(path);
+                    }
+                    else {
+                        include.push(path);
+                    }
                 }
-                else if (prop.typeIndex === CARDINALITY) {
-                    includeRaw.push(path);
-                }
-                else {
-                    include.push(path);
-                }
+                map[id] = { type, include, includeRaw };
             }
-            map[id] = { type, include, includeRaw };
-        }
-        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, includeRaw } = map[leafData.typeId];
-                const typeTransformFn = transformFns[type];
-                const query = fromDb
-                    .query(type)
-                    .range(leafData.start - 1, leafData.end)
-                    .include(include);
-                for (const rawProp of includeRaw) {
-                    query.include(rawProp, { raw: true });
-                }
-                const nodes = query._getSync(fromCtx);
-                if (typeTransformFn) {
-                    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, includeRaw } = map[leafData.typeId];
+                    const typeTransformFn = transformFns[type];
+                    const query = fromDb
+                        .query(type)
+                        .range(leafData.start - 1, leafData.end)
+                        .include(include);
+                    for (const rawProp of includeRaw) {
+                        query.include(rawProp, { raw: true });
+                    }
+                    const nodes = query._getSync(fromCtx);
+                    if (typeTransformFn) {
+                        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) {
-                    for (const node of nodes) {
-                        toDb.create(type, node, { unsafe: true });
+                    else if (type in toDb.server.schemaTypesParsed) {
+                        for (const node of nodes) {
+                            toDb.create(type, node, { unsafe: true });
+                        }
                     }
                 }
+                await toDb.drain();
+                native.membarSyncWrite();
+                setToSleep(workerState);
             }
-            await toDb.drain();
-            native.membarSyncWrite();
-            setToSleep(workerState);
         }
-    }
-    catch (e) {
-        console.error(e);
-        throw e;
-    }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+    })();
 }
 else {
     console.info('incorrect worker db migrate');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "main": "./dist/src/index.js",
   "scripts": {