decorator-dependency-injection 1.0.0 → 1.0.2

package/.github/workflows/release.yml

@@ -0,0 +1,129 @@
+name: Create Release
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [22.x, 23.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run build --if-present
+      - run: npm test
+
+  release:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Get package.json version
+        id: package_version
+        run: echo "VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_ENV
+
+      - name: Check if tag exists
+        id: check_tag
+        run: |
+          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,
+            })
+            
+            if (!tags.find(t => t.name === tag)) {
+              await github.rest.git.createRef({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                ref: `refs/tags/${tag}`,
+                sha: context.sha,
+              })
+            
+              await github.rest.repos.createRelease({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                tag_name: tag,
+                name: `Release ${tag}`,
+                body: `Automated release of version ${tag}\n\nCommits:\n${commits}`,
+                draft: false,
+                prerelease: false,
+              })
+              core.notice(`Release ${tag} created.`)
+            } else {
+              core.notice(`Release ${tag} already exists. No new release created.`)
+            }
+
+  publish:
+    needs: release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Get package.json version
+        id: package_version
+        run: echo "VERSION=$(node -p "require('./package.json').version")" >> $GITHUB_ENV
+
+      - name: Check if version exists on npm
+        id: check_npm_version
+        run: |
+          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
+          fi
+
+      - name: Publish to npm
+        if: env.VERSION_EXISTS == 'false'
+        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 == 'true'
+        run: echo "::notice::Version ${{ env.VERSION }} already exists on npm. No new version published."
+
+

package/README.md

@@ -5,7 +5,7 @@
 
 ## Description
 
-With TC39 reaching stage 3 on the decorators proposal, it's time to start thinking about how we can use them in our projects. One of the most common patterns in JavaScript is dependency injection. This pattern is used to make our code more testable and maintainable. This library provides simple decorators to help you inject dependencies into your classes and mock them for testing.
+With [TC39](https://github.com/tc39/proposal-decorators) reaching stage 3 on the decorators proposal, it's time to start thinking about how we can use them in our projects. One of the most common patterns in JavaScript is dependency injection. This pattern is used to make our code more testable and maintainable. This library provides simple decorators to help you inject dependencies into your classes and mock them for testing.
 
 ## Installation
 
@@ -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 (singletons.has(name ?? clazz)) {
-      throw new Error('Singleton with the same name already defined')
+    if (instances.has(name ?? clazz)) {
+      throw new Error('Instance with that name or class already instantiated')
     }
-    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,31 +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)
-      instanceContext.original = instanceContext.clazz
-      instanceContext.clazz = clazz
-    } else if (factories.has(mockedClazzOrName)) {
-      const instanceContext = factories.get(mockedClazzOrName)
-      instanceContext.original = instanceContext.clazz
-      instanceContext.clazz = clazz
-    } else {
-      throw new Error('Cannot find injection source with the provided name')
+    const instanceContext = getContext(mockedClazzOrName)
+    if (instanceContext.originalClazz) {
+        throw new Error('Mock already defined, reset before mocking again')
     }
+    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')
   }
 }
 
@@ -134,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)
   }
 }
@@ -147,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))
 }
 
 /**
@@ -160,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.0",
+  "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,12 +6,20 @@ describe('Mocking', () => {
     op() {
       return 'original'
     }
+
+    op2() {
+      return 'original2'
+    }
   }
 
   class TestInjection {
     @Inject(ToBeMockedSingleton) toBeMockedSingleton
   }
 
+  afterEach(() => {
+    resetMocks()
+  })
+
   it('should inject a mock singleton', () => {
     @Mock(ToBeMockedSingleton)
     class MockedSingleton {
@@ -22,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()
@@ -54,4 +64,14 @@ describe('Mocking', () => {
     const result2 = new TestInjectionFactory()
     expect(result2.toBeMockedFactory.op()).toBe('original')
   })
+
+  it('should throw an error if a mock is not a singleton or factory', () => {
+    expect(() => {
+      @Mock(ToBeMockedFactory)
+      class Mocked1 {}
+
+      @Mock(ToBeMockedFactory)
+      class Mocked2 {}
+    }).toThrow('Mock already defined, reset before mocking again')
+  })
 })

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')
+  })
+})

package/.github/workflows/node.js.yml

@@ -1,31 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x, 22.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test

package/.idea/decorator-depdenency-injection.iml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" name="@types/jest" level="application" />
-  </component>
-</module>

package/.idea/git_toolbox_blame.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GitToolBoxBlameSettings">
-    <option name="version" value="2" />
-  </component>
-</project>

package/.idea/git_toolbox_prj.xml

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GitToolBoxProjectSettings">
-    <option name="commitMessageIssueKeyValidationOverride">
-      <BoolValueOverride>
-        <option name="enabled" value="true" />
-      </BoolValueOverride>
-    </option>
-    <option name="commitMessageValidationEnabledOverride">
-      <BoolValueOverride>
-        <option name="enabled" value="true" />
-      </BoolValueOverride>
-    </option>
-  </component>
-</project>

package/.idea/jsLibraryMappings.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptLibraryMappings">
-    <file url="file://$PROJECT_DIR$" libraries="{Node.js Core, decorator-depdenency-injection/node_modules}" />
-    <file url="file://$PROJECT_DIR$/test" libraries="{@types/jest, Node.js Core, decorator-depdenency-injection/node_modules}" />
-    <excludedPredefinedLibrary name="HTML" />
-  </component>
-</project>

package/.idea/material_theme_project_new.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="MaterialThemeProjectNewConfig">
-    <option name="metadata">
-      <MTProjectMetadataState>
-        <option name="migrated" value="true" />
-        <option name="pristineConfig" value="false" />
-        <option name="userId" value="-1911ddbb:1739357c210:-8000" />
-        <option name="version" value="8.13.2" />
-      </MTProjectMetadataState>
-    </option>
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/decorator-depdenency-injection.iml" filepath="$PROJECT_DIR$/.idea/decorator-depdenency-injection.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>