@moostjs/otel 0.4.6 → 0.4.7

package/dist/index.mjs

@@ -1,8 +1,11 @@
 import { trace, context, SpanStatusCode } from '@opentelemetry/api';
-import { useAsyncEventContext, eventContextHooks, useControllerContext, getConstructor } from 'moost';
+import { useAsyncEventContext as useAsyncEventContext$1, eventContextHooks as eventContextHooks$1, useControllerContext, getConstructor as getConstructor$2 } from 'moost';
+import { randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
 
 function useOtelContext() {
-    const store = useAsyncEventContext().store('otel');
+    const store = useAsyncEventContext$1().store('otel');
     const getSpan = () => store.get('span');
     const getSpanContext = () => {
         const span = getSpan();
@@ -54,7 +57,7 @@ function useOtelPropagation() {
 }
 
 function enableOtelForMoost() {
-    eventContextHooks.onStartEvent((eventType) => {
+    eventContextHooks$1.onStartEvent((eventType) => {
         if (eventType === 'init') {
             return;
         }
@@ -71,28 +74,30 @@ function enableOtelForMoost() {
             registerSpan(span);
         }
     });
-    eventContextHooks.onEndEvent((eventType, abortReason) => {
+    eventContextHooks$1.onEndEvent((eventType, abortReason) => {
         if (eventType === 'init') {
             return;
         }
         const { getSpan } = useOtelContext();
         const span = getSpan();
         if (span) {
-            const { getMethod, getMethodMeta, getController } = useControllerContext();
+            const { getMethod, getMethodMeta, getController, getControllerMeta } = useControllerContext();
             const methodName = getMethod();
             const methodMeta = getMethodMeta();
+            const cMeta = getControllerMeta();
             span.setAttributes({
                 'custom.event_type': eventType,
                 'custom.event_description': methodMeta?.description || methodMeta?.label || methodName,
-                'moost.controller': getConstructor(getController()).name,
+                'moost.controller': getConstructor$2(getController()).name,
                 'moost.handler': methodName,
+                'moost.ignore': cMeta?.otelIgnoreSpan || methodMeta?.otelIgnoreSpan,
             });
             if (abortReason) {
                 span.recordException(new Error(abortReason));
                 span.setStatus({ code: SpanStatusCode.ERROR, message: abortReason });
             }
             if (eventType === 'HTTP') {
-                const req = useAsyncEventContext()
+                const req = useAsyncEventContext$1()
                     .store('event')
                     .get('req');
                 span.updateName(`${req?.method || ''} ${methodMeta?.id || methodMeta?.label || methodName}`);
@@ -105,4 +110,913 @@ function enableOtelForMoost() {
     });
 }
 
-export { enableOtelForMoost, useOtelContext, useOtelPropagation, useSpan, useTrace };
+const defaultLevels = [
+    'fatal',
+    'error',
+    'warn',
+    'log',
+    'info',
+    'debug',
+    'trace',
+];
+const defaultMappedLevels = new Map();
+defaultLevels.forEach((type, level) => defaultMappedLevels.set(type, level));
+
+class Hookable {
+    constructor() {
+        this.hooks = {};
+    }
+    hook(name, cb) {
+        if (!this.hooks[name]) {
+            this.hooks[name] = [];
+        }
+        this.hooks[name].push(cb);
+        return () => {
+            this.unhook(name, cb);
+        };
+    }
+    callHook(name, ...args) {
+        if (this.hooks[name]) {
+            for (const cb of this.hooks[name]) {
+                try {
+                    cb(...args);
+                }
+                catch (error) {
+                    console.error(`Error in hook ${name}:`, error);
+                }
+            }
+        }
+    }
+    unhook(name, cb) {
+        if (this.hooks[name]) {
+            this.hooks[name] = this.hooks[name].filter(hookCb => hookCb !== cb);
+        }
+    }
+}
+
+class EventContextHooks extends Hookable {
+    fireStartEvent(eventType) {
+        this.callHook('start-event', eventType);
+    }
+    fireEndEvent(eventType, abortReason) {
+        this.callHook('end-event', eventType, abortReason);
+    }
+    onStartEvent(cb) {
+        return this.hook('start-event', cb);
+    }
+    onEndEvent(cb) {
+        return this.hook('end-event', cb);
+    }
+}
+const eventContextHooks = new EventContextHooks();
+
+function attachHook(target, opts, name) {
+    Object.defineProperty(target, name || 'value', {
+        get: opts.get,
+        set: opts.set,
+    });
+    return target;
+}
+
+const asyncStorage = new AsyncLocalStorage();
+function useAsyncEventContext(expectedTypes) {
+    let cc = asyncStorage.getStore();
+    if (!cc) {
+        throw new Error('Event context does not exist at this point.');
+    }
+    if (expectedTypes || typeof expectedTypes === 'string') {
+        const type = cc.event.type;
+        const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
+        if (!types.includes(type)) {
+            if (cc.parentCtx?.event.type && types.includes(cc.parentCtx.event.type)) {
+                cc = cc.parentCtx;
+            }
+            else {
+                throw new Error(`Event context type mismatch: expected ${types
+                    .map(t => `"${t}"`)
+                    .join(', ')}, received "${type}"`);
+            }
+        }
+    }
+    return _getCtxHelpers(cc);
+}
+function _getCtxHelpers(cc) {
+    function store(key) {
+        const obj = {
+            value: null,
+            hook,
+            init,
+            set: setNested,
+            get: getNested,
+            has: hasNested,
+            del: delNested,
+            entries,
+            clear,
+        };
+        attachHook(obj, {
+            set: v => {
+                set(key, v);
+            },
+            get: () => get(key),
+        });
+        function init(key2, getter) {
+            if (hasNested(key2)) {
+                return getNested(key2);
+            }
+            return setNested(key2, getter());
+        }
+        function hook(key2) {
+            const obj = {
+                value: null,
+                isDefined: null,
+            };
+            attachHook(obj, {
+                set: v => setNested(key2, v),
+                get: () => getNested(key2),
+            });
+            attachHook(obj, {
+                get: () => hasNested(key2),
+            }, 'isDefined');
+            return obj;
+        }
+        function setNested(key2, v) {
+            if (obj.value === undefined) {
+                obj.value = {};
+            }
+            obj.value[key2] = v;
+            return v;
+        }
+        function delNested(key2) {
+            setNested(key2, undefined);
+        }
+        function getNested(key2) {
+            return (obj.value || {})[key2];
+        }
+        function hasNested(key2) {
+            return (obj.value || {})[key2] !== undefined;
+        }
+        function entries() {
+            return Object.entries(obj.value || {});
+        }
+        function clear() {
+            obj.value = {};
+        }
+        return obj;
+    }
+    function getCtx() {
+        return cc;
+    }
+    function get(key) {
+        return getCtx()[key];
+    }
+    function set(key, v) {
+        getCtx()[key] = v;
+    }
+    const hasParentCtx = () => !!cc.parentCtx;
+    return {
+        getCtx,
+        endEvent: (abortReason) => {
+            if (cc && !cc._ended) {
+                cc._ended = true;
+                eventContextHooks.fireEndEvent(cc.event.type, abortReason);
+            }
+        },
+        store,
+        getStore: get,
+        setStore: set,
+        setParentCtx: (parentCtx) => {
+            cc.parentCtx = parentCtx;
+        },
+        hasParentCtx,
+        getParentCtx: () => {
+            if (!hasParentCtx()) {
+                throw new Error('Parent context is not available');
+            }
+            return _getCtxHelpers(cc.parentCtx);
+        },
+    };
+}
+
+function useEventId() {
+    const { store } = useAsyncEventContext();
+    const { init } = store('event');
+    const getId = () => init('id', () => randomUUID());
+    return { getId };
+}
+
+function getConstructor$1(instance) {
+    return Object.getPrototypeOf(instance).constructor;
+}
+
+const globalRegistry = {};
+const UNDEFINED = Symbol('undefined');
+class Infact {
+    constructor(options) {
+        this.options = options;
+        this.registry = {};
+        this.instanceRegistries = 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) {
+        const registries = this.getInstanceRegistries(instance);
+        return this.get(classConstructor, {
+            ...opts,
+            provide: registries.provide || {},
+            replace: registries.replace,
+            customData: registries.customData,
+        });
+    }
+    async get(classConstructor, opts, optional = false) {
+        const result = await this._get(classConstructor, opts, optional);
+        if (result) {
+            const { instance, mergedProvide, replace } = result;
+            if (this.options.storeProvideRegByInstance) {
+                this.setInstanceRegistries(instance, mergedProvide, replace, opts === null || opts === void 0 ? void 0 : opts.customData);
+            }
+            return instance;
+        }
+        return undefined;
+    }
+    setInstanceRegistries(instance, provide, replace, customData) {
+        this.instanceRegistries.set(instance, { provide, replace, customData });
+    }
+    getInstanceRegistries(instance) {
+        return this.instanceRegistries.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 replace = opts === null || opts === void 0 ? void 0 : opts.replace;
+        const syncContextFn = opts === null || opts === void 0 ? void 0 : opts.syncContextFn;
+        hierarchy.push(classConstructor.name);
+        let classMeta;
+        let instanceKey = Symbol.for(classConstructor);
+        if (replace && replace[instanceKey]) {
+            classConstructor = replace === null || replace === void 0 ? void 0 : replace[instanceKey];
+            instanceKey = Symbol.for(classConstructor);
+        }
+        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);
+        }
+        if (!classMeta || !classMeta.injectable) {
+            if (provide && provide[instanceKey]) {
+                syncContextFn && syncContextFn(classMeta);
+                return {
+                    instance: await getProvidedValue(provide[instanceKey]),
+                    mergedProvide: provide,
+                    replace,
+                };
+            }
+            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,
+                replace,
+            };
+        }
+        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,
+                            replace,
+                            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$1(p))
+                                return getConstructor$1(p).name;
+                            return '{}';
+                        default:
+                            return '*';
+                    }
+                })
+                    .join(', ')}]`);
+            }
+        }
+        hierarchy.pop();
+        syncContextFn && syncContextFn(classMeta);
+        return {
+            instance: await (scope[instanceKey] ||
+                this.registry[instanceKey] ||
+                globalRegistry[instanceKey]),
+            mergedProvide,
+            replace,
+        };
+    }
+    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 getProvidedValue(meta) {
+    if (!meta.resolved) {
+        meta.resolved = true;
+        meta.value = meta.fn();
+    }
+    return meta.value;
+}
+
+async function runPipes(pipes, initialValue, metas, level) {
+    let v = initialValue;
+    for (const pipe of pipes) {
+        v = await pipe.handler(v, metas, level);
+    }
+    return v;
+}
+
+function getConstructor(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 = new WeakMap();
+const paramMetadata = new WeakMap();
+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 = getConstructor(target);
+    let meta = metadata.get(targetKey);
+    if (!meta) {
+        meta = {};
+        metadata.set(targetKey, meta);
+    }
+    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) {
+        var _a;
+        const isConstr = isConstructor(target);
+        const constructor = isConstr ? target : getConstructor(target);
+        const proto = constructor.prototype;
+        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
+        if (ownMeta && propKey === undefined && ownMeta.params === undefined) {
+            const parent = Object.getPrototypeOf(constructor);
+            if (typeof parent === 'function' &&
+                parent !== fnProto &&
+                parent !== constructor) {
+                ownMeta.params = (_a = this.read(parent)) === null || _a === void 0 ? void 0 : _a.params;
+            }
+        }
+        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?.inherit;
+        }
+        if (level === 'PROP') {
+            return !!targetMeta?.inherit || !!(classMeta?.inherit && !targetMeta);
+        }
+        return !!targetMeta?.inherit;
+    },
+});
+function getMoostMate() {
+    return moostMate;
+}
+
+getNewMoostInfact();
+function getNewMoostInfact() {
+    return new Infact({
+        describeClass(classConstructor) {
+            const meta = getMoostMate().read(classConstructor);
+            return {
+                injectable: !!meta?.injectable,
+                global: false,
+                constructorParams: meta?.params || [],
+                provide: meta?.provide,
+                properties: meta?.properties || [],
+                scopeId: meta?.injectable === 'FOR_EVENT' ? useEventId().getId() : undefined,
+            };
+        },
+        resolveParam({ paramMeta, classMeta, customData, classConstructor, index }) {
+            if (paramMeta && 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?.pipes) {
+                return runPipes(customData.pipes, initialValue, {
+                    instance,
+                    type: classConstructor,
+                    key,
+                    propMeta,
+                    targetMeta: propMeta,
+                    classMeta: classMeta,
+                }, 'PROP');
+            }
+        },
+        storeProvideRegByInstance: true,
+    });
+}
+
+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 = {}));
+
+function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
+    fn.priority = priority;
+    return fn;
+}
+
+const resolvePipe = definePipeFn((_value, metas, level) => {
+    const resolver = metas.targetMeta?.resolver;
+    if (resolver) {
+        return resolver(metas, level);
+    }
+    return undefined;
+}, TPipePriority.RESOLVE);
+
+[
+    {
+        handler: resolvePipe,
+        priority: TPipePriority.RESOLVE,
+    },
+];
+
+function getOtelMate() {
+    return getMoostMate();
+}
+
+const mate = getOtelMate();
+const OtelIgnoreSpan = () => mate.decorate('otelIgnoreSpan', true);
+
+function shouldSpanBeIgnored(span) {
+    return span.attributes['moost.ignore'] === true;
+}
+
+class MoostBatchSpanProcessor extends BatchSpanProcessor {
+    onEnd(span) {
+        if (shouldSpanBeIgnored(span)) {
+            return;
+        }
+        super.onEnd(span);
+    }
+}
+
+class MoostSimpleSpanProcessor extends SimpleSpanProcessor {
+    onEnd(span) {
+        if (shouldSpanBeIgnored(span)) {
+            return;
+        }
+        super.onEnd(span);
+    }
+}
+
+export { MoostBatchSpanProcessor, MoostSimpleSpanProcessor, OtelIgnoreSpan, enableOtelForMoost, getOtelMate, shouldSpanBeIgnored, useOtelContext, useOtelPropagation, useSpan, useTrace };