Make services replacable

Author: TiMESPLiNTER

.github/workflows/test.yml

@@ -9,5 +9,7 @@ jobs:
       - uses: actions/checkout@v2
       - name: Install modules
         run: npm install
+      - name: Run typecheck
+        run: npm run typecheck
       - name: Run coverage
         run: npm run test:cov

package-lock.json

@@ -1,12 +1,13 @@
 {
   "name": "@timesplinter/pimple",
   "license": "LGPL-3.0-or-later",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "module": "./lib/esm/index.js",
   "main": "./lib/cjs/index.js",
   "scripts": {
     "test": "jest",
     "test:cov": "jest --collect-coverage",
+    "typecheck": "tsc --noEmit  -p tsconfig.json && tsc --noEmit -p tsconfig-cjs.json",
     "transpile": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
     "prepublish": "npm run transpile"
   },
@@ -17,10 +18,10 @@
     "@babel/core": "^7.23.9",
     "@babel/preset-env": "^7.23.9",
     "@babel/preset-typescript": "^7.23.3",
-    "@types/jest": "^29.5.11",
+    "@types/jest": "^29.5.14",
     "babel-jest": "^29.7.0",
     "jest": "^29.7.0",
-    "typescript": "^4.9.5",
-    "ts-node": "^10.9.2"
+    "ts-node": "^10.9.2",
+    "typescript": "^4.9.5"
   }
 }

package.json

@@ -28,27 +28,18 @@ const reservedProperties: string[] = [
  * @copyright 2016 SerafimArts <nesk@xakep.ru>
  * @copyright 2021 TiMESPLiNTER <dev@timesplinter.ch>
  * @license LGPL
- * @version 3.0.0
+ * @version 2.1.0
  */
 export default class Pimple<T> implements Container<T>
 {
-    /**
-     * @type {string}
-     */
-    static get VERSION() { return '3.0.0'; }
+    static get VERSION() { return '2.1.0'; }
 
-    /**
-     * @type {{}}
-     * @private
-     */
     private _definitions: Partial<ServiceMap<T>> = {};
 
-    /**
-     * @type {{}}
-     * @private
-     */
     private _raw: Partial<ServiceMap<T>> = {};
 
+    private _resolved: Set<string | number | symbol> = new Set();
+
     constructor(services: Partial<ServiceMap<T>> = {}) {
         Object.keys(services).forEach((service) => {
             const serviceKey = service as ServiceKey<T>;
@@ -57,9 +48,33 @@ export default class Pimple<T> implements Container<T>
     }
 
     /**
-     * Define a service
+     * Define a service (first-time registration only)
      */
     public set<K extends ServiceKey<T>>(name: K, service: ServiceDefinition<T,T[K]>): Pimple<T>
+    {
+        if (this.has(name)) {
+            throw new Error(`Service "${name.toString()}" is already defined. Use replace() to overwrite it.`);
+        }
+
+        return this.define(name, service);
+    }
+
+    /**
+     * Replace an existing service definition before it has been resolved
+     */
+    public replace<K extends ServiceKey<T>>(name: K, service: ServiceDefinition<T,T[K]>): Pimple<T>
+    {
+        if (!this.has(name)) {
+            throw new RangeError(`Service "${name.toString()}" is not defined in the container.`);
+        }
+        if (this._resolved.has(name)) {
+            throw new Error(`Service "${name.toString()}" has already been resolved and cannot be replaced.`);
+        }
+
+        return this.define(name, service);
+    }
+
+    private define<K extends ServiceKey<T>>(name: K, service: ServiceDefinition<T,T[K]>): Pimple<T>
     {
         this._raw[name] = service;
 
@@ -76,6 +91,7 @@ export default class Pimple<T> implements Container<T>
 
         if (reservedProperties.indexOf(name.toString()) === -1) {
             Object.defineProperty(this, name, {
+                configurable: true,
                 get: () => {
                     return this.get(name);
                 }
@@ -94,6 +110,7 @@ export default class Pimple<T> implements Container<T>
 
         if (reservedProperties.indexOf(name.toString()) === -1) {
             Object.defineProperty(this, name, {
+                configurable: true,
                 get: () => {
                     return this.get(name);
                 }
@@ -108,6 +125,7 @@ export default class Pimple<T> implements Container<T>
      */
     public get<K extends ServiceKey<T>>(name: K): T[K] {
         if (this._definitions[name] instanceof Function) {
+            this._resolved.add(name);
             return (this._definitions[name] as LazyServiceDefinition<T, T[K]>)(this);
         }
         return this._definitions[name] as T[K];

src/pimple.ts

@@ -1,9 +1,10 @@
 import Pimple from '../src/pimple';
 import {ServiceProvider} from "../src/index.js";
+import {describe, expect, it} from "@jest/globals";
 
 describe('pimple container', () => {
     it('returns container version', async () => {
-        expect(Pimple.VERSION).toBe('3.0.0');
+        expect(Pimple.VERSION).toBe('2.1.0');
     });
 
     it('stores values', async () => {
@@ -174,6 +175,57 @@ describe('pimple container', () => {
         }).toThrow('Definition with "foo" not defined in container.');
     });
 
+    it('throws when calling set on an already defined service', () => {
+        type ServiceMap = {
+            foo: string,
+        }
+
+        const container = new Pimple<ServiceMap>();
+        container.set('foo', () => 'first');
+
+        expect(() => {
+            container.set('foo', () => 'second');
+        }).toThrow('Service "foo" is already defined. Use replace() to overwrite it.');
+    });
+
+    it('replaces a service before it is resolved', () => {
+        type ServiceMap = {
+            foo: string,
+        }
+
+        const container = new Pimple<ServiceMap>();
+        container.set('foo', () => 'original');
+        container.replace('foo', () => 'replaced');
+
+        expect(container.get('foo')).toBe('replaced');
+    });
+
+    it('throws when replacing a service that has already been resolved', () => {
+        type ServiceMap = {
+            foo: string,
+        }
+
+        const container = new Pimple<ServiceMap>();
+        container.set('foo', () => 'original');
+        container.get('foo');
+
+        expect(() => {
+            container.replace('foo', () => 'replaced');
+        }).toThrow('Service "foo" has already been resolved and cannot be replaced.');
+    });
+
+    it('throws when replacing a service that is not defined', () => {
+        type ServiceMap = {
+            foo: string,
+        }
+
+        const container = new Pimple<ServiceMap>();
+
+        expect(() => {
+            container.replace('foo', () => 'replaced');
+        }).toThrow('Service "foo" is not defined in the container.');
+    });
+
     it('extends service', () => {
         type ServiceMap = {
             foo: string,