packages/lib/di/di.ts (1)

31-50: Single-dependency overload reads cleanly.

This removes ambiguity at call sites and matches the repository modules’ usage in this PR.

packages/lib/di/modules/Attribute.ts (1)

10-16: Correct use of dep path for single dependency; matches the intended API.

This mirrors the pattern discussed in prior comments—good call using dep until multiple deps are needed.

packages/lib/di/di.ts (1)

57-112: Load dependencies first; small ergonomics tweaks.

• Load deps before calling container.load to avoid order surprises.
• Use Object.values when iterating depsMap to simplify and avoid inherited keys.
• Optional: consider symbol-keyed deps if needed.

Apply:

@@
-  if (dep) {
-    module.bind(token).toClass(classs, [dep.token]);
-  } else if (depsMap) {
-    const depsObject = Object.fromEntries(Object.entries(depsMap).map(([key, value]) => [key, value.token]));
-    module.bind(token).toClass(classs, depsObject);
-  }
+  if (dep) {
+    module.bind(token).toClass(classs, [dep.token]);
+  } else if (depsMap) {
+    const entries = Object.entries(depsMap) as [string, ModuleLoader][];
+    const depsObject = Object.fromEntries(entries.map(([key, value]) => [key, value.token]));
+    module.bind(token).toClass(classs, depsObject);
+  }
@@
-  return function loadModule(container: Container) {
-    container.load(moduleToken, module);
-
-    if (dep) {
-      dep.loadModule(container);
-    } else if (depsMap) {
-      for (const key in depsMap) {
-        const loadModule = depsMap[key as keyof typeof depsMap].loadModule;
-        loadModule(container);
-      }
-    }
-  };
+  return function loadModule(container: Container) {
+    if (dep) {
+      dep.loadModule(container);
+    } else if (depsMap) {
+      for (const loader of Object.values(depsMap)) {
+        loader.loadModule(container);
+      }
+    }
+    container.load(moduleToken, module);
+  };

Confirmed @evyweb/ioctopus supports both array and object-map forms for toClass. (npmjs.com)

packages/lib/di/modules/Host.ts (1)

18-21: Minor: prevent accidental mutation of the loader object.

Optional: freeze or mark as readonly to guard against accidental reassignment.

-export const moduleLoader: ModuleLoader = {
-  token,
-  loadModule,
-};
+export const moduleLoader: ModuleLoader = Object.freeze({
+  token,
+  loadModule,
+}) as ModuleLoader;

packages/lib/di/modules/Attribute.ts (1)

18-21: Nit: make the exported loader immutable for safety.

Same small hardening as in Host.

-export const moduleLoader: ModuleLoader = {
-  token,
-  loadModule,
-};
+export const moduleLoader: ModuleLoader = Object.freeze({
+  token,
+  loadModule,
+}) as ModuleLoader;

packages/lib/di/containers/LuckyUser.ts (2)

9-10: Ensure idempotent loading to avoid duplicate bindings.

If getLuckyUserService() is called multiple times, consider guarding loadModule so the module is loaded once per container.

-  luckyUserServiceModuleLoader.loadModule(container);
-  return container.get<LuckyUserService>(luckyUserServiceModuleLoader.token);
+  // Load once per process/container
+  if (!(globalThis as any).__luckyUserLoaded) {
+    luckyUserServiceModuleLoader.loadModule(container);
+    (globalThis as any).__luckyUserLoaded = true;
+  }
+  return container.get<LuckyUserService>(luckyUserServiceModuleLoader.token);

Alternatively (outside the changed lines), introduce a local guard:

// top-level (outside the function)
let luckyUserLoaded = false;

function ensureLuckyUserLoaded() {
  if (!luckyUserLoaded) {
    luckyUserServiceModuleLoader.loadModule(container);
    luckyUserLoaded = true;
  }
}

Then inside the function:

ensureLuckyUserLoaded();
return container.get<LuckyUserService>(luckyUserServiceModuleLoader.token);

---

4-4: Tiny ergonomics: add an explicit return type to the getter.

Improves API clarity and refactors.

-export function getLuckyUserService() {
+export function getLuckyUserService(): LuckyUserService {

packages/lib/di/modules/LuckyUser.ts (1)

11-26: Ensure depsMap keys exactly match LuckyUserService constructor deps

Constructor uses ILuckyUserService with keys bookingRepository, hostRepository, oooRepository, userRepository, attributeRepository — add a compile-time check using satisfies:

+type LuckyUserDeps = ConstructorParameters<typeof LuckyUserService>[0];
+const depsMapTyped = {
+  bookingRepository: bookingRepositoryModuleLoader,
+  hostRepository: hostRepositoryModuleLoader,
+  oooRepository: oooRepositoryModuleLoader,
+  userRepository: userRepositoryModuleLoader,
+  attributeRepository: attributeRepositoryModuleLoader,
+} satisfies Record<keyof LuckyUserDeps, ModuleLoader>;
 
-const loadModule = bindModuleToClassOnToken({
+const loadModule = bindModuleToClassOnToken({
   module: thisModule,
   moduleToken,
   token,
   classs: LuckyUserService,
-  depsMap: {
-    bookingRepository: bookingRepositoryModuleLoader,
-    hostRepository: hostRepositoryModuleLoader,
-    oooRepository: oooRepositoryModuleLoader,
-    userRepository: userRepositoryModuleLoader,
-    attributeRepository: attributeRepositoryModuleLoader,
-  },
+  depsMap: depsMapTyped,
 });

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: nangelina
PR: calcom/cal.com#23486
File: packages/app-store/kyzon-space/lib/tokenManager.ts:25-31
Timestamp: 2025-09-01T08:56:14.071Z
Learning: In token refresh utilities like tokenManager.ts, accessing credential.key from Prisma is legitimate and necessary for OAuth token refresh flows. These internal utilities need stored credentials to refresh tokens and don't expose them in API responses.