nesoi 3.0.21 → 3.1.1

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

@@ -1,4 +1,4 @@
-import { $BucketViewField, $BucketViewFieldFn, $BucketViewFieldValue, $BucketViewFields, $BucketViews } from './bucket_view.schema';
+import { $BucketViewField, $BucketViewFieldFn, $BucketViewFieldMeta, $BucketViewFields, $BucketViews } from './bucket_view.schema';
 import { $Module, $Space, ViewObj } from "../../../../schema";
 import { $BucketModel } from '../model/bucket_model.schema';
 import { $BucketGraph } from '../graph/bucket_graph.schema';
@@ -8,8 +8,8 @@ import { $BucketViewFieldBuilderInfer } from '../bucket.infer';
 import { TrxNode } from "../../../../engine/transaction/trx_node";
 import { NesoiFile } from "../../../../engine/data/file";
 type DriveFieldpath<Bucket extends $Bucket> = {
-    [K in keyof Bucket['#fieldpath']]: NonNullable<Bucket['#fieldpath'][K]> extends NesoiFile ? K : never;
-}[keyof Bucket['#fieldpath']];
+    [K in keyof Bucket['#modelpath']]: NonNullable<Bucket['#modelpath'][K]> extends NesoiFile ? K : never;
+}[keyof Bucket['#modelpath']];
 type GraphLinkBucket<Bucket extends $Bucket, L extends keyof Bucket['graph']['links']> = Bucket['graph']['links'][L]['#bucket'];
 type ComputedData<Fn extends $BucketViewFieldFn<any, any>, R = ReturnType<Fn>> = R extends Promise<infer X> ? X : R;
 /**
@@ -19,10 +19,12 @@ type ComputedData<Fn extends $BucketViewFieldFn<any, any>, R = ReturnType<Fn>> =
 export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
     private _view;
     protected scope: $BucketViewField['scope'];
-    protected type: $BucketViewField['type'];
-    protected value: $BucketViewField['value'];
+    protected value: $BucketViewField['meta'];
     constructor(_view: BucketViewBuilder<any, any, any>);
-    model<K extends keyof Bucket['#fieldpath'], Extra extends BucketViewFieldBuilderTree>(key: K, extra?: Extra): BucketViewFieldBuilder<Bucket["#fieldpath"][K], "model", never>;
+    raw(): {
+        [K in keyof Bucket['#data']]: BucketViewFieldBuilder<Bucket['#data'][K], 'model'>;
+    };
+    model<K extends keyof Bucket['#modelpath'], SubModel extends BucketViewFieldBuilderTree>(path: K, submodel?: SubModel): BucketViewFieldBuilder<Bucket["#modelpath"][K], "model", never>;
     computed<Fn extends $BucketViewFieldFn<TrxNode<Space, Module, Space['authnUsers']>, Bucket>>(fn: Fn): BucketViewFieldBuilder<ComputedData<Fn, ReturnType<Fn>>, "computed", never>;
     graph<L extends keyof Bucket['graph']['links'], LinkBucket extends GraphLinkBucket<Bucket, L>, V extends (keyof LinkBucket['views']) | undefined>(link: L, view?: V): BucketViewFieldBuilder<undefined extends V ? LinkBucket["#data"] : ViewObj<LinkBucket, NonNullable<V>>, "graph", `${LinkBucket["name"]}.${V & string}`>;
     drive<F extends DriveFieldpath<Bucket>>(path: F): BucketViewFieldBuilder<string, "drive", never>;
@@ -36,12 +38,14 @@ export declare class BucketViewFieldFactory<Space extends $Space, Module extends
  * */
 export declare class BucketViewFieldBuilder<Data, Scope extends $BucketViewField['scope'], GraphLink extends string = never> {
     protected scope: $BucketViewField['scope'];
-    protected value: $BucketViewFieldValue;
-    protected extra?: BucketViewFieldBuilderTree | undefined;
-    protected type: $BucketViewField['type'];
-    constructor(scope: $BucketViewField['scope'], value: $BucketViewFieldValue, extra?: BucketViewFieldBuilderTree | undefined);
-    static build(builder: BucketViewFieldBuilder<any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string): $BucketViewField;
-    static buildFields(fields: BucketViewFieldBuilderTree, model: $BucketModel, graph: $BucketGraph, views: $BucketViews): $BucketViewFields;
+    protected meta: $BucketViewFieldMeta;
+    protected submodel?: BucketViewFieldBuilderTree | undefined;
+    $b: "view.field";
+    protected _chain?: BucketViewFieldBuilder<any, any, any>;
+    constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, submodel?: BucketViewFieldBuilderTree | undefined);
+    chain<Fn extends $BucketViewFieldFn<any, any>>(fn: Fn): void;
+    static build(builder: BucketViewFieldBuilder<any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string, n_indexes: number): $BucketViewField;
+    static buildFields(fields: BucketViewFieldBuilderTree, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number): $BucketViewFields;
 }
 export type BucketViewFieldBuilderTree = {
     [x: string]: BucketViewFieldBuilder<any, any, any> | BucketViewFieldBuilderTree;

package/lib/elements/entities/bucket/view/bucket_view_field.builder.js

@@ -4,7 +4,6 @@ exports.BucketViewFieldBuilder = exports.BucketViewFieldFactory = void 0;
 const error_1 = require("../../../../engine/data/error");
 const bucket_view_schema_1 = require("./bucket_view.schema");
 const bucket_model_schema_1 = require("../model/bucket_model.schema");
-const bucket_model_convert_1 = require("../model/bucket_model.convert");
 /*
     Factory
 */
@@ -16,12 +15,17 @@ class BucketViewFieldFactory {
     constructor(_view) {
         this._view = _view;
     }
-    model(key, extra) {
+    raw() {
+        return {
+            __raw: {}
+        };
+    }
+    model(path, submodel) {
         return new BucketViewFieldBuilder('model', {
             model: {
-                key: key.replace(/\.__dict/g, '')
+                path: path
             }
-        }, extra);
+        }, submodel);
     }
     computed(fn) {
         return new BucketViewFieldBuilder('computed', {
@@ -59,7 +63,7 @@ class BucketViewFieldFactory {
         };
     }
     static group(name, children) {
-        return new bucket_view_schema_1.$BucketViewField(name, 'group', 'obj', name, false, true, { group: {} }, children);
+        return new bucket_view_schema_1.$BucketViewField(name, 'group', name, {}, children);
     }
 }
 exports.BucketViewFieldFactory = BucketViewFieldFactory;
@@ -71,59 +75,67 @@ exports.BucketViewFieldFactory = BucketViewFieldFactory;
  * @subcategory Entity
  * */
 class BucketViewFieldBuilder {
-    constructor(scope, value, extra) {
+    constructor(scope, meta, submodel) {
         this.scope = scope;
-        this.value = value;
-        this.extra = extra;
-        this.type = 'unknown';
-        this.type = 'unknown';
+        this.meta = meta;
+        this.submodel = submodel;
+        this.$b = 'view.field';
+    }
+    chain(fn) {
+        this._chain = new BucketViewFieldBuilder('computed', {
+            computed: {
+                fn: fn
+            }
+        });
     }
     // Build
-    static build(builder, model, graph, views, name) {
-        let type = 'unknown';
-        let array = 'unknown';
-        let required = true;
+    static build(builder, model, graph, views, name, n_indexes) {
         let children = undefined;
+        const chain = builder._chain;
         if (builder.scope === 'model') {
-            const modelField = bucket_model_schema_1.$BucketModel.get(model, builder.value.model.key);
-            if (!modelField) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.value.model.key);
+            const path = builder.meta.model.path;
+            const spread_n = path.match(/\.\*(\.|$)/g)?.length || 0;
+            if (spread_n === 0 && builder.submodel) {
+                throw new Error('Submodels can only be specified for modelpaths with at least one \'*\'');
             }
-            type = modelField.type;
-            array = builder.value.model.key.endsWith('.#') || modelField.array;
-            required = modelField.required;
-            if (modelField.meta?.enum) {
-                builder.value.model.enumOptions = modelField.meta.enum.options;
+            // Check if indexes are valid
+            // $0, $1, $2.. should be up to n_indexes
+            const path_indexes = path.match(/\.\$\d+(\.|$)/g)?.map(d => parseInt(d.slice(2))) || [];
+            if (Math.max(...path_indexes) >= n_indexes) {
+                if (n_indexes === 0) {
+                    throw new Error('Index $ can only be specified inside a submodel');
+                }
+                throw new Error(`Maximum index allowed: $${n_indexes - 1}`);
             }
-            if (modelField.children) {
-                const path = builder.value.model.key + ((modelField.array || modelField.type === 'dict') ? '.#' : '');
-                const fromModel = (0, bucket_model_convert_1.convertToView)(model, '', modelField.children, path).fields;
-                children = Object.assign({}, fromModel);
+            // Retrieve one or more BucketModelFields referenced by a modelpath.
+            // (It's only more than one when using unions)
+            // The field itself is not used, but serves to validate that the modelpath exists.
+            const modelFields = bucket_model_schema_1.$BucketModel.getField(model, path);
+            if (!modelFields.length) {
+                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.meta.model.path);
             }
-            if (builder.extra) {
-                const extra = this.buildFields(builder.extra, model, graph, views);
-                children = Object.assign({}, children, extra);
+            // If there's a submodel, add it as children
+            if (builder.submodel) {
+                const overrides = this.buildFields(builder.submodel, model, graph, views, n_indexes + spread_n);
+                children = Object.assign({}, children, overrides);
             }
         }
         else if (builder.scope === 'graph') {
-            const graphLink = builder.value.graph.link ? graph.links[builder.value.graph.link] : undefined;
+            const graphLink = builder.meta.graph.link ? graph.links[builder.meta.graph.link] : undefined;
             if (!graphLink) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.value.graph.link || '');
+                throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.meta.graph.link || '');
             }
-            array = graphLink.many;
         }
         else if (builder.scope === 'view') {
-            const view = builder.value.view?.view ? views[builder.value.view?.view] : undefined;
+            const view = builder.meta.view?.view ? views[builder.meta.view?.view] : undefined;
             if (!view) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownViewName(builder.value.view?.view || '');
+                throw error_1.NesoiError.Builder.Bucket.UnknownViewName(builder.meta.view?.view || '');
             }
-            type = 'obj';
-            array = false;
             children = view.fields;
         }
-        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, type, name, array, required, builder.value, children);
+        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, children, chain);
     }
-    static buildFields(fields, model, graph, views) {
+    static buildFields(fields, model, graph, views, n_indexes = 0) {
         const schema = {};
         // Extended fields inherit from other views
         if ('__ext' in fields) {
@@ -134,15 +146,18 @@ class BucketViewFieldBuilder {
             if (f === '__ext') {
                 continue;
             }
+            if (f === '__raw') {
+                schema['__raw'] = {};
+            }
             const field = fields[f];
             // Normal fields are built here
             if (field instanceof BucketViewFieldBuilder) {
-                schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f);
+                schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f, n_indexes);
             }
             // Builders are allowed to implicitly declare nested fields.
             // The code below transforms these groups into fields of the scope 'group'.
             else {
-                const children = BucketViewFieldBuilder.buildFields(field, model, graph, views);
+                const children = BucketViewFieldBuilder.buildFields(field, model, graph, views, n_indexes);
                 schema[f] = BucketViewFieldFactory.group(f, children);
             }
         }

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

@@ -16,17 +16,7 @@ export declare class MessageBuilder<Space extends $Space, Module extends $Module
     private _template;
     constructor(module: string, name: string);
     as(alias: string): this;
-    template<Def extends MessageTemplateDef<Space, Module, Message['name']>>($: Def): MessageBuilder<Space, Module, $MessageInfer<Message["name"], Def, ReturnType<Def>, import("./message.infer").$MessageInputInfer<ReturnType<Def>, ReturnType<Def> extends infer T ? { [K in keyof T]: ReturnType<Def>[K] extends import("./template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
-        path: `${K & string}${keyof I & string}`;
-        data: I[keyof I];
-        opt: Opt[0];
-        nul: Nul[0];
-    } : never; } : never>, import("./message.infer").$MessageOutputInfer<ReturnType<Def>, ReturnType<Def> extends infer T_1 ? { [K_1 in keyof T_1]: ReturnType<Def>[K_1] extends import("./template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
-        path: `${K_1 & string}${keyof O & string}`;
-        data: O[keyof O];
-        opt: Opt_1[1];
-        nul: Nul_1[1];
-    } : never; } : never>>>;
+    template<Def extends MessageTemplateDef<Space, Module, Message['name']>>($: Def): MessageBuilder<Space, Module, $MessageInfer<Message["name"], Def, ReturnType<Def>, import("./message.infer").$MessageInputInfer<ReturnType<Def>>, import("./message.infer").$MessageOutputInfer<ReturnType<Def>>>>;
     static build(node: MessageBuilderNode, tree: ModuleTree, module: $Module): $Message;
     static buildInlines(node: ResolvedBuilderNode, tree: ModuleTree, module: $Module): Record<string, $Message>;
 }

package/lib/elements/entities/message/message.infer.d.ts

@@ -2,39 +2,15 @@ import { MessageTemplateFieldBuilder, MessageTemplateFieldBuilders } from './tem
 import { MessageTemplateDef } from './template/message_template.builder';
 import { $Module } from "../../../schema";
 import { $Message } from './message.schema';
-export type $MessageInputInfer<Builder, Fields extends Record<string, {
-    path: any;
-    data: any;
-    opt: any;
-    nul: any;
-}> = {
-    [K in keyof Builder]: Builder[K] extends MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt, infer Nul> ? {
-        path: `${K & string}${keyof I & string}`;
-        data: I[keyof I];
-        opt: Opt[0];
-        nul: Nul[0];
-    } : never;
-}> = {
-    [K in keyof Fields as Fields[K]['opt'] extends never ? Fields[K]['path'] : never]: Fields[K]['data'] | Fields[K]['nul'];
+export type $MessageInputInfer<Fields extends MessageTemplateFieldBuilders> = {
+    [K in keyof Fields as Fields[K]['#optional'][0] extends true ? never : `${K & string}${Fields[K]['#input_suffix']}`]: Fields[K]['#input'];
 } & {
-    [K in keyof Fields as Fields[K]['opt'] extends never ? never : Fields[K]['path']]?: Fields[K]['data'] | Fields[K]['nul'];
+    [K in keyof Fields as Fields[K]['#optional'][0] extends true ? `${K & string}${Fields[K]['#input_suffix']}` : never]?: Fields[K]['#input'];
 };
-export type $MessageOutputInfer<Builder, Fields extends Record<string, {
-    path: any;
-    data: any;
-    opt: any;
-    nul: any;
-}> = {
-    [K in keyof Builder]: Builder[K] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt, infer Nul> ? {
-        path: `${K & string}${keyof O & string}`;
-        data: O[keyof O];
-        opt: Opt[1];
-        nul: Nul[1];
-    } : never;
-}> = {
-    [K in keyof Fields as Fields[K]['opt'] extends never ? Fields[K]['path'] : never]: Fields[K]['data'] | Fields[K]['nul'];
+export type $MessageOutputInfer<Fields extends MessageTemplateFieldBuilders> = {
+    [K in keyof Fields as Fields[K]['#optional'][1] extends true ? never : K]: Fields[K]['#output'];
 } & {
-    [K in keyof Fields as Fields[K]['opt'] extends never ? never : Fields[K]['path']]?: Fields[K]['data'] | Fields[K]['nul'];
+    [K in keyof Fields as Fields[K]['#optional'][1] extends true ? K : never]?: Fields[K]['#output'];
 };
 export interface $MessageInfer<Name extends string, Def extends MessageTemplateDef<any, any, any>, Builders extends MessageTemplateFieldBuilders = ReturnType<Def>, Raw = $MessageInputInfer<Builders>, Parsed = $MessageOutputInfer<Builders>> extends $Message {
     name: Name;

package/lib/elements/entities/message/message.schema.js

@@ -25,7 +25,7 @@ class $Message {
                 if (field.type === 'id') {
                     str += `(${field.meta.id.bucket.refName})`;
                 }
-                if (field.type === 'enum') {
+                else if (field.type === 'enum') {
                     const options = field.meta.enum.options;
                     if (typeof options === 'object') {
                         str += `(${Object.keys(options)})`;
@@ -34,7 +34,7 @@ class $Message {
                         str += `(${options})`;
                     }
                 }
-                if (field.array) {
+                else if (field.type === 'list') {
                     str += '[]';
                 }
                 str += '\n';

package/lib/elements/entities/message/template/message_template.builder.js

@@ -17,7 +17,7 @@ class MessageTemplateBuilder {
     }
     /// Build
     static build(builder, tree, module) {
-        const fields = message_template_field_builder_1.MessageTemplateFieldBuilder.buildChildren(builder._fields, tree, module);
+        const fields = message_template_field_builder_1.MessageTemplateFieldBuilder.buildMany(builder._fields, tree, module);
         return new message_template_schema_1.$MessageTemplate(fields);
     }
 }

package/lib/elements/entities/message/template/message_template.schema.d.ts

@@ -47,23 +47,16 @@ export declare class $MessageTemplateField {
     name: string;
     /** A human name for the field */
     alias: string;
-    /** A human name for the field union, assigned before the type.
-     * This is only relevant when using .obj.or, to allow for different
-     * aliases for the union and the root object */
-    preAlias: string;
     /** The absolute path for reading the field value on the raw object */
-    path_raw: string;
+    pathRaw: string;
     /** The absolute path for writing the field value on the parsed object */
-    path_parsed: string;
-    array: boolean;
+    pathParsed: string;
     required: boolean;
     defaultValue: any;
     nullable: boolean;
     rules: $MessageTemplateRule[];
-    arrayRules: $MessageTemplateRule[];
     meta: $MessageTemplateFieldMeta;
     children?: $MessageTemplateFields | undefined;
-    or?: $MessageTemplateField | undefined;
     '#raw': unknown;
     '#parsed': unknown;
     $t: string;
@@ -77,14 +70,15 @@ export declare class $MessageTemplateField {
     name: string, 
     /** A human name for the field */
     alias: string, 
-    /** A human name for the field union, assigned before the type.
-     * This is only relevant when using .obj.or, to allow for different
-     * aliases for the union and the root object */
-    preAlias: string, 
     /** The absolute path for reading the field value on the raw object */
-    path_raw: string, 
+    pathRaw: string, 
     /** The absolute path for writing the field value on the parsed object */
-    path_parsed: string, array: boolean, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule[], arrayRules: $MessageTemplateRule[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined, or?: $MessageTemplateField | undefined);
+    pathParsed: string, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined);
+    /**
+     * Warning: this does not clone the field's children or union.
+     * @returns
+     */
+    static clone(schema: $MessageTemplateField): $MessageTemplateField;
 }
 export type $MessageTemplateFields = {
     [x: string]: $MessageTemplateField;
@@ -98,4 +92,5 @@ export declare class $MessageTemplate {
     $t: string;
     constructor(fields?: $MessageTemplateFields);
     static fieldsOfType(template: $MessageTemplate, type: $MessageTemplateFieldType): $MessageTemplateField[];
+    static forEachField(template: $MessageTemplate, predicate: (field: $MessageTemplateField, path: string) => void): void;
 }

package/lib/elements/entities/message/template/message_template.schema.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$MessageTemplate = exports.$MessageTemplateField = void 0;
+const deep_1 = require("../../../../engine/util/deep");
 /**
  * @category Schemas
  * @subcategory Entity
@@ -16,31 +17,30 @@ class $MessageTemplateField {
     name, 
     /** A human name for the field */
     alias, 
-    /** A human name for the field union, assigned before the type.
-     * This is only relevant when using .obj.or, to allow for different
-     * aliases for the union and the root object */
-    preAlias, 
     /** The absolute path for reading the field value on the raw object */
-    path_raw, 
+    pathRaw, 
     /** The absolute path for writing the field value on the parsed object */
-    path_parsed, array, required, defaultValue, nullable, rules, arrayRules, meta, children, or) {
+    pathParsed, required, defaultValue, nullable, rules, meta, children) {
         this.type = type;
         this.name = name;
         this.alias = alias;
-        this.preAlias = preAlias;
-        this.path_raw = path_raw;
-        this.path_parsed = path_parsed;
-        this.array = array;
+        this.pathRaw = pathRaw;
+        this.pathParsed = pathParsed;
         this.required = required;
         this.defaultValue = defaultValue;
         this.nullable = nullable;
         this.rules = rules;
-        this.arrayRules = arrayRules;
         this.meta = meta;
         this.children = children;
-        this.or = or;
         this.$t = 'message.template.field';
     }
+    /**
+     * Warning: this does not clone the field's children or union.
+     * @returns
+     */
+    static clone(schema) {
+        return new $MessageTemplateField(schema.type, schema.name, schema.alias, schema.pathRaw, schema.pathParsed, schema.required, schema.defaultValue, schema.nullable, [...schema.rules], deep_1.Deep.copy(schema.meta), undefined);
+    }
 }
 exports.$MessageTemplateField = $MessageTemplateField;
 /**
@@ -69,5 +69,22 @@ class $MessageTemplate {
         }
         return fields;
     }
+    static forEachField(template, predicate) {
+        let poll = Object.entries(template.fields).map(([path, field]) => ({ path, field }));
+        while (poll.length) {
+            const next = [];
+            for (const obj of poll) {
+                predicate(obj.field, obj.path);
+                if (obj.field.children) {
+                    next.push(...Object.values(obj.field.children)
+                        .map((field, i) => ({
+                        field,
+                        path: obj.path + '.' + (obj.field.type === 'union' ? i : field.name)
+                    })));
+                }
+            }
+            poll = next;
+        }
+    }
 }
 exports.$MessageTemplate = $MessageTemplate;