@tstdl/base 0.89.3 → 0.89.5

package/injector/injector.js

@@ -288,7 +288,15 @@ export class Injector {
                     throw new ResolveError(`${provider.useClass.name} has constructor parameters but is not injectable.`, chain);
                 }
                 const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
-                result = { value: new provider.useClass(...parameters) };
+                try {
+                    result = { value: new provider.useClass(...parameters) };
+                }
+                catch (error) {
+                    if (error instanceof ResolveError) {
+                        throw error;
+                    }
+                    throw new ResolveError('Error in class constructor.', chain, error);
+                }
             }
             if (isValueProvider(provider)) {
                 result = { value: provider.useValue };

package/key-value-store/mongo/module.js

@@ -13,6 +13,6 @@ export function configureMongoKeyValueStore(keyValueRepositoryConfig, register =
     Injector.register(DEFAULT_KEY_VALUE_REPOSITORY_CONFIG, { useValue: keyValueRepositoryConfig });
     if (register) {
         Injector.registerSingleton(KeyValueStoreProvider, { useToken: MongoKeyValueStoreProvider });
-        Injector.registerSingleton(KeyValueStore, { useToken: MongoKeyValueStore, defaultArgument: '' });
+        Injector.registerSingleton(KeyValueStore, { useToken: MongoKeyValueStore });
     }
 }

package/key-value-store/mongo/mongo-key-value.store.js

@@ -7,15 +7,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 import { getNewId } from '../../database/index.js';
-import { InjectArg, Singleton } from '../../injector/index.js';
-import { KeyValueStore } from '../../key-value-store/index.js';
+import { Singleton } from '../../injector/index.js';
+import { KeyValueStore, MongoKeyValueStoreProvider } from '../../key-value-store/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { objectEntries } from '../../utils/object/object.js';
-import { assertStringPass, isUndefined } from '../../utils/type-guards.js';
+import { assertString, isUndefined } from '../../utils/type-guards.js';
 import { MongoKeyValueRepository } from './mongo-key-value.repository.js';
 let MongoKeyValueStore = class MongoKeyValueStore extends KeyValueStore {
     keyValueRepository;
@@ -61,8 +58,15 @@ let MongoKeyValueStore = class MongoKeyValueStore extends KeyValueStore {
     }
 };
 MongoKeyValueStore = __decorate([
-    Singleton(),
-    __param(1, InjectArg((argument) => assertStringPass(argument, 'key-value store argument missing (module)'))),
+    Singleton({
+        provider: {
+            useFactory: (argument, context) => {
+                const provider = context.resolve(MongoKeyValueStoreProvider);
+                assertString(argument, 'Missing or invalid argument (KV-Store module)');
+                return provider.get(argument);
+            }
+        }
+    }),
     __metadata("design:paramtypes", [MongoKeyValueRepository, String])
 ], MongoKeyValueStore);
 export { MongoKeyValueStore };

package/lock/mongo/provider.js

@@ -10,7 +10,7 @@ import { inject, injectArgument } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
 import { LockProvider } from '../../lock/index.js';
 import { Logger } from '../../logger/index.js';
-import { assertDefinedPass } from '../../utils/type-guards.js';
+import { assertDefinedPass, isDefined } from '../../utils/type-guards.js';
 import { MongoLock } from './lock.js';
 import { mongoLockModuleConfig } from './module.js';
 import { MongoLockRepository } from './mongo-lock-repository.js';
@@ -18,7 +18,7 @@ let MongoLockProvider = MongoLockProvider_1 = class MongoLockProvider extends Lo
     #injector = inject(Injector);
     #lockRepository = inject(MongoLockRepository, assertDefinedPass(mongoLockModuleConfig.lockEntityRepositoryConfig, 'mongo lock module not configured'));
     #logger = inject(Logger, 'MongoLock');
-    #prefix = injectArgument(this);
+    #prefix = injectArgument(this, { optional: true });
     prefix(prefix) {
         return this.#injector.resolve(MongoLockProvider_1, this.getResourceString(prefix));
     }
@@ -26,7 +26,7 @@ let MongoLockProvider = MongoLockProvider_1 = class MongoLockProvider extends Lo
         return new MongoLock(this.#lockRepository, this.getResourceString(resource), this.#logger);
     }
     getResourceString(resource) {
-        const prefixDivider = (this.#prefix.length > 0) ? ':' : '';
+        const prefixDivider = (isDefined(this.#prefix) && (this.#prefix.length > 0)) ? ':' : '';
         return `${this.#prefix}${prefixDivider}${resource}`;
     }
 };

package/module/modules/web-server.module.js

@@ -55,7 +55,9 @@ let WebServerModule = class WebServerModule extends ModuleBase {
     }
 };
 WebServerModule = __decorate([
-    Singleton({ defaultArgumentProvider: () => webServerModuleConfiguration }),
+    Singleton({
+        defaultArgumentProvider: () => webServerModuleConfiguration
+    }),
     __metadata("design:paramtypes", [])
 ], WebServerModule);
 export { WebServerModule };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.89.3",
+  "version": "0.89.5",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -121,7 +121,7 @@
     "@typescript-eslint/parser": "6.7",
     "concurrently": "8.2",
     "esbuild": "0.19",
-    "eslint": "8.49",
+    "eslint": "8.50",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.28",
     "tsc-alias": "1.8",