decorator-dependency-injection 1.0.3 → 1.0.4

package/package.json

@@ -1,34 +1,73 @@
 {
   "name": "decorator-dependency-injection",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "A simple library for dependency injection using decorators",
   "author": "Ravi Gairola <mallox@pyxzl.net>",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mallocator/decorator-dependency-injection.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mallocator/decorator-dependency-injection/issues"
+  },
+  "homepage": "https://github.com/mallocator/decorator-dependency-injection#readme",
   "keywords": [
     "dependency-injection",
     "di",
     "decorators",
-    "mocking"
+    "mocking",
+    "singleton",
+    "factory"
   ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "main": "index.js",
+  "types": "index.d.ts",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
   "scripts": {
     "start": "babel-node index.js",
-    "test": "jest"
+    "test": "jest --no-watchman",
+    "test:coverage": "jest --no-watchman --coverage",
+    "typecheck": "tsc test/types.check.ts --noEmit --esModuleInterop --skipLibCheck",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
   },
   "jest": {
     "transform": {
       "^.+\\.js$": "babel-jest"
-    }
+    },
+    "coverageThreshold": {
+      "global": {
+        "branches": 80,
+        "functions": 80,
+        "lines": 80,
+        "statements": 80
+      }
+    },
+    "collectCoverageFrom": [
+      "index.js",
+      "src/**/*.js"
+    ]
   },
   "devDependencies": {
     "@babel/cli": "^7.26.4",
     "@babel/core": "^7.26.9",
+    "@babel/eslint-parser": "^7.28.6",
     "@babel/plugin-proposal-decorators": "^7.25.9",
-    "@babel/polyfill": "^7.12.1",
     "@babel/preset-env": "^7.26.9",
     "@babel/register": "^7.25.9",
+    "@eslint/js": "^9.39.2",
     "@types/jest": "^29.5.14",
-    "jest": "^29.7.0"
+    "eslint": "^9.39.2",
+    "jest": "^29.7.0",
+    "typescript": "^5.9.3"
   }
-}
+}

package/src/Container.js

@@ -0,0 +1,184 @@
+/**
+ * @typedef {Object} InstanceContext
+ * @property {'singleton'|'factory'} type - The type of the instance.
+ * @property {Function} clazz - The class constructor for the instance.
+ * @property {Function} [originalClazz] - The original class if this is a mock.
+ * @property {Object} [instance] - The singleton instance, if created.
+ * @property {Object} [originalInstance] - The original instance if this is a mock.
+ * @property {boolean} [proxy=false] - If true, the mock will proxy to the original class for undefined methods/properties.
+ */
+
+import {createProxy} from './proxy.js'
+
+/**
+ * A dependency injection container that manages singleton and factory instances.
+ * Supports mocking for testing purposes.
+ */
+export class Container {
+  /** @type {Map<string|Function, InstanceContext>} */
+  #instances = new Map()
+
+  /**
+   * Register a class as a singleton.
+   * @param {Function} clazz The class constructor
+   * @param {string} [name] Optional name key
+   */
+  registerSingleton(clazz, name) {
+    this.#register(clazz, 'singleton', name)
+  }
+
+  /**
+   * Register a class as a factory.
+   * @param {Function} clazz The class constructor
+   * @param {string} [name] Optional name key
+   */
+  registerFactory(clazz, name) {
+    this.#register(clazz, 'factory', name)
+  }
+
+  /**
+   * Internal registration logic.
+   * @param {Function} clazz The class constructor
+   * @param {'singleton'|'factory'} type The registration type
+   * @param {string} [name] Optional name key
+   * @private
+   */
+  #register(clazz, type, name) {
+    const key = name ?? clazz
+    if (this.#instances.has(key)) {
+      throw new Error(
+        'A different class is already registered under this name. ' +
+        'This may be a circular dependency. Try using @InjectLazy'
+      )
+    }
+    this.#instances.set(key, {clazz, type})
+  }
+
+  /**
+   * Get the context for a given class or name.
+   * @param {string|Function} clazzOrName The class or name to look up
+   * @returns {InstanceContext}
+   * @throws {Error} If the context is not found
+   */
+  getContext(clazzOrName) {
+    if (this.#instances.has(clazzOrName)) {
+      return this.#instances.get(clazzOrName)
+    }
+    const available = Array.from(this.#instances.keys())
+      .map(k => typeof k === 'string' ? k : k.name)
+      .join(', ')
+    throw new Error(
+      `Cannot find injection source for "${clazzOrName?.name || clazzOrName}". ` +
+      `Available: [${available}]`
+    )
+  }
+
+  /**
+   * Check if a class or name is registered.
+   * @param {string|Function} clazzOrName The class or name to check
+   * @returns {boolean}
+   */
+  has(clazzOrName) {
+    return this.#instances.has(clazzOrName)
+  }
+
+  /**
+   * Get or create an instance based on the context.
+   * @param {InstanceContext} instanceContext The instance context
+   * @param {Array} params Constructor parameters
+   * @returns {Object} The instance
+   */
+  getInstance(instanceContext, params) {
+    if (instanceContext.type === 'singleton' && !instanceContext.originalClazz && instanceContext.instance) {
+      return instanceContext.instance
+    }
+
+    let instance
+    try {
+      instance = new instanceContext.clazz(...params)
+    } catch (err) {
+      if (err instanceof RangeError) {
+        throw new Error(
+          `Circular dependency detected for ${instanceContext.clazz.name || instanceContext.clazz}. ` +
+          `Use @InjectLazy to break the cycle.`
+        )
+      }
+      throw err
+    }
+
+    if (instanceContext.proxy && instanceContext.originalClazz) {
+      const originalInstance = new instanceContext.originalClazz(...params)
+      instance = createProxy(instance, originalInstance)
+    }
+
+    if (instanceContext.type === 'singleton') {
+      instanceContext.instance = instance
+    }
+
+    return instance
+  }
+
+  /**
+   * Register a mock for an existing class.
+   * @param {string|Function} targetClazzOrName The class or name to mock
+   * @param {Function} mockClazz The mock class
+   * @param {boolean} [useProxy=false] Whether to proxy unmocked methods to original
+   */
+  registerMock(targetClazzOrName, mockClazz, useProxy = false) {
+    const instanceContext = this.getContext(targetClazzOrName)
+    if (instanceContext.originalClazz) {
+      throw new Error('Mock already defined, reset before mocking again')
+    }
+    instanceContext.originalClazz = instanceContext.clazz
+    instanceContext.proxy = useProxy
+    instanceContext.clazz = mockClazz
+  }
+
+  /**
+   * Reset a specific mock to its original class.
+   * @param {string|Function} clazzOrName The class or name to reset
+   * @throws {Error} If the class or name is not registered
+   */
+  resetMock(clazzOrName) {
+    const key = typeof clazzOrName === 'string' ? clazzOrName : clazzOrName
+    this.#restoreOriginal(this.#instances.get(key), clazzOrName)
+  }
+
+  /**
+   * Reset all mocks to their original classes.
+   */
+  resetAllMocks() {
+    for (const instanceContext of this.#instances.values()) {
+      this.#restoreOriginal(instanceContext)
+    }
+  }
+
+  /**
+   * Clear all registered instances and mocks.
+   * Useful for test isolation.
+   */
+  clear() {
+    this.#instances.clear()
+  }
+
+  /**
+   * Internal function to restore an instance context to its original.
+   * @param {InstanceContext} instanceContext The instance context to reset
+   * @param {string|Function} [clazzOrName] Optional identifier for error messages
+   * @throws {Error} If instanceContext is null or undefined
+   * @private
+   */
+  #restoreOriginal(instanceContext, clazzOrName) {
+    if (!instanceContext) {
+      const name = clazzOrName?.name || clazzOrName || 'unknown'
+      throw new Error(`Cannot reset mock for "${name}": not registered`)
+    }
+    if (instanceContext.originalClazz) {
+      instanceContext.clazz = instanceContext.originalClazz
+      delete instanceContext.instance
+      delete instanceContext.originalClazz
+      delete instanceContext.originalInstance
+      delete instanceContext.proxy
+    }
+  }
+}

package/src/proxy.js

@@ -0,0 +1,42 @@
+/**
+ * Create a proxy that delegates to the mock first, then falls back to the original.
+ * This allows partial mocking where only specific methods are overridden.
+ *
+ * @param {Object} mock The mock instance
+ * @param {Object} original The original instance to fall back to
+ * @returns {Proxy} A proxy that delegates appropriately
+ */
+export function createProxy(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, original)
+    },
+
+    set(target, prop, value, receiver) {
+      if (prop in target) {
+        return Reflect.set(target, prop, value, receiver)
+      }
+      return Reflect.set(original, prop, value, original)
+    },
+
+    has(target, prop) {
+      return prop in target || prop in original
+    },
+
+    ownKeys(target) {
+      const mockKeys = Reflect.ownKeys(target)
+      const originalKeys = Reflect.ownKeys(original)
+      return [...new Set([...mockKeys, ...originalKeys])]
+    },
+
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop in target) {
+        return Reflect.getOwnPropertyDescriptor(target, prop)
+      }
+      return Reflect.getOwnPropertyDescriptor(original, prop)
+    }
+  })
+}

package/.github/workflows/release.yml

@@ -1,129 +0,0 @@
-name: 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" }]
-  ]
-}