@based/db 0.0.1

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

@@ -0,0 +1,134 @@
+import { isPropDef, ID_FIELD_DEF, } from '../../../server/schema/schema.js';
+import { primitiveFilter } from './primitiveFilter.js';
+import { IsFilter } from './types.js';
+import { hasField, checkOperator, checkValue } from '../validation.js';
+const referencesFilter = (db, filter, schema, conditions, def) => {
+    const [fieldStr, operator, value] = filter;
+    var size = 0;
+    const path = fieldStr.split('.');
+    let t = schema.tree;
+    hasField(fieldStr);
+    checkOperator(operator);
+    checkValue(value, operator);
+    for (let i = 0; i < path.length; i++) {
+        const p = path[i];
+        t = t[p];
+        if (!t) {
+            if (p[0] === '$') {
+                let edges = conditions.fromRef && conditions.fromRef.edges;
+                if (!edges && 'propDef' in def.target) {
+                    edges = def.target.propDef.edges;
+                }
+                if (edges) {
+                    const edgeDef = edges[p];
+                    if (edgeDef) {
+                        conditions.edges ??= new Map();
+                        size += 3 + primitiveFilter(edgeDef, filter, conditions);
+                    }
+                }
+            }
+            return size;
+        }
+        if (isPropDef(t) && t.typeIndex === 13) {
+            conditions.references ??= new Map();
+            let refConditions = conditions.references.get(t.prop);
+            if (!refConditions) {
+                const schema = db.schemaTypesParsed[t.inverseTypeName];
+                size += 6;
+                refConditions = {
+                    conditions: new Map(),
+                    fromRef: t,
+                    schema,
+                    size: 0,
+                };
+                conditions.references.set(t.prop, refConditions);
+            }
+            // more nested
+            size += filterRaw(db, [path.slice(i + 1).join('.'), operator, value], refConditions.schema, refConditions, def);
+            return size;
+        }
+    }
+    console.error(`Querty: field "${fieldStr}" does not exist on type ${schema.type}`);
+    return size;
+};
+export const filterRaw = (db, filter, schema, conditions, def) => {
+    const [field, operator, value] = filter;
+    hasField(field); // Validates if the field is a non-empty string
+    checkOperator(operator); // Validates if the operator is valid
+    checkValue(value, operator); // Validates the value based on the operator
+    let fieldDef = schema.props[field];
+    if (!fieldDef) {
+        if (field === 'id') {
+            fieldDef = ID_FIELD_DEF;
+            return primitiveFilter(fieldDef, filter, conditions);
+        }
+        return referencesFilter(db, filter, schema, conditions, def);
+    }
+    return primitiveFilter(fieldDef, filter, conditions);
+};
+export const filter = (db, def, filterAst, conditions) => {
+    for (const f of filterAst) {
+        if (IsFilter(f)) {
+            conditions.size += filterRaw(db, f, def.schema, conditions, def);
+        }
+        else {
+            filterOr(db, def, f, conditions);
+        }
+    }
+};
+export const filterOr = (db, def, filterAst, conditions) => {
+    if (!conditions.or) {
+        conditions.size += 7; // [0] [next 4]
+        conditions.or = {
+            size: 0,
+            conditions: new Map(),
+        };
+    }
+    filter(db, def, filterAst, conditions.or);
+    conditions.size += conditions.or.size;
+    return conditions.or;
+};
+function normalizeNeedle(s) {
+    return s
+        .normalize('NFKD')
+        .split('')
+        .filter((ch) => ch.charCodeAt(0) <= 127)
+        .join('');
+}
+export const convertFilter = (field, operator, value) => {
+    if (operator === undefined) {
+        operator = '=';
+        value = true;
+    }
+    else if (typeof operator === 'boolean') {
+        value = operator;
+        operator = '=';
+    }
+    hasField(field);
+    checkOperator(operator);
+    checkValue(value, operator);
+    if (operator === '!..') {
+        return [
+            [field, '>', value[1]],
+            [field, '<', value[0]],
+        ];
+    }
+    else if (operator === '..') {
+        return [
+            [field, '>', value[0]],
+            [field, '<', value[1]],
+        ];
+    }
+    else {
+        if (operator == 'like') {
+            if (value.normalize) {
+                value = normalizeNeedle(value);
+            }
+            else {
+                value = value.map(normalizeNeedle);
+            }
+        }
+        return [[field, operator, value]];
+    }
+};
+//# sourceMappingURL=filter.js.map

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

@@ -0,0 +1,6 @@
+export declare const validOperators: readonly ["=", "has", "!has", "<", ">", "!=", "like", ">=", "<=", "..", "!..", "hasLoose"];
+export type Operator = '=' | 'has' | '!has' | '<' | '>' | '!=' | 'like' | '>=' | '<=' | '..' | '!..' | 'like' | 'hasLoose';
+export declare const operationToByte: (op: Operator) => number;
+export declare const isNumerical: (op: number) => boolean;
+export declare const stripNegation: (op: number) => number;
+export declare const negateType: (op: number) => number;

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

@@ -0,0 +1,98 @@
+export const validOperators = [
+    '=',
+    'has',
+    '!has',
+    '<',
+    '>',
+    '!=',
+    'like',
+    '>=',
+    '<=',
+    '..',
+    '!..',
+    'hasLoose',
+];
+// -------------------------------------------
+// operations shared
+// 1 = equality
+// 2 = has (simd)
+// 3 = not equal
+// 4 = ends with
+// 5 = starts with
+// -------------------------------------------
+// operations numbers
+// 6 = larger then
+// 7 = smaller then
+// 8 = larger then inclusive
+// 9 = smaller then inclusive
+// 10 = range
+// 11 = exclude range
+// -------------------------------------------
+// operations strings
+// 12 = equality to lower case
+// 13 = has to lower case (simd)
+// 14 = starts with to lower case
+// 15 = ends with to lower case
+// 18 = search
+// -------------------------------------------
+export const operationToByte = (op) => {
+    if (op === '=') {
+        return 1;
+    }
+    if (op === 'has') {
+        return 2;
+    }
+    if (op === '!=') {
+        return 3;
+    }
+    if (op === '!has') {
+        return 16;
+    }
+    if (op === '>') {
+        return 6;
+    }
+    if (op === '<') {
+        return 7;
+    }
+    if (op === '>=') {
+        return 8;
+    }
+    if (op === '<=') {
+        return 9;
+    }
+    if (op === '..') {
+        return 10;
+    }
+    if (op === '!..') {
+        return 11;
+    }
+    if (op === 'like') {
+        return 18;
+    }
+    if (op === 'hasLoose') {
+        return 19;
+    }
+    return 0;
+};
+export const isNumerical = (op) => {
+    if (op === 6 || op === 7 || op === 8 || op === 9 || op === 10 || op === 11) {
+        return true;
+    }
+    return false;
+};
+export const stripNegation = (op) => {
+    if (op === 16) {
+        return 2;
+    }
+    if (op === 3) {
+        return 1;
+    }
+    return op;
+};
+export const negateType = (op) => {
+    if (op === 3) {
+        return 1;
+    }
+    return 2;
+};
+//# sourceMappingURL=operators.js.map

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

@@ -0,0 +1,2 @@
+import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
+export declare const parseFilterValue: (prop: PropDef | PropDefEdge, value: any) => any;

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

@@ -0,0 +1,99 @@
+import { TIMESTAMP, CREATED, UPDATED, ENUM, BOOLEAN, STRING, BINARY, } from '../../../server/schema/types.js';
+import { crc32 } from '../../crc32.js';
+// -------------------------------------------
+// conditions normal
+// field, [size 2]
+// [or = 0] [size 2] [start 2], [op], value[size]
+// -------------------------------------------
+// conditions or fixed
+// field, [size 2]
+// [or = 1] [size 2] [start 2] [op], [repeat 2], value[size] value[size] value[size]
+// -------------------------------------------
+// conditions or variable
+// field, [size 2]
+// [or = 2] [size 2] [start 2], [op], [size 2], value[size], [size 2], value[size]
+// -------------------------------------------
+const timeToNumber = (ex) => {
+    if (ex === 's') {
+        return 1000;
+    }
+    if (ex === 'm') {
+        return 1000 * 60;
+    }
+    if (ex === 'h') {
+        return 1000 * 60 * 60;
+    }
+    if (ex === 'd') {
+        return 1000 * 60 * 60 * 24;
+    }
+    if (ex === 'y') {
+        return 31556952000;
+    }
+    return 1;
+};
+export const parseFilterValue = (prop, value) => {
+    if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
+        const b = value instanceof Buffer ? value : Buffer.from(value);
+        const buf = Buffer.allocUnsafe(8);
+        buf.writeUint32LE(crc32(b), 0);
+        buf.writeUint32LE(b.byteLength, 4);
+        return buf;
+    }
+    else if (prop.typeIndex === BOOLEAN) {
+        return value ? 1 : 0;
+    }
+    else if (prop.typeIndex === ENUM) {
+        return prop.reverseEnum[value] + 1;
+    }
+    else if (prop.typeIndex === TIMESTAMP ||
+        prop.typeIndex === CREATED ||
+        prop.typeIndex === UPDATED) {
+        if (value instanceof Date) {
+            return value.valueOf();
+        }
+        if (typeof value === 'string') {
+            if (value === 'now') {
+                return Date.now();
+            }
+            const y = value.replace(/([+-])/g, ' $1 ');
+            const arr = y.split(/ +/);
+            let newValue = 0;
+            let now;
+            let op = 1;
+            for (const seg of arr) {
+                if (seg === '-') {
+                    op = -1;
+                }
+                else if (seg === '+') {
+                    op = 1;
+                }
+                else {
+                    var v = 0;
+                    if (seg === 'now') {
+                        if (!now) {
+                            now = Date.now();
+                        }
+                        v = now;
+                    }
+                    else if (/[smhdy]$/.test(seg)) {
+                        const ex = seg[seg.length - 1];
+                        const number = parseInt(seg, 10);
+                        v = number * timeToNumber(ex);
+                    }
+                    else if (seg) {
+                        v = new Date(seg).valueOf();
+                    }
+                    if (op === -1) {
+                        newValue -= v;
+                    }
+                    else {
+                        newValue += v;
+                    }
+                }
+            }
+            return newValue;
+        }
+    }
+    return value;
+};
+//# sourceMappingURL=parseFilterValue.js.map

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

@@ -0,0 +1,4 @@
+import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
+import { QueryDefFilter } from '../types.js';
+import { Filter } from './types.js';
+export declare const primitiveFilter: (prop: PropDef | PropDefEdge, filter: Filter, conditions: QueryDefFilter) => number;

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

@@ -0,0 +1,47 @@
+import { REFERENCE, REFERENCES, REVERSE_SIZE_MAP, } from '../../../server/schema/types.js';
+import { isNumerical, operationToByte } from './operators.js';
+import { createVariableFilterBuffer } from './createVariableFilterBuffer.js';
+import { createFixedFilterBuffer } from './createFixedFilterBuffer.js';
+import { createReferenceFilter } from './createReferenceFilter.js';
+import { checkOperator, checkValue } from '../validation.js';
+export const primitiveFilter = (prop, filter, conditions) => {
+    let [, operator, value] = filter;
+    checkOperator(operator);
+    checkValue(value, operator);
+    const fieldIndexChar = prop.prop;
+    let buf;
+    const op = operationToByte(operator);
+    let size = 0;
+    const bufferMap = prop.__isEdge ? conditions.edges : conditions.conditions;
+    const isArray = Array.isArray(value);
+    if (isArray && value.length === 1) {
+        value = value[0];
+    }
+    const propSize = REVERSE_SIZE_MAP[prop.typeIndex];
+    if (prop.typeIndex === REFERENCE) {
+        buf = createReferenceFilter(prop, op, value);
+    }
+    else if (prop.typeIndex === REFERENCES) {
+        if (op === 1 && !isArray) {
+            value = [value];
+        }
+        buf = createFixedFilterBuffer(prop, 4, op, value, !isNumerical(op));
+    }
+    else if (propSize) {
+        buf = createFixedFilterBuffer(prop, propSize, op, value, false);
+    }
+    else {
+        buf = createVariableFilterBuffer(value, prop, op);
+    }
+    // ADD OR if array for value
+    let arr = bufferMap.get(fieldIndexChar);
+    if (!arr) {
+        size += 3; // [field] [size 2]
+        arr = [];
+        bufferMap.set(fieldIndexChar, arr);
+    }
+    size += buf.byteLength;
+    arr.push(buf);
+    return size;
+};
+//# sourceMappingURL=primitiveFilter.js.map

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

@@ -0,0 +1,3 @@
+import { QueryDefFilter } from '../types.js';
+export declare const fillConditionsBuffer: (result: Buffer, conditions: QueryDefFilter, offset: number) => number;
+export declare const filterToBuffer: (conditions: QueryDefFilter) => Buffer;

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

@@ -0,0 +1,100 @@
+// -------------------------------------------
+// and
+// [meta = 255] [size 2]
+// -------------------------------------------
+// or
+// [meta = 253]  [size 2] [next 4]
+// -------------------------------------------
+// edge
+// [meta = 252] [size 2]
+// -------------------------------------------
+// ref
+// [meta = 254] [field] [typeId 2] [size 2]
+// -------------------------------------------
+// conditions normal
+// field, [size 2]
+// [or = 0] [size 2] [start 2], [op] [typeIndex], value[size]
+// -------------------------------------------
+// conditions or fixed
+// field, [size 2]
+// [or = 1] [size 2] [start 2] [op] [typeIndex], [repeat 2], value[size] value[size] value[size]
+// -------------------------------------------
+// conditions or variable
+// field, [size 2]
+// [or = 2] [size 2] [start 2], [op] [typeIndex], [size 2], value[size], [size 2], value[size]
+// -------------------------------------------
+const writeConditions = (result, k, offset, conditions) => {
+    let lastWritten = offset;
+    result[lastWritten] = k;
+    lastWritten++;
+    const sizeIndex = lastWritten;
+    lastWritten += 2;
+    let conditionSize = 0;
+    for (const condition of conditions) {
+        conditionSize += condition.byteLength;
+        result.set(condition, lastWritten);
+        lastWritten += condition.byteLength;
+    }
+    // make this u32
+    result.writeUint16LE(conditionSize, sizeIndex);
+    return lastWritten - offset;
+};
+export const fillConditionsBuffer = (result, conditions, offset) => {
+    let lastWritten = offset;
+    let orJumpIndex = 0;
+    if (conditions.or) {
+        result[lastWritten] = 253;
+        lastWritten++;
+        orJumpIndex = lastWritten;
+        lastWritten += 2;
+        lastWritten += 4;
+    }
+    conditions.conditions.forEach((v, k) => {
+        lastWritten += writeConditions(result, k, lastWritten, v);
+    });
+    if (conditions.references) {
+        for (const [refField, refConditions] of conditions.references) {
+            result[lastWritten] = 254;
+            lastWritten++;
+            result[lastWritten] = refField;
+            lastWritten++;
+            result.writeUint16LE(refConditions.schema.id, lastWritten);
+            lastWritten += 2;
+            const sizeIndex = lastWritten;
+            lastWritten += 2;
+            const size = fillConditionsBuffer(result, refConditions, lastWritten);
+            result.writeUint16LE(size, sizeIndex);
+            lastWritten += size;
+        }
+    }
+    if (conditions.edges) {
+        conditions.edges.forEach((v, k) => {
+            result[lastWritten] = 252;
+            lastWritten++;
+            let sizeIndex = lastWritten;
+            lastWritten += 2;
+            const size = writeConditions(result, k, lastWritten, v);
+            lastWritten += size;
+            result.writeUint16LE(size, sizeIndex);
+        });
+    }
+    if (conditions.or) {
+        const size = fillConditionsBuffer(result, conditions.or, lastWritten);
+        result.writeUint16LE(size, orJumpIndex);
+        result.writeUint32LE(lastWritten, orJumpIndex + 2);
+        lastWritten += size;
+    }
+    return lastWritten - offset;
+};
+export const filterToBuffer = (conditions) => {
+    let result;
+    if (conditions.size > 0) {
+        result = Buffer.allocUnsafe(conditions.size);
+        fillConditionsBuffer(result, conditions, 0);
+    }
+    else {
+        result = Buffer.alloc(0);
+    }
+    return result;
+};
+//# sourceMappingURL=toBuffer.js.map

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

@@ -0,0 +1,6 @@
+import { Operator } from './operators.js';
+import { FilterBranch } from './FilterBranch.js';
+export type Filter = [fieldStr: string, operator: Operator, value: any];
+export type FilterBranchFn = (filterBranch: FilterBranch) => void;
+export type FilterAst = (Filter | FilterAst)[];
+export declare const IsFilter: (f: FilterAst) => f is Filter;

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

@@ -0,0 +1,7 @@
+export const IsFilter = (f) => {
+    if (typeof f[0] === 'string') {
+        return true;
+    }
+    return false;
+};
+//# sourceMappingURL=types.js.map

package/dist/src/client/query/include/props.d.ts

@@ -0,0 +1,6 @@
+import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
+import { QueryDef } from '../types.js';
+export declare const getAll: (props: QueryDef["props"]) => string[];
+export declare const includeFields: (def: QueryDef, fields: string[]) => void;
+export declare const includeAllProps: (def: QueryDef) => void;
+export declare const includeProp: (def: QueryDef, prop: PropDef | PropDefEdge) => boolean;

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

@@ -0,0 +1,44 @@
+import { REFERENCE, REFERENCES, } from '../../../server/schema/types.js';
+export const getAll = (props) => {
+    const fields = [];
+    for (const key in props) {
+        const prop = props[key];
+        if (prop.typeIndex !== REFERENCE && prop.typeIndex !== REFERENCES) {
+            fields.push(prop.path.join('.'));
+        }
+    }
+    return fields;
+};
+export const includeFields = (def, fields) => {
+    for (const field of fields) {
+        if (field === '*') {
+            includeFields(def, getAll(def.props));
+        }
+        else {
+            def.include.stringFields.add(field);
+        }
+    }
+};
+export const includeAllProps = (def) => {
+    for (const key in def.props) {
+        const prop = def.props[key];
+        if (prop.typeIndex !== REFERENCE && prop.typeIndex !== REFERENCES) {
+            includeProp(def, prop);
+        }
+    }
+};
+export const includeProp = (def, prop) => {
+    if (!prop || prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
+        return false;
+    }
+    if (prop.separate) {
+        def.include.props.add(prop.prop);
+    }
+    else {
+        def.include.main.len += prop.len;
+        def.include.main.include[prop.start] = [0, prop];
+        return true;
+    }
+    return false;
+};
+//# sourceMappingURL=props.js.map

package/dist/src/client/query/include/toBuffer.d.ts

@@ -0,0 +1,3 @@
+import { DbClient } from '../../index.js';
+import { QueryDef } from '../types.js';
+export declare const includeToBuffer: (db: DbClient, def: QueryDef) => Buffer[];

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

@@ -0,0 +1,82 @@
+import { walkDefs } from './walk.js';
+const EMPTY_BUFFER = Buffer.alloc(0);
+export const includeToBuffer = (db, def) => {
+    const result = [];
+    if (!def.include.stringFields.size &&
+        !def.include.props.size &&
+        !def.references.size &&
+        !def.include.main.len) {
+        return result;
+    }
+    let mainBuffer;
+    let len = 0;
+    let includeBuffer;
+    if (def.include.stringFields) {
+        for (const f of def.include.stringFields) {
+            walkDefs(db, def, f);
+        }
+    }
+    if (def.include.main.len > 0) {
+        if (def.include.main.len === def.schema.mainLen) {
+            // GET ALL MAIN FIELDS
+            let m = 0;
+            for (const key in def.include.main.include) {
+                const v = def.include.main.include[key];
+                const len = v[1].len;
+                v[0] = m;
+                m += len;
+            }
+            mainBuffer = EMPTY_BUFFER;
+        }
+        else {
+            // GET SOME MAIN FIELDS
+            const size = Object.keys(def.include.main.include).length;
+            mainBuffer = Buffer.allocUnsafe(size * 4 + 2);
+            mainBuffer.writeUint16LE(def.include.main.len, 0);
+            let i = 2;
+            let m = 0;
+            for (const key in def.include.main.include) {
+                const v = def.include.main.include[key];
+                mainBuffer.writeUint16LE(v[1].start, i);
+                const len = v[1].len;
+                v[0] = m;
+                mainBuffer.writeUint16LE(len, i + 2);
+                i += 4;
+                m += len;
+            }
+        }
+    }
+    const propSize = def.include.props.size ?? 0;
+    if (mainBuffer) {
+        len = mainBuffer.byteLength + 3 + propSize;
+        includeBuffer = Buffer.allocUnsafe(len);
+        includeBuffer[0] = 0;
+        includeBuffer.writeInt16LE(mainBuffer.byteLength, 1);
+        const offset = 3 + mainBuffer.byteLength;
+        mainBuffer.copy(includeBuffer, 3);
+        if (propSize) {
+            let i = 0;
+            for (const prop of def.include.props) {
+                includeBuffer[i + offset] = prop;
+                i++;
+            }
+        }
+    }
+    else if (propSize) {
+        const buf = Buffer.allocUnsafe(propSize);
+        let i = 0;
+        for (const prop of def.include.props) {
+            buf[i] = prop;
+            i++;
+        }
+        includeBuffer = buf;
+    }
+    if (includeBuffer) {
+        def.include.props.forEach((v) => {
+            def.include.propsRead[v] = 0;
+        });
+        result.push(includeBuffer);
+    }
+    return result;
+};
+//# sourceMappingURL=toBuffer.js.map

package/dist/src/client/query/include/utils.d.ts

@@ -0,0 +1,6 @@
+import { PropDef, PropDefEdge, SchemaPropTree } from '../../../server/schema/types.js';
+import { DbClient } from '../../index.js';
+import { QueryDef } from '../types.js';
+export declare const getAllFieldFromObject: (tree: SchemaPropTree | PropDef, arr?: string[]) => string[];
+export declare const createOrGetRefQueryDef: (db: DbClient, def: QueryDef, t: PropDef | PropDefEdge) => QueryDef;
+export declare const createOrGetEdgeRefQueryDef: (db: DbClient, def: QueryDef, t: PropDefEdge) => QueryDef;