@based/db 0.0.7 → 0.0.9

package/dist/lib/linux_x86_64/include/selva/vector.h

@@ -4,11 +4,32 @@
  */
 #pragma once
 
+#include "selva/_export.h"
+
 typedef float v2f __attribute__((vector_size(2 * sizeof(float))));
 typedef float v4f __attribute__((vector_size(4 * sizeof(float))));
 typedef float v8f __attribute__((vector_size(8 * sizeof(float))));
 
+/**
+ * Calculate the dot product of two vectors of length len.
+ */
+SELVA_EXPORT
+float vector_dot(const float *a, const float *b, size_t len);
+
+/**
+ * Calculate the Manhattan distance of two vectors of length len.
+ */
+SELVA_EXPORT
+float vector_l1(const float *a, const float *b, size_t len);
+
+/**
+ * Calculate the squared Euclidean distance of two vectors of length len.
+ */
+SELVA_EXPORT
+float vector_l2s(const float *a, const float *b, size_t len);
+
 /**
  * Calculate the cosine similarity of two vectors of length len.
  */
-float vector_sc(float *a, float *b, size_t len);
+SELVA_EXPORT
+float vector_sc(const float *a, const float *b, size_t len);

package/dist/lib/linux_x86_64/include/selva/xxhash64.h

@@ -0,0 +1,23 @@
+#pragma once
+#ifndef XXHASH64_H
+#define XXHASH64_H
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "selva/_export.h"
+#include "cdefs.h"
+
+
+/**
+ * @brief Wrapper function that computes the 64-bit hash of a given input string using the xxHash algorithm.
+ *
+ * Takes a string as input and returns a 64-bit hash value.
+ *
+ * @param s The input string to be hashed.
+ * @return A 64-bit hash value of the input string.
+ */
+
+SELVA_EXPORT
+uint64_t xxHash64(const char *s, size_t len);
+
+#endif

package/dist/src/client/bitWise.js

@@ -28,7 +28,27 @@ export const readDoubleLE = (val, offset) => {
     return sign * fraction * 2 ** (exponent - 1075);
 };
 export const readFloatLE = (val, offset) => {
-    return Buffer.from(val.buffer).readFloatLE(offset);
+    const bits = val[offset] |
+        (val[offset + 1] << 8) |
+        (val[offset + 2] << 16) |
+        (val[offset + 3] << 24);
+    const sign = bits >>> 31 ? -1 : 1;
+    let exponent = (bits >>> 23) & 0xff;
+    let fraction = bits & 0x7fffff;
+    if (exponent === 0xff) {
+        if (fraction === 0)
+            return sign * Infinity;
+        return NaN;
+    }
+    if (exponent === 0) {
+        if (fraction === 0)
+            return sign * 0;
+        exponent = 1;
+    }
+    else {
+        fraction |= 0x800000;
+    }
+    return sign * fraction * 2 ** (exponent - 150);
 };
 export const readUint32 = (val, offset) => {
     return ((val[offset] |

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

@@ -7,6 +7,7 @@ import { BasedDbQuery, QueryByAliasObj } from './query/BasedDbQuery.js';
 import { ModifyRes } from './modify/ModifyRes.js';
 import { DbServer } from '../server/index.js';
 import { TransformFns } from '../server/migrate/index.js';
+import { ModifyOpts } from './modify/types.js';
 export type DbClientHooks = {
     putSchema(schema: StrictSchema, fromStart?: boolean, transformFns?: TransformFns): Promise<DbServer['schema']>;
     flushModify(buf: Buffer): Promise<{
@@ -44,13 +45,18 @@ export declare class DbClient {
     putLocalSchema(schema: any): StrictSchema & {
         lastId: number;
     };
-    create(type: string, obj: CreateObj, unsafe?: boolean): ModifyRes;
+    create(type: string, obj?: CreateObj, opts?: ModifyOpts): ModifyRes;
+    copy(type: string, target: number | ModifyRes, objOrTransformFn?: Record<string, any> | ((item: Record<string, any>) => Promise<any>)): Promise<ModifyRes>;
     query(type: string, id?: number | ModifyRes | (number | ModifyRes)[] | QueryByAliasObj | QueryByAliasObj[]): BasedDbQuery;
     query(): BasedDbQuery;
-    update(type: string, id: number | ModifyRes, value: any, overwrite?: boolean): ModifyRes;
-    update(value: any, overwrite?: boolean): ModifyRes;
-    upsert(type: string, obj: Record<string, any>): Promise<any>;
-    remove(type: string, id: number | ModifyRes): boolean;
+    update(type: string, id: number | ModifyRes, value: any, opts?: ModifyOpts): ModifyRes;
+    update(type: string, value: Record<string, any> & {
+        id: number | ModifyRes;
+    }, opts?: ModifyOpts): ModifyRes;
+    update(value: any, opts?: ModifyOpts): ModifyRes;
+    upsert(type: string, obj: Record<string, any>, opts?: ModifyOpts): Promise<any>;
+    delete(type: string, id: number | ModifyRes): boolean;
+    expire(type: string, id: number | ModifyRes, seconds: number): void;
     destroy(): void;
     stop(): void;
     drain(): Promise<number>;

package/dist/src/client/index.js

@@ -5,11 +5,12 @@ 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 { remove } from './modify/remove.js';
+import { deleteFn } from './modify/delete.js';
 import { updateTypeDefs } from '../server/schema/typeDef.js';
 import { schemaToSelvaBuffer } from '../server/schema/selvaBuffer.js';
 import { deepEqual } from '@saulx/utils';
 import { hash } from '@saulx/hash';
+import { expire } from './modify/expire.js';
 export class DbClient {
     constructor({ hooks, maxModifySize = 100 * 1e3 * 1e3 }) {
         this.hooks = hooks;
@@ -57,8 +58,42 @@ export class DbClient {
         schemaToSelvaBuffer(this.schemaTypesParsed);
         return this.schema;
     }
-    create(type, obj, unsafe) {
-        return create(this, type, obj, unsafe);
+    create(type, obj = {}, opts) {
+        return create(this, type, obj, opts);
+    }
+    async copy(type, target, objOrTransformFn) {
+        const item = await this.query(type, target)
+            .include('*', '**.id')
+            .get()
+            .toObject();
+        if (typeof objOrTransformFn === 'function') {
+            const { id, ...props } = await objOrTransformFn(item);
+            return this.create(type, props);
+        }
+        if (typeof objOrTransformFn === 'object' && objOrTransformFn !== null) {
+            const { id, ...props } = item;
+            await Promise.all(Object.keys(objOrTransformFn).map(async (key) => {
+                const val = objOrTransformFn[key];
+                if (val === null) {
+                    delete props[key];
+                }
+                else if (typeof val === 'function') {
+                    const res = await val(item);
+                    if (Array.isArray(res)) {
+                        props[key] = await Promise.all(res);
+                    }
+                    else {
+                        props[key] = res;
+                    }
+                }
+                else {
+                    props[key] = val;
+                }
+            }));
+            return this.create(type, props);
+        }
+        const { id, ...props } = item;
+        return this.create(type, props);
     }
     query(type, id) {
         if (type === undefined) {
@@ -89,19 +124,30 @@ export class DbClient {
         }
         return new BasedDbQuery(this, type, id);
     }
-    update(typeOrValue, idOrOverwrite, value, overwrite) {
+    update(typeOrValue, idOverwriteOrValue, value, opts) {
         if (typeof typeOrValue === 'string') {
-            const id = typeof idOrOverwrite === 'object' ? idOrOverwrite.tmpId : idOrOverwrite;
-            return update(this, typeOrValue, id, value, overwrite);
+            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);
+                }
+            }
+            return update(this, typeOrValue, idOverwriteOrValue, value, opts);
         }
         // else it is rootProps
-        return update(this, '_root', 1, typeOrValue, idOrOverwrite);
+        return update(this, '_root', 1, typeOrValue, idOverwriteOrValue);
+    }
+    upsert(type, obj, opts) {
+        return upsert(this, type, obj, opts);
     }
-    upsert(type, obj) {
-        return upsert(this, type, obj);
+    delete(type, id) {
+        return deleteFn(this, type, typeof id === 'number' ? id : id.tmpId);
     }
-    remove(type, id) {
-        return remove(this, type, typeof id === 'number' ? id : id.tmpId);
+    expire(type, id, seconds) {
+        return expire(this, type, typeof id === 'number' ? id : id.tmpId, seconds);
     }
     destroy() {
         this.modifyCtx.len = 0;

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

@@ -2,6 +2,8 @@ import { PropDef, PropDefEdge, SchemaPropTree } from '../../server/schema/types.
 import { inspect } from 'node:util';
 import { SubscriptionMarkersCheck } from '../query/subscription/index.js';
 import { DbClient } from '../index.js';
+import { ModifyOpts } from './types.js';
+import { LangCode } from '@based/schema';
 export type ModifyRes = {
     tmpId: number;
     error?: Error;
@@ -14,8 +16,9 @@ export declare class ModifyError {
 }
 export declare class ModifyState {
     #private;
-    constructor(typeId: number, tmpId: number, db: DbClient, subMarkers: SubscriptionMarkersCheck | false);
+    constructor(typeId: number, tmpId: number, db: DbClient, subMarkers: SubscriptionMarkersCheck | false, opts?: ModifyOpts);
     subMarkers: SubscriptionMarkersCheck | false;
+    i18n: LangCode;
     tmpId: number;
     error?: ModifyError;
     promises?: Promise<any>[];

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

@@ -1,5 +1,6 @@
 import { isPropDef, REVERSE_TYPE_INDEX_MAP, } from '../../server/schema/types.js';
 import { inspect } from 'node:util';
+import { langCodesMap } from '@based/schema';
 const MAGIC_KEY = Math.random().toString(36).substring(2);
 const MAGIC_REG = RegExp(`("${MAGIC_KEY}|${MAGIC_KEY}")`, 'g');
 const walk = (val) => {
@@ -44,14 +45,20 @@ export class ModifyError {
     }
 }
 export class ModifyState {
-    constructor(typeId, tmpId, db, subMarkers) {
+    constructor(typeId, tmpId, db, subMarkers, opts) {
         this.tmpId = tmpId;
         this.#typeId = typeId;
         this.#buf = db.modifyCtx;
         this.#ctx = db.modifyCtx.ctx;
         this.subMarkers = subMarkers;
+        if (opts) {
+            if (opts.i18n) {
+                this.i18n = langCodesMap.get(opts.i18n);
+            }
+        }
     }
     subMarkers;
+    i18n;
     #buf;
     #ctx;
     #typeId;

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

@@ -8,7 +8,7 @@ export function writeAlias(value, ctx, def, t, parentId, modifyOp) {
                 if (ctx.len + 11 > ctx.max) {
                     return RANGE_ERR;
                 }
-                setCursor(ctx, def, t.prop, parentId, modifyOp);
+                setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
                 ctx.buf[ctx.len++] = DELETE;
             }
         }
@@ -22,7 +22,7 @@ export function writeAlias(value, ctx, def, t, parentId, modifyOp) {
                 def.stringPropsCurrent[t.prop] = 2;
                 ctx.hasStringField++;
             }
-            setCursor(ctx, def, t.prop, parentId, modifyOp);
+            setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
             ctx.buf[ctx.len++] = modifyOp;
             ctx.buf[ctx.len++] = size;
             ctx.buf[ctx.len++] = size >>>= 8;
@@ -36,7 +36,7 @@ export function writeAlias(value, ctx, def, t, parentId, modifyOp) {
             if (ctx.len + 11 > ctx.max) {
                 return RANGE_ERR;
             }
-            setCursor(ctx, def, t.prop, parentId, modifyOp);
+            setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
             ctx.buf[ctx.len++] = DELETE;
         }
     }

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

@@ -11,6 +11,9 @@ export function getBuffer(value) {
             return Buffer.from(value.buffer);
         }
     }
+    else if (typeof value === 'string') {
+        return Buffer.from(value);
+    }
 }
 export function writeBinaryRaw(value, ctx) {
     let size = value.byteLength + 6;
@@ -45,7 +48,7 @@ export function writeBinary(value, ctx, schema, t, parentId, modifyOp) {
             if (ctx.len + 11 > ctx.max) {
                 return RANGE_ERR;
             }
-            setCursor(ctx, schema, t.prop, parentId, modifyOp);
+            setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);
             ctx.buf[ctx.len++] = DELETE;
         }
     }
@@ -53,7 +56,7 @@ export function writeBinary(value, ctx, schema, t, parentId, modifyOp) {
         if (ctx.len + 15 + size > ctx.max) {
             return RANGE_ERR;
         }
-        setCursor(ctx, schema, t.prop, parentId, modifyOp);
+        setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);
         ctx.buf[ctx.len++] = modifyOp;
         writeBinaryRaw(value, ctx);
     }

package/dist/src/client/modify/cardinality.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/cardinality.js

@@ -0,0 +1,50 @@
+import { RANGE_ERR } from './types.js';
+import { ModifyError } from './ModifyRes.js';
+import { setCursor } from './setCursor.js';
+import { xxHash64 } from '../xxHash64.js';
+export function writeHll(value, ctx, def, t, parentId, modifyOp) {
+    if (!value) {
+        return new ModifyError(t, value);
+    }
+    if (value === null) {
+        // console.log('modify/cardinality.ts trying to reset?')
+        // 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)) {
+        // console.log('modify/cardinality.ts Array.isArray(value)')
+        // for (const key in value) {
+        //   if (key === 'add') {
+        //     // @ts-ignore
+        //     const err = addHll(value[key], ctx, def, t, parentId, modifyOp, 1)
+        //     if (err) {
+        //       return err
+        //     }
+        //   } else {
+        //     return new ModifyError(t, value)
+        //   }
+        // }
+    }
+    else {
+        return addHll(value, ctx, def, t, parentId, modifyOp);
+    }
+}
+function addHll(value, ctx, def, t, parentId, modifyOp) {
+    let size = 8;
+    if (ctx.len + size + 11 > ctx.max) {
+        return RANGE_ERR;
+    }
+    // console.log(`test JS original value = ${value}`)
+    setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
+    ctx.buf[ctx.len++] = modifyOp;
+    let hash = xxHash64(Buffer.from(value)); //1ec6c662633f0026 or 2217677992400715814
+    ctx.buf.writeBigUInt64LE(hash, ctx.len);
+    // console.log('js hash:', hash)
+    ctx.len += 8;
+}
+//# sourceMappingURL=cardinality.js.map

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

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

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

@@ -0,0 +1,112 @@
+import { MICRO_BUFFER } from '../../server/schema/schema.js';
+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, MICRO_BUFFER, 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, MICRO_BUFFER, 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, opts) {
+    const def = db.schemaTypesParsed[type];
+    if (!def) {
+        throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
+    }
+    let id;
+    if ('id' in obj) {
+        if (opts?.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), opts);
+    const pos = ctx.len;
+    const err = appendCreate(ctx, def, obj, res, opts?.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, opts);
+        }
+        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%20copy.js.map

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

@@ -1,4 +1,5 @@
 import { ModifyRes } from './ModifyRes.js';
+import { ModifyOpts } from './types.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;
+export declare function create(db: DbClient, type: string, obj: CreateObj, opts?: ModifyOpts): ModifyRes;

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

@@ -1,3 +1,4 @@
+import { MICRO_BUFFER } from '../../server/schema/schema.js';
 import { startDrain, flushBuffer } from '../operations.js';
 import { setCursor } from './setCursor.js';
 import { modify } from './modify.js';
@@ -15,14 +16,14 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
         if (ctx.len + 10 > ctx.max) {
             return RANGE_ERR;
         }
-        setCursor(ctx, def, 0, res.tmpId, CREATE);
+        setCursor(ctx, def, 0, MICRO_BUFFER, 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);
+                setCursor(ctx, def, prop.prop, MICRO_BUFFER, res.tmpId, CREATE);
                 ctx.buf[ctx.len++] = CREATE;
                 ctx.buf[ctx.len++] = mainLenU32;
                 ctx.buf[ctx.len++] = mainLenU32 >>>= 8;
@@ -63,11 +64,14 @@ const appendCreate = (ctx, def, obj, res, unsafe) => {
         }
     }
 };
-export function create(db, type, obj, unsafe) {
+export function create(db, type, obj, opts) {
     const def = db.schemaTypesParsed[type];
+    if (!def) {
+        throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
+    }
     let id;
     if ('id' in obj) {
-        if (unsafe) {
+        if (opts?.unsafe) {
             id = obj.id;
         }
         else {
@@ -78,9 +82,9 @@ export function create(db, type, obj, unsafe) {
         id = def.lastId + 1;
     }
     const ctx = db.modifyCtx;
-    const res = new ModifyState(def.id, id, db, getSubscriptionMarkers(db, def.id, id, true));
+    const res = new ModifyState(def.id, id, db, getSubscriptionMarkers(db, def.id, id, true), opts);
     const pos = ctx.len;
-    const err = appendCreate(ctx, def, obj, res, unsafe);
+    const err = appendCreate(ctx, def, obj, res, opts?.unsafe);
     if (err) {
         ctx.prefix0 = -1; // force a new cursor
         ctx.len = pos;
@@ -89,7 +93,7 @@ export function create(db, type, obj, unsafe) {
                 throw new Error('out of range');
             }
             flushBuffer(db);
-            return db.create(type, obj, unsafe);
+            return db.create(type, obj, opts);
         }
         res.error = err;
         // @ts-ignore

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

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

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

@@ -0,0 +1,37 @@
+import { flushBuffer, startDrain } from '../operations.js';
+import { setCursor } from './setCursor.js';
+import { UPDATE } from './types.js';
+import { MICRO_BUFFER } from '../../server/schema/schema.js';
+export const deleteFn = (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 deleteFn(db, type, id);
+        }
+        setCursor(ctx, schema, 0, MICRO_BUFFER, id, UPDATE);
+        ctx.buf[ctx.len++] = 4;
+        for (const s of separate) {
+            setCursor(ctx, schema, s.prop, s.typeIndex, id, UPDATE);
+            ctx.buf[ctx.len++] = 4;
+        }
+        ctx.buf[ctx.len++] = 10;
+    }
+    else {
+        if (ctx.len + 12 > ctx.max) {
+            flushBuffer(db);
+            return deleteFn(db, type, id);
+        }
+        setCursor(ctx, schema, 0, MICRO_BUFFER, id, UPDATE);
+        ctx.buf[ctx.len++] = 4;
+        ctx.buf[ctx.len++] = 10;
+    }
+    if (!db.isDraining) {
+        startDrain(db);
+    }
+    return true;
+};
+//# sourceMappingURL=delete.js.map

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

@@ -0,0 +1,3 @@
+import { DbClient } from '../index.js';
+export type CreateObj = Record<string, any>;
+export declare function expire(db: DbClient, type: string, id: number, seconds: number): void;

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

@@ -0,0 +1,25 @@
+import { MICRO_BUFFER } from '../../server/schema/schema.js';
+import { startDrain, flushBuffer } from '../operations.js';
+import { setCursor } from './setCursor.js';
+import { EXPIRE } from './types.js';
+export function expire(db, type, id, seconds) {
+    const def = db.schemaTypesParsed[type];
+    if (!def) {
+        throw new Error(`Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`);
+    }
+    const ctx = db.modifyCtx;
+    if (ctx.len + 8 + 1 + 4 > ctx.max) {
+        flushBuffer(db);
+        return expire(db, type, id, seconds);
+    }
+    setCursor(ctx, def, 0, MICRO_BUFFER, id, EXPIRE);
+    ctx.buf[ctx.len++] = EXPIRE;
+    ctx.buf[ctx.len++] = seconds;
+    ctx.buf[ctx.len++] = seconds >>>= 8;
+    ctx.buf[ctx.len++] = seconds >>>= 8;
+    ctx.buf[ctx.len++] = seconds >>>= 8;
+    if (!db.isDraining) {
+        startDrain(db);
+    }
+}
+//# sourceMappingURL=expire.js.map