@based/db 0.0.71 → 0.1.1

package/dist/src/client/index.js

@@ -1,23 +1,24 @@
 import { parse } from '@based/schema';
-import { create } from './modify/create.js';
-import { flushBuffer, makeFlushIsReady, ModifyCtx, startDrain, } from './flushModify.js';
 import { BasedDbQuery } from './query/BasedDbQuery.js';
-import { ModifyState } from './modify/ModifyRes.js';
-import { upsert } from './modify/upsert.js';
-import { update } from './modify/update.js';
-import { deleteFn } from './modify/delete.js';
-import { expire } from './modify/expire.js';
 import { debugMode } from '../utils.js';
 import { DbShared } from '../shared/DbBase.js';
 import { setLocalClientSchema } from './setLocalClientSchema.js';
+import { create } from './modify/create/index.js';
+import { Ctx } from './modify/Ctx.js';
+import { update } from './modify/update/index.js';
+import { del } from './modify/delete/index.js';
+import { expire } from './modify/expire/index.js';
+import { cancel, drain, schedule } from './modify/drain.js';
+import { upsert } from './modify/upsert/index.js';
 export class DbClient extends DbShared {
     constructor({ hooks, maxModifySize = 100 * 1e3 * 1e3, flushTime = 0, debug, }) {
         super();
         this.hooks = hooks;
         this.maxModifySize = maxModifySize;
-        this.modifyCtx = new ModifyCtx(this);
+        this.modifyCtx = new Ctx(0, new Uint8Array(new ArrayBuffer(Math.min(1e3, maxModifySize), {
+            maxByteLength: maxModifySize,
+        })));
         this.flushTime = flushTime;
-        makeFlushIsReady(this);
         if (debug) {
             debugMode(this);
         }
@@ -29,8 +30,6 @@ export class DbClient extends DbShared {
     hooks;
     // modify
     flushTime;
-    flushReady;
-    flushIsReady;
     writeTime = 0;
     isDraining = false;
     modifyCtx;
@@ -92,87 +91,77 @@ export class DbClient extends DbShared {
         if (type === undefined) {
             return new BasedDbQuery(this, '_root', 1);
         }
-        // this is now double resolve
-        if (Array.isArray(id)) {
-            let i = id.length;
-            while (i--) {
-                if (typeof id[i] === 'object') {
-                    if (id[i] instanceof ModifyState) {
-                        // @ts-ignore
-                        id[i] = id[i].tmpId;
-                    }
-                    else {
-                        // it's get by alias
-                    }
-                }
-            }
-        }
-        else if (id instanceof Uint32Array) {
-            // all good
-        }
-        else if (typeof id === 'object') {
-            if (id instanceof ModifyState) {
-                id = id.tmpId;
-            }
-            else {
-                // it's get by alias
-            }
-        }
         return new BasedDbQuery(this, type, id);
     }
     update(typeOrValue, idOverwriteOrValue, value, opts) {
-        if (typeof typeOrValue === 'string') {
-            if (typeof idOverwriteOrValue === 'object') {
-                if (idOverwriteOrValue instanceof ModifyState) {
-                    return update(this, typeOrValue, idOverwriteOrValue.tmpId, value, opts);
-                }
-                if ('id' in idOverwriteOrValue) {
-                    const { id, ...props } = idOverwriteOrValue;
-                    return this.update(typeOrValue, id, props, opts);
+        if (typeof typeOrValue !== 'string') {
+            return this.update('_root', 1, typeOrValue, idOverwriteOrValue);
+        }
+        if (typeof idOverwriteOrValue === 'object') {
+            if ('then' in idOverwriteOrValue &&
+                typeof idOverwriteOrValue.then === 'function') {
+                // @ts-ignore
+                if (idOverwriteOrValue.id) {
+                    // @ts-ignore
+                    return this.update(typeOrValue, idOverwriteOrValue.id, value, opts);
                 }
+                return idOverwriteOrValue.then((id) => {
+                    return this.update(typeOrValue, id, value, opts);
+                });
+            }
+            if ('id' in idOverwriteOrValue) {
+                const { id, ...props } = idOverwriteOrValue;
+                return this.update(typeOrValue, id, props, opts);
             }
-            return update(this, typeOrValue, idOverwriteOrValue, value, opts);
         }
-        // else it is rootProps
-        return update(this, '_root', 1, typeOrValue, idOverwriteOrValue);
+        return update(this, typeOrValue, idOverwriteOrValue, value, opts);
     }
     upsert(type, obj, opts) {
         return upsert(this, type, obj, opts);
     }
     delete(type, id) {
-        return deleteFn(this, type, typeof id === 'number' ? id : id.tmpId);
+        if (typeof id === 'object' &&
+            id !== null &&
+            'then' in id &&
+            typeof id.then === 'function') {
+            // @ts-ignore
+            if (id.id) {
+                // @ts-ignore
+                id = id.id;
+            }
+            else {
+                return id.then((id) => this.delete(type, id));
+            }
+        }
+        // @ts-ignore
+        return del(this, type, id);
     }
     expire(type, id, seconds) {
-        return expire(this, type, typeof id === 'number' ? id : id.tmpId, seconds);
+        return expire(this, type, id, seconds);
     }
     destroy() {
         this.stop();
         delete this.listeners;
-        this.modifyCtx.db = null; // Make sure we don't have a circular ref and leak mem
     }
     stop() {
         for (const [, { onClose }] of this.subs) {
             onClose();
         }
         this.subs.clear();
-        this.modifyCtx.len = 0;
+        cancel(this.modifyCtx, Error('Db stopped - in-flight modify cancelled'));
     }
     // For more advanced / internal usage - use isModified instead for most cases
     async drain() {
         if (this.upserting.size) {
             await Promise.all(Array.from(this.upserting).map(([, { p }]) => p));
         }
-        await flushBuffer(this);
+        await drain(this, this.modifyCtx);
         const t = this.writeTime;
         this.writeTime = 0;
         return t;
     }
-    async isModified() {
-        if (!this.isDraining) {
-            startDrain(this);
-        }
-        await this.flushIsReady;
-        return;
+    isModified() {
+        return schedule(this, this.modifyCtx);
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/src/client/modify/Ctx.d.ts

@@ -0,0 +1,38 @@
+import type { SchemaTypeDef, PropDef } from '@based/schema/def';
+import type { LangCode } from '@based/schema';
+import { type ModifyOp } from './types.js';
+import type { Tmp } from './Tmp.js';
+export declare class Ctx {
+    constructor(schemaChecksum: number, array: Uint8Array<ArrayBufferLike>);
+    id: number;
+    start: number;
+    index: number;
+    schema: SchemaTypeDef;
+    array: Uint8Array<ArrayBufferLike>;
+    max: number;
+    size: number;
+    unsafe?: boolean;
+    overwrite?: boolean;
+    operation: ModifyOp;
+    main: Map<PropDef, any>;
+    draining: Promise<void>;
+    scheduled: Promise<void>;
+    created: Record<number, number>;
+    locale: LangCode;
+    sort: number;
+    sortText: number;
+    defaults: number;
+    cursor: {
+        id?: number;
+        type?: number;
+        prop?: number;
+        main?: number;
+        operation?: ModifyOp;
+    };
+    batch: {
+        promises?: Tmp[];
+        offsets?: Record<number, number>;
+        ready?: boolean;
+        error?: Error;
+    };
+}

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

@@ -0,0 +1,30 @@
+import { writeUint64 } from '@based/utils';
+export class Ctx {
+    constructor(schemaChecksum, array) {
+        this.array = array;
+        this.max = array.buffer.maxByteLength - 4; // dataLen
+        this.size = array.buffer.byteLength - this.max;
+        writeUint64(array, schemaChecksum, 0);
+    }
+    id;
+    start;
+    index = 8;
+    schema;
+    array;
+    max;
+    size;
+    unsafe;
+    overwrite;
+    operation;
+    main = new Map();
+    draining;
+    scheduled;
+    created = {}; // <typeId, count
+    locale;
+    sort = 0;
+    sortText = 0;
+    defaults = 0;
+    cursor = {};
+    batch = {};
+}
+//# sourceMappingURL=Ctx.js.map

package/dist/src/client/modify/Tmp.d.ts

@@ -0,0 +1,19 @@
+import { Ctx } from './Ctx.js';
+export declare const resolveTmp: (tmp: Tmp) => void;
+export declare const rejectTmp: (tmp: Tmp) => void;
+export declare class Tmp implements Promise<number> {
+    #private;
+    constructor(ctx: Ctx, id?: number);
+    get [Symbol.toStringTag](): string;
+    get error(): Error;
+    get id(): number;
+    type: number;
+    tmpId: number;
+    batch: Ctx['batch'];
+    promise?: Promise<number>;
+    resolve?: (value: number | PromiseLike<number>) => void;
+    reject?: (reason?: any) => void;
+    then<Res1 = number, Res2 = never>(onfulfilled?: ((value: number) => Res1 | PromiseLike<Res1>) | null, onrejected?: ((reason: any) => Res2 | PromiseLike<Res2>) | null): Promise<Res1 | Res2>;
+    catch<Res = never>(onrejected?: ((reason: any) => Res | PromiseLike<Res>) | null): Promise<number | Res>;
+    finally(onfinally?: (() => void) | null): Promise<number>;
+}

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

@@ -0,0 +1,67 @@
+const promisify = (tmp) => {
+    if (!tmp.promise) {
+        const id = tmp.id;
+        if (id) {
+            tmp.promise = Promise.resolve(id);
+        }
+        else {
+            tmp.promise = new Promise((resolve, reject) => {
+                tmp.resolve = resolve;
+                tmp.reject = reject;
+                tmp.batch.promises ??= [];
+                tmp.batch.promises.push(tmp);
+            });
+        }
+    }
+    return tmp.promise;
+};
+export const resolveTmp = (tmp) => {
+    tmp.resolve(tmp.id);
+};
+export const rejectTmp = (tmp) => tmp.reject(tmp.error);
+export class Tmp {
+    constructor(ctx, id) {
+        this.type = ctx.cursor.type;
+        this.tmpId = ctx.id;
+        this.batch = ctx.batch;
+        this.#id = id;
+    }
+    get [Symbol.toStringTag]() {
+        return 'ModifyPromise';
+    }
+    #id;
+    get error() {
+        if (!this.batch.ready) {
+            return;
+        }
+        return this.batch.error;
+    }
+    get id() {
+        if (!this.batch.ready) {
+            return;
+        }
+        if (!this.#id) {
+            if (this.batch.offsets) {
+                const offset = this.batch.offsets[this.type];
+                this.#id = this.tmpId + offset;
+            }
+        }
+        return this.#id;
+    }
+    type;
+    tmpId;
+    batch;
+    promise;
+    resolve;
+    reject;
+    then(onfulfilled, onrejected) {
+        return promisify(this).then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return promisify(this).catch(onrejected);
+    }
+    finally(onfinally) {
+        return promisify(this).finally(onfinally);
+    }
+}
+//# sourceMappingURL=Tmp.js.map

package/dist/src/client/modify/create/index.d.ts

@@ -0,0 +1,6 @@
+import { SchemaTypeDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+import { DbClient } from '../../../index.js';
+import { ModifyOpts } from '../types.js';
+export declare const writeCreate: (ctx: Ctx, schema: SchemaTypeDef, payload: any, opts: ModifyOpts) => void;
+export declare function create(db: DbClient, type: string, payload: any, opts: ModifyOpts): Promise<number>;

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

@@ -0,0 +1,191 @@
+import { TEXT } from '@based/schema/def';
+import { writeObject } from '../props/object.js';
+import { reserve } from '../resize.js';
+import { FULL_CURSOR_SIZE, PROP_CURSOR_SIZE, writeMainCursor, writeNodeCursor, writeTypeCursor, } from '../cursor.js';
+import { getByPath, writeUint16 } from '@based/utils';
+import { writeMainBuffer, writeMainValue } from '../props/main.js';
+import { Tmp } from '../Tmp.js';
+import { schedule } from '../drain.js';
+import { ADD_EMPTY_SORT, ADD_EMPTY_SORT_TEXT, CREATE, } from '../types.js';
+import { inverseLangMap, langCodesMap } from '@based/schema';
+import { writeSeparate } from '../props/separate.js';
+import { writeString } from '../props/string.js';
+import { writeU8 } from '../uint.js';
+import { getValidSchema, validatePayload } from '../validate.js';
+import { handleError } from '../error.js';
+const writeDefaults = (ctx, payload) => {
+    if (!ctx.schema.hasSeperateDefaults) {
+        return;
+    }
+    if (ctx.defaults !== ctx.schema.separateDefaults.props.size) {
+        for (const def of ctx.schema.separateDefaults.props.values()) {
+            const type = def.typeIndex;
+            if (ctx.schema.separateDefaults.bufferTmp[def.prop] === 0) {
+                writeSeparate(ctx, def, def.default);
+                continue;
+            }
+            if (type !== TEXT) {
+                continue;
+            }
+            const buf = ctx.schema.separateTextSort.bufferTmp;
+            const amount = ctx.schema.localeSize + 1;
+            const len = amount * ctx.schema.separateTextSort.props.length;
+            for (const sortDef of ctx.schema.separateTextSort.props) {
+                const index = sortDef.prop * amount;
+                if (buf[index] === 0) {
+                    continue;
+                }
+                for (let i = index + 1; i < len + index; i++) {
+                    const lang = buf[i];
+                    if (lang === 0) {
+                        continue;
+                    }
+                    const val = def.default[inverseLangMap.get(lang)];
+                    if (val !== undefined) {
+                        writeString(ctx, def, val, lang);
+                    }
+                }
+            }
+        }
+    }
+};
+const writeSortable = (ctx) => {
+    if (!ctx.schema.hasSeperateSort) {
+        return;
+    }
+    if (ctx.sort !== ctx.schema.separateSort.size) {
+        reserve(ctx, 3);
+        writeU8(ctx, ADD_EMPTY_SORT);
+        const index = ctx.index;
+        ctx.index += 2;
+        const start = ctx.index;
+        for (const def of ctx.schema.separateSort.props) {
+            if (ctx.schema.separateSort.bufferTmp[def.prop] === 0) {
+                reserve(ctx, 1);
+                writeU8(ctx, def.prop);
+            }
+        }
+        writeUint16(ctx.array, ctx.index - start, index);
+    }
+};
+const writeSortableText = (ctx) => {
+    if (!ctx.schema.hasSeperateTextSort) {
+        return;
+    }
+    if (ctx.sortText !== ctx.schema.separateTextSort.size) {
+        reserve(ctx, 3);
+        writeU8(ctx, ADD_EMPTY_SORT_TEXT);
+        const index = ctx.index;
+        ctx.index += 2;
+        const start = ctx.index;
+        const amount = ctx.schema.localeSize + 1;
+        const len = amount * ctx.schema.separateTextSort.props.length;
+        const buf = ctx.schema.separateTextSort.bufferTmp;
+        for (const def of ctx.schema.separateTextSort.props) {
+            const index = def.prop * amount;
+            if (buf[index] === 0) {
+                continue;
+            }
+            reserve(ctx, 2);
+            writeU8(ctx, def.prop);
+            writeU8(ctx, buf[index]);
+            for (let i = index + 1; i < len + index; i++) {
+                const lang = buf[i];
+                if (lang === 0) {
+                    continue;
+                }
+                reserve(ctx, 1);
+                writeU8(ctx, lang);
+            }
+        }
+        writeUint16(ctx.array, ctx.index - start, index);
+        if (ctx.sortText) {
+            buf.set(ctx.schema.separateTextSort.buffer, 0);
+        }
+    }
+};
+const writeCreateTs = (ctx, payload) => {
+    if (!ctx.schema.createTs) {
+        return;
+    }
+    let createTs;
+    for (const prop of ctx.schema.createTs) {
+        if (getByPath(payload, prop.path) !== undefined) {
+            continue;
+        }
+        createTs ??= Date.now();
+        writeMainValue(ctx, prop, createTs);
+    }
+};
+export const writeCreate = (ctx, schema, payload, opts) => {
+    validatePayload(payload);
+    validatePayload(schema);
+    if (schema.hooks?.create) {
+        payload = schema.hooks.create(payload) || payload;
+    }
+    if (payload.id) {
+        if (!opts?.unsafe) {
+            throw 'Invalid payload. "id" not allowed';
+        }
+        ctx.id = payload.id;
+    }
+    else {
+        if (!(schema.id in ctx.created)) {
+            ctx.created[schema.id] = 0;
+            ctx.max -= 6;
+            ctx.size -= 6;
+        }
+        ctx.id = ctx.created[schema.id] + 1;
+    }
+    if (ctx.defaults) {
+        ctx.defaults = 0;
+        schema.separateDefaults?.bufferTmp.fill(0);
+    }
+    if (ctx.sort) {
+        ctx.sort = 0;
+        schema.separateSort.bufferTmp.set(schema.separateSort.buffer);
+    }
+    if (ctx.sortText) {
+        ctx.sortText = 0;
+        schema.separateTextSort.bufferTmp.set(schema.separateTextSort.buffer);
+    }
+    ctx.schema = schema;
+    ctx.operation = CREATE;
+    ctx.overwrite = true;
+    ctx.unsafe = opts?.unsafe;
+    ctx.locale = opts?.locale && langCodesMap.get(opts.locale);
+    ctx.start = ctx.index;
+    reserve(ctx, FULL_CURSOR_SIZE);
+    writeTypeCursor(ctx);
+    writeNodeCursor(ctx);
+    const index = ctx.index;
+    writeObject(ctx, ctx.schema.tree, payload);
+    if (ctx.index === index || ctx.schema.mainLen === 0) {
+        reserve(ctx, PROP_CURSOR_SIZE);
+        writeMainCursor(ctx);
+    }
+    writeCreateTs(ctx, payload);
+    if (!ctx.cursor.main && !ctx.schema.mainEmptyAllZeroes) {
+        writeMainBuffer(ctx);
+    }
+    writeDefaults(ctx, payload);
+    writeSortable(ctx);
+    writeSortableText(ctx);
+    if (schema.id in ctx.created) {
+        ctx.created[schema.id]++;
+    }
+};
+export function create(db, type, payload, opts) {
+    const schema = getValidSchema(db, type);
+    const ctx = db.modifyCtx;
+    try {
+        writeCreate(ctx, schema, payload, opts);
+        const tmp = new Tmp(ctx);
+        schedule(db, ctx);
+        return tmp;
+    }
+    catch (e) {
+        return handleError(db, ctx, create, arguments, e);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/src/client/modify/create/mark.d.ts

@@ -0,0 +1,7 @@
+import { PropDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+import { LangCode } from '@based/schema';
+export declare const markString: (ctx: Ctx, def: PropDef) => void;
+export declare const markDefaults: (ctx: Ctx, def: PropDef, val: any) => void;
+export declare const markTextObj: (ctx: Ctx) => void;
+export declare const markTextValue: (ctx: Ctx, def: PropDef, locale: LangCode, textStringValue: boolean) => void;

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

@@ -0,0 +1,42 @@
+import { CREATE } from '../types.js';
+export const markString = (ctx, def) => {
+    if (ctx.operation === CREATE) {
+        ctx.schema.separateSort.bufferTmp[def.prop] = 2;
+        ctx.sort++;
+        if (ctx.schema.hasSeperateDefaults) {
+            ctx.schema.separateDefaults.bufferTmp[def.prop] = 1;
+            ctx.defaults++;
+        }
+    }
+};
+export const markDefaults = (ctx, def, val) => {
+    if (ctx.operation === CREATE &&
+        ctx.schema.hasSeperateDefaults &&
+        val !== null) {
+        if (!ctx.schema.separateDefaults.bufferTmp[def.prop]) {
+            ctx.schema.separateDefaults.bufferTmp[def.prop] = 1;
+            ctx.defaults++;
+        }
+    }
+};
+export const markTextObj = (ctx) => {
+    if (ctx.operation === CREATE && ctx.schema.hasSeperateDefaults) {
+        ctx.defaults++;
+    }
+};
+export const markTextValue = (ctx, def, locale, textStringValue) => {
+    if (ctx.operation === CREATE) {
+        const index = def.prop * (1 + ctx.schema.localeSize);
+        const langIndex = ctx.schema.separateTextSort.localeToIndex.get(locale);
+        ctx.schema.separateTextSort.bufferTmp[index] -= 1;
+        ctx.schema.separateTextSort.bufferTmp[index + langIndex] = 0;
+        ctx.sortText++;
+        if (ctx.schema.hasSeperateDefaults) {
+            ctx.schema.separateDefaults.bufferTmp[def.prop]++;
+            if (textStringValue) {
+                ctx.defaults++;
+            }
+        }
+    }
+};
+//# sourceMappingURL=mark.js.map

package/dist/src/client/modify/cursor.d.ts

@@ -0,0 +1,10 @@
+import { PropDef } from '@based/schema/def';
+import { Ctx } from './Ctx.js';
+export declare const TYPE_CURSOR_SIZE = 3;
+export declare const PROP_CURSOR_SIZE = 3;
+export declare const NODE_CURSOR_SIZE = 5;
+export declare const FULL_CURSOR_SIZE: number;
+export declare const writeTypeCursor: (ctx: Ctx) => void;
+export declare const writePropCursor: (ctx: Ctx, def: PropDef) => void;
+export declare const writeMainCursor: (ctx: Ctx) => void;
+export declare const writeNodeCursor: (ctx: Ctx) => void;

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

@@ -0,0 +1,48 @@
+import { MICRO_BUFFER } from '@based/schema/def';
+import { writeUint32 } from '@based/utils';
+import { SWITCH_TYPE, SWITCH_FIELD, CREATE, SWITCH_ID_CREATE, SWITCH_ID_UPDATE, } from './types.js';
+export const TYPE_CURSOR_SIZE = 3;
+export const PROP_CURSOR_SIZE = 3;
+export const NODE_CURSOR_SIZE = 5;
+export const FULL_CURSOR_SIZE = TYPE_CURSOR_SIZE + NODE_CURSOR_SIZE + PROP_CURSOR_SIZE;
+export const writeTypeCursor = (ctx) => {
+    if (ctx.schema.id !== ctx.cursor.type) {
+        ctx.array[ctx.index] = SWITCH_TYPE; // switch node type
+        ctx.array.set(ctx.schema.idUint8, ctx.index + 1);
+        ctx.index += 3;
+        ctx.cursor.type = ctx.schema.id;
+        ctx.cursor.main = null;
+        ctx.cursor.prop = null;
+        ctx.cursor.id = null;
+    }
+};
+export const writePropCursor = (ctx, def) => {
+    if (def.prop !== ctx.cursor.prop) {
+        ctx.array[ctx.index] = SWITCH_FIELD;
+        ctx.array[ctx.index + 1] = def.prop;
+        ctx.array[ctx.index + 2] = def.typeIndex;
+        ctx.index += 3;
+        ctx.cursor.prop = def.prop;
+    }
+};
+export const writeMainCursor = (ctx) => {
+    if (ctx.cursor.prop !== 0) {
+        ctx.array[ctx.index] = SWITCH_FIELD;
+        ctx.array[ctx.index + 1] = 0;
+        ctx.array[ctx.index + 2] = MICRO_BUFFER;
+        ctx.index += 3;
+        ctx.cursor.prop = 0;
+    }
+};
+export const writeNodeCursor = (ctx) => {
+    if (ctx.id !== ctx.cursor.id || ctx.operation !== ctx.cursor.operation) {
+        ctx.array[ctx.index] =
+            ctx.operation === CREATE ? SWITCH_ID_CREATE : SWITCH_ID_UPDATE; // swtch id
+        writeUint32(ctx.array, ctx.id, ctx.index + 1);
+        ctx.index += 5;
+        ctx.cursor.id = ctx.id;
+        ctx.cursor.main = null;
+        ctx.cursor.operation = ctx.operation;
+    }
+};
+//# sourceMappingURL=cursor.js.map

package/dist/src/client/modify/delete/index.d.ts

@@ -0,0 +1,2 @@
+import { DbClient } from '../../../index.js';
+export declare function del(db: DbClient, type: string, id: number): Promise<number>;

package/dist/src/client/modify/delete/index.js

@@ -0,0 +1,39 @@
+import { getValidSchema, validateId } from '../validate.js';
+import { FULL_CURSOR_SIZE, writeMainCursor, writeNodeCursor, writePropCursor, writeTypeCursor, } from '../cursor.js';
+import { reserve } from '../resize.js';
+import { DELETE_NODE, DELETE_SORT_INDEX, UPDATE } from '../types.js';
+import { writeU8 } from '../uint.js';
+import { handleError } from '../error.js';
+import { Tmp } from '../Tmp.js';
+import { schedule } from '../drain.js';
+export function del(db, type, id) {
+    const schema = getValidSchema(db, type);
+    const ctx = db.modifyCtx;
+    try {
+        if (schema.insertOnly) {
+            throw `This type is insertOnly`;
+        }
+        ctx.id = id;
+        ctx.start = ctx.index;
+        ctx.schema = schema;
+        ctx.operation = UPDATE;
+        validateId(id);
+        reserve(ctx, FULL_CURSOR_SIZE + 2 + schema.separate.length * 12); // 12 too much?
+        writeTypeCursor(ctx);
+        writeMainCursor(ctx);
+        writeNodeCursor(ctx);
+        writeU8(ctx, DELETE_SORT_INDEX);
+        for (const def of schema.separate) {
+            writePropCursor(ctx, def);
+            writeU8(ctx, DELETE_SORT_INDEX);
+        }
+        writeU8(ctx, DELETE_NODE);
+        const tmp = new Tmp(ctx, id);
+        schedule(db, ctx);
+        return tmp;
+    }
+    catch (e) {
+        return handleError(db, ctx, del, arguments, e);
+    }
+}
+//# sourceMappingURL=index.js.map