nesoi 3.0.0 → 3.0.6

package/lib/compiler/apps/monolyth/monolyth_compiler.js

@@ -50,6 +50,7 @@ const _2_build_typescript_stage_1 = require("./stages/2_build_typescript_stage")
 const log_1 = require("../../../engine/util/log");
 const app_1 = require("../../../engine/apps/app");
 const monolyth_app_1 = require("../../../engine/apps/monolyth/monolyth.app");
+const path_1 = require("../../../engine/util/path");
 class MonolythCompiler {
     constructor(compiler, appPath, config = {}) {
         this.compiler = compiler;
@@ -63,6 +64,8 @@ class MonolythCompiler {
         const appFile = space_1.Space.path(this.compiler.space, this.appPath);
         const app = (await Promise.resolve(`${appFile}`).then(s => __importStar(require(s)))).default;
         this.config = Object.assign({}, app_1.App.getInfo(app).config?.compiler || {}, this.config);
+        this.mergeProviderPaths(app);
+        this.expandLibPaths();
         try {
             await new _1_mkdir_stage_1.MkdirStage(this, app).run();
             await new _2_build_typescript_stage_1.BuildTypescriptStage(this, app).run();
@@ -76,6 +79,27 @@ class MonolythCompiler {
             process.exit();
         }
     }
+    mergeProviderPaths(app) {
+        var _a;
+        const providers = app_1.App.getProviders(app);
+        for (const name in providers) {
+            const provider = providers[name];
+            if (!provider.libPaths)
+                continue;
+            (_a = this.config).libPaths ?? (_a.libPaths = []);
+            this.config.libPaths.push(...provider.libPaths);
+        }
+    }
+    expandLibPaths() {
+        var _a;
+        const expandedPaths = [];
+        (_a = this.config).libPaths ?? (_a.libPaths = []);
+        for (const path of this.config.libPaths) {
+            const expanded = path_1.Path.expandWildcard(path);
+            expandedPaths.push(...expanded);
+        }
+        this.config.libPaths = expandedPaths;
+    }
     static async scanAll(dir) {
         const apps = [];
         const nodes = fs.readdirSync(dir, { withFileTypes: true });

package/lib/compiler/apps/monolyth/stages/2_build_typescript_stage.js

@@ -80,7 +80,8 @@ class BuildTypescriptStage {
         if (config.nesoiPath) {
             tsPaths['nesoi/*'] = [`${config.nesoiPath}/*`];
         }
-        this.monolyth.config.libPaths?.forEach(lib => {
+        libPaths.forEach(lib => {
+            lib = space_1.Space.relPath(compiler.space, lib);
             replacePaths[lib] = path.resolve(dirs.build, lib);
             tsPaths['.nesoi/*'] = [space_1.Space.path(compiler.space, '.nesoi') + '/*'];
             tsPaths[lib + '/*'] = [space_1.Space.path(compiler.space, lib) + '/*'];

package/lib/compiler/apps/monolyth/stages/5_dump_cli_stage.js

@@ -50,7 +50,7 @@ class DumpCLIStage {
         log_1.Log.info('compiler', 'monolyth', 'Dumping cli.js file to build/bin folder...');
         const { dirs } = this.monolyth;
         let str = '';
-        str += 'require("dotenv/config");\n';
+        str += 'require("nesoi/tools/dotenv");\n';
         str += 'const app = require(\'../app\').default\n';
         str += 'const { Log } = require(\'nesoi/lib/engine/util/log\');\n';
         str += 'Log.level = \'debug\';\n';

package/lib/compiler/apps/monolyth/stages/6_dump_package_json_stage.js

@@ -51,7 +51,7 @@ class DumpPackageJsonStage {
     async run() {
         log_1.Log.info('compiler', 'monolyth', 'Dumping package.json to build folder...');
         const { config, compiler, dirs } = this.monolyth;
-        const nesoiPackageJson = await Promise.resolve(`${`${config.nesoiPath || 'node_modules/nesoi'}/package.json`}`).then(s => __importStar(require(s)));
+        const nesoiPackageJson = await Promise.resolve(`${`${config.nesoiPath || path.join('..', '..', '..', '..', '..', 'package.json')}`}`).then(s => __importStar(require(s)));
         const spacePackageJson = await Promise.resolve(`${space_1.Space.path(compiler.space, 'package.json')}`).then(s => __importStar(require(s)));
         const filePath = path.resolve(dirs.build, 'package.json');
         const scripts = {

package/lib/compiler/elements/bucket.element.js

@@ -76,9 +76,9 @@ class BucketElement extends element_1.Element {
             type = 'NesoiDatetime';
         }
         else if (field.type === 'enum') {
-            const options = field._enum.options;
+            const options = field.meta.enum.options;
             if (typeof options === 'string') {
-                const constants = this.compiler.tree.getSchema(field._enum.dep);
+                const constants = this.compiler.tree.getSchema(field.meta.enum.dep);
                 const constName = name_helpers_1.NameHelpers.names(constants);
                 const tag = dependency_1.$Tag.parseOrFail(options);
                 if (tag.module || constants.module !== this.module) {
@@ -97,7 +97,7 @@ class BucketElement extends element_1.Element {
             }
         }
         else if (field.type === 'file') {
-            type = 'File';
+            type = 'NesoiFile';
         }
         else if (field.type === 'float') {
             type = 'number';
@@ -116,10 +116,10 @@ class BucketElement extends element_1.Element {
         }
         else if (field.type === 'dict') {
             type = this.buildModelType({
-                '[x: string]': field.children.__dict
+                '[x in string]': field.children.__dict
             });
         }
-        if (!field.required && !field.defaultValue) {
+        if (!field.required && field.defaultValue === undefined) {
             if (typeof type === 'object') {
                 type.__optional = true;
             }
@@ -136,9 +136,17 @@ class BucketElement extends element_1.Element {
             }
         }
         if (field.or) {
-            type = dump_helpers_1.DumpHelpers.dumpType(type, 4)
-                + ' | '
-                + dump_helpers_1.DumpHelpers.dumpType(this.buildModelFieldType(field.or), 4);
+            const orType = this.buildModelFieldType(field.or);
+            if (typeof type === 'object') {
+                type.__or = orType;
+            }
+            else if (typeof orType === 'object') {
+                type = orType;
+                type.__or = orType;
+            }
+            else {
+                type = `${type} | ${orType}`;
+            }
         }
         return type;
     }
@@ -176,10 +184,10 @@ class BucketElement extends element_1.Element {
                 let nextKey = keyPath;
                 if ('__dict' in field.children) {
                     nextFields = field.children.__dict.children;
-                    nextKey += '.*';
+                    nextKey += '.#';
                 }
                 if (field.array)
-                    nextKey += '.*';
+                    nextKey += '.#';
                 if (nextFields) {
                     Object.assign(fieldPaths, this.buildModelFieldNamesType(model[key], nextFields, nextKey));
                 }
@@ -258,6 +266,12 @@ class BucketElement extends element_1.Element {
                     children: children.fields
                 };
             }
+            else if (field.scope === 'drive') {
+                fields[key] = {
+                    '#data': 'string',
+                    children: 'undefined'
+                };
+            }
             const { children, ...f } = field;
             const type = dump_helpers_1.DumpHelpers.dumpValueToType(f, {
                 $t: () => dump_helpers_1.DumpHelpers.dumpValueToType('bucket.view.field'),
@@ -269,7 +283,8 @@ class BucketElement extends element_1.Element {
                     graph: v => ({
                         link: dump_helpers_1.DumpHelpers.dumpValueToType(v.link),
                         view: v.view ? dump_helpers_1.DumpHelpers.dumpValueToType(v.view) : 'undefined'
-                    })
+                    }),
+                    drive: v => dump_helpers_1.DumpHelpers.dumpValueToType(v)
                 }
             });
             Object.assign(fields[key], type);

package/lib/compiler/elements/constants.element.js

@@ -75,7 +75,7 @@ class ConstantsElement extends element_1.Element {
                 _subs: 'never'
             };
             if (_subs.length) {
-                paths[path + key + '.*'] = {
+                paths[path + key + '.#'] = {
                     _enum: _enum,
                     _subs: _subs.map(v => `'${v}'`).join(' | ')
                 };

package/lib/compiler/elements/element.d.ts

@@ -10,6 +10,7 @@ export type TypeAsObj = string | ({
 } & {
     __array?: boolean;
     __optional?: boolean;
+    __or?: TypeAsObj;
 });
 export type ObjTypeAsObj = TypeAsObj & Record<string, any>;
 export declare abstract class Element<T extends AnyElementSchema> {
@@ -40,6 +41,7 @@ export declare abstract class Element<T extends AnyElementSchema> {
     } & {
         __array?: boolean;
         __optional?: boolean;
+        __or?: TypeAsObj;
     } & Record<string, any>) | "{}";
     static makeIOType(compiler: Compiler, schema: $Job | $Machine | $MachineState | $MachineTransition | $Queue): {
         input: string;

package/lib/compiler/elements/message.element.js

@@ -91,8 +91,8 @@ class MessageElement extends element_1.Element {
                 }
             }
             else if (field.type === 'file') {
-                input[key] = 'File';
-                output[key] = 'File';
+                input[key] = 'NesoiFile';
+                output[key] = 'NesoiFile';
             }
             else if (field.type === 'float') {
                 input[key] = 'number';
@@ -124,10 +124,10 @@ class MessageElement extends element_1.Element {
             else if (field.type === 'dict') {
                 const child = this.buildIO(field.children);
                 input[key] = {
-                    '[x: string]': child.input.__dict
+                    '[x in string]': child.input.__dict
                 };
                 output[key] = {
-                    '[x: string]': child.output.__dict
+                    '[x in string]': child.output.__dict
                 };
             }
             else if (field.type === 'msg') {

package/lib/compiler/helpers/dump_helpers.js

@@ -26,7 +26,7 @@ class DumpHelpers {
         else {
             str = '{\n' +
                 Object.entries(type)
-                    .filter(([key]) => key !== '__array' && key !== '__optional')
+                    .filter(([key]) => !['__array', '__optional', '__or'].includes(key))
                     .map(([key, value]) => {
                     let k = key;
                     // If key is not a special [],
@@ -54,8 +54,11 @@ class DumpHelpers {
                 + `\n${pad0}}`;
         }
         if (typeof type === 'object') {
+            if (type.__or) {
+                str += ' | ' + this.dumpType(type.__or, d);
+            }
             if (type.__array) {
-                str += '[]';
+                str = `(${str})[]`;
             }
             if (type.__optional) {
                 str += ' | undefined';

package/lib/compiler/stages/7_dump_stage.js

@@ -113,6 +113,8 @@ class DumpStage {
         moduleFile.push(`import { $Module, $Constants, $Bucket, $Message, $Job, $Resource, $Machine, $Controller, $Queue } from '${nesoiPath}/lib/elements';`);
         moduleFile.push(`import { NesoiDate } from '${nesoiPath}/lib/engine/data/date';`);
         moduleFile.push(`import { NesoiDatetime } from '${nesoiPath}/lib/engine/data/datetime';`);
+        moduleFile.push(`import { NesoiDecimal } from '${nesoiPath}/lib/engine/data/decimal';`);
+        moduleFile.push(`import { NesoiFile } from '${nesoiPath}/lib/engine/data/file';`);
         // Build module type (with all blocks)
         const type = {
             name: `'${module.lowName}'`,

package/lib/compiler/treeshake.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Treeshake = void 0;
 const dependency_1 = require("../engine/dependency");
@@ -78,8 +45,8 @@ class Treeshake {
     static bucketModelFields(node, fields) {
         const dependencies = [];
         Object.values(fields).forEach(field => {
-            if (field._enum?.dep) {
-                dependencies.push(field._enum.dep);
+            if (field.meta?.enum?.dep) {
+                dependencies.push(field.meta?.enum.dep);
             }
             if (field.children?.length) {
                 dependencies.push(...Treeshake.bucketModelFields(node, field.children));
@@ -289,12 +256,17 @@ class Treeshake {
      */
     static async file(module, filepath) {
         log_1.Log.debug('compiler', 'treeshake', ` └ Treeshaking file ${(0, string_1.colored)(filepath, 'blue')}`);
-        const fileBuilders = await Promise.resolve(`${filepath}`).then(s => __importStar(require(s)));
+        // Require is used here to avoid cache - which allows watch mode
+        delete require.cache[filepath];
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fileBuilders = require(filepath);
         const nodes = [];
         for (const key in fileBuilders) {
             const builder = fileBuilders[key];
             if (!builder.$b) {
-                log_1.Log.warn('compiler', 'treeshake', `No builder found on file ${filepath}, move it to a library folder or it won't work on the built version.`);
+                // TODO: check lib paths to re-enable this message
+                // without annoying
+                // Log.warn('compiler', 'treeshake', `No builder found on file ${filepath}, move it to a library folder or it won't work on the built version.`);
                 continue;
             }
             nodes.push(...Treeshake.builder(module, builder, filepath));

package/lib/compiler/typescript/bridge/extract.js

@@ -130,6 +130,10 @@ class TSBridgeExtract {
                 query: 'resource.*.create.0.return.input.0.return.**.rule.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.create.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
             functions.push(...tsCompiler.query(node.filepath, {
                 query: 'resource.*.create.0.return.assert.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
@@ -146,6 +150,10 @@ class TSBridgeExtract {
                 query: 'resource.*.update.0.return.input.0.return.**.rule.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.update.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
             functions.push(...tsCompiler.query(node.filepath, {
                 query: 'resource.*.update.0.return.assert.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
@@ -162,6 +170,10 @@ class TSBridgeExtract {
                 query: 'resource.*.delete.0.return.input.0.return.**.rule.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.delete.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
             functions.push(...tsCompiler.query(node.filepath, {
                 query: 'resource.*.delete.0.return.assert.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]

package/lib/compiler/typescript/bridge/inject.js

@@ -75,6 +75,9 @@ class TSBridgeInject {
         const { tsCompiler } = compiler;
         const schema = node.schema;
         if (extract.extrasAndAsserts) {
+            if (extract.extrasAndAsserts.length !== schema.extrasAndAsserts.length) {
+                throw new Error(`Mismatching length of extracted asserts/extras for job ${schema.module}::${schema.name}. Expected ${schema.extrasAndAsserts.length}, but found ${extract.extrasAndAsserts.length}`);
+            }
             schema.extrasAndAsserts = extract.extrasAndAsserts.map(e => {
                 const t = Object.keys(e)[0];
                 return {

package/lib/compiler/typescript/bridge/organize.js

@@ -239,13 +239,13 @@ class TSBridgeOrganize {
             nElses++;
         extract.transitions ?? (extract.transitions = {});
         (_a = extract.transitions)[msg] ?? (_a[msg] = []);
-        const trans = extract.transitions[msg];
+        const trans = extract.transitions?.[msg];
+        const condition = path.match(/if▹0$/);
         if (trans.length < nElses) {
             trans.push(...Array(nElses - trans.length).map(() => ({})));
         }
-        const condition = path.match(/if▹0$/);
         if (condition) {
-            trans[nElses].if = node;
+            trans.push({ if: node });
         }
         const job = path.match(/runJob▹0▹return/);
         if (job) {

package/lib/elements/blocks/block.builder.js

@@ -32,6 +32,7 @@ class BlockBuilder {
         const schema = def(builder);
         for (const key in schema) {
             const name = `${this.name}${key.length ? ('.' + key) : ''}`;
+            this._inputMsgs.push(new dependency_1.$Dependency(this.module, 'message', name));
             const builder = new message_builder_1.MessageBuilder(this.module, name)
                 .template(() => schema[key]);
             this._inlineNodes.push(new dependency_1.BuilderNode({
@@ -56,9 +57,10 @@ class BlockBuilder {
     }
     // Input/Output
     _input(...names) {
-        this._inputMsgs = names.map((name) => {
+        names.forEach((name) => {
             const fullName = name_helpers_1.NameHelpers.unabbrevName(name, this.name);
-            return new dependency_1.$Dependency(this.module, 'message', fullName);
+            const dep = new dependency_1.$Dependency(this.module, 'message', fullName);
+            this._inputMsgs.push(dep);
         });
         return this;
     }

package/lib/elements/blocks/job/internal/resource_job.builder.d.ts

@@ -9,15 +9,17 @@ import { TrxNode } from "../../../../engine/transaction/trx_node";
 import { ModuleTree } from "../../../../engine/tree";
 import { BlockBuilder } from '../../block.builder';
 import { ResolvedBuilderNode } from "../../../../engine/dependency";
-import { AnyQuery } from "../../../entities/bucket/query/nql.schema";
+import { NQL_AnyQuery } from "../../../entities/bucket/query/nql.schema";
 import { $Bucket } from "../../../entities/bucket/bucket.schema";
 import { $BlockOutput } from '../../block.schema';
 export type ResourceAssertions<Bucket extends $Bucket> = {
-    'query is empty': AnyQuery<any, any>;
+    'query is empty': NQL_AnyQuery;
     'has no link': keyof Bucket['graph']['links'];
 };
-export type ResourceAssertionDef<Bucket extends $Bucket> = <T extends keyof ResourceAssertions<Bucket>>(type: T, arg: ResourceAssertions<Bucket>[T]) => boolean;
-export declare class ResourceJobBuilder<Space extends $Space, Module extends $Module, Name extends string, Prepared, Authn extends AnyUsers = {}, Bucket extends $Bucket = never, ImplicitInput = {}, Trigger extends $Message = never, MsgExtras = {}, Ctx = {}, CtxAfter = {}> extends BlockBuilder<Space, Module, 'job'> {
+export type ResourceAssertionDef<Bucket extends $Bucket> = <T extends keyof ResourceAssertions<Bucket>>(type: T, arg: ResourceAssertions<Bucket>[T]) => {
+    else: (error: string) => Promise<true | string>;
+};
+export declare class ResourceJobBuilder<Space extends $Space, Module extends $Module, Name extends string, Prepared, Authn extends AnyUsers = {}, Bucket extends $Bucket = never, RequiredInput = {}, Trigger extends $Message = never, MsgExtras = {}, Ctx = {}, CtxAfter = {}> extends BlockBuilder<Space, Module, 'job'> {
     protected module: string;
     protected name: Name;
     protected bucket: string;
@@ -40,25 +42,25 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
      *
      * @param def A `$ => ({})` definition for a custom trigger message
      */
-    input<Def extends MessageTemplateDef<Space, Module, Name>>(def: Def): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, ImplicitInput, $MessageInfer<Name, any, ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': ImplicitInput[K];
-    }, any, [never, never], [never, never]>; }, import("../../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': ImplicitInput[K];
-    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': ImplicitInput[K];
-    }, any, [never, never], [never, never]>; } extends infer T ? { [K_1 in keyof T]: (ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': ImplicitInput[K];
+    input<Def extends MessageTemplateDef<Space, Module, Name>>(def: Def): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, RequiredInput, $MessageInfer<Name, any, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': RequiredInput[K];
+    }, any, [never, never], [never, never]>; }, import("../../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': RequiredInput[K];
+    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': RequiredInput[K];
+    }, any, [never, never], [never, never]>; } extends infer T ? { [K_1 in keyof T]: (ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': RequiredInput[K];
     }, any, [never, never], [never, never]>; })[K_1] extends MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
         path: `${K_1 & string}${keyof I & string}`;
         data: I[keyof I];
         opt: Opt[0];
         nul: Nul[0];
-    } : never; } : never>, import("../../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': ImplicitInput[K];
-    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': ImplicitInput[K];
-    }, any, [never, never], [never, never]>; } extends infer T_1 ? { [K_2 in keyof T_1]: (ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': ImplicitInput[K];
+    } : never; } : never>, import("../../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': RequiredInput[K];
+    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': RequiredInput[K];
+    }, any, [never, never], [never, never]>; } extends infer T_1 ? { [K_2 in keyof T_1]: (ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': RequiredInput[K];
     }, any, [never, never], [never, never]>; })[K_2] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
         path: `${K_2 & string}${keyof O & string}`;
         data: O[keyof O];
@@ -73,7 +75,7 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
      */
     extra<Extra extends {
         [_: string]: any;
-    }, Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, PreviousExtras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>($: $JobMethod<Trx, Msg, Extra, PreviousExtras, C>): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, ImplicitInput, Trigger, MsgExtras & Extra, Ctx, CtxAfter>;
+    }, Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, PreviousExtras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>($: $JobMethod<Trx, Msg, Extra, PreviousExtras, C>): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, RequiredInput, Trigger, MsgExtras & Extra, Ctx, CtxAfter>;
     /**
      * A function that checks a given condition over the input and throws an exception;
      * This assertion runs before the job method.
@@ -102,7 +104,7 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
     };
 }
 export type AnyResourceJobBuilder = ResourceJobBuilder<any, any, any, any, any, any>;
-export type ResourceJobDef<S extends $Space, M extends $Module, Name extends string, Prepared, Authn extends AnyUsers, Bucket extends $Bucket, DefaultTrigger extends $Message = never, ImplicitInput = {}, Ctx = {}, CtxAfter = {}> = ($: ResourceJobBuilder<S, M, Name, Prepared, Authn, Bucket, ImplicitInput, DefaultTrigger, {}, Ctx, CtxAfter>) => any;
+export type ResourceJobDef<S extends $Space, M extends $Module, Name extends string, Prepared, Authn extends AnyUsers, Bucket extends $Bucket, DefaultTrigger extends $Message = never, RequiredInput = {}, Ctx = {}, CtxAfter = {}> = ($: ResourceJobBuilder<S, M, Name, Prepared, Authn, Bucket, RequiredInput, DefaultTrigger, {}, Ctx, CtxAfter>) => any;
 export type ResourceJobBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
     builder: AnyResourceJobBuilder;
     schema?: $Job;

package/lib/elements/blocks/job/internal/resource_job.d.ts

@@ -5,8 +5,9 @@ export declare class ResourceJob {
     static method($: {
         trx: AnyTrxNode;
         msg: any;
+        obj: Record<string, any>;
         job: $Job;
-    }): Promise<any>;
+    }): Promise<Record<string, any> | undefined>;
     static prepareMsgData($: {
         msg: any;
     }): Promise<Omit<AnyMessage, "$" | "__meta__" | "getData">>;

package/lib/elements/blocks/job/internal/resource_job.js

@@ -1,14 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceJob = void 0;
+const trx_node_1 = require("../../../../engine/transaction/trx_node");
 class ResourceJob {
     static async method($) {
+        // Check authentication
+        trx_node_1.TrxNode.checkAuthn($.trx, $.job.authn);
+        // 
+        const id = $.msg.id;
         const scope = $.job.scope;
-        let obj;
-        if (scope.method === 'update' || scope.method === 'delete') {
-            obj = await $.trx.bucket(scope.bucket).readOneOrFail($.msg.id);
-        }
+        let obj = $.obj;
         obj = await scope.prepareMethod({ ...$, obj, bucket: scope.bucket });
+        // Preserve the original message ID (if any),
+        // even if the prepare method doesn't add it
+        if (scope.method === 'create' || scope.method === 'update') {
+            obj.id = id;
+        }
+        // On delete, the method returns a boolean, so replace it with the id. 
+        else {
+            if (!obj)
+                return;
+            obj = { id };
+        }
         if (scope.execMethod) {
             obj = await scope.execMethod({ ...$, obj, bucket: scope.bucket });
         }

package/lib/elements/blocks/job/job.js

@@ -7,6 +7,7 @@ exports.Job = void 0;
 const block_1 = require("../block");
 const promise_1 = __importDefault(require("../../../engine/util/promise"));
 const message_1 = require("../../entities/message/message");
+const trx_node_1 = require("../../../engine/transaction/trx_node");
 const error_1 = require("../../../engine/data/error");
 class Job extends block_1.Block {
     constructor(module, schema) {
@@ -15,6 +16,8 @@ class Job extends block_1.Block {
         this.schema = schema;
     }
     async run(trx, msg, _ctx = {}) {
+        // Check authentication
+        trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
         const _msg = message_1.Message.clone(msg);
         const extra = {};
         const ctx = { trx, msg: _msg, extra, job: this.schema };

package/lib/elements/blocks/job/job.types.d.ts

@@ -0,0 +1,7 @@
+import { $Job } from "../..";
+import { Overlay } from "../../../engine/util/type";
+export type JobInput<Job extends $Job, IntrinsicMsg = Extract<Job['#input']['#raw'], {
+    $: Job['name'];
+}>> = Exclude<Job['#input']['#raw'], IntrinsicMsg> | (IntrinsicMsg extends never ? never : Overlay<IntrinsicMsg, {
+    $?: Job['name'];
+}>);

package/lib/elements/blocks/job/job.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/elements/blocks/machine/machine.js

@@ -114,7 +114,6 @@ class Machine extends block_1.Block {
     async _run(trx, _msg) {
         const output = new MachineOutput();
         const msg = message_1.Message.clone(_msg);
-        const ctx = { trx, msg };
         if (!msg.id) {
             throw error_1.NesoiError.Machine.MessageHasNoId(this.schema.alias);
         }
@@ -156,6 +155,7 @@ class Machine extends block_1.Block {
         for (const transition of transitions) {
             // Transition condition [ .if() ]
             if (transition.condition) {
+                const ctx = { trx, msg, obj };
                 const conditionResult = await transition.condition(ctx);
                 // Condition not met, save message as info and try next transition
                 if (conditionResult !== true) {
@@ -187,7 +187,7 @@ class Machine extends block_1.Block {
             if (this.schema.stateAliasField) {
                 obj[this.schema.stateAliasField] = nextState.alias;
             }
-            obj = await trx.bucket(bucketUsed.refName).put(obj);
+            obj = await trx.bucket(bucketUsed.refName).patch(obj);
             if (nextStateName !== stateName) {
                 MachineOutput.add(output, MachineOutputEntry.info_state_changed(state.name, nextState.name));
             }
@@ -198,6 +198,7 @@ class Machine extends block_1.Block {
             await this.runStateJob(trx, output, queue, state.jobs.afterLeave, msg, obj, state.name, state.name, 'after_leave', `Ran job '${state.jobs.afterLeave?.name}' after leaving '${state.name}'`);
             // Run "afterEnter" job of current state (which was the next until now)
             await this.runStateJob(trx, output, queue, nextState.jobs.afterEnter, msg, obj, state.name, nextState.name, 'after_enter', `Ran job '${nextState.jobs.afterEnter?.name}' after entering '${nextState.name}'`);
+            break;
         }
         // No transition run, 
         if (!nextState) {

package/lib/elements/blocks/resource/resource.builder.js

@@ -59,11 +59,9 @@ class ResourceBuilder extends block_builder_1.BlockBuilder {
         const jobBuilder = new resource_job_builder_1.ResourceJobBuilder(this.module, name, this._bucket.refName, 'query', alias, resource_1.Resource.query, this._authn)
             .input($ => ({
             view: $.enum(views).default(views[0]),
-            query: $.dict($.any),
+            query: $.dict($.any).default({}),
             perPage: $.int.default(10),
-            page: $.int.default(0),
-            orderBy: $.string.optional,
-            orderDesc: $.boolean.default(false)
+            page: $.int.default(0)
         }))
             .prepare(resource_job_1.ResourceJob.prepareMsgData);
         this._inlineNodes.push(new dependency_1.BuilderNode({

package/lib/elements/blocks/resource/resource.d.ts

@@ -27,7 +27,7 @@ export declare class Resource<S extends $Space, M extends $Module, $ extends $Re
         trx: AnyTrxNode;
         msg: any;
         job: $Job;
-    }): Promise<any[]>;
+    }): Promise<import("../../entities/bucket/query/nql_engine").NQL_Result<any>>;
     static create($: {
         trx: AnyTrxNode;
         obj: any;
@@ -42,7 +42,9 @@ export declare class Resource<S extends $Space, M extends $Module, $ extends $Re
         trx: AnyTrxNode;
         obj: any;
         job: $Job;
-    }): Promise<void> | undefined;
-    static assertThat(trx: AnyTrxNode, bucket: $Dependency, obj: NesoiObj | undefined, type: keyof ResourceAssertions<any>, arg: any): Promise<boolean | undefined>;
+    }): Promise<void>;
+    static assertThat(trx: AnyTrxNode, bucket: $Dependency, obj: NesoiObj | undefined, type: keyof ResourceAssertions<any>, arg: any): {
+        else: (error: string) => Promise<string | true>;
+    };
 }
 export type AnyResource = Resource<any, any, any>;