nesoi 3.0.6 → 3.0.9

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

@@ -31,6 +31,10 @@ export type $MessageTemplateFieldMeta = {
     msg?: $Dependency;
 };
 export type $MessageTemplateFieldType = $BucketModelFieldType | 'string_or_number' | 'id' | 'msg';
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $MessageTemplateField {
     type: $MessageTemplateFieldType;
     name: string;
@@ -52,8 +56,13 @@ export declare class $MessageTemplateField {
 export type $MessageTemplateFields = {
     [x: string]: $MessageTemplateField;
 };
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $MessageTemplate {
     fields: $MessageTemplateFields;
     $t: string;
     constructor(fields?: $MessageTemplateFields);
+    static fieldsOfType(template: $MessageTemplate, type: $MessageTemplateFieldType): $MessageTemplateField[];
 }

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

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$MessageTemplate = exports.$MessageTemplateField = void 0;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $MessageTemplateField {
     constructor(type, name, alias, path, array, required, defaultValue, nullable, rules, meta, children, or) {
         this.type = type;
@@ -19,10 +23,31 @@ class $MessageTemplateField {
     }
 }
 exports.$MessageTemplateField = $MessageTemplateField;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $MessageTemplate {
     constructor(fields = {}) {
         this.fields = fields;
         this.$t = 'message.template';
     }
+    static fieldsOfType(template, type) {
+        const fields = [];
+        let poll = Object.values(template.fields);
+        while (poll.length) {
+            const next = [];
+            for (const field of poll) {
+                if (field.type === type) {
+                    fields.push(field);
+                }
+                if (field.children) {
+                    next.push(...Object.values(field.children));
+                }
+            }
+            poll = next;
+        }
+        return fields;
+    }
 }
 exports.$MessageTemplate = $MessageTemplate;

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

@@ -9,6 +9,10 @@ import { MessageEnumpath } from '../../constants/constants.schema';
 import { NesoiDecimal } from "../../../../engine/data/decimal";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
 import { NesoiFile } from "../../../../engine/data/file";
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 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?;
@@ -197,6 +201,10 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
     }, {}, [never, never], [never, never]>;
     extend<MsgName extends keyof Module['messages'], Builders extends MessageTemplateFieldBuilders>(name: MsgName, fields: Builders): $MessageTemplateBuilderInfer<Module, Module["messages"][MsgName], Module["messages"][MsgName]["#raw"], Module["messages"][MsgName]["#parsed"]> & Builders;
 }
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class MessageTemplateFieldBuilder<Module extends $Module, Message extends $Message, DefinedInput, DefinedOutput, Children extends MessageTemplateFieldBuilders, Optional extends [undefined | never, undefined | never] = [never, never], // Used to infer the message type
 Nullable extends [null | never, null | never] = [never, never]> {
     private type;

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

@@ -4,6 +4,10 @@ exports.MessageTemplateFieldBuilder = exports.MessageTemplateFieldFactory = void
 const message_template_schema_1 = require("./message_template.schema");
 const error_1 = require("../../../../engine/data/error");
 const dependency_1 = require("../../../../engine/dependency");
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class MessageTemplateFieldFactory {
     constructor(module) {
         this.module = module;
@@ -81,6 +85,10 @@ class MessageTemplateFieldFactory {
     }
 }
 exports.MessageTemplateFieldFactory = MessageTemplateFieldFactory;
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class MessageTemplateFieldBuilder {
     constructor(type, value, alias, children) {
         this.type = type;

package/lib/elements/index.d.ts

@@ -7,5 +7,5 @@ export { $Bucket } from './entities/bucket/bucket.schema';
 export { $Job } from './blocks/job/job.schema';
 export { $Resource } from './blocks/resource/resource.schema';
 export { $Queue } from './blocks/queue/queue.schema';
-export { $Externals } from './blocks/externals/externals.schema';
+export { $Externals } from './edge/externals/externals.schema';
 export { $Space, $Module } from '../schema';

package/lib/elements/index.js

@@ -19,5 +19,5 @@ var resource_schema_1 = require("./blocks/resource/resource.schema");
 Object.defineProperty(exports, "$Resource", { enumerable: true, get: function () { return resource_schema_1.$Resource; } });
 var queue_schema_1 = require("./blocks/queue/queue.schema");
 Object.defineProperty(exports, "$Queue", { enumerable: true, get: function () { return queue_schema_1.$Queue; } });
-var externals_schema_1 = require("./blocks/externals/externals.schema");
+var externals_schema_1 = require("./edge/externals/externals.schema");
 Object.defineProperty(exports, "$Externals", { enumerable: true, get: function () { return externals_schema_1.$Externals; } });

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

@@ -54,6 +54,9 @@ export type AppAuditConfig = {
 /**
  * Factory
  */
+/**
+ * @category App
+ */
 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;

package/lib/engine/apps/app.config.js

@@ -4,6 +4,9 @@ exports.AppConfigFactory = void 0;
 /**
  * Factory
  */
+/**
+ * @category App
+ */
 class AppConfigFactory {
     constructor(app) {
         this.app = app;

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

@@ -15,6 +15,9 @@ export type AppProvider<out Name, T> = {
     libPaths?: string[];
 };
 export type AnyAppProvider = AppProvider<any, any>;
+/**
+ * @category App
+ */
 export declare abstract class App<S extends $Space, Modules extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> {
     name: string;
     protected _config: AnyAppConfig;

package/lib/engine/apps/app.js

@@ -7,6 +7,9 @@ const app_config_1 = require("./app.config");
 /*
     App
 */
+/**
+ * @category App
+ */
 class App {
     constructor(name, boot) {
         this.name = name;
@@ -73,7 +76,7 @@ class App {
         if (this.space) {
             space_1.Space.scan(this.space, (name, path) => {
                 if (this._spaceModuleNames.includes(name)) {
-                    modules[name] = new module_1.Module(name, { path });
+                    modules[name] = new module_1.Module(name, { dirpath: path });
                 }
             });
         }

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

@@ -4,6 +4,9 @@ import { AnyTrxEngine } from '../transaction/trx_engine';
 import { AnyBuilder, AnyModule, Module } from '../module';
 import { AnyDaemon, Daemon } from '../daemon';
 import { AppConfigFactory } from './app.config';
+/**
+ * @category App
+ */
 export declare class InlineApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> extends App<S, ModuleNames, Providers> {
     protected _daemon?: Daemon<S, ModuleNames>;
     protected _modules: Record<string, AnyModule>;

package/lib/engine/apps/inline.app.js

@@ -7,6 +7,9 @@ const trx_engine_1 = require("../transaction/trx_engine");
 const tree_1 = require("../tree");
 const daemon_1 = require("../daemon");
 const app_config_1 = require("./app.config");
+/**
+ * @category App
+ */
 class InlineApp extends app_1.App {
     constructor(name, builders) {
         super(name, { builders });

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

@@ -5,6 +5,10 @@ import { AnyTrxEngine } from '../../transaction/trx_engine';
 import { Space } from '../../space';
 import { Daemon } from "../../daemon";
 import { AppConfigFactory } from '../app.config';
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
 export declare class MonolythApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> extends InlineApp<S, ModuleNames, Providers> {
     private watcher?;
     constructor(name: string, space?: Space<S>);
@@ -18,5 +22,9 @@ export declare class MonolythApp<S extends $Space, ModuleNames extends string =
     provider<Name extends string, T>($: AppProvider<Name, T>): MonolythApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
     get config(): AppConfigFactory<S, ModuleNames, Providers, typeof this>;
 }
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
 export declare class MonolythDaemon<S extends $Space, Modules extends ModuleName<S>> extends Daemon<S, Modules> {
 }

package/lib/engine/apps/monolyth/monolyth.app.js

@@ -39,6 +39,10 @@ const space_1 = require("../../space");
 const daemon_1 = require("../../daemon");
 const log_1 = require("../../util/log");
 const app_config_1 = require("../app.config");
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
 class MonolythApp extends inline_app_1.InlineApp {
     constructor(name, space) {
         super(name, []);
@@ -101,6 +105,10 @@ class MonolythApp extends inline_app_1.InlineApp {
     }
 }
 exports.MonolythApp = MonolythApp;
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
 class MonolythDaemon extends daemon_1.Daemon {
 }
 exports.MonolythDaemon = MonolythDaemon;

package/lib/engine/auth/authn.d.ts

@@ -8,6 +8,10 @@ export type AuthnToken = string;
 export type AuthnRequest<P extends keyof any> = {
     [K in P]?: AuthnToken;
 };
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 export declare abstract class AuthnProvider<U extends User> {
     abstract authenticate($: {
         trx: AnyTrxNode;

package/lib/engine/auth/authn.js

@@ -4,6 +4,10 @@ exports.AuthnProvider = void 0;
 /*
     Provider
 */
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 class AuthnProvider {
 }
 exports.AuthnProvider = AuthnProvider;

package/lib/engine/auth/zero.authn_provider.d.ts

@@ -4,6 +4,10 @@ type ZeroUser = {
     id: NesoiObjId;
     name: string;
 };
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 export declare class ZeroAuthnProvider extends AuthnProvider<ZeroUser> {
     authenticate($: {
         token: string;

package/lib/engine/auth/zero.authn_provider.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZeroAuthnProvider = void 0;
 const authn_1 = require("./authn");
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 class ZeroAuthnProvider extends authn_1.AuthnProvider {
     authenticate($) {
         return Promise.resolve({

package/lib/engine/cli/cli.d.ts

@@ -1,10 +1,15 @@
 import { AnyDaemon } from '../daemon';
 import { CLIAdapter } from './cli_adapter';
 export type CLIConfig<Providers> = {
+    editor?: string;
     adapters?: {
-        [x: string]: (providers: Providers) => CLIAdapter;
+        [x: string]: (cli: CLI, providers: Providers) => CLIAdapter;
     };
 };
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare class CLI {
     private daemon;
     config?: CLIConfig<any> | undefined;
@@ -18,4 +23,5 @@ export declare class CLI {
     private cmdHelp;
     private cmdClear;
     private getCmds;
+    openEditor(file: string): void;
 }

package/lib/engine/cli/cli.js

@@ -10,6 +10,11 @@ const console_1 = __importDefault(require("../util/console"));
 const daemon_1 = require("../daemon");
 const log_1 = require("../util/log");
 const cli_input_1 = require("./cli_input");
+const shell_1 = __importDefault(require("../util/shell"));
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLI {
     constructor(daemon, config) {
         this.daemon = daemon;
@@ -20,7 +25,7 @@ class CLI {
         // Build adapters
         this.adapters = {};
         Object.entries(config?.adapters || {}).forEach(([key, val]) => {
-            this.adapters[key] = val(daemon_1.Daemon.get(daemon, 'providers'));
+            this.adapters[key] = val(this, daemon_1.Daemon.get(daemon, 'providers'));
             this.adapters[key].name = key;
         });
         this.input = new cli_input_1.CLIInputHandler(this.getCmds());
@@ -103,5 +108,9 @@ class CLI {
         }
         return cmds;
     }
+    openEditor(file) {
+        const editor = this.config?.editor || 'code';
+        shell_1.default.cmd(process.cwd(), `${editor} ${file}`);
+    }
 }
 exports.CLI = CLI;

package/lib/engine/cli/cli_adapter.d.ts

@@ -1,4 +1,9 @@
 import { AnyDaemon } from '../daemon';
+import { CLI } from './cli';
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare abstract class CLICommand<T extends Record<string, any> = Record<string, any>> {
     scope: 'dev' | 'prod' | 'any';
     name: string;
@@ -10,10 +15,15 @@ export declare abstract class CLICommand<T extends Record<string, any> = Record<
     input(payload: string): Record<string, any>;
     abstract run(daemon: AnyDaemon, input: T): Promise<void>;
 }
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare abstract class CLIAdapter {
+    protected cli: CLI;
     name?: string;
     commands: Record<string, CLICommand>;
-    constructor();
+    constructor(cli: CLI);
     runCmd(daemon: AnyDaemon, payload: string): Promise<boolean>;
     help(): string;
 }

package/lib/engine/cli/cli_adapter.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIAdapter = exports.CLICommand = void 0;
 const string_1 = require("../util/string");
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLICommand {
     constructor(scope, name, syntax, description, regex, groups) {
         this.scope = scope;
@@ -30,8 +34,13 @@ class CLICommand {
     }
 }
 exports.CLICommand = CLICommand;
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLIAdapter {
-    constructor() {
+    constructor(cli) {
+        this.cli = cli;
         this.commands = {};
     }
     async runCmd(daemon, payload) {

package/lib/engine/cli/cli_input.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare class CLIInputHandler {
     private suggestions;
     private items;

package/lib/engine/cli/cli_input.js

@@ -36,6 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIInputHandler = void 0;
 const stream_1 = require("stream");
 const readline = __importStar(require("readline"));
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLIInputHandler {
     constructor(suggestions = []) {
         this.suggestions = suggestions;

package/lib/engine/cli/ui.d.ts

@@ -1,8 +1,15 @@
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export default class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
      */
-    static select<T>(title: string, options: T[], val?: NoInfer<(o: T) => string>, defaul?: number): Promise<T>;
+    static select<T>(title: string, options: T[], val?: NoInfer<(o: T) => string>, defaul?: number): Promise<{
+        i: number;
+        value: T;
+    }>;
     /**
      * Ask a question and wait for the answer
      */
@@ -10,7 +17,12 @@ export default class UI {
     /**
      * Show a message and wait for the user to press any key
      */
-    static waitForAnyKey(title?: string): Promise<void>;
+    static waitForAnyKey(title?: string): Promise<{
+        sequence: string;
+        name: string;
+        ctrl: boolean;
+        shift: boolean;
+    }>;
     /**
      * Ask a yes or no question and wait for the answer
      */

package/lib/engine/cli/ui.js

@@ -36,6 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const readline = __importStar(require("readline"));
 const stream_1 = require("stream");
 const string_1 = require("../util/string");
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
@@ -85,7 +89,7 @@ class UI {
                 else if (key.name === 'return') {
                     rl.close();
                     process.stdin.off('keypress', onKeypress);
-                    resolve(options[selected]);
+                    resolve({ i: selected, value: options[selected] });
                 }
                 clear();
                 print();
@@ -115,7 +119,7 @@ class UI {
      */
     static waitForAnyKey(title = 'Press any key to continue...') {
         return new Promise(resolve => {
-            UI.step(title);
+            process.stdin.write(title + ' ');
             const mutableStdout = new stream_1.Writable({
                 write: function (chunk, encoding, callback) {
                 }
@@ -127,8 +131,9 @@ class UI {
             });
             const onKeypress = function (ch, key) {
                 rl.close();
+                console.log(`${(0, string_1.colored)(ch, 'lightcyan')}\n`);
                 process.stdin.off('keypress', onKeypress);
-                resolve();
+                resolve(key);
             };
             process.stdin.on('keypress', onKeypress);
         });
@@ -137,9 +142,8 @@ class UI {
      * Ask a yes or no question and wait for the answer
      */
     static async yesOrNo(text, defaul = 'n') {
-        let answer = await this.question(text + ' [y|n]', defaul);
-        answer = answer.toLowerCase();
-        if (answer === 'y' || answer === 'yes')
+        const answer = await this.waitForAnyKey('\n\t» ' + (0, string_1.colored)(text, 'lightblue') + (0, string_1.colored)(' [y|n]', 'lightgray'));
+        if (answer.name === 'y')
             return true;
         return false;
     }

package/lib/engine/daemon.d.ts

@@ -6,31 +6,118 @@ import { AnyUsers, AuthnRequest } from './auth/authn';
 import { TrxNode } from './transaction/trx_node';
 import { TrxStatus } from './transaction/trx';
 import { AnyModule } from './module';
+import { AnyAppProvider } from './apps/app';
+/**
+ * A background process running one or more modules,
+ * which runs _Transactions_ for the available elements.
+ *
+ * A `Daemon` is spawn by an `App`.
+ *
+ * @category Engine
+ */
 export declare abstract class Daemon<S extends $Space, Modules extends ModuleName<S>> {
     protected name: string;
     protected trxEngines: Record<Modules, AnyTrxEngine>;
-    protected providers: Record<string, any>;
-    protected app?: AnyAppConfig | undefined;
-    private _cli?;
-    constructor(name: string, trxEngines: Record<Modules, AnyTrxEngine>, providers: Record<string, any>, app?: AnyAppConfig | undefined);
+    protected providers: Record<string, AnyAppProvider>;
+    protected config?: AnyAppConfig | undefined;
+    /**
+     * @param name Name of the daemon (taken from App)
+     * @param trxEngines A dictionary of Transaction Engine by module name
+     * @param providers A dictionary of App Provider by name
+     * @param config Optional `AppConfig`
+     */
+    constructor(name: string, trxEngines: Record<Modules, AnyTrxEngine>, providers: Record<string, AnyAppProvider>, config?: AnyAppConfig | undefined);
+    /**
+     * Prepare a transaction to be run by the Daemon.
+     *
+     * @param moduleName Name of the module where to run the transactoin
+     * @returns A `DaemonTrx` instance, which can be run
+     */
     trx<K extends Modules & keyof S['modules']>(moduleName: K): DaemonTrx<S, S["modules"][K], {}>;
+    /**
+     * Run the Nesoi CLI for this Daemon.
+     */
     cli(cmd?: string): Promise<void>;
+    /**
+     * Bind the controller of each module to this Daemon.
+     * This allows the registered `Controller Adapters` to run
+     * transactions on the daemon.
+     */
     private bindControllers;
+    /**
+     * Destroy the providers and transaction engines of this daemon
+     *
+     * @param A `Daemon` instance
+     */
     static destroy(daemon: AnyDaemon): Promise<void>;
+    /**
+     * Replace the providers and transaction engines of this daemon
+     * and rebind the controllers
+     *
+     * @param daemon A `Daemon` instance
+     * @param trxEngines A dictionary of Transaction Engine by module name
+     * @param providers A dictionary of App Provider by name
+     */
     static reload(daemon: AnyDaemon, trxEngines: Record<string, AnyTrxEngine>, providers: Record<string, any>): void;
+    /**
+     * Return a `Daemon` property.
+     * This is used to read private properties.
+     *
+     * @param daemon A `Daemon` instance
+     * @param key A `Daemon` property `'name'|'providers'|'app'`
+     * @returns The selected property
+     */
     static get<T extends {
         name: string;
         providers: Record<string, any>;
         app: AnyAppConfig;
     }, K extends keyof T>(daemon: AnyDaemon | undefined, key: K): T[K];
-    static getModule<Modules extends ModuleName<any>, D extends Daemon<any, Modules>>(daemon: D, module: Modules): import("./module").Module<any, any>;
+    /**
+     * Return one module of the `Daemon` by name.
+     *
+     * @param daemon A `Daemon` instance
+     * @param module A module name
+     * @returns The `Module` instance
+     */
+    static getModule<Module extends ModuleName<any>, D extends Daemon<any, Module>>(daemon: D, module: Module): import("./module").Module<any, any>;
+    /**
+     * Return all modules of the `Daemon`.
+     *
+     * @param daemon A `Daemon` instance
+     * @returns The `Module` instances
+     */
     static getModules(daemon: AnyDaemon): AnyModule[];
 }
+/**
+ * A helper class for preparing a transaction to be run.
+ * It allows declaring authentication data before running
+ * the transaction.
+ *
+ * @category Engine
+ */
 export declare class DaemonTrx<S extends $Space, M extends $Module, Authn extends AnyUsers = {}> {
     private trxEngine;
-    private _authn?;
+    /**
+     * The authentication request which will be used to
+     * authenticate this transaction prior to running.
+     */
+    private authnRequest?;
+    /**
+     * @param trxEngine The transaction engine where to run the transaction.
+     */
     constructor(trxEngine: AnyTrxEngine);
+    /**
+     * Authenticate the transaction with the given credentials.
+     * You can specify one or more credentials, so the transaction
+     * is able to access elements with different authn providers.
+     */
     authn<Authn extends AuthnRequest<keyof S['authnUsers']>>(authn?: Authn): DaemonTrx<S, M, { [K in keyof Authn]: S["authnUsers"][K & keyof S["authnUsers"]]; }>;
+    /**
+     * Run a method inside the transaction.
+     *
+     * @param fn A function to execute inside the transaction
+     * @returns A `TrxStatus` containing metadata about the transaction and the function response
+     */
     run<Output>(fn: (trx: TrxNode<S, M, Authn>) => Promise<Output>): Promise<TrxStatus<Output>>;
 }
 export type AnyDaemon = Daemon<any, any>;