@based/db 0.0.1

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

@@ -0,0 +1,61 @@
+import { UPDATE, RANGE_ERR, DELETE } from './types.js';
+import { ModifyError } from './ModifyRes.js';
+import { setCursor } from './setCursor.js';
+import native from '../../native.js';
+export function getBuffer(value) {
+    if (typeof value === 'object') {
+        if (value instanceof Buffer) {
+            return value;
+        }
+        if (value.buffer instanceof ArrayBuffer) {
+            return Buffer.from(value.buffer);
+        }
+    }
+}
+export function writeBinaryRaw(value, ctx) {
+    let size = value.byteLength + 6;
+    let crc = native.crc32(value);
+    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++] = 0;
+    ctx.buf[ctx.len++] = 0;
+    ctx.buf.set(value, ctx.len);
+    ctx.len += value.byteLength;
+    ctx.buf[ctx.len++] = crc;
+    ctx.buf[ctx.len++] = crc >>>= 8;
+    ctx.buf[ctx.len++] = crc >>>= 8;
+    ctx.buf[ctx.len++] = crc >>>= 8;
+}
+export function writeBinary(value, ctx, schema, t, parentId, modifyOp) {
+    let size;
+    if (value === null) {
+        size = 0;
+    }
+    else {
+        value = getBuffer(value);
+        if (!value) {
+            return new ModifyError(t, value);
+        }
+        size = value.byteLength + 6;
+    }
+    if (size === 0) {
+        if (modifyOp === UPDATE) {
+            if (ctx.len + 11 > ctx.max) {
+                return RANGE_ERR;
+            }
+            setCursor(ctx, schema, t.prop, parentId, modifyOp);
+            ctx.buf[ctx.len++] = DELETE;
+        }
+    }
+    else {
+        if (ctx.len + 15 + size > ctx.max) {
+            return RANGE_ERR;
+        }
+        setCursor(ctx, schema, t.prop, parentId, modifyOp);
+        ctx.buf[ctx.len++] = modifyOp;
+        writeBinaryRaw(value, ctx);
+    }
+}
+//# sourceMappingURL=binary.js.map

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

@@ -0,0 +1,4 @@
+import { ModifyRes } from './ModifyRes.js';
+import { DbClient } from '../index.js';
+export type CreateObj = Record<string, any>;
+export declare function create(db: DbClient, type: string, obj: CreateObj, unsafe?: boolean): ModifyRes;

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

@@ -0,0 +1,108 @@
+import { startDrain, flushBuffer } from '../operations.js';
+import { setCursor } from './setCursor.js';
+import { modify } from './modify.js';
+import { ModifyState } from './ModifyRes.js';
+import { CREATE, RANGE_ERR } from './types.js';
+import { writeFixedValue } from './fixed.js';
+import { getSubscriptionMarkers } from '../query/subscription/index.js';
+const appendCreate = (ctx, def, obj, res, unsafe) => {
+    const len = ctx.len;
+    let err = modify(ctx, res, obj, def, CREATE, def.tree, true, unsafe);
+    if (err) {
+        return err;
+    }
+    if (ctx.len === len || def.mainLen === 0) {
+        if (ctx.len + 10 > ctx.max) {
+            return RANGE_ERR;
+        }
+        setCursor(ctx, def, 0, res.tmpId, CREATE);
+    }
+    if (def.createTs) {
+        const createTs = Date.now();
+        for (const prop of def.createTs) {
+            if (ctx.lastMain === -1) {
+                let mainLenU32 = def.mainLen;
+                setCursor(ctx, def, prop.prop, res.tmpId, CREATE);
+                ctx.buf[ctx.len++] = CREATE;
+                ctx.buf[ctx.len++] = mainLenU32;
+                ctx.buf[ctx.len++] = mainLenU32 >>>= 8;
+                ctx.buf[ctx.len++] = mainLenU32 >>>= 8;
+                ctx.buf[ctx.len++] = mainLenU32 >>>= 8;
+                ctx.lastMain = ctx.len;
+                ctx.buf.fill(0, ctx.len, (ctx.len += def.mainLen));
+            }
+            err = writeFixedValue(ctx, createTs, prop, ctx.lastMain + prop.start);
+            if (err) {
+                return err;
+            }
+        }
+    }
+    // if touched lets see perf impact here
+    if (def.hasStringProp) {
+        if (ctx.hasStringField !== def.stringPropsSize - 1) {
+            if (ctx.len + 3 > ctx.max) {
+                return RANGE_ERR;
+            }
+            ctx.buf[ctx.len++] = 7;
+            let sizepos = ctx.len;
+            ctx.len += 2;
+            for (const { prop } of def.stringPropsLoop) {
+                if (def.stringPropsCurrent[prop] === 1) {
+                    if (ctx.len + 1 > ctx.max) {
+                        return RANGE_ERR;
+                    }
+                    ctx.buf[ctx.len++] = prop;
+                }
+            }
+            let size = ctx.len - sizepos - 2;
+            ctx.buf[sizepos++] = size;
+            ctx.buf[sizepos] = size >>>= 8;
+        }
+        if (ctx.hasStringField !== -1) {
+            def.stringProps.copy(def.stringPropsCurrent);
+        }
+    }
+};
+export function create(db, type, obj, unsafe) {
+    const def = db.schemaTypesParsed[type];
+    let id;
+    if ('id' in obj) {
+        if (unsafe) {
+            id = obj.id;
+        }
+        else {
+            throw Error('create with "id" is not allowed');
+        }
+    }
+    else {
+        id = def.lastId + 1;
+    }
+    const ctx = db.modifyCtx;
+    const res = new ModifyState(def.id, id, db, getSubscriptionMarkers(db, def.id, id, true));
+    const pos = ctx.len;
+    const err = appendCreate(ctx, def, obj, res, unsafe);
+    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 db.create(type, obj, unsafe);
+        }
+        res.error = err;
+        // @ts-ignore
+        return res;
+    }
+    if (!db.isDraining) {
+        startDrain(db);
+    }
+    if (id > def.lastId) {
+        def.lastId = id;
+        def.total++;
+    }
+    // @ts-ignore
+    return res;
+}
+//# sourceMappingURL=create.js.map

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

@@ -0,0 +1,5 @@
+import { ModifyCtx } from '../../index.js';
+import { PropDef, PropDefEdge } from '../../server/schema/types.js';
+import { ModifyErr } from './types.js';
+export declare const writeFixedValue: (ctx: ModifyCtx, val: any, def: PropDef | PropDefEdge, pos: number) => ModifyErr;
+export declare const appendFixedValue: (ctx: ModifyCtx, val: any, def: PropDef | PropDefEdge) => ModifyErr;

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

@@ -0,0 +1,118 @@
+import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, } from '../../server/schema/types.js';
+import { getBuffer } from './binary.js';
+import { ModifyError } from './ModifyRes.js';
+import { RANGE_ERR } from './types.js';
+const map = {};
+map[BINARY] = (ctx, val, def) => {
+    const buf = getBuffer(val);
+    if (buf === undefined) {
+        return new ModifyError(def, val);
+    }
+    const size = buf.byteLength;
+    if (ctx.len + size + 1 > ctx.max) {
+        return RANGE_ERR;
+    }
+    ctx.buf[ctx.len++] = size;
+    ctx.buf.set(buf, ctx.len);
+    ctx.len += buf.byteLength;
+};
+map[STRING] = (ctx, val, def) => {
+    if (typeof val !== 'string') {
+        if (val !== null) {
+            return new ModifyError(def, val);
+        }
+        val = '';
+    }
+    const size = Buffer.byteLength(val, 'utf8');
+    if (size + 1 > def.len) {
+        return new ModifyError(def, val, `max length of ${def.len - 1},`);
+    }
+    if (ctx.len + size + 1 > ctx.max) {
+        return RANGE_ERR;
+    }
+    ctx.buf[ctx.len++] = size;
+    ctx.len += ctx.buf.write(val, ctx.len, 'utf8');
+};
+map[BOOLEAN] = (ctx, val, def) => {
+    if (ctx.len + 1 > ctx.max) {
+        return RANGE_ERR;
+    }
+    if (val === null) {
+        ctx.buf[ctx.len++] = 0;
+    }
+    else if (typeof val === 'boolean') {
+        ctx.buf[ctx.len++] = val ? 1 : 0;
+    }
+    else {
+        return new ModifyError(def, val);
+    }
+};
+map[ENUM] = (ctx, val, def) => {
+    if (ctx.len + 1 > ctx.max) {
+        return RANGE_ERR;
+    }
+    if (val === null) {
+        ctx.buf[ctx.len++] = 1;
+    }
+    else if (val in def.reverseEnum) {
+        ctx.buf[ctx.len++] = def.reverseEnum[val] + 1;
+    }
+    else {
+        return new ModifyError(def, val);
+    }
+};
+map[NUMBER] = (ctx, val, def) => {
+    if (typeof val !== 'number') {
+        return new ModifyError(def, val);
+    }
+    if (ctx.len + 8 > ctx.max) {
+        return RANGE_ERR;
+    }
+    ctx.len = ctx.buf.writeDoubleLE(val, ctx.len);
+};
+map[UINT32] = (ctx, val, def) => {
+    if (typeof val !== 'number') {
+        return new ModifyError(def, val);
+    }
+    if (ctx.len + 4 > ctx.max) {
+        return RANGE_ERR;
+    }
+    ctx.buf[ctx.len++] = val;
+    ctx.buf[ctx.len++] = val >>>= 8;
+    ctx.buf[ctx.len++] = val >>>= 8;
+    ctx.buf[ctx.len++] = val >>>= 8;
+};
+map[UINT16] = (ctx, val, def) => {
+    if (typeof val !== 'number') {
+        return new ModifyError(def, val);
+    }
+    if (ctx.len + 2 > ctx.max) {
+        return RANGE_ERR;
+    }
+    ctx.buf[ctx.len++] = val;
+    ctx.buf[ctx.len++] = val >>>= 8;
+};
+map[UINT8] = (ctx, val, def) => {
+    if (typeof val !== 'number') {
+        return new ModifyError(def, val);
+    }
+    if (ctx.len + 1 > ctx.max) {
+        return RANGE_ERR;
+    }
+    ctx.buf[ctx.len++] = val;
+};
+map[TIMESTAMP] = map[NUMBER];
+map[INT32] = map[UINT32];
+map[INT16] = map[UINT16];
+map[INT8] = map[UINT8];
+export const writeFixedValue = (ctx, val, def, pos) => {
+    const len = ctx.len;
+    ctx.len = pos;
+    const res = map[def.typeIndex](ctx, val, def);
+    ctx.len = len;
+    return res;
+};
+export const appendFixedValue = (ctx, val, def) => {
+    return map[def.typeIndex](ctx, val, def);
+};
+//# sourceMappingURL=fixed.js.map

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

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

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

@@ -0,0 +1,58 @@
+import { UPDATE, RANGE_ERR, DELETE } from './types.js';
+import { ModifyError } from './ModifyRes.js';
+import { setCursor } from './setCursor.js';
+import { crc32 } from '../crc32.js';
+export function writeHll(value, ctx, def, t, parentId, modifyOp) {
+    if (typeof value !== 'object') {
+        return new ModifyError(t, value);
+    }
+    if (value === null) {
+        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 if (Array.isArray(value)) {
+        return addHll(value, ctx, def, t, parentId, modifyOp, 0);
+    }
+    else {
+        for (const key in value) {
+            if (key === 'add') {
+                const err = addHll(value, ctx, def, t, parentId, modifyOp, 1);
+                if (err) {
+                    return err;
+                }
+            }
+            else {
+                return new ModifyError(t, value);
+            }
+        }
+    }
+}
+function addHll(value, ctx, def, t, parentId, modifyOp, addOrPut) {
+    let size = value.length * 4 + 1;
+    if (ctx.len + size + 11 > ctx.max) {
+        return RANGE_ERR;
+    }
+    setCursor(ctx, def, t.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++] = addOrPut;
+    for (const str of value) {
+        if (typeof str !== 'string') {
+            return new ModifyError(t, value);
+        }
+        let hash = crc32(Buffer.from(str));
+        ctx.buf[ctx.len++] = hash;
+        ctx.buf[ctx.len++] = hash >>>= 8;
+        ctx.buf[ctx.len++] = hash >>>= 8;
+        ctx.buf[ctx.len++] = hash >>>= 8;
+    }
+}
+//# sourceMappingURL=hll.js.map

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

@@ -0,0 +1,4 @@
+export { ModifyRes } from './ModifyRes.js';
+export { create } from './create.js';
+export { update } from './update.js';
+export { remove } from './remove.js';

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

@@ -0,0 +1,4 @@
+export { create } from './create.js';
+export { update } from './update.js';
+export { remove } from './remove.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+import { ModifyCtx } from '../../index.js';
+import { SchemaTypeDef } from '../../server/schema/types.js';
+import { ModifyState } from './ModifyRes.js';
+import { ModifyErr, ModifyOp } from './types.js';
+export declare function modify(ctx: ModifyCtx, res: ModifyState, obj: Record<string, any>, schema: SchemaTypeDef, mod: ModifyOp, tree: SchemaTypeDef['tree'], overwrite: boolean, unsafe?: boolean): ModifyErr;

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

@@ -0,0 +1,126 @@
+import { isPropDef, REFERENCE, REFERENCES, STRING, TEXT, ALIAS, BINARY, HLL, } from '../../server/schema/types.js';
+import { ModifyError } from './ModifyRes.js';
+import { writeReference } from './references/reference.js';
+import { writeReferences } from './references/references.js';
+import { writeString } from './string.js';
+import { writeText } from './text.js';
+import { DECREMENT, INCREMENT, RANGE_ERR, } from './types.js';
+import { writeBinary } from './binary.js';
+import { setCursor } from './setCursor.js';
+import { appendFixedValue, writeFixedValue } from './fixed.js';
+import { writeAlias } from './alias.js';
+import { writeHll } from './hll.js';
+import { checkSubscriptionMarkers } from '../query/subscription/index.js';
+function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
+    for (const key in obj) {
+        const def = tree[key];
+        if (def === undefined) {
+            if (unsafe) {
+                continue;
+            }
+            return new ModifyError(tree, key);
+        }
+        let err;
+        if (isPropDef(def)) {
+            if (res.subMarkers) {
+                checkSubscriptionMarkers(ctx.db, res.subMarkers, def);
+            }
+            const val = obj[key];
+            const type = def.typeIndex;
+            if (def.separate) {
+                if (type === STRING) {
+                    err = writeString(0, val, ctx, schema, def, res.tmpId, mod);
+                }
+                else if (type === TEXT) {
+                    err = writeText(val, ctx, schema, def, res.tmpId, mod);
+                }
+                else if (type === REFERENCE) {
+                    err = writeReference(val, ctx, schema, def, res, mod);
+                }
+                else if (type === REFERENCES) {
+                    err = writeReferences(val, ctx, schema, def, res, mod);
+                }
+                else if (type === BINARY) {
+                    err = writeBinary(val, ctx, schema, def, res.tmpId, mod);
+                }
+                else if (type === ALIAS) {
+                    err = writeAlias(val, ctx, schema, def, res.tmpId, mod);
+                }
+                else if (type === HLL) {
+                    err = writeHll(val, ctx, schema, def, res.tmpId, mod);
+                }
+            }
+            else if (overwrite) {
+                if (ctx.len + 15 + schema.mainLen > ctx.max) {
+                    return RANGE_ERR;
+                }
+                setCursor(ctx, schema, def.prop, res.tmpId, mod, true);
+                if (ctx.lastMain === -1) {
+                    let mainLenU32 = schema.mainLen;
+                    setCursor(ctx, schema, def.prop, res.tmpId, mod);
+                    ctx.buf[ctx.len++] = mod;
+                    ctx.buf[ctx.len++] = mainLenU32;
+                    ctx.buf[ctx.len++] = mainLenU32 >>>= 8;
+                    ctx.buf[ctx.len++] = mainLenU32 >>>= 8;
+                    ctx.buf[ctx.len++] = mainLenU32 >>>= 8;
+                    ctx.lastMain = ctx.len;
+                    ctx.buf.fill(0, ctx.len, (ctx.len += schema.mainLen));
+                }
+                if (typeof val === 'object' && val !== null && 'increment' in val) {
+                    err = writeFixedValue(ctx, val.increment, def, ctx.lastMain + def.start);
+                }
+                else {
+                    err = writeFixedValue(ctx, val, def, ctx.lastMain + def.start);
+                }
+            }
+            else if (typeof val === 'object') {
+                if (val !== null && 'increment' in val) {
+                    let increment = val.increment;
+                    if (increment === 0) {
+                        continue;
+                    }
+                    if (ctx.len + 10 > ctx.max) {
+                        return RANGE_ERR;
+                    }
+                    setCursor(ctx, schema, def.prop, res.tmpId, mod);
+                    let start = def.start;
+                    if (increment < 0) {
+                        ctx.buf[ctx.len++] = DECREMENT;
+                        increment = -increment;
+                    }
+                    else {
+                        ctx.buf[ctx.len++] = INCREMENT;
+                    }
+                    ctx.buf[ctx.len++] = def.typeIndex;
+                    ctx.buf[ctx.len++] = start;
+                    ctx.buf[ctx.len++] = start >>>= 8;
+                    appendFixedValue(ctx, increment, def);
+                }
+                else {
+                    return new ModifyError(def, val);
+                }
+            }
+            else if (ctx.mergeMain) {
+                ctx.mergeMain.push(def, val);
+                ctx.mergeMainSize += def.len + 4;
+            }
+            else {
+                ctx.mergeMain = [def, val];
+                ctx.mergeMainSize = def.len + 4;
+            }
+        }
+        else {
+            err = _modify(ctx, res, obj[key], schema, mod, def, overwrite, unsafe);
+        }
+        if (err) {
+            if (unsafe && err !== RANGE_ERR) {
+                continue;
+            }
+            return err;
+        }
+    }
+}
+export function modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe = false) {
+    return _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe);
+}
+//# sourceMappingURL=modify.js.map

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

@@ -0,0 +1,6 @@
+import { ModifyCtx } from '../../../index.js';
+import { PropDef } from '../../../server/schema/types.js';
+import { ModifyErr } from '../types.js';
+import { RefModifyOpts } from './references.js';
+export declare function getEdgeSize(t: PropDef, ref: RefModifyOpts): number;
+export declare function writeEdges(t: PropDef, ref: RefModifyOpts, ctx: ModifyCtx): ModifyErr;

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

@@ -0,0 +1,158 @@
+import { BINARY, REFERENCE, REFERENCES, STRING, } from '../../../server/schema/types.js';
+import { write } from '../../string.js';
+import { getBuffer, writeBinaryRaw } from '../binary.js';
+import { ModifyError, ModifyState } from '../ModifyRes.js';
+import { RANGE_ERR } from '../types.js';
+import { appendFixedValue } from '../fixed.js';
+export function getEdgeSize(t, ref) {
+    let size = 0;
+    for (const key in t.edges) {
+        if (key in ref) {
+            const edge = t.edges[key];
+            const value = ref[key];
+            if (edge.len === 0) {
+                if (edge.typeIndex === STRING) {
+                    size += Buffer.byteLength(value) + 4;
+                }
+                else if (edge.typeIndex === REFERENCE) {
+                    size += 4;
+                }
+                else if (edge.typeIndex === REFERENCES) {
+                    size += value.length * 4 + 4;
+                }
+            }
+            else {
+                size += edge.len;
+            }
+        }
+    }
+    return size;
+}
+function appendRefs(t, ctx, value) {
+    for (let i = 0; i < value.length; i++) {
+        let id = value[i];
+        if (typeof id !== 'number') {
+            if (id instanceof ModifyState) {
+                if (id.error) {
+                    return id.error;
+                }
+                id = id.tmpId;
+            }
+            else {
+                return new ModifyError(t, value);
+            }
+        }
+        if (id > 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 {
+            return new ModifyError(t, value);
+        }
+    }
+}
+export function writeEdges(t, ref, ctx) {
+    for (const key in t.edges) {
+        if (key in ref) {
+            const edge = t.edges[key];
+            let value = ref[key];
+            if (edge.len === 0) {
+                if (edge.typeIndex === BINARY) {
+                    let size = 0;
+                    if (value === null) {
+                        size = 0;
+                    }
+                    else {
+                        const buf = getBuffer(value);
+                        if (!buf) {
+                            return new ModifyError(t, ref);
+                        }
+                        size = buf.byteLength;
+                    }
+                    if (ctx.len + 6 + size > ctx.max) {
+                        return RANGE_ERR;
+                    }
+                    ctx.buf[ctx.len++] = edge.prop;
+                    ctx.buf[ctx.len++] = STRING;
+                    if (size) {
+                        writeBinaryRaw(value, ctx);
+                    }
+                    else {
+                        ctx.buf[ctx.len++] = 0;
+                        ctx.buf[ctx.len++] = 0;
+                        ctx.buf[ctx.len++] = 0;
+                        ctx.buf[ctx.len++] = 0;
+                    }
+                }
+                else if (edge.typeIndex === STRING) {
+                    if (typeof value !== 'string') {
+                        return new ModifyError(t, ref);
+                    }
+                    if (ctx.len + 6 + Buffer.byteLength(value) > ctx.max) {
+                        return RANGE_ERR;
+                    }
+                    ctx.buf[ctx.len++] = edge.prop;
+                    ctx.buf[ctx.len++] = STRING;
+                    let size = write(ctx.buf, value, ctx.len + 4, edge.compression === 0);
+                    let sizeU32 = size;
+                    ctx.buf[ctx.len++] = sizeU32;
+                    ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+                    ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+                    ctx.buf[ctx.len++] = sizeU32 >>>= 8;
+                    ctx.len += size;
+                }
+                else if (edge.typeIndex === REFERENCE) {
+                    if (typeof value !== 'number') {
+                        if (value instanceof ModifyState) {
+                            value = value.tmpId;
+                        }
+                        else {
+                            return new ModifyError(t, ref);
+                        }
+                    }
+                    if (value > 0) {
+                        ctx.buf[ctx.len++] = edge.prop;
+                        ctx.buf[ctx.len++] = REFERENCE;
+                        ctx.buf[ctx.len++] = value;
+                        ctx.buf[ctx.len++] = value >>>= 8;
+                        ctx.buf[ctx.len++] = value >>>= 8;
+                        ctx.buf[ctx.len++] = value >>>= 8;
+                    }
+                    else {
+                        return new ModifyError(t, ref);
+                    }
+                }
+                else if (edge.typeIndex === REFERENCES) {
+                    if (!Array.isArray(value)) {
+                        return new ModifyError(t, ref);
+                    }
+                    let size = value.length * 4;
+                    if (ctx.len + 6 + size > ctx.max) {
+                        return RANGE_ERR;
+                    }
+                    ctx.buf[ctx.len++] = edge.prop;
+                    ctx.buf[ctx.len++] = REFERENCES;
+                    ctx.buf[ctx.len++] = size;
+                    ctx.buf[ctx.len++] = size >>>= 8;
+                    ctx.buf[ctx.len++] = size >>>= 8;
+                    ctx.buf[ctx.len++] = size >>>= 8;
+                    appendRefs(edge, ctx, value);
+                }
+            }
+            else {
+                if (ctx.len + 2 > ctx.max) {
+                    return RANGE_ERR;
+                }
+                ctx.buf[ctx.len++] = edge.prop;
+                ctx.buf[ctx.len++] = edge.typeIndex;
+                const err = appendFixedValue(ctx, value, edge);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=edge.js.map

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

@@ -0,0 +1,11 @@
+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 declare function writeReference(value: number | ModifyState | {
+    id: number;
+    upsert?: Record<string, any>;
+} | {
+    id?: number;
+    upsert: Record<string, any>;
+}, ctx: ModifyCtx, schema: SchemaTypeDef, def: PropDef, res: ModifyState, modifyOp: ModifyOp): ModifyErr;