@based/db 0.0.15 → 0.0.17

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

@@ -11,6 +11,7 @@ export const registerQuery = (q) => {
         handleErrors(q.def);
         return buf;
     }
+    handleErrors(q.def);
     return q.buffer;
 };
 //# sourceMappingURL=registerQuery.js.map

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

@@ -1,6 +1,7 @@
 import { langCodesMap } from '@based/schema';
 import { STRING, TEXT, VECTOR } from '../../../server/schema/types.js';
 import { getVectorFn } from '../filter/types.js';
+import { searchDoesNotExist, searchIncorrecQueryValue, searchIncorrectType, } from '../validation.js';
 const makeSize = (nr, u8 = false) => {
     if (u8) {
         const size = Buffer.allocUnsafe(1);
@@ -13,12 +14,12 @@ const makeSize = (nr, u8 = false) => {
 };
 // vector
 export const vectorSearch = (def, q, field, opts) => {
-    const prop = def.props[field];
+    let prop = def.props[field];
     if (!prop) {
-        throw new Error(`Cannot find prop ${field}`);
+        prop = searchDoesNotExist(def, field, true);
     }
     if (prop.typeIndex !== VECTOR) {
-        throw new Error('Can only search trough strings / text');
+        searchIncorrectType(def, prop);
     }
     // [isVec] [q len] [q len] [field] [fn] [score] [score] [score] [score] [q..]
     let size = 9;
@@ -35,6 +36,10 @@ export const vectorSearch = (def, q, field, opts) => {
 export const search = (def, q, s) => {
     const bufs = [];
     let blocks = 0;
+    if (typeof q !== 'string') {
+        searchIncorrecQueryValue(def, q);
+        q = '';
+    }
     const x = q.toLowerCase().trim().split(' ');
     for (const s of x) {
         if (s) {
@@ -80,17 +85,18 @@ export const search = (def, q, s) => {
                 prop = def.props[k.slice(0, -1).join('.')];
                 if (prop && prop.typeIndex === TEXT) {
                     lang = langCodesMap.get(k[k.length - 1]);
+                    // incorrect LANG
                 }
                 else {
-                    throw new Error('field ' + key + ' does not exist on type');
+                    prop = searchDoesNotExist(def, key, false);
                 }
             }
             else {
-                throw new Error('field ' + key + ' does not exist on type');
+                prop = searchDoesNotExist(def, key, false);
             }
         }
         if (prop.typeIndex !== STRING && prop.typeIndex !== TEXT) {
-            throw new Error('Can only search trough strings / text');
+            searchIncorrectType(def, prop);
         }
         def.search.size += 5;
         def.search.fields.push({

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

@@ -1,18 +1,19 @@
+import { validateSort } from './validation.js';
 export const createSortBuffer = (sort) => {
-    const buf = Buffer.allocUnsafe(7);
-    // [order] [propType] [start] [start] [len] [len]
+    const buf = Buffer.allocUnsafe(8);
+    // [order] [propType] [start] [start] [len] [len] [lang]
     buf[0] = sort.order;
     buf[1] = sort.prop.prop;
     buf[2] = sort.prop.typeIndex;
     buf.writeUint16LE(sort.prop.start, 3);
     buf.writeUint16LE(sort.prop.len, 5);
+    buf[7] = sort.lang;
+    // console.info({ sort, buf: new Uint8Array(buf) })
+    //[LANG]
     return buf;
 };
 // NO REF / REFERENCES SUPPORT
 export const sort = (def, field, order) => {
-    def.sort = {
-        prop: def.props[field],
-        order: order === 'asc' || order === undefined ? 0 : 1,
-    };
+    def.sort = validateSort(def, field, order);
 };
 //# sourceMappingURL=sort.js.map

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

@@ -1,5 +1,4 @@
 export declare const MAX_IDS_PER_QUERY = 1000000;
-export declare const MAX_BUFFER_SIZE: number;
 export declare const DEF_RANGE_PROP_LIMIT = 1000;
 export declare const DEF_RANGE_REF_LIMIT = 10000;
 export declare const MAX_ID = 4294967295;

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

@@ -1,17 +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 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)
-// Performance-related thresholds
-// <Just making room to further threshoulds e.g. MAX_MEMORY_BLABLABLA>
-// Network-related thresholds
-// <Just making room to further threshoulds e.g. MAX_NETWORK_RETRIES, NETWORK_TIMEOUT, etc.>
-// Security-related thresholds
-// <Just making room to further threshoulds that could make sense such. e.g.
-// MAX_INPUT_LENGTH (strings/json to prevent DDoS attacks) or MAX_API_DUMP_LENGTH to avoid undesired dumps>
 //# sourceMappingURL=thresholds.js.map

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

@@ -9,9 +9,6 @@ const byteSize = (arr) => {
     }, 0);
 };
 export function defToBuffer(db, def) {
-    // if (def.errors.length) {
-    //   return []
-    // }
     const result = [];
     const include = includeToBuffer(db, def);
     def.references.forEach((ref) => {

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

@@ -57,6 +57,7 @@ export type QueryDefSearch = {
 export type QueryDefSort = {
     prop: PropDefEdge | PropDef;
     order: 0 | 1;
+    lang: LangCode;
 };
 export type QueryDefShared = {
     errors: QueryError[];
@@ -65,6 +66,7 @@ export type QueryDefShared = {
     search: null | QueryDefSearch;
     sort: null | QueryDefSort;
     reverseProps: any;
+    skipValidation: boolean;
     range: {
         offset: number;
         limit: number;

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;
@@ -18,6 +19,17 @@ export declare const ERR_FILTER_INVALID_VAL = 10;
 export declare const ERR_FILTER_INVALID_OPTS = 11;
 export declare const ERR_FILTER_INVALID_LANG = 12;
 export declare const ERR_INCLUDE_INVALID_LANG = 13;
+export declare const ERR_SORT_ENOENT = 14;
+export declare const ERR_SORT_TYPE = 15;
+export declare const ERR_SORT_ORDER = 16;
+export declare const ERR_SORT_WRONG_TARGET = 17;
+export declare const ERR_RANGE_INVALID_OFFSET = 18;
+export declare const ERR_RANGE_INVALID_LIMIT = 19;
+export declare const ERR_INVALID_LANG = 20;
+export declare const ERR_SEARCH_ENOENT = 21;
+export declare const ERR_SEARCH_TYPE = 22;
+export declare const ERR_SEARCH_INCORRECT_VALUE = 23;
+export declare const ERR_SORT_LANG = 24;
 declare const messages: {
     1: (p: any) => string;
     2: (p: any) => string;
@@ -29,14 +41,38 @@ 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;
+    14: (p: any) => string;
+    17: (p: any) => string;
+    16: (p: any) => string;
+    15: (p: any) => string;
+    18: (p: any) => string;
+    19: (p: any) => string;
+    20: (p: any) => string;
+    21: (p: any) => string;
+    22: (p: any) => string;
+    23: (p: any) => string;
+    24: (p: any) => string;
 };
 export type ErrorCode = keyof typeof messages;
+export declare const searchIncorrecQueryValue: (def: QueryDef, payload: any) => void;
+export declare const searchIncorrectType: (def: QueryDef, payload: PropDef | PropDefEdge) => void;
+export declare const searchDoesNotExist: (def: QueryDef, field: string, isVector: boolean) => PropDef;
+export declare const validateRange: (def: QueryDef, offset: number, limit: number) => boolean;
+export declare const isValidId: (id: number) => boolean;
+export declare const isValidString: (v: any) => boolean;
+export declare const validateVal: (def: QueryDef, f: Filter, validate: (v: any) => boolean) => 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;
 export declare const filterFieldDoesNotExist: (def: QueryDef, field: string) => void;
 export declare const includeDoesNotExist: (def: QueryDef, field: string) => void;
 export declare const includeLangDoesNotExist: (def: QueryDef, field: string) => void;
+export declare const validateLocale: (def: QueryDef, lang: string) => void;
+export declare const validateSort: (def: QueryDef, field: string, orderInput?: "asc" | "desc") => QueryDef["sort"];
 export declare const validateAlias: (alias: QueryByAliasObj, path: string[], def: QueryDef) => {
     def: PropDef;
     value: string;
@@ -45,5 +81,7 @@ 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_ALIAS_PROP_DEF: PropDef;
+export declare const ERROR_STRING: PropDef;
+export declare const ERROR_VECTOR: PropDef;
 export declare const EMPTY_SCHEMA_DEF: SchemaTypeDef;
 export {};