nesoi 3.0.0 → 3.0.3

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

@@ -17,7 +17,7 @@ class BucketViewFieldFactory {
             model: {
                 key: key
             }
-        }, key, extra);
+        }, extra);
     }
     computed(fn) {
         return new BucketViewFieldBuilder('computed', {
@@ -32,14 +32,21 @@ class BucketViewFieldFactory {
                 link: link,
                 view: view
             }
-        }, link);
+        });
+    }
+    drive(path) {
+        return new BucketViewFieldBuilder('drive', {
+            drive: {
+                path: path,
+            }
+        });
     }
     view(view) {
         return new BucketViewFieldBuilder('view', {
             view: {
                 view: view
             }
-        }, view);
+        });
     }
     extend(view, fields) {
         return {
@@ -56,10 +63,9 @@ exports.BucketViewFieldFactory = BucketViewFieldFactory;
     Builder
 */
 class BucketViewFieldBuilder {
-    constructor(scope, value, refKey, extra) {
+    constructor(scope, value, extra) {
         this.scope = scope;
         this.value = value;
-        this.refKey = refKey;
         this.extra = extra;
         this.type = 'unknown';
         this.type = 'unknown';
@@ -71,18 +77,18 @@ class BucketViewFieldBuilder {
         let required = true;
         let children = undefined;
         if (builder.scope === 'model') {
-            const modelField = bucket_model_schema_1.$BucketModel.get(model, builder.refKey);
+            const modelField = bucket_model_schema_1.$BucketModel.get(model, builder.value.model.key);
             if (!modelField) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.refKey);
+                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.value.model.key);
             }
             type = modelField.type;
-            array = builder.refKey?.includes('.*') || modelField.array;
+            array = builder.value.model.key.includes('.#') || modelField.array;
             required = modelField.required;
-            if (modelField._enum) {
-                builder.value.model.enumOptions = modelField._enum.options;
+            if (modelField.meta?.enum) {
+                builder.value.model.enumOptions = modelField.meta.enum.options;
             }
             if (modelField.children) {
-                const path = builder.refKey + ((modelField.array || modelField.type === 'dict') ? '.*' : '');
+                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);
             }
@@ -92,16 +98,16 @@ class BucketViewFieldBuilder {
             }
         }
         else if (builder.scope === 'graph') {
-            const graphLink = builder.refKey ? graph.links[builder.refKey] : undefined;
+            const graphLink = builder.value.graph.link ? graph.links[builder.value.graph.link] : undefined;
             if (!graphLink) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.refKey || '');
+                throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.value.graph.link || '');
             }
             array = graphLink.many;
         }
         else if (builder.scope === 'view') {
-            const view = builder.refKey ? views[builder.refKey] : undefined;
+            const view = builder.value.view?.view ? views[builder.value.view?.view] : undefined;
             if (!view) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownViewName(builder.refKey || '');
+                throw error_1.NesoiError.Builder.Bucket.UnknownViewName(builder.value.view?.view || '');
             }
             type = 'obj';
             array = false;

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

@@ -36,7 +36,7 @@ export declare class $Constants {
 type CompatibleMessageKey<Data, Subs extends string> = {
     [K in keyof Data]: Data[K] extends Subs ? K : never;
 }[keyof Data];
-type ParseMessageEnumpath<Message extends $Message, Path extends string, Subs extends string> = Path extends `${infer X}.*` ? `${X}.{${CompatibleMessageKey<Message['#parsed'], Subs> & string}}` : Path;
+type ParseMessageEnumpath<Message extends $Message, Path extends string, Subs extends string> = Path extends `${infer X}.#` ? `${X}.{${CompatibleMessageKey<Message['#parsed'], Subs> & string}}` : Path;
 export type MessageEnumpath<Module extends $Module, Message extends $Message, Modules extends Record<string, $Module>> = MergeUnion<{
     [M in keyof Modules]: {
         [K in keyof Modules[M]['constants']['#enumpath'] as M extends Module['name'] ? ParseMessageEnumpath<Message, K & string, Modules[M]['constants']['#enumpath'][K]['_subs']> : `${M & string}::${ParseMessageEnumpath<Message, K & string, Modules[M]['constants']['#enumpath'][K]['_subs']>}`]: Modules[M]['constants']['#enumpath'][K]['_enum'];

package/lib/elements/entities/drive/drive_adapter.d.ts

@@ -0,0 +1,36 @@
+import { NesoiFile } from "../../../engine/data/file";
+export type DriveAdapterConfig = {
+    hashAlgorithm?: 'sha1' | 'md5' | 'sha256';
+    maxsize?: number;
+};
+export declare abstract class DriveAdapter {
+    dirpath: string;
+    config: DriveAdapterConfig;
+    constructor(dirpath: string, config?: DriveAdapterConfig);
+    /**
+     * Return a public reference to the file as a string, which
+     *  can be used outside the application to reach it.
+     *
+     * @returns A `string` which publicly refers to the file
+     */
+    abstract public(remoteFile: NesoiFile[]): Promise<string[]>;
+    /**
+     * Read one file from the Drive, given a NesoiFile specifier.
+     *
+     * @returns The file contents as a Buffer
+     */
+    abstract read(remoteFile: NesoiFile): Promise<Buffer>;
+    /**
+     * Create a new file on the Drive, from the contents.
+     *
+     * @returns A new `NesoiFile` which refers to the Drive
+     */
+    abstract new(filepath: string, data: string | NodeJS.ArrayBufferView): Promise<NesoiFile>;
+    /**
+     * Copy a local file to the Drive
+     * - Fails if a file with the same name exists on the target dirpath of the Drive
+     *
+     * @returns A new `NesoiFile` which refers to the Drive
+     */
+    abstract copy(localFile: NesoiFile, dirpath: string, newFilename?: string): Promise<NesoiFile>;
+}

package/lib/elements/entities/drive/drive_adapter.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveAdapter = void 0;
+class DriveAdapter {
+    constructor(dirpath, config = {}) {
+        this.dirpath = dirpath;
+        this.config = config;
+    }
+}
+exports.DriveAdapter = DriveAdapter;

package/lib/elements/entities/drive/local.drive_adapter.d.ts

@@ -0,0 +1,8 @@
+import { NesoiFile } from "../../../engine/data/file";
+import { DriveAdapter } from './drive_adapter';
+export declare class LocalDriveAdapter extends DriveAdapter {
+    public(remoteFiles: NesoiFile[]): Promise<string[]>;
+    read(remoteFile: NesoiFile): Promise<Buffer>;
+    new(filepath: string, data: string | NodeJS.ArrayBufferView): Promise<NesoiFile>;
+    copy(localFile: NesoiFile, dirpath: string): Promise<NesoiFile>;
+}

package/lib/elements/entities/drive/local.drive_adapter.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalDriveAdapter = void 0;
+const file_1 = require("../../../engine/data/file");
+const drive_adapter_1 = require("./drive_adapter");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class LocalDriveAdapter extends drive_adapter_1.DriveAdapter {
+    public(remoteFiles) {
+        return Promise.resolve(remoteFiles.map(file => path_1.default.join(process.cwd(), file.filepath)));
+    }
+    read(remoteFile) {
+        return Promise.resolve(fs_1.default.readFileSync(remoteFile.filepath));
+    }
+    async new(filepath, data) {
+        fs_1.default.writeFileSync(filepath, data);
+        return new file_1.NesoiFile(filepath);
+    }
+    async copy(localFile, dirpath) {
+        const remoteFilepath = path_1.default.join(dirpath, localFile.newFilename);
+        fs_1.default.copyFileSync(localFile.filepath, remoteFilepath);
+        return new file_1.NesoiFile(remoteFilepath, { originalFilename: localFile.originalFilename });
+    }
+}
+exports.LocalDriveAdapter = LocalDriveAdapter;

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

@@ -12,4 +12,5 @@ export declare class $Message {
         $: unknown;
     };
     constructor(module: string, name: string, alias: string, template: $MessageTemplate);
+    static describe(schema: $Message): string;
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$Message = void 0;
+const string_1 = require("../../../engine/util/string");
 class $Message {
     constructor(module, name, alias, template) {
         this.module = module;
@@ -9,5 +10,37 @@ class $Message {
         this.template = template;
         this.$t = 'message';
     }
+    static describe(schema) {
+        let str = '';
+        str += `◆ ${schema.module}::message:${(0, string_1.colored)(schema.name, 'lightblue')}\n`;
+        str += `  "${schema.alias}"\n\n`;
+        const fields = (_fields, d = 0) => {
+            for (const key in _fields) {
+                const field = _fields[key];
+                str += `${'  '.repeat(d)}- ${(0, string_1.colored)(key, 'green')}${field.required ? '' : '?'}: ${field.type}`;
+                if (field.type === 'id') {
+                    str += `(${field.meta.id.bucket.refName})`;
+                }
+                if (field.type === 'enum') {
+                    const options = field.meta.enum.options;
+                    if (typeof options === 'object') {
+                        str += `(${Object.keys(options)})`;
+                    }
+                    else {
+                        str += `(${options})`;
+                    }
+                }
+                if (field.array) {
+                    str += '[]';
+                }
+                str += '\n';
+                if (field.children) {
+                    fields(field.children, d + 1);
+                }
+            }
+        };
+        fields(schema.template.fields);
+        return str;
+    }
 }
 exports.$Message = $Message;

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

@@ -8,5 +8,9 @@ export declare class MessageParser<$ extends $Message> {
     static parseWithTrxModule(trx: AnyTrxNode, raw: RawMessageInput<any, any>, sigKey?: string): Promise<any>;
     parse(trx: AnyTrxNode, raw: $['#raw'], sigKey?: string): Promise<Message<$>>;
     private sanitize;
-    private isEmpty;
+    /**
+     * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
+     */
+    static isEmpty(value: any): boolean;
 }
+export type AnyMessageParser = MessageParser<$Message>;

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

@@ -45,47 +45,63 @@ class MessageParser {
             // 1. Sanitize input
             this.sanitize(value);
             // 2. Check for required fields
-            if (this.isEmpty(value)) {
+            let parsedValue;
+            if (MessageParser.isEmpty(value)) {
                 if (field.required) {
-                    throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: field.path, value });
+                    const pathWithSuffix = field.type === 'id' ? `${field.path}_id` : field.path;
+                    throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: pathWithSuffix, value });
                 }
                 else if (field.defaultValue !== undefined) {
-                    value = field.defaultValue;
+                    parsedValue = { '': field.defaultValue };
                 }
                 else {
-                    return { '': undefined };
+                    parsedValue = { '': undefined };
                 }
             }
-            if (field.array) {
-                if (!Array.isArray(value)) {
-                    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value, type: 'list' });
+            else {
+                if (field.array) {
+                    if (!Array.isArray(value)) {
+                        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value, type: 'list' });
+                    }
                 }
-            }
-            // 3. Run parse method
-            let parsedValue;
-            try {
-                parsedValue = await (0, message_template_parser_1.MessageTemplateFieldParser)(raw, trx, field, value, parseFields);
-            }
-            catch (e) {
-                if (field.or) {
-                    return parseField(trx, field.or, value);
+                // 3. Run parse method
+                try {
+                    parsedValue = await (0, message_template_parser_1.MessageTemplateFieldParser)(raw, trx, field, value, parseFields);
+                }
+                catch (e) {
+                    // If this error was not triggered by a nested field,
+                    // and we have another option, we try that option.
+                    if (field.or && !e.__msg_deep_error) {
+                        return parseField(trx, field.or, value);
+                    }
+                    e.__msg_deep_error = true;
+                    throw e;
                 }
-                throw e;
             }
-            // 4. Apply rules
-            for (const r in field.rules) {
-                const rule = field.rules[r];
-                const res = await rule({ field, value: parsedValue, raw });
-                if (typeof res === 'object') {
-                    parsedValue = res.set;
+            return parsedValue;
+        };
+        const applyRules = async (fields, parsed, parsedValue = parsed) => {
+            for (const f in fields) {
+                const field = fields[f];
+                for (const r in field.rules) {
+                    const rule = field.rules[r];
+                    const value = parsedValue?.[field.name];
+                    const res = await rule({ field, value, msg: parsed });
+                    if (typeof res === 'object') {
+                        parsedValue ?? (parsedValue = {});
+                        parsedValue[field.name] = res.set;
+                    }
+                    else if (res !== true) {
+                        throw error_1.NesoiError.Message.RuleFailed(rule, res);
+                    }
                 }
-                else if (res !== true) {
-                    throw error_1.NesoiError.Message.RuleFailed(rule, res);
+                if (field.children) {
+                    await applyRules(field.children, parsed, parsedValue?.[field.name]);
                 }
             }
-            return parsedValue;
         };
         const parsed = await parseFields(trx, this.schema.template.fields, raw);
+        await applyRules(this.schema.template.fields, parsed);
         return message_1.Message.new(this.schema.name, parsed, sigKey);
     }
     sanitize(value) {
@@ -95,18 +111,23 @@ class MessageParser {
             });
         }
     }
-    isEmpty(value) {
-        // if (Array.isArray(value)) {
-        //     return value.length === 0
-        // }
-        //  if (typeof value === 'object') {
-        //     return Object.keys(value).length === 0
-        // }
+    /**
+     * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
+     */
+    static isEmpty(value) {
+        if (value === null || value === undefined) {
+            return true;
+        }
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        if (typeof value === 'object') {
+            return Object.keys(value).length === 0;
+        }
         if (typeof value === 'string') {
             return value.length === 0;
         }
-        return value === null ||
-            value === undefined;
+        return false;
     }
 }
 exports.MessageParser = MessageParser;

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

@@ -1,13 +1,14 @@
+import { $Message } from "../../..";
 import { $BucketModelFieldType } from "../../bucket/model/bucket_model.schema";
 import { $Dependency } from "../../../../engine/dependency";
-export type $MessageTemplateRule<I, Raw> = (def: {
+export type $MessageTemplateRule = (def: {
     field: $MessageTemplateField;
-    value: I;
-    raw: Raw;
+    value: any;
+    msg: $Message['#raw'];
 }) => {
-    set: I;
+    set: any;
 } | true | string | Promise<{
-    set: I;
+    set: any;
 } | true | string>;
 export type $MessageTemplateFieldMeta = {
     decimal?: {
@@ -19,11 +20,12 @@ export type $MessageTemplateFieldMeta = {
         dep?: $Dependency;
     };
     file?: {
-        maxSize?: number;
+        maxsize?: number;
         extnames?: string[];
     };
     id?: {
         bucket: $Dependency;
+        type?: 'int' | 'string';
         view?: string;
     };
     msg?: $Dependency;
@@ -38,14 +40,14 @@ export declare class $MessageTemplateField {
     required: boolean;
     defaultValue: any;
     nullable: boolean;
-    rules: $MessageTemplateRule<any, any>[];
+    rules: $MessageTemplateRule[];
     meta: $MessageTemplateFieldMeta;
     children?: $MessageTemplateFields | undefined;
     or?: $MessageTemplateField | undefined;
     '#raw': unknown;
     '#parsed': unknown;
     $t: string;
-    constructor(type: $MessageTemplateFieldType, name: string, alias: string, path: string, array: boolean, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule<any, any>[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined, or?: $MessageTemplateField | undefined);
+    constructor(type: $MessageTemplateFieldType, name: string, alias: string, path: string, array: boolean, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined, or?: $MessageTemplateField | undefined);
 }
 export type $MessageTemplateFields = {
     [x: string]: $MessageTemplateField;

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

@@ -1,13 +1,14 @@
 import { $Module, $Space, BucketName, ViewName } from "../../../../schema";
-import { $MessageTemplateField, $MessageTemplateFieldMeta, $MessageTemplateFieldType, $MessageTemplateFields, $MessageTemplateRule } from './message_template.schema';
+import { $MessageTemplateField, $MessageTemplateFieldMeta, $MessageTemplateFieldType, $MessageTemplateFields } from './message_template.schema';
 import { $MessageInputInfer, $MessageOutputInfer, $MessageTemplateBuilderInfer } from '../message.infer';
 import { NesoiDate } from "../../../../engine/data/date";
 import { $Message } from '../message.schema';
 import { ModuleTree } from "../../../../engine/tree";
 import { NesoiObj } from "../../../../engine/data/obj";
 import { MessageEnumpath } from '../../constants/constants.schema';
-import { Decimal } from "../../../../engine/data/decimal";
+import { NesoiDecimal } from "../../../../engine/data/decimal";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
+import { NesoiFile } from "../../../../engine/data/file";
 export declare class MessageTemplateFieldFactory<Space extends $Space, Module extends $Module, MsgName extends keyof Module['messages'], Message extends $Message = Module['messages'][MsgName]> {
     private module;
     private alias?;
@@ -36,7 +37,7 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
     decimal(config?: $MessageTemplateFieldMeta['decimal']): MessageTemplateFieldBuilder<Module, Message, {
         '': string;
     }, {
-        '': Decimal;
+        '': NesoiDecimal;
     }, {}, [never, never], [never, never]>;
     enum<Enumpaths extends MessageEnumpath<Module, Module['messages'][MsgName], Space['modules']>, Options extends (keyof Enumpaths & string) | readonly string[] | Record<string, any>>(options: Options): MessageTemplateFieldBuilder<Module, Message, {
         '': (Options extends string ? keyof Enumpaths[Options & keyof Enumpaths]["options" & keyof Enumpaths[Options & keyof Enumpaths]] : Options extends (infer X)[] | readonly (infer X)[] ? X : keyof Options) & string;
@@ -44,9 +45,9 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
         '': (Options extends string ? keyof Enumpaths[Options & keyof Enumpaths]["options" & keyof Enumpaths[Options & keyof Enumpaths]] : Options extends (infer X)[] | readonly (infer X)[] ? X : keyof Options) & string;
     }, {}, [never, never], [never, never]>;
     file(config?: $MessageTemplateFieldMeta['file']): MessageTemplateFieldBuilder<Module, Message, {
-        '': File;
+        '': NesoiFile;
     }, {
-        '': File;
+        '': NesoiFile;
     }, {}, [never, never], [never, never]>;
     get float(): MessageTemplateFieldBuilder<Module, Message, {
         '': number;
@@ -213,7 +214,7 @@ Nullable extends [null | never, null | never] = [never, never]> {
     get optional(): MessageTemplateFieldBuilder<Module, Message, DefinedInput, DefinedOutput, Children, [undefined, undefined], Nullable>;
     default(value: DefinedInput[keyof DefinedInput] | Nullable[0]): MessageTemplateFieldBuilder<Module, Message, DefinedInput, DefinedOutput, Children, [undefined, never], Nullable>;
     get nullable(): MessageTemplateFieldBuilder<Module, Message, DefinedInput, DefinedOutput, Children, Optional, [null, null]>;
-    rule(rule: $MessageTemplateRule<DefinedInput[keyof DefinedInput], Message['#raw']>): this;
+    rule(rule: MessageTemplateRuleDef<DefinedOutput[keyof DefinedOutput], Message['#raw']>): this;
     get array(): MessageTemplateFieldBuilder<Module, Message, { [K in keyof DefinedInput]: DefinedInput[K][]; }, { [K in keyof DefinedOutput]: DefinedOutput[K][]; }, Children, Optional, Nullable>;
     or<Def extends AnyMessageTemplateFieldBuilder>(def: Def): MessageTemplateFieldBuilder<Module, Message, { [K in keyof DefinedInput]: DefinedInput[K] | (Def extends MessageTemplateFieldBuilder<any, any, infer X, any, any, [never, never], [never, never]> ? X : never)[keyof (Def extends MessageTemplateFieldBuilder<any, any, infer X, any, any, [never, never], [never, never]> ? X : never)]; }, { [K in keyof DefinedOutput]: DefinedOutput[K] | (Def extends MessageTemplateFieldBuilder<any, any, any, infer X, any, [never, never], [never, never]> ? X : never)[keyof (Def extends MessageTemplateFieldBuilder<any, any, any, infer X, any, [never, never], [never, never]> ? X : never)]; }, Children, Optional, Nullable>;
     static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePath: string): $MessageTemplateField;
@@ -223,3 +224,12 @@ export type MessageTemplateFieldBuilders = {
     [x: string]: AnyMessageTemplateFieldBuilder;
 };
 export type AnyMessageTemplateFieldBuilder = MessageTemplateFieldBuilder<any, any, any, any, any>;
+export type MessageTemplateRuleDef<I, Msg> = (def: {
+    field: $MessageTemplateField;
+    value: I;
+    msg: Msg;
+}) => {
+    set: I;
+} | true | string | Promise<{
+    set: I;
+} | true | string>;

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

@@ -64,6 +64,7 @@ class MessageTemplateFieldFactory {
         return new MessageTemplateFieldBuilder('obj', {}, this.alias, children);
     }
     dict(item) {
+        item = item.optional;
         return new MessageTemplateFieldBuilder('dict', {}, this.alias, { __dict: item });
     }
     msg(msg, extra) {
@@ -98,15 +99,26 @@ class MessageTemplateFieldBuilder {
     }
     get optional() {
         this._required = false;
+        if (this._or) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            this._or.optional;
+        }
         return this;
     }
     default(value) {
         this._required = false;
         this._defaultValue = value;
+        if (this._or) {
+            this._or.default(value);
+        }
         return this;
     }
     get nullable() {
         this._nullable = true;
+        if (this._or) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            this._or.nullable;
+        }
         return this;
     }
     rule(rule) {
@@ -115,10 +127,19 @@ class MessageTemplateFieldBuilder {
     }
     get array() {
         this._array = true;
+        if (this._or) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            this._or.array;
+        }
         return this;
     }
     or(def) {
         this._or = def;
+        this._or._array = this._array;
+        this._or._defaultValue = this._defaultValue;
+        this._or._nullable = this._nullable;
+        this._or._required = this._required;
+        this._or._rules = this._rules;
         return this;
     }
     // Build
@@ -130,6 +151,10 @@ class MessageTemplateFieldBuilder {
         const childrenBasePath = builder.children
             ? path + (builder._array ? '*.' : '')
             : undefined;
+        if (builder.value.id) {
+            const bucket = tree.getSchema(builder.value.id.bucket);
+            builder.value.id.type = bucket.model.fields.id.type;
+        }
         return new message_template_schema_1.$MessageTemplateField(builder.type, name, builder.alias || name, basePath + name, builder._array, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder.value, builder.children ? MessageTemplateFieldBuilder.buildChildren(builder.children, tree, module, childrenBasePath) : undefined, or);
     }
     static buildChildren(fields, tree, module, basePath = '') {

package/lib/elements/entities/message/template/message_template_parser.js

@@ -48,8 +48,9 @@ async function MessageTemplateFieldParser(raw, trx, field, value, parseFields) {
     }
     if (field.type === 'id') {
         const bucket = field.meta.id.bucket;
+        const type = field.meta.id.type;
         const view = field.meta.id.view;
-        const parsed = await (0, parse_1.parseId)(field, value, field.array, trx, bucket.refName, view);
+        const parsed = await (0, parse_1.parseId)(field, value, field.array, trx, bucket.refName, type, view);
         return {
             '': parsed.obj
         };

package/lib/engine/apps/app.config.d.ts

@@ -6,6 +6,11 @@ import { TrxEngineConfig } from '../transaction/trx_engine.config';
 import { CompilerConfig } from "../../compiler/compiler";
 import { App } from './app';
 import { CLIConfig } from '../cli/cli';
+import { BucketAdapter } from "../../elements/entities/bucket/adapters/bucket_adapter";
+import { TrashObj } from '../data/trash';
+import { $Bucket } from "../../elements";
+import { Overlay } from '../util/type';
+import { TrxStatus } from '../transaction/trx';
 export type AppConfig<S extends $Space, Modules extends ModuleName<S>> = {
     i18n?: AppI18nConfig;
     authn?: AppAuthnConfig<S>;
@@ -20,13 +25,18 @@ export type AppI18nConfig = {
     [x: string]: ($: Record<string, any>) => string;
 };
 export type AppAuthnConfig<S extends $Space> = {
-    [K in keyof S['authnUsers']]: AuthnProvider<S['authnUsers'][K]>;
+    [K in keyof S['authnUsers']]: () => AuthnProvider<S['authnUsers'][K]>;
 };
 export type AppBucketConfig<S extends $Space, Modules extends ModuleName<S>, Providers extends Record<string, any>> = Partial<{
     [M in (Modules & keyof S['modules'])]: Partial<{
-        [K in keyof S['modules'][M]['buckets']]: BucketConfig<S['modules'][M]['buckets'][K], Providers>;
+        [K in keyof S['modules'][M]['buckets']]: BucketConfig<S['modules'][M], S['modules'][M]['buckets'][K], Providers>;
     }>;
 }>;
+export type AppTrashConfig = {
+    adapter: ($: Overlay<$Bucket, {
+        '#data': TrashObj;
+    }>) => BucketAdapter<TrashObj>;
+};
 export type AppControllerConfig<S extends $Space, Modules extends ModuleName<S>, Providers extends Record<string, any>> = Partial<{
     [M in (Modules & keyof S['modules'])]: Partial<{
         [K in keyof S['modules'][M]['controllers']]: ControllerConfig<S['modules'][M]['controllers'][K], Providers>;
@@ -35,15 +45,26 @@ export type AppControllerConfig<S extends $Space, Modules extends ModuleName<S>,
 export type AppTrxEngineConfig<S extends $Space, Modules extends ModuleName<S>, Providers extends Record<string, any>> = Partial<{
     [M in (Modules & keyof S['modules'])]: TrxEngineConfig<S, S['modules'][M], any, Providers>;
 }>;
-export declare class AppConfigFactory<S extends $Space, Modules extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> {
+export type AppAuditConfig = {
+    adapter: ($: Overlay<$Bucket, {
+        '#data': TrashObj;
+    }>) => BucketAdapter<TrashObj>;
+    transform?: (trx: TrxStatus<any>) => Record<string, any>;
+};
+/**
+ * Factory
+ */
+export declare class AppConfigFactory<S extends $Space, Modules extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>, _App = App<S, Modules, Providers>> {
     private app;
     private config;
-    constructor(app: App<S, Modules, Providers>);
-    i18n(config: AppI18nConfig): App<S, Modules, Providers>;
-    authn(config: AppAuthnConfig<S>): App<S, Modules, Providers>;
-    buckets(config: AppBucketConfig<S, Modules, Providers>): App<S, Modules, Providers>;
-    controllers(config: AppControllerConfig<S, Modules, Providers>): App<S, Modules, Providers>;
-    compiler(config: CompilerConfig): App<S, Modules, Providers>;
-    cli(config: CLIConfig<Providers>): App<S, Modules, Providers>;
-    trx(config: AppTrxEngineConfig<S, Modules, Providers>): App<S, Modules, Providers>;
+    constructor(app: _App);
+    i18n(config: AppI18nConfig): _App;
+    authn(config: AppAuthnConfig<S>): _App;
+    buckets(config: AppBucketConfig<S, Modules, Providers>): _App;
+    trash(config: AppTrashConfig): _App;
+    controllers(config: AppControllerConfig<S, Modules, Providers>): _App;
+    audit(config: AppI18nConfig): _App;
+    compiler(config: CompilerConfig): _App;
+    cli(config: CLIConfig<Providers>): _App;
+    trx(config: AppTrxEngineConfig<S, Modules, Providers>): _App;
 }