nesoi 3.0.20 → 3.1.0

package/lib/elements/edge/externals/externals.schema.d.ts

@@ -6,10 +6,11 @@ import { $Dependency } from "../../../engine/dependency";
 export declare class $Externals {
     name: string;
     buckets: Record<string, $Dependency>;
+    messages: Record<string, $Dependency>;
     jobs: Record<string, $Dependency>;
     machines: Record<string, $Dependency>;
     $t: "externals";
     module: string;
-    constructor(name: string, buckets?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>);
+    constructor(name: string, buckets?: Record<string, $Dependency>, messages?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>);
     static merge(to: $Externals, from: $Externals): void;
 }

package/lib/elements/edge/externals/externals.schema.js

@@ -6,9 +6,10 @@ exports.$Externals = void 0;
  * @subcategory Edge
  */
 class $Externals {
-    constructor(name, buckets = {}, jobs = {}, machines = {}) {
+    constructor(name, buckets = {}, messages = {}, jobs = {}, machines = {}) {
         this.name = name;
         this.buckets = buckets;
+        this.messages = messages;
         this.jobs = jobs;
         this.machines = machines;
         this.$t = 'externals';
@@ -16,6 +17,7 @@ class $Externals {
     }
     static merge(to, from) {
         Object.assign(to.buckets, from.buckets);
+        Object.assign(to.messages, from.messages);
         Object.assign(to.jobs, from.jobs);
         Object.assign(to.machines, from.machines);
     }

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

@@ -66,7 +66,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             if (pagination.returnTotal) {
                 totalItems = output.length;
             }
-            if (pagination.page || pagination.perPage) {
+            if (pagination.page !== undefined || pagination.perPage !== undefined) {
                 const a = ((pagination.page || 1) - 1) * (pagination.perPage || 10);
                 const b = a + (pagination.perPage || 10);
                 output = output.slice(a, b);

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

@@ -10,7 +10,7 @@ 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 { BucketModelpathInfer, BucketModelInfer, BucketQuerypathInfer } from './model/bucket_model.infer';
 import { Overlay } from "../../../engine/util/type";
 import { $Constants } from '../constants/constants.schema';
 import { NesoiObj } from "../../../engine/data/obj";
@@ -33,14 +33,16 @@ export declare class BucketBuilder<Space extends $Space, Module extends $Module,
     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, {
+    model<Def extends BucketModelDef<Space, Module>, Obj = BucketModelInfer<Def>, Modelpath extends {} = BucketModelpathInfer<Def>, Querypath extends {} = BucketQuerypathInfer<Def>>($: Def): BucketBuilder<Space, Overlay<Module, {
         buckets: Overlay<Module["buckets"], { [K in Bucket["name"]]: Overlay<Bucket, {
             '#data': Obj & NesoiObj;
-            '#fieldpath': Fieldpath;
+            '#modelpath': Modelpath;
+            '#querypath': Querypath;
         }>; }>;
     }>, Overlay<Bucket, {
         '#data': Obj & NesoiObj;
-        '#fieldpath': Fieldpath;
+        '#modelpath': Modelpath;
+        '#querypath': Querypath;
     }>>;
     /**
      * Optional query to be appended to every read of this bucket, based on the user

package/lib/elements/entities/bucket/bucket.js

@@ -735,22 +735,13 @@ class Bucket {
         if (!this.drive) {
             throw error_1.NesoiError.Bucket.Drive.NoAdapter({ bucket: this.schema.alias });
         }
-        const fields = bucket_model_schema_1.$BucketModel.fieldsOfType(this.schema.model, 'file');
-        for (const field of fields) {
-            if (field.array) {
-                const files = tree_1.Tree.get(obj, field.path);
-                const remoteFiles = [];
-                for (const file of files) {
-                    remoteFiles.push(await this.drive.upload(file));
-                }
-                tree_1.Tree.set(obj, field.path, () => remoteFiles);
-            }
-            else {
-                const file = tree_1.Tree.get(obj, field.path);
-                const remoteFile = await this.drive.upload(file);
-                tree_1.Tree.set(obj, field.path, () => remoteFile);
-            }
-        }
+        await bucket_model_schema_1.$BucketModel.forEachField(this.schema.model, async (field) => {
+            if (field.type !== 'file')
+                return;
+            const file = tree_1.Tree.get(obj, field.path);
+            const remoteFile = await this.drive.upload(file);
+            tree_1.Tree.set(obj, field.path, () => remoteFile);
+        });
     }
 }
 exports.Bucket = Bucket;

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

@@ -28,7 +28,8 @@ export declare class $Bucket {
         many: boolean;
         optional: boolean;
     }>;
-    '#fieldpath': {};
+    '#modelpath': {};
+    '#querypath': {};
     '#defaults': Record<string, any>;
     constructor(module: string, name: string, alias: string, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, tenancy?: $BucketTenancy<any, any> | undefined, extended?: $Dependency | undefined);
 }

package/lib/elements/entities/bucket/graph/bucket_graph.infer.d.ts

@@ -1,9 +1,11 @@
 import { Overlay } from "../../../../engine/util/type";
 import { $BucketGraphLink } from './bucket_graph.schema';
-import { BucketGraphLinkBuilder, BucketGraphLinkBuilders } from './bucket_graph_link.builder';
+import { BucketGraphLinkBuilders } from './bucket_graph_link.builder';
+type Replace<T extends string> = T extends `${infer L}$${infer R}` ? `${L}${string}${Replace<R>}` : T;
 export type $BucketGraphLinksInfer<Builders extends BucketGraphLinkBuilders> = {
-    [K in keyof Builders]: Builders[K] extends BucketGraphLinkBuilder<any, any, infer Y> ? Overlay<$BucketGraphLink, {
-        '#bucket': Y;
-        '#data': Y['#data'];
-    }> : never;
+    [K in keyof Builders as Replace<K & string>]: Overlay<$BucketGraphLink, {
+        '#bucket': Builders[K]['#other'];
+        '#data': Builders[K]['#other']['#data'];
+    }>;
 };
+export {};

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

@@ -8,7 +8,7 @@ import { NQL_AnyQuery, NQL_Query } from '../query/nql.schema';
  * @category Builders
  * @subcategory Entity
  * */
-export declare class BucketGraphLinkFactory<Module extends $Module, SelfBucket extends $Bucket, Fieldpaths = NoInfer<SelfBucket['#fieldpath']>> {
+export declare class BucketGraphLinkFactory<Module extends $Module, SelfBucket extends $Bucket, Fieldpaths = NoInfer<SelfBucket['#modelpath']>> {
     private module;
     private alias?;
     private type;
@@ -28,6 +28,7 @@ export declare class BucketGraphLinkBuilder<Module extends $Module, SelfBucket e
     private query;
     private many;
     private alias?;
+    '#other': OtherBucket;
     private _optional;
     constructor(bucket: $Dependency, rel: 'aggregation' | 'composition', query: NQL_AnyQuery, many: boolean, alias?: string | undefined);
     as(alias: string): this;

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

@@ -13,5 +13,5 @@ export declare class BucketModelBuilder<Module extends $Module> {
     static build(builder: BucketModelBuilder<any>): $BucketModel;
 }
 export type BucketModelDef<Space extends $Space, Module extends $Module> = ($: BucketModelFieldFactory<Space, Module>) => {
-    id: BucketModelFieldBuilder<Module, any>;
+    id: BucketModelFieldBuilder<Module, any, any, any, any, any>;
 } & BucketModelFieldBuilders<Module>;

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

@@ -5,7 +5,7 @@ import { $Message } from "../../message/message.schema";
  * @category Elements
  * @subcategory Entity
  * */
-export declare function convertToView<Model extends $BucketModel>(model: Model, name: string, fields?: $BucketModelFields, path?: string): $BucketView;
+export declare function convertToView<Model extends $BucketModel>(model: Model, name: string, fields?: $BucketModelFields, path?: string, depth?: number): $BucketView;
 /**
  * @category Elements
  * @subcategory Entity

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

@@ -13,7 +13,7 @@ const dependency_1 = require("../../../../engine/dependency");
  * @category Elements
  * @subcategory Entity
  * */
-function convertToView(model, name, fields = model.fields, path) {
+function convertToView(model, name, fields = model.fields, path, depth = 0) {
     const view = new bucket_view_builder_1.BucketViewBuilder(name);
     const convertFields = (fields) => {
         const viewFields = {};
@@ -24,7 +24,7 @@ function convertToView(model, name, fields = model.fields, path) {
                 + field.name;
             const builder = $.model(key);
             const graph = new bucket_graph_schema_1.$BucketGraph();
-            viewFields[f] = bucket_view_field_builder_1.BucketViewFieldBuilder.build(builder, model, graph, {}, field.name);
+            viewFields[f] = bucket_view_field_builder_1.BucketViewFieldBuilder.build(builder, model, graph, {}, field.name, depth);
         }
         return viewFields;
     };
@@ -36,12 +36,12 @@ function convertToView(model, name, fields = model.fields, path) {
  * */
 function convertToMessage(module, model, name, alias, include = [], exclude = []) {
     const convertField = (field) => {
-        return new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, field.path, field.path, field.array, field.required, undefined, false, [], {
+        return new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, field.path, field.path, field.required, undefined, false, [], {
             enum: field.meta?.enum ? {
                 options: field.meta.enum.options,
                 dep: field.meta.enum.dep ? new dependency_1.$Dependency(module, 'constants', `${field.meta.enum.dep.module}::${field.meta.enum.dep.name}`) : undefined
             } : undefined
-        }, field.children ? convertFields(field.children, include, exclude) : undefined, field.or ? convertField(field.or) : undefined);
+        }, field.children ? convertFields(field.children, include, exclude) : undefined);
     };
     const convertFields = (fields, include = [], exclude = [], root = '') => {
         const msgFields = {};

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

@@ -1,13 +1,49 @@
-import { MergeUnion } from "../../../../engine/util/type";
+import { UnionToIntersection } from "../../../../engine/util/type";
 import { BucketModelDef } from './bucket_model.builder';
-import { BucketModelFieldBuilder, BucketModelFieldBuilders } from './bucket_model_field.builder';
-export type BucketModelObjInfer<Builders extends BucketModelFieldBuilders<any>> = {
-    [K in keyof Builders]: Builders[K] extends BucketModelFieldBuilder<any, any, any, infer X> ? X : BucketModelObjInfer<Builders[K] & BucketModelFieldBuilders<any>>;
+import { AnyBucketModelFieldBuilder, BucketModelFieldBuilders } from './bucket_model_field.builder';
+export type BucketModelObjInfer<Fields extends BucketModelFieldBuilders<any>, Prefix = ''> = {
+    [K in keyof Fields as Fields[K]['#optional'][1] extends true ? never : `${Prefix & string}${K & string}`]: Fields[K]['#output'];
+} & {
+    [K in keyof Fields as Fields[K]['#optional'][1] extends true ? `${Prefix & string}${K & string}` : never]?: Fields[K]['#output'];
 };
 export type BucketModelInfer<Def extends BucketModelDef<any, any>> = BucketModelObjInfer<ReturnType<Def>>;
-export type BucketFieldpathObjInfer<Builders extends BucketModelFieldBuilders<any>, Prefix extends string> = MergeUnion<{
-    [K in keyof Builders]: Builders[K] extends BucketModelFieldBuilder<any, any, any, any, infer X> ? {
-        [J in keyof X as `${Prefix}${K & string}${J & string}`]: X[J];
-    } : never;
+type BucketModelpathRawInfer<Builders extends BucketModelFieldBuilders<any>> = UnionToIntersection<{
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#modelpath'] as `${K & string}${J & string}`]: Builders[K]['#modelpath'][J];
+    };
 }[keyof Builders]>;
-export type BucketFieldpathInfer<Def extends BucketModelDef<any, any>, Prefix extends string = ''> = BucketFieldpathObjInfer<ReturnType<Def>, Prefix>;
+export type BucketModelpathObjInfer<Builders extends BucketModelFieldBuilders<any>> = UnionToIntersection<{
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#modelpath'] as `.${K & string}${J & string}`]: Builders[K]['#modelpath'][J];
+    };
+}[keyof Builders]>;
+export type BucketModelpathListInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#modelpath'] as `.$${number}${J & string}` | `.${number}${J & string}`]: Builder['#modelpath'][J];
+} & {
+    [J in keyof Builder['#modelpath'] as `.${'*'}${J & string}`]: Builder['#modelpath'][J][];
+};
+export type BucketModelpathDictInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#modelpath'] as `.$${number}${J & string}` | `.${string}${J & string}`]: Builder['#modelpath'][J];
+} & {
+    [J in keyof Builder['#modelpath'] as `.${'*'}${J & string}`]: Record<string, Builder['#modelpath'][J]>;
+};
+export type BucketModelpathUnionInfer<Builders extends AnyBucketModelFieldBuilder[]> = Builders[0]['#modelpath'] | Builders[1]['#modelpath'];
+export type BucketModelpathInfer<Def extends BucketModelDef<any, any>> = BucketModelpathRawInfer<ReturnType<Def>>;
+type BucketQuerypathRawInfer<Builders extends BucketModelFieldBuilders<any>> = {
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#querypath'] as `${K & string}${J & string}`]: Builders[K]['#querypath'][J];
+    };
+}[keyof Builders];
+export type BucketQuerypathObjInfer<Builders extends BucketModelFieldBuilders<any>> = UnionToIntersection<{
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#querypath'] as `.${K & string}${J & string}`]: Builders[K]['#querypath'][J];
+    };
+}[keyof Builders]>;
+export type BucketQuerypathListInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#querypath'] as `.${number | '#' | '*'}${J & string}`]: Builder['#querypath'][J];
+};
+export type BucketQuerypathDictInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#querypath'] as `.${string | '#' | '*'}${J & string}`]: Builder['#querypath'][J];
+};
+export type BucketQuerypathInfer<Def extends BucketModelDef<any, any>> = UnionToIntersection<BucketQuerypathRawInfer<ReturnType<Def>>>;
+export {};

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

@@ -1,5 +1,5 @@
 import { $Dependency } from "../../../../engine/dependency";
-export type $BucketModelFieldType = 'boolean' | 'date' | 'datetime' | 'duration' | 'decimal' | 'enum' | 'file' | 'float' | 'int' | 'string' | 'obj' | 'unknown' | 'dict';
+export type $BucketModelFieldType = 'boolean' | 'date' | 'datetime' | 'duration' | 'decimal' | 'enum' | 'file' | 'float' | 'int' | 'string' | 'obj' | 'unknown' | 'dict' | 'list' | 'union';
 export type $BucketModelFieldCrypto = {
     algorithm: string;
     key: string;
@@ -13,7 +13,6 @@ export declare class $BucketModelField {
     path: string;
     type: $BucketModelFieldType;
     alias: string;
-    array: boolean;
     required: boolean;
     meta?: {
         enum?: {
@@ -31,10 +30,9 @@ export declare class $BucketModelField {
     } | undefined;
     defaultValue?: any | undefined;
     children?: $BucketModelFields | undefined;
-    or?: $BucketModelField | undefined;
     crypto?: $BucketModelFieldCrypto | undefined;
     $t: string;
-    constructor(name: string, path: string, type: $BucketModelFieldType, alias: string, array: boolean, required: boolean, meta?: {
+    constructor(name: string, path: string, type: $BucketModelFieldType, alias: string, required: boolean, meta?: {
         enum?: {
             options: string | string[];
             dep?: $Dependency;
@@ -47,7 +45,7 @@ export declare class $BucketModelField {
             extnames?: string[];
             maxsize?: number;
         };
-    } | undefined, defaultValue?: any | undefined, children?: $BucketModelFields | undefined, or?: $BucketModelField | undefined, crypto?: $BucketModelFieldCrypto | undefined);
+    } | undefined, defaultValue?: any | undefined, children?: $BucketModelFields | undefined, crypto?: $BucketModelFieldCrypto | undefined);
 }
 export type $BucketModelFields = {
     [x: string]: $BucketModelField;
@@ -67,6 +65,7 @@ export declare class $BucketModel {
     constructor(fields: $BucketModelFields & {
         id: $BucketModelField;
     }, defaults?: Record<string, any>, hasFileField?: boolean, hasEncryptedField?: boolean);
-    static get(model: $BucketModel, fieldpath: string): $BucketModelField | undefined;
+    static getField(model: $BucketModel, modelpath: string): $BucketModelField[];
     static fieldsOfType(model: $BucketModel, type: $BucketModelFieldType): $BucketModelField[];
+    static forEachField(template: $BucketModel, predicate: (field: $BucketModelField, unionKey?: number) => Promise<void>): Promise<void>;
 }

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

@@ -6,17 +6,15 @@ exports.$BucketModel = exports.$BucketModelField = void 0;
  * @subcategory Entity
  * */
 class $BucketModelField {
-    constructor(name, path, type, alias, array, required, meta, defaultValue, children, or, crypto) {
+    constructor(name, path, type, alias, required, meta, defaultValue, children, crypto) {
         this.name = name;
         this.path = path;
         this.type = type;
         this.alias = alias;
-        this.array = array;
         this.required = required;
         this.meta = meta;
         this.defaultValue = defaultValue;
         this.children = children;
-        this.or = or;
         this.crypto = crypto;
         this.$t = 'bucket.model.field';
     }
@@ -34,26 +32,54 @@ class $BucketModel {
         this.hasEncryptedField = hasEncryptedField;
         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;
+    static getField(model, modelpath) {
+        const paths = modelpath.split('.');
+        const results = [];
+        let poll = [{ i: 0, field: { children: model.fields } }];
+        while (poll.length) {
+            const next = [];
+            for (const item of poll) {
+                const path = paths[item.i];
+                if (!path) {
+                    results.push(item.field);
+                    continue;
+                }
+                const field = item.field;
+                // If the field is a union, add all of it's children with the same path index
+                if (field.type === 'union') {
+                    next.push(...Object.values(field.children).map(field => ({
+                        i: item.i,
+                        field
+                    })));
+                    continue;
+                }
+                // If it's a list or dict, or an object 
+                if (field.type === 'list' || field.type === 'dict') {
+                    // If not, iterate
+                    next.push({
+                        i: item.i + 1,
+                        field: field.children['#']
+                    });
+                    continue;
+                }
+                // If it's an object, walk it's children
+                if (field.type === 'obj' && path === '*') {
+                    next.push(...Object.values(field.children).map(field => ({
+                        i: item.i + 1,
+                        field
+                    })));
+                }
+                const child = field.children[path];
+                if (child) {
+                    next.push({
+                        i: item.i + 1,
+                        field: child
+                    });
+                }
             }
-            ref = ref.children;
+            poll = next;
         }
-        return ref;
+        return results;
     }
     static fieldsOfType(model, type) {
         const fields = [];
@@ -72,5 +98,22 @@ class $BucketModel {
         }
         return fields;
     }
+    static async forEachField(template, predicate) {
+        let poll = Object.values(template.fields).map(field => ({ field }));
+        while (poll.length) {
+            const next = [];
+            for (const obj of poll) {
+                await predicate(obj.field, obj.unionKey);
+                if (obj.field.children) {
+                    next.push(...Object.values(obj.field.children)
+                        .map((field, i) => ({
+                        field,
+                        unionKey: obj.field.type === 'union' ? i : undefined
+                    })));
+                }
+            }
+            poll = next;
+        }
+    }
 }
 exports.$BucketModel = $BucketModel;