assemblerjs 1.0.0 → 1.1.0

package/dist/index.js

@@ -11,18 +11,22 @@ const abstract = require('./index7.js');
 const types = require('./index8.js');
 const listenerCollection_abstract = require('./index9.js');
 const eventManager_abstract = require('./index10.js');
-const _await = require('./index11.js');
-const indexFactory = require('./index12.js');
-const parameterDecoratorFactory = require('./index13.js');
-const context = require('./index14.js');
-const configuration = require('./index15.js');
-const definition = require('./index16.js');
-const dispose = require('./index17.js');
-const use = require('./index18.js');
-const global = require('./index19.js');
-const optional = require('./index20.js');
-const helpers$1 = require('./index21.js');
-const constructorDecorator = require('./index22.js');
+const decorators = require('./index11.js');
+const affect = require('./index12.js');
+const transversalManager = require('./index13.js');
+const abstract$1 = require('./index14.js');
+const _await = require('./index15.js');
+const indexFactory = require('./index16.js');
+const parameterDecoratorFactory = require('./index17.js');
+const context = require('./index18.js');
+const configuration = require('./index19.js');
+const definition = require('./index20.js');
+const dispose = require('./index21.js');
+const use = require('./index22.js');
+const global = require('./index23.js');
+const optional = require('./index24.js');
+const helpers$1 = require('./index25.js');
+const constructorDecorator = require('./index26.js');
 
 
 
@@ -38,6 +42,14 @@ exports.AbstractAssemblage = abstract.AbstractAssemblage;
 exports.AbstractAssembler = types.AbstractAssembler;
 exports.AbstractListenerCollection = listenerCollection_abstract.AbstractListenerCollection;
 exports.AbstractEventManager = eventManager_abstract.AbstractEventManager;
+exports.After = decorators.After;
+exports.Around = decorators.Around;
+exports.Before = decorators.Before;
+exports.Transversal = decorators.Transversal;
+exports.isTransversal = decorators.isTransversal;
+exports.Affect = affect.Affect;
+exports.TransversalManager = transversalManager.TransversalManager;
+exports.AbstractTransversal = abstract$1.AbstractTransversal;
 exports.Await = _await.Await;
 exports.createParamIndexDecorator = indexFactory.createParamIndexDecorator;
 exports.ParameterDecoratorFactory = parameterDecoratorFactory.ParameterDecoratorFactory;

package/dist/index.mjs

@@ -7,15 +7,19 @@ export { AbstractAssemblage } from './index7.mjs';
 export { AbstractAssembler } from './index8.mjs';
 export { AbstractListenerCollection } from './index9.mjs';
 export { AbstractEventManager } from './index10.mjs';
-export { Await } from './index11.mjs';
-export { createParamIndexDecorator } from './index12.mjs';
-export { ParameterDecoratorFactory } from './index13.mjs';
-export { Context } from './index14.mjs';
-export { Configuration } from './index15.mjs';
-export { Definition } from './index16.mjs';
-export { Dispose } from './index17.mjs';
-export { Use, decorateUse } from './index18.mjs';
-export { Global, decorateGlobal } from './index19.mjs';
-export { Optional } from './index20.mjs';
-export { getDecoratedParametersIndexes, getParamIndexKey, getParamValueKey, getParameterIndexes, getParameterValues } from './index21.mjs';
-export { ConstructorDecorator, createConstructorDecorator } from './index22.mjs';
+export { After, Around, Before, Transversal, isTransversal } from './index11.mjs';
+export { Affect } from './index12.mjs';
+export { TransversalManager } from './index13.mjs';
+export { AbstractTransversal } from './index14.mjs';
+export { Await } from './index15.mjs';
+export { createParamIndexDecorator } from './index16.mjs';
+export { ParameterDecoratorFactory } from './index17.mjs';
+export { Context } from './index18.mjs';
+export { Configuration } from './index19.mjs';
+export { Definition } from './index20.mjs';
+export { Dispose } from './index21.mjs';
+export { Use, decorateUse } from './index22.mjs';
+export { Global, decorateGlobal } from './index23.mjs';
+export { Optional } from './index24.mjs';
+export { getDecoratedParametersIndexes, getParamIndexKey, getParamValueKey, getParameterIndexes, getParameterValues } from './index25.mjs';
+export { ConstructorDecorator, createConstructorDecorator } from './index26.mjs';

package/dist/index11.js

@@ -2,26 +2,88 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const Await = (t, e = 25)=>{
-    return (n, s, a)=>{
-        const i = a.value;
-        a.value = async function() {
-            return new Promise((n)=>{
-                if (this[t]) {
-                    i.apply(this);
-                    n();
-                } else {
-                    const s = setInterval(()=>{
-                        if (this[t]) {
-                            clearInterval(s);
-                            i.apply(this);
-                            n();
-                        }
-                    }, e);
-                }
-            });
+const constants = require('./index28.js');
+const reflection = require('./index34.js');
+const decorator = require('./index2.js');
+const schema = require('./index37.js');
+
+function isTransversal(e) {
+    try {
+        const t = schema.getDefinition(e);
+        return t?.metadata?.isTransversal === true;
+    } catch  {
+        return false;
+    }
+}
+function Transversal(t) {
+    return function(a) {
+        if (t) {
+            if ('inject' in t || 'use' in t) {
+                throw new Error(`@Transversal on class ${a.name} cannot have inject or use properties. ` + `Aspects receive dependencies through constructor parameters resolved from parent context.`);
+            }
+        }
+        const s = reflection.getCustomMetadata(constants.ReflectValue.TransversalAdvices, a) || [];
+        const o = {
+            singleton: true,
+            ...t,
+            inject: [],
+            use: [],
+            metadata: {
+                ...t?.metadata,
+                isTransversal: true,
+                advices: s
+            }
         };
+        return decorator.Assemblage(o)(a);
+    };
+}
+function Before(e, t = 0) {
+    return function(r, n, a) {
+        s(r.constructor, {
+            type: 'before',
+            pointcut: e,
+            methodName: n,
+            priority: t,
+            enabled: true
+        });
+    };
+}
+function After(e, t = 0) {
+    return function(r, n, a) {
+        s(r.constructor, {
+            type: 'after',
+            pointcut: e,
+            methodName: n,
+            priority: t,
+            enabled: true
+        });
+    };
+}
+function Around(e, t = 0) {
+    return function(r, n, a) {
+        s(r.constructor, {
+            type: 'around',
+            pointcut: e,
+            methodName: n,
+            priority: t,
+            enabled: true
+        });
     };
-};
+}
+function s(e, a) {
+    const s = reflection.getCustomMetadata(constants.ReflectValue.TransversalAdvices, e) || [];
+    s.push(a);
+    reflection.defineCustomMetadata(constants.ReflectValue.TransversalAdvices, s, e);
+    const o = reflection.getCustomMetadata('assemblage:definition.value', e) || {};
+    if (!o.metadata) {
+        o.metadata = {};
+    }
+    o.metadata.advices = s;
+    reflection.defineCustomMetadata('assemblage:definition.value', o, e);
+}
 
-exports.Await = Await;
+exports.After = After;
+exports.Around = Around;
+exports.Before = Before;
+exports.Transversal = Transversal;
+exports.isTransversal = isTransversal;

package/dist/index11.mjs

@@ -1,23 +1,81 @@
-const Await = (t, e = 25)=>{
-    return (n, s, a)=>{
-        const i = a.value;
-        a.value = async function() {
-            return new Promise((n)=>{
-                if (this[t]) {
-                    i.apply(this);
-                    n();
-                } else {
-                    const s = setInterval(()=>{
-                        if (this[t]) {
-                            clearInterval(s);
-                            i.apply(this);
-                            n();
-                        }
-                    }, e);
-                }
-            });
+import { ReflectValue } from './index28.mjs';
+import { getCustomMetadata, defineCustomMetadata } from './index34.mjs';
+import { Assemblage } from './index2.mjs';
+import { getDefinition } from './index37.mjs';
+
+function isTransversal(e) {
+    try {
+        const t = getDefinition(e);
+        return t?.metadata?.isTransversal === true;
+    } catch  {
+        return false;
+    }
+}
+function Transversal(t) {
+    return function(a) {
+        if (t) {
+            if ('inject' in t || 'use' in t) {
+                throw new Error(`@Transversal on class ${a.name} cannot have inject or use properties. ` + `Aspects receive dependencies through constructor parameters resolved from parent context.`);
+            }
+        }
+        const s = getCustomMetadata(ReflectValue.TransversalAdvices, a) || [];
+        const o = {
+            singleton: true,
+            ...t,
+            inject: [],
+            use: [],
+            metadata: {
+                ...t?.metadata,
+                isTransversal: true,
+                advices: s
+            }
         };
+        return Assemblage(o)(a);
+    };
+}
+function Before(e, t = 0) {
+    return function(r, n, a) {
+        s(r.constructor, {
+            type: 'before',
+            pointcut: e,
+            methodName: n,
+            priority: t,
+            enabled: true
+        });
+    };
+}
+function After(e, t = 0) {
+    return function(r, n, a) {
+        s(r.constructor, {
+            type: 'after',
+            pointcut: e,
+            methodName: n,
+            priority: t,
+            enabled: true
+        });
+    };
+}
+function Around(e, t = 0) {
+    return function(r, n, a) {
+        s(r.constructor, {
+            type: 'around',
+            pointcut: e,
+            methodName: n,
+            priority: t,
+            enabled: true
+        });
     };
-};
+}
+function s(e, a) {
+    const s = getCustomMetadata(ReflectValue.TransversalAdvices, e) || [];
+    s.push(a);
+    defineCustomMetadata(ReflectValue.TransversalAdvices, s, e);
+    const o = getCustomMetadata('assemblage:definition.value', e) || {};
+    if (!o.metadata) {
+        o.metadata = {};
+    }
+    o.metadata.advices = s;
+    defineCustomMetadata('assemblage:definition.value', o, e);
+}
 
-export { Await };
+export { After, Around, Before, Transversal, isTransversal };

package/dist/index12.js

@@ -2,15 +2,24 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const reflection = require('./index30.js');
+require('./index27.js');
+const constants = require('./index28.js');
 
-const t = (t)=>()=>{
-        return (e, c, n)=>{
-            const a = reflection.getOwnCustomMetadata(t, e) || [];
-            a.push(n);
-            reflection.defineCustomMetadata(t, a, e);
+function Affect(t, f) {
+    return function(o, c, n) {
+        const d = {
+            transversal: t,
+            config: f
         };
+        const a = Reflect.getOwnMetadata(constants.ReflectValue.AffectedMethods, o, c) || [];
+        a.push(d);
+        Reflect.defineMetadata(constants.ReflectValue.AffectedMethods, a, o, c);
+        return n;
     };
-const createParamIndexDecorator = t;
+}
+function getAffectedMethods(t, f) {
+    return Reflect.getOwnMetadata(constants.ReflectValue.AffectedMethods, t, f) || [];
+}
 
-exports.createParamIndexDecorator = createParamIndexDecorator;
+exports.Affect = Affect;
+exports.getAffectedMethods = getAffectedMethods;

package/dist/index12.mjs

@@ -1,12 +1,20 @@
-import { getOwnCustomMetadata, defineCustomMetadata } from './index30.mjs';
+import './index27.mjs';
+import { ReflectValue } from './index28.mjs';
 
-const t = (t)=>()=>{
-        return (e, c, n)=>{
-            const a = getOwnCustomMetadata(t, e) || [];
-            a.push(n);
-            defineCustomMetadata(t, a, e);
+function Affect(t, f) {
+    return function(o, c, n) {
+        const d = {
+            transversal: t,
+            config: f
         };
+        const a = Reflect.getOwnMetadata(ReflectValue.AffectedMethods, o, c) || [];
+        a.push(d);
+        Reflect.defineMetadata(ReflectValue.AffectedMethods, a, o, c);
+        return n;
     };
-const createParamIndexDecorator = t;
+}
+function getAffectedMethods(t, f) {
+    return Reflect.getOwnMetadata(ReflectValue.AffectedMethods, t, f) || [];
+}
 
-export { createParamIndexDecorator };
+export { Affect, getAffectedMethods };

package/dist/index13.js

@@ -2,93 +2,168 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const reflection = require('./index30.js');
+const core = require('@assemblerjs/core');
+const pointcutMatcher = require('./index39.js');
+const affect = require('./index12.js');
+const schema = require('./index37.js');
 
-class ParameterDecoratorFactory {
-    static create(e) {
-        const { name: r, valueType: t = 'single', handler: a } = e;
-        if (this.registeredDecorators.has(r)) {
-            throw new Error(`Decorator ${r} already exists`);
+class TransversalManager {
+    static getInstance(e) {
+        let t = this.instances.get(e);
+        if (!t) {
+            t = new TransversalManager(e);
+            this.instances.set(e, t);
         }
-        const s = `assemblage:${r.toLowerCase()}.param.index`;
-        const o = `assemblage:${r.toLowerCase()}.param.value`;
-        const c = this.createDecoratorFunction(s, o, t);
-        this.registeredDecorators.set(r, {
-            name: r,
-            valueType: t,
-            handler: a
-        });
-        return c;
+        return t;
     }
-    static createDecoratorFunction(e, r, t) {
-        return (a)=>{
-            return (s, o, c)=>{
-                this.storeParameterData(a, s, c, e, r, t);
-            };
-        };
+    getTransversalInstance(e) {
+        return TransversalManager.transversalInstances.get(e);
+    }
+    static resetGlobalState() {
+        TransversalManager.transversalInstances.clear();
+        TransversalManager.transversalMetadata.clear();
+        TransversalManager.instances = new WeakMap();
     }
-    static validateSingleDecoratorPerParameter(r, t, a) {
-        for (const s of this.registeredDecorators.keys()){
-            const o = `assemblage:${s.toLowerCase()}.param.index`;
-            if (o === a) {
-                continue;
+    registerTransversal(t, n) {
+        let s;
+        let r;
+        let o;
+        if (t.length === 1) {
+            s = t[0];
+            r = t[0];
+            o = undefined;
+        } else if (t.length === 2) {
+            const a = t[1];
+            if (core.isClass(a)) {
+                s = t[0];
+                r = a;
+                o = undefined;
+            } else {
+                s = t[0];
+                r = t[0];
+                o = a;
             }
-            const c = reflection.getOwnCustomMetadata(o, r) || [];
-            if (c.includes(t)) {
-                throw new Error(`Parameter at index ${t} already has decorator @${s}. ` + `Multiple decorators per parameter are not allowed.`);
+        } else {
+            s = t[0];
+            r = t[1];
+            o = t[2];
+        }
+        const c = r.name;
+        if (!TransversalManager.transversalInstances.has(c)) {
+            const e = n || this.context;
+            const t = e.require(s, o);
+            const i = schema.getDefinition(r);
+            if (!i) {
+                throw new Error(`Transversal ${c} must be decorated with @Transversal`);
             }
+            TransversalManager.transversalInstances.set(c, t);
+            const l = {
+                definition: i,
+                advices: this.extractAdvices(r, t),
+                instance: t
+            };
+            TransversalManager.transversalMetadata.set(c, l);
         }
     }
-    static storeParameterData(t, a, s, o, c, i) {
-        this.validateSingleDecoratorPerParameter(a, s, o);
-        const n = reflection.getOwnCustomMetadata(o, a) || [];
-        n.push(s);
-        reflection.defineCustomMetadata(o, n, a);
-        switch(i){
-            case 'single':
-                {
-                    reflection.defineCustomMetadata(c, t, a);
-                    break;
-                }
-            case 'array':
-                {
-                    const o = reflection.getOwnCustomMetadata(c, a) || [];
-                    o[s] = t;
-                    reflection.defineCustomMetadata(c, o, a);
-                    break;
-                }
-            case 'map':
-                {
-                    const o = reflection.getOwnCustomMetadata(c, a) || {};
-                    o[s] = t;
-                    reflection.defineCustomMetadata(c, o, a);
-                    break;
-                }
+    extractAdvices(e, t) {
+        const n = schema.getDefinition(e);
+        const s = [];
+        const r = n?.metadata?.advices || [];
+        for (const a of r){
+            const n = t[a.methodName];
+            if (typeof n !== 'function') {
+                throw new Error(`Advice method ${a.methodName} not found in ${e.name}`);
+            }
+            const r = a.pointcut.startsWith('execution(') ? undefined : a.pointcut;
+            s.push({
+                type: a.type,
+                pointcut: a.pointcut,
+                method: n,
+                transversalInstance: t,
+                priority: a.priority || 0,
+                enabled: a.enabled ?? true,
+                role: r
+            });
         }
+        return s;
     }
-    static createParameterIndexGetter(r) {
-        return (t)=>{
-            return reflection.getOwnCustomMetadata(r, t) || [];
-        };
-    }
-    static createParameterValueGetter(r, t) {
-        return (t)=>{
-            return reflection.getOwnCustomMetadata(r, t);
-        };
+    getAspectsForTarget(e) {
+        const t = [];
+        for (const a of TransversalManager.transversalMetadata.values()){
+            if (this.hasMatchingAdviceForClass(a, e)) {
+                t.push(a);
+            }
+        }
+        return t;
     }
-    static getRegisteredDecorators() {
-        return Array.from(this.registeredDecorators.keys());
+    hasMatchingAdviceForClass(e, t) {
+        return e.advices.some((e)=>{
+            if (!e.enabled) return false;
+            const a = e.pointcut.match(/execution\(([^.]+)\.[^)]+\)/);
+            if (a) {
+                const e = a[1];
+                const n = this.patternToRegex(e);
+                return n.test(t.name);
+            }
+            return false;
+        });
     }
-    static isRegistered(e) {
-        return this.registeredDecorators.has(e);
+    patternToRegex(e) {
+        if (e === '*') {
+            return /.*/;
+        }
+        const t = e.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        const a = t.replace(/\*/g, '.*');
+        return new RegExp(`^${a}$`);
     }
-    static getDecoratorMetadata(e) {
-        return this.registeredDecorators.get(e);
+    getAdvicesForJoinPoint(e, a, s, r) {
+        const o = [];
+        for (const n of a){
+            for (const a of n.advices){
+                if (!a.enabled) continue;
+                const n = pointcutMatcher.PointcutMatcher.parse(a.pointcut);
+                if (n.matches(e)) {
+                    o.push(a);
+                }
+            }
+        }
+        if (s && r) {
+            const e = s.constructor.prototype;
+            const t = affect.getAffectedMethods(e, r);
+            for (const e of t){
+                const t = e.transversal;
+                const a = typeof t === 'function' ? t.name : String(t);
+                let n = TransversalManager.transversalMetadata.get(a);
+                if (!n && typeof t === 'function') {
+                    const e = Object.getPrototypeOf(t);
+                    if (e && e.name) {
+                        n = TransversalManager.transversalMetadata.get(e.name);
+                    }
+                }
+                if (!n) {
+                    console.warn(`@Affect: Transversal ${a} not found. Make sure it's registered in transversals[].`);
+                    continue;
+                }
+                for (const t of n.advices){
+                    if (!t.enabled) continue;
+                    if (e.role && t.role !== e.role) {
+                        continue;
+                    }
+                    o.push({
+                        ...t,
+                        config: e.config
+                    });
+                }
+            }
+        }
+        return o.sort((e, t)=>t.priority - e.priority);
     }
-    static getDecoratorHandler(e) {
-        return this.registeredDecorators.get(e)?.handler;
+    constructor(e){
+        this.context = e;
     }
 }
-ParameterDecoratorFactory.registeredDecorators = new Map();
+TransversalManager.instances = new WeakMap();
+TransversalManager.transversalInstances = new Map();
+TransversalManager.transversalMetadata = new Map();
 
-exports.ParameterDecoratorFactory = ParameterDecoratorFactory;
+exports.TransversalManager = TransversalManager;