nesoi 3.0.0

package/lib/elements/entities/bucket/adapters/memory.bucket_query copy.js

@@ -0,0 +1,218 @@
+"use strict";
+// import { AnyTrxNode } from '~/engine/transaction/trx_node';
+// import { NesoiObj } from '~/engine/data/obj';
+// import { NesoiError } from '~/engine/data/error';
+// import { Tree } from '~/engine/data/tree';
+// import { $BucketView } from '../view/bucket_view.schema';
+// import { BucketQuery } from '../query/bucket_query';
+// import { BucketAdapter } from './bucket_adapter';
+// import { MemoryBucketAdapter } from './memory.bucket_adapter';
+// /**
+//  * This is a slow implementation of the query engine for a Memory Bucket.
+//  * 
+//  * It goes through all objects and applies all rules. If one returns false,
+//  * it skips and goes to the next.
+//  */
+// export class MemoryBucketQuery extends BucketQuery {
+//     async run<Obj extends NesoiObj, V extends $BucketView>(
+//         adapter: BucketAdapter<Obj>,
+//         trx: AnyTrxNode,
+//         view: V,
+//         query: $BucketQuery,
+//         pagination?: NQL_Pagination
+//     ) {
+//         const filtered: Obj[] = [];
+//         await this.parse(trx, view, query);
+//         const memory = adapter as MemoryBucketAdapter<Obj>;
+//         for (const id in memory.data) {
+//             const obj = (memory.data as any)[id] as Obj;
+//             const match = await this.checkObj(view, obj, query);
+//             if (match) {
+//                 filtered.push(obj);
+//             }
+//         }
+//         return filtered;
+//     }
+//     private async checkObj<Obj extends NesoiObj, V extends $BucketView>(
+//         view: V,
+//         obj: Obj,
+//         query: $BucketQuery
+//     ) {
+//         for (const term of query.or) {
+//             const match = ('$t' in term) && term.$t === 'bucket.query.rule'
+//                 ? await this.applyRule(view, obj, term)
+//                 : await this.checkObj(view, obj, term);
+//             if (match) {
+//                 return true;
+//             }
+//         }
+//         for (const term of query.and) {
+//             const match = ('$t' in term) && term.$t === 'bucket.query.rule'
+//                 ? await this.applyRule(view, obj, term)
+//                 : await this.checkObj(view, obj, term);
+//             if (!match) {
+//                 return false;
+//             }
+//         }
+//         return true;
+//     }
+//     private async applyRule<Obj extends NesoiObj, V extends $BucketView>(
+//         view: V,
+//         obj: Obj,
+//         rule: $BucketQueryRule
+//     ) {
+//         const field = rule.viewField;
+//         const objVal = Tree.get(obj, rule.path);
+//         let res;
+//         switch (field.type) {
+//         case 'id':
+//             res = await this.applyIdRule(objVal, rule); break;
+//         case 'int':
+//         case 'float':
+//             res = await this.applyNumberRule(objVal, rule); break;
+//         case 'string':
+//             res = await this.applyStringRule(objVal, rule); break;
+//         case 'boolean':
+//             res = await this.applyBooleanRule(objVal, rule); break;
+//             // TODO
+//             // case 'list':
+//             //     return this.applyListRule(objVal, rule);
+//             // case 'obj':
+//             //     return this.applyObjRule(objVal, rule);
+//         }
+//         if (rule.not) {
+//             res = !res;
+//         }
+//         return res;
+//     }
+//     private async applyIdRule(
+//         objVal: number|string,
+//         rule: $BucketQueryRule
+//     ) {
+//         switch (rule.op) {
+//         case '==':
+//             if (typeof rule.parsedValue !== 'number' && typeof rule.parsedValue !== 'string')
+//                 throw NesoiError.Bucket.Query.InvalidRuleValueType(rule.path, 'id');
+//             return objVal === rule.parsedValue;
+//         case 'in':
+//             if (!Array.isArray(rule.parsedValue))
+//                 throw NesoiError.Bucket.Query.InvalidRuleValueType(rule.path, 'id[]');
+//             return (rule.parsedValue as (number|string)[]).includes(objVal);
+//         case 'present':
+//             return (objVal !== undefined) === rule.parsedValue;
+//         }
+//     }
+//     private async applyNumberRule(
+//         objVal: number | number[],
+//         rule: $BucketQueryRule
+//     ) {
+//         const isNumber = typeof objVal === 'number';
+//         const isNumberList = Array.isArray(objVal) && !objVal.some(v => typeof v !== 'number');
+//         if (!isNumber && !isNumberList) {
+//             return false;
+//         }
+//         switch (rule.op) {
+//         case '<':
+//             return (objVal as number) < (rule.parsedValue as number);
+//         case '<=':
+//             return (objVal as number) <= (rule.parsedValue as number);
+//         case '>':
+//             return (objVal as number) > (rule.parsedValue as number);
+//         case '>=':
+//             return (objVal as number) >= (rule.parsedValue as number);
+//         case '==':
+//             return (objVal as number) === (rule.parsedValue as number);
+//         case 'in':
+//             return (rule.parsedValue as number[]).includes(objVal as number);
+//         case 'contains':
+//             return (rule.parsedValue as boolean[]).includes(rule.parsedValue as boolean);
+//         case 'contains_any':
+//             return (rule.parsedValue as boolean[]).some(v => (rule.parsedValue as boolean[]).includes(v));
+//         case 'present':
+//             return (objVal !== undefined) === rule.parsedValue;
+//         }
+//     }
+//     private async applyStringRule(
+//         objVal: string | string[],
+//         rule: $BucketQueryRule
+//     ) {
+//         const isString = typeof objVal === 'string';
+//         const isStringList = Array.isArray(objVal) && !objVal.some(v => typeof v !== 'string');
+//         if (!isString && !isStringList) {
+//             return false;
+//         }
+//         switch (rule.op) {
+//         case '==':
+//             if (rule.case_sensitive) {
+//                 return objVal === rule.parsedValue;
+//             }
+//             return (objVal as string).toLowerCase() === (rule.parsedValue as string).toLowerCase()
+//         case 'contains':
+//             if (rule.case_sensitive) {
+//                 return objVal.includes(rule.parsedValue as string);
+//             }
+//             return (objVal as string).toLowerCase().includes((rule.parsedValue as string).toLowerCase());
+//         case 'contains_any':
+//             if (rule.case_sensitive) {
+//                 return (rule.parsedValue as string[]).some(v => objVal.includes(v.toString()));
+//             }
+//             return (rule.parsedValue as string[])
+//                 .map(o => o.toString().toLowerCase())
+//                 .some(v => objVal.includes(v.toString()));
+//         case 'in':
+//             return (rule.parsedValue as string|string[]).includes(objVal as string);
+//         case 'present':
+//             return (objVal !== undefined) === rule.parsedValue;
+//         }
+//     }
+//     private async applyBooleanRule(
+//         objVal: boolean | boolean[],
+//         rule: $BucketQueryRule
+//     ) {
+//         const isBoolean = typeof objVal === 'boolean';
+//         const isBooleanList = Array.isArray(objVal) && !objVal.some(v => typeof v !== 'boolean');
+//         if (!isBoolean && !isBooleanList) {
+//             return false;
+//         }
+//         switch (rule.op) {
+//         case '==':
+//             return objVal === rule.parsedValue;
+//         case 'in':
+//             return (rule.parsedValue as boolean[]).includes(objVal as boolean);
+//         case 'contains':
+//             return (objVal as boolean[]).includes(rule.parsedValue as boolean);
+//         case 'contains_any':
+//             return (rule.parsedValue as boolean[]).some(v => (objVal as boolean[]).includes(v));
+//         case 'present':
+//             return (objVal !== undefined) === rule.parsedValue;
+//         }
+//     }
+//     // private async applyObjRule<Obj extends NesoiObj, V extends $BucketView>(
+//     //     objVal: Record<string, any>,
+//     //     rule: $BucketQueryRule
+//     // ) {
+//     //     if (typeof objVal !== 'object' && !Array.isArray(objVal)) {
+//     //         return false;
+//     //     }
+//     //     switch (rule.op) {
+//     //     // case '==':
+//     //     //     if (typeof rule.parsedValue !== 'object' && !Array.isArray(rule.parsedValue))
+//     //     //         throw NesoiError.Bucket.Query.InvalidRuleValueType(rule.path, 'object');
+//     //     //     return objVal === rule.parsedValue;
+//     //     case 'contains':
+//     //         if (typeof rule.parsedValue !== 'string')
+//     //             throw NesoiError.Bucket.Query.InvalidRuleValueType(rule.path, 'string');
+//     //         return Object.keys(objVal).includes(rule.parsedValue);
+//     //         // case 'contains_any':
+//     //         //     if (!Array.isArray(rule.parsedValue))
+//     //         //         throw NesoiError.Bucket.Query.InvalidRuleValueType(rule.path, 'object');
+//     //         //     return rule.parsedValue.some(v => Object.keys(objVal).includes(v));
+//     //         // case 'in':
+//     //         //     if (!Array.isArray(rule.parsedValue))
+//     //         //         throw NesoiError.Bucket.Query.InvalidRuleValueType(rule.path, 'object');
+//     //         //     return (rule.parsedValue as Record<string, any>[]).includes(objVal);
+//     //     case 'present':
+//     //         return objVal !== undefined;
+//     //     }
+//     // }
+// }

package/lib/elements/entities/bucket/adapters/memory.nql.d.ts

@@ -0,0 +1,19 @@
+import { NQLRunner } from '../query/nql_engine';
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { NQL_Part } from '../query/nql.schema';
+import { MemoryBucketAdapter } from "../../..";
+type Obj = Record<string, any>;
+type Objs = Record<string, Obj>;
+export declare class MemoryNQLRunner extends NQLRunner {
+    protected adapter?: MemoryBucketAdapter<any>;
+    constructor();
+    bind(adapter: MemoryBucketAdapter<any>): void;
+    run(trx: AnyTrxNode, part: NQL_Part, params: Obj): Promise<Objs>;
+    /**
+     * Goes through each rule keeping a scoped white and black list to avoid
+     * testing objects unnecessarily. Returns a dict of results by id.
+     * @returns
+     */
+    private filter;
+}
+export {};

package/lib/elements/entities/bucket/adapters/memory.nql.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryNQLRunner = void 0;
+const nql_engine_1 = require("../query/nql_engine");
+const tree_1 = require("../../../../engine/data/tree");
+class MemoryNQLRunner extends nql_engine_1.NQLRunner {
+    constructor() {
+        super();
+    }
+    bind(adapter) {
+        this.adapter = adapter;
+    }
+    async run(trx, part, params) {
+        if (!this.adapter) {
+            throw new Error('No adapter bound to NQL Runner');
+        }
+        const data = this.adapter.data;
+        return this.filter(part, data, params);
+    }
+    /**
+     * Goes through each rule keeping a scoped white and black list to avoid
+     * testing objects unnecessarily. Returns a dict of results by id.
+     * @returns
+     */
+    filter(part, objs, params) {
+        const _union = (union, objs, params) => {
+            // console.log(`::UNION (objs: ${Object.keys(objs)})\n`)
+            const out = {};
+            for (const inter of union.inters) {
+                // Pass `out` as blacklist: if already found, can be skipped
+                const black = out;
+                const interOut = _inter(inter, objs, params, black);
+                Object.assign(out, interOut);
+            }
+            // console.log('    -> union out\n', out);
+            return out;
+        };
+        const _inter = (inter, objs, params, black = {}) => {
+            // console.log(`::INTER (objs: ${Object.keys(objs)}, black: ${Object.keys(black)})\n`)
+            // Create white set, which will be modified by rules running on this union
+            const white = new Set(Object.keys(objs));
+            let out = {};
+            for (const rule of inter.rules) {
+                // <Union>
+                if ('inters' in rule) {
+                    if (!_union(rule, objs, objs))
+                        return false;
+                }
+                // <Rule>
+                else {
+                    const ruleOut = _rule(rule, objs, params, black, white);
+                    out = ruleOut;
+                }
+                if (white.size == 0)
+                    break;
+                // console.log(`    -> white: ${Array.from(white.values())}\n`)
+            }
+            // console.log(`    -> inter out: ${Object.keys(out)}\n`)
+            return out;
+        };
+        const _rule = (rule, objs, params, black, white) => {
+            // console.log(`::RULE (objs: ${Object.keys(objs)}, black: ${Object.keys(black)}, white: ${Array.from(white.values())})\n`)
+            const out = {};
+            for (const id in objs) {
+                if (!white.has(id)) {
+                    continue;
+                }
+                if (id in black) {
+                    white.delete(id);
+                    continue;
+                }
+                const obj = objs[id];
+                let match = _obj(rule, obj, params);
+                // console.log(`    -> match: ${match}\n`)
+                if (rule.not) {
+                    match = !match;
+                }
+                if (!match) {
+                    white.delete(id);
+                    continue;
+                }
+                if (obj !== undefined) {
+                    if (rule.select) {
+                        out[obj.id] = obj[rule.select];
+                    }
+                    else {
+                        out[obj.id] = obj;
+                    }
+                }
+            }
+            // console.log(`    -> rule out: ${Object.keys(out)}\n`)
+            return out;
+        };
+        const _obj = (rule, obj, params) => {
+            // console.log(`::OBJ (obj: ${obj.id})\n`)
+            const fieldValue = tree_1.Tree.get(obj, rule.fieldpath);
+            // Value is undefined, only 'present' rule applies
+            if (fieldValue === undefined) {
+                if (rule.op === 'present') {
+                    return false;
+                }
+                return false;
+            }
+            // Fieldpath is a spread, apply rule to each item
+            if (rule.fieldpath.includes('.*')) {
+                for (const item of fieldValue) {
+                    if (_obj(rule, item, params))
+                        return true;
+                }
+                return false;
+            }
+            let queryValue;
+            // Value is a subquery, run union
+            if ('subquery' in rule.value) {
+                const subOut = _union(rule.value.subquery, objs, params);
+                const subList = Object.values(subOut);
+                // Subquery operator is for a list, filter
+                if (rule.op === 'in' || rule.op === 'contains_any') {
+                    queryValue = subList;
+                }
+                // Subquery operator is for a single item, pick first
+                else {
+                    queryValue = subList[0];
+                }
+            }
+            else if ('param' in rule.value) {
+                if (Array.isArray(rule.value.param)) {
+                    queryValue = rule.value.param.map(p => params[p]);
+                }
+                else {
+                    queryValue = params[rule.value.param];
+                }
+            }
+            else if ('static' in rule.value) {
+                queryValue = rule.value.static;
+            }
+            // console.log({fieldpath: rule.fieldpath, op: rule.op, fieldValue, queryValue});
+            // Check each operation
+            // (Compatible operations and types have already been validated)
+            if (rule.op === '<') {
+                return fieldValue < queryValue;
+            }
+            if (rule.op === '<=') {
+                return fieldValue <= queryValue;
+            }
+            if (rule.op === '==') {
+                if (rule.case_i) {
+                    return fieldValue.toLowerCase() === queryValue.toLowerCase();
+                }
+                else {
+                    return fieldValue === queryValue;
+                }
+            }
+            if (rule.op === '>') {
+                return fieldValue > queryValue;
+            }
+            if (rule.op === '>=') {
+                return fieldValue >= queryValue;
+            }
+            if (rule.op === 'in') {
+                if (typeof fieldValue === 'object' && !Array.isArray(fieldValue)) {
+                    return fieldValue in queryValue;
+                }
+                else {
+                    return queryValue.includes(fieldValue);
+                }
+            }
+            if (rule.op === 'contains') {
+                if (typeof fieldValue === 'string') {
+                    if (rule.case_i) {
+                        return fieldValue.toLowerCase().includes(queryValue.toLowerCase());
+                    }
+                    else {
+                        return fieldValue.includes(queryValue);
+                    }
+                }
+                else {
+                    if (rule.case_i) {
+                        return Object.keys(fieldValue).some(f => f.toLowerCase().includes(queryValue.toLowerCase()));
+                    }
+                    else {
+                        return queryValue in fieldValue;
+                    }
+                }
+            }
+            if (rule.op === 'contains_any') {
+                if (typeof fieldValue === 'string') {
+                    if (rule.case_i) {
+                        return queryValue.some(q => fieldValue.toLowerCase().includes(q.toLowerCase()));
+                    }
+                    else {
+                        return queryValue.some(q => fieldValue.includes(q));
+                    }
+                }
+                else {
+                    if (rule.case_i) {
+                        return queryValue.some(q => Object.keys(q).some(k => fieldValue.toLowerCase().includes(q.toLowerCase())));
+                    }
+                    else {
+                        return queryValue.some(q => q in fieldValue);
+                    }
+                }
+            }
+            if (rule.op === 'present') {
+                return true;
+            }
+            return false;
+        };
+        return _union(part.union, objs, params);
+    }
+}
+exports.MemoryNQLRunner = MemoryNQLRunner;

package/lib/elements/entities/bucket/adapters/slow_memory.bucket_adapter.d.ts

@@ -0,0 +1,20 @@
+import { BucketAdapterConfig } from './bucket_adapter';
+import { MemoryBucketAdapter } from './memory.bucket_adapter';
+import { $Bucket } from '../bucket.schema';
+import { NesoiObj } from "../../../../engine/data/obj";
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { NQL_AnyQuery, NQL_Pagination } from '../query/nql.schema';
+export declare class SlowMemoryBucketAdapter<Obj extends NesoiObj> extends MemoryBucketAdapter<Obj> {
+    schema: $Bucket;
+    protected timeout: number;
+    constructor(schema: $Bucket, timeout: number, data?: Record<Obj['id'], Obj>, config?: BucketAdapterConfig);
+    private wrap;
+    index(trx: AnyTrxNode): Promise<Obj[]>;
+    get(trx: AnyTrxNode, id: Obj['id']): Promise<Awaited<Record<Obj["id"], Obj>[Obj["id"]]>>;
+    query<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, config?: {
+        metadataOnly: MetadataOnly;
+    }): Promise<MetadataOnly extends true ? {
+        id: Obj['id'];
+        [x: string]: any;
+    }[] : Obj[]>;
+}

package/lib/elements/entities/bucket/adapters/slow_memory.bucket_adapter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlowMemoryBucketAdapter = void 0;
+const memory_bucket_adapter_1 = require("./memory.bucket_adapter");
+class SlowMemoryBucketAdapter extends memory_bucket_adapter_1.MemoryBucketAdapter {
+    constructor(schema, timeout, data = {}, config) {
+        super(schema, data, config);
+        this.schema = schema;
+        this.timeout = timeout;
+    }
+    wrap(scale, fn) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                fn()
+                    .then(resolve)
+                    .catch(reject);
+            }, this.timeout * scale);
+        });
+    }
+    /* Read operations */
+    index(trx) {
+        return this.wrap(5, () => super.index(trx));
+    }
+    get(trx, id) {
+        return this.wrap(1, () => super.get(trx, id));
+    }
+    async query(trx, query, pagination, config) {
+        return this.wrap(3, () => super.query(trx, query, pagination, config));
+    }
+}
+exports.SlowMemoryBucketAdapter = SlowMemoryBucketAdapter;

package/lib/elements/entities/bucket/bucket.builder.d.ts

@@ -0,0 +1,61 @@
+import { $Module, $Space, BucketName } from "../../../schema";
+import { BucketGraphDef } from './graph/bucket_graph.builder';
+import { $BucketView, $BucketViews } from './view/bucket_view.schema';
+import { BucketViewDef } from './view/bucket_view.builder';
+import { $Bucket } from './bucket.schema';
+import { BucketModelDef } from './model/bucket_model.builder';
+import { $BucketModelFields } from './model/bucket_model.schema';
+import { $BucketViewDataInfer, $BucketViewFieldsInfer } from './bucket.infer';
+import { $BucketGraphLinksInfer } from './graph/bucket_graph.infer';
+import { $BucketGraph } from './graph/bucket_graph.schema';
+import { $Dependency, ResolvedBuilderNode } from "../../../engine/dependency";
+import { ModuleTree } from "../../../engine/tree";
+import { BucketFieldpathInfer, BucketModelInfer } from './model/bucket_model.infer';
+import { Overlay } from "../../../engine/util/type";
+import { $Constants } from '../constants/constants.schema';
+import { NesoiObj } from "../../../engine/data/obj";
+export declare class BucketBuilder<Space extends $Space, Module extends $Module, Bucket extends $Bucket = Omit<$Bucket, 'views'> & {
+    views: {};
+}> {
+    private module;
+    private name;
+    $b: "bucket";
+    private _alias?;
+    private _model;
+    private _graph;
+    private _views;
+    private _extend?;
+    constructor(module: string, name: string);
+    as(alias: string): this;
+    extend<N extends Exclude<BucketName<Module>, Bucket['name']>>(name: N): BucketBuilder<Space, Module, Module["buckets"][N]>;
+    model<Def extends BucketModelDef<Space, Module>, Obj = BucketModelInfer<Def>, Fieldpath extends {} = BucketFieldpathInfer<Def>>($: Def): BucketBuilder<Space, Overlay<Module, {
+        buckets: Overlay<Module["buckets"], { [K in Bucket["name"]]: Overlay<Bucket, {
+            '#data': Obj & NesoiObj;
+            '#fieldpath': Fieldpath;
+        }>; }>;
+    }>, Overlay<Bucket, {
+        '#data': Obj & NesoiObj;
+        '#fieldpath': Fieldpath;
+    }>>;
+    graph<Def extends BucketGraphDef<Module, Bucket>>($: Def): BucketBuilder<Space, Module, Overlay<Bucket, {
+        graph: Overlay<Bucket["graph"], {
+            links: $BucketGraphLinksInfer<ReturnType<Def>>;
+        }>;
+    }>>;
+    view<ViewName extends string, Def extends BucketViewDef<Space, Module, Bucket>>(name: ViewName, $: Def): BucketBuilder<Space, Module, Bucket & {
+        views: { [K in ViewName]: $BucketView & {
+            "#data": $BucketViewDataInfer<ReturnType<Def>>;
+            fields: $BucketViewFieldsInfer<ReturnType<Def>>;
+        }; };
+    }>;
+    static build(node: BucketBuilderNode, tree: ModuleTree): $Bucket;
+    static mergeModelEnums(fields: $BucketModelFields, constants: $Constants): void;
+    static buildGraph(node: BucketBuilderNode, tree: ModuleTree, extend?: $Dependency): $BucketGraph;
+    static buildViews(builder: AnyBucketBuilder, graph: $BucketGraph, tree: ModuleTree, extend?: $Dependency): $BucketViews;
+    static checkComposition(node: BucketBuilderNode, graph: $BucketGraph): void;
+}
+export type AnyBucketBuilder = BucketBuilder<any, any>;
+export type BucketBuilderNode = ResolvedBuilderNode & {
+    builder: AnyBucketBuilder;
+    schema?: $Bucket;
+};