akanjs 2.3.9-rc.2 → 2.3.9-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.3.9-rc.2",
+  "version": "2.3.9-rc.3",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/di/diLifecycle.ts

@@ -1,5 +1,5 @@
 import type { BaseEnv } from "akanjs/base";
-import { Logger, lowerlize } from "akanjs/common";
+import { Logger } from "akanjs/common";
 import {
   type Adaptor,
   type AdaptorCls,
@@ -26,29 +26,17 @@ import type { SignalRoutes, WebsocketRoutes } from "../types";
 import { getPredefinedAdaptor, predefinedAdaptorRole } from "./predefinedAdaptor";
 import { collectAdaptors, resolveAdaptorHierarchy } from "./resolveAdaptorHierarchy";
 import { resolveServiceHierarchy } from "./resolveServiceHierarchy";
-import { reasonMessage, runStage, toError } from "./utils";
-
-interface DestroyableUse {
-  onDestroy(): Promise<void> | void;
-}
-
-const isDestroyableUse = (value: unknown): value is DestroyableUse =>
-  typeof value === "object" &&
-  value !== null &&
-  "onDestroy" in value &&
-  typeof (value as { onDestroy?: unknown }).onDestroy === "function";
-
-const normalizeServiceRefName = (refName: string) => {
-  const normalized = lowerlize(refName);
-  return normalized.endsWith("Service") ? normalized.slice(0, -"Service".length) : normalized;
-};
-
-const normalizeSignalRefName = (refName: string) => {
-  const normalized = lowerlize(refName);
-  return normalized.endsWith("Signal") ? normalized : `${normalized}Signal`;
-};
-
-const normalizeAdaptorRefName = (refName: string) => lowerlize(refName);
+import {
+  type DiModuleCandidate,
+  getModuleDependencyRefNames,
+  isDestroyableUse,
+  normalizeAdaptorRefName,
+  normalizeServiceRefName,
+  normalizeSignalRefName,
+  reasonMessage,
+  runStage,
+  toError,
+} from "./utils";
 
 /**
  * Owns the app's DI container state (registry + live maps + init order) and
@@ -88,25 +76,32 @@ export class DiLifecycle {
       this.#middleware.set(middleware.refName, middleware);
     });
     this.webProxies.push(...defaultOption.getWebProxies());
+    const databaseCandidates = new Map<string, DiModuleCandidate>();
+    const serviceCandidates = new Map<string, DiModuleCandidate>();
     libs.forEach((lib) => {
       lib.option.getMiddlewares().forEach((middleware) => {
         this.#middleware.set(middleware.refName, middleware);
       });
       this.webProxies.push(...lib.option.getWebProxies());
       lib.database.forEach((mod) => {
-        
-        if (!mod.service.srv.enabled) return;
-        this.#database.set(mod.constant.refName, mod);
+        databaseCandidates.set(mod.constant.refName, { refName: mod.constant.refName, module: mod });
       });
       lib.service.forEach((mod) => {
-        
-        if (!mod.service.srv.enabled) return;
-        this.#service.set(mod.service.srv.refName, mod);
+        serviceCandidates.set(mod.service.srv.refName, { refName: mod.service.srv.refName, module: mod });
       });
       lib.scalar.forEach((mod) => {
         this.#scalar.set(mod.constant.refName, mod);
       });
     });
+    const disabledModules = this.#resolveDisabledModules(databaseCandidates, serviceCandidates);
+    databaseCandidates.forEach(({ refName, module }) => {
+      if (disabledModules.has(refName)) return;
+      this.#database.set(refName, module as DatabaseModule);
+    });
+    serviceCandidates.forEach(({ refName, module }) => {
+      if (disabledModules.has(refName)) return;
+      this.#service.set(refName, module as ServiceModule);
+    });
     this.#database.forEach((mod) => {
       const databaseAdaptor = DatabaseResolver.resolveDatabase(mod.constant, mod.database);
       this.#adaptor.set(databaseAdaptor.refName, databaseAdaptor);
@@ -120,6 +115,39 @@ export class DiLifecycle {
     }
   }
 
+  #resolveDisabledModules(
+    databaseCandidates: Map<string, DiModuleCandidate>,
+    serviceCandidates: Map<string, DiModuleCandidate>,
+  ) {
+    const candidates = new Map<string, DiModuleCandidate>([...databaseCandidates, ...serviceCandidates]);
+    const disabledReasons = new Map<string, string>();
+
+    candidates.forEach(({ refName, module }) => {
+      if (!module.service.srv.enabled) disabledReasons.set(refName, "service disabled");
+    });
+
+    let changed = true;
+    while (changed) {
+      changed = false;
+      candidates.forEach(({ refName, module }) => {
+        if (disabledReasons.has(refName)) return;
+        for (const dependencyRefName of getModuleDependencyRefNames(module)) {
+          if (dependencyRefName === refName) continue;
+          const dependencyReason = disabledReasons.get(dependencyRefName);
+          if (!dependencyReason) continue;
+          disabledReasons.set(refName, `depends on disabled module "${dependencyRefName}"`);
+          changed = true;
+          break;
+        }
+      });
+    }
+
+    disabledReasons.forEach((reason, refName) => {
+      this.logger.verbose(`Skipping disabled module "${refName}": ${reason}`);
+    });
+    return new Set(disabledReasons.keys());
+  }
+
   /** Run every init stage in dependency order and collect the generated routes. */
   async initializeAll(): Promise<SignalRoutes> {
     await this.#initializeUses();

package/server/di/utils.ts

@@ -1,8 +1,72 @@
+import { INJECT_META } from "akanjs/base";
+import { lowerlize } from "akanjs/common";
+import type { InjectInfo } from "akanjs/service";
+import type { DatabaseModule, ServiceModule } from "../akanLib";
+
 interface StageTask {
   label: string;
   run: () => Promise<unknown>;
 }
 
+interface DestroyableUse {
+  onDestroy(): Promise<void> | void;
+}
+
+type InjectableCls = { [INJECT_META]?: unknown };
+
+export interface DiModuleCandidate {
+  refName: string;
+  module: DatabaseModule | ServiceModule;
+}
+
+export const isDestroyableUse = (value: unknown): value is DestroyableUse =>
+  typeof value === "object" &&
+  value !== null &&
+  "onDestroy" in value &&
+  typeof (value as { onDestroy?: unknown }).onDestroy === "function";
+
+export const normalizeServiceRefName = (refName: string) => {
+  const normalized = lowerlize(refName);
+  return normalized.endsWith("Service") ? normalized.slice(0, -"Service".length) : normalized;
+};
+
+export const normalizeSignalRefName = (refName: string) => {
+  const normalized = lowerlize(refName);
+  return normalized.endsWith("Signal") ? normalized : `${normalized}Signal`;
+};
+
+export const normalizeAdaptorRefName = (refName: string) => lowerlize(refName);
+
+const normalizeInjectedServiceRefName = (propKey: string) =>
+  propKey.endsWith("Service") ? propKey.slice(0, -"Service".length) : propKey;
+
+const normalizeInjectedDatabaseRefName = (propKey: string) =>
+  propKey.endsWith("Model") ? propKey.slice(0, -"Model".length) : propKey;
+
+const normalizeInjectedSignalRefName = (propKey: string) => {
+  const normalized = lowerlize(propKey);
+  return normalized.endsWith("Signal") ? normalized.slice(0, -"Signal".length) : normalized;
+};
+
+const getModuleInjectables = (mod: DatabaseModule | ServiceModule): InjectableCls[] => {
+  const injectables: InjectableCls[] = [mod.service.srv, mod.signal.internal, mod.signal.endpoint, mod.signal.server];
+  if ("constant" in mod) injectables.push(mod.signal.slice);
+  return injectables;
+};
+
+export const getModuleDependencyRefNames = (mod: DatabaseModule | ServiceModule) => {
+  const dependencies = new Set<string>();
+  for (const injectable of getModuleInjectables(mod)) {
+    const injectMap = (injectable[INJECT_META] ?? {}) as Record<string, InjectInfo>;
+    for (const [propKey, injectInfo] of Object.entries(injectMap)) {
+      if (injectInfo.type === "service") dependencies.add(normalizeInjectedServiceRefName(propKey));
+      else if (injectInfo.type === "database") dependencies.add(normalizeInjectedDatabaseRefName(propKey));
+      else if (injectInfo.type === "signal") dependencies.add(normalizeInjectedSignalRefName(propKey));
+    }
+  }
+  return dependencies;
+};
+
 /**
  * Run every task in parallel and, if any rejects, throw a single
  * `AggregateError` that enumerates every failing label + cause. This replaces

package/signal/internalInfo.ts

@@ -212,8 +212,7 @@ export const buildInternal = {
   resolveField: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(
     returnRef: Returns,
     signalOption?: Pick<SignalOption<Returns, Nullable>, "nullable">,
-  ) =>
-    new InternalInfo("resolveField", returnRef, signalOption),
+  ) => new InternalInfo("resolveField", returnRef, signalOption),
   interval: (scheduleTime: number, signalOption?: SignalOption) =>
     new InternalInfo("interval", Any, {
       enabled: true,

package/types/server/di/utils.d.ts

@@ -1,7 +1,20 @@
+import type { DatabaseModule, ServiceModule } from "../akanLib.d.ts";
 interface StageTask {
     label: string;
     run: () => Promise<unknown>;
 }
+interface DestroyableUse {
+    onDestroy(): Promise<void> | void;
+}
+export interface DiModuleCandidate {
+    refName: string;
+    module: DatabaseModule | ServiceModule;
+}
+export declare const isDestroyableUse: (value: unknown) => value is DestroyableUse;
+export declare const normalizeServiceRefName: (refName: string) => string;
+export declare const normalizeSignalRefName: (refName: string) => string;
+export declare const normalizeAdaptorRefName: (refName: string) => string;
+export declare const getModuleDependencyRefNames: (mod: DatabaseModule | ServiceModule) => Set<string>;
 /**
  * Run every task in parallel and, if any rejects, throw a single
  * `AggregateError` that enumerates every failing label + cause. This replaces