decorator-dependency-injection 1.0.2 → 1.0.4

package/.github/workflows/release.yml

@@ -1,129 +0,0 @@
-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/babel.config.json

@@ -1,6 +0,0 @@
-{
-  "presets": ["@babel/preset-env"],
-  "plugins": [
-    ["@babel/plugin-proposal-decorators", { "version": "2023-11" }]
-  ]
-}

package/test/injection.test.js

@@ -1,152 +0,0 @@
-import {Factory, Inject, Singleton} from '../index.js'
-
-describe('Injection via fields', () => {
-  @Singleton()
-  class TestSingleton {
-    static calls = 0
-
-    constructor() {
-      TestSingleton.calls++
-    }
-  }
-
-  it('should inject singleton', () => {
-    class TestInjection {
-      @Inject(TestSingleton) testSingleton
-
-      constructor() {
-        expect(this.testSingleton).toBeInstanceOf(TestSingleton)
-        expect(TestSingleton.calls).toBe(1)
-      }
-    }
-
-    class TestInjection2 {
-      @Inject(TestSingleton) testSingleton
-
-      constructor() {
-        expect(this.testSingleton).toBeInstanceOf(TestSingleton)
-        expect(TestSingleton.calls).toBe(1)
-      }
-    }
-
-    new TestInjection()
-    new TestInjection2()
-  })
-
-  @Factory()
-  class TestFactory {
-    static calls = 0
-    params
-
-    @Inject(TestSingleton) testSingleton
-
-    constructor(...params) {
-      TestFactory.calls++
-      this.params = params
-    }
-  }
-
-  it('should inject factory', () => {
-    class TestInjectionFactory {
-      @Inject(TestFactory) testFactory
-
-      constructor() {
-        expect(this.testFactory).toBeInstanceOf(TestFactory)
-        expect(TestFactory.calls).toBe(1)
-      }
-    }
-
-    class TestInjectionFactory2 {
-      @Inject(TestFactory) testFactory
-
-      constructor() {
-        expect(this.testFactory).toBeInstanceOf(TestFactory)
-        expect(TestFactory.calls).toBe(2)
-      }
-    }
-
-    const result = new TestInjectionFactory()
-    new TestInjectionFactory2()
-    expect(result.testFactory.testSingleton).toBeInstanceOf(TestSingleton)
-  })
-
-  it('should inject factory with parameters', () => {
-    class TestInjectionFactoryParams {
-      @Inject(TestFactory, 'param1', 'param2') testFactory
-
-      constructor() {
-        expect(this.testFactory).toBeInstanceOf(TestFactory)
-        expect(this.testFactory.params).toEqual(['param1', 'param2'])
-      }
-    }
-
-    new TestInjectionFactoryParams()
-  })
-
-  @Singleton("named")
-  class NamedSingleton {
-    static calls = 0
-
-    constructor() {
-      NamedSingleton.calls++
-    }
-  }
-
-  it('should inject named singleton', () => {
-    class TestInjectionNamedSingleton {
-      @Inject("named") namedSingleton
-
-      constructor() {
-        expect(this.namedSingleton).toBeInstanceOf(NamedSingleton)
-        expect(NamedSingleton.calls).toBe(1)
-      }
-    }
-
-    class TestInjectionNamedSingleton2 {
-      @Inject("named") namedSingleton
-
-      constructor() {
-        expect(this.namedSingleton).toBeInstanceOf(NamedSingleton)
-        expect(NamedSingleton.calls).toBe(1)
-      }
-    }
-
-    new TestInjectionNamedSingleton()
-    new TestInjectionNamedSingleton2()
-  })
-
-  @Factory("named2")
-  class NamedFactory {
-    static calls = 0
-    params
-
-    constructor(...params) {
-      NamedFactory.calls++
-      this.params = params
-    }
-  }
-
-  it('should inject named factory', () => {
-    class TestInjectionNamedFactory {
-      @Inject("named2") namedFactory
-
-      constructor() {
-        expect(this.namedFactory).toBeInstanceOf(NamedFactory)
-        expect(NamedFactory.calls).toBe(1)
-      }
-    }
-
-    class TestInjectionNamedFactory2 {
-      @Inject("named2") namedFactory
-
-      constructor() {
-        expect(this.namedFactory).toBeInstanceOf(NamedFactory)
-        expect(NamedFactory.calls).toBe(2)
-      }
-    }
-
-    const result = new TestInjectionNamedFactory()
-    new TestInjectionNamedFactory2()
-    expect(result.namedFactory.params).toEqual([])
-  })
-})

package/test/mock.test.js

@@ -1,77 +0,0 @@
-import {resetMocks, Inject, Mock, Singleton, Factory} from '../index.js'
-
-describe('Mocking', () => {
-  @Singleton()
-  class ToBeMockedSingleton {
-    op() {
-      return 'original'
-    }
-
-    op2() {
-      return 'original2'
-    }
-  }
-
-  class TestInjection {
-    @Inject(ToBeMockedSingleton) toBeMockedSingleton
-  }
-
-  afterEach(() => {
-    resetMocks()
-  })
-
-  it('should inject a mock singleton', () => {
-    @Mock(ToBeMockedSingleton)
-    class MockedSingleton {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    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()
-  class ToBeMockedFactory {
-    op() {
-      return 'original'
-    }
-  }
-
-  class TestInjectionFactory {
-    @Inject(ToBeMockedFactory) toBeMockedFactory
-  }
-
-  it('should inject a mock factory', () => {
-    @Mock(ToBeMockedFactory)
-    class MockedFactory {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    const result = new TestInjectionFactory()
-    expect(result.toBeMockedFactory.op()).toBe('mocked')
-
-    resetMocks()
-    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

@@ -1,73 +0,0 @@
-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')
-  })
-})