@nestia/fetcher 2.0.0-dev.20230906 → 2.0.0-dev.20230907

package/src/Resolved.ts

@@ -0,0 +1,116 @@
+/**
+ * Resolved type erased every methods.
+ *
+ * `Resolved` is a type of TMP (Type Meta Programming) type which converts
+ * its argument as a resolved type that erased every method properties.
+ *
+ * If the target argument is a built-in class which returns its origin primitive type
+ * through the `valueOf()` method like the `String` or `Number`, its return type would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be same with the target argument.
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom methods
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the resolved object.
+ *
+ * Before                  | After
+ * ------------------------|----------------------------------------
+ * `Boolean`               | `boolean`
+ * `Number`                | `number`
+ * `BigInt`                | `bigint`
+ * `String`                | `string`
+ * `Class`                 | `interface`
+ * Native Class or Others  | No change
+ *
+ * @template Instance Target argument type.
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
+    ? T
+    : ResolvedMain<T>;
+
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type ResolvedMain<Instance> = Instance extends [never]
+    ? never // (special trick for jsonable | null) type
+    : ValueOf<Instance> extends boolean | number | bigint | string
+    ? ValueOf<Instance>
+    : Instance extends Function
+    ? never
+    : Instance extends object
+    ? ResolvedObject<Instance>
+    : ValueOf<Instance>;
+
+type ResolvedObject<Instance extends object> = Instance extends Array<infer T>
+    ? IsTuple<Instance> extends true
+        ? ResolvedTuple<Instance>
+        : ResolvedMain<T>[]
+    : Instance extends Set<infer U>
+    ? Set<ResolvedMain<U>>
+    : Instance extends Map<infer K, infer V>
+    ? Map<ResolvedMain<K>, ResolvedMain<V>>
+    : Instance extends WeakSet<any> | WeakMap<any, any>
+    ? never
+    : Instance extends
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? Instance
+    : {
+          [P in keyof Instance]: ResolvedMain<Instance[P]>;
+      };
+
+type ResolvedTuple<T extends readonly any[]> = T extends []
+    ? []
+    : T extends [infer F]
+    ? [ResolvedMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+    ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
+    : T extends [(infer F)?]
+    ? [ResolvedMain<F>?]
+    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+    ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
+    : [];
+
+type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : IsValueOf<Instance, Number> extends true
+    ? number
+    : IsValueOf<Instance, String> extends true
+    ? string
+    : Instance;
+
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+    never,
+]
+    ? false
+    : T extends readonly any[]
+    ? number extends T["length"]
+        ? false
+        : true
+    : false;
+
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
+    ? Object extends IValueOf<infer Primitive>
+        ? Instance extends Primitive
+            ? false
+            : true // not Primitive, but Object
+        : false // cannot be
+    : false;
+
+interface IValueOf<T> {
+    valueOf(): T;
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from "./IConnection";
 export * from "./IEncryptionPassword";
+export * from "./IPropagation";
 export * from "./IRandomGenerator";
-export * from "./Primitive";
 export * from "./HttpError";
+export * from "./Primitive";
+export * from "./Resolved";

package/src/internal/FetcherBase.ts

@@ -4,6 +4,7 @@ import { Primitive } from "../Primitive";
 import { IFetchRoute } from "./IFetchRoute";
 import { Singleton } from "./Singleton";
 import { HttpError } from "../HttpError";
+import { IPropagation } from "../IPropagation";
 
 export namespace FetcherBase {
     export interface IProps {
@@ -28,6 +29,49 @@ export namespace FetcherBase {
             input?: Input,
             stringify?: (input: Input) => string,
         ): Promise<Primitive<Output>> => {
+            const result = await _Propagate("fetch")(props)(
+                connection,
+                route,
+                input,
+                stringify,
+            );
+            if (result.success === false)
+                throw new HttpError(
+                    route.method,
+                    route.path,
+                    result.status,
+                    result.headers,
+                    result.data as string,
+                );
+            return result.data as Primitive<Output>;
+        };
+
+    export const propagate =
+        (props: IProps) =>
+        async <Input>(
+            connection: IConnection,
+            route: IFetchRoute<
+                "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT"
+            >,
+            input?: Input,
+            stringify?: (input: Input) => string,
+        ): Promise<IPropagation<any, any, any>> =>
+            _Propagate("propagate")(props)(connection, route, input, stringify);
+
+    /**
+     * @internal
+     */
+    const _Propagate =
+        (method: string) =>
+        (props: IProps) =>
+        async <Input>(
+            connection: IConnection,
+            route: IFetchRoute<
+                "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT"
+            >,
+            input?: Input,
+            stringify?: (input: Input) => string,
+        ): Promise<IPropagation<any, any, any>> => {
             //----
             // REQUEST MESSSAGE
             //----
@@ -86,46 +130,47 @@ export namespace FetcherBase {
                 await polyfill.get()
             )(url.href, init);
 
-            // VALIDATE RESPONSE
-            if (
-                (route.status !== null && response.status !== route.status) ||
-                (route.status === null &&
-                    response.status !== 200 &&
-                    response.status !== 201)
-            )
-                throw new HttpError(
-                    route.method,
-                    path,
-                    response.status,
-                    await response.text(),
-                );
-            else if (
-                route.response?.type &&
-                (
-                    response.headers.get("content-type") ?? route.response.type
-                )?.indexOf(route.response.type) === -1
-            )
-                throw new Error(
-                    `Error on ${
-                        props.className
-                    }.fetch(): response type mismatched - expected ${
-                        route.response.type
-                    }, but ${response.headers.get("content-type")}.`,
-                );
-
-            // RETURNS
-            if (route.method === "HEAD") return undefined!;
-            else if (route.response?.type === "application/json") {
-                const text: string = await response.text();
-                return text.length ? JSON.parse(text) : undefined;
+            // CONSTRUCT RESULT DATA
+            const result: IPropagation<any, any, any> = {
+                success:
+                    response.status === 200 ||
+                    response.status === 201 ||
+                    response.status == route.status,
+                status: route.status,
+                headers: response_headers_to_object(response.headers),
+                data: undefined!,
+            };
+            if (result.success === false) {
+                // WHEN FAILED
+                result.data = await response.text();
+                const type = response.headers.get("content-type");
+                if (
+                    method !== "fetch" &&
+                    type &&
+                    type.indexOf("application/json") !== -1
+                )
+                    try {
+                        result.data = JSON.parse(result.data);
+                    } catch {}
+            } else {
+                // WHEN SUCCESS
+                if (route.method === "HEAD") result.data = undefined!;
+                else if (route.response?.type === "application/json") {
+                    const text: string = await response.text();
+                    result.data = text.length ? JSON.parse(text) : undefined;
+                } else
+                    result.data = props.decode(
+                        await response.text(),
+                        result.headers,
+                    );
             }
-            return props.decode(
-                await response.text(),
-                response_headers_to_object(response.headers),
-            ) as Primitive<Output>;
+            return result;
         };
 }
 
+/**
+ * @internal
+ */
 const polyfill = new Singleton(async (): Promise<typeof fetch> => {
     if (
         typeof global === "object" &&
@@ -134,16 +179,19 @@ const polyfill = new Singleton(async (): Promise<typeof fetch> => {
         typeof global.process.versions.node !== undefined
     ) {
         if (global.fetch === undefined)
-            global.fetch = ((await import2("node-fetch")) as any).default;
+            global.fetch ??= ((await import2("node-fetch")) as any).default;
         return (global as any).fetch;
     }
     return window.fetch;
 });
 
+/**
+ * @internal
+ */
 const response_headers_to_object = (
     headers: Headers,
-): Record<string, IConnection.HeaderValue | undefined> => {
-    const output: Record<string, IConnection.HeaderValue> = {};
+): Record<string, string | string[]> => {
+    const output: Record<string, string | string[]> = {};
     headers.forEach((value, key) => {
         if (key === "set-cookie") {
             output[key] ??= [];