nesoi 3.0.0

package/lib/elements/entities/bucket/model/bucket_model.schema.d.ts

@@ -0,0 +1,35 @@
+import { $Dependency } from "../../../../engine/dependency";
+export type $BucketModelFieldType = 'boolean' | 'date' | 'datetime' | 'decimal' | 'enum' | 'file' | 'float' | 'int' | 'string' | 'obj' | 'unknown' | 'dict';
+export declare class $BucketModelField {
+    name: string;
+    type: $BucketModelFieldType;
+    alias: string;
+    array: boolean;
+    required: boolean;
+    _enum?: {
+        options: string | string[];
+        dep?: $Dependency;
+    } | undefined;
+    defaultValue?: any | undefined;
+    children?: $BucketModelFields | undefined;
+    or?: $BucketModelField | undefined;
+    $t: string;
+    constructor(name: string, type: $BucketModelFieldType, alias: string, array: boolean, required: boolean, _enum?: {
+        options: string | string[];
+        dep?: $Dependency;
+    } | undefined, defaultValue?: any | undefined, children?: $BucketModelFields | undefined, or?: $BucketModelField | undefined);
+}
+export type $BucketModelFields = {
+    [x: string]: $BucketModelField;
+};
+export declare class $BucketModel {
+    fields: $BucketModelFields & {
+        id: $BucketModelField;
+    };
+    defaults: Record<string, any>;
+    $t: string;
+    constructor(fields: $BucketModelFields & {
+        id: $BucketModelField;
+    }, defaults?: Record<string, any>);
+    static get(model: $BucketModel, fieldpath: string): $BucketModelField | undefined;
+}

package/lib/elements/entities/bucket/model/bucket_model.schema.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$BucketModel = exports.$BucketModelField = void 0;
+class $BucketModelField {
+    constructor(name, type, alias, array, required, _enum, defaultValue, children, or) {
+        this.name = name;
+        this.type = type;
+        this.alias = alias;
+        this.array = array;
+        this.required = required;
+        this._enum = _enum;
+        this.defaultValue = defaultValue;
+        this.children = children;
+        this.or = or;
+        this.$t = 'bucket.model.field';
+    }
+}
+exports.$BucketModelField = $BucketModelField;
+class $BucketModel {
+    constructor(fields, defaults = {}) {
+        this.fields = fields;
+        this.defaults = defaults;
+        this.$t = 'bucket.model';
+    }
+    static get(model, fieldpath) {
+        const paths = fieldpath.split('.');
+        let ref = model.fields;
+        for (let i = 0; i < paths.length; i++) {
+            const path = paths[i];
+            if (path === '*') {
+                continue;
+            }
+            else {
+                ref = ref?.[path];
+            }
+            if (!ref?.children || i == paths.length - 1) {
+                return ref;
+            }
+            if (!ref) {
+                return undefined;
+            }
+            ref = ref.children;
+        }
+        return ref;
+    }
+}
+exports.$BucketModel = $BucketModel;

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

@@ -0,0 +1,119 @@
+import { $Module, $Space } from "../../../../schema";
+import { $BucketModelField, $BucketModelFieldType, $BucketModelFields } from './bucket_model.schema';
+import { NesoiDate } from "../../../../engine/data/date";
+import { BucketFieldpathObjInfer, BucketModelObjInfer } from './bucket_model.infer';
+import { $Dependency } from "../../../../engine/dependency";
+import { EnumFromName, EnumName } from '../../constants/constants.schema';
+import { Decimal } from "../../../../engine/data/decimal";
+import { NesoiDatetime } from "../../../../engine/data/datetime";
+export declare class BucketModelFieldFactory<Space extends $Space, Module extends $Module> {
+    private module;
+    constructor(module: string);
+    private alias?;
+    as(alias: string): Omit<typeof this, "as">;
+    get any(): BucketModelFieldBuilder<Module, any, never, any, {
+        '': any;
+    }>;
+    get boolean(): BucketModelFieldBuilder<Module, boolean, never, boolean, {
+        '': boolean;
+    }>;
+    get date(): BucketModelFieldBuilder<Module, NesoiDate, never, NesoiDate, {
+        '': NesoiDate;
+    }>;
+    get datetime(): BucketModelFieldBuilder<Module, NesoiDatetime, never, NesoiDatetime, {
+        '': NesoiDatetime;
+    }>;
+    decimal(def?: {
+        left?: number;
+        right?: number;
+    }): BucketModelFieldBuilder<Module, Decimal, never, Decimal, {
+        '': Decimal;
+    }>;
+    enum<Enums extends EnumName<Space>, Options extends (keyof Enums & string) | (readonly string[])>(options: Options): BucketModelFieldBuilder<Module, Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], never, Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], {
+        '': Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options];
+    }>;
+    get int(): BucketModelFieldBuilder<Module, number, never, number, {
+        '': number;
+    }>;
+    get float(): BucketModelFieldBuilder<Module, number, never, number, {
+        '': number;
+    }>;
+    get string(): BucketModelFieldBuilder<Module, string, never, string, {
+        '': string;
+    }>;
+    obj<T extends BucketModelFieldBuilders<Module>>(fields?: T): BucketModelFieldBuilder<Module, BucketModelObjInfer<T>, never, BucketModelObjInfer<T>, {
+        '': BucketModelObjInfer<T>;
+    } & BucketFieldpathObjInfer<T, ".">>;
+    dict<T extends BucketModelFieldBuilder<Module, any>>(dictItem: T): BucketModelFieldBuilder<Module, Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
+        '': infer X;
+    }> ? X : never>, never, Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
+        '': infer X;
+    }> ? X : never>, {
+        '': Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
+            '': infer X;
+        }> ? X : never>;
+    } & BucketFieldpathObjInfer<{
+        '': T;
+    }, ".*">>;
+}
+export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData, TypeAppend = never, Data = DefinedData | TypeAppend, Fieldpath = {
+    '': Data;
+}> {
+    private module;
+    private type;
+    private alias?;
+    private _enum?;
+    private children?;
+    private _array;
+    private _required;
+    private _defaultValue?;
+    private _or?;
+    constructor(module: string, type: $BucketModelFieldType, alias?: string | undefined, _enum?: {
+        options: string | string[];
+        dep?: $Dependency;
+    } | undefined, children?: BucketModelFieldBuilders<Module> | undefined);
+    as(alias: string): this;
+    /**
+     * This field can be `undefined`.
+     */
+    get optional(): BucketModelFieldBuilder<Module, DefinedData, undefined, DefinedData | undefined, { [K in keyof Fieldpath]: Fieldpath[K] | undefined; }>;
+    /**
+     * If this field is undefined on the source, it will be
+     * read as the given value.
+     * Also, when creating or updating the model through a default
+     * resource method, this value is used if undefined is passed.
+     */
+    default(defaultValue: DefinedData): BucketModelFieldBuilder<Module, DefinedData, never, DefinedData, Fieldpath>;
+    get array(): BucketModelFieldBuilder<Module, DefinedData[], TypeAppend, DefinedData[] | TypeAppend, { [K in Exclude<keyof Fieldpath, ""> as `.*${K & string}`]: Fieldpath[K]; } & {
+        "": DefinedData[] | TypeAppend;
+        ".*": DefinedData | TypeAppend;
+    }>;
+    or<Def extends AnyBucketModelFieldBuilder>(def: Def): BucketModelFieldBuilder<Module, DefinedData | (Def extends BucketModelFieldBuilder<any, any, any, infer X, {
+        '': infer X;
+    }> ? X : never), TypeAppend, DefinedData | (Def extends BucketModelFieldBuilder<any, any, any, infer X, {
+        '': infer X;
+    }> ? X : never) | TypeAppend, { [K in Exclude<keyof Fieldpath, "">]: Fieldpath[K] | (K extends keyof (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never) ? (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never)[K] : undefined); } & {
+        "": DefinedData | (Def extends BucketModelFieldBuilder<any, any, any, infer X, {
+            '': infer X;
+        }> ? X : never) | TypeAppend;
+    } & { [K in Exclude<keyof (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never), "">]: (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never)[K]; }>;
+    /**
+     * This can be applied to `string` and `enum` fields,
+     * to control storage performance.
+     * - `null` means unconstrained length
+     * - `number` must be an integer number, if not it's floored
+     * > Notice: `enum` has a default max length of 64.
+     * > `string` is unconstrained by default.
+     * > If you want unconstrained enum you must specify `null` here.
+     */
+    maxLength(val: number | null): void;
+    static build(builder: BucketModelFieldBuilder<any, any>, name: string): $BucketModelField;
+    static buildChildren(module: string, children: BucketModelFieldBuilders<any>): {
+        schema: $BucketModelFields;
+        defaults: Record<string, any>;
+    };
+}
+export type BucketModelFieldBuilders<Module extends $Module> = {
+    [x: string]: BucketModelFieldBuilder<Module, any> | BucketModelFieldBuilders<Module>;
+};
+export type AnyBucketModelFieldBuilder = BucketModelFieldBuilder<any, any>;

package/lib/elements/entities/bucket/model/bucket_model_field.builder.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketModelFieldBuilder = exports.BucketModelFieldFactory = void 0;
+const bucket_model_schema_1 = require("./bucket_model.schema");
+const dependency_1 = require("../../../../engine/dependency");
+/*
+    Factory
+*/
+class BucketModelFieldFactory {
+    constructor(module) {
+        this.module = module;
+    }
+    as(alias) {
+        this.alias = alias;
+        return this;
+    }
+    get any() {
+        return new BucketModelFieldBuilder(this.module, 'unknown', this.alias);
+    }
+    get boolean() {
+        return new BucketModelFieldBuilder(this.module, 'boolean', this.alias);
+    }
+    get date() {
+        return new BucketModelFieldBuilder(this.module, 'date', this.alias);
+    }
+    get datetime() {
+        return new BucketModelFieldBuilder(this.module, 'datetime', this.alias);
+    }
+    decimal(def) {
+        // TODO: store definition on schema
+        return new BucketModelFieldBuilder(this.module, 'decimal', this.alias);
+    }
+    enum(options) {
+        const strings = (Array.isArray(options) || typeof options === 'string')
+            ? options
+            : Object.keys(options);
+        let dep;
+        if (typeof options === 'string') {
+            const tag = dependency_1.$Tag.parseOrFail(options);
+            if (tag.module) {
+                dep = new dependency_1.$Dependency(this.module, 'constants', `${tag.module}::*`);
+            }
+            else {
+                dep = new dependency_1.$Dependency(this.module, 'constants', '*');
+            }
+        }
+        return new BucketModelFieldBuilder(this.module, 'enum', this.alias, { options: strings, dep });
+    }
+    get int() {
+        return new BucketModelFieldBuilder(this.module, 'int', this.alias);
+    }
+    get float() {
+        return new BucketModelFieldBuilder(this.module, 'float', this.alias);
+    }
+    get string() {
+        return new BucketModelFieldBuilder(this.module, 'string', this.alias);
+    }
+    obj(fields) {
+        return new BucketModelFieldBuilder(this.module, 'obj', this.alias, undefined, fields);
+    }
+    dict(dictItem) {
+        return new BucketModelFieldBuilder(this.module, 'dict', this.alias, undefined, { __dict: dictItem });
+    }
+}
+exports.BucketModelFieldFactory = BucketModelFieldFactory;
+/*
+    Builder
+*/
+class BucketModelFieldBuilder {
+    constructor(module, type, alias, _enum, children) {
+        this.module = module;
+        this.type = type;
+        this.alias = alias;
+        this._enum = _enum;
+        this.children = children;
+        this._array = false;
+        this._required = true;
+        this._defaultValue = undefined;
+    }
+    as(alias) {
+        this.alias = alias;
+        return this;
+    }
+    /**
+     * This field can be `undefined`.
+     */
+    get optional() {
+        this._required = false;
+        return this;
+    }
+    /**
+     * If this field is undefined on the source, it will be
+     * read as the given value.
+     * Also, when creating or updating the model through a default
+     * resource method, this value is used if undefined is passed.
+     */
+    default(defaultValue) {
+        this._required = false;
+        this._defaultValue = defaultValue;
+        return this;
+    }
+    get array() {
+        this._array = true;
+        return this;
+    }
+    or(def) {
+        this._or = def;
+        return this;
+    }
+    /**
+     * This can be applied to `string` and `enum` fields,
+     * to control storage performance.
+     * - `null` means unconstrained length
+     * - `number` must be an integer number, if not it's floored
+     * > Notice: `enum` has a default max length of 64.
+     * > `string` is unconstrained by default.
+     * > If you want unconstrained enum you must specify `null` here.
+     */
+    maxLength(val) {
+    }
+    // Build
+    static build(builder, name) {
+        const children = builder.children
+            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children)
+            : undefined;
+        const defaults = builder._defaultValue && builder.children
+            ? Object.assign({}, builder._defaultValue, children?.defaults)
+            : builder._defaultValue;
+        const or = builder._or
+            ? this.build(builder._or, name)
+            : undefined;
+        return new bucket_model_schema_1.$BucketModelField(name, builder.type, builder.alias || name, builder._array, builder._required, builder._enum, defaults, children?.schema, or);
+    }
+    static buildChildren(module, children) {
+        const schema = {};
+        const defaults = {};
+        for (const c in children) {
+            const child = children[c];
+            if (child instanceof BucketModelFieldBuilder) {
+                schema[c] = BucketModelFieldBuilder.build(child, c);
+            }
+            // Builders are allowed to implicitly declare nested fields.
+            // The code below transforms these groups into fields of the scope 'group'.
+            else {
+                const fieldTypeBuilder = new BucketModelFieldFactory(module);
+                const fieldBuilder = fieldTypeBuilder.obj(child);
+                schema[c] = BucketModelFieldBuilder.build(fieldBuilder, c);
+            }
+            defaults[c] = schema[c].defaultValue;
+        }
+        return { schema, defaults };
+    }
+}
+exports.BucketModelFieldBuilder = BucketModelFieldBuilder;

package/lib/elements/entities/bucket/query/nql.schema.d.ts

@@ -0,0 +1,140 @@
+import { $Bucket } from '../bucket.schema';
+import { $Module } from "../../../../schema";
+import { NesoiDate } from "../../../../engine/data/date";
+import { NesoiDatetime } from "../../../../engine/data/datetime";
+export type NQL_QueryMeta = {
+    bucket?: $Bucket;
+    scope?: string;
+    avgTime: number;
+};
+export type NQL_Union = {
+    meta: NQL_QueryMeta;
+    inters: NQL_Intersection[];
+    order?: {
+        by: string;
+        dir: 'asc' | 'desc';
+    };
+    _debug_id?: number;
+};
+export type NQL_Intersection = {
+    meta: NQL_QueryMeta;
+    rules: (NQL_Rule | NQL_Union)[];
+    _debug_id?: number;
+};
+export type NQL_Rule = {
+    meta: NQL_QueryMeta;
+    fieldpath: string;
+    op: NQL_Operation;
+    case_i: boolean;
+    not: boolean;
+    value: {
+        static: any | any[];
+    } | {
+        param: string | string[];
+    } | {
+        subquery: NQL_Union;
+    };
+    select?: string;
+    part?: number;
+    _debug_id?: number;
+};
+export type NQL_Part = {
+    i: number;
+    many: boolean;
+    union: NQL_Union;
+    parent?: NQL_Part;
+};
+export type NQL_Node = NQL_Union | NQL_Intersection | NQL_Rule;
+/**
+ * All operations
+ */
+export type NQL_Operation = '==' | '>' | '<' | '>=' | '<=' | 'in' | 'contains' | 'contains_any' | 'present';
+export type NQL_Order<Fieldpath> = {
+    by?: keyof Fieldpath;
+    dir?: 'asc' | 'desc';
+};
+export type NQL_Pagination = {
+    page?: number;
+    perPage?: number;
+};
+/**
+ * A union of all operators which apply to the selected field
+ */
+type NQL_OpFromField<T> = T extends boolean ? '' | ' ==' | ' in' | ' present' : T extends number | NesoiDate | NesoiDatetime ? '' | ' ==' | ' >' | ' <' | ' >=' | ' <=' | ' in' | ' present' : T extends string ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' | ' ~' | ' ~in' | ' ~contains' | ' ~contains_any' : T extends boolean[] | number[] | NesoiDate[] | NesoiDatetime[] | string[] ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' : T extends object ? ' contains' | ' contains_any' | ' present' : ' present';
+/**
+ * A dict of accepted values for a given operator on a bucket field
+ */
+type NQL_ValueFromOp<T> = {
+    '': T;
+    ' ==': T;
+    ' ~': T;
+    ' >': T;
+    ' <': T;
+    ' >=': T;
+    ' <=': T;
+    ' in': T[];
+    ' ~in': T[];
+    ' contains': (T extends (infer X)[] ? X : string);
+    ' ~contains': (T extends (infer X)[] ? X : string);
+    ' contains_any': (T extends any[] ? T : string[]);
+    ' ~contains_any': (T extends any[] ? T : string[]);
+    ' present': '';
+};
+/**
+ * The expected type for a value, or a compatible parameter from the list
+ */
+type NQL_ConditionValue<T, Parameters, Titem = NoInfer<T extends (infer X)[] ? X : never>, P = NoInfer<{
+    [X in keyof Parameters]: NonNullable<Parameters[X]> extends NonNullable<T> ? X : never;
+}[keyof Parameters]>, PArr = NoInfer<{
+    [X in keyof Parameters]: NonNullable<Parameters[X]> extends NonNullable<Titem> ? X : never;
+}[keyof Parameters]>> = T | {
+    '.': P;
+} | {
+    '.': PArr;
+}[];
+/**
+ * A field name of the subquery bucket which resolves to
+ * a type that's compatible with the query
+ */
+type NQL_SubQueryField<$ extends $Bucket, Field, Fieldpath = NoInfer<$['#fieldpath']>, T = NoInfer<Fieldpath[Field & keyof Fieldpath]>> = keyof {
+    [X in keyof Fieldpath as NonNullable<T> extends NonNullable<Fieldpath[X]> ? X : never]: any;
+};
+/**
+ * A subquery passed as value to a query
+ * It must be of the form:
+ * {
+ *      @BUCKETNAME.FIELDNAME: { ... }
+ * }
+ */
+type NQL_SubQuery<M extends $Module, Field, Parameters> = {
+    [B in keyof M['buckets'] as `${'' | 'or '}@${B & string}.${NQL_SubQueryField<M['buckets'][B], Field> & string}`]?: NQL_Query<M, M['buckets'][B], Parameters>;
+};
+/**
+ * Graph link
+ */
+type NQL_GraphLinks<M extends $Module, $ extends $Bucket, Parameters = {}> = {
+    [K in keyof $['graph']['links'] as `*${K & string}`]?: NQL_Terms<M, $['graph']['links'][K]['#bucket'], Parameters>;
+};
+/**
+    All possible query rules on the format:
+    (or |)FIELDNAME( not|)OPERATOR
+*/
+type NQL_Terms<M extends $Module, $ extends $Bucket, Parameters = {}, Fieldpath = NoInfer<$['#fieldpath']>, Conditions = NoInfer<{
+    [Field in keyof Fieldpath as Field]: {
+        [Op in NQL_OpFromField<Fieldpath[Field]> as `${'or ' | ''}${Field & string}${' not' | ''}${Op}`]?: NQL_ConditionValue<NQL_ValueFromOp<Fieldpath[Field]>[Op], Parameters> | NQL_SubQuery<M, Field, Parameters>;
+    };
+}>> = Conditions[keyof Conditions] & {
+    [K in `${'#and' | '#or'}${string}`]?: NQL_Terms<M, $, Parameters>;
+} & NQL_GraphLinks<M, $, Parameters> & {
+    '#order'?: NQL_Order<Fieldpath>;
+};
+/**
+ * NQL Dynamic Query Type
+ */
+export type NQL_Query<M extends $Module, $ extends $Bucket, Parameters = {}> = NQL_Terms<M, $, Parameters>;
+export type NQL_AnyQuery = NQL_Query<any, any>;
+/**
+ * @deprecated Use `NQL_Query` instead
+ */
+export type AnyQuery<M extends $Module, $ extends $Bucket, Parameters = {}> = NQL_Query<M, $, Parameters>;
+export {};

package/lib/elements/entities/bucket/query/nql.schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/elements/entities/bucket/query/nql_compiler.d.ts

@@ -0,0 +1,44 @@
+import { NQL_AnyQuery, NQL_Union, NQL_Part, NQL_Node } from './nql.schema';
+import { AnyModule } from "../../../../engine/module";
+export declare class NQL_RuleTree {
+    private module;
+    private bucketName;
+    private query;
+    private debug;
+    private static OpByType;
+    root: NQL_Union;
+    constructor(module: AnyModule, bucketName: string, query: NQL_AnyQuery, debug?: boolean);
+    private parseUnion;
+    private parseOrder;
+    private parseKey;
+    private parseOp;
+    private parseValue;
+    private parseSubQuery;
+    /**
+     * Depth-first search on the tree:
+     * - Collapses single-child Unions
+     * - Accumulate avgTime over tree nodes, for building multi-tree
+     */
+    private simplify;
+    _addDebugId(): void;
+    describeNQL(): string;
+    describe(): string;
+    static describe(node: NQL_Node, d?: number): string;
+}
+/**
+ * Builds a NQL_CompiledQuery by splitting it into multiple parts
+ */
+export declare class NQL_Compiler {
+    static build(module: AnyModule, bucketName: string, query: NQL_AnyQuery): NQL_CompiledQuery;
+    static buildUnion(union: NQL_Union): NQL_CompiledQuery;
+}
+/**
+ * A query ready to be run by the NQL engine, which will call
+ * each NQLRunner with a different adapter
+ */
+export declare class NQL_CompiledQuery {
+    parts: Record<number, NQL_Part>;
+    execOrder: number[];
+    constructor(parts: NQL_Part[]);
+    describe(): string;
+}