@based/db 0.0.1

package/dist/src/client/modify/references/reference.js

@@ -0,0 +1,92 @@
+import { ModifyError, ModifyState } from '../ModifyRes.js';
+import { setCursor } from '../setCursor.js';
+import { DELETE, RANGE_ERR } from '../types.js';
+import { getEdgeSize, writeEdges } from './edge.js';
+import { dbUpdateFromUpsert } from './references.js';
+function writeRef(id, ctx, schema, def, parentId, modifyOp, hasEdges) {
+    if (ctx.len + 16 > ctx.max) {
+        return RANGE_ERR;
+    }
+    ctx.markNodeDirty(ctx.db.schemaTypesParsed[def.inverseTypeName], id);
+    setCursor(ctx, schema, def.prop, parentId, modifyOp);
+    ctx.buf[ctx.len++] = modifyOp;
+    ctx.buf[ctx.len++] = hasEdges ? 1 : 0;
+    ctx.buf[ctx.len++] = id;
+    ctx.buf[ctx.len++] = id >>>= 8;
+    ctx.buf[ctx.len++] = id >>>= 8;
+    ctx.buf[ctx.len++] = id >>>= 8;
+}
+function singleReferenceEdges(ref, ctx, schema, def, parentId, modifyOp) {
+    let id = ref.id;
+    if (typeof id !== 'number') {
+        if (id instanceof ModifyState) {
+            if (id.error) {
+                return id.error;
+            }
+            id = id.tmpId;
+        }
+    }
+    if (id > 0) {
+        const edgesLen = def.edgesTotalLen || getEdgeSize(def, ref);
+        if (edgesLen === 0) {
+            return writeRef(id, ctx, schema, def, parentId, modifyOp, false);
+        }
+        let err = writeRef(id, ctx, schema, def, parentId, modifyOp, true);
+        if (err) {
+            return err;
+        }
+        if (ctx.len + 4 + edgesLen > ctx.max) {
+            return RANGE_ERR;
+        }
+        let sizepos = ctx.len;
+        ctx.len += 4;
+        err = writeEdges(def, ref, ctx);
+        if (err) {
+            return err;
+        }
+        let size = ctx.len - sizepos;
+        ctx.buf[sizepos++] = size;
+        ctx.buf[sizepos++] = size >>>= 8;
+        ctx.buf[sizepos++] = size >>>= 8;
+        ctx.buf[sizepos] = size >>>= 8;
+    }
+    else {
+        return new ModifyError(def, ref);
+    }
+}
+export function writeReference(value, ctx, schema, def, res, modifyOp) {
+    if (value === null) {
+        if (ctx.len + 11 > ctx.max) {
+            return RANGE_ERR;
+        }
+        setCursor(ctx, schema, def.prop, res.tmpId, modifyOp);
+        ctx.buf[ctx.len++] = DELETE;
+    }
+    else if (typeof value === 'number') {
+        return writeRef(value, ctx, schema, def, res.tmpId, modifyOp, false);
+    }
+    else if (value instanceof ModifyState) {
+        if (value.error) {
+            return value.error;
+        }
+        return writeRef(value.tmpId, ctx, schema, def, res.tmpId, modifyOp, false);
+    }
+    else if (typeof value === 'object' && value !== null) {
+        if (def.edges) {
+            return singleReferenceEdges(value, ctx, schema, def, res.tmpId, modifyOp);
+        }
+        else if (typeof value.id === 'number') {
+            return writeRef(value.id, ctx, schema, def, res.tmpId, modifyOp, false);
+        }
+        else if (typeof value.upsert === 'object' && value.upsert !== null) {
+            dbUpdateFromUpsert(ctx, schema, def, res, ctx.db.upsert(def.inverseTypeName, value.upsert));
+        }
+        else {
+            return new ModifyError(def, value);
+        }
+    }
+    else {
+        return new ModifyError(def, value);
+    }
+}
+//# sourceMappingURL=reference.js.map

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

@@ -0,0 +1,17 @@
+import { ModifyCtx } from '../../../index.js';
+import { PropDef, SchemaTypeDef } from '../../../server/schema/types.js';
+import { ModifyState } from '../ModifyRes.js';
+import { ModifyErr, ModifyOp } from '../types.js';
+export type RefModifyOpts = {
+    id?: number | ModifyState;
+    $index?: number;
+} & Record<`$${string}`, any>;
+export type RefModify = ModifyState | RefModifyOpts | number;
+export type Refs = RefModify[] | {
+    add?: RefModify[] | RefModify;
+    update?: RefModify[] | RefModify;
+    delete?: RefModify[] | RefModify;
+    upsert: RefModify[] | RefModify;
+};
+export declare function writeReferences(value: any, ctx: ModifyCtx, schema: SchemaTypeDef, def: PropDef, res: ModifyState, mod: ModifyOp): ModifyErr;
+export declare const dbUpdateFromUpsert: (ctx: ModifyCtx, schema: SchemaTypeDef, def: PropDef, res: ModifyState, promise: Promise<any>) => void;

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

@@ -0,0 +1,271 @@
+import { REFERENCES, } from '../../../server/schema/types.js';
+import { ModifyError, ModifyState } from '../ModifyRes.js';
+import { setCursor } from '../setCursor.js';
+import { DELETE, RANGE_ERR } from '../types.js';
+import { writeEdges } from './edge.js';
+export function writeReferences(value, ctx, schema, def, res, mod) {
+    if (typeof value !== 'object') {
+        return new ModifyError(def, value);
+    }
+    if (value === null) {
+        if (ctx.len + 11 > ctx.max) {
+            return RANGE_ERR;
+        }
+        setCursor(ctx, schema, def.prop, res.tmpId, mod);
+        ctx.buf[ctx.len++] = DELETE;
+        return;
+    }
+    if (Array.isArray(value)) {
+        return updateRefs(def, ctx, schema, mod, value, res.tmpId, 0);
+    }
+    for (const key in value) {
+        const val = value[key];
+        let err;
+        if (!Array.isArray(val)) {
+            err = new ModifyError(def, value);
+        }
+        else if (key === 'delete') {
+            err = deleteRefs(def, ctx, schema, mod, val, res.tmpId);
+        }
+        else if (key === 'add') {
+            err = updateRefs(def, ctx, schema, mod, val, res.tmpId, 1);
+        }
+        else if (key === 'upsert') {
+            dbUpdateFromUpsert(ctx, schema, def, res, Promise.all(val.map((val) => ctx.db.upsert(def.inverseTypeName, val))));
+        }
+        else {
+            err = new ModifyError(def, value);
+        }
+        if (err) {
+            return err;
+        }
+    }
+}
+export const dbUpdateFromUpsert = (ctx, schema, def, res, promise) => {
+    res.promises ??= [];
+    res.promises.push(promise.then((result) => {
+        let payload = {};
+        let i = 0;
+        for (; i < def.path.length - 1; i++) {
+            payload = payload[def.path[i]] = {};
+        }
+        payload[def.path[i]] = result;
+        return ctx.db.update(schema.type, res.tmpId, payload);
+    }));
+};
+function deleteRefs(def, ctx, schema, modifyOp, refs, parentId) {
+    let size = 4 * refs.length + 1;
+    if (ctx.len + 10 + size > ctx.max) {
+        return RANGE_ERR;
+    }
+    setCursor(ctx, schema, def.prop, parentId, modifyOp);
+    ctx.buf[ctx.len++] = modifyOp;
+    ctx.buf[ctx.len++] = size;
+    ctx.buf[ctx.len++] = size >>>= 8;
+    ctx.buf[ctx.len++] = size >>>= 8;
+    ctx.buf[ctx.len++] = size >>>= 8;
+    ctx.buf[ctx.len++] = 2;
+    for (let ref of refs) {
+        if (typeof ref === 'number') {
+            ctx.buf[ctx.len++] = ref;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+        }
+        else if (ref instanceof ModifyState) {
+            if (ref.error) {
+                return ref.error;
+            }
+            ref = ref.tmpId;
+            ctx.buf[ctx.len++] = ref;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+        }
+        else {
+            return new ModifyError(def, refs);
+        }
+    }
+}
+function updateRefs(def, ctx, schema, mod, refs, parentId, op) {
+    if (ctx.len + 19 + refs.length * 4 > ctx.max) {
+        return RANGE_ERR;
+    }
+    setCursor(ctx, schema, def.prop, parentId, mod);
+    const initpos = ctx.len;
+    const nrOrErr = putRefs(def, ctx, mod, refs, op);
+    if (nrOrErr) {
+        if (typeof nrOrErr === 'number') {
+            if (nrOrErr === refs.length) {
+                // reset
+                ctx.len = initpos;
+            }
+            else if (ctx.len + 2 > ctx.max) {
+                return RANGE_ERR;
+            }
+            else {
+                ctx.buf[ctx.len++] = 0;
+                ctx.buf[ctx.len++] = REFERENCES;
+            }
+            return appendRefs(def, ctx, mod, refs, op, nrOrErr);
+        }
+        return nrOrErr;
+    }
+}
+function appendRefs(def, ctx, modifyOp, refs, op, remaining) {
+    if (ctx.len + 10 > ctx.max) {
+        return RANGE_ERR;
+    }
+    const hasEdges = !!def.edges;
+    ctx.buf[ctx.len++] = modifyOp;
+    let i = refs.length - remaining;
+    let totalpos = ctx.len;
+    ctx.len += 4;
+    ctx.buf[ctx.len++] = i === 0 ? op : 1; // if it just did a PUT, it should ADD not overwrite the remaining
+    ctx.buf[ctx.len++] = remaining;
+    ctx.buf[ctx.len++] = remaining >>>= 8;
+    ctx.buf[ctx.len++] = remaining >>>= 8;
+    ctx.buf[ctx.len++] = remaining >>>= 8;
+    for (; i < refs.length; i++) {
+        const ref = refs[i];
+        let id;
+        let index;
+        if (typeof ref === 'object') {
+            if (ref instanceof ModifyState) {
+                if (ref.error) {
+                    return ref.error;
+                }
+                id = ref.tmpId;
+            }
+            else if (ref.id instanceof ModifyState) {
+                if (ref.id.error) {
+                    return ref.id.error;
+                }
+                id = ref.id.tmpId;
+                index = ref.$index;
+            }
+            else if (ref.id > 0) {
+                id = ref.id;
+                index = ref.$index;
+            }
+            else {
+                return new ModifyError(def, refs);
+            }
+        }
+        else if (ref > 0) {
+            id = ref;
+        }
+        else {
+            return new ModifyError(def, refs);
+        }
+        if (hasEdges) {
+            if (index === undefined) {
+                if (ctx.len + 9 > ctx.max) {
+                    return RANGE_ERR;
+                }
+                ctx.buf[ctx.len++] = 1;
+                ctx.buf[ctx.len++] = id;
+                ctx.buf[ctx.len++] = id >>>= 8;
+                ctx.buf[ctx.len++] = id >>>= 8;
+                ctx.buf[ctx.len++] = id >>>= 8;
+            }
+            else if (typeof index === 'number') {
+                if (ctx.len + 13 > ctx.max) {
+                    return RANGE_ERR;
+                }
+                ctx.buf[ctx.len++] = 2;
+                ctx.buf[ctx.len++] = id;
+                ctx.buf[ctx.len++] = id >>>= 8;
+                ctx.buf[ctx.len++] = id >>>= 8;
+                ctx.buf[ctx.len++] = id >>>= 8;
+                ctx.buf[ctx.len++] = index;
+                ctx.buf[ctx.len++] = index >>>= 8;
+                ctx.buf[ctx.len++] = index >>>= 8;
+                ctx.buf[ctx.len++] = index >>>= 8;
+            }
+            else {
+                return new ModifyError(def, refs);
+            }
+            let sizepos = ctx.len;
+            ctx.len += 4;
+            const err = writeEdges(def, ref, ctx);
+            if (err) {
+                return err;
+            }
+            let size = ctx.len - sizepos - 4;
+            ctx.buf[sizepos++] = size;
+            ctx.buf[sizepos++] = size >>>= 8;
+            ctx.buf[sizepos++] = size >>>= 8;
+            ctx.buf[sizepos] = size >>>= 8;
+        }
+        else if (index === undefined) {
+            if (ctx.len + 5 > ctx.max) {
+                return RANGE_ERR;
+            }
+            ctx.buf[ctx.len++] = 0;
+            ctx.buf[ctx.len++] = id;
+            ctx.buf[ctx.len++] = id >>>= 8;
+            ctx.buf[ctx.len++] = id >>>= 8;
+            ctx.buf[ctx.len++] = id >>>= 8;
+        }
+        else if (typeof index === 'number') {
+            if (ctx.len + 9 > ctx.max) {
+                return RANGE_ERR;
+            }
+            ctx.buf[ctx.len++] = 3;
+            ctx.buf[ctx.len++] = id;
+            ctx.buf[ctx.len++] = id >>>= 8;
+            ctx.buf[ctx.len++] = id >>>= 8;
+            ctx.buf[ctx.len++] = id >>>= 8;
+            ctx.buf[ctx.len++] = index;
+            ctx.buf[ctx.len++] = index >>>= 8;
+            ctx.buf[ctx.len++] = index >>>= 8;
+            ctx.buf[ctx.len++] = index >>>= 8;
+        }
+        else {
+            return new ModifyError(def, refs);
+        }
+        ctx.markNodeDirty(ctx.db.schemaTypesParsed[def.inverseTypeName], id);
+    }
+    let size = ctx.len - totalpos - 4;
+    ctx.buf[totalpos++] = size;
+    ctx.buf[totalpos++] = size >>>= 8;
+    ctx.buf[totalpos++] = size >>>= 8;
+    ctx.buf[totalpos] = size >>>= 8;
+}
+function putRefs(def, ctx, modifyOp, refs, op) {
+    let size = refs.length * 4 + 1;
+    ctx.buf[ctx.len++] = modifyOp;
+    ctx.buf[ctx.len++] = size;
+    ctx.buf[ctx.len++] = size >>>= 8;
+    ctx.buf[ctx.len++] = size >>>= 8;
+    ctx.buf[ctx.len++] = size >>>= 8;
+    ctx.buf[ctx.len++] = op === 0 ? 3 : 4;
+    ctx.len = (ctx.len + 3) & ~3;
+    let i = 0;
+    for (; i < refs.length; i++) {
+        let ref = refs[i];
+        if (typeof ref === 'number') {
+            ctx.buf[ctx.len++] = ref;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+        }
+        else if (ref instanceof ModifyState) {
+            if (ref.error) {
+                return ref.error;
+            }
+            ref = ref.tmpId;
+            ctx.buf[ctx.len++] = ref;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+            ctx.buf[ctx.len++] = ref >>>= 8;
+        }
+        else {
+            break;
+        }
+        ctx.markNodeDirty(ctx.db.schemaTypesParsed[def.inverseTypeName], ref);
+    }
+    return refs.length - i;
+}
+//# sourceMappingURL=references.js.map

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

@@ -0,0 +1,2 @@
+import { DbClient } from '../index.js';
+export declare const remove: (db: DbClient, type: string, id: number) => boolean;

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

@@ -0,0 +1,36 @@
+import { flushBuffer, startDrain } from '../operations.js';
+import { setCursor } from './setCursor.js';
+import { UPDATE } from './types.js';
+export const remove = (db, type, id) => {
+    const ctx = db.modifyCtx;
+    const schema = db.schemaTypesParsed[type];
+    const separate = schema.separate;
+    if (separate) {
+        const size = 12 + separate.length * 12;
+        if (ctx.len + size > ctx.max) {
+            flushBuffer(db);
+            return remove(db, type, id);
+        }
+        setCursor(ctx, schema, 0, id, UPDATE);
+        ctx.buf[ctx.len++] = 4;
+        for (const s of separate) {
+            setCursor(ctx, schema, s.prop, id, UPDATE);
+            ctx.buf[ctx.len++] = 4;
+        }
+        ctx.buf[ctx.len++] = 10;
+    }
+    else {
+        if (ctx.len + 12 > ctx.max) {
+            flushBuffer(db);
+            return remove(db, type, id);
+        }
+        setCursor(ctx, schema, 0, id, UPDATE);
+        ctx.buf[ctx.len++] = 4;
+        ctx.buf[ctx.len++] = 10;
+    }
+    if (!db.isDraining) {
+        startDrain(db);
+    }
+    return true;
+};
+//# sourceMappingURL=remove.js.map

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

@@ -0,0 +1,4 @@
+import { ModifyCtx } from '../../index.js';
+import { SchemaTypeDef } from '../../server/schema/types.js';
+import { ModifyOp } from './types.js';
+export declare const setCursor: (ctx: ModifyCtx, schema: SchemaTypeDef, field: number, id: number, modifyOp: ModifyOp, ignoreField?: boolean) => void;

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

@@ -0,0 +1,36 @@
+import { CREATE, SWITCH_FIELD, SWITCH_ID_CREATE, SWITCH_ID_UPDATE, SWITCH_TYPE, } from './types.js';
+export const setCursor = (ctx, schema, field, id, modifyOp, ignoreField) => {
+    const prefix0 = schema.idUint8[0];
+    const prefix1 = schema.idUint8[1];
+    if (ctx.prefix0 !== prefix0 || ctx.prefix1 !== prefix1) {
+        ctx.buf[ctx.len++] = SWITCH_TYPE; // switch node type
+        ctx.buf[ctx.len++] = prefix0; // type1
+        ctx.buf[ctx.len++] = prefix1; // type2
+        ctx.prefix0 = prefix0;
+        ctx.prefix1 = prefix1;
+        ctx.field = -1;
+        ctx.id = -1;
+        ctx.lastMain = -1;
+        if (modifyOp === CREATE) {
+            ctx.markTypeDirty(schema);
+        }
+    }
+    if (!ignoreField && ctx.field !== field) {
+        ctx.buf[ctx.len++] = SWITCH_FIELD; // switch field
+        ctx.buf[ctx.len++] = field; // actual field
+        // add start and len if its main
+        ctx.field = field;
+    }
+    if (ctx.id !== id) {
+        ctx.markNodeDirty(schema, id);
+        ctx.id = id;
+        ctx.lastMain = -1;
+        ctx.buf[ctx.len++] =
+            modifyOp === CREATE ? SWITCH_ID_CREATE : SWITCH_ID_UPDATE; // swtch id
+        ctx.buf[ctx.len++] = id;
+        ctx.buf[ctx.len++] = id >>>= 8;
+        ctx.buf[ctx.len++] = id >>>= 8;
+        ctx.buf[ctx.len++] = id >>>= 8;
+    }
+};
+//# sourceMappingURL=setCursor.js.map

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

@@ -0,0 +1,5 @@
+import { LangCode } from '@based/schema';
+import { ModifyCtx } from '../../index.js';
+import { SchemaTypeDef, PropDef } from '../../server/schema/types.js';
+import { ModifyOp, ModifyErr } from './types.js';
+export declare function writeString(lang: LangCode, value: string | null | Buffer, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -0,0 +1,56 @@
+import { CREATE, UPDATE, RANGE_ERR, DELETE, } from './types.js';
+import { ModifyError } from './ModifyRes.js';
+import { setCursor } from './setCursor.js';
+import { write } from '../string.js';
+// allow setting buffer in modify create for strings
+// add compression handling for main buffer
+// add compression handling for edge fields
+export function writeString(lang, value, ctx, def, t, parentId, modifyOp) {
+    const isBuffer = value instanceof Buffer;
+    if (typeof value !== 'string' && value !== null && !isBuffer) {
+        return new ModifyError(t, value);
+    }
+    const len = value?.length;
+    if (!len) {
+        if (modifyOp === UPDATE) {
+            if (ctx.len + 11 > ctx.max) {
+                return RANGE_ERR;
+            }
+            setCursor(ctx, def, t.prop, parentId, modifyOp);
+            ctx.buf[ctx.len++] = DELETE;
+        }
+    }
+    else {
+        let size = isBuffer
+            ? value.byteLength
+            : Buffer.byteLength(value, 'utf8') + 6;
+        if (ctx.len + 20 + size > ctx.max) {
+            // 5 compression size
+            return RANGE_ERR;
+        }
+        if (modifyOp === CREATE) {
+            def.stringPropsCurrent[t.prop] = 2;
+            ctx.hasStringField++;
+        }
+        setCursor(ctx, def, t.prop, parentId, modifyOp);
+        // TODO if buffer check if second byte is zero or one
+        // modOp | size u32 | stringprotocol | string
+        ctx.buf[ctx.len] = modifyOp;
+        ctx.len += 5;
+        if (isBuffer) {
+            ctx.buf.set(value, ctx.len);
+        }
+        else {
+            const isNoCompression = t.compression === 0;
+            // @ts-ignore stupid str
+            size = write(ctx.buf, value, ctx.len, isNoCompression, lang);
+        }
+        let sizepos = ctx.len + 1 - 5;
+        ctx.len += size;
+        ctx.buf[sizepos++] = size;
+        ctx.buf[sizepos++] = size >>>= 8;
+        ctx.buf[sizepos++] = size >>>= 8;
+        ctx.buf[sizepos] = size >>>= 8;
+    }
+}
+//# sourceMappingURL=string.js.map

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

@@ -0,0 +1,5 @@
+import { ModifyCtx } from '../../index.js';
+import { ModifyOp, ModifyErr } from './types.js';
+import { SchemaTypeDef, PropDef } from '../../server/schema/types.js';
+export declare function writeText(value: any, // TODO YOLO
+ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -0,0 +1,14 @@
+import { langCodesMap } from '@based/schema';
+import { writeString } from './string.js';
+export function writeText(value, // TODO YOLO
+ctx, def, t, parentId, modifyOp) {
+    for (const lang in value) {
+        const langCode = langCodesMap.get(lang) || langCodesMap.get('en'); // TODO use proper fallback
+        const s = value[lang];
+        const err = writeString(langCode, s, ctx, def, t, parentId, modifyOp);
+        if (err) {
+            return err;
+        }
+    }
+}
+//# sourceMappingURL=text.js.map

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

@@ -0,0 +1,14 @@
+import { ModifyError } from './ModifyRes.js';
+export declare const CREATE = 3;
+export declare const UPDATE = 6;
+export declare const DELETE = 11;
+export declare const MERGE_MAIN = 4;
+export declare const RANGE_ERR = 1;
+export declare const INCREMENT = 12;
+export declare const DECREMENT = 13;
+export declare const SWITCH_TYPE = 2;
+export declare const SWITCH_FIELD = 0;
+export declare const SWITCH_ID_CREATE = 9;
+export declare const SWITCH_ID_UPDATE = 1;
+export type ModifyErr = typeof RANGE_ERR | ModifyError | void;
+export type ModifyOp = typeof CREATE | typeof UPDATE | typeof INCREMENT;

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

@@ -0,0 +1,12 @@
+export const CREATE = 3;
+export const UPDATE = 6;
+export const DELETE = 11;
+export const MERGE_MAIN = 4;
+export const RANGE_ERR = 1;
+export const INCREMENT = 12;
+export const DECREMENT = 13;
+export const SWITCH_TYPE = 2;
+export const SWITCH_FIELD = 0;
+export const SWITCH_ID_CREATE = 9;
+export const SWITCH_ID_UPDATE = 1;
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,5 @@
+import { ModifyRes } from './ModifyRes.js';
+import { DbClient } from '../index.js';
+type Payload = Record<string, any>;
+export declare const update: (db: DbClient, type: string, id: number, obj: Payload, overwrite?: boolean) => ModifyRes;
+export {};

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

@@ -0,0 +1,80 @@
+import { startDrain, flushBuffer } from '../operations.js';
+import { setCursor } from './setCursor.js';
+import { modify } from './modify.js';
+import { ModifyState } from './ModifyRes.js';
+import { RANGE_ERR, UPDATE } from './types.js';
+import { appendFixedValue } from './fixed.js';
+import { getSubscriptionMarkers } from '../query/subscription/index.js';
+const appendUpdate = (ctx, def, obj, res, overwrite) => {
+    const err = modify(ctx, res, obj, def, UPDATE, def.tree, overwrite);
+    if (err) {
+        return err;
+    }
+    if (def.updateTs) {
+        const updateTs = Date.now();
+        for (const prop of def.updateTs) {
+            if (ctx.mergeMain) {
+                ctx.mergeMain.push(prop, updateTs);
+                ctx.mergeMainSize += prop.len + 4;
+            }
+            else {
+                ctx.mergeMain = [prop, updateTs];
+                ctx.mergeMainSize = prop.len + 4;
+            }
+        }
+    }
+    if (ctx.mergeMain) {
+        let { mergeMain, mergeMainSize } = ctx;
+        ctx.mergeMainSize = 0;
+        ctx.mergeMain = null;
+        if (ctx.len + 15 + mergeMain.length * 4 > ctx.max) {
+            return RANGE_ERR;
+        }
+        setCursor(ctx, def, 0, res.tmpId, UPDATE);
+        ctx.buf[ctx.len++] = 5;
+        ctx.buf[ctx.len++] = mergeMainSize;
+        ctx.buf[ctx.len++] = mergeMainSize >>>= 8;
+        ctx.buf[ctx.len++] = mergeMainSize >>>= 8;
+        ctx.buf[ctx.len++] = mergeMainSize >>>= 8;
+        for (let i = 0; i < mergeMain.length; i += 2) {
+            const t = mergeMain[i];
+            const v = mergeMain[i + 1];
+            let { start, len } = t;
+            ctx.buf[ctx.len++] = start;
+            ctx.buf[ctx.len++] = start >>>= 8;
+            ctx.buf[ctx.len++] = len;
+            ctx.buf[ctx.len++] = len >>>= 8;
+            const err = appendFixedValue(ctx, v, t);
+            if (err) {
+                return err;
+            }
+        }
+    }
+};
+export const update = (db, type, id, obj, overwrite) => {
+    const def = db.schemaTypesParsed[type];
+    const ctx = db.modifyCtx;
+    const pos = ctx.len;
+    const res = new ModifyState(def.id, id, db, getSubscriptionMarkers(db, def.id, id, false));
+    const err = appendUpdate(ctx, def, obj, res, overwrite);
+    if (err) {
+        ctx.prefix0 = -1; // force a new cursor
+        ctx.len = pos;
+        if (err === RANGE_ERR) {
+            if (pos === 0) {
+                throw new Error('out of range');
+            }
+            flushBuffer(db);
+            return update(db, type, id, obj, overwrite);
+        }
+        res.error = err;
+        // @ts-ignore
+        return res;
+    }
+    if (!db.isDraining) {
+        startDrain(db);
+    }
+    // @ts-ignore
+    return res;
+};
+//# sourceMappingURL=update.js.map

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

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