@based/db 0.0.10 → 0.0.12

package/dist/lib/darwin_aarch64/include/selva/fields.h

@@ -119,17 +119,6 @@ int selva_fields_set(
         const struct SelvaFieldSchema *fs,
         const void *value, size_t len);
 
-/**
- * Set field value with CRC.
- */
-SELVA_EXPORT
-int selva_fields_set_wcrc(
-        struct SelvaDb *db,
-        struct SelvaNode *node,
-        const struct SelvaFieldSchema *fs,
-        const void *value, size_t len,
-        uint32_t crc);
-
 SELVA_EXPORT
 int selva_fields_get_mutable_string(
         struct SelvaNode *node,
@@ -160,6 +149,7 @@ int selva_fields_reference_set(
 
 /**
  * @param index 0 = first; -1 = last.
+ * @param reorder move the existing ref to `index` instead of returning EEXIST.
  */
 SELVA_EXPORT
 int selva_fields_references_insert(
@@ -243,7 +233,12 @@ int selva_fields_get_reference_meta_mutable_string(
  * +------+------+--------+-----+
  */
 SELVA_EXPORT
-int selva_fields_set_string(struct SelvaNode *node, const struct SelvaFieldSchema *fs, struct SelvaFieldInfo *nfo, const char *str, size_t len);
+int selva_fields_set_string(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        struct SelvaFieldInfo *nfo,
+        const char *str,
+        size_t len);
 
 /**
  * Set text field translation.
@@ -326,7 +321,7 @@ SELVA_EXPORT
 void selva_fields_clear_references(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs);
 
 /**
- * Init fields of a node.
+ * Init the fields struct of a node or edge.
  */
 SELVA_EXPORT
 void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaFields *fields);

package/dist/lib/linux_aarch64/include/selva/fields.h

@@ -119,17 +119,6 @@ int selva_fields_set(
         const struct SelvaFieldSchema *fs,
         const void *value, size_t len);
 
-/**
- * Set field value with CRC.
- */
-SELVA_EXPORT
-int selva_fields_set_wcrc(
-        struct SelvaDb *db,
-        struct SelvaNode *node,
-        const struct SelvaFieldSchema *fs,
-        const void *value, size_t len,
-        uint32_t crc);
-
 SELVA_EXPORT
 int selva_fields_get_mutable_string(
         struct SelvaNode *node,
@@ -160,6 +149,7 @@ int selva_fields_reference_set(
 
 /**
  * @param index 0 = first; -1 = last.
+ * @param reorder move the existing ref to `index` instead of returning EEXIST.
  */
 SELVA_EXPORT
 int selva_fields_references_insert(
@@ -243,7 +233,12 @@ int selva_fields_get_reference_meta_mutable_string(
  * +------+------+--------+-----+
  */
 SELVA_EXPORT
-int selva_fields_set_string(struct SelvaNode *node, const struct SelvaFieldSchema *fs, struct SelvaFieldInfo *nfo, const char *str, size_t len);
+int selva_fields_set_string(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        struct SelvaFieldInfo *nfo,
+        const char *str,
+        size_t len);
 
 /**
  * Set text field translation.
@@ -326,7 +321,7 @@ SELVA_EXPORT
 void selva_fields_clear_references(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs);
 
 /**
- * Init fields of a node.
+ * Init the fields struct of a node or edge.
  */
 SELVA_EXPORT
 void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaFields *fields);

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

@@ -119,17 +119,6 @@ int selva_fields_set(
         const struct SelvaFieldSchema *fs,
         const void *value, size_t len);
 
-/**
- * Set field value with CRC.
- */
-SELVA_EXPORT
-int selva_fields_set_wcrc(
-        struct SelvaDb *db,
-        struct SelvaNode *node,
-        const struct SelvaFieldSchema *fs,
-        const void *value, size_t len,
-        uint32_t crc);
-
 SELVA_EXPORT
 int selva_fields_get_mutable_string(
         struct SelvaNode *node,
@@ -160,6 +149,7 @@ int selva_fields_reference_set(
 
 /**
  * @param index 0 = first; -1 = last.
+ * @param reorder move the existing ref to `index` instead of returning EEXIST.
  */
 SELVA_EXPORT
 int selva_fields_references_insert(
@@ -243,7 +233,12 @@ int selva_fields_get_reference_meta_mutable_string(
  * +------+------+--------+-----+
  */
 SELVA_EXPORT
-int selva_fields_set_string(struct SelvaNode *node, const struct SelvaFieldSchema *fs, struct SelvaFieldInfo *nfo, const char *str, size_t len);
+int selva_fields_set_string(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        struct SelvaFieldInfo *nfo,
+        const char *str,
+        size_t len);
 
 /**
  * Set text field translation.
@@ -326,7 +321,7 @@ SELVA_EXPORT
 void selva_fields_clear_references(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs);
 
 /**
- * Init fields of a node.
+ * Init the fields struct of a node or edge.
  */
 SELVA_EXPORT
 void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaFields *fields);

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

@@ -47,7 +47,7 @@ export declare class DbClient {
     };
     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(type: string, id?: number | ModifyRes | (number | ModifyRes)[] | QueryByAliasObj | QueryByAliasObj[] | Uint32Array): BasedDbQuery;
     query(): BasedDbQuery;
     update(type: string, id: number | ModifyRes, value: any, opts?: ModifyOpts): ModifyRes;
     update(type: string, value: Record<string, any> & {

package/dist/src/client/index.js

@@ -114,6 +114,9 @@ export class DbClient {
                 }
             }
         }
+        else if (id instanceof Uint32Array) {
+            // all good
+        }
         else if (typeof id === 'object') {
             if (id instanceof ModifyState) {
                 id = id.tmpId;

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

@@ -1,4 +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;
+export declare function writeHll(value: string | null | Buffer | Array<string | Buffer>, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -7,44 +7,36 @@ export function writeHll(value, ctx, def, t, parentId, modifyOp) {
         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
-        // }
+        // Future hll_reset frunction
+        return;
     }
-    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);
+    else if (!Array.isArray(value)) {
+        value = [value];
     }
+    const err = addHll(value, ctx, def, t, parentId, modifyOp);
 }
 function addHll(value, ctx, def, t, parentId, modifyOp) {
-    let size = 8;
+    const len = value.length;
+    let size = 2 + len * 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;
+    ctx.buf.writeUint16LE(len, ctx.len);
+    ctx.len += 2;
+    for (let val of value) {
+        let b;
+        if (typeof val === 'string') {
+            b = Buffer.from(val);
+        }
+        else if (!(val instanceof Buffer)) {
+            b = val;
+            return new ModifyError(t, val);
+        }
+        const hash = xxHash64(b);
+        ctx.buf.writeBigUInt64LE(hash, ctx.len);
+        ctx.len += 8;
+    }
 }
 //# sourceMappingURL=cardinality.js.map

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

@@ -31,11 +31,11 @@ declare class GetPromise extends Promise<BasedQueryResponse> {
 }
 export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     #private;
-    constructor(db: DbClient, type: string, id?: QueryByAliasObj | number | (QueryByAliasObj | number)[]);
+    constructor(db: DbClient, type: string, id?: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[]);
     id: number;
     get(): GetPromise;
     buffer: Buffer;
-    register(): Buffer;
+    register(): void;
     i18n(locale: LangName): this;
     subscribe(onData: OnData, onError?: OnError): import("./subscription/types.js").OnClose;
     _getSync(dbCtxExternal: any): BasedQueryResponse;

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

@@ -1,9 +1,8 @@
-import { createQueryDef, QueryDefType, includeFields, filter, sort, defToBuffer, filterOr, convertFilter, isAlias, includeField, } from './query.js';
+import { createQueryDef, QueryDefType, filter, sort, defToBuffer, filterOr, convertFilter, isAlias, includeField, includeFields, } from './query.js';
 import { BasedQueryResponse } from './BasedIterable.js';
 import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef, } from './include/utils.js';
 import { FilterBranch } from './filter/FilterBranch.js';
 import { search, vectorSearch } from './search/index.js';
-import { isValidId, checkMaxIdsPerQuery, checkTotalBufferSize, hasField, isValidAlias, } from './validation.js';
 import native from '../../native.js';
 import { REFERENCE, REFERENCES } from '../../server/schema/types.js';
 import { subscribe } from './subscription/index.js';
@@ -140,10 +139,7 @@ export class QueryBranch {
                 });
             }
             else if (Array.isArray(f)) {
-                for (const field of f) {
-                    hasField(field);
-                    includeField(this.def, field);
-                }
+                includeFields(this.def, f);
             }
             else if (f !== undefined) {
                 throw new Error('Invalid include statement: expected props, refs and edges (string or array) or function');
@@ -178,39 +174,33 @@ export class BasedDbQuery extends QueryBranch {
                 target.alias = id;
             }
             else {
-                if (Array.isArray(id)) {
-                    checkMaxIdsPerQuery(id);
-                    // const ids = id.filter((id) => typeof id === 'number')
-                    // if (ids.length < id.length) {
-                    //   throw new Error(
-                    //     'Seems that aliases are part of ids in qeury not supported yet...',
-                    //   )
-                    // }
+                if (Array.isArray(id) || id instanceof Uint32Array) {
                     // TODO ADD MULTI ALIAS
                     // @ts-ignore
-                    target.ids = new Uint32Array(id);
-                    for (const id of target.ids) {
-                        isValidId(id);
-                    }
-                    target.ids.sort();
+                    target.ids = id;
+                    // target.ids = new Uint32Array(id)
+                    // target.ids.sort()
                 }
                 else {
-                    isValidId(id);
                     target.id = id;
                 }
             }
         }
         const def = createQueryDef(db, QueryDefType.Root, target);
-        if (isAlias(id)) {
-            isValidAlias(def, id);
-        }
         super(db, def);
     }
     #getInternal = async (resolve, reject) => {
         if (!this.def.include.stringFields.size && !this.def.references.size) {
-            includeFields(this.def, ['*']);
+            includeField(this.def, '*');
+        }
+        let buf;
+        try {
+            buf = registerQuery(this);
+        }
+        catch (err) {
+            reject(err);
+            return;
         }
-        const buf = registerQuery(this);
         const d = performance.now();
         const res = await this.db.hooks.getQueryBuf(buf);
         if (res instanceof Error) {
@@ -227,7 +217,7 @@ export class BasedDbQuery extends QueryBranch {
     }
     buffer;
     register() {
-        return registerQuery(this);
+        registerQuery(this);
     }
     i18n(locale) {
         this.def.lang = langCodesMap.get(locale) ?? 0;
@@ -241,7 +231,7 @@ export class BasedDbQuery extends QueryBranch {
     }
     _getSync(dbCtxExternal) {
         if (!this.def.include.stringFields.size && !this.def.references.size) {
-            includeFields(this.def, ['*']);
+            includeField(this.def, '*');
         }
         const buf = registerQuery(this);
         const d = performance.now();
@@ -250,10 +240,9 @@ export class BasedDbQuery extends QueryBranch {
     }
     toBuffer() {
         if (!this.def.include.stringFields.size && !this.def.references.size) {
-            includeFields(this.def, ['*']);
+            includeField(this.def, '*');
         }
         const b = defToBuffer(this.db, this.def);
-        checkTotalBufferSize(b);
         return Buffer.concat(b);
     }
 }

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

@@ -2,7 +2,6 @@ import { isPropDef, ID_FIELD_DEF, TEXT, } from '../../../server/schema/schema.js
 import { primitiveFilter } from './primitiveFilter.js';
 import { toFilterCtx } from './types.js';
 import { IsFilter } from './types.js';
-import { hasField, checkOperator, checkValue } from '../validation.js';
 import { langCodesMap } from '@based/schema';
 const referencesFilter = (db, filter, schema, conditions, def) => {
     const [fieldStr, ctx, value] = filter;
@@ -111,9 +110,6 @@ export const convertFilter = (field, operator, value, opts) => {
         value = operator;
         operator = '=';
     }
-    hasField(field);
-    checkOperator(operator);
-    checkValue(value, operator);
     if (operator === '!..') {
         return [
             [field, toFilterCtx('>', opts), value[1]],

package/dist/src/client/query/include/walk.js

@@ -2,8 +2,9 @@ import { isPropDef, REFERENCE, REFERENCES, TEXT, } from '../../../server/schema/
 import { createQueryDef } from '../queryDef.js';
 import { isRefDef, QueryDefType } from '../types.js';
 import { getAllFieldFromObject, createOrGetRefQueryDef } from './utils.js';
-import { includeFields, includeProp, includeAllProps } from './props.js';
+import { includeProp, includeAllProps, includeField } from './props.js';
 import { langCodesMap } from '@based/schema';
+import { includeDoesNotExist } from '../validation.js';
 export const walkDefs = (db, def, f) => {
     const prop = def.props[f];
     const path = f.split('.');
@@ -28,7 +29,7 @@ export const walkDefs = (db, def, f) => {
                     else {
                         const f = path.slice(i + 1).join('.');
                         if (!includeProp(refDef, refDef.props[f])) {
-                            includeFields(refDef, [f]);
+                            includeField(refDef, f);
                         }
                         return;
                     }
@@ -40,6 +41,9 @@ export const walkDefs = (db, def, f) => {
             }
             t = t[p];
             if (!t) {
+                if (f != 'id') {
+                    includeDoesNotExist(def, f);
+                }
                 return;
             }
             if (isPropDef(t) && t.typeIndex === TEXT) {
@@ -55,7 +59,7 @@ export const walkDefs = (db, def, f) => {
                 const refDef = createOrGetRefQueryDef(db, def, t);
                 const f = path.slice(i + 1).join('.');
                 if (!includeProp(refDef, refDef.props[f])) {
-                    includeFields(refDef, [f]);
+                    includeField(refDef, f);
                 }
                 return;
             }

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

@@ -1,8 +1,10 @@
 import { langCodesMap } from '@based/schema';
-import { MAX_RANGE_PROP_LIMIT, MAX_RANGE_REF_LIMIT } from './thresholds.js';
+import { DEF_RANGE_PROP_LIMIT, DEF_RANGE_REF_LIMIT } from './thresholds.js';
 import { QueryDefType, } from './types.js';
+import { validateId, validateIds, validateType } from './validation.js';
 const createEmptySharedDef = () => {
     const q = {
+        errors: [],
         filter: { conditions: new Map(), size: 0 },
         range: { offset: 0, limit: 0 },
         lang: langCodesMap.get('none'),
@@ -35,21 +37,24 @@ export const createQueryDef = (db, type, target) => {
     else {
         const t = target;
         const q = queryDef;
-        q.schema = db.schemaTypesParsed[t.type];
+        q.schema = validateType(db, q, t.type);
         q.props = q.schema.props;
         q.type = type;
         q.target = t;
         if (type === QueryDefType.Root) {
-            // IDS sort
-            if (t.ids) {
-                q.range.limit = t.ids.length; // 1k?
+            if (t.id) {
+                t.id = validateId(q, t.id);
+            }
+            else if (t.ids) {
+                t.ids = validateIds(q, t.ids);
+                q.range.limit = t.ids.length;
             }
             else {
-                q.range.limit = MAX_RANGE_PROP_LIMIT;
+                q.range.limit = DEF_RANGE_PROP_LIMIT;
             }
         }
         else if (type === QueryDefType.References) {
-            q.range.limit = MAX_RANGE_REF_LIMIT;
+            q.range.limit = DEF_RANGE_REF_LIMIT;
         }
         return q;
     }

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

@@ -1,29 +1,14 @@
 import native from '../../native.js';
 import { defToBuffer } from './toBuffer.js';
-import { checkMaxBufferSize } from './validation.js';
+import { handleErrors } from './validation.js';
 export const registerQuery = (q) => {
-    // just add crc32 in the buffer
     if (!q.id) {
         const b = defToBuffer(q.db, q.def);
         const buf = Buffer.concat(b);
         let id = native.crc32(buf);
         q.id = id;
-        //   id = (id ^ q.def.schema.id) >>> 0
-        // typeId, crc32, len
-        // but want it to fit in a js number...
-        // use 2 bytes for len and just continue counting
-        //   const x = Buffer.allocUnsafe(8)
-        //   // const number
-        //   x.writeUint16LE(q.def.schema.id, 0)
-        //   x.writeUint32LE(id, 2)
-        //   x.writeUint16LE(buf.byteLength, 6)
-        //   // ------------------------
-        //   console.log('-> CRC32', { id, x: new Uint8Array(x), y: x.readFloatLE(0) })
-        // do a test for
-        //   console.log(id)
-        // id, len, type as id?
         q.buffer = buf;
-        checkMaxBufferSize(buf);
+        handleErrors(q.def);
         return buf;
     }
     return q.buffer;

package/dist/src/client/query/subscription/index.js

@@ -1,4 +1,4 @@
-import { includeFields } from '../query.js';
+import { includeField } from '../query.js';
 import { registerQuery } from '../registerQuery.js';
 import { runSubscription } from './run.js';
 import { addSubscriptionMarkers, deleteSubscriptionMarkers } from './markers.js';
@@ -7,9 +7,15 @@ export * from './markers.js';
 export const subscribe = (q, onData, onError) => {
     let closed = false;
     if (!q.def.include.stringFields.size && !q.def.references.size) {
-        includeFields(q.def, ['*']);
+        includeField(q.def, '*');
+    }
+    try {
+        registerQuery(q);
+    }
+    catch (err) {
+        onError(err);
+        return () => q;
     }
-    registerQuery(q);
     if (!q.db.subscriptions.has(q.id)) {
         const subscription = {
             query: q,

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

@@ -1,6 +1,7 @@
 export declare const MAX_IDS_PER_QUERY = 1000000;
 export declare const MAX_BUFFER_SIZE: number;
-export declare const MAX_RANGE_PROP_LIMIT = 1000;
-export declare const MAX_RANGE_REF_LIMIT = 10000;
+export declare const DEF_RANGE_PROP_LIMIT = 1000;
+export declare const DEF_RANGE_REF_LIMIT = 10000;
+export declare const MAX_ID = 4294967295;
 export declare const MIN_ID_VALUE = 1;
 export declare const MAX_ID_VALUE: number;

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

@@ -1,8 +1,9 @@
 // Query thresholds
 export const MAX_IDS_PER_QUERY = 1e6; // Max number of IDs that can be queried at once
 export const MAX_BUFFER_SIZE = 5 * 1024 * 1024; // 5MB (max buffer size)
-export const MAX_RANGE_PROP_LIMIT = 1e3;
-export const MAX_RANGE_REF_LIMIT = 1e4;
+export const DEF_RANGE_PROP_LIMIT = 1e3;
+export const DEF_RANGE_REF_LIMIT = 1e4;
+export const MAX_ID = 4294967295;
 // Data validation thresholds
 export const MIN_ID_VALUE = 1; // Minimum allowed value for an ID (id array stared)
 export const MAX_ID_VALUE = 2 ** 32 - 1; /// Maximum allowed value for an ID (Uint32)

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

@@ -28,10 +28,16 @@ const getAliasPropdef = (alias, path, def) => {
     }
 };
 export function defToBuffer(db, def) {
+    // if (def.errors.length) {
+    //   return []
+    // }
     const result = [];
     const include = includeToBuffer(db, def);
     def.references.forEach((ref) => {
         include.push(...defToBuffer(db, ref));
+        if (ref.errors) {
+            def.errors.push(...ref.errors);
+        }
     });
     let edges;
     let edgesSize = 0;
@@ -39,6 +45,9 @@ export function defToBuffer(db, def) {
         edges = includeToBuffer(db, def.edges);
         def.edges.references.forEach((ref) => {
             edges.push(...defToBuffer(db, ref));
+            if (ref.errors) {
+                def.errors.push(...ref.errors);
+            }
         });
         edgesSize = byteSize(edges);
     }

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

@@ -1,6 +1,7 @@
 import { LangCode } from '@based/schema';
 import { PropDef, PropDefEdge, SchemaTypeDef } from '../../server/schema/schema.js';
 import { FilterOpts } from './filter/types.js';
+import { QueryError } from './validation.js';
 export type MainIncludes = {
     [start: string]: [number, PropDef];
 };
@@ -54,6 +55,7 @@ export type QueryDefSort = {
     order: 0 | 1;
 };
 export type QueryDefShared = {
+    errors: QueryError[];
     lang: LangCode;
     filter: QueryDefFilter;
     search: null | QueryDefSearch;
@@ -97,4 +99,4 @@ export { QueryDefType };
 export type QueryByAliasObj = {
     [key: string]: string | QueryByAliasObj;
 };
-export declare const isAlias: (id: QueryByAliasObj | number | (QueryByAliasObj | number)[]) => id is QueryByAliasObj;
+export declare const isAlias: (id: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[]) => id is QueryByAliasObj;

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

@@ -10,6 +10,9 @@ export const isRefDef = (def) => {
 };
 export { QueryDefType };
 export const isAlias = (id) => {
+    if (id instanceof Uint32Array) {
+        return false;
+    }
     return typeof id === 'object' && id !== null && !Array.isArray(id);
 };
 //# sourceMappingURL=types.js.map

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

@@ -1,16 +1,29 @@
-import { PropDef, PropDefEdge } from '../../server/schema/types.js';
-import { Operator } from './filter/types.js';
-import { QueryByAliasObj, QueryDef } from './types.js';
-export declare const isValidId: (id: number) => void;
-export declare const checkMaxIdsPerQuery: (ids: (number | QueryByAliasObj)[]) => void;
-export declare const checkMaxBufferSize: (buf: Buffer) => void;
-export declare const checkTotalBufferSize: (bufers: Buffer[]) => void;
-export declare const hasFields: (fields: {
-    [key: string]: PropDefEdge;
-} | {
-    [path: string]: PropDef;
-}) => void;
-export declare const isValidAlias: (def: QueryDef, id: QueryByAliasObj) => void;
-export declare const hasField: (field: string) => void;
-export declare const checkOperator: (operator: Operator | boolean) => void;
-export declare const checkValue: (value: any, operator: Operator) => void;
+import { SchemaTypeDef } from '../../server/schema/types.js';
+import { DbClient } from '../index.js';
+import { QueryDef } from './types.js';
+export type QueryError = {
+    code: number;
+    payload: any;
+};
+export declare const ERR_TARGET_INVAL_TYPE = 1;
+export declare const ERR_TARGET_INVAL_ALIAS = 2;
+export declare const ERR_TARGET_EXCEED_MAX_IDS = 3;
+export declare const ERR_TARGET_INVAL_IDS = 4;
+export declare const ERR_TARGET_INVAL_ID = 5;
+export declare const ERR_INCLUDE_ENOENT = 6;
+declare const messages: {
+    1: (p: any) => string;
+    2: (p: any) => string;
+    3: (p: any) => string;
+    4: (p: any) => string;
+    5: (p: any) => string;
+    6: (p: any) => string;
+};
+export type ErrorCode = keyof typeof messages;
+export declare const validateType: (db: DbClient, def: QueryDef, type: string) => SchemaTypeDef;
+export declare const includeDoesNotExist: (def: QueryDef, field: string) => void;
+export declare const validateId: (def: QueryDef, id: any) => number;
+export declare const validateIds: (def: QueryDef, ids: any) => Uint32Array;
+export declare const handleErrors: (def: QueryDef) => void;
+export declare const EMPTY_SCHEMA_DEF: SchemaTypeDef;
+export {};

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

@@ -1,74 +1,184 @@
-import { ALIAS } from '../../server/schema/types.js';
-import { MAX_IDS_PER_QUERY, MIN_ID_VALUE, MAX_ID_VALUE, MAX_BUFFER_SIZE, } from './thresholds.js';
-import { validOperators } from './filter/types.js';
-export const isValidId = (id) => {
-    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 checkMaxIdsPerQuery = (ids) => {
-    if (ids.length > MAX_IDS_PER_QUERY) {
-        throw new Error(`The number of IDs cannot exceed ${MAX_IDS_PER_QUERY}.`);
-    }
+import { MAX_ID, MAX_IDS_PER_QUERY } 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;
+export const ERR_TARGET_INVAL_IDS = 4;
+export const ERR_TARGET_INVAL_ID = 5;
+export const ERR_INCLUDE_ENOENT = 6;
+const messages = {
+    [ERR_TARGET_INVAL_TYPE]: (p) => `Type "${p}" does not exist`,
+    [ERR_TARGET_INVAL_ALIAS]: (p) => `Invalid alias "${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`,
+    [ERR_TARGET_INVAL_ID]: (p) => `Invalid id should be a number larger then 0 "${p}"`,
+    [ERR_INCLUDE_ENOENT]: (p) => `Included field does not exist "${p}"`,
 };
-export const checkMaxBufferSize = (buf) => {
-    if (buf.byteLength > MAX_BUFFER_SIZE) {
-        throw new Error(`The buffer size exceeds the maximum threshold of ${MAX_BUFFER_SIZE} bytes.` +
-            `Crrent size is ${buf.byteLength} bytes.`);
+export const validateType = (db, def, type) => {
+    const r = db.schemaTypesParsed[type];
+    if (!r) {
+        def.errors.push({
+            code: ERR_TARGET_INVAL_TYPE,
+            payload: type,
+        });
+        EMPTY_SCHEMA_DEF.locales = db.schema.locales;
+        return EMPTY_SCHEMA_DEF;
     }
+    return r;
 };
-export const checkTotalBufferSize = (bufers) => {
-    let totalSize = 0;
-    for (const buffer of bufers) {
-        totalSize += buffer.byteLength;
-        if (totalSize > MAX_BUFFER_SIZE) {
-            throw new Error(`The total buffer size exceeds the maximum threshold of ${MAX_BUFFER_SIZE} bytes.` +
-                `Crrent size is ${totalSize} bytes.`);
-        }
-    }
+export const includeDoesNotExist = (def, field) => {
+    def.errors.push({
+        code: ERR_INCLUDE_ENOENT,
+        payload: field,
+    });
 };
-export const hasFields = (
-// get schema see if it actualy has the value (can find it on def)
-fields) => {
-    if (Object.keys(fields).length === 0) {
-        throw new Error('No fields available to include');
+export const validateId = (def, id) => {
+    if (typeof id != 'number' || id == 0 || id > MAX_ID) {
+        def.errors.push({
+            code: ERR_TARGET_INVAL_ID,
+            payload: id,
+        });
+        return 1;
     }
+    return id;
 };
-export const isValidAlias = (def, id) => {
-    for (const key in id) {
-        const prop = def.schema.props[key];
-        if (!prop || prop.typeIndex !== ALIAS) {
-            throw new Error(`Incorrect alias provided for query "${key}"`);
-        }
+export const validateIds = (def, ids) => {
+    if (!Array.isArray(ids) && !(ids instanceof Uint32Array)) {
+        def.errors.push({
+            code: ERR_TARGET_INVAL_IDS,
+            payload: ids,
+        });
+        return new Uint32Array([]);
     }
-};
-// also wrong
-export const hasField = (field) => {
-    // get schema see if it actualy has the value (can find it on def)
-    if (!field) {
-        throw new Error(`Invalid field: ${field}`);
+    if (ids.length > MAX_IDS_PER_QUERY) {
+        def.errors.push({
+            code: ERR_TARGET_EXCEED_MAX_IDS,
+            payload: ids,
+        });
+        return new Uint32Array([]);
     }
-    else if (typeof field !== 'string' || field.trim() === '') {
-        throw new Error('Field must be a non-empty string');
+    if (Array.isArray(ids)) {
+        try {
+            ids = new Uint32Array(ids);
+            ids.sort();
+        }
+        catch (err) {
+            def.errors.push({
+                code: ERR_TARGET_INVAL_IDS,
+                payload: ids,
+            });
+            return new Uint32Array([]);
+        }
     }
-};
-export const checkOperator = (operator) => {
-    // pass schema value (def) and complete for each prop + operator combination
-    if (operator !== undefined &&
-        typeof operator !== 'boolean' &&
-        !validOperators.includes(operator)) {
-        throw new Error(`Invalid operator: ${operator}`);
+    // pretty heavy if it are a lot...
+    for (const id of ids) {
+        if (typeof id != 'number' || id == 0 || id > MAX_ID) {
+            def.errors.push({
+                code: ERR_TARGET_INVAL_IDS,
+                payload: ids,
+            });
+            return new Uint32Array([]);
+        }
     }
+    return ids;
 };
-export const checkValue = (value, operator) => {
-    // pass schema value (def) and complete for each prop + operator combination
-    if (operator === '..' || operator === '!..') {
-        if (!Array.isArray(value) || value.length !== 2) {
-            throw new Error(`Invalid value for operator ${operator}: expected an array with two elements`);
+export const handleErrors = (def) => {
+    if (def.errors.length) {
+        let name = `Query\n`;
+        for (const err of def.errors) {
+            name += `  ${messages[err.code](err.payload)}\n`;
         }
+        const err = new Error(name);
+        err.stack = '';
+        throw err;
     }
 };
+export const EMPTY_SCHEMA_DEF = {
+    type: '_error',
+    cnt: 0,
+    checksum: 0,
+    total: 0,
+    lastId: 0,
+    blockCapacity: 0,
+    mainLen: 0,
+    buf: Buffer.from([]),
+    propNames: Buffer.from([]),
+    props: {},
+    locales: {},
+    reverseProps: {},
+    id: 0,
+    idUint8: new Uint8Array([0, 0]),
+    main: {},
+    separate: [],
+    tree: {},
+    hasStringProp: false,
+    stringPropsSize: 0,
+    stringPropsCurrent: Buffer.from([]),
+    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 => {
+//   if (ids.length > MAX_IDS_PER_QUERY) {
+//     throw new Error(`The number of IDs cannot exceed ${MAX_IDS_PER_QUERY}.`)
+//   }
+// }
+// export const checkMaxBufferSize = (buf: Buffer): void => {
+//   if (buf.byteLength > MAX_BUFFER_SIZE) {
+//     throw new Error(
+//       `The buffer size exceeds the maximum threshold of ${MAX_BUFFER_SIZE} bytes.` +
+//         `Crrent size is ${buf.byteLength} bytes.`,
+//     )
+//   }
+// }
+// export const checkTotalBufferSize = (bufers: Buffer[]): void => {
+//   let totalSize = 0
+//   for (const buffer of bufers) {
+//     totalSize += buffer.byteLength
+//     if (totalSize > MAX_BUFFER_SIZE) {
+//       throw new Error(
+//         `The total buffer size exceeds the maximum threshold of ${MAX_BUFFER_SIZE} bytes.` +
+//           `Crrent size is ${totalSize} bytes.`,
+//       )
+//     }
+//   }
+// }
+// // ------------------------------
+// export const includeDoesNotExist = (def: QueryDef, field: string) => {
+//   throw new Error(`Incorrect include field provided to query "${field}")`)
+// }
 //# sourceMappingURL=validation.js.map

package/dist/src/server/csmt/tree.js

@@ -81,7 +81,6 @@ export function createTree(createHash) {
         const left = node.left;
         const right = node.right;
         if (!left || !right) {
-            console.log(node, k);
             if (node.data) {
                 if (node.key === k) {
                     return null;

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

@@ -3,6 +3,7 @@ import { SchemaTypeDef } from './schema/types.js';
 import { createTree } from './csmt/index.js';
 import { Worker, MessagePort } from 'node:worker_threads';
 import { TransformFns } from './migrate/index.js';
+import exitHook from 'exit-hook';
 declare class SortIndex {
     constructor(buf: Buffer, dbCtxExternal: any);
     buf: Buffer;
@@ -48,6 +49,7 @@ export declare class DbServer {
     queryQueue: Map<Function, Buffer>;
     stopped: boolean;
     onSchemaChange: OnSchemaChange;
+    unlistenExit: ReturnType<typeof exitHook>;
     constructor({ path, maxModifySize, onSchemaChange, }: {
         path: string;
         maxModifySize?: number;
@@ -56,7 +58,7 @@ export declare class DbServer {
     start(opts?: {
         clean?: boolean;
     }): Promise<void>;
-    save(): Promise<void>;
+    save(): void | Promise<void>;
     createCsmtHashFun: () => {
         update: (buf: Buffer) => any;
         digest: (encoding?: BufferEncoding) => Buffer | string;

package/dist/src/server/index.js

@@ -82,6 +82,7 @@ export class DbServer {
     queryQueue = new Map();
     stopped;
     onSchemaChange;
+    unlistenExit;
     constructor({ path, maxModifySize = 100 * 1e3 * 1e3, onSchemaChange, }) {
         this.maxModifySize = maxModifySize;
         this.fileSystemPath = path;
@@ -432,6 +433,7 @@ export class DbServer {
         }
         this.stopped = true;
         clearTimeout(this.cleanupTimer);
+        this.unlistenExit();
         try {
             if (!noSave) {
                 await this.save();
@@ -448,7 +450,7 @@ export class DbServer {
     }
     async destroy() {
         await this.stop(true);
-        await rm(this.fileSystemPath, { recursive: true }).catch((err) => console.warn('Error removing dump folder', err.message));
+        await rm(this.fileSystemPath, { recursive: true }).catch((err) => console.warn('Error removing dump folder', this.fileSystemPath, err.message));
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/src/server/save.d.ts

@@ -1,2 +1,2 @@
 import { DbServer } from './index.js';
-export declare function save(db: DbServer): Promise<void>;
+export declare function save(db: DbServer, sync?: boolean): void | Promise<void>;

package/dist/src/server/save.js

@@ -2,10 +2,14 @@ import native from '../native.js';
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { destructureCsmtKey, foreachDirtyBlock } from './tree.js';
+import { writeFileSync } from 'node:fs';
 const WRITELOG_FILE = 'writelog.json';
 const COMMON_SDB_FILE = 'common.sdb';
 const block_sdb_file = (typeId, start, end) => `${typeId}_${start}_${end}.sdb`;
-export async function save(db) {
+export function save(db, sync = false) {
+    if (!db.dirtyRanges.size) {
+        return;
+    }
     let err;
     const ts = Date.now();
     err = native.saveCommon(join(db.fileSystemPath, COMMON_SDB_FILE), db.dbCtxExternal);
@@ -61,6 +65,8 @@ export async function save(db) {
     if (mtRoot) {
         data.hash = mtRoot.hash.toString('hex');
     }
-    await writeFile(join(db.fileSystemPath, WRITELOG_FILE), JSON.stringify(data));
+    const filePath = join(db.fileSystemPath, WRITELOG_FILE);
+    const content = JSON.stringify(data);
+    return sync ? writeFileSync(filePath, content) : writeFile(filePath, content);
 }
 //# sourceMappingURL=save.js.map

package/dist/src/server/start.js

@@ -6,7 +6,9 @@ import { join } from 'node:path';
 import { createTree } from './csmt/index.js';
 import { foreachBlock } from './tree.js';
 import { availableParallelism } from 'node:os';
+import exitHook from 'exit-hook';
 import './worker.js';
+import { save } from './save.js';
 const SCHEMA_FILE = 'schema.json';
 const WRITELOG_FILE = 'writelog.json';
 export const DEFAULT_BLOCK_CAPACITY = 100_000;
@@ -82,5 +84,10 @@ export async function start(db, opts) {
     while (i--) {
         db.workers[i] = new DbWorker(address, db);
     }
+    db.unlistenExit = exitHook((signal) => {
+        console.log(`Exiting with signal: ${signal}`);
+        save(db, true);
+        console.log('Successfully saved.');
+    });
 }
 //# sourceMappingURL=start.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -34,6 +34,7 @@
     "@based/schema": "5.0.0-alpha.3",
     "@saulx/hash": "^3.0.0",
     "@saulx/utils": "^4.3.2",
+    "exit-hook": "^4.0.0",
     "picocolors": "^1.1.0"
   },
   "optionalDependencies": {