@based/db 0.0.14 → 0.0.16

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

@@ -1,7 +1,8 @@
-import { ALIAS, ALIASES, BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, VECTOR, JSON, } from '../../../server/schema/types.js';
+import { ALIAS, ALIASES, BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, VECTOR, JSON, CARDINALITY, } from '../../../server/schema/types.js';
 import { read, readUtf8 } from '../../string.js';
 import { readDoubleLE, readFloatLE, readInt16, readInt32, readUint16, readUint32, } from '../../bitWise.js';
 import { inverseLangMap } from '@based/schema';
+import { READ_EDGE, READ_ID, READ_REFERENCE, READ_REFERENCES } from './types.js';
 const addField = (p, value, item, defaultOnly = false, lang = 0) => {
     let i = p.__isEdge === true ? 1 : 0;
     // TODO OPTMIZE
@@ -58,19 +59,15 @@ const getEmptyField = (p, item) => {
     return select;
 };
 const readMainValue = (prop, result, index, item) => {
-    // 1: timestamp, 4: number
     if (prop.typeIndex === TIMESTAMP || prop.typeIndex === NUMBER) {
         addField(prop, readDoubleLE(result, index), item);
     }
-    // 5: uint32
     else if (prop.typeIndex === UINT32) {
         addField(prop, readUint32(result, index), item);
     }
-    // 9: boolean
     else if (prop.typeIndex === BOOLEAN) {
         addField(prop, Boolean(result[index]), item);
     }
-    // 10: Enum
     else if (prop.typeIndex === ENUM) {
         if (result[index] === 0) {
             addField(prop, undefined, item);
@@ -79,9 +76,7 @@ const readMainValue = (prop, result, index, item) => {
             addField(prop, prop.enum[result[index] - 1], item);
         }
     }
-    // 11: string
     else if (prop.typeIndex === STRING) {
-        // Also delete this default then (same as other string)
         const len = result[index];
         if (len !== 0) {
             const str = readUtf8(result, index + 1, len);
@@ -91,32 +86,25 @@ const readMainValue = (prop, result, index, item) => {
             addField(prop, '', item);
         }
     }
-    // ?: json
     else if (prop.typeIndex === JSON) {
-        addField(prop, global.JSON.parse(Buffer.from(result.subarray(index + 1, index + 1 + result[index])).toString()), item);
+        addField(prop, global.JSON.parse(readUtf8(result, index + 1, index + 1 + result[index])), item);
     }
-    // 25: binary
     else if (prop.typeIndex === BINARY) {
         addField(prop, result.subarray(index + 1, index + 1 + result[index]), item);
     }
-    // 18: int8
     else if (prop.typeIndex === INT8) {
         const signedVal = (result[index] << 24) >> 24;
         addField(prop, signedVal, item);
     }
-    // 19: uint8
     else if (prop.typeIndex === UINT8) {
         addField(prop, result[index], item);
     }
-    // 20: int16
     else if (prop.typeIndex === INT16) {
         addField(prop, readInt16(result, index), item);
     }
-    // 21: uint16
     else if (prop.typeIndex === UINT16) {
         addField(prop, readUint16(result, index), item);
     }
-    // 22: int32
     else if (prop.typeIndex === INT32) {
         addField(prop, readInt32(result, index), item);
     }
@@ -143,7 +131,10 @@ const handleUndefinedProps = (id, q, item) => {
     for (const k in q.include.propsRead) {
         if (q.include.propsRead[k] !== id) {
             const prop = q.schema.reverseProps[k];
-            if (prop.typeIndex === TEXT && q.lang == 0) {
+            if (prop.typeIndex === CARDINALITY) {
+                addField(prop, 0, item);
+            }
+            else if (prop.typeIndex === TEXT && q.lang == 0) {
                 const lan = getEmptyField(prop, item);
                 const lang = q.include.langTextFields.get(prop.prop).codes;
                 if (lang.has(0)) {
@@ -173,16 +164,13 @@ export const readAllFields = (q, result, offset, end, item, id) => {
     while (i < end) {
         const index = result[i];
         i++;
-        // index:255 id
-        if (index === 255) {
+        if (index === READ_ID) {
             handleUndefinedProps(id, q, item);
             return i - offset;
         }
-        // index:252 edge
-        if (index === 252) {
+        if (index === READ_EDGE) {
             let prop = result[i];
-            // index:254 ref
-            if (prop === 254) {
+            if (prop === READ_REFERENCE) {
                 i++;
                 const field = result[i];
                 i++;
@@ -206,9 +194,8 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                     addField(ref.target.propDef, refItem, item);
                     i += size - 5;
                 }
-                // index:253 refs
             }
-            else if (prop === 253) {
+            else if (prop === READ_REFERENCES) {
                 i++;
                 const field = result[i];
                 i++;
@@ -227,7 +214,7 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                 if (t === JSON) {
                     i++;
                     const size = readUint32(result, i);
-                    addField(edgeDef, global.JSON.parse(Buffer.from(result.subarray(i + 6, size + i)).toString()), item);
+                    addField(edgeDef, global.JSON.parse(readUtf8(result, i + 6, size + i)), item);
                     i += size + 4;
                 }
                 else if (t === BINARY) {
@@ -253,9 +240,8 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                     i += edgeDef.len;
                 }
             }
-            // index:254 ref
         }
-        else if (index === 254) {
+        else if (index === READ_REFERENCE) {
             const field = result[i];
             i++;
             const size = readUint32(result, i);
@@ -278,9 +264,8 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                 addField(ref.target.propDef, refItem, item);
                 i += size - 5;
             }
-            // index:253 refs
         }
-        else if (index === 253) {
+        else if (index === READ_REFERENCES) {
             const field = result[i];
             i++;
             const ref = q.references.get(field);
@@ -296,7 +281,13 @@ export const readAllFields = (q, result, offset, end, item, id) => {
         }
         else {
             const prop = q.schema.reverseProps[index];
-            if (prop.typeIndex === JSON) {
+            if (prop.typeIndex === CARDINALITY) {
+                q.include.propsRead[index] = id;
+                const size = readUint32(result, i);
+                addField(prop, readUint32(result, i + 4), item);
+                i += size + 4;
+            }
+            else if (prop.typeIndex === JSON) {
                 q.include.propsRead[index] = id;
                 const size = readUint32(result, i);
                 addField(prop, global.JSON.parse(Buffer.from(result.subarray(i + 6, i + size)).toString()), item);
@@ -329,7 +320,6 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                         addField(prop, read(result, i + 4, size), item);
                     }
                     else {
-                        // q.include.propsRead[index] = id
                         addField(prop, read(result, i + 4, size), item, false, result[i + 4]);
                     }
                 }
@@ -360,7 +350,6 @@ export const readAllFields = (q, result, offset, end, item, id) => {
             }
         }
     }
-    // to add defaults - may not optimal for performance
     handleUndefinedProps(id, q, item);
     return i - offset;
 };

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

@@ -0,0 +1,4 @@
+export declare const READ_ID = 255;
+export declare const READ_EDGE = 252;
+export declare const READ_REFERENCES = 253;
+export declare const READ_REFERENCE = 254;

package/dist/src/client/query/read/types.js

@@ -0,0 +1,5 @@
+export const READ_ID = 255;
+export const READ_EDGE = 252;
+export const READ_REFERENCES = 253;
+export const READ_REFERENCE = 254;
+//# sourceMappingURL=types.js.map

package/dist/src/client/query/validation.d.ts

@@ -1,5 +1,6 @@
-import { PropDef, SchemaTypeDef } from '../../server/schema/types.js';
+import { PropDef, PropDefEdge, SchemaTypeDef } from '../../server/schema/types.js';
 import { DbClient } from '../index.js';
+import { Filter } from './query.js';
 import { QueryByAliasObj, QueryDef } from './types.js';
 export type QueryError = {
     code: number;
@@ -29,8 +30,13 @@ declare const messages: {
     7: (p: any) => string;
     12: (p: any) => string;
     9: (p: any) => string;
+    8: (p: Filter) => string;
+    11: (p: any) => string;
+    10: (p: any) => string;
 };
 export type ErrorCode = keyof typeof messages;
+export declare const isValidId: (id: number) => boolean;
+export declare const validateFilter: (def: QueryDef, prop: PropDef | PropDefEdge, f: Filter) => boolean;
 export declare const validateType: (db: DbClient, def: QueryDef, type: string) => SchemaTypeDef;
 export declare const filterOperatorDoesNotExist: (def: QueryDef, field: string) => void;
 export declare const filterInvalidLang: (def: QueryDef, field: string) => void;

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

@@ -1,5 +1,7 @@
-import { ALIAS } from '../../server/schema/types.js';
-import { MAX_ID, MAX_IDS_PER_QUERY } from './thresholds.js';
+import { ALIAS, BOOLEAN, REFERENCE, REFERENCES, STRING, TEXT, VECTOR, } from '../../server/schema/types.js';
+import { propIsNumerical } from '../../server/schema/utils.js';
+import { EQUAL, HAS, isNumerical, LIKE, operatorReverseMap, VECTOR_FNS, } from './filter/types.js';
+import { MAX_ID, MAX_ID_VALUE, MAX_IDS_PER_QUERY, MIN_ID_VALUE, } from './thresholds.js';
 export const ERR_TARGET_INVAL_TYPE = 1;
 export const ERR_TARGET_INVAL_ALIAS = 2;
 export const ERR_TARGET_EXCEED_MAX_IDS = 3;
@@ -13,17 +15,20 @@ export const ERR_FILTER_INVALID_VAL = 10;
 export const ERR_FILTER_INVALID_OPTS = 11;
 export const ERR_FILTER_INVALID_LANG = 12;
 export const ERR_INCLUDE_INVALID_LANG = 13;
+const safeStringify = (p) => {
+    var v;
+    try {
+        v = JSON.stringify(p).replace(/"/g, '');
+    }
+    catch (err) {
+        v = '';
+    }
+    return v;
+};
 const messages = {
     [ERR_TARGET_INVAL_TYPE]: (p) => `Type "${p}" does not exist`,
     [ERR_TARGET_INVAL_ALIAS]: (p) => {
-        var v;
-        try {
-            v = JSON.stringify(p).replace(/"/g, '');
-        }
-        catch (err) {
-            v = '';
-        }
-        return `Invalid alias prodived to query "${v}"`;
+        return `Invalid alias prodived to query "${safeStringify(p)}"`;
     },
     [ERR_TARGET_EXCEED_MAX_IDS]: (p) => `Exceeds max ids ${~~(p.length / 1e3)}k (max ${MAX_IDS_PER_QUERY / 1e3}k)`,
     [ERR_TARGET_INVAL_IDS]: (p) => `Ids should be of type array or Uint32Array with valid ids`,
@@ -33,6 +38,118 @@ const messages = {
     [ERR_FILTER_ENOENT]: (p) => `Filter: field does not exist "${p}"`,
     [ERR_FILTER_INVALID_LANG]: (p) => `Filter: invalid lang "${p}"`,
     [ERR_FILTER_OP_ENOENT]: (p) => `Filter: invalid operator "${p}"`,
+    [ERR_FILTER_OP_FIELD]: (p) => `Cannot use operator "${operatorReverseMap[p[1].operation]}" on field "${p[0]}"`,
+    [ERR_FILTER_INVALID_OPTS]: (p) => {
+        return `Filter: Invalid opts "${safeStringify(p)}"`;
+    },
+    [ERR_FILTER_INVALID_VAL]: (p) => {
+        return `Filter: Invalid value ${p[0]} ${operatorReverseMap[p[1].operation]} "${safeStringify(p[2])}"`;
+    },
+};
+export const isValidId = (id) => {
+    if (typeof id != 'number') {
+        return false;
+    }
+    else if (id < MIN_ID_VALUE || id > MAX_ID_VALUE) {
+        return false;
+    }
+    return true;
+};
+export const validateFilter = (def, prop, f) => {
+    const t = prop.typeIndex;
+    const op = f[1].operation;
+    const value = f[2];
+    if (t === REFERENCES) {
+        if (op == LIKE) {
+            def.errors.push({
+                code: ERR_FILTER_OP_FIELD,
+                payload: f,
+            });
+            return true;
+        }
+    }
+    else if (t === REFERENCE) {
+        if (op != EQUAL) {
+            def.errors.push({
+                code: ERR_FILTER_OP_FIELD,
+                payload: f,
+            });
+            return true;
+        }
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                if (!isValidId(v)) {
+                    def.errors.push({
+                        code: ERR_FILTER_INVALID_VAL,
+                        payload: f,
+                    });
+                    return true;
+                }
+            }
+        }
+        else if (!isValidId(value)) {
+            def.errors.push({
+                code: ERR_FILTER_INVALID_VAL,
+                payload: f,
+            });
+            return true;
+        }
+    }
+    else if (t === VECTOR) {
+        if (isNumerical(op) || op === HAS) {
+            def.errors.push({
+                code: ERR_FILTER_OP_FIELD,
+                payload: f,
+            });
+            return true;
+        }
+        if (op === LIKE) {
+            const opts = f[1].opts;
+            if ((opts.fn && !VECTOR_FNS.includes(opts.fn)) ||
+                (opts.score != undefined && typeof opts.score !== 'number')) {
+                def.errors.push({
+                    code: ERR_FILTER_INVALID_OPTS,
+                    payload: f,
+                });
+                return true;
+            }
+        }
+    }
+    else if (t === TEXT || t === STRING) {
+        if (isNumerical(op)) {
+            def.errors.push({
+                code: ERR_FILTER_OP_FIELD,
+                payload: f,
+            });
+            return true;
+        }
+        if (op === LIKE) {
+            const opts = f[1].opts;
+            if (opts.score &&
+                (typeof opts.score !== 'number' || opts.score < 0 || opts.score > 255)) {
+                def.errors.push({
+                    code: ERR_FILTER_INVALID_OPTS,
+                    payload: f,
+                });
+                return true;
+            }
+        }
+    }
+    else if (propIsNumerical(prop) && op !== EQUAL && !isNumerical(op)) {
+        def.errors.push({
+            code: ERR_FILTER_OP_FIELD,
+            payload: f,
+        });
+        return true;
+    }
+    else if (t === BOOLEAN && op !== EQUAL) {
+        def.errors.push({
+            code: ERR_FILTER_OP_FIELD,
+            payload: f,
+        });
+        return true;
+    }
+    return false;
 };
 export const validateType = (db, def, type) => {
     const r = db.schemaTypesParsed[type];
@@ -155,8 +272,8 @@ export const handleErrors = (def) => {
         for (const err of def.errors) {
             name += `  ${messages[err.code](err.payload)}\n`;
         }
-        const err = new Error(name);
-        err.stack = '';
+        const err = new Error(`Query\n`);
+        err.stack = name;
         throw err;
     }
 };
@@ -193,40 +310,6 @@ export const EMPTY_SCHEMA_DEF = {
     stringProps: Buffer.from([]),
     stringPropsLoop: [],
 };
-// import { ALIAS, PropDef, PropDefEdge } from '../../server/schema/types.js'
-// import {
-//   MAX_IDS_PER_QUERY,
-//   MIN_ID_VALUE,
-//   MAX_ID_VALUE,
-//   MAX_BUFFER_SIZE,
-// } from './thresholds.js'
-// import { QueryByAliasObj, QueryDef } from './types.js'
-// import { DbClient } from '../index.js'
-// export const isValidId = (id: number): void => {
-//   if (typeof id != 'number') {
-//     throw new Error('Id has to be a number')
-//   } else if (id < MIN_ID_VALUE || id > MAX_ID_VALUE) {
-//     throw new Error(
-//       `Invalid Id: The Id should range between ${MIN_ID_VALUE} and ${MAX_ID_VALUE}.)`,
-//     )
-//   }
-// }
-// export const isValidType = (
-//   type: string,
-//   schema: DbClient['schemaTypesParsed'],
-// ): void => {
-//   if (!schema[type]) {
-//     throw new Error(`Incorrect type provided to query "${type}"`)
-//   }
-// }
-// export const isValidAlias = (def: QueryDef, id: QueryByAliasObj) => {
-//   for (const key in id) {
-//     const prop = def.schema.props[key]
-//     if (!prop || prop.typeIndex !== ALIAS) {
-//       throw new Error(`Incorrect alias provided to query "${key}"`)
-//     }
-//   }
-// }
 // export const checkMaxIdsPerQuery = (
 //   ids: (number | QueryByAliasObj)[],
 // ): void => {

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

@@ -1 +1 @@
-export declare const xxHash64: (buf: Buffer) => any;
+export declare const xxHash64: (buf: Buffer, target?: Buffer, index?: number) => Buffer;

package/dist/src/client/xxHash64.js

@@ -1,5 +1,10 @@
 import native from '../native.js';
-export const xxHash64 = (buf) => {
-    return native.xxHash64(buf);
+export const xxHash64 = (buf, target, index) => {
+    if (!target) {
+        target = Buffer.allocUnsafe(8);
+        index = 0;
+    }
+    native.xxHash64(buf, target, index);
+    return target;
 };
 //# sourceMappingURL=xxHash64.js.map

package/dist/src/index.d.ts

@@ -7,12 +7,14 @@ export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx };
 export { DbClient, DbServer };
+export { xxHash64 } from './client/xxHash64.js';
 export declare class BasedDb {
+    #private;
     client: DbClient;
     server: DbServer;
     fileSystemPath: string;
     maxModifySize: number;
-    constructor({ path, maxModifySize, }: {
+    constructor(opt: {
         path: string;
         maxModifySize?: number;
     });
@@ -31,4 +33,5 @@ export declare class BasedDb {
     save: DbServer['save'];
     migrateSchema: DbServer['migrateSchema'];
     destroy(): Promise<void>;
+    wipe(): Promise<void>;
 }

package/dist/src/index.js

@@ -7,12 +7,18 @@ export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx }; // TODO move this somewhere
 export { DbClient, DbServer };
+export { xxHash64 } from './client/xxHash64.js';
 export class BasedDb {
     client;
     server;
     fileSystemPath;
     maxModifySize;
-    constructor({ path, maxModifySize, }) {
+    constructor(opt) {
+        this.#init(opt);
+    }
+    #init({ path, maxModifySize }) {
+        this.fileSystemPath = path;
+        this.maxModifySize = maxModifySize;
         const server = new DbServer({
             path,
             maxModifySize,
@@ -91,5 +97,14 @@ export class BasedDb {
         this.client.destroy();
         return this.server.destroy();
     }
+    async wipe() {
+        const opts = {
+            maxModifySize: this.maxModifySize,
+            path: this.fileSystemPath,
+        };
+        await this.destroy();
+        this.#init(opts);
+        await this.start({ clean: true });
+    }
 }
 //# sourceMappingURL=index.js.map

package/dist/src/native.d.ts

@@ -24,6 +24,6 @@ declare const _default: {
     crc32: (buf: Buffer) => any;
     createSortIndex: (buf: Buffer, dbCtx: any) => any;
     destroySortIndex: (buf: Buffer, dbCtx: any) => any;
-    xxHash64: (buf: Buffer) => any;
+    xxHash64: (buf: Buffer, target: Buffer, index: number) => any;
 };
 export default _default;

package/dist/src/native.js

@@ -93,8 +93,8 @@ export default {
     destroySortIndex: (buf, dbCtx) => {
         return db.destroySortIndex(dbCtx, buf);
     },
-    xxHash64: (buf) => {
-        return db.xxHash64(buf);
+    xxHash64: (buf, target, index) => {
+        return db.xxHash64(buf, target, index);
     },
 };
 //# sourceMappingURL=native.js.map

package/dist/src/server/schema/utils.d.ts

@@ -2,5 +2,6 @@ import { DbClient } from '../../client/index.js';
 import { DbServer } from '../index.js';
 import { PropDef, PropDefEdge } from './types.js';
 export declare const propIsSigned: (prop: PropDef | PropDefEdge) => boolean;
+export declare const propIsNumerical: (prop: PropDef | PropDefEdge) => boolean;
 export declare const genRootId: () => number;
 export declare const genId: (db: DbServer | DbClient) => number;

package/dist/src/server/schema/utils.js

@@ -1,9 +1,22 @@
-import { INT16, INT32, INT64, INT8 } from './types.js';
+import { INT16, INT32, INT64, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, } from './types.js';
 export const propIsSigned = (prop) => {
-    if (prop.typeIndex === INT16 ||
-        prop.typeIndex === INT32 ||
-        prop.typeIndex === INT64 ||
-        prop.typeIndex === INT8) {
+    const t = prop.typeIndex;
+    if (t === INT16 || t === INT32 || t === INT64 || t === INT8) {
+        return true;
+    }
+    return false;
+};
+export const propIsNumerical = (prop) => {
+    const t = prop.typeIndex;
+    if (t === INT16 ||
+        t === INT32 ||
+        t === INT64 ||
+        t === INT8 ||
+        t === UINT8 ||
+        t === UINT16 ||
+        t === UINT32 ||
+        t === NUMBER ||
+        t === TIMESTAMP) {
         return true;
     }
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",

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

@@ -1,5 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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