nesoi 3.0.8 → 3.0.10

package/lib/engine/transaction/trx_engine.d.ts

@@ -4,23 +4,28 @@ import { Trx } from './trx';
 import { TrxNode, TrxNodeStatus } from './trx_node';
 import { AnyAuthnProviders, AuthnRequest } from '../auth/authn';
 import { TrxEngineConfig } from './trx_engine.config';
+import { IService } from '../apps/service';
 export type TrxEngineOrigin = `app:${string}`;
+/**
+ * @category Engine
+ * @subcategory Transaction
+ */
 export declare class TrxEngine<S extends $Space, M extends $Module, Authn extends AnyAuthnProviders> {
     private origin;
     private module;
     private authnProviders?;
     private config?;
-    private providers;
+    private services;
     /**
      * Transaction used to read/write transactions on the adapter
      */
     private innerTrx;
     private adapter;
-    constructor(origin: TrxEngineOrigin, module: Module<S, M>, authnProviders?: Authn | undefined, config?: TrxEngineConfig<S, M, any, any> | undefined, providers?: Record<string, any>);
+    constructor(origin: TrxEngineOrigin, module: Module<S, M>, authnProviders?: Authn | undefined, config?: TrxEngineConfig<S, M, any, any> | undefined, services?: Record<string, IService>);
     getModule(): Module<S, M>;
     get(id?: string): Promise<Trx<S, M, any>>;
     trx(fn: (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>, authn?: AuthnRequest<keyof Authn>): Promise<import("./trx").TrxStatus<any>>;
-    private authenticate;
+    authenticate(node: TrxNode<S, M, any>, request?: AuthnRequest<keyof Authn>): Promise<void>;
     private commit;
     private rollback;
 }

package/lib/engine/transaction/trx_engine.js

@@ -6,17 +6,18 @@ const trx_1 = require("./trx");
 const trx_node_1 = require("./trx_node");
 const error_1 = require("../data/error");
 const memory_bucket_adapter_1 = require("../../elements/entities/bucket/adapters/memory.bucket_adapter");
-/*
-    Transaction Engine
-*/
+/**
+ * @category Engine
+ * @subcategory Transaction
+ */
 class TrxEngine {
-    constructor(origin, module, authnProviders, config, providers = {}) {
+    constructor(origin, module, authnProviders, config, services = {}) {
         this.origin = origin;
         this.module = module;
         this.authnProviders = authnProviders;
         this.config = config;
-        this.providers = providers;
-        this.innerTrx = new trx_1.Trx(this.module, `trx:${origin}`);
+        this.services = services;
+        this.innerTrx = new trx_1.Trx(this, this.module, `trx:${origin}`);
         this.adapter = config?.adapter?.(module.schema) || new memory_bucket_adapter_1.MemoryBucketAdapter({}, {});
     }
     getModule() {
@@ -25,7 +26,7 @@ class TrxEngine {
     async get(id) {
         let trx = undefined;
         if (!id) {
-            trx = new trx_1.Trx(this.module, this.origin);
+            trx = new trx_1.Trx(this, this.module, this.origin);
             log_1.Log.info('module', this.module.name, `Begin ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
             return this.adapter.create(this.innerTrx.root, trx);
         }
@@ -36,7 +37,7 @@ class TrxEngine {
             }
             else {
                 log_1.Log.info('module', this.module.name, `Chain ${(0, log_1.scopeTag)('trx', id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
-                trx = new trx_1.Trx(this.module, this.origin, undefined, id);
+                trx = new trx_1.Trx(this, this.module, this.origin, undefined, id);
                 return this.adapter.create(this.innerTrx.root, trx);
             }
         }
@@ -45,13 +46,10 @@ class TrxEngine {
     async trx(fn, authn) {
         const trx = await this.get(undefined);
         try {
-            const users = authn ? await this.authenticate(trx.root, authn) : undefined;
-            if (users) {
-                trx_node_1.TrxNode.addAuthn(trx.root, authn, users);
-            }
+            await this.authenticate(trx.root, authn);
             let output;
             if (this.config?.wrap) {
-                output = await this.config?.wrap(trx, fn, this.providers);
+                output = await this.config?.wrap(trx, fn, this.services);
             }
             else {
                 output = await fn(trx.root);
@@ -64,19 +62,25 @@ class TrxEngine {
         return trx.status();
     }
     // authentication
-    async authenticate(trx, request) {
+    async authenticate(node, request = {}) {
         if (!this.authnProviders) {
             throw error_1.NesoiError.Authn.NoProvidersRegisteredForModule(this.module.name);
         }
         const users = {};
-        for (const provider in request) {
-            const token = request[provider];
-            if (!(provider in this.authnProviders)) {
-                throw error_1.NesoiError.Authn.NoProviderRegisteredForModule(this.module.name, provider);
+        const tokens = {};
+        for (const providerName in this.authnProviders) {
+            const provider = this.authnProviders[providerName];
+            const reqToken = request[providerName];
+            if (provider.eager || reqToken) {
+                if (!provider) {
+                    throw error_1.NesoiError.Authn.NoProviderRegisteredForModule(this.module.name, providerName);
+                }
+                const { user, token } = await provider.authenticate({ trx: node, token: reqToken });
+                users[providerName] = user;
+                tokens[providerName] = token;
             }
-            users[provider] = await this.authnProviders[provider].authenticate({ trx, token });
         }
-        return users;
+        trx_node_1.TrxNode.addAuthn(node, tokens, users);
     }
     //
     async commit(trx, output) {

package/lib/engine/transaction/trx_node.d.ts

@@ -1,4 +1,5 @@
 import { $Module, $Space } from "../../schema";
+import { NesoiError } from '../data/error';
 import { AnyModule, VirtualModuleDef } from '../module';
 import { AnyTrx } from './trx';
 import { BucketTrxNode } from './nodes/bucket.trx_node';
@@ -18,10 +19,14 @@ export type TrxNodeStatus = {
     action?: string;
     input?: Record<string, any>;
     output?: Record<string, any>;
-    error?: string;
+    error?: NesoiError.BaseError;
     nodes: TrxNodeStatus[];
     app: number;
 };
+/**
+ * @category Engine
+ * @subcategory Transaction
+ */
 export declare class TrxNode<Space extends $Space, M extends $Module, Authn extends AnyUsers> {
     private scope;
     private trx;
@@ -43,7 +48,7 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     } | undefined, id?: string);
     static open(node: AnyTrxNode, action: string, input: Record<string, any>): Promise<void>;
     static ok(node: AnyTrxNode, output?: Record<string, any>): Promise<void>;
-    static error(node: AnyTrxNode, error: any): Promise<void>;
+    static error(node: AnyTrxNode, error: any): Promise<any>;
     message<Raw extends M['#input']['#raw'], Msg extends $Message = M['messages'][Raw['$'] & keyof M['messages']]>(raw: Raw): Promise<M['#input']['#parsed']>;
     value<K extends keyof M['constants']['values']>(key: K): M["constants"]["values"][K]["value"];
     enum<EnumName extends KeysOfUnion<Space['modules'][keyof Space['modules']]['constants']['enums']>>(name: EnumName): Enum<M['constants']['enums'][EnumName]>;
@@ -53,6 +58,7 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     resource<Name extends keyof M['resources'], Resource extends M['resources'][Name]>(name: Name): ResourceTrxNode<M, Resource>;
     machine<Name extends keyof M['machines'], Machine extends M['machines'][Name]>(name: Name): MachineTrxNode<M, Machine>;
     queue<Name extends keyof M['queues'], Queue extends M['queues'][Name]>(name: Name): QueueTrxNode<M, Queue>;
+    authenticate(authnRequest: AuthnRequest<keyof Authn>): Promise<TrxNode<$Space, $Module, Authn>>;
     token<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
     user<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
     virtual<T>(def: VirtualModuleDef, fn: ($: AnyTrxNode) => T | Promise<T>): Promise<T>;

package/lib/engine/transaction/trx_node.js

@@ -15,6 +15,10 @@ const datetime_1 = require("../data/datetime");
 /*
     Transaction Node
 */
+/**
+ * @category Engine
+ * @subcategory Transaction
+ */
 class TrxNode {
     constructor(scope, trx, parent, module, authn, id) {
         this.scope = scope;
@@ -47,8 +51,15 @@ class TrxNode {
     }
     static async error(node, error) {
         node.state = 'error';
-        node.error = i18n_1.i18n.error(error, node.trx.root.module.daemon);
+        if (error instanceof error_1.NesoiError.BaseError) {
+            error.message = i18n_1.i18n.error(error, node.trx.root.module.daemon);
+        }
+        else {
+            error = new error_1.NesoiError.BaseError('UnknownError', error.toString());
+        }
+        node.error = error;
         node.time.end = datetime_1.NesoiDatetime.now();
+        return error;
     }
     // Entities
     async message(raw) {
@@ -117,6 +128,11 @@ class TrxNode {
         return new queue_trx_node_1.QueueTrxNode(this, queue);
     }
     // Authentication
+    async authenticate(authnRequest) {
+        const newNode = new TrxNode(this.scope, this.trx, this, this.module, this.authn);
+        await this.trx.engine.authenticate(newNode, authnRequest);
+        return newNode;
+    }
     token(provider) {
         if (!this.authn?.tokens) {
             throw error_1.NesoiError.Authn.NoUsersAuthenticatedForTrxNode(this.globalId);

package/lib/engine/tree.d.ts

@@ -3,32 +3,84 @@ import { ResolvedBuilderNode } from './dependency';
 import { AnyModule } from './module';
 import { TreeshakeConfig } from "../compiler/treeshake";
 type TraverseCallback = (node: ResolvedBuilderNode) => Promise<void>;
+/**
+ * A tree of module elements which allows building in the correct order.
+ *
+ * @category Engine
+ */
 export declare class ModuleTree {
     modules: Record<string, AnyModule>;
     config?: TreeshakeConfig | undefined;
     private layers;
+    /**
+     * @param modules A dictionary of modules by name
+     * @param config Optional configuration for the treeshaking process
+     */
     constructor(modules: Record<string, AnyModule>, config?: TreeshakeConfig | undefined);
+    /**
+     * Build the tree from existing modules on the Space.
+     * - Treeshakes each element to identify it's dependencies
+     * - Resolves each found dependency forming a tree
+     * - Groups tree into layers which can be built in isolation
+     */
     resolve(): Promise<void>;
+    /**
+     * Read the module elements from files and identify
+     * all related nodes.
+     *
+     * @returns A dictionary of nodes by module name
+     */
     private treeshake;
     /**
-     * Each node declares it's dependencies as a `$Dependency`.
+     * Each element declares it's dependencies as a `$Dependency`.
      * In order to assemble the build layers, it's necessary to
      * resolve them into a graph of `ResolvedBuilderNode`s.
      * This also resolves the inline nodes, to allow merging the schemas
      * of inline nodes on build.
+     *
+     * @param nodesByModule A dictionary of builder nodes by module name
+     * @returns A dictionary of resolved builder nodes
      */
     private resolveDependencies;
+    /**
+     * Recursively extract all inline nodes from a resolved builder node.
+     *
+     * @param node A resolved builder node
+     * @returns A list of resolved builder nodes
+     */
     private getAllInlineNodes;
     /**
-     * In order to build nodes on the proper order, a set of layers must be stablished
+     * Build a list of layers (a _layer_ is a list of resolved builder nodes),
+     * each of which can be separately built, in a specific order, so all
+     * the dependencies of a node are built before the node itself.
+     *
+     * @param nodes A list of resolved builder nodes
+     * @returns A list of module tree layers
      */
     private resolveLayers;
+    /**
+     * Traverse tree layers and run the callback `fn` for each node of each layer.
+     *
+     * @param actionAlias Action alias to be logged
+     * @param fn Callback to be run for each node
+     */
     traverse(actionAlias: string, fn: TraverseCallback): Promise<void>;
+    /**
+     * Get schema of a dependency-like object.
+     *
+     * @param node A dependency-like object
+     * @return An element schema
+     */
     getSchema(node: {
         module: string;
         type: BuilderType;
         name: string;
     }): import("../elements").$Message | import("../elements").$Machine | import("../elements").$Bucket | import("../elements").$Constants | import("../elements").$Job | import("../elements").$Externals | import("../elements").$Resource | import("../elements").$Controller;
+    /**
+     * Return a list of all nodes of all modules on the tree.
+     *
+     * @returns A list of resolved builder nodes
+     */
     allNodes(): ResolvedBuilderNode[];
 }
 export {};

package/lib/engine/tree.js

@@ -1,21 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleTree = void 0;
+const dependency_1 = require("./dependency");
 const error_1 = require("../compiler/error");
 const log_1 = require("./util/log");
 const string_1 = require("./util/string");
 const treeshake_1 = require("../compiler/treeshake");
+/**
+ * A tree of module elements which allows building in the correct order.
+ *
+ * @category Engine
+ */
 class ModuleTree {
+    /**
+     * @param modules A dictionary of modules by name
+     * @param config Optional configuration for the treeshaking process
+     */
     constructor(modules, config) {
         this.modules = modules;
         this.config = config;
         this.layers = [];
     }
+    /**
+     * Build the tree from existing modules on the Space.
+     * - Treeshakes each element to identify it's dependencies
+     * - Resolves each found dependency forming a tree
+     * - Groups tree into layers which can be built in isolation
+     */
     async resolve() {
         const nodesByModule = await this.treeshake();
         const resolvedNodes = await this.resolveDependencies(nodesByModule);
         this.layers = this.resolveLayers(resolvedNodes);
     }
+    /**
+     * Read the module elements from files and identify
+     * all related nodes.
+     *
+     * @returns A dictionary of nodes by module name
+     */
     async treeshake() {
         log_1.Log.debug('compiler', 'tree', 'Treeshaking');
         const nodesByModule = {};
@@ -27,11 +49,14 @@ class ModuleTree {
         return nodesByModule;
     }
     /**
-     * Each node declares it's dependencies as a `$Dependency`.
+     * Each element declares it's dependencies as a `$Dependency`.
      * In order to assemble the build layers, it's necessary to
      * resolve them into a graph of `ResolvedBuilderNode`s.
      * This also resolves the inline nodes, to allow merging the schemas
      * of inline nodes on build.
+     *
+     * @param nodesByModule A dictionary of builder nodes by module name
+     * @returns A dictionary of resolved builder nodes
      */
     async resolveDependencies(nodesByModule) {
         log_1.Log.debug('compiler', 'tree', 'Resolving dependencies');
@@ -123,6 +148,12 @@ class ModuleTree {
         });
         return resolvedNodes;
     }
+    /**
+     * Recursively extract all inline nodes from a resolved builder node.
+     *
+     * @param node A resolved builder node
+     * @returns A list of resolved builder nodes
+     */
     getAllInlineNodes(node) {
         const inlineNodes = [];
         if (node.inlines.message) {
@@ -139,7 +170,12 @@ class ModuleTree {
         return inlineNodes;
     }
     /**
-     * In order to build nodes on the proper order, a set of layers must be stablished
+     * Build a list of layers (a _layer_ is a list of resolved builder nodes),
+     * each of which can be separately built, in a specific order, so all
+     * the dependencies of a node are built before the node itself.
+     *
+     * @param nodes A list of resolved builder nodes
+     * @returns A list of module tree layers
      */
     resolveLayers(nodes) {
         log_1.Log.debug('compiler', 'tree', 'Resolving Layers');
@@ -195,6 +231,12 @@ class ModuleTree {
         });
         return layers;
     }
+    /**
+     * Traverse tree layers and run the callback `fn` for each node of each layer.
+     *
+     * @param actionAlias Action alias to be logged
+     * @param fn Callback to be run for each node
+     */
     async traverse(actionAlias, fn) {
         for (let i = 0; i < this.layers.length; i++) {
             const layer = this.layers[i];
@@ -204,26 +246,25 @@ class ModuleTree {
             }
         }
     }
+    /**
+     * Get schema of a dependency-like object.
+     *
+     * @param node A dependency-like object
+     * @return An element schema
+     */
     getSchema(node) {
         const mod = this.modules[node.module];
-        if (node.type === 'constants')
-            return mod.schema.constants;
-        if (node.type === 'externals')
-            return mod.schema.externals;
-        if (node.type === 'bucket')
-            return mod.schema.buckets[node.name];
-        if (node.type === 'message')
-            return mod.schema.messages[node.name];
-        if (node.type === 'job')
-            return mod.schema.jobs[node.name];
-        if (node.type === 'resource')
-            return mod.schema.resources[node.name];
-        if (node.type === 'machine')
-            return mod.schema.machines[node.name];
-        if (node.type === 'controller')
-            return mod.schema.controllers[node.name];
-        throw error_1.CompilerError.UnmetDependency('tree', node.name);
+        const schema = dependency_1.$Dependency.resolve(mod.schema, node);
+        if (!schema) {
+            throw error_1.CompilerError.UnmetDependency('tree', node.name);
+        }
+        return schema;
     }
+    /**
+     * Return a list of all nodes of all modules on the tree.
+     *
+     * @returns A list of resolved builder nodes
+     */
     allNodes() {
         const nodes = [];
         for (const layer of this.layers) {

package/lib/engine/util/mime.d.ts

@@ -1,8 +1,8 @@
 export declare class Mime {
-    static ofFilepath(filepath: string): {
-        extname: string;
-        mimetype: string;
-    };
+    /**
+     * extname without '.'
+     */
+    static ofExtname(extname: string): string;
 }
 declare const types: {
     [key: string]: string[];

package/lib/engine/util/mime.js

@@ -1,23 +1,21 @@
 "use strict";
 // Taken from [mime](https://github.com/broofa/mime)
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mime = void 0;
-const path_1 = __importDefault(require("path"));
 class Mime {
-    static ofFilepath(filepath) {
-        let extname = path_1.default.extname(filepath);
+    /**
+     * extname without '.'
+     */
+    static ofExtname(extname) {
         if (!extname.length)
-            return { extname, mimetype: '' };
+            return '';
         extname = extname.slice(1);
         for (const type in types) {
             if (types[type].includes(extname)) {
-                return { extname, mimetype: type };
+                return type;
             }
         }
-        return { extname, mimetype: '' };
+        return '';
     }
 }
 exports.Mime = Mime;

package/lib/schema.d.ts

@@ -7,7 +7,7 @@ import { $Bucket } from './elements/entities/bucket/bucket.schema';
 import { $Job } from './elements/blocks/job/job.schema';
 import { $Resource } from './elements/blocks/resource/resource.schema';
 import { $Queue } from './elements/blocks/queue/queue.schema';
-import { $Externals } from './elements/blocks/externals/externals.schema';
+import { $Externals } from './elements/edge/externals/externals.schema';
 export type BuilderType = 'constants' | 'externals' | 'message' | 'bucket' | 'job' | 'resource' | 'machine' | 'controller' | 'queue';
 export type $Space = {
     authnUsers: {
@@ -44,7 +44,7 @@ export type $Module = {
     };
     '#input': $Message;
     '#authn': AnyUsers;
-    '#providers': Record<string, any>;
+    '#services': Record<string, any>;
 };
 export type ModuleName<$ extends $Space> = keyof $['modules'];
 export type MessageName<$ extends $Module> = keyof $['messages'];

package/package.json

@@ -1,14 +1,13 @@
 {
     "name": "nesoi",
-    "version": "3.0.8",
+    "version": "3.0.10",
     "description": "Declarative framework for data-driven applications",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/nesoi-org/nesoi.git"
     },
     "keywords": [
-        "nesoi",
-        "postgresql"
+        "nesoi"
     ],
     "author": "Hugo Aboud",
     "license": "MIT",

package/tools/joaquin/job.js

@@ -34,8 +34,8 @@ function expectJob(def) {
             try {
                 const status = await promise;
                 expect(status.state).toEqual('error');
-                expect(status.error)
-                    .toMatch(new RegExp(`^\\[${errorObj.name}\\]`));
+                expect(status.error?.name)
+                    .toEqual(errorObj.name);
             }
             catch (e) {
                 expect(e.toString())

package/tools/joaquin/message.js

@@ -33,8 +33,8 @@ function expectMessage(def) {
                 const status = await promise;
                 status.forEach(st => {
                     expect(st.state).toEqual('error');
-                    expect(st.error)
-                        .toMatch(new RegExp(`^\\[${errorObj.name}\\]`));
+                    expect(st.error?.name)
+                        .toEqual(errorObj.name);
                 });
             }
             catch (e) {

package/tools/joaquin/mock.d.ts

@@ -1,9 +1,9 @@
-import { $Bucket, $Message, $Module, $Space } from "../../src/elements";
-import { Daemon } from "../../src/engine/daemon";
-import { NesoiDate } from "../../src/engine/data/date";
-import { NesoiDatetime } from "../../src/engine/data/datetime";
-import { NesoiDecimal } from "../../src/engine/data/decimal";
-import { DeepPartial } from "../../src/engine/util/deep";
+import { $Bucket, $Message, $Module, $Space } from "../../lib/elements";
+import { Daemon } from "../../lib/engine/daemon";
+import { NesoiDate } from "../../lib/engine/data/date";
+import { NesoiDatetime } from "../../lib/engine/data/datetime";
+import { NesoiDecimal } from "../../lib/engine/data/decimal";
+import { DeepPartial } from "../../lib/engine/util/deep";
 export declare class BucketMockObj<$ extends $Bucket, T> {
     private module;
     private bucketName;