chore: review coderabbitai

packages/di/src/common/decorators/autoInjectable.ts

@@ -17,7 +17,7 @@ function resolveAutoInjectableArgs(token: Type, args: unknown[]) {
       list.push(args[i]);
     } else {
       const value = deps[i];
-      const instance = isArray(value) ? inj!.getMany(value[0], {locals, parent: token}) : inj!.invoke(value, {locals, parent: token});
+      const instance = isArray(value) ? inj.getMany(value[0], {locals, parent: token}) : inj.invoke(value, {locals, parent: token});
 
       list.push(instance);
     }

packages/di/src/common/domain/Provider.ts

@@ -140,8 +140,18 @@ export class Provider<T = any> implements ProviderOpts<T> {
   getArgOpts(index: number) {
     return this.store.get(`${DI_USE_PARAM_OPTIONS}:${index}`);
   }
-
+  /**
+   * Retrieves a value from the provider's store.
+   * @param key The key to look up
+   * @returns The value if found, undefined otherwise
+   */
   get<Type = unknown>(key: string): Type | undefined;
+  /**
+   * Retrieves a value from the provider's store with a default fallback.
+   * @param key The key to look up
+   * @param defaultValue The value to return if key is not found
+   * @returns The found value or defaultValue
+   */
   get<Type = unknown>(key: string, defaultValue: Type): Type;
   get<Type = unknown>(key: string, defaultValue?: Type): Type | undefined {
     return this.store.get(key) || this._tokenStore.get(key) || defaultValue;

packages/di/src/common/fn/injectMany.ts

@@ -2,6 +2,15 @@ import type {InvokeOptions} from "../interfaces/InvokeOptions.js";
 import {injector} from "./injector.js";
 import {localsContainer} from "./localsContainer.js";
 
+/**
+ * Injects multiple instances of a given token using the injector service.
+ * @param token - The injection token to resolve
+ * @param opts - Optional configuration for the injection
+ * @param opts.useOpts - Options for instance creation
+ * @param opts.rebuild - Whether to rebuild the instance
+ * @param opts.locals - Local container overrides
+ * @returns Array of resolved instances
+ */
 export function injectMany<T>(token: string | symbol, opts?: Partial<Pick<InvokeOptions, "useOpts" | "rebuild" | "locals">>): T[] {
-  return injector().getMany<T>(token, {...opts, locals: opts?.locals || localsContainer()});
+  return injector().getMany<T>(token, {...opts, locals: opts?.locals || localsContainer()} as InvokeOptions);
 }

packages/di/src/common/services/InjectorService.ts

@@ -18,6 +18,8 @@ import {createContainer} from "../utils/createContainer.js";
 import {getConstructorDependencies} from "../utils/getConstructorDependencies.js";
 import {DIConfiguration} from "./DIConfiguration.js";
 
+const EXCLUDED_CONFIGURATION_KEYS = ["mount", "imports"];
+
 /**
  * This service contain all services collected by `@Service` or services declared manually with `InjectorService.factory()` or `InjectorService.service()`.
  *
@@ -89,7 +91,7 @@ export class InjectorService extends Container {
    */
   getMany<Type = any>(type: any, options?: Partial<InvokeOptions>): Type[] {
     return this.getProviders(type).map((provider) => {
-      return this.invoke(provider.token, options)!;
+      return this.invoke<Type>(provider.token, options);
     });
   }
 
@@ -194,9 +196,7 @@ export class InjectorService extends Container {
         if (options.locals) {
           options.locals.set(token, instance);
 
-          if (provider.hooks && provider.hooks.$onDestroy) {
-            options.locals.hooks.on("$onDestroy", (...args: any[]) => provider.hooks!.$onDestroy(instance, ...args));
-          }
+          options.locals?.hooks.on("$onDestroy", (...args: unknown[]) => provider.hooks?.$onDestroy(instance, ...args));
         }
 
         return instance;
@@ -257,7 +257,7 @@ export class InjectorService extends Container {
     super.forEach((provider) => {
       if (provider.configuration && provider.type !== "server:module") {
         Object.entries(provider.configuration).forEach(([key, value]) => {
-          if (!["mount", "imports"].includes(key)) {
+          if (!EXCLUDED_CONFIGURATION_KEYS.includes(key)) {
             value = mergedConfiguration.has(key) ? deepMerge(mergedConfiguration.get(key), value) : deepClone(value);
             mergedConfiguration.set(key, value);
           }

packages/orm/adapters/src/services/Adapters.ts

@@ -1,5 +1,5 @@
 import {Type} from "@tsed/core";
-import {Inject, Injectable, InjectorService} from "@tsed/di";
+import {constant, inject, injectable} from "@tsed/di";
 
 import {MemoryAdapter} from "../adapters/MemoryAdapter.js";
 import {Adapter, AdapterConstructorOptions} from "../domain/Adapter.js";
@@ -8,16 +8,14 @@ export interface AdapterInvokeOptions<Model = any> extends AdapterConstructorOpt
   adapter?: Type<Adapter<Model>>;
 }
 
-@Injectable()
 export class Adapters {
-  @Inject()
-  injector: InjectorService;
-
   invokeAdapter<T = any>(options: AdapterInvokeOptions): Adapter<T> {
-    const {adapter = this.injector.settings.get("adapters.Adapter", MemoryAdapter), ...props} = options;
+    const {adapter = constant("adapters.Adapter", MemoryAdapter), ...props} = options;
 
-    return this.injector.invoke<Adapter<T>>(adapter, {
+    return inject<Adapter<T>>(adapter, {
       useOpts: props
     });
   }
 }
+
+injectable(Adapters);