feat: add resolveProps (#340) (#343)

* feat: add `resolveProps` (#340)

* docs: fix resolveProps docs

* feat: add type test for resolveProps

Author: 2chanhaeng

src/index.ts

@@ -53,6 +53,7 @@ import prop from "./prop";
 import props from "./props";
 import reduce from "./reduce";
 import reduceLazy from "./reduceLazy";
+import resolveProps from "./resolveProps";
 import size from "./size";
 import some from "./some";
 import sort from "./sort";
@@ -98,11 +99,11 @@ export {
   isDate,
   isEmpty,
   isNil,
+  isNull,
   isNumber,
   isObject,
   isString,
   isUndefined,
-  isNull,
   join,
   juxt,
   last,
@@ -126,8 +127,8 @@ export {
   props,
   reduce,
   reduceLazy,
+  resolveProps,
   size,
-  unless,
   some,
   sort,
   sortBy,
@@ -137,6 +138,7 @@ export {
   throwIf,
   toArray,
   unicodeToArray,
+  unless,
   when,
 };
 

src/resolveProps.ts

@@ -0,0 +1,52 @@
+/**
+ * Resolve all properties of an object that may be promises.
+ *
+ * @example
+ * ```ts
+ * const obj = {
+ *  a: Promise.resolve(1),
+ *  b: 2,
+ *  c: Promise.resolve(3),
+ * }
+ *
+ * const result = await resolveProps(obj);
+ * console.log(result); // { a: 1, b: 2, c: 3 }
+ * ```
+ *
+ * Also, with this function, you can define `asyncEvolve` simply.
+ *
+ * ```ts
+ * import { evolve, pipe, resolveProps } from "@fx-ts/core";
+ *
+ * const asyncEvolve = <T extends object>(transformation:Transformation<T>) =>
+ *   (obj:T) => pipe(obj, evolve(transformation), resolveProps)
+ *
+ * const a = await asyncEvolve({ a: async (a) => a + 1 })({ a: 1 });
+ * console.log(a); // { a: 2 }
+ *
+ * const resultByFormat = await asyncEvolve<Request>({
+ *   foo: async (foo) => await fetch(`https://example.com/foo/${foo}`).json(),
+ *   bar: async (bar) => await fetch(`https://example.com/bar/${bar}`).text(),
+ * })
+ * const result = await resultByFormat({foo: "foo", bar: "bar"});
+ *
+ * console.log({
+ *  foo: result.foo,
+ *  bar: result.bar,
+ * })
+ * ```
+ *
+ * see {@link https://fxts.dev/docs/pipe | pipe} and {@link https://fxts.dev/docs/evolve | evolve}.
+ *
+ * @typeParam T - Type of input object
+ * @typeParam Key - Alias type of Keys of input object which are not symbols
+ */
+async function resolveProps<T extends object, Key = Exclude<keyof T, symbol>>(
+  obj: T,
+): Promise<{ [K in keyof T]: K extends Key ? Awaited<T[K]> : never }> {
+  return await Promise.all(
+    Object.entries(obj).map(async ([k, v]) => [k, await v]),
+  ).then(Object.fromEntries);
+}
+
+export default resolveProps;

test/resolveProps.spec.ts

@@ -0,0 +1,15 @@
+import resolveProps from "../src/resolveProps";
+
+describe("resolveProps", () => {
+  it("should resolve an object of promises to a promise of an object", async () => {
+    const obj = {
+      a: Promise.resolve(1),
+      b: Promise.resolve("2"),
+      c: Promise.resolve(true),
+      d: "non-promise value",
+    };
+
+    const result = await resolveProps(obj);
+    expect(result).toEqual({ a: 1, b: "2", c: true, d: "non-promise value" });
+  });
+});

type-check/resolveProps.test.ts

@@ -0,0 +1,71 @@
+import { evolve, pipe, resolveProps } from "../src";
+import * as Test from "../src/types/Test";
+
+const { checks, check } = Test;
+
+const res1 = pipe(
+  {
+    1: Promise.resolve(1),
+    a: Promise.resolve("a"),
+    undefined: Promise.resolve(undefined),
+    null: Promise.resolve(null),
+    bool: Promise.resolve(true),
+    object: Promise.resolve({ key: "value" }),
+  },
+  resolveProps,
+);
+const res2 = pipe(
+  {
+    notPromiseProp: 1,
+    promiseProp: Promise.resolve(1),
+  },
+  resolveProps,
+);
+const res3 = pipe(
+  {
+    notPromiseAsync: 1,
+    notPromiseResolve: 1,
+    promiseAsync: Promise.resolve(1),
+    promiseThen: Promise.resolve(1),
+  },
+  evolve({
+    notPromiseAsync: async (x) => ({ a: x }),
+    notPromiseResolve: (x) => Promise.resolve({ b: x + 1 }),
+    promiseAsync: async (x) => ({ c: (await x) + 2 }),
+    promiseThen: (x) => x.then((d) => ({ d: d + 3 })),
+  }),
+  resolveProps,
+);
+
+checks([
+  check<
+    typeof res1,
+    Promise<{
+      1: number;
+      a: string;
+      undefined: undefined;
+      null: null;
+      bool: boolean;
+      object: { key: string };
+    }>,
+    Test.Pass
+  >(),
+  check<
+    typeof res2,
+    Promise<{
+      notPromiseProp: number;
+      promiseProp: number;
+    }>,
+    Test.Pass
+  >(),
+  check<
+    typeof res3,
+    Promise<{
+      notPromiseAsync: { a: number };
+      notPromiseResolve: { b: number };
+      promiseAsync: { c: number };
+      promiseThen: { d: number };
+    }>,
+    Test.Pass
+  >(),
+]);