@moostjs/event-wf 0.2.34 → 0.2.36

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { getMoostMate, getMoostInfact, defineMoostEventHandler } from 'moost';
-import { WooksWf, createWfApp } from '@wooksjs/event-wf';
+import { getMoostMate as getMoostMate$1, getMoostInfact, defineMoostEventHandler } from 'moost';
+import { WooksWf, createWfApp, useWfState } from '@wooksjs/event-wf';
 import { useEventId, useEventContext } from '@wooksjs/event-core';
 import 'wooks';
 
@@ -31,7 +31,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
 }
 
 function getWfMate() {
-    return getMoostMate();
+    return getMoostMate$1();
 }
 
 const LOGGER_TITLE = 'moost-wf';
@@ -39,6 +39,7 @@ const CONTEXT_TYPE = 'WF';
 class MoostWf {
     constructor(opts) {
         this.opts = opts;
+        this.toInit = [];
         const wfAppOpts = opts === null || opts === void 0 ? void 0 : opts.wooksWf;
         if (wfAppOpts && wfAppOpts instanceof WooksWf) {
             this.wfApp = wfAppOpts;
@@ -68,6 +69,7 @@ class MoostWf {
     }
     onInit(moost) {
         this.moost = moost;
+        this.toInit.forEach(fn => fn());
     }
     start(schemaId, inputContext, input) {
         return this.wfApp.start(schemaId, inputContext, input, () => {
@@ -105,11 +107,11 @@ class MoostWf {
                     manualUnscope: true,
                 });
             }
-            let routerBinding;
             if (handler.type === 'WF_STEP') {
-                routerBinding = this.wfApp.step(targetPath, {
+                this.wfApp.step(targetPath, {
                     handler: fn,
                 });
+                opts.logHandler(`${''}(${handler.type})${''}${targetPath}`);
             }
             else {
                 const mate = getWfMate();
@@ -117,26 +119,711 @@ class MoostWf {
                 if (!wfSchema) {
                     wfSchema = (_b = mate.read(opts.fakeInstance)) === null || _b === void 0 ? void 0 : _b.wfSchema;
                 }
-                routerBinding = this.wfApp.flow(targetPath, wfSchema || []);
+                const _fn = fn;
+                this.toInit.push(() => {
+                    this.wfApp.flow(targetPath, wfSchema || [], _fn);
+                    opts.logHandler(`${''}(${handler.type})${''}${targetPath}`);
+                });
             }
-            opts.logHandler(`${''}(${handler.type})${''}${targetPath}`);
-            const args = routerBinding.getArgs();
-            const params = {};
-            args.forEach(a => params[a] = `{${a}}`);
-            opts.register(handler, routerBinding.getPath(params), args);
         }
     }
 }
 
-function WfStep(path) {
-    return getWfMate().decorate('handlers', { path, type: 'WF_STEP' }, true);
+function getConstructor$1(instance) {
+    return isConstructor(instance) ?
+        instance : instance.constructor ?
+        instance.constructor : Object.getPrototypeOf(instance).constructor;
+}
+function isConstructor(v) {
+    return typeof v === 'function' && Object.getOwnPropertyNames(v).includes('prototype') && !Object.getOwnPropertyNames(v).includes('caller') && !!v.name;
+}
+
+const classMetadata = {};
+const paramMetadata = {};
+const root = typeof global === 'object' ? global : typeof self === 'object' ? self : {};
+function getMetaObject(target, prop) {
+    const isParam = typeof prop !== 'undefined';
+    const metadata = isParam ? paramMetadata : classMetadata;
+    const targetKey = Symbol.for(getConstructor$1(target));
+    let meta = metadata[targetKey] = metadata[targetKey] || {};
+    if (isParam)
+        meta = (meta[prop] = meta[prop] || {});
+    return meta;
+}
+const _reflect = {
+    getOwnMetadata(key, target, prop) {
+        return getMetaObject(target, prop)[key];
+    },
+    defineMetadata(key, data, target, prop) {
+        const meta = getMetaObject(target, prop);
+        meta[key] = data;
+    },
+    metadata(key, data) {
+        return ((target, propKey) => {
+            Reflect$1.defineMetadata(key, data, target, propKey);
+        });
+    },
+};
+if (!root.Reflect) {
+    root.Reflect = _reflect;
+}
+else {
+    const funcs = [
+        'getOwnMetadata',
+        'defineMetadata',
+        'metadata',
+    ];
+    const target = root.Reflect;
+    for (const func of funcs) {
+        if (typeof target[func] !== 'function') {
+            Object.defineProperty(target, func, { configurable: true, writable: true, value: _reflect[func] });
+        }
+    }
+}
+const Reflect$1 = _reflect;
+
+const Reflect = (global === null || global === void 0 ? void 0 : global.Reflect) || (self === null || self === void 0 ? void 0 : self.Reflect) || Reflect$1;
+class Mate {
+    constructor(workspace, options = {}) {
+        this.workspace = workspace;
+        this.options = options;
+        this.logger = options.logger || console;
+    }
+    set(args, key, value, isArray) {
+        var _a;
+        let level = 'CLASS';
+        const newArgs = args.level === 'CLASS' ? { target: args.target }
+            : args.level === 'PROP' ? { target: args.target, propKey: args.propKey }
+                : args;
+        let meta = (Reflect.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {});
+        if (newArgs.propKey && this.options.readReturnType && !meta.returnType && args.descriptor) {
+            meta.returnType = Reflect.getOwnMetadata('design:returntype', newArgs.target, newArgs.propKey);
+        }
+        if (newArgs.propKey && this.options.readType && !meta.type) {
+            meta.type = Reflect.getOwnMetadata('design:type', newArgs.target, newArgs.propKey);
+        }
+        const { index } = newArgs;
+        const cb = typeof key === 'function' ? key : undefined;
+        let data = meta;
+        if (!data.params) {
+            data.params = (_a = Reflect.getOwnMetadata('design:paramtypes', newArgs.target, newArgs.propKey)) === null || _a === void 0 ? void 0 : _a.map((f) => ({ type: f }));
+        }
+        if (typeof index === 'number') {
+            level = 'PARAM';
+            data.params = data.params || [];
+            data.params[index] = data.params[index] || {
+                type: undefined,
+            };
+            if (cb) {
+                data.params[index] = cb(data.params[index], level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
+            }
+            else {
+                data = data.params[index];
+            }
+        }
+        else if (!index && !args.descriptor && args.propKey && this.options.collectPropKeys && args.level !== 'CLASS') {
+            this.set({ ...args, level: 'CLASS' }, (meta) => {
+                if (!meta.properties) {
+                    meta.properties = [args.propKey];
+                }
+                else if (!meta.properties.includes(args.propKey)) {
+                    meta.properties.push(args.propKey);
+                }
+                return meta;
+            });
+        }
+        level = typeof index === 'number' ? 'PARAM' : newArgs.propKey && newArgs.descriptor ? 'METHOD' : newArgs.propKey ? 'PROP' : 'CLASS';
+        if (typeof key !== 'function') {
+            if (isArray) {
+                const newArray = (data[key] || []);
+                if (!Array.isArray(newArray)) {
+                    this.logger.error('Mate.add (isArray=true) called for non-array metadata');
+                }
+                newArray.unshift(value);
+                data[key] = newArray;
+            }
+            else {
+                data[key] = value;
+            }
+        }
+        else if (cb && typeof index !== 'number') {
+            meta = cb(data, level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
+        }
+        Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
+    }
+    read(target, propKey) {
+        const isConstr = isConstructor(target);
+        const constructor = isConstr ? target : getConstructor$1(target);
+        const proto = constructor.prototype;
+        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
+        if (this.options.inherit) {
+            const inheritFn = typeof this.options.inherit === 'function' ? this.options.inherit : undefined;
+            let shouldInherit = this.options.inherit;
+            if (inheritFn) {
+                if (typeof propKey === 'string') {
+                    const classMeta = Reflect.getOwnMetadata(this.workspace, constructor);
+                    shouldInherit = inheritFn(classMeta, ownMeta, 'PROP', propKey);
+                }
+                else {
+                    shouldInherit = inheritFn(ownMeta, ownMeta, 'CLASS');
+                }
+            }
+            if (shouldInherit) {
+                const parent = Object.getPrototypeOf(constructor);
+                if (typeof parent === 'function' && parent !== fnProto && parent !== constructor) {
+                    const inheritedMeta = (this.read(parent, propKey) || {});
+                    const ownParams = ownMeta === null || ownMeta === void 0 ? void 0 : ownMeta.params;
+                    ownMeta = { ...inheritedMeta, ...ownMeta };
+                    if (typeof propKey === 'string' && ownParams && (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params)) {
+                        for (let i = 0; i < ownParams.length; i++) {
+                            if (typeof (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i]) !== 'undefined') {
+                                const ownParam = ownParams[i];
+                                if (ownMeta.params && inheritFn && inheritFn(ownMeta, ownParam, 'PARAM', typeof propKey === 'string' ? propKey : undefined)) {
+                                    ownMeta.params[i] = {
+                                        ...inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i],
+                                        ...ownParams[i],
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return ownMeta;
+    }
+    apply(...decorators) {
+        return ((target, propKey, descriptor) => {
+            for (const d of decorators) {
+                d(target, propKey, descriptor);
+            }
+        });
+    }
+    decorate(key, value, isArray, level) {
+        return ((target, propKey, descriptor) => {
+            const args = {
+                target,
+                propKey,
+                descriptor: typeof descriptor === 'number' ? undefined : descriptor,
+                index: typeof descriptor === 'number' ? descriptor : undefined,
+                level,
+            };
+            this.set(args, key, value, isArray);
+        });
+    }
+    decorateConditional(ccb) {
+        return ((target, propKey, descriptor) => {
+            const hasIndex = typeof descriptor === 'number';
+            const decoratorLevel = hasIndex ? 'PARAM' : propKey && descriptor ? 'METHOD' : propKey ? 'PROP' : 'CLASS';
+            const d = ccb(decoratorLevel);
+            if (d) {
+                d(target, propKey, descriptor);
+            }
+        });
+    }
+    decorateClass(key, value, isArray) {
+        return this.decorate(key, value, isArray, 'CLASS');
+    }
+}
+const fnProto = Object.getPrototypeOf(Function);
+
+const METADATA_WORKSPACE = 'moost';
+const moostMate = new Mate(METADATA_WORKSPACE, {
+    readType: true,
+    readReturnType: true,
+    collectPropKeys: true,
+    inherit(classMeta, targetMeta, level) {
+        if (level === 'CLASS') {
+            return !!(classMeta === null || classMeta === void 0 ? void 0 : classMeta.inherit);
+        }
+        if (level === 'PROP') {
+            return (!!(targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.inherit) || !!((classMeta === null || classMeta === void 0 ? void 0 : classMeta.inherit) && !targetMeta));
+        }
+        return !!(targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.inherit);
+    },
+});
+function getMoostMate() {
+    return moostMate;
+}
+
+function getConstructor(instance) {
+    return Object.getPrototypeOf(instance).constructor;
+}
+
+const globalRegistry = {};
+const UNDEFINED = Symbol('undefined');
+class Infact {
+    constructor(options) {
+        this.options = options;
+        this.registry = {};
+        this.provideRegByInstance = new WeakMap();
+        this.scopes = {};
+        this._silent = false;
+        this.logger = options.logger || console;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    silent(value = 'logs') {
+        this._silent = value;
+    }
+    registerScope(scopeId) {
+        if (!this.scopes[scopeId]) {
+            this.scopes[scopeId] = {};
+        }
+    }
+    unregisterScope(scopeId) {
+        delete this.scopes[scopeId];
+    }
+    getForInstance(instance, classConstructor, opts) {
+        return this.get(classConstructor, { ...opts, provide: this.getProvideRegByInstnce(instance) || {} });
+    }
+    async get(classConstructor, opts, optional = false) {
+        const result = await this._get(classConstructor, opts, optional);
+        if (result) {
+            const { instance, mergedProvide } = result;
+            if (this.options.storeProvideRegByInstance) {
+                this.setProvideRegByInstance(instance, mergedProvide);
+            }
+            return instance;
+        }
+        return undefined;
+    }
+    setProvideRegByInstance(instance, provide) {
+        this.provideRegByInstance.set(instance, provide);
+    }
+    getProvideRegByInstnce(instance) {
+        return this.provideRegByInstance.get(instance) || {};
+    }
+    async _get(classConstructor, opts, optional) {
+        const hierarchy = (opts === null || opts === void 0 ? void 0 : opts.hierarchy) || [];
+        const provide = opts === null || opts === void 0 ? void 0 : opts.provide;
+        const syncContextFn = opts === null || opts === void 0 ? void 0 : opts.syncContextFn;
+        hierarchy.push(classConstructor.name);
+        let classMeta;
+        try {
+            classMeta = this.options.describeClass(classConstructor);
+        }
+        catch (e) {
+            throw this.panicOwnError(`Could not instantiate "${classConstructor.name}". `
+                + `An error occored on "describeClass" function.\n${e.message}`, hierarchy);
+        }
+        const instanceKey = Symbol.for(classConstructor);
+        if (!classMeta || !classMeta.injectable) {
+            if (provide && provide[instanceKey]) {
+                syncContextFn && syncContextFn(classMeta);
+                return { instance: await getProvidedValue(provide[instanceKey]), mergedProvide: provide };
+            }
+            if (!optional) {
+                throw this.panicOwnError(`Could not instantiate Injectable "${classConstructor.name}". `
+                    + 'Please check if the class is injectable or if you properly typed arguments.', hierarchy);
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (classMeta.scopeId && classMeta.global) {
+            throw this.panicOwnError(`Could not instantiate scoped Injectable "${classConstructor.name}" for scope "${classMeta.scopeId}". `
+                + 'The scoped Injectable is not supported for Global scope.', hierarchy);
+        }
+        if (classMeta.scopeId && !this.scopes[classMeta.scopeId]) {
+            throw this.panicOwnError(`Could not instantiate scoped Injectable "${classConstructor.name}" for scope "${classMeta.scopeId}". `
+                + 'The requested scope isn\'t registered.', hierarchy);
+        }
+        const scope = classMeta.scopeId ? this.scopes[classMeta.scopeId] : {};
+        const mergedProvide = { ...(provide || {}), ...(classMeta.provide || {}) };
+        if (mergedProvide[instanceKey]) {
+            syncContextFn && syncContextFn(classMeta);
+            return { instance: await getProvidedValue(mergedProvide[instanceKey]), mergedProvide };
+        }
+        if (!this.registry[instanceKey] && !globalRegistry[instanceKey] && !scope[instanceKey]) {
+            const registry = classMeta.scopeId ? scope : classMeta.global ? globalRegistry : this.registry;
+            const params = classMeta.constructorParams || [];
+            const isCircular = !!params.find(p => !!p.circular);
+            if (isCircular) {
+                registry[instanceKey] = Object.create(classConstructor.prototype);
+            }
+            const resolvedParams = [];
+            for (let i = 0; i < params.length; i++) {
+                const param = params[i];
+                if (param.inject) {
+                    if (mergedProvide && mergedProvide[param.inject]) {
+                        resolvedParams[i] = getProvidedValue(mergedProvide[param.inject]);
+                    }
+                    else if (param.nullable || param.optional) {
+                        resolvedParams[i] = UNDEFINED;
+                    }
+                    else {
+                        throw this.panicOwnError(`Could not inject ${JSON.stringify(param.inject)} to "${classConstructor.name}" to argument ${param.label ? `labeled as "${param.label}"` : `with index ${i}`}`, hierarchy);
+                    }
+                }
+                else if (this.options.resolveParam) {
+                    resolvedParams[i] = this.options.resolveParam({
+                        classMeta,
+                        classConstructor,
+                        index: i,
+                        paramMeta: param,
+                        customData: opts === null || opts === void 0 ? void 0 : opts.customData,
+                    });
+                }
+            }
+            for (let i = 0; i < resolvedParams.length; i++) {
+                const rp = resolvedParams[i];
+                if (rp && rp !== UNDEFINED && typeof rp.then === 'function') {
+                    try {
+                        syncContextFn && syncContextFn(classMeta);
+                        resolvedParams[i] = await rp;
+                    }
+                    catch (e) {
+                        const param = params[i];
+                        throw this.panic(e, `Could not inject "${param.type.name}" to "${classConstructor.name}" `
+                            + `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. An exception occured.`, hierarchy);
+                    }
+                }
+            }
+            for (let i = 0; i < params.length; i++) {
+                const param = params[i];
+                if (typeof resolvedParams[i] === 'undefined') {
+                    if (param.type === undefined && !param.circular) {
+                        if (this._silent === false) {
+                            this.logger.warn(`${classConstructor.name}.constructor() expects argument ${param.label ? `labeled as "${param.label}"` : `#${i}`} that is undefined. This might happen when Circular Dependency occurs. To handle Circular Dependencies please specify circular meta for param.`);
+                        }
+                    }
+                    else if (param.type === undefined && param.circular) {
+                        param.type = param.circular();
+                    }
+                    if (typeof param.type === 'function') {
+                        if ([String, Number, Date, Array].includes(param.type)) {
+                            if (!param.nullable && !param.optional) {
+                                throw this.panicOwnError(`Could not inject "${param.type.name}" to "${classConstructor.name}" `
+                                    + `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. The param was not resolved to a value.`, hierarchy);
+                            }
+                        }
+                        resolvedParams[i] = this.get(param.type, { provide: mergedProvide, hierarchy, syncContextFn, customData: opts === null || opts === void 0 ? void 0 : opts.customData }, param.optional || param.nullable);
+                    }
+                }
+                if (resolvedParams[i] === UNDEFINED) {
+                    resolvedParams[i] = undefined;
+                }
+            }
+            for (let i = 0; i < resolvedParams.length; i++) {
+                const rp = resolvedParams[i];
+                if (rp && typeof rp.then === 'function') {
+                    try {
+                        syncContextFn && syncContextFn(classMeta);
+                        resolvedParams[i] = await rp;
+                    }
+                    catch (e) {
+                        const param = params[i];
+                        throw this.panic(e, `Could not inject "${param.type.name}" to "${classConstructor.name}" `
+                            + `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. An exception occured.`, hierarchy);
+                    }
+                }
+            }
+            const instance = new classConstructor(...resolvedParams);
+            if (isCircular) {
+                Object.assign(registry[instanceKey], instance);
+            }
+            else {
+                registry[instanceKey] = instance;
+            }
+            if (this.options.describeProp && this.options.resolveProp && classMeta.properties && classMeta.properties.length) {
+                const resolvedProps = {};
+                for (const prop of classMeta.properties) {
+                    const initialValue = instance[prop];
+                    let propMeta;
+                    try {
+                        propMeta = this.options.describeProp(classConstructor, prop);
+                    }
+                    catch (e) {
+                        throw this.panic(e, `Could not process prop "${prop}" of "${classConstructor.name}". `
+                            + `An error occored on "describeProp" function.\n${e.message}`, hierarchy);
+                    }
+                    if (propMeta) {
+                        try {
+                            resolvedProps[prop] = this.options.resolveProp({
+                                classMeta,
+                                classConstructor,
+                                initialValue,
+                                key: prop,
+                                instance,
+                                propMeta,
+                                customData: opts === null || opts === void 0 ? void 0 : opts.customData,
+                            });
+                        }
+                        catch (e) {
+                            throw this.panic(e, `Could not inject prop "${prop}" to "${classConstructor.name}". `
+                                + 'An exception occured: ' + e.message, hierarchy);
+                        }
+                    }
+                }
+                for (const [prop, value] of Object.entries(resolvedProps)) {
+                    try {
+                        syncContextFn && syncContextFn(classMeta);
+                        resolvedProps[prop] = value ? await value : value;
+                    }
+                    catch (e) {
+                        throw this.panic(e, `Could not inject prop "${prop}" to "${classConstructor.name}". `
+                            + 'An exception occured: ' + e.message, hierarchy);
+                    }
+                }
+                Object.assign(instance, resolvedProps);
+            }
+            if (this._silent === false) {
+                this.logger.info(`Class "${'' + classConstructor.name + '' + ''}" instantiated with: ${''}[${resolvedParams.map(p => {
+                    switch (typeof p) {
+                        case 'number':
+                        case 'boolean':
+                            return p;
+                        case 'string':
+                            return `"${''}...${''}"`;
+                        case 'object':
+                            if (getConstructor(p))
+                                return getConstructor(p).name;
+                            return '{}';
+                        default: return '*';
+                    }
+                }).join(', ')}]`);
+            }
+        }
+        hierarchy.pop();
+        syncContextFn && syncContextFn(classMeta);
+        return { instance: await (scope[instanceKey] || this.registry[instanceKey] || globalRegistry[instanceKey]), mergedProvide };
+    }
+    panic(origError, text, hierarchy) {
+        if (this._silent === true) ;
+        else {
+            this.logger.error(text + (hierarchy ? ('\nHierarchy:\n' + hierarchy.join(' -> ')) : ''));
+        }
+        return origError;
+    }
+    panicOwnError(text, hierarchy) {
+        const e = new Error(text + (hierarchy ? ('\nHierarchy:\n' + hierarchy.join(' -> ')) : ''));
+        if (this._silent === true) {
+            return e;
+        }
+        else {
+            this.logger.error(e);
+            return e;
+        }
+    }
 }
-function WfFlow(path) {
+function getProvidedValue(meta) {
+    if (!meta.resolved) {
+        meta.resolved = true;
+        meta.value = meta.fn();
+    }
+    return meta.value;
+}
+
+function runPipes(pipes, initialValue, metas, level, restoreCtx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let v = initialValue;
+        for (const pipe of pipes) {
+            restoreCtx && restoreCtx();
+            v = yield pipe.handler(v, metas, level);
+        }
+        return v;
+    });
+}
+
+getNewMoostInfact();
+function getNewMoostInfact() {
+    return new Infact({
+        describeClass(classConstructor) {
+            const meta = getMoostMate().read(classConstructor);
+            const infactMeta = {
+                injectable: !!(meta === null || meta === void 0 ? void 0 : meta.injectable),
+                global: false,
+                constructorParams: (meta === null || meta === void 0 ? void 0 : meta.params) || [],
+                provide: meta === null || meta === void 0 ? void 0 : meta.provide,
+                properties: (meta === null || meta === void 0 ? void 0 : meta.properties) || [],
+                scopeId: (meta === null || meta === void 0 ? void 0 : meta.injectable) === 'FOR_EVENT'
+                    ? useEventId().getId()
+                    : undefined,
+            };
+            return infactMeta;
+        },
+        resolveParam({ paramMeta, classMeta, customData, classConstructor, index }) {
+            if (paramMeta && customData && customData.pipes) {
+                return runPipes(customData.pipes, undefined, {
+                    paramMeta,
+                    type: classConstructor,
+                    key: 'constructor',
+                    classMeta: classMeta,
+                    index,
+                    targetMeta: paramMeta,
+                }, 'PARAM');
+            }
+        },
+        describeProp(classConstructor, key) {
+            const meta = getMoostMate().read(classConstructor, key);
+            return meta;
+        },
+        resolveProp({ instance, key, initialValue, propMeta, classMeta, customData, classConstructor, }) {
+            if (propMeta && customData && customData.pipes) {
+                return runPipes(customData.pipes, initialValue, {
+                    instance,
+                    type: classConstructor,
+                    key,
+                    propMeta,
+                    targetMeta: propMeta,
+                    classMeta: classMeta,
+                }, 'PROP');
+            }
+        },
+        storeProvideRegByInstance: true,
+    });
+}
+
+/**
+ * ## Label
+ * ### @Decorator
+ * _Common purpose decorator that may be used by various adapters for various purposes_
+ *
+ * Stores Label metadata
+ */
+function Label(value) {
+    return getMoostMate().decorate('label', value);
+}
+
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @param resolver - resolver function
+ * @param label - field label
+ * @paramType unknown
+ */
+function Resolve(resolver, label) {
+    return (target, key, index) => {
+        const i = typeof index === 'number' ? index : undefined;
+        getMoostMate().decorate('resolver', (metas, level) => {
+            let newLabel = label;
+            if (!newLabel && level === 'PROP' && typeof metas.key === 'string') {
+                newLabel = metas.key;
+            }
+            fillLabel(target, key || '', i, newLabel);
+            return resolver(metas, level);
+        })(target, key, i);
+    };
+}
+function fillLabel(target, key, index, name) {
+    if (name) {
+        const meta = getMoostMate().read(target, key);
+        if (typeof index === 'number') {
+            if (!(meta === null || meta === void 0 ? void 0 : meta.params) ||
+                !(meta === null || meta === void 0 ? void 0 : meta.params[index]) ||
+                !(meta === null || meta === void 0 ? void 0 : meta.params[index].label)) {
+                Label(name)(target, key, index);
+            }
+        }
+        else {
+            if (!(meta === null || meta === void 0 ? void 0 : meta.label)) {
+                Label(name)(target, key);
+            }
+        }
+    }
+}
+
+getMoostMate().decorate((meta) => {
+    if (!meta.injectable)
+        meta.injectable = true;
+    return meta;
+});
+
+var TInterceptorPriority;
+(function (TInterceptorPriority) {
+    TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
+    TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
+    TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
+    TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
+    TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
+    TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
+    TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
+})(TInterceptorPriority || (TInterceptorPriority = {}));
+
+var TPipePriority;
+(function (TPipePriority) {
+    TPipePriority[TPipePriority["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
+    TPipePriority[TPipePriority["RESOLVE"] = 1] = "RESOLVE";
+    TPipePriority[TPipePriority["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
+    TPipePriority[TPipePriority["BEFORE_TRANSFORM"] = 3] = "BEFORE_TRANSFORM";
+    TPipePriority[TPipePriority["TRANSFORM"] = 4] = "TRANSFORM";
+    TPipePriority[TPipePriority["AFTER_TRANSFORM"] = 5] = "AFTER_TRANSFORM";
+    TPipePriority[TPipePriority["BEFORE_VALIDATE"] = 6] = "BEFORE_VALIDATE";
+    TPipePriority[TPipePriority["VALIDATE"] = 7] = "VALIDATE";
+    TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
+})(TPipePriority || (TPipePriority = {}));
+
+/**
+ * ### Define Pipe Function
+ *
+ * ```ts
+ * // example of a transform pipe
+ * const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
+ *         return typeof value === 'string' ? value.toUpperCase() : value
+ *     },
+ *     TPipePriority.TRANSFORM,
+ * )
+ * ```
+ *
+ * @param fn interceptor function
+ * @param priority priority of the pipe where BEFORE_RESOLVE = 0, RESOLVE = 1, AFTER_RESOLVE = 2, BEFORE_TRANSFORM = 3, TRANSFORM = 4, AFTER_TRANSFORM = 5, BEFORE_VALIDATE = 6, VALIDATE = 7, AFTER_VALIDATE = 8
+ * @returns
+ */
+function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
+    fn.priority = priority;
+    return fn;
+}
+
+const resolvePipe = definePipeFn((_value, metas, level) => {
+    var _a;
+    const resolver = (_a = metas.targetMeta) === null || _a === void 0 ? void 0 : _a.resolver;
+    if (resolver) {
+        return resolver(metas, level);
+    }
+    return undefined;
+}, TPipePriority.RESOLVE);
+
+[
+    {
+        handler: resolvePipe,
+        priority: TPipePriority.RESOLVE,
+    },
+];
+
+const defaultLevels = [
+    'fatal',
+    'error',
+    'warn',
+    'log',
+    'info',
+    'debug',
+    'trace',
+];
+const defaultMappedLevels = new Map();
+defaultLevels.forEach((type, level) => defaultMappedLevels.set(type, level));
+
+function WStep(path) {
     return getWfMate().decorate('handlers', { path, type: 'WF_STEP' }, true);
 }
-function WfSchema(schema) {
+function WFlow(path) {
+    return getWfMate().decorate('handlers', { path, type: 'WF_FLOW' }, true);
+}
+function WSchema(schema) {
     return getWfMate().decorate('wfSchema', schema);
-}
+}
+const WfCtx = (name) => Resolve(() => {
+    const c = useWfState().ctx();
+    return name ? c[name] : c;
+}, name || 'WfCtx');
+const WfResume = () => Resolve(() => useWfState().resume);
+const WfIndexes = () => Resolve(() => useWfState().indexes);
+const WfSchemaId = () => Resolve(() => useWfState().schemaId);
+const WfInput = (name) => Resolve(() => {
+    const i = useWfState().input();
+    return name ? i[name] : i;
+}, name || 'WfInput');
 
 /**
  * Wrapper on top of useEventContext that provides
@@ -147,4 +834,4 @@ function useCliContext() {
     return useEventContext('CLI');
 }
 
-export { MoostWf, WfFlow, WfSchema, WfStep, useCliContext };
+export { MoostWf, WFlow, WSchema, WStep, WfCtx, WfIndexes, WfInput, WfResume, WfSchemaId, useCliContext };