decorator-dependency-injection 1.0.1 → 1.0.2

package/.github/workflows/release.yml

@@ -48,12 +48,19 @@ jobs:
           TAG_EXISTS=$(git ls-remote --tags origin "v${VERSION}" | wc -l)
           echo "TAG_EXISTS=${TAG_EXISTS}" >> $GITHUB_ENV
 
+      - name: Get commit messages
+        id: commit_messages
+        run: |
+          COMMITS=$(git log --pretty=format:"%h - %s" $(git describe --tags --abbrev=0 @^)..@ | while read -r hash msg; do echo "[${hash}](https://github.com/${{ github.repository }}/commit/${hash}) - ${msg}"; done)
+          echo "COMMITS=${COMMITS}" >> $GITHUB_ENV
+
       - name: Create Tag and Release
         uses: actions/github-script@v7
         with:
           script: |
             const version = process.env.VERSION
             const tag = `v${version}`
+            const commits = process.env.COMMITS
             const { data: tags } = await github.rest.repos.listTags({
               owner: context.repo.owner,
               repo: context.repo.repo,
@@ -72,7 +79,7 @@ jobs:
                 repo: context.repo.repo,
                 tag_name: tag,
                 name: `Release ${tag}`,
-                body: `Automated release of version ${tag}`,
+                body: `Automated release of version ${tag}\n\nCommits:\n${commits}`,
                 draft: false,
                 prerelease: false,
               })
@@ -101,7 +108,7 @@ jobs:
       - name: Check if version exists on npm
         id: check_npm_version
         run: |
-          if npm show ${{ github.repository }}@${{ env.VERSION }} > /dev/null 2>&1; then
+          if npm show decorator-dependency-injection@${{ env.VERSION }} > /dev/null 2>&1; then
             echo "VERSION_EXISTS=true" >> $GITHUB_ENV
           else
             echo "VERSION_EXISTS=false" >> $GITHUB_ENV
@@ -109,14 +116,12 @@ jobs:
 
       - name: Publish to npm
         if: env.VERSION_EXISTS == 'false'
-        run: npm publish --access public
+        run: | 
+          npm publish --access public
+          echo "::notice::Published new version ${{ env.VERSION }} to npm."
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-      - name: Notice Publish Status
-        if: env.VERSION_EXISTS == 'false'
-        run: echo "::notice::Published new version ${{ env.VERSION }} to npm."
-
       - name: Notice Publish Status
         if: env.VERSION_EXISTS == 'true'
         run: echo "::notice::Version ${{ env.VERSION }} already exists on npm. No new version published."

package/README.md

@@ -88,8 +88,8 @@ import { Factory, Inject } from 'decorator-dependency-injection';
 @Factory
 class Dependency {
   constructor(param1, param2) {
-    this.param1 = param1;
-    this.param2 = param2;
+    this.param1 = param1
+    this.param2 = param2
   }
 }
 
@@ -105,33 +105,77 @@ While this is most useful for Factory dependencies, it can also be used with Sin
 You can mock dependencies by using the ```@Mock``` decorator with a function that returns the mock dependency.
 
 ```javascript
-import { Factory, Inject, Mock } from 'decorator-dependency-injection';
+import { Factory, Inject, Mock } from 'decorator-dependency-injection'
 
 @Factory
 class Dependency {
   method() {
-    return 'real';
+    return 'real'
   }
 }
 
 class Consumer {
   @Inject(Dependency) dependency
 
-  test() {
-    return this.dependency.method();
+  constructor() {
+    console.log(this.dependency.method())
   }
 }
 
-@Mock
+// Test Code
+
+@Mock(Dependency)
+class MockDependency {
+  method() {
+    return 'mock'
+  }
+}
+
+const consumer = new Consumer()  // prints 'mock'
+
+resetMock(Dependency)
+
+const consumer = new Consumer()  // prints 'real'
+```
+
+You can also use the ```@Mock``` decorator as a proxy instead of a full mock. Any method calls not implemented in the mock will be passed to the real dependency.
+
+```javascript
+import { Factory, Inject, Mock } from 'decorator-dependency-injection'
+
+@Factory
+class Dependency {
+  method() {
+    return 'real'
+  }
+
+  otherMethod() {
+    return 'other'
+  }
+}
+
+class Consumer {
+  @Inject(Dependency) dependency
+
+  constructor() {
+    console.log(this.dependency.method(), this.dependency.otherMethod())
+  }
+}
+
+// Test Code
+
+@Mock(Dependency, true)
 class MockDependency {
   method() {
-    return 'mock';
+    return 'mock'
   }
 }
 
-const consumer = new Consumer();
+const consumer = new Consumer()  // prints 'mock other'
 
-consumer.test(); // returns 'real'
+resetMock(Dependency)
+
+const consumer = new Consumer()  // prints 'real other'
 ```
 
 For more examples, see the tests in the ```test``` directory.
@@ -142,4 +186,10 @@ To run the tests, run the following command in the project root.
 
 ```bash
 npm test
-```
+```
+
+## Version History
+
+- 1.0.0 - Initial release
+- 1.0.1 - Automated release with GitHub Actions
+- 1.0.2 - Added proxy option to @Mock decorator

package/index.js

@@ -1,14 +1,15 @@
 /**
  * @typedef {Object} InstanceContext
+ * @property {string} type The type of the instance, either 'singleton' or 'factory'
  * @property {Class} clazz The class of the instance
+ * @property {Class} [originalClazz] The original class if it is a mock
  * @property {Object} [instance] The instance if it is a singleton
- * @property {Class} [original] The original class if it is a mock
+ * @property {Object} [originalInstance] The original instance if it is a mock
+ * @property {boolean} [proxy=false] If true, the mock if the injection instance will be a proxy to the original class
  */
 
 /** @type {Map<string|Class, InstanceContext>} */
-const singletons = new Map()
-/** @type {Map<string|Class, InstanceContext>} */
-const factories = new Map()
+const instances = new Map()
 
 /**
  * Register a class as a singleton. If a name is provided, it will be used as the key in the singleton map.
@@ -27,13 +28,10 @@ export function Singleton(name) {
     if (context.kind !== "class") {
       throw new Error('Invalid injection target')
     }
-    if (singletons.has(name ?? clazz)) {
-      throw new Error('Singleton already defined')
-    }
-    if (factories.has(name ?? clazz)) {
-      throw new Error('Factory with the same name already defined')
+    if (instances.has(name ?? clazz)) {
+      throw new Error('Instance with that name or class already instantiated')
     }
-    singletons.set(name ?? clazz, { clazz })
+    instances.set(name ?? clazz, { clazz, type: 'singleton' })
   }
 }
 
@@ -54,13 +52,10 @@ export function Factory(name) {
     if (context.kind !== "class") {
       throw new Error('Invalid injection target')
     }
-    if (factories.has(name ?? clazz)) {
-      throw new Error('Factory already defined')
+    if (instances.has(name ?? clazz)) {
+      throw new Error('Instance with that name or class already instantiated')
     }
-    if (singletons.has(name ?? clazz)) {
-      throw new Error('Singleton with the same name already defined')
-    }
-    factories.set(name ?? clazz, { clazz })
+    instances.set(name ?? clazz, { clazz, type: 'factory' })
   }
 }
 
@@ -69,7 +64,7 @@ export function Factory(name) {
  * If the instance is a singleton, it will only be created once with the first set of parameters it encounters.
  *
  * @param {string|Class} clazzOrName The singleton or factory class or name
- * @param {*} params Parameters to pass to the constructor
+ * @param {*} params Parameters to pass to the constructor. Recommended to use only with factories.
  * @return {(function(*): void)|*}
  * @example @Inject(MySingleton) mySingleton
  * @example @Inject("myCustomName") myFactory
@@ -83,18 +78,32 @@ export function Inject(clazzOrName, ...params) {
         if (initialValue) {
           throw new Error('Cannot assign value to injected field')
         }
-        if (singletons.has(clazzOrName)) {
-          const instanceContext = singletons.get(clazzOrName)
-          if (!instanceContext.instance) {
-            singletons.set(clazzOrName, {clazz: clazzOrName, instance: new instanceContext.clazz(...params), original: instanceContext.original})
+        const instanceContext = getContext(clazzOrName)
+
+        if (instanceContext.instance) {
+          return instanceContext.instance
+        }
+
+        const instance = new instanceContext.clazz(...params)
+
+        if (instanceContext.type === 'singleton') {
+          if (instanceContext.originalClazz && instanceContext.proxy) {
+            instanceContext.instance = getProxy(instance, new instanceContext.originalClazz(...params))
+          } else {
+            instanceContext.instance = instance
           }
-          return singletons.get(clazzOrName).instance
-        } else if (factories.has(clazzOrName)) {
-          const factoryClass = factories.get(clazzOrName).clazz
-          return new factoryClass(...params)
-        } else {
-          throw new Error('Cannot find injection source with the provided name')
+          return instanceContext.instance
         }
+
+        if (instanceContext.type === 'factory') {
+          if (instanceContext.originalClazz && instanceContext.proxy) {
+            return getProxy(instance, new instanceContext.originalClazz(...params))
+          } else {
+            return instance
+          }
+        }
+
+        throw new Error('Unexpected injection type')
       }
     } else {
       throw new Error('Invalid injection target')
@@ -102,37 +111,47 @@ export function Inject(clazzOrName, ...params) {
   }
 }
 
+function getProxy(mock, original) {
+  return new Proxy(mock, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver)
+      }
+      return Reflect.get(original, prop, receiver)
+    }
+  })
+}
+
 /**
  * Mark a class as a mock. This will replace the class with a mock instance when injected.
  * @param {string|Class} mockedClazzOrName The singleton or factory class or name to be mocked
+ * @param {boolean} [proxy=false] If true, the mock will be a proxy to the original class. Any methods not defined in the mock will be called on the original class.
  * @return {(function(*, *): void)|*}
  * @example @Mock(MySingleton) class MyMock {}
  * @example @Mock("myCustomName") class MyMock {}
  * @throws {Error} If the injection target is not a class
  * @throws {Error} If the injection source is not found
  */
-export function Mock(mockedClazzOrName) {
+export function Mock(mockedClazzOrName, proxy = false) {
   return function(clazz, context) {
     if (context.kind !== "class") {
       throw new Error('Invalid injection target')
     }
-    if (singletons.has(mockedClazzOrName)) {
-      const instanceContext = singletons.get(mockedClazzOrName)
-      if (instanceContext.original) {
-        throw new Error('Mock already defined, reset before mocking again')
-      }
-      instanceContext.original = instanceContext.clazz
-      instanceContext.clazz = clazz
-    } else if (factories.has(mockedClazzOrName)) {
-      const instanceContext = factories.get(mockedClazzOrName)
-      if (instanceContext.original) {
+    const instanceContext = getContext(mockedClazzOrName)
+    if (instanceContext.originalClazz) {
         throw new Error('Mock already defined, reset before mocking again')
-      }
-      instanceContext.original = instanceContext.clazz
-      instanceContext.clazz = clazz
-    } else {
-      throw new Error('Cannot find injection source with the provided name')
     }
+    instanceContext.originalClazz = instanceContext.clazz
+    instanceContext.proxy = proxy
+    instanceContext.clazz = clazz
+  }
+}
+
+function getContext(mockedClazzOrName) {
+  if (instances.has(mockedClazzOrName)) {
+    return instances.get(mockedClazzOrName)
+  } else {
+    throw new Error('Cannot find injection source with the provided name')
   }
 }
 
@@ -140,10 +159,7 @@ export function Mock(mockedClazzOrName) {
  * Reset all mocks to their original classes.
  */
 export function resetMocks() {
-  for (const instanceContext of singletons.values()) {
-    reset(instanceContext)
-  }
-  for (const instanceContext of factories.values()) {
+  for (const instanceContext of instances.values()) {
     reset(instanceContext)
   }
 }
@@ -153,8 +169,7 @@ export function resetMocks() {
  * @param {string|Class} clazzOrName The singleton or factory class or name to reset
  */
 export function resetMock(clazzOrName) {
-  const instanceContext = singletons.get(clazzOrName) ?? factories.get(clazzOrName)
-  reset(instanceContext)
+  reset(getContext(clazzOrName))
 }
 
 /**
@@ -166,9 +181,10 @@ function reset(instanceContext) {
   if (!instanceContext) {
     throw new Error('Cannot find injection source with the provided name')
   }
-  if (instanceContext.original) {
-    instanceContext.clazz = instanceContext.original
-    delete instanceContext.original
-    delete instanceContext.instance
+  if (instanceContext.originalClazz) {
+    instanceContext.clazz = instanceContext.originalClazz
+    instanceContext.instance = instanceContext.originalInstance
+    delete instanceContext.originalClazz
+    delete instanceContext.originalInstance
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decorator-dependency-injection",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A simple library for dependency injection using decorators",
   "author": "Ravi Gairola <mallox@pyxzl.net>",
   "license": "Apache-2.0",

package/test/mock.test.js

@@ -6,6 +6,10 @@ describe('Mocking', () => {
     op() {
       return 'original'
     }
+
+    op2() {
+      return 'original2'
+    }
   }
 
   class TestInjection {
@@ -26,10 +30,12 @@ describe('Mocking', () => {
 
     const result = new TestInjection()
     expect(result.toBeMockedSingleton.op()).toBe('mocked')
+    expect(result.toBeMockedSingleton.op2).toBe.undefined
 
     resetMocks()
     const result2 = new TestInjection()
     expect(result2.toBeMockedSingleton.op()).toBe('original')
+    expect(result2.toBeMockedSingleton.op2()).toBe('original2')
   })
 
   @Factory()

package/test/proxy.test.js

@@ -0,0 +1,73 @@
+import {resetMocks, Inject, Mock, Singleton, Factory} from '../index.js'
+
+describe('Proxy Mocking', () => {
+  @Singleton()
+  class ToBeProxiedSingleton {
+    op() {
+      return 'original'
+    }
+
+    op2() {
+      return 'original2'
+    }
+  }
+
+  class TestInjection {
+    @Inject(ToBeProxiedSingleton) toBeProxiedSingleton
+  }
+
+  afterEach(() => {
+    resetMocks()
+  })
+
+  it('should inject a proxy singleton', () => {
+    @Mock(ToBeProxiedSingleton, true)
+    class ProxiedSingleton {
+      op() {
+        return 'mocked'
+      }
+    }
+
+    const result = new TestInjection()
+    expect(result.toBeProxiedSingleton.op()).toBe('mocked')
+    expect(result.toBeProxiedSingleton.op2()).toBe('original2')
+
+    resetMocks()
+    const result2 = new TestInjection()
+    expect(result2.toBeProxiedSingleton.op()).toBe('original')
+    expect(result2.toBeProxiedSingleton.op2()).toBe('original2')
+  })
+
+  @Factory()
+  class ToBeProxiedFactory {
+    op() {
+      return 'original'
+    }
+
+    op2() {
+      return 'original2'
+    }
+  }
+
+  class TestInjectionFactory {
+    @Inject(ToBeProxiedFactory) toBeProxiedFactory
+  }
+
+  it('should inject a proxy factory', () => {
+    @Mock(ToBeProxiedFactory, true)
+    class ProxiedFactory {
+      op() {
+        return 'mocked'
+      }
+    }
+
+    const result = new TestInjectionFactory()
+    expect(result.toBeProxiedFactory.op()).toBe('mocked')
+    expect(result.toBeProxiedFactory.op2()).toBe('original2')
+
+    resetMocks()
+    const result2 = new TestInjectionFactory()
+    expect(result2.toBeProxiedFactory.op()).toBe('original')
+    expect(result2.toBeProxiedFactory.op2()).toBe('original2')
+  })
+})