@based/db 0.0.13 → 0.0.14

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

@@ -21,7 +21,7 @@ export class QueryBranch {
         return this;
     }
     filter(field, operator, value, opts) {
-        const f = convertFilter(field, operator, value, opts);
+        const f = convertFilter(this.def, field, operator, value, opts);
         filter(this.db, this.def, f, this.def.filter);
         // @ts-ignore
         return this;
@@ -93,7 +93,7 @@ export class QueryBranch {
             this.def.filter.size += f.filterBranch.size;
         }
         else {
-            const f = convertFilter(field, operator, value, opts);
+            const f = convertFilter(this.def, field, operator, value, opts);
             filterOr(this.db, this.def, f, this.def.filter);
         }
         // @ts-ignore

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

@@ -15,13 +15,13 @@ export class FilterBranch {
             this.def.filter.size += f.filterBranch.size;
         }
         else {
-            const f = convertFilter(field, operator, value, opts);
+            const f = convertFilter(this.def, field, operator, value, opts);
             filterOr(this.db, this.def, f, this.filterBranch);
         }
         return this;
     }
     filter(field, operator, value) {
-        const f = convertFilter(field, operator, value);
+        const f = convertFilter(this.def, field, operator, value);
         filter(this.db, this.def, f, this.filterBranch);
         return this;
     }

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

@@ -7,4 +7,4 @@ export { Operator, Filter };
 export declare const filterRaw: (db: DbClient, filter: Filter, schema: SchemaTypeDef, conditions: QueryDefFilter, def: QueryDef) => number;
 export declare const filter: (db: DbClient, def: QueryDef, filterAst: FilterAst, conditions: QueryDefFilter) => void;
 export declare const filterOr: (db: DbClient, def: QueryDef, filterAst: FilterAst[], conditions: QueryDefFilter) => QueryDefFilter;
-export declare const convertFilter: (field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts) => FilterAst;
+export declare const convertFilter: (def: QueryDef, field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts) => FilterAst;

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

@@ -1,8 +1,9 @@
-import { isPropDef, ID_FIELD_DEF, TEXT, } from '../../../server/schema/schema.js';
+import { isPropDef, ID_FIELD_DEF, TEXT, REFERENCE, } from '../../../server/schema/schema.js';
 import { primitiveFilter } from './primitiveFilter.js';
 import { toFilterCtx } from './types.js';
 import { IsFilter } from './types.js';
 import { langCodesMap } from '@based/schema';
+import { filterFieldDoesNotExist, filterInvalidLang } from '../validation.js';
 const referencesFilter = (db, filter, schema, conditions, def) => {
     const [fieldStr, ctx, value] = filter;
     var size = 0;
@@ -25,9 +26,13 @@ const referencesFilter = (db, filter, schema, conditions, def) => {
                     }
                 }
             }
+            else {
+                filterFieldDoesNotExist(def, fieldStr);
+                return 0;
+            }
             return size;
         }
-        if (isPropDef(t) && t.typeIndex === 13) {
+        if (isPropDef(t) && t.typeIndex === REFERENCE) {
             conditions.references ??= new Map();
             let refConditions = conditions.references.get(t.prop);
             if (!refConditions) {
@@ -46,7 +51,10 @@ const referencesFilter = (db, filter, schema, conditions, def) => {
             return size;
         }
     }
-    throw new Error(`Query: field "${fieldStr}" does not exist on type ${schema.type}`);
+    if (!def) {
+        filterFieldDoesNotExist(def, fieldStr);
+        return 0;
+    }
 };
 export const filterRaw = (db, filter, schema, conditions, def) => {
     const field = filter[0];
@@ -57,9 +65,11 @@ export const filterRaw = (db, filter, schema, conditions, def) => {
             const f = s.slice(0, -1).join();
             fieldDef = schema.props[f];
             if (fieldDef && fieldDef.typeIndex === TEXT) {
-                const code = langCodesMap.get(s[s.length - 1]);
-                if (!code) {
-                    throw new Error(`Invalid value for filter on ${field}: expected a valid locale`);
+                const lang = s[s.length - 1];
+                const code = langCodesMap.get(lang);
+                if (!code || !schema.locales[lang]) {
+                    filterInvalidLang(def, field);
+                    return 0;
                 }
                 return primitiveFilter(fieldDef, filter, conditions, code);
             }
@@ -101,7 +111,7 @@ const normalizeNeedle = (s) => {
         .filter((ch) => ch.charCodeAt(0) <= 127)
         .join('');
 };
-export const convertFilter = (field, operator, value, opts) => {
+export const convertFilter = (def, field, operator, value, opts) => {
     if (operator === undefined) {
         operator = '=';
         value = true;
@@ -112,14 +122,14 @@ export const convertFilter = (field, operator, value, opts) => {
     }
     if (operator === '!..') {
         return [
-            [field, toFilterCtx('>', opts), value[1]],
-            [field, toFilterCtx('<', opts), value[0]],
+            [field, toFilterCtx(def, '>', opts), value[1]],
+            [field, toFilterCtx(def, '<', opts), value[0]],
         ];
     }
     else if (operator === '..') {
         return [
-            [field, toFilterCtx('>', opts), value[0]],
-            [field, toFilterCtx('<', opts), value[1]],
+            [field, toFilterCtx(def, '>', opts), value[0]],
+            [field, toFilterCtx(def, '<', opts), value[1]],
         ];
     }
     else {
@@ -142,7 +152,7 @@ export const convertFilter = (field, operator, value, opts) => {
                 value = value.buffer;
             }
         }
-        return [[field, toFilterCtx(operator, opts), value]];
+        return [[field, toFilterCtx(def, operator, opts), value]];
     }
 };
 //# sourceMappingURL=filter.js.map

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

@@ -1,3 +1,4 @@
+import { QueryDef } from '../types.js';
 import { FilterBranch } from './FilterBranch.js';
 export type Filter = [fieldStr: string, ctx: FilterCtx, value: any];
 export type FilterBranchFn = (filterBranch: FilterBranch) => void;
@@ -52,4 +53,4 @@ export declare const VECTOR_MANHATTAN_DIST = 1;
 export declare const VECTOR_COSTINE_SIMILARITY = 2;
 export declare const VECTOR_EUCLIDEAN_DIST = 3;
 export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 0 | 1 | 2 | 3;
-export declare const toFilterCtx: (op: Operator, opts?: FilterOpts) => FilterCtx;
+export declare const toFilterCtx: (def: QueryDef, op: Operator, opts?: FilterOpts) => FilterCtx;

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

@@ -1,3 +1,4 @@
+import { filterOperatorDoesNotExist } from '../validation.js';
 export const IsFilter = (f) => {
     if (typeof f[0] === 'string') {
         return true;
@@ -86,7 +87,7 @@ export const getVectorFn = (optsFn) => {
         return VECTOR_MANHATTAN_DIST;
     }
 };
-export const toFilterCtx = (op, opts = {}) => {
+export const toFilterCtx = (def, op, opts = {}) => {
     if (op === '=' || op === '!=') {
         return {
             operation: EQUAL,
@@ -116,6 +117,6 @@ export const toFilterCtx = (op, opts = {}) => {
     if (op === 'like') {
         return { operation: LIKE, opts, type: TYPE_DEFAULT };
     }
-    throw new Error('Invalid filter operator');
+    filterOperatorDoesNotExist(def, op);
 };
 //# sourceMappingURL=types.js.map

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

@@ -51,7 +51,7 @@ export const includeProp = (def, prop) => {
         return false;
     }
     if (prop.separate) {
-        def.include.props.add(prop.prop);
+        def.include.props.set(prop.prop, prop);
     }
     else {
         def.include.main.len += prop.len;

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

@@ -48,19 +48,21 @@ export const includeToBuffer = (db, def) => {
         }
     }
     if (def.include.langTextFields.size) {
-        for (const [prop, langCode] of def.include.langTextFields.entries()) {
+        for (const [prop, { codes, def: propDef },] of def.include.langTextFields.entries()) {
             def.include.propsRead[prop] = 0;
-            if (langCode.has(0)) {
-                const b = Buffer.allocUnsafe(2);
+            if (codes.has(0)) {
+                const b = Buffer.allocUnsafe(3);
                 b[0] = prop;
-                b[1] = 0;
+                b[1] = propDef.typeIndex;
+                b[2] = 0;
                 result.push(b);
             }
             else {
-                for (const code of langCode) {
-                    const b = Buffer.allocUnsafe(2);
+                for (const code of codes) {
+                    const b = Buffer.allocUnsafe(3);
                     b[0] = prop;
-                    b[1] = code;
+                    b[1] = propDef.typeIndex;
+                    b[2] = code;
                     result.push(b);
                 }
             }
@@ -68,7 +70,7 @@ export const includeToBuffer = (db, def) => {
     }
     const propSize = def.include.props.size ?? 0;
     if (mainBuffer) {
-        len = mainBuffer.byteLength + 3 + propSize;
+        len = mainBuffer.byteLength + 3 + propSize * 2;
         includeBuffer = Buffer.allocUnsafe(len);
         includeBuffer[0] = 0;
         includeBuffer.writeInt16LE(mainBuffer.byteLength, 1);
@@ -76,24 +78,26 @@ export const includeToBuffer = (db, def) => {
         mainBuffer.copy(includeBuffer, 3);
         if (propSize) {
             let i = 0;
-            for (const prop of def.include.props) {
+            for (const [prop, propDef] of def.include.props.entries()) {
                 includeBuffer[i + offset] = prop;
-                i++;
+                includeBuffer[i + offset + 1] = propDef.typeIndex;
+                i += 2;
             }
         }
     }
     else if (propSize) {
-        const buf = Buffer.allocUnsafe(propSize);
+        const buf = Buffer.allocUnsafe(propSize * 2);
         let i = 0;
-        for (const prop of def.include.props) {
+        for (const [prop, propDef] of def.include.props.entries()) {
             buf[i] = prop;
-            i++;
+            buf[i + 1] = propDef.typeIndex;
+            i += 2;
         }
         includeBuffer = buf;
     }
     if (includeBuffer) {
-        def.include.props.forEach((v) => {
-            def.include.propsRead[v] = 0;
+        def.include.props.forEach((v, k) => {
+            def.include.propsRead[k] = 0;
         });
         result.push(includeBuffer);
     }

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

@@ -4,7 +4,7 @@ import { isRefDef, QueryDefType } from '../types.js';
 import { getAllFieldFromObject, createOrGetRefQueryDef } from './utils.js';
 import { includeProp, includeAllProps, includeField } from './props.js';
 import { langCodesMap } from '@based/schema';
-import { includeDoesNotExist } from '../validation.js';
+import { includeDoesNotExist, includeLangDoesNotExist } from '../validation.js';
 export const walkDefs = (db, def, f) => {
     const prop = def.props[f];
     const path = f.split('.');
@@ -35,7 +35,7 @@ export const walkDefs = (db, def, f) => {
                     }
                 }
                 else {
-                    def.edges.include.props.add(edgeProp.prop);
+                    def.edges.include.props.set(edgeProp.prop, edgeProp);
                 }
                 return;
             }
@@ -47,11 +47,16 @@ export const walkDefs = (db, def, f) => {
                 return;
             }
             if (isPropDef(t) && t.typeIndex === TEXT) {
-                const langCode = langCodesMap.get(path[path.length - 1]);
+                const lang = path[path.length - 1];
+                const langCode = langCodesMap.get(lang);
+                if (!langCode || !db.schema.locales[lang]) {
+                    includeLangDoesNotExist(def, f);
+                    return;
+                }
                 if (!def.include.langTextFields.has(t.prop)) {
-                    def.include.langTextFields.set(t.prop, new Set());
+                    def.include.langTextFields.set(t.prop, { def: t, codes: new Set() });
                 }
-                def.include.langTextFields.get(t.prop).add(langCode);
+                def.include.langTextFields.get(t.prop).codes.add(langCode);
                 return;
             }
             else if (isPropDef(t) &&
@@ -79,9 +84,9 @@ export const walkDefs = (db, def, f) => {
     }
     else if (prop.typeIndex === TEXT) {
         if (!def.include.langTextFields.has(prop.prop)) {
-            def.include.langTextFields.set(prop.prop, new Set());
+            def.include.langTextFields.set(prop.prop, { def: prop, codes: new Set() });
         }
-        def.include.langTextFields.get(prop.prop).add(def.lang ?? 0);
+        def.include.langTextFields.get(prop.prop).codes.add(def.lang ?? 0);
     }
     else {
         includeProp(def, prop);

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

@@ -1,7 +1,7 @@
 import { langCodesMap } from '@based/schema';
 import { DEF_RANGE_PROP_LIMIT, DEF_RANGE_REF_LIMIT } from './thresholds.js';
 import { QueryDefType, } from './types.js';
-import { validateId, validateIds, validateType } from './validation.js';
+import { validateAlias, validateId, validateIds, validateType, } from './validation.js';
 const createEmptySharedDef = () => {
     const q = {
         errors: [],
@@ -11,7 +11,7 @@ const createEmptySharedDef = () => {
         include: {
             langTextFields: new Map(),
             stringFields: new Set(),
-            props: new Set(),
+            props: new Map(),
             propsRead: {},
             main: {
                 len: 0,
@@ -49,6 +49,9 @@ export const createQueryDef = (db, type, target) => {
                 t.ids = validateIds(q, t.ids);
                 q.range.limit = t.ids.length;
             }
+            else if (t.alias) {
+                t.resolvedAlias = validateAlias(t.alias, [], q);
+            }
             else {
                 q.range.limit = DEF_RANGE_PROP_LIMIT;
             }

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

@@ -145,7 +145,7 @@ const handleUndefinedProps = (id, q, item) => {
             const prop = q.schema.reverseProps[k];
             if (prop.typeIndex === TEXT && q.lang == 0) {
                 const lan = getEmptyField(prop, item);
-                const lang = q.include.langTextFields.get(prop.prop);
+                const lang = q.include.langTextFields.get(prop.prop).codes;
                 if (lang.has(0)) {
                     for (const locale in q.schema.locales) {
                         if (!lan[locale]) {

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

@@ -132,7 +132,7 @@ export const addSubscriptionMarkers = (q, subscription) => {
         const marker = markerType.ids.get(id);
         const props = q.def.include.props;
         const main = q.def.include.main;
-        for (const p of props) {
+        for (const [p] of props.entries()) {
             if (!(p in marker.props)) {
                 marker.props[p] = [];
             }
@@ -154,7 +154,7 @@ export const addSubscriptionMarkers = (q, subscription) => {
         const props = q.def.include.props;
         const main = q.def.include.main;
         const marker = markerType.collection;
-        for (const p of props) {
+        for (const [p] of props.entries()) {
             if (!(p in marker.props)) {
                 marker.props[p] = [];
             }

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

@@ -3,30 +3,11 @@ import { QueryDefType } from './types.js';
 import { includeToBuffer } from './include/toBuffer.js';
 import { filterToBuffer } from './query.js';
 import { searchToBuffer } from './search/index.js';
-import { ALIAS } from '../../server/schema/types.js';
 const byteSize = (arr) => {
     return arr.reduce((a, b) => {
         return a + b.byteLength;
     }, 0);
 };
-const getAliasPropdef = (alias, path, def) => {
-    const schema = def.schema;
-    for (const k in alias) {
-        if (typeof alias[k] === 'string') {
-            const p = path.join('.') + k;
-            const prop = schema.props[p];
-            if (prop.typeIndex === ALIAS) {
-                return { def: prop, value: alias[k] };
-            }
-        }
-        else if (typeof alias[k] === 'object') {
-            const propDef = getAliasPropdef(alias[k], [...path, k], def);
-            if (propDef) {
-                return propDef;
-            }
-        }
-    }
-};
 export function defToBuffer(db, def) {
     // if (def.errors.length) {
     //   return []
@@ -67,33 +48,23 @@ export function defToBuffer(db, def) {
         }
         // [type,type]
         // [q type] 0 == id, 1 === ids, 2 === type only
-        if (def.target.alias) {
+        if (def.target.resolvedAlias) {
             // put this somehwere else at some point
-            try {
-                const alias = getAliasPropdef(def.target.alias, [], def);
-                if (!alias) {
-                    throw new Error(`Cannot find valid alias type in "${JSON.stringify(def.target.alias)}"`);
-                }
-                else {
-                    const s = Buffer.byteLength(alias.value);
-                    // filter is nice for things like access
-                    const buf = Buffer.allocUnsafe(8 + filterSize + s);
-                    buf[0] = 3;
-                    buf[1] = def.schema.idUint8[0];
-                    buf[2] = def.schema.idUint8[1];
-                    buf[3] = alias.def.prop;
-                    buf.writeUint16LE(s, 4);
-                    buf.write(alias.value, 6);
-                    buf.writeUint16LE(filterSize, s + 6);
-                    if (filterSize) {
-                        buf.set(filter, 8 + s);
-                    }
-                    result.push(buf);
-                }
-            }
-            catch (err) {
-                throw new Error(`Cannot parse alias object query for type ${def.schema.type}`);
+            const alias = def.target.resolvedAlias;
+            const s = Buffer.byteLength(alias.value);
+            // filter is nice for things like access
+            const buf = Buffer.allocUnsafe(8 + filterSize + s);
+            buf[0] = 3;
+            buf[1] = def.schema.idUint8[0];
+            buf[2] = def.schema.idUint8[1];
+            buf[3] = alias.def.prop;
+            buf.writeUint16LE(s, 4);
+            buf.write(alias.value, 6);
+            buf.writeUint16LE(filterSize, s + 6);
+            if (filterSize) {
+                buf.set(filter, 8 + s);
             }
+            result.push(buf);
         }
         else if (def.target.id) {
             // type 0

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

@@ -21,6 +21,10 @@ export type Target = {
     ids?: Uint32Array | void;
     propDef?: PropDef | PropDefEdge;
     alias?: QueryByAliasObj;
+    resolvedAlias?: {
+        def: PropDef;
+        value: string;
+    };
 };
 export declare const isRefDef: (def: QueryDef) => def is QueryDefRest;
 export type QueryDefFilter = {
@@ -66,9 +70,12 @@ export type QueryDefShared = {
         limit: number;
     };
     include: {
-        langTextFields: Map<number, Set<LangCode>>;
+        langTextFields: Map<number, {
+            def: PropDef | PropDefEdge;
+            codes: Set<LangCode>;
+        }>;
         stringFields: Set<string>;
-        props: Set<number>;
+        props: Map<number, PropDef | PropDefEdge>;
         propsRead: {
             [propName: number]: number;
         };

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

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

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

@@ -1,6 +1,6 @@
-import { SchemaTypeDef } from '../../server/schema/types.js';
+import { PropDef, SchemaTypeDef } from '../../server/schema/types.js';
 import { DbClient } from '../index.js';
-import { QueryDef } from './types.js';
+import { QueryByAliasObj, QueryDef } from './types.js';
 export type QueryError = {
     code: number;
     payload: any;
@@ -11,6 +11,13 @@ 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;
+export declare const ERR_FILTER_ENOENT = 7;
+export declare const ERR_FILTER_OP_FIELD = 8;
+export declare const ERR_FILTER_OP_ENOENT = 9;
+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;
 declare const messages: {
     1: (p: any) => string;
     2: (p: any) => string;
@@ -18,12 +25,25 @@ declare const messages: {
     4: (p: any) => string;
     5: (p: any) => string;
     6: (p: any) => string;
+    13: (p: any) => string;
+    7: (p: any) => string;
+    12: (p: any) => string;
+    9: (p: any) => string;
 };
 export type ErrorCode = keyof typeof messages;
 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 validateAlias: (alias: QueryByAliasObj, path: string[], def: QueryDef) => {
+    def: PropDef;
+    value: string;
+};
 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 EMPTY_SCHEMA_DEF: SchemaTypeDef;
 export {};

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

@@ -1,3 +1,4 @@
+import { ALIAS } from '../../server/schema/types.js';
 import { MAX_ID, MAX_IDS_PER_QUERY } from './thresholds.js';
 export const ERR_TARGET_INVAL_TYPE = 1;
 export const ERR_TARGET_INVAL_ALIAS = 2;
@@ -5,13 +6,33 @@ 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;
+export const ERR_FILTER_ENOENT = 7;
+export const ERR_FILTER_OP_FIELD = 8;
+export const ERR_FILTER_OP_ENOENT = 9;
+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 messages = {
     [ERR_TARGET_INVAL_TYPE]: (p) => `Type "${p}" does not exist`,
-    [ERR_TARGET_INVAL_ALIAS]: (p) => `Invalid alias "${p}"`,
+    [ERR_TARGET_INVAL_ALIAS]: (p) => {
+        var v;
+        try {
+            v = JSON.stringify(p).replace(/"/g, '');
+        }
+        catch (err) {
+            v = '';
+        }
+        return `Invalid alias prodived to query "${v}"`;
+    },
     [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}"`,
+    [ERR_INCLUDE_ENOENT]: (p) => `Include: field does not exist "${p}"`,
+    [ERR_INCLUDE_INVALID_LANG]: (p) => `Include: invalid lang "${p}"`,
+    [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}"`,
 };
 export const validateType = (db, def, type) => {
     const r = db.schemaTypesParsed[type];
@@ -25,12 +46,59 @@ export const validateType = (db, def, type) => {
     }
     return r;
 };
+export const filterOperatorDoesNotExist = (def, field) => {
+    def.errors.push({
+        code: ERR_FILTER_OP_ENOENT,
+        payload: field,
+    });
+};
+export const filterInvalidLang = (def, field) => {
+    def.errors.push({
+        code: ERR_FILTER_INVALID_LANG,
+        payload: field,
+    });
+};
+export const filterFieldDoesNotExist = (def, field) => {
+    def.errors.push({
+        code: ERR_FILTER_ENOENT,
+        payload: field,
+    });
+};
 export const includeDoesNotExist = (def, field) => {
     def.errors.push({
         code: ERR_INCLUDE_ENOENT,
         payload: field,
     });
 };
+export const includeLangDoesNotExist = (def, field) => {
+    def.errors.push({
+        code: ERR_INCLUDE_INVALID_LANG,
+        payload: field,
+    });
+};
+export const validateAlias = (alias, path, def) => {
+    const schema = def.schema;
+    for (const k in alias) {
+        if (typeof alias[k] === 'string') {
+            const p = path.join('.') + k;
+            const prop = schema.props[p];
+            if (prop.typeIndex === ALIAS) {
+                return { def: prop, value: alias[k] };
+            }
+        }
+        else if (typeof alias[k] === 'object') {
+            const propDef = validateAlias(alias[k], [...path, k], def);
+            if (propDef) {
+                return propDef;
+            }
+        }
+    }
+    def.errors.push({
+        code: ERR_TARGET_INVAL_ALIAS,
+        payload: alias,
+    });
+    return { value: '', def: EMPTY_ALIAS_PROP_DEF };
+};
 export const validateId = (def, id) => {
     if (typeof id != 'number' || id == 0 || id > MAX_ID) {
         def.errors.push({
@@ -92,6 +160,15 @@ export const handleErrors = (def) => {
         throw err;
     }
 };
+export const EMPTY_ALIAS_PROP_DEF = {
+    prop: 1,
+    typeIndex: ALIAS,
+    __isPropDef: true,
+    separate: true,
+    len: 0,
+    start: 0,
+    path: ['ERROR_ALIAS'],
+};
 export const EMPTY_SCHEMA_DEF = {
     type: '_error',
     cnt: 0,

package/package.json

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