@based/db 0.1.3-alpha.1 → 0.1.3

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

@@ -70,11 +70,24 @@ const ensureAggregate = (def) => {
         };
     }
 };
-export const groupBy = (def, field, StepInput) => {
+export const groupBy = (q, field, StepInput) => {
+    const def = q.def;
     const fieldDef = def.schema.props[field];
     if (!fieldDef) {
         aggregationFieldDoesNotExist(def, field);
     }
+    const groupByPropHook = fieldDef.hooks?.groupBy;
+    if (groupByPropHook) {
+        fieldDef.hooks.groupBy = null;
+        groupByPropHook(q, field);
+        fieldDef.hooks.groupBy = groupByPropHook;
+    }
+    const groupByHook = def.schema.hooks?.groupBy;
+    if (groupByHook) {
+        def.schema.hooks.groupBy = null;
+        groupByHook(q, field);
+        def.schema.hooks.groupBy = groupByHook;
+    }
     ensureAggregate(def);
     if (!def.aggregate.groupBy) {
         def.aggregate.size += 12;
@@ -113,10 +126,11 @@ export const groupBy = (def, field, StepInput) => {
 };
 export const addAggregate = (query, type, fields, option) => {
     const def = query.def;
-    def.schema.hooks?.aggregate?.(def, new Set(fields));
+    let hookFields;
     ensureAggregate(def);
-    if (option?.mode)
+    if (option?.mode) {
         def.aggregate.option = option;
+    }
     const aggregates = def.aggregate.aggregates;
     for (const field of fields) {
         const fieldDef = type === AggregateType.COUNT
@@ -135,6 +149,10 @@ export const addAggregate = (query, type, fields, option) => {
         if (!fieldDef) {
             aggregationFieldDoesNotExist(def, field);
         }
+        if (fieldDef.hooks?.aggregate) {
+            hookFields ??= new Set(fields);
+            fieldDef.hooks.aggregate(query, hookFields);
+        }
         if (!aggregates.get(fieldDef.prop)) {
             aggregates.set(fieldDef.prop, []);
             def.aggregate.size += 3;
@@ -158,6 +176,9 @@ export const addAggregate = (query, type, fields, option) => {
         // needs to add an extra field WRITE TO
         def.aggregate.size += 8;
     }
+    if (def.schema.hooks?.aggregate) {
+        def.schema.hooks.aggregate(query, hookFields || new Set(fields));
+    }
 };
 export const isRootCountOnly = (def, filterSize) => {
     if (filterSize != 0) {

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

@@ -8,16 +8,29 @@ const normalizeNeedle = (s) => {
 };
 export const convertFilter = (query, field, operator, value, opts) => {
     const def = query.def;
-    const filterHook = def.schema.hooks?.filter;
+    const propHooks = def.schema.props[field]?.hooks;
+    const hooks = def.schema.hooks;
+    const propFilterHook = propHooks?.filter;
+    const filterHook = hooks?.filter;
+    if (propFilterHook) {
+        propHooks.filter = null;
+        if (typeof operator === 'boolean') {
+            propFilterHook(query, field, '=', operator);
+        }
+        else {
+            propFilterHook(query, field, operator, value);
+        }
+        propHooks.filter = propFilterHook;
+    }
     if (filterHook) {
-        def.schema.hooks.filter = null;
+        hooks.filter = null;
         if (typeof operator === 'boolean') {
             filterHook(query, field, '=', operator);
         }
         else {
             filterHook(query, field, operator, value);
         }
-        def.schema.hooks.filter = filterHook;
+        hooks.filter = filterHook;
     }
     if (operator === undefined) {
         operator = '=';

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

@@ -54,7 +54,7 @@ export declare const VECTOR_DOT_PRODUCT = 0;
 export declare const VECTOR_MANHATTAN_DIST = 1;
 export declare const VECTOR_COSTINE_SIMILARITY = 2;
 export declare const VECTOR_EUCLIDEAN_DIST = 3;
-export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 0 | 1 | 3 | 2;
+export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 1 | 0 | 3 | 2;
 export declare const toFilterCtx: (def: QueryDef, op: Operator, opts?: FilterOpts) => FilterCtx;
 export declare const operatorReverseMap: Record<OPERATOR, string>;
 export declare const ALIGNMENT_NOT_SET = 255;

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

@@ -16,7 +16,7 @@ export const include = (query, fields) => {
         }
         else if (typeof f === 'function') {
             f((field) => {
-                if (field[0] == '$') {
+                if (field[0] === '$') {
                     // @ts-ignore
                     const prop = query.def.target?.propDef?.edges[field];
                     if (prop &&
@@ -28,10 +28,7 @@ export const include = (query, fields) => {
                     throw new Error(`No edge reference or edge references field named "${field}"`);
                 }
                 else {
-                    const prop = field[0] == '$'
-                        ? // @ts-ignore
-                            query.def.target?.propDef?.edges[field]
-                        : query.def.props[field];
+                    const prop = query.def.props[field];
                     if (prop &&
                         (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
                         const refDef = createOrGetRefQueryDef(query.db, query.def, prop);

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

@@ -41,6 +41,13 @@ const createReaderPropDef = (p, locales, opts) => {
     }
     return readerPropDef;
 };
+const normalizeHookFn = (fn) => {
+    let src = fn.toString();
+    if (/^[a-zA-Z0-9_$]+\s*\(/.test(src)) {
+        src = 'function ' + src;
+    }
+    return src;
+};
 export const convertToReaderSchema = (q, locales) => {
     if (!locales) {
         locales = {};
@@ -100,7 +107,19 @@ export const convertToReaderSchema = (q, locales) => {
         }
     }
     else {
-        if (q.schema?.hooks?.read) {
+        if (q.schema?.propHooks?.read) {
+            let body = '';
+            for (const def of q.schema.propHooks.read) {
+                const target = `r.${def.path.join('.')}`;
+                body += `if(r.${def.path.join('?.')}!=null)${target}=(${normalizeHookFn(def.hooks.read)})(${target},r);`;
+            }
+            if (q.schema?.hooks?.read) {
+                body += `r=(${normalizeHookFn(q.schema.hooks.read)})(r);`;
+            }
+            body += `return r;`;
+            readerSchema.hook = new Function('r', body);
+        }
+        else if (q.schema?.hooks?.read) {
             readerSchema.hook = q.schema.hooks.read;
         }
         if (isRoot && q.search) {

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

@@ -73,6 +73,7 @@ export const search = (queryBranch, q, s) => {
         }
         s = x;
     }
+    let hookFields;
     for (const key in s) {
         let prop = def.props[key];
         let lang = def.lang.lang;
@@ -110,11 +111,18 @@ export const search = (queryBranch, q, s) => {
             field: prop.prop,
             start: prop.start ?? 0, // also need lang ofc if you have start
         });
+        const searchHook = prop.hooks?.search;
+        if (searchHook) {
+            hookFields ??= new Set(Object.keys(s));
+            prop.hooks.search = null;
+            searchHook(queryBranch, hookFields);
+            prop.hooks.search = searchHook;
+        }
     }
     const searchHook = def.schema.hooks?.search;
     if (searchHook) {
         def.schema.hooks.search = null;
-        searchHook(queryBranch, new Set(Object.keys(s)));
+        searchHook(queryBranch, hookFields || new Set(Object.keys(s)));
         def.schema.hooks.search = searchHook;
     }
 };

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

@@ -1,4 +1,4 @@
 import type { LangCode } from '@based/schema';
 import { Ctx } from './modify/Ctx.js';
 export declare const write: (ctx: Ctx, value: string, offset: number, noCompression: boolean, lang?: LangCode) => number | null;
-export declare const compress: (str: string) => Uint8Array;
+export declare const stringCompress: (str: string) => Uint8Array;

package/dist/src/client/string.js

@@ -40,7 +40,7 @@ export const write = (ctx, value, offset, noCompression, lang) => {
         return l + 6;
     }
 };
-export const compress = (str) => {
+export const stringCompress = (str) => {
     const len = ENCODER.encode(str).byteLength;
     const tmpCompressBlock = getTmpBuffer(len * 3);
     const l = write({ array: tmpCompressBlock }, str, 0, false);

package/dist/src/hooks.d.ts

@@ -1,14 +1,11 @@
 import { StrictSchema, MigrateFns, DbSchema, SchemaChecksum } from '@based/schema';
-import { BasedDbQuery } from './client/query/BasedDbQuery.js';
+import type { BasedDbQuery } from './client/query/BasedDbQuery.js';
 import { OnClose, OnData, OnError } from './client/query/subscription/types.js';
 import { DbServer } from './server/index.js';
 export type DbClientHooks = {
     setSchema(schema: StrictSchema, transformFns?: MigrateFns): Promise<SchemaChecksum>;
-    flushModify(buf: Uint8Array): Promise<{
-        offsets: Record<number, number>;
-        dbWriteTime?: number;
-    }>;
-    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
+    flushModify(buf: Uint8Array): Promise<Uint8Array | null>;
+    getQueryBuf(buf: Uint8Array): ReturnType<DbServer['getQueryBuf']>;
     subscribe(q: BasedDbQuery, onData: (buf: Uint8Array) => ReturnType<OnData>, onError?: OnError): OnClose;
     subscribeSchema(cb: (schema: DbSchema) => void): void;
 };

package/dist/src/hooks.js

@@ -43,21 +43,14 @@ export const getDefaultHooks = (server, subInterval = 200) => {
             });
         },
         flushModify(buf) {
-            try {
-                const d = performance.now();
-                const offsets = server.modify(buf);
-                const dbWriteTime = performance.now() - d;
-                return Promise.resolve({
-                    offsets,
-                    dbWriteTime,
-                });
-            }
-            catch (e) {
-                return Promise.reject(e);
+            const res = server.modify(buf);
+            if (res instanceof Promise) {
+                return res.then((res) => res && new Uint8Array(res));
             }
+            return Promise.resolve(res && new Uint8Array(res));
         },
         getQueryBuf(buf) {
-            return Promise.resolve(server.getQueryBuf(buf));
+            return server.getQueryBuf(buf);
         },
     };
 };

package/dist/src/index.d.ts

@@ -1,11 +1,10 @@
-import { compress } from './client/string.js';
+import { stringCompress } from './client/string.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import { getDefaultHooks } from './hooks.js';
 import { Emitter } from './shared/Emitter.js';
 import { BasedDbOpts } from './types.js';
-import { decompress } from '@based/protocol/db-read';
-export { compress, decompress };
+export { stringCompress };
 export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
@@ -27,6 +26,7 @@ export declare class BasedDb extends Emitter {
     copy: DbClient['copy'];
     update: DbClient['update'];
     upsert: DbClient['upsert'];
+    insert: DbClient['insert'];
     delete: DbClient['delete'];
     expire: DbClient['expire'];
     query: DbClient['query'];

package/dist/src/index.js

@@ -1,12 +1,11 @@
-import { compress } from './client/string.js';
+import { stringCompress } from './client/string.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import { wait } from '@based/utils';
 import { debugMode, debugServer } from './utils.js';
 import { getDefaultHooks } from './hooks.js';
 import { Emitter } from './shared/Emitter.js';
-import { decompress } from '@based/protocol/db-read';
-export { compress, decompress };
+export { stringCompress };
 export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
@@ -61,6 +60,9 @@ export class BasedDb extends Emitter {
     upsert = function () {
         return this.client.upsert.apply(this.client, arguments);
     };
+    insert = function () {
+        return this.client.insert.apply(this.client, arguments);
+    };
     delete = function () {
         return this.client.delete.apply(this.client, arguments);
     };

package/dist/src/native.d.ts

@@ -4,7 +4,7 @@ declare const native: {
     destroyThreadCtx: (dbCtx: any, threadId: BigInt) => void;
     externalFromInt(address: BigInt): any;
     intFromExternal(external: any): BigInt;
-    modify: (data: Uint8Array, types: Uint8Array, dbCtx: any, dirtyBlocksOut: Float64Array) => any;
+    modify: (data: Uint8Array, dbCtx: any, dirtyBlocksOut: Float64Array) => number | null;
     getQueryBuf: (q: Uint8Array, dbCtx: any) => ArrayBuffer | null;
     start: () => any;
     stop: (dbCtx: any) => any;
@@ -13,8 +13,9 @@ declare const native: {
     loadCommon: (path: string, dbCtx: any) => void;
     loadBlock: (path: string, dbCtx: any) => void;
     delBlock: (dbCtx: any, typeId: number, block: number) => void;
-    updateSchemaType: (prefix: number, buf: Uint8Array, dbCtx: any) => any;
-    getTypeInfo: (typeId: number, dbCtx: any) => any;
+    setSchemaType: (prefix: number, buf: Uint8Array, dbCtx: any) => any;
+    setSchemaIds: (ids: Uint32Array, dbCtx: any) => any;
+    getSchemaIds: (dbCtx: any) => Uint32Array;
     getNodeRangeHash: (typeId: number, start: number, end: number, bufOut: Uint8Array, dbCtx: any) => any;
     createCompressor(): any;
     compressRaw: (compressor: any, buf: Uint8Array, offset: number, stringSize: number) => any;

package/dist/src/native.js

@@ -1,8 +1,6 @@
 // @ts-ignore
-import db from '../../basedDbNative.cjs';
-// Can't import these from utils or it would be a cyclic import.
-const DECODER = new TextDecoder('utf-8');
-const ENCODER = new TextEncoder();
+import db from '@based/db/native';
+import { DECODER, ENCODER } from '@based/utils';
 const selvaIoErrlog = new Uint8Array(256);
 var compressor = db.createCompressor();
 var decompressor = db.createDecompressor();
@@ -27,8 +25,8 @@ const native = {
     intFromExternal(external) {
         return db.intFromExternal(external);
     },
-    modify: (data, types, dbCtx, dirtyBlocksOut) => {
-        db.modify(data, types, dbCtx, dirtyBlocksOut);
+    modify: (data, dbCtx, dirtyBlocksOut) => {
+        return db.modify(data, dbCtx, dirtyBlocksOut);
     },
     getQueryBuf: (q, dbCtx) => {
         const x = db.getQueryBuf(dbCtx, q);
@@ -65,11 +63,14 @@ const native = {
     delBlock: (dbCtx, typeId, block) => {
         db.delBlock(dbCtx, typeId, block);
     },
-    updateSchemaType: (prefix, buf, dbCtx) => {
-        return db.updateSchema(prefix, buf, dbCtx);
+    setSchemaType: (prefix, buf, dbCtx) => {
+        return db.setSchemaType(prefix, buf, dbCtx);
     },
-    getTypeInfo: (typeId, dbCtx) => {
-        return db.getTypeInfo(typeId, dbCtx);
+    setSchemaIds: (ids, dbCtx) => {
+        return db.setSchemaIds(ids, dbCtx);
+    },
+    getSchemaIds: (dbCtx) => {
+        return new Uint32Array(db.getSchemaIds(dbCtx));
     },
     getNodeRangeHash: (typeId, start, end, bufOut, dbCtx) => {
         return db.getNodeRangeHash(typeId, start, end, bufOut, dbCtx);

package/dist/src/server/blocks.js

@@ -106,7 +106,7 @@ export async function unloadBlock(db, def, start) {
  */
 export function foreachBlock(db, def, cb, includeEmptyBlocks = false) {
     const step = def.blockCapacity;
-    const lastId = def.lastId || native.getTypeInfo(def.id, db.dbCtxExternal)[1];
+    const lastId = db.ids[def.id - 1];
     for (let start = 1; start <= lastId; start += step) {
         const end = start + step - 1;
         const hash = new Uint8Array(16);

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

@@ -24,13 +24,14 @@ export declare class DbServer extends DbShared {
     workers: QueryWorker[];
     availableWorkerIndex: number;
     activeReaders: number;
-    modifyQueue: Uint8Array[];
+    modifyQueue: Map<Function, Uint8Array>;
     queryQueue: Map<Function, Uint8Array>;
     stopped: boolean;
     unlistenExit: ReturnType<typeof exitHook>;
     saveIntervalInSeconds?: number;
     saveInterval?: NodeJS.Timeout;
     delayInMs?: number;
+    ids: Uint32Array;
     constructor({ path, debug, saveIntervalInSeconds, }: {
         path: string;
         debug?: boolean;
@@ -58,7 +59,7 @@ 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?: MigrateFns): Promise<SchemaChecksum>;
-    modify(payload: Uint8Array, skipParse?: boolean): Record<number, number> | null;
+    modify(payload: Uint8Array): Uint8Array | null | Promise<Uint8Array | null>;
     addToQueryQueue(resolve: any, buf: any): Promise<Uint8Array<ArrayBuffer>>;
     getQueryBuf(buf: Uint8Array, fromQueue?: boolean): Promise<Uint8Array>;
     onQueryEnd(): void;

package/dist/src/server/index.js

@@ -1,6 +1,6 @@
 import native from '../native.js';
 import { rm } from 'node:fs/promises';
-import { langCodesMap, strictSchemaToDbSchema } from '@based/schema';
+import { langCodesMap, strictSchemaToDbSchema, } from '@based/schema';
 import { ID_FIELD_DEF } from '@based/schema/def';
 import { start } from './start.js';
 import { destructureTreeKey, makeTreeKeyFromNodeId } from './tree.js';
@@ -8,7 +8,7 @@ import { save } from './save.js';
 import { setTimeout } from 'node:timers/promises';
 import { migrate } from './migrate/index.js';
 import { debugServer } from '../utils.js';
-import { readUint16, readUint32, readUint64, writeUint32 } from '@based/utils';
+import { readUint16, readUint64 } from '@based/utils';
 import { QueryType } from '../client/query/types.js';
 import { DbShared } from '../shared/DbBase.js';
 import { setNativeSchema, setSchemaOnServer, writeSchemaFile, } from './schema.js';
@@ -36,13 +36,14 @@ export class DbServer extends DbShared {
     workers = [];
     availableWorkerIndex = -1;
     activeReaders = 0; // processing queries or other DB reads
-    modifyQueue = [];
+    modifyQueue = new Map();
     queryQueue = new Map();
     stopped; // = true does not work
     unlistenExit;
     saveIntervalInSeconds;
     saveInterval;
     delayInMs;
+    ids;
     constructor({ path, debug, saveIntervalInSeconds, }) {
         super();
         this.fileSystemPath = path;
@@ -269,56 +270,31 @@ export class DbServer extends DbShared {
         });
         return schema.hash;
     }
-    modify(payload, skipParse) {
+    modify(payload) {
         const hash = readUint64(payload, 0);
-        const contentEnd = readUint32(payload, payload.byteLength - 4);
-        let result;
         if (this.schema?.hash !== hash) {
             this.emit('info', 'Schema mismatch in write');
             return null;
         }
-        if (!skipParse) {
-            result = {};
-            let i = payload.byteLength - 4;
-            while (i > contentEnd) {
-                const typeId = readUint16(payload, i - 6);
-                const count = readUint32(payload, i - 4);
-                const typeDef = this.schemaTypesParsedById[typeId];
-                if (!typeDef) {
-                    console.error('Missing typeDef, cancel write', { typeId, count });
-                    this.emit('info', 'Missing typeDef, cancel write');
-                    return null;
-                }
-                const lastId = typeDef.lastId ||
-                    native.getTypeInfo(typeDef.id, this.dbCtxExternal)[1];
-                // TODO replace this with Ctx.created
-                const offset = lastId;
-                // write the offset into payload for zig to use
-                writeUint32(payload, offset, i - 4);
-                result[typeId] = offset;
-                typeDef.lastId = lastId + count;
-                i -= 6;
-            }
-        }
-        const content = payload.subarray(8, contentEnd);
-        const offsets = payload.subarray(contentEnd, payload.byteLength - 4);
         if (this.activeReaders) {
-            this.modifyQueue.push(new Uint8Array(payload));
+            return new Promise((resolve) => {
+                this.modifyQueue.set(resolve, new Uint8Array(payload));
+            });
         }
-        else {
-            resizeModifyDirtyRanges(this);
-            native.modify(content, offsets, this.dbCtxExternal, this.modifyDirtyRanges);
-            for (const key of this.modifyDirtyRanges) {
-                if (key === 0)
-                    break;
-                this.dirtyRanges.add(key);
+        resizeModifyDirtyRanges(this);
+        const content = payload.subarray(8);
+        const len = native.modify(content, this.dbCtxExternal, this.modifyDirtyRanges);
+        for (const key of this.modifyDirtyRanges) {
+            if (key === 0) {
+                break;
             }
+            this.dirtyRanges.add(key);
         }
-        return result;
+        return content.subarray(0, len);
     }
     #expire() {
         resizeModifyDirtyRanges(this);
-        native.modify(emptyUint8Array, emptyUint8Array, this.dbCtxExternal, this.modifyDirtyRanges);
+        native.modify(emptyUint8Array, this.dbCtxExternal, this.modifyDirtyRanges);
         for (const key of this.modifyDirtyRanges) {
             if (key === 0)
                 break;
@@ -326,7 +302,7 @@ export class DbServer extends DbShared {
         }
     }
     addToQueryQueue(resolve, buf) {
-        if (this.queryQueue.size === 16777216) {
+        if (this.queryQueue.size === 16_777_216) {
             resolve(new Error('Query queue exceeded'));
             return;
         }
@@ -341,7 +317,7 @@ export class DbServer extends DbShared {
             console.error('Db is stopped - trying to query', buf.byteLength);
             return Promise.resolve(new Uint8Array(8));
         }
-        if (this.modifyQueue.length) {
+        if (this.modifyQueue.size) {
             return new Promise((resolve) => {
                 this.addToQueryQueue(resolve, buf);
             });
@@ -385,11 +361,11 @@ export class DbServer extends DbShared {
     }
     onQueryEnd() {
         if (this.activeReaders === 0) {
-            if (this.modifyQueue.length) {
+            if (this.modifyQueue.size) {
                 const modifyQueue = this.modifyQueue;
-                this.modifyQueue = [];
-                for (const payload of modifyQueue) {
-                    this.modify(payload, true);
+                this.modifyQueue = new Map();
+                for (const [resolve, payload] of modifyQueue) {
+                    resolve(this.modify(payload));
                 }
             }
             if (this.queryQueue.size) {

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

@@ -65,6 +65,10 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
     }
     let killed = false;
     const abort = () => {
+        if (server.stopped) {
+            console.info(`server stopped during migration ${migrationId}`);
+            return true;
+        }
         if (killed) {
             server.emit('info', `migration killed something went wrong ${migrationId}`);
             return true;

package/dist/src/server/resizeModifyDirtyRanges.js

@@ -2,7 +2,7 @@ export const resizeModifyDirtyRanges = (server) => {
     let maxNrChanges = 0;
     for (const typeId in server.schemaTypesParsedById) {
         const def = server.schemaTypesParsedById[typeId];
-        const lastId = def.lastId;
+        const lastId = server.ids[def.id - 1];
         const blockCapacity = def.blockCapacity;
         const tmp = lastId - +!(lastId % def.blockCapacity);
         const lastBlock = Math.ceil((((tmp / blockCapacity) | 0) * blockCapacity + 1) / blockCapacity);

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

@@ -9,7 +9,6 @@ export type Writelog = {
     ts: number;
     types: {
         [t: number]: {
-            lastId: number;
             blockCapacity: number;
         };
     };

package/dist/src/server/save.js

@@ -38,8 +38,8 @@ function makeWritelog(db, ts) {
     const types = {};
     const rangeDumps = {};
     for (const key in db.schemaTypesParsed) {
-        const { id, lastId, blockCapacity } = db.schemaTypesParsed[key];
-        types[id] = { lastId, blockCapacity };
+        const { id, blockCapacity } = db.schemaTypesParsed[key];
+        types[id] = { blockCapacity };
         rangeDumps[id] = [];
     }
     db.verifTree.foreachBlock((block) => {

package/dist/src/server/schema.js

@@ -13,6 +13,7 @@ export const setSchemaOnServer = (server, schema) => {
     server.schema = schema;
     server.schemaTypesParsed = schemaTypesParsed;
     server.schemaTypesParsedById = schemaTypesParsedById;
+    server.ids = native.getSchemaIds(server.dbCtxExternal);
 };
 export const writeSchemaFile = async (server, schema) => {
     if (server.fileSystemPath) {
@@ -34,15 +35,19 @@ export const writeSchemaFile = async (server, schema) => {
 export const setNativeSchema = (server, schema) => {
     const types = Object.keys(server.schemaTypesParsed);
     const s = schemaToSelvaBuffer(server.schemaTypesParsed);
+    let maxTid = 0;
     for (let i = 0; i < s.length; i++) {
         const type = server.schemaTypesParsed[types[i]];
+        maxTid = Math.max(maxTid, type.id);
         try {
-            native.updateSchemaType(type.id, new Uint8Array(s[i]), server.dbCtxExternal);
+            native.setSchemaType(type.id, new Uint8Array(s[i]), server.dbCtxExternal);
         }
         catch (err) {
             throw new Error(`Cannot update schema on selva (native) ${type.type} ${err.message}`);
         }
     }
+    // Init the last ids
+    native.setSchemaIds(new Uint32Array(maxTid), server.dbCtxExternal);
     // Insert a root node
     if (schema.types._root) {
         const tmpArr = new Uint8Array(new ArrayBuffer(1e3, { maxByteLength: 10e3 }));

package/dist/src/server/start.js

@@ -93,8 +93,6 @@ export async function start(db, opts) {
     db.verifTree = new VerifTree(db.schemaTypesParsed);
     for (const { typeId } of db.verifTree.types()) {
         const def = db.schemaTypesParsedById[typeId];
-        const [total, lastId] = native.getTypeInfo(def.id, db.dbCtxExternal);
-        def.lastId = writelog?.types[def.id]?.lastId || lastId;
         def.blockCapacity =
             writelog?.types[def.id]?.blockCapacity ||
                 def.blockCapacity ||

package/dist/src/shared/Emitter.d.ts

@@ -1,4 +1,4 @@
-import { DbSchema } from "@based/schema";
+import { DbSchema } from '@based/schema';
 export type EventMap = {
     schema: DbSchema;
     info: string;

package/dist/src/utils.d.ts

@@ -1,5 +1,3 @@
 import { DbServer } from './server/index.js';
-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;

package/dist/src/utils.js

@@ -1,7 +1,5 @@
 import { inspect } from 'node:util';
 import picocolors from 'picocolors';
-export const DECODER = new TextDecoder('utf-8');
-export const ENCODER = new TextEncoder();
 export const debugMode = (target, getInfo = null) => {
     const opts = { showHidden: false, depth: null, colors: true };
     const info = (v) => (typeof v === 'object' ? inspect(v, opts) : v);
@@ -42,5 +40,5 @@ export const debugMode = (target, getInfo = null) => {
         }
     }
 };
-export const debugServer = (server) => debugMode(server, () => `p: ${server.activeReaders} m: ${server.modifyQueue.length} q: ${server.queryQueue.size}`);
+export const debugServer = (server) => debugMode(server, () => `p: ${server.activeReaders} m: ${server.modifyQueue.size} q: ${server.queryQueue.size}`);
 //# sourceMappingURL=utils.js.map