nesoi 3.0.9 → 3.0.10

package/lib/compiler/apps/monolyth/monolyth_compiler.d.ts

@@ -18,7 +18,7 @@ export declare class MonolythCompiler {
     };
     constructor(compiler: Compiler, appPath: string, config?: MonolythCompilerConfig);
     run(): Promise<void>;
-    mergeProviderPaths(app: AnyApp): void;
+    mergeServicePaths(app: AnyApp): void;
     expandLibPaths(): void;
     static scanAll(dir: string): Promise<MonolythApp<any, any, Record<string, any>>[] | undefined>;
 }

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

@@ -64,7 +64,7 @@ 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.mergeServicePaths(app);
         this.expandLibPaths();
         try {
             await new _1_mkdir_stage_1.MkdirStage(this, app).run();
@@ -79,15 +79,15 @@ class MonolythCompiler {
             process.exit();
         }
     }
-    mergeProviderPaths(app) {
+    mergeServicePaths(app) {
         var _a;
-        const providers = app_1.App.getProviders(app);
-        for (const name in providers) {
-            const provider = providers[name];
-            if (!provider.libPaths)
+        const services = app_1.App.getServices(app);
+        for (const name in services) {
+            const service = services[name];
+            if (!service.libPaths)
                 continue;
             (_a = this.config).libPaths ?? (_a.libPaths = []);
-            this.config.libPaths.push(...provider.libPaths);
+            this.config.libPaths.push(...service.libPaths);
         }
     }
     expandLibPaths() {

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

@@ -86,7 +86,18 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
         const input = Object.values(states)
             .map(state => state.input)
             .flat(1);
-        node.schema = new machine_schema_1.$Machine(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, node.builder._buckets, node.builder._stateField || 'state', states, transitions, node.builder._stateAliasField, node.builder._logger);
+        const jobs = [];
+        Object.values(states).forEach(state => {
+            jobs.push(...Object.values(state.jobs));
+        });
+        Object.values(transitions.from).forEach(stateTransitions => {
+            Object.values(stateTransitions).forEach(transitionList => {
+                transitionList.forEach(trans => {
+                    jobs.push(...trans.jobs);
+                });
+            });
+        });
+        node.schema = new machine_schema_1.$Machine(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, node.builder._buckets, jobs, node.builder._stateField || 'state', states, transitions, node.builder._stateAliasField, node.builder._logger);
         // Configure state jobs with proper input, based on transition targets
         const inlineJobsConfig = {};
         Object.values(states).forEach(state => {

package/lib/elements/blocks/machine/machine.schema.d.ts

@@ -75,6 +75,7 @@ export declare class $Machine extends $Block {
     authn: string[];
     input: $Dependency[];
     buckets: $Dependency[];
+    jobs: $Dependency[];
     stateField: string;
     states: $MachineStates;
     transitions: $MachineTransitions;
@@ -82,7 +83,7 @@ export declare class $Machine extends $Block {
     logger?: $MachineLogFn<any> | undefined;
     $t: "machine";
     '#data': unknown;
-    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], buckets: $Dependency[], stateField: string, states: $MachineStates, transitions: $MachineTransitions, stateAliasField?: string | undefined, logger?: $MachineLogFn<any> | undefined);
+    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], buckets: $Dependency[], jobs: $Dependency[], stateField: string, states: $MachineStates, transitions: $MachineTransitions, stateAliasField?: string | undefined, logger?: $MachineLogFn<any> | undefined);
 }
 /**
  * @category Schemas

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

@@ -49,7 +49,7 @@ exports.$MachineState = $MachineState;
  * @subcategory Block
  */
 class $Machine extends block_schema_1.$Block {
-    constructor(module, name, alias, authn, input, buckets, stateField, states, transitions, stateAliasField, logger) {
+    constructor(module, name, alias, authn, input, buckets, jobs, stateField, states, transitions, stateAliasField, logger) {
         super(module, name, alias, authn, input, {});
         this.module = module;
         this.name = name;
@@ -57,6 +57,7 @@ class $Machine extends block_schema_1.$Block {
         this.authn = authn;
         this.input = input;
         this.buckets = buckets;
+        this.jobs = jobs;
         this.stateField = stateField;
         this.states = states;
         this.transitions = transitions;

package/lib/elements/edge/controller/adapters/controller_adapter.d.ts

@@ -2,15 +2,17 @@ import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from '../controller.schema';
 import { AnyDaemon } from "../../../../engine/daemon";
 import { AuthnRequest } from "../../../../engine/auth/authn";
+import { $Module } from "../../..";
 export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
 /**
  * @category Adapters
  * @subcategory Edge
  */
 export declare abstract class ControllerAdapter {
+    protected module: $Module;
     protected schema: $Controller;
     protected daemon?: AnyDaemon;
-    constructor(schema: $Controller);
+    constructor(module: $Module, schema: $Controller);
     trx(fn: (trx: AnyTrxNode) => Promise<any>, authn?: AuthnRequest<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
     bind(daemon: AnyDaemon): void;
     protected abstract makeEndpoint(path: string, schema: $ControllerEndpoint): void;

package/lib/elements/edge/controller/adapters/controller_adapter.js

@@ -7,7 +7,8 @@ const log_1 = require("../../../../engine/util/log");
  * @subcategory Edge
  */
 class ControllerAdapter {
-    constructor(schema) {
+    constructor(module, schema) {
+        this.module = module;
         this.schema = schema;
     }
     async trx(fn, authn) {

package/lib/elements/edge/controller/controller.config.d.ts

@@ -1,6 +1,7 @@
+import { $Module } from "../..";
 import { ControllerAdapter } from './adapters/controller_adapter';
 import { $Controller } from './controller.schema';
-export type ControllerConfig<B extends $Controller, Providers extends Record<string, any>> = {
+export type ControllerConfig<M extends $Module, B extends $Controller, Services extends Record<string, any>> = {
     /** Adapter used by this Controller to communicate with a data source */
-    adapter?: (schema: B, providers: Providers) => ControllerAdapter;
+    adapter?: (module: M, schema: B, services: Services) => ControllerAdapter;
 };

package/lib/elements/edge/controller/controller.d.ts

@@ -18,10 +18,10 @@ export declare class ControllerEndpoint<$ extends $ControllerEndpoint> {
 }
 export declare class Controller<S extends $Space, M extends $Module, $ extends $Controller> {
     schema: $;
-    config?: ControllerConfig<$, any> | undefined;
-    providers: Record<string, any>;
+    config?: ControllerConfig<M, $, any> | undefined;
+    services: Record<string, any>;
     adapter: ControllerAdapter;
-    constructor(module: Module<S, M>, schema: $, config?: ControllerConfig<$, any> | undefined, providers?: Record<string, any>);
+    constructor(module: Module<S, M>, schema: $, config?: ControllerConfig<M, $, any> | undefined, services?: Record<string, any>);
     bind(daemon: AnyDaemon): void;
 }
 export type AnyController = Controller<any, any, any>;

package/lib/elements/edge/controller/controller.js

@@ -34,11 +34,11 @@ class ControllerEndpoint {
 }
 exports.ControllerEndpoint = ControllerEndpoint;
 class Controller {
-    constructor(module, schema, config, providers = {}) {
+    constructor(module, schema, config, services = {}) {
         this.schema = schema;
         this.config = config;
-        this.providers = providers;
-        this.adapter = config?.adapter?.(schema, providers) || new cli_controller_adapter_1.CLIControllerAdapter(schema);
+        this.services = services;
+        this.adapter = config?.adapter?.(module.schema, schema, services) || new cli_controller_adapter_1.CLIControllerAdapter(module.schema, schema);
     }
     bind(daemon) {
         this.adapter.bind(daemon);

package/lib/elements/entities/bucket/adapters/bucket_adapter.d.ts

@@ -28,7 +28,8 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
      */
     protected abstract deleteEverything(trx: AnyTrxNode): Promise<void>;
     /**
-     * Return one entity by ID
+     * Return one entity by ID.
+     * - This method MUST NOT throw an exception if not found. The exception is thrown by Nesoi.
      */
     abstract get(trx: AnyTrxNode, id: Obj['id']): Promise<undefined | Obj>;
     /**

package/lib/elements/entities/bucket/bucket.config.d.ts

@@ -2,11 +2,11 @@ import { $Module } from "../..";
 import { BucketAdapter } from './adapters/bucket_adapter';
 import { $Bucket } from './bucket.schema';
 import { DriveAdapter } from '../drive/drive_adapter';
-export type BucketConfig<M extends $Module, B extends $Bucket, Providers extends Record<string, any>> = {
+export type BucketConfig<M extends $Module, B extends $Bucket, Services extends Record<string, any>> = {
     /** Adapter used by this bucket to communicate with a data source */
-    adapter?: (schema: B, providers: Providers) => BucketAdapter<B['#data']>;
+    adapter?: (schema: B, services: Services) => BucketAdapter<B['#data']>;
     /** Drive Adapter used by this bucket to write/read files */
-    drive?: (schema: B, providers: Providers) => DriveAdapter;
+    drive?: (schema: B, services: Services) => DriveAdapter;
     /** Settings for the app cache of this bucket */
     cache?: {
         /** Inner adapter used by the cache to manage cache entry data */

package/lib/elements/entities/bucket/bucket.d.ts

@@ -10,6 +10,7 @@ import { CreateObj, PatchObj, PutObj } from './bucket.types';
 import { NQL_Result } from './query/nql_engine';
 import { $BucketModelFields } from './model/bucket_model.schema';
 import { DriveAdapter } from '../drive/drive_adapter';
+import { IService } from "../../../engine/apps/service";
 /**
  * **This should only be used inside a `#composition` of a bucket `create`** to refer to the parent id, which doesn't exist yet.
  *
@@ -27,13 +28,13 @@ export declare const $id: string | number;
 export declare class Bucket<M extends $Module, $ extends $Bucket> {
     schema: $;
     private config?;
-    providers: Record<string, any>;
+    services: Record<string, IService>;
     adapter: BucketAdapter<$['#data']>;
     private cache?;
     graph: BucketGraph<M, $>;
     private views;
     drive?: DriveAdapter;
-    constructor(schema: $, config?: BucketConfig<any, any, any> | undefined, providers?: Record<string, any>);
+    constructor(schema: $, config?: BucketConfig<any, any, any> | undefined, services?: Record<string, IService>);
     getQueryMeta(): {
         bucket: $;
         scope: string;

package/lib/elements/entities/bucket/bucket.js

@@ -27,12 +27,12 @@ exports.$id = Symbol('FUTURE ID OF CREATE');
  * @subcategory Entity
  * */
 class Bucket {
-    constructor(schema, config, providers = {}) {
+    constructor(schema, config, services = {}) {
         this.schema = schema;
         this.config = config;
-        this.providers = providers;
+        this.services = services;
         // Config
-        this.adapter = this.config?.adapter?.(schema, providers) || new memory_bucket_adapter_1.MemoryBucketAdapter(schema, {});
+        this.adapter = this.config?.adapter?.(schema, services) || new memory_bucket_adapter_1.MemoryBucketAdapter(schema, {});
         // Graph
         this.graph = new bucket_graph_1.BucketGraph(this);
         // Views
@@ -47,7 +47,7 @@ class Bucket {
         }
         // Drive
         if (this.config?.drive) {
-            this.drive = this.config.drive(schema, providers);
+            this.drive = this.config.drive(schema, services);
         }
     }
     // Getters

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

@@ -5,6 +5,7 @@ import { ControllerConfig } from "../../elements/edge/controller/controller.conf
 import { TrxEngineConfig } from '../transaction/trx_engine.config';
 import { CompilerConfig } from "../../compiler/compiler";
 import { App } from './app';
+import { IService } from './service';
 import { CLIConfig } from '../cli/cli';
 import { BucketAdapter } from "../../elements/entities/bucket/adapters/bucket_adapter";
 import { TrashObj } from '../data/trash';
@@ -27,9 +28,9 @@ export type AppI18nConfig = {
 export type AppAuthnConfig<S extends $Space> = {
     [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<{
+export type AppBucketConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = Partial<{
     [M in (Modules & keyof S['modules'])]: Partial<{
-        [K in keyof S['modules'][M]['buckets']]: BucketConfig<S['modules'][M], S['modules'][M]['buckets'][K], Providers>;
+        [K in keyof S['modules'][M]['buckets']]: BucketConfig<S['modules'][M], S['modules'][M]['buckets'][K], Services>;
     }>;
 }>;
 export type AppTrashConfig = {
@@ -37,13 +38,13 @@ export type AppTrashConfig = {
         '#data': TrashObj;
     }>) => BucketAdapter<TrashObj>;
 };
-export type AppControllerConfig<S extends $Space, Modules extends ModuleName<S>, Providers extends Record<string, any>> = Partial<{
+export type AppControllerConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = Partial<{
     [M in (Modules & keyof S['modules'])]: Partial<{
-        [K in keyof S['modules'][M]['controllers']]: ControllerConfig<S['modules'][M]['controllers'][K], Providers>;
+        [K in keyof S['modules'][M]['controllers']]: ControllerConfig<S['modules'][M], S['modules'][M]['controllers'][K], Services>;
     }>;
 }>;
-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 type AppTrxEngineConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = Partial<{
+    [M in (Modules & keyof S['modules'])]: TrxEngineConfig<S, S['modules'][M], any, Services>;
 }>;
 export type AppAuditConfig = {
     adapter: ($: Overlay<$Bucket, {
@@ -57,17 +58,17 @@ export type AppAuditConfig = {
 /**
  * @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>> {
+export declare class AppConfigFactory<S extends $Space, Modules extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>, _App = App<S, Modules, Services>> {
     private app;
     private config;
     constructor(app: _App);
     i18n(config: AppI18nConfig): _App;
     authn(config: AppAuthnConfig<S>): _App;
-    buckets(config: AppBucketConfig<S, Modules, Providers>): _App;
+    buckets(config: AppBucketConfig<S, Modules, Services>): _App;
     trash(config: AppTrashConfig): _App;
-    controllers(config: AppControllerConfig<S, Modules, Providers>): _App;
+    controllers(config: AppControllerConfig<S, Modules, Services>): _App;
     audit(config: AppI18nConfig): _App;
     compiler(config: CompilerConfig): _App;
-    cli(config: CLIConfig<Providers>): _App;
-    trx(config: AppTrxEngineConfig<S, Modules, Providers>): _App;
+    cli(config: CLIConfig<Services>): _App;
+    trx(config: AppTrxEngineConfig<S, Modules, Services>): _App;
 }

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

@@ -3,27 +3,16 @@ import { AnyBuilder, AnyModule } from '../module';
 import { Space } from '../space';
 import { Daemon } from '../daemon';
 import { AnyAppConfig, AppConfigFactory } from './app.config';
-/**
- * Provider
- */
-export type AppProvider<out Name, T> = {
-    name: Name;
-    up: ($: {
-        modules: Record<string, AnyModule>;
-    }) => T;
-    down: (provider: NoInfer<T>) => any;
-    libPaths?: string[];
-};
-export type AnyAppProvider = AppProvider<any, any>;
+import { IService } from './service';
 /**
  * @category App
  */
-export declare abstract class App<S extends $Space, Modules extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> {
+export declare abstract class App<S extends $Space, Modules extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> {
     name: string;
     protected _config: AnyAppConfig;
     protected _spaceModuleNames: ModuleName<S>[];
     protected _injectedModules: AnyModule[];
-    protected _providers: Record<string, AnyAppProvider>;
+    protected _services: Record<string, IService>;
     protected space?: Space<S>;
     protected builders?: AnyBuilder[];
     constructor(name: string, boot?: {
@@ -37,7 +26,7 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
      * This can be run without await before the daemon,
      * to preload the module in background.
      */
-    abstract boot(): App<S, Modules, Providers>;
+    abstract boot(): App<S, Modules, Services>;
     /**
      * Spawn a daemon for this app.
      */
@@ -48,7 +37,7 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
      * ⚠ This has no effect on apps without a `Space`, such as `InlineApp`.
      * @param modules A list of names of modules from the current `Space`.
      */
-    modules<M extends ModuleName<S>>(modules: M[]): App<S, M & Modules, Providers>;
+    modules<M extends ModuleName<S>>(modules: M[]): App<S, M & Modules, Services>;
     /**
      * Injects pre-built modules into this App.
      * These will be included on the Daemon once it starts.
@@ -57,16 +46,16 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
      */
     inject(modules: AnyModule[]): this;
     /**
-     * Declares a `Provider` with a given name.
+     * Declares a `Service`.
      *
-     * Providers are started and ended along with the daemon, and can be used on the App
+     * Services are started and ended along with the daemon, and can be used on the App
      * config to share globals between adapters and other methods.
-     * @param $ `AppProvider` with an `up` and `down` method to create/destroy the provider.
+     * @param $ object with an `up` and `down` method to create/destroy the service
      */
-    provider<Name extends string, T>($: AppProvider<Name, T>): App<S, Modules, Providers & { [K in Name]: T; }>;
-    get config(): AppConfigFactory<S, Modules, Providers>;
+    service<T extends IService>($: T): App<S, Modules, Services & { [K in T["name"]]: T; }>;
+    get config(): AppConfigFactory<S, Modules, Services>;
     protected makeModules(): Record<string, AnyModule>;
-    static getProviders(app: AnyApp): Record<string, AnyAppProvider>;
+    static getServices(app: AnyApp): Record<string, IService>;
     static getInfo(app: AnyApp): {
         spaceModules: (string | number | symbol)[];
         config: AnyAppConfig;

package/lib/engine/apps/app.js

@@ -21,10 +21,10 @@ class App {
         // running the daemon. These will be included on the daemon
         // once it's run.
         this._injectedModules = [];
-        // A list of providers, which are created and destroyed
+        // A list of services, which are created and destroyed
         // along with the daemon. These are internally available for
         // blocks - usually used by adapters.
-        this._providers = {};
+        this._services = {};
         if (boot) {
             if ('space' in boot) {
                 this.space = boot.space;
@@ -56,14 +56,14 @@ class App {
         return this;
     }
     /**
-     * Declares a `Provider` with a given name.
+     * Declares a `Service`.
      *
-     * Providers are started and ended along with the daemon, and can be used on the App
+     * Services are started and ended along with the daemon, and can be used on the App
      * config to share globals between adapters and other methods.
-     * @param $ `AppProvider` with an `up` and `down` method to create/destroy the provider.
+     * @param $ object with an `up` and `down` method to create/destroy the service
      */
-    provider($) {
-        this._providers[$.name] = $;
+    service($) {
+        this._services[$.name] = $;
         return this;
     }
     //
@@ -94,8 +94,8 @@ class App {
         return modules;
     }
     //
-    static getProviders(app) {
-        return app._providers;
+    static getServices(app) {
+        return app._services;
     }
     static getInfo(app) {
         return {

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

@@ -1,5 +1,6 @@
 import { $Module, $Space, ModuleName } from "../../schema";
-import { App, AppProvider } from './app';
+import { App } from './app';
+import { IService } from './service';
 import { AnyTrxEngine } from '../transaction/trx_engine';
 import { AnyBuilder, AnyModule, Module } from '../module';
 import { AnyDaemon, Daemon } from '../daemon';
@@ -7,28 +8,28 @@ 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> {
+export declare class InlineApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> extends App<S, ModuleNames, Services> {
     protected _daemon?: Daemon<S, ModuleNames>;
     protected _modules: Record<string, AnyModule>;
     private packageJson?;
     protected bootPromise?: Promise<void>;
     constructor(name: string, builders: AnyBuilder[]);
-    boot(): InlineApp<S, ModuleNames, Providers>;
+    boot(): InlineApp<S, ModuleNames, Services>;
     /**
      * Treeshake and build modules declared for this application.
      */
     protected build(): Promise<void>;
     /**
-     * Build the application, start providers and trx engines.
+     * Build the application, start services and trx engines.
      * Returns references to start a daemon.
      */
     protected make(): Promise<{
         modules: Record<string, AnyModule>;
-        providers: Record<string, any>;
+        services: Record<string, any>;
         trxEngines: Record<ModuleNames, AnyTrxEngine>;
     }>;
     daemon(): Promise<Daemon<S, ModuleNames>>;
-    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, providers: Record<string, any>): AnyDaemon;
+    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, services: Record<string, IService>): AnyDaemon;
     package(_package: Record<string, any>): this;
     /**
      * This method injects elements flagged as externals by referencing them
@@ -38,8 +39,8 @@ export declare class InlineApp<S extends $Space, ModuleNames extends string = Mo
      */
     protected linkExternals(modules: Record<string, Module<S, $Module>>): void;
     modules<M extends ModuleName<S>>(modules: M[]): InlineApp<S, M & ModuleNames>;
-    provider<Name extends string, T>($: AppProvider<Name, T>): InlineApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
-    get config(): AppConfigFactory<S, ModuleNames, Providers, typeof this>;
+    service<T extends IService>($: T): InlineApp<S, ModuleNames, Services & { [K in T["name"]]: T; }>;
+    get config(): AppConfigFactory<S, ModuleNames, Services, typeof this>;
     static package(app: InlineApp<any, any>, scripts: Record<string, string>, dependencies: Record<string, string>): {
         name: string;
         version: string;

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

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InlineDaemon = exports.InlineApp = void 0;
 const app_1 = require("./app");
@@ -7,6 +10,7 @@ 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");
+const promise_1 = __importDefault(require("../util/promise"));
 /**
  * @category App
  */
@@ -44,7 +48,7 @@ class InlineApp extends app_1.App {
         });
     }
     /**
-     * Build the application, start providers and trx engines.
+     * Build the application, start services and trx engines.
      * Returns references to start a daemon.
      */
     async make() {
@@ -56,19 +60,19 @@ class InlineApp extends app_1.App {
             const mod = this._injectedModules[key];
             modules[mod.name] = mod;
         }
-        const providers = {};
-        for (const key in this._providers) {
-            const provider = this._providers[key].up({
+        const services = {};
+        for (const key in this._services) {
+            const service = this._services[key];
+            await promise_1.default.solve(service.up({
                 modules
-            });
-            provider.__down = this._providers[key].down;
-            providers[key] = provider;
+            }));
+            services[key] = service;
         }
         log_1.Log.debug('app', this.name, 'Starting transaction engines');
         const trxEngines = {};
         for (const m in modules) {
             const module = modules[m];
-            module.start(this, providers);
+            module.start(this, services);
             const trxConfig = this._config.trxEngine?.[m];
             const authn = {};
             for (const a in this._config?.authn || {}) {
@@ -77,13 +81,13 @@ class InlineApp extends app_1.App {
                     authn[a] = prov;
                 }
             }
-            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authn, trxConfig, providers);
+            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authn, trxConfig, services);
         }
         log_1.Log.debug('app', this.name, 'Linking externals');
         this.linkExternals(modules);
         return {
             modules,
-            providers,
+            services,
             trxEngines
         };
     }
@@ -93,7 +97,7 @@ class InlineApp extends app_1.App {
         }
         const app = await this.make();
         log_1.Log.debug('app', this.name, 'Spawning daemon');
-        this._daemon = this.makeDaemon(app.trxEngines, app.providers);
+        this._daemon = this.makeDaemon(app.trxEngines, app.services);
         // Link daemon to modules
         for (const m in app.modules) {
             const module = app.modules[m];
@@ -101,8 +105,8 @@ class InlineApp extends app_1.App {
         }
         return this._daemon;
     }
-    makeDaemon(trxEngines, providers) {
-        return new InlineDaemon(this.name, trxEngines, providers, this._config);
+    makeDaemon(trxEngines, services) {
+        return new InlineDaemon(this.name, trxEngines, services, this._config);
     }
     package(_package) {
         this.packageJson = _package;
@@ -116,19 +120,15 @@ class InlineApp extends app_1.App {
      */
     linkExternals(modules) {
         Object.values(modules).forEach(module => {
+            module.injectDependencies(modules, {
+                buckets: Object.values(module.schema.externals.buckets),
+                jobs: Object.values(module.schema.externals.jobs),
+                machines: Object.values(module.schema.externals.machines),
+            });
             const buckets = module.schema.externals.buckets;
             Object.values(buckets).forEach(bucket => {
-                module.buckets[bucket.refName] = modules[bucket.module].buckets[bucket.name];
                 module.nql.linkExternal(modules[bucket.module].buckets[bucket.name]);
             });
-            const jobs = module.schema.externals.jobs;
-            Object.values(jobs).forEach(job => {
-                module.jobs[job.refName] = modules[job.module].jobs[job.name];
-            });
-            const machines = module.schema.externals.machines;
-            Object.values(machines).forEach(machine => {
-                module.machines[machine.refName] = modules[machine.module].machines[machine.name];
-            });
         });
     }
     // Type Builder Overrides
@@ -136,8 +136,8 @@ class InlineApp extends app_1.App {
         super.modules(modules);
         return this;
     }
-    provider($) {
-        super.provider($);
+    service($) {
+        super.service($);
         return this;
     }
     get config() {

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

@@ -1,5 +1,5 @@
 import { $Space, ModuleName } from "../../../schema";
-import { AppProvider } from '../app';
+import { IService } from '../service';
 import { InlineApp } from './../inline.app';
 import { AnyTrxEngine } from '../../transaction/trx_engine';
 import { Space } from '../../space';
@@ -9,18 +9,18 @@ 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> {
+export declare class MonolythApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> extends InlineApp<S, ModuleNames, Services> {
     private watcher?;
     constructor(name: string, space?: Space<S>);
     protected _packageJson?: Record<string, any>;
     daemon($?: {
         watch?: boolean;
     }): Promise<Daemon<S, ModuleNames>>;
-    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, providers: Record<string, any>): MonolythDaemon<$Space, ModuleNames>;
+    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, services: Record<string, IService>): MonolythDaemon<$Space, ModuleNames>;
     remake(): Promise<void>;
     modules<M extends ModuleName<S>>(modules: M[]): MonolythApp<S, M & ModuleNames>;
-    provider<Name extends string, T>($: AppProvider<Name, T>): MonolythApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
-    get config(): AppConfigFactory<S, ModuleNames, Providers, typeof this>;
+    service<T extends IService>($: T): MonolythApp<S, ModuleNames, Services & { [K in T["name"]]: T; }>;
+    get config(): AppConfigFactory<S, ModuleNames, Services, typeof this>;
 }
 /**
  * @category App