feat(ioc): allow deep plain object as param

Author: juanrgm

.changeset/hot-points-help.md

@@ -0,0 +1,5 @@
+---
+"@dreamkit/ioc": minor
+---
+
+Allow deep plain object as param

packages/ioc/src/context.ts

@@ -17,6 +17,7 @@ import {
 } from "./registry.js";
 import { ensureSync } from "./utils/async.js";
 import { iocKind, KindMap } from "./utils/kind.js";
+import { isPlainObject } from "./utils/object.js";
 import { capitalize } from "./utils/string.js";
 import type { AbstractConstructor, Constructor } from "./utils/ts.js";
 import { is } from "@dreamkit/kind";
@@ -323,7 +324,7 @@ export class IocContext {
     if (!onResolveIocObject || onResolveIocObject(input)) {
       return {
         paramOptions: { context, parent: input },
-        params: normalizeIocParams(iocObject.$ioc.params),
+        params: iocObject.$ioc.params,
         create,
       };
     }
@@ -340,22 +341,45 @@ export class IocContext {
       ? this.resolveAsync(input, options)
       : this.resolve(input, options);
   }
-  resolveParams<T extends IocParamsUserConfig>(input: T): IocParams<T> {
-    const config = normalizeIocParams(input);
+  resolveParams<T extends IocParamsUserConfig>(
+    input: T,
+    options: {
+      parent?: unknown;
+      context?: IocContext;
+    } = {},
+  ): IocParams<T> {
+    const config = normalizeIocParams(input, false);
     const params: Record<string, any> = {};
     for (const name in config) {
-      params[name] = ensureSync(this.createParam(config[name]));
+      const value = config[name];
+      if (isPlainObject(value)) {
+        params[name] = this.resolveParams(value, options);
+      } else {
+        params[name] = ensureSync(this.createParam(value, options));
+      }
     }
     return params as any;
   }
 
   async resolveAsyncParams<T extends IocParamsUserConfig>(
     input: T,
+    options: {
+      parent?: unknown;
+      context?: IocContext;
+    } = {},
   ): Promise<IocParams<T>> {
-    const config = normalizeIocParams(input);
+    const config = normalizeIocParams(input, false);
     const params: Record<string, any> = {};
     for (const name in config) {
-      params[name] = await this.createParam(config[name]);
+      const value = config[name];
+      if (isPlainObject(value)) {
+        params[name] = await this.resolveAsyncParams(value, options);
+      } else {
+        params[name] = await this.createParam(value, {
+          ...options,
+          async: true,
+        });
+      }
     }
     return params as any;
   }
@@ -400,12 +424,7 @@ export class IocContext {
     const object = this.tryParseIocObject(input, options);
 
     if (object) {
-      const params: Record<string, any> = {};
-      for (const name in object.params) {
-        params[name] = ensureSync(
-          this.createParam(object.params[name], object.paramOptions),
-        );
-      }
+      const params = this.resolveParams(object.params, object.paramOptions);
       return object.create(params);
     }
   }
@@ -451,13 +470,10 @@ export class IocContext {
     const object = this.tryParseIocObject(input, options);
 
     if (object) {
-      const params: Record<string, any> = {};
-      for (const name in object.params) {
-        params[name] = await this.createParam(object.params[name], {
-          ...object.paramOptions,
-          async: true,
-        });
-      }
+      const params = await this.resolveAsyncParams(
+        object.params,
+        object.paramOptions,
+      );
       return object.create(params);
     }
   }

packages/ioc/src/params.ts

@@ -1,6 +1,7 @@
 import { IocFunc } from "./func.js";
 import type { IocRegistryData, IocRegistryKey } from "./registry.js";
 import { iocKind } from "./utils/kind.js";
+import { isPlainObject } from "./utils/object.js";
 import { uncapitalize } from "./utils/string.js";
 import type {
   AbstractConstructor,
@@ -18,7 +19,9 @@ export type IocParamValue = ParamValue & {
 };
 
 export type IocParamsConfig = Record<string, IocParamBuilder>;
-export type IocParamsUserConfig = Record<string, IocParamBuilder | ParamValue>;
+export type IocParamsUserConfig = {
+  [name: string]: IocParamBuilder | ParamValue | IocParamsUserConfig;
+};
 
 export type IocParamConfigurable<V extends ParamValue> = V extends IocParamValue
   ? {
@@ -131,7 +134,9 @@ export type IocParam<V> = V extends NumberConstructor
           ? V extends { bind: IocBind }
             ? ReturnType<V["bind"]>
             : (...args: Parameters<V>) => ReturnType<V>
-          : V;
+          : V extends Record<string, any>
+            ? IocParams<V>
+            : V;
 
 export type IocBind<S = any, R = any> = {
   (input: S): R;
@@ -180,16 +185,27 @@ export function iocParam<V extends ParamValue>(
 ): IocParamBuilder<{ value: V }> {
   return new IocParamBuilder({ value });
 }
-
+export function normalizeIocParams(input: IocParamsUserConfig): IocParamsConfig;
+export function normalizeIocParams(
+  input: IocParamsUserConfig,
+  deep: false,
+): {
+  [name: string]: IocParamBuilder | IocParamsUserConfig;
+};
 export function normalizeIocParams(
   input: IocParamsUserConfig,
+  deep?: boolean,
 ): IocParamsConfig {
-  const params: IocParamsConfig = {};
+  const params: any = {};
   for (const key in input) {
     const value = input[key];
     params[uncapitalize(key)] = kindOf(value, IocParamBuilder)
       ? value
-      : iocParam(value);
+      : isPlainObject(value)
+        ? deep
+          ? normalizeIocParams(value)
+          : value
+        : iocParam(value);
   }
   return params;
 }

packages/ioc/src/utils/object.ts

@@ -0,0 +1,7 @@
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return !proto || !Object.getPrototypeOf(proto);
+}

packages/ioc/test/class.test.ts

@@ -1,5 +1,6 @@
 import { createIocClass, IocClass } from "../src/class.js";
 import { context } from "../src/context.js";
+import { IocFunc } from "../src/func.js";
 import { iocParam } from "../src/params.js";
 import { kind } from "@dreamkit/kind";
 import { describe, expect, expectTypeOf, it } from "vitest";
@@ -187,6 +188,49 @@ describe("IocClass", () => {
       external: 2,
     });
   });
+  it("with deep plain object", () => {
+    class Handler {
+      read() {
+        return 1;
+      }
+      fetch() {
+        return 2;
+      }
+    }
+    class Token {
+      constructor(readonly value: string) {}
+    }
+
+    const api = {
+      fs: {
+        Token,
+        read: IocFunc({ Handler })(function () {
+          return this.handler.read();
+        }),
+      },
+      network: {
+        http: {
+          Token: iocParam(Token).optional(),
+          fetch: IocFunc({ Handler })(function () {
+            return this.handler.fetch();
+          }),
+        },
+      },
+    };
+
+    class App extends IocClass({ api }) {}
+    const app = context
+      .fork()
+      .register(new Handler())
+      .register(new Token("secret"))
+      .resolve(App);
+    // @ts-expect-error
+    app.api.network.http.token.value;
+    expect(app.api.fs.token.value).toBe("secret");
+    expect(app.api.network.http.token?.value).toBe("secret");
+    expect(app.api.fs.read()).toBe(1);
+    expect(app.api.network.http.fetch()).toBe(2);
+  });
 });
 
 describe("createIocClass", () => {