@bluelibs/runner 2.2.4 → 3.1.0

package/dist/defs.d.ts

@@ -1,18 +1,30 @@
+import { MiddlewareEverywhereOptions } from "./define";
+export { ICacheInstance } from "./globals/middleware/cache.middleware";
 export declare const symbolTask: unique symbol;
 export declare const symbolResource: unique symbol;
 export declare const symbolResourceWithConfig: unique symbol;
 export declare const symbolEvent: unique symbol;
 export declare const symbolMiddleware: unique symbol;
+export declare const symbolMiddlewareConfigured: unique symbol;
 export declare const symbolMiddlewareGlobal: unique symbol;
+export declare const symbolMiddlewareEverywhereTasks: unique symbol;
+export declare const symbolMiddlewareEverywhereResources: unique symbol;
 export declare const symbolFilePath: unique symbol;
+export declare const symbolDispose: unique symbol;
+export declare const symbolStore: unique symbol;
+export declare const symbolIndexResource: unique symbol;
 export declare const symbols: {
     task: symbol;
     resource: symbol;
     resourceWithConfig: symbol;
+    indexResource: symbol;
     event: symbol;
     middleware: symbol;
-    middlewareGlobal: symbol;
+    middlewareEverywhereTasks: symbol;
+    middlewareEverywhereResources: symbol;
     filePath: symbol;
+    dispose: symbol;
+    store: symbol;
 };
 export interface IMeta {
     title?: string;
@@ -31,25 +43,33 @@ export type DependencyMapType = Record<string, ITask<any, any, any, any> | IReso
 type ExtractTaskInput<T> = T extends ITask<infer I, any, infer D> ? I : never;
 type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer D> ? O : never;
 type ExtractResourceValue<T> = T extends IResource<any, infer V, infer D> ? V : never;
-type ExtractEventParams<T> = T extends IEventDefinition<infer P> ? P : never;
+type ExtractEventParams<T> = T extends IEvent<infer P> ? P : never;
+/**
+ * This represents a task dependency function that can be called with or without parameters.
+ */
 type TaskDependency<I, O> = (...args: I extends null | void ? [] : [I]) => O;
+/**
+ * This represents the resource's value type.
+ */
 type ResourceDependency<V> = V;
-type EventDependency<P> = (input: P) => Promise<void>;
+/**
+ * This represents an event emission function that can be called with or without parameters.
+ */
+type EventDependency<P> = P extends void ? (() => Promise<void>) & ((input?: Record<string, never>) => Promise<void>) : (input: P) => Promise<void>;
 export type DependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependency<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IEventDefinition<any> ? EventDependency<ExtractEventParams<T>> : never;
 export type DependencyValuesType<T extends DependencyMapType> = {
     [K in keyof T]: DependencyValueType<T[K]>;
 };
-type Optional<T> = {
-    [K in keyof T]?: T[K];
-};
-type IsVoid<T> = [T] extends [void] ? true : false;
-type IsOptional<T> = undefined extends T ? true : false;
-type OptionalOrVoidOrAnything<T> = IsVoid<T> extends true ? void : IsOptional<T> extends true ? Optional<T> : T;
-export type RegisterableItems<T = any> = IResourceWithConfig<any> | IResource<OptionalOrVoidOrAnything<T>, any, any> | ITaskDefinition<any, any, any, any> | IMiddlewareDefinition<any> | IEventDefinition<any>;
+export type RegisterableItems<T = any> = IResourceWithConfig<any> | IResource<void, any, any, any> | IResource<{
+    [K in any]?: any;
+}, any, any, any> | ITask<any, any, any, any> | IMiddleware<any> | IEvent<any>;
+export type MiddlewareAttachments = IMiddleware<void> | IMiddleware<{
+    [K in any]?: any;
+}> | IMiddlewareConfigured<any>;
 export interface ITaskDefinition<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined> {
-    id: string;
+    id?: string | symbol;
     dependencies?: TDependencies | (() => TDependencies);
-    middleware?: IMiddlewareDefinition[];
+    middleware?: MiddlewareAttachments[];
     /**
      * Listen to events in a simple way
      */
@@ -60,14 +80,15 @@ export interface ITaskDefinition<TInput = any, TOutput extends Promise<any> = an
      */
     listenerOrder?: number;
     meta?: ITaskMeta;
-    run: (input: TOn extends undefined ? TInput : IEvent<TOn extends "*" ? any : ExtractEventParams<TOn>>, dependencies: DependencyValuesType<TDependencies>) => TOutput;
+    run: (input: TOn extends undefined ? TInput : IEventEmission<TOn extends "*" ? any : ExtractEventParams<TOn>>, dependencies: DependencyValuesType<TDependencies>) => TOutput;
 }
 export type BeforeRunEventPayload<TInput> = {
     input: TInput;
 };
 export type AfterRunEventPayload<TInput, TOutput> = {
     input: TInput;
-    output: TOutput;
+    output: TOutput extends Promise<infer U> ? U : TOutput;
+    setOutput(newOutput: TOutput extends Promise<infer U> ? U : TOutput): void;
 };
 export type OnErrorEventPayload = {
     error: any;
@@ -87,58 +108,87 @@ export type AfterInitEventPayload<TConfig, TValue> = {
  * This is the response after the definition has been prepared. TODO: better naming?
  */
 export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined> extends ITaskDefinition<TInput, TOutput, TDependencies, TOn> {
+    id: string | symbol;
     dependencies: TDependencies | (() => TDependencies);
     computedDependencies?: DependencyValuesType<TDependencies>;
-    middleware: IMiddlewareDefinition[];
+    middleware: MiddlewareAttachments[];
     /**
      * These events are automatically populated after the task has been defined.
      */
     events: {
-        beforeRun: IEventDefinition<BeforeRunEventPayload<TInput>>;
-        afterRun: IEventDefinition<AfterRunEventPayload<TInput, TOutput>>;
-        onError: IEventDefinition<OnErrorEventPayload>;
+        beforeRun: IEvent<BeforeRunEventPayload<TInput>>;
+        afterRun: IEvent<AfterRunEventPayload<TInput, TOutput>>;
+        onError: IEvent<OnErrorEventPayload>;
     };
 }
-export interface IResourceDefinition<TConfig = any, TValue = unknown, TDependencies extends DependencyMapType = {}, TRegisterableItems = any> {
-    id: string;
+export interface IResourceDefinition<TConfig = any, TValue = unknown, TDependencies extends DependencyMapType = {}, TContext = any, THooks = any, TRegisterableItems = any> {
+    id?: string | symbol;
     dependencies?: TDependencies | ((config: TConfig) => TDependencies);
     register?: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
-    init?: (config: TConfig, dependencies: DependencyValuesType<TDependencies>) => Promise<TValue>;
+    init?: (this: any, config: TConfig, dependencies: DependencyValuesType<TDependencies>, context: TContext) => Promise<TValue>;
     /**
      * Clean-up function for the resource. This is called when the resource is no longer needed.
      *
-     * @param value The value of the resource
+     * @param value The value of the resource (undefined if no init method)
      * @param config The configuration it received
      * @param dependencies The dependencies it needed
-     * @returns
+     * @returns Promise<void>
      */
-    dispose?: (value: TValue, config: TConfig, dependencies: DependencyValuesType<TDependencies>) => Promise<TValue>;
+    dispose?: (this: any, value: TValue, config: TConfig, dependencies: DependencyValuesType<TDependencies>, context: TContext) => Promise<void>;
     meta?: IResourceMeta;
     overrides?: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
-    middleware?: IMiddlewareDefinition[];
+    middleware?: MiddlewareAttachments[];
+    context?: () => TContext;
+    /**
+     * This is optional and used from an index resource to get the correct caller.
+     */
+    [symbolFilePath]?: string;
+    /**
+     * This is used internally when creating index resources.
+     */
+    [symbolIndexResource]?: boolean;
 }
-export interface IResource<TConfig = void, TValue = any, TDependencies extends DependencyMapType = any> extends IResourceDefinition<TConfig, TValue, TDependencies> {
-    init: (config: TConfig, dependencies: DependencyValuesType<TDependencies>) => Promise<TValue>;
+export interface IResource<TConfig = void, TValue = any, TDependencies extends DependencyMapType = any, TContext = any> extends IResourceDefinition<TConfig, TValue, TDependencies, TContext> {
+    id: string | symbol;
     with(config: TConfig): IResourceWithConfig<TConfig, TValue, TDependencies>;
     register: Array<RegisterableItems> | ((config: TConfig) => Array<RegisterableItems>);
     /**
      * These events are automatically populated after the task has been defined.
      */
     events: {
-        beforeInit: IEventDefinition<BeforeInitEventPayload<TConfig>>;
-        afterInit: IEventDefinition<AfterInitEventPayload<TConfig, TValue>>;
-        onError: IEventDefinition<OnErrorEventPayload>;
+        beforeInit: IEvent<BeforeInitEventPayload<TConfig>>;
+        afterInit: IEvent<AfterInitEventPayload<TConfig, TValue>>;
+        onError: IEvent<OnErrorEventPayload>;
     };
     overrides: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
-    middleware: IMiddlewareDefinition[];
+    middleware: MiddlewareAttachments[];
 }
 export interface IResourceWithConfig<TConfig = any, TValue = any, TDependencies extends DependencyMapType = any> {
     id: string;
     resource: IResource<TConfig, TValue, TDependencies>;
     config: TConfig;
 }
-export interface IEvent<TPayload = any> {
-    id: string;
+export type EventHandlerType<T = any> = (event: IEventEmission<T>) => any | Promise<any>;
+export interface IEventDefinition<TPayload = void> {
+    id?: string | symbol;
+    meta?: IEventMeta;
+}
+export interface IEvent<TPayload = any> extends IEventDefinition<TPayload> {
+    id: string | symbol;
+    /**
+     * We use this event to discriminate between resources with just 'id' and 'events' as they collide. This is a workaround, should be redone using classes and instanceof.
+     */
+    [symbolEvent]: true;
+}
+/**
+ * This represents the object that is passed to event handlers
+ */
+export interface IEventEmission<TPayload = any> {
+    /**
+     * The ID of the event. This is the same as the event's ID.
+     * This is useful for global event listeners.
+     */
+    id: string | symbol;
     /**
      * The data that the event carries. It can be anything.
      */
@@ -150,54 +200,40 @@ export interface IEvent<TPayload = any> {
     /**
      * The source of the event. This can be useful for debugging.
      */
-    source: string;
-}
-export type EventHandlerType<T = any> = (event: IEvent<T>) => any | Promise<any>;
-export interface IEventDefinitionConfig<TPayload = void> {
-    id: string;
-    meta?: IEventMeta;
+    source: string | symbol;
 }
-export interface IEventDefinition<TPayload = void> {
-    id: string;
-    /**
-     * We use this event to discriminate between resources with just 'id' and 'events' as they collide. This is a workaround, should be redone using classes and instanceof.
-     */
-    [symbolEvent]: true;
-    meta?: IEventMeta;
-}
-export interface IMiddlewareDefinition<TDependencies extends DependencyMapType = any> {
-    id: string;
+export interface IMiddlewareDefinition<TConfig = any, TDependencies extends DependencyMapType = any> {
+    id?: string | symbol;
     dependencies?: TDependencies | (() => TDependencies);
-    run: (input: IMiddlewareExecutionInput, dependencies: DependencyValuesType<TDependencies>) => Promise<any>;
+    run: (input: IMiddlewareExecutionInput, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
     meta?: IMiddlewareMeta;
 }
-export interface IMiddleware<TDependencies extends DependencyMapType = any> extends IMiddlewareDefinition<TDependencies> {
+export interface IMiddleware<TConfig = any, TDependencies extends DependencyMapType = any> extends IMiddlewareDefinition<TConfig, TDependencies> {
+    [symbolMiddleware]: true;
+    [symbolMiddlewareConfigured]?: boolean;
+    [symbolMiddlewareEverywhereTasks]?: boolean;
+    [symbolMiddlewareEverywhereResources]?: boolean;
+    id: string | symbol;
     dependencies: TDependencies | (() => TDependencies);
-    global(): IMiddleware<TDependencies>;
+    everywhere(config?: MiddlewareEverywhereOptions): IMiddleware<TConfig, TDependencies>;
+    config: TConfig;
+    with: (config: TConfig) => IMiddlewareConfigured<TConfig, TDependencies>;
+}
+export interface IMiddlewareConfigured<TConfig = any, TDependencies extends DependencyMapType = any> extends IMiddleware<TConfig, TDependencies> {
+    [symbolMiddlewareConfigured]: true;
 }
 export interface IMiddlewareDefinitionConfigured<C extends Record<string, any> = {}> {
     middleware: IMiddleware<C>;
     config?: C;
 }
-export interface IMiddlewareExecutionInput {
-    taskDefinition?: ITask;
-    resourceDefinition?: IResource;
-    config?: any;
-    input?: any;
-    next: (taskInputOrResourceConfig?: any) => Promise<any>;
-}
-export interface IHookDefinition<D extends DependencyMapType = {}, T = any, B extends boolean = false> {
-    event: "*" | IEventDefinition<T>;
-    /**
-     * The higher the number, the higher the priority.
-     * We recommend using numbers between -1000 and 1000.
-     */
-    order?: number;
-    /**
-     * These are hooks that run before any resource instantiation.
-     * @param event
-     */
-    early?: B;
-    run: (event: IEvent<T>, dependencies: T extends true ? void : DependencyValuesType<D>) => Promise<void> | void;
+export interface IMiddlewareExecutionInput<TTaskInput = any, TResourceConfig = any> {
+    task?: {
+        definition: ITask<TTaskInput>;
+        input: TTaskInput;
+    };
+    resource?: {
+        definition: IResource<TResourceConfig>;
+        config: TResourceConfig;
+    };
+    next: (taskInputOrResourceConfig?: TTaskInput | TResourceConfig) => Promise<any>;
 }
-export {};

package/dist/defs.js

@@ -1,20 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.symbols = exports.symbolFilePath = exports.symbolMiddlewareGlobal = exports.symbolMiddleware = exports.symbolEvent = exports.symbolResourceWithConfig = exports.symbolResource = exports.symbolTask = void 0;
+exports.symbols = exports.symbolIndexResource = exports.symbolStore = exports.symbolDispose = exports.symbolFilePath = exports.symbolMiddlewareEverywhereResources = exports.symbolMiddlewareEverywhereTasks = exports.symbolMiddlewareGlobal = exports.symbolMiddlewareConfigured = exports.symbolMiddleware = exports.symbolEvent = exports.symbolResourceWithConfig = exports.symbolResource = exports.symbolTask = void 0;
 exports.symbolTask = Symbol("runner.task");
 exports.symbolResource = Symbol("runner.resource");
 exports.symbolResourceWithConfig = Symbol("runner.resourceWithConfig");
 exports.symbolEvent = Symbol("runner.event");
 exports.symbolMiddleware = Symbol("runner.middleware");
+exports.symbolMiddlewareConfigured = Symbol("runner.middlewareConfigured");
 exports.symbolMiddlewareGlobal = Symbol("runner.middlewareGlobal");
+exports.symbolMiddlewareEverywhereTasks = Symbol("runner.middlewareGlobalTasks");
+exports.symbolMiddlewareEverywhereResources = Symbol("runner.middlewareGlobalResources");
 exports.symbolFilePath = Symbol("runner.filePath");
+exports.symbolDispose = Symbol("runner.dispose");
+exports.symbolStore = Symbol("runner.store");
+exports.symbolIndexResource = Symbol("runner.indexResource");
 exports.symbols = {
     task: exports.symbolTask,
     resource: exports.symbolResource,
     resourceWithConfig: exports.symbolResourceWithConfig,
+    indexResource: exports.symbolIndexResource,
     event: exports.symbolEvent,
     middleware: exports.symbolMiddleware,
-    middlewareGlobal: exports.symbolMiddlewareGlobal,
+    middlewareEverywhereTasks: exports.symbolMiddlewareEverywhereTasks,
+    middlewareEverywhereResources: exports.symbolMiddlewareEverywhereResources,
     filePath: exports.symbolFilePath,
+    dispose: exports.symbolDispose,
+    store: exports.symbolStore,
 };
 //# sourceMappingURL=defs.js.map

package/dist/defs.js.map

@@ -1 +1 @@
-{"version":3,"file":"defs.js","sourceRoot":"","sources":["../src/defs.ts"],"names":[],"mappings":";;;AAAa,QAAA,UAAU,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AAClD,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AACW,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AACpD,QAAA,gBAAgB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC9D,QAAA,sBAAsB,GAAkB,MAAM,CACzD,yBAAyB,CAC1B,CAAC;AAEW,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAE1D,QAAA,OAAO,GAAG;IACrB,IAAI,EAAE,kBAAU;IAChB,QAAQ,EAAE,sBAAc;IACxB,kBAAkB,EAAE,gCAAwB;IAC5C,KAAK,EAAE,mBAAW;IAClB,UAAU,EAAE,wBAAgB;IAC5B,gBAAgB,EAAE,8BAAsB;IACxC,QAAQ,EAAE,sBAAc;CACzB,CAAC"}
+{"version":3,"file":"defs.js","sourceRoot":"","sources":["../src/defs.ts"],"names":[],"mappings":";;;AAKa,QAAA,UAAU,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AAClD,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AACW,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AACpD,QAAA,gBAAgB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC9D,QAAA,0BAA0B,GAAkB,MAAM,CAC7D,6BAA6B,CAC9B,CAAC;AACW,QAAA,sBAAsB,GAAkB,MAAM,CACzD,yBAAyB,CAC1B,CAAC;AACW,QAAA,+BAA+B,GAAkB,MAAM,CAClE,8BAA8B,CAC/B,CAAC;AACW,QAAA,mCAAmC,GAAkB,MAAM,CACtE,kCAAkC,CACnC,CAAC;AAEW,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,aAAa,GAAkB,MAAM,CAAC,gBAAgB,CAAC,CAAC;AACxD,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AAEpD,QAAA,mBAAmB,GAAkB,MAAM,CACtD,sBAAsB,CACvB,CAAC;AAEW,QAAA,OAAO,GAAG;IACrB,IAAI,EAAE,kBAAU;IAChB,QAAQ,EAAE,sBAAc;IACxB,kBAAkB,EAAE,gCAAwB;IAC5C,aAAa,EAAE,2BAAmB;IAClC,KAAK,EAAE,mBAAW;IAClB,UAAU,EAAE,wBAAgB;IAC5B,yBAAyB,EAAE,uCAA+B;IAC1D,6BAA6B,EAAE,2CAAmC;IAClE,QAAQ,EAAE,sBAAc;IACxB,OAAO,EAAE,qBAAa;IACtB,KAAK,EAAE,mBAAW;CACnB,CAAC"}

package/dist/errors.d.ts

@@ -1,10 +1,10 @@
 export declare const Errors: {
-    duplicateRegistration: (type: string, id: string) => Error;
-    dependencyNotFound: (key: string) => Error;
+    duplicateRegistration: (type: string, id: string | symbol) => Error;
+    dependencyNotFound: (key: string | symbol) => Error;
     unknownItemType: (item: any) => Error;
     circularDependencies: (cycles: string[]) => Error;
-    eventNotFound: (id: string) => Error;
-    middlewareAlreadyGlobal: (id: string) => Error;
-    locked: (what: string) => Error;
+    eventNotFound: (id: string | symbol) => Error;
+    middlewareAlreadyGlobal: (id: string | symbol) => Error;
+    locked: (what: string | symbol) => Error;
     storeAlreadyInitialized: () => Error;
 };

package/dist/errors.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Errors = void 0;
 exports.Errors = {
-    duplicateRegistration: (type, id) => new Error(`${type} "${id}" already registered`),
-    dependencyNotFound: (key) => new Error(`Dependency ${key} not found. Did you forget to register it through a resource?`),
+    duplicateRegistration: (type, id) => new Error(`${type} "${id.toString()}" already registered`),
+    dependencyNotFound: (key) => new Error(`Dependency ${key.toString()} not found. Did you forget to register it through a resource?`),
     unknownItemType: (item) => new Error(`Unknown item type: ${item}`),
     circularDependencies: (cycles) => new Error(`Circular dependencies detected: ${cycles.join(", ")}`),
-    eventNotFound: (id) => new Error(`Event "${id}" not found. Did you forget to register it?`),
-    middlewareAlreadyGlobal: (id) => new Error("Cannot call global on a global middleware: " + id),
-    locked: (what) => new Error(`Cannot modify the ${what} when it is locked.`),
+    eventNotFound: (id) => new Error(`Event "${id.toString()}" not found. Did you forget to register it?`),
+    middlewareAlreadyGlobal: (id) => new Error("Cannot call .everywhere() on an already global middleware: " +
+        id.toString),
+    locked: (what) => new Error(`Cannot modify the ${what.toString()} when it is locked.`),
     storeAlreadyInitialized: () => new Error("Store already initialized. Cannot reinitialize."),
 };
 //# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEa,QAAA,MAAM,GAAG;IACpB,qBAAqB,EAAE,CAAC,IAAY,EAAE,EAAU,EAAE,EAAE,CAClD,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,EAAE,sBAAsB,CAAC;IAEjD,kBAAkB,EAAE,CAAC,GAAW,EAAE,EAAE,CAClC,IAAI,KAAK,CACP,cAAc,GAAG,+DAA+D,CACjF;IAEH,eAAe,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,KAAK,CAAC,sBAAsB,IAAI,EAAE,CAAC;IAEvE,oBAAoB,EAAE,CAAC,MAAgB,EAAE,EAAE,CACzC,IAAI,KAAK,CAAC,mCAAmC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAEnE,aAAa,EAAE,CAAC,EAAU,EAAE,EAAE,CAC5B,IAAI,KAAK,CAAC,UAAU,EAAE,6CAA6C,CAAC;IAEtE,uBAAuB,EAAE,CAAC,EAAU,EAAE,EAAE,CACtC,IAAI,KAAK,CAAC,6CAA6C,GAAG,EAAE,CAAC;IAE/D,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE,CACvB,IAAI,KAAK,CAAC,qBAAqB,IAAI,qBAAqB,CAAC;IAE3D,uBAAuB,EAAE,GAAG,EAAE,CAC5B,IAAI,KAAK,CAAC,iDAAiD,CAAC;CAC/D,CAAC"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEa,QAAA,MAAM,GAAG;IACpB,qBAAqB,EAAE,CAAC,IAAY,EAAE,EAAmB,EAAE,EAAE,CAC3D,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,EAAE,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAE5D,kBAAkB,EAAE,CAAC,GAAoB,EAAE,EAAE,CAC3C,IAAI,KAAK,CACP,cAAc,GAAG,CAAC,QAAQ,EAAE,+DAA+D,CAC5F;IAEH,eAAe,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,KAAK,CAAC,sBAAsB,IAAI,EAAE,CAAC;IAEvE,oBAAoB,EAAE,CAAC,MAAgB,EAAE,EAAE,CACzC,IAAI,KAAK,CAAC,mCAAmC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAEnE,aAAa,EAAE,CAAC,EAAmB,EAAE,EAAE,CACrC,IAAI,KAAK,CACP,UAAU,EAAE,CAAC,QAAQ,EAAE,6CAA6C,CACrE;IAEH,uBAAuB,EAAE,CAAC,EAAmB,EAAE,EAAE,CAC/C,IAAI,KAAK,CACP,6DAA6D;QAC3D,EAAE,CAAC,QAAQ,CACd;IAEH,MAAM,EAAE,CAAC,IAAqB,EAAE,EAAE,CAChC,IAAI,KAAK,CAAC,qBAAqB,IAAI,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAEtE,uBAAuB,EAAE,GAAG,EAAE,CAC5B,IAAI,KAAK,CAAC,iDAAiD,CAAC;CAC/D,CAAC"}

package/dist/event.types.d.ts

@@ -0,0 +1,18 @@
+import { IEventMeta } from "./common.types";
+import { symbolEvent } from "./symbols";
+export interface IEvent<TPayload = any> {
+    id: string;
+    data: TPayload;
+    timestamp: Date;
+    source: string;
+}
+export type EventHandlerType<T = any> = (event: IEvent<T>) => any | Promise<any>;
+export interface IEventDefinitionConfig<TPayload = void> {
+    id: string;
+    meta?: IEventMeta;
+}
+export interface IEventDefinition<TPayload = void> {
+    id: string;
+    [symbolEvent]: true;
+    meta?: IEventMeta;
+}

package/dist/event.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbols_1 = require("./symbols");
+//# sourceMappingURL=event.types.js.map

package/dist/event.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.types.js","sourceRoot":"","sources":["../src/event.types.ts"],"names":[],"mappings":";;AACA,uCAAwC"}

package/dist/examples/registrator-example.d.ts

@@ -0,0 +1,122 @@
+export declare const userPackage: import("../defs").IRegistrator<(import("../defs").IEventDefinition<{
+    userId: string;
+    email: string;
+}> | import("../defs").IResource<void, {
+    createUser: (email: string) => Promise<{
+        id: string;
+        email: string;
+    }>;
+    getUser: (id: string) => Promise<{
+        id: string;
+        email: string;
+    }>;
+}, {}> | import("../defs").ITask<string, Promise<{
+    id: string;
+    email: string;
+}>, {
+    userService: import("../defs").IResource<void, {
+        createUser: (email: string) => Promise<{
+            id: string;
+            email: string;
+        }>;
+        getUser: (id: string) => Promise<{
+            id: string;
+            email: string;
+        }>;
+    }, {}>;
+    userCreatedEvent: import("../defs").IEventDefinition<{
+        userId: string;
+        email: string;
+    }>;
+}, undefined>)[]> & import("../defs").IResource<void, {
+    items: ({
+        createUser: (email: string) => Promise<{
+            id: string;
+            email: string;
+        }>;
+        getUser: (id: string) => Promise<{
+            id: string;
+            email: string;
+        }>;
+    } | ((args_0: string) => Promise<{
+        id: string;
+        email: string;
+    }>) | ((input: {
+        userId: string;
+        email: string;
+    }) => Promise<void>))[];
+}, any>;
+export declare const loggingPackage: import("../defs").IRegistrator<(import("../defs").IEventDefinition<{
+    level: string;
+    message: string;
+}> | import("../defs").IMiddleware<{
+    logEvent: import("../defs").IEventDefinition<{
+        level: string;
+        message: string;
+    }>;
+}> | import("../defs").IResource<void, {
+    info: (message: string) => Promise<void>;
+    error: (message: string) => Promise<void>;
+}, {
+    logEvent: import("../defs").IEventDefinition<{
+        level: string;
+        message: string;
+    }>;
+}>)[]> & import("../defs").IResource<void, {
+    items: ({
+        info: (message: string) => Promise<void>;
+        error: (message: string) => Promise<void>;
+    } | ((input: {
+        level: string;
+        message: string;
+    }) => Promise<void>))[];
+}, any>;
+export declare const emailPackage: import("../defs").IRegistrator<(import("../defs").IEventDefinition<{
+    to: string;
+    subject: string;
+}> | import("../defs").IResource<void, {
+    sendEmail: (to: string, subject: string, body: string) => Promise<{
+        messageId: string;
+    }>;
+}, {
+    emailSentEvent: import("../defs").IEventDefinition<{
+        to: string;
+        subject: string;
+    }>;
+}> | import("../defs").ITask<undefined, Promise<{
+    messageId: string;
+}>, {
+    emailService: import("../defs").IResource<void, {
+        sendEmail: (to: string, subject: string, body: string) => Promise<{
+            messageId: string;
+        }>;
+    }, {
+        emailSentEvent: import("../defs").IEventDefinition<{
+            to: string;
+            subject: string;
+        }>;
+    }>;
+}, import("../defs").IEventDefinition<{
+    userId: string;
+    email: string;
+}>>)[]> & import("../defs").IResource<void, {
+    items: ({
+        sendEmail: (to: string, subject: string, body: string) => Promise<{
+            messageId: string;
+        }>;
+    } | ((input: {
+        to: string;
+        subject: string;
+    }) => Promise<void>))[];
+}, any>;
+declare function demonstrateRegistrators(): Promise<{
+    createUser: (args_0: string) => Promise<{
+        id: string;
+        email: string;
+    }>;
+    logger: {
+        info: (message: string) => Promise<void>;
+        error: (message: string) => Promise<void>;
+    };
+}>;
+export { demonstrateRegistrators };