milkio 0.1.2 → 0.2.0

package/defines/define-http-handler.ts

@@ -1,194 +1,194 @@
 /* eslint-disable no-console */
-import { loggerPushTags, loggerSubmit, useLogger, runtime, MiddlewareEvent } from ".."
-import type { ExecuteId, MilkioApp, Mixin } from ".."
-import { hanldeCatchError } from "../utils/handle-catch-error"
-import { routerHandler } from "../../../src/router"
-import schema from "../../../generated/api-schema"
-import { failCode } from "../../../src/fail-code"
-import { TSON } from "@southern-aurora/tson"
-import { createUlid } from "../utils/create-ulid"
-import { configMilkio } from "../../../src/config/milkio"
-import { headerToPlainObject } from "../utils/header-to-plain-object"
+import { loggerPushTags, loggerSubmit, useLogger, runtime, MiddlewareEvent } from "..";
+import type { ExecuteId, MilkioApp, Mixin } from "..";
+import { hanldeCatchError } from "../utils/handle-catch-error";
+import { routerHandler } from "../../../src/router";
+import schema from "../../../generated/api-schema";
+import { failCode } from "../../../src/fail-code";
+import { TSON } from "@southern-aurora/tson";
+import { createUlid } from "../utils/create-ulid";
+import { configMilkio } from "../../../src/config/milkio";
+import { headerToPlainObject } from "../utils/header-to-plain-object";
 
 export type ExecuteHttpServerOptions = {
-  /**
-   * The execution ID generator
-   * If you have enabled this option, the executeId will be generated each time by calling this method. Otherwise, it will be generated using the built-in method.
-   *
-   * @param request
-   * @returns
-   */
-  executeIdGenerator?: (request: Request) => string | Promise<string>;
+	/**
+	 * The execution ID generator
+	 * If you have enabled this option, the executeId will be generated each time by calling this method. Otherwise, it will be generated using the built-in method.
+	 *
+	 * @param request
+	 * @returns
+	 */
+	executeIdGenerator?: (request: Request) => string | Promise<string>;
 };
 
 export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOptions = {}) {
-  const fetch = async (request: MilkioHTTPRequest) => {
-    const fullurl = new URL(request.request.url, `http://${request.request.headers.get("host") ?? "localhost"}`)
-    const executeId = (options?.executeIdGenerator ? await options.executeIdGenerator(request.request) : createUlid()) as ExecuteId
-    runtime.execute.executeIds.add(executeId)
-    const logger = useLogger(executeId)
-    const ip = (request.request.headers.get("x-forwarded-for") as string | undefined)?.split(",")[0] ?? "0.0.0.0"
-    const headers = request.request.headers
-
-    loggerPushTags(executeId, {
-      from: "http-server",
-      fullUrl: fullurl.pathname,
-      ip,
-      method: request.request.method,
-      // @ts-ignore
-      requestHeaders: headerToPlainObject(request.request.headers),
-      timein: new Date().getTime()
-    })
-
-    const response: MilkioHTTPResponse = {
-      body: "",
-      status: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "Access-Control-Allow-Methods": configMilkio.corsAllowMethods ?? "*",
-        "Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
-        "Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*"
-      }
-    }
-
-    try {
-      // Process OPTIONS pre inspection requests
-      if (request.request.method === "OPTIONS") {
-        await loggerSubmit(executeId)
-        runtime.execute.executeIds.delete(executeId)
-
-        return new Response("", {
-          headers: {
-            "Access-Control-Allow-Methods": configMilkio.corsAllowMethods ?? "*",
-            "Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
-            "Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*"
-          }
-        })
-      }
-
-      let path = fullurl.pathname.substring(1).split("/")
-
-      // Compatible with API gateway's ability to differentiate versions by path
-      // see: /src/config/ConfigProgram.ts in "ignorePathLevel"
-      if (configMilkio.ignorePathLevel !== 0) path = path.slice(configMilkio.ignorePathLevel)
-
-      let pathstr = path.join("/") as keyof (typeof schema)["apiMethodsSchema"]
-
-      // Special processing: do not run middleware when encountering 404 and return quickly
-      if (!(pathstr in schema.apiMethodsSchema) || pathstr.startsWith('$/')) {
-        // @ts-ignore
-        const redirectPath = await routerHandler(pathstr, fullurl)
-        if (!redirectPath) {
-          const rawbody = await request.request.text()
-          loggerPushTags(executeId, {
-            body: rawbody || "no body"
-          })
-          if (!response.body) response.body = `{"executeId":"${executeId}","success":false,"fail":{"code":"NOT_FOUND","message":${JSON.stringify(failCode.NOT_FOUND())}}}`
-
-          loggerPushTags(executeId, {
-            status: response.status,
-            responseHeaders: response.headers,
-            timeout: new Date().getTime()
-          })
-
-          await loggerSubmit(executeId)
-          runtime.execute.executeIds.delete(executeId)
-
-          return new Response(response.body, response)
-        }
-        pathstr = redirectPath as typeof pathstr
-      }
-
-      loggerPushTags(executeId, {
-        path: pathstr
-      })
-
-      const detail = {
-        path: pathstr,
-        ip,
-        executeId,
-        fullurl,
-        request: request.request,
-        response
-      }
-
-      // execute api
-      // after request middleware
-      await MiddlewareEvent.handle("afterHTTPRequest", [headers, detail])
-
-      const rawbody = await request.request.text()
-      loggerPushTags(executeId, {
-        body: rawbody || "no body"
-      })
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      let params: any
-      if (rawbody === "") {
-        params = undefined
-      } else {
-        try {
-          params = JSON.parse(rawbody)
-        } catch (error) {
-          const logger = useLogger(executeId)
-          logger.log("TIP: body is not json, the content is not empty, but the content is not in a valid JSON format. The original content value can be retrieved via request.request.text()")
-          params = undefined
-        }
-      }
-
-      loggerPushTags(executeId, {
-        params
-      })
-
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      // @ts-ignore
-      const result = await app._executeCoreToJson(pathstr, params, headers, {
-        executeId,
-        logger,
-        detail
-      })
-
-      // @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression, @typescript-eslint/no-explicit-any
-      if (!response.body) response.body = result
-
-      // before response middleware
-      const middlewareResponse = {
-        value: response.body
-      }
-      await MiddlewareEvent.handle("beforeHTTPResponse", [middlewareResponse, detail])
-
-      if (!response.body) response.body = middlewareResponse.value
-    } catch (error) {
-      const result = hanldeCatchError(error, executeId)
-      if (!response.body) response.body = TSON.stringify(result)
-    }
-
-    loggerPushTags(executeId, {
-      status: response.status,
-      responseHeaders: response.headers,
-      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      body: response.body?.toString() ?? "",
-      timeout: new Date().getTime()
-    })
-
-    await loggerSubmit(executeId)
-    runtime.execute.executeIds.delete(executeId)
-
-    return new Response(response.body, response)
-  }
-
-  return fetch
+	const fetch = async (request: MilkioHTTPRequest) => {
+		const fullurl = new URL(request.request.url, `http://${request.request.headers.get("host") ?? "localhost"}`);
+		const executeId = (options?.executeIdGenerator ? await options.executeIdGenerator(request.request) : createUlid()) as ExecuteId;
+		runtime.execute.executeIds.add(executeId);
+		const logger = useLogger(executeId);
+		const ip = (request.request.headers.get("x-forwarded-for") as string | undefined)?.split(",")[0] ?? "0.0.0.0";
+		const headers = request.request.headers;
+
+		loggerPushTags(executeId, {
+			from: "http-server",
+			fullUrl: fullurl.pathname,
+			ip,
+			method: request.request.method,
+			// @ts-ignore
+			requestHeaders: headerToPlainObject(request.request.headers),
+			timein: new Date().getTime(),
+		});
+
+		const response: MilkioHTTPResponse = {
+			body: "",
+			status: 200,
+			headers: {
+				"Content-Type": "application/json",
+				"Access-Control-Allow-Methods": configMilkio.corsAllowMethods ?? "*",
+				"Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
+				"Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*",
+			},
+		};
+
+		try {
+			// Process OPTIONS pre inspection requests
+			if (request.request.method === "OPTIONS") {
+				await loggerSubmit(executeId);
+				runtime.execute.executeIds.delete(executeId);
+
+				return new Response("", {
+					headers: {
+						"Access-Control-Allow-Methods": configMilkio.corsAllowMethods ?? "*",
+						"Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
+						"Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*",
+					},
+				});
+			}
+
+			let path = fullurl.pathname.substring(1).split("/");
+
+			// Compatible with API gateway's ability to differentiate versions by path
+			// see: /src/config/ConfigProgram.ts in "ignorePathLevel"
+			if (configMilkio.ignorePathLevel !== 0) path = path.slice(configMilkio.ignorePathLevel);
+
+			let pathstr = path.join("/") as keyof (typeof schema)["apiMethodsSchema"];
+
+			// Special processing: do not run middleware when encountering 404 and return quickly
+			if (!(pathstr in schema.apiMethodsSchema) || pathstr.startsWith("$/")) {
+				// @ts-ignore
+				const redirectPath = await routerHandler(pathstr, fullurl);
+				if (!redirectPath) {
+					const rawbody = await request.request.text();
+					loggerPushTags(executeId, {
+						body: rawbody || "no body",
+					});
+					if (!response.body) response.body = `{"executeId":"${executeId}","success":false,"fail":{"code":"NOT_FOUND","message":${JSON.stringify(failCode.NOT_FOUND())}}}`;
+
+					loggerPushTags(executeId, {
+						status: response.status,
+						responseHeaders: response.headers,
+						timeout: new Date().getTime(),
+					});
+
+					await loggerSubmit(executeId);
+					runtime.execute.executeIds.delete(executeId);
+
+					return new Response(response.body, response);
+				}
+				pathstr = redirectPath as typeof pathstr;
+			}
+
+			loggerPushTags(executeId, {
+				path: pathstr,
+			});
+
+			const detail = {
+				path: pathstr,
+				ip,
+				executeId,
+				fullurl,
+				request: request.request,
+				response,
+			};
+
+			// execute api
+			// after request middleware
+			await MiddlewareEvent.handle("afterHTTPRequest", [headers, detail]);
+
+			const rawbody = await request.request.text();
+			loggerPushTags(executeId, {
+				body: rawbody || "no body",
+			});
+
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			let params: any;
+			if (rawbody === "") {
+				params = undefined;
+			} else {
+				try {
+					params = JSON.parse(rawbody);
+				} catch (error) {
+					const logger = useLogger(executeId);
+					logger.log("TIP: body is not json, the content is not empty, but the content is not in a valid JSON format. The original content value can be retrieved via request.request.text()");
+					params = undefined;
+				}
+			}
+
+			loggerPushTags(executeId, {
+				params,
+			});
+
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+			// @ts-ignore
+			const result = await app._executeCoreToJson(pathstr, params, headers, {
+				executeId,
+				logger,
+				detail,
+			});
+
+			// @ts-ignore
+			// eslint-disable-next-line @typescript-eslint/no-confusing-void-expression, @typescript-eslint/no-explicit-any
+			if (!response.body) response.body = result;
+
+			// before response middleware
+			const middlewareResponse = {
+				value: response.body,
+			};
+			await MiddlewareEvent.handle("beforeHTTPResponse", [middlewareResponse, detail]);
+
+			if (!response.body) response.body = middlewareResponse.value;
+		} catch (error) {
+			const result = hanldeCatchError(error, executeId);
+			if (!response.body) response.body = TSON.stringify(result);
+		}
+
+		loggerPushTags(executeId, {
+			status: response.status,
+			responseHeaders: response.headers,
+			// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+			body: response.body?.toString() ?? "",
+			timeout: new Date().getTime(),
+		});
+
+		await loggerSubmit(executeId);
+		runtime.execute.executeIds.delete(executeId);
+
+		return new Response(response.body, response);
+	};
+
+	return fetch;
 }
 
 export type MilkioHTTPRequest = {
-  request: Request;
+	request: Request;
 };
 
 export type MilkioHTTPResponse = Mixin<
-  ResponseInit,
-  {
-    body: string | BodyInit;
-    status: number;
-    headers: Record<string, string>;
-  }
+	ResponseInit,
+	{
+		body: string | BodyInit;
+		status: number;
+		headers: Record<string, string>;
+	}
 >;

package/defines/define-middleware.ts

@@ -1,9 +1,9 @@
-import { type MiddlewareOptions } from ".."
+import type { MiddlewareOptions } from "..";
 
 export function defineMiddleware(options: MiddlewareOptions): () => MiddlewareOptions {
-  return () => ({
-    ...options,
-    // @ts-ignore
-    isMiddleware: true
-  })
+	return () => ({
+		...options,
+		// @ts-ignore
+		isMiddleware: true,
+	});
 }

package/defines/define-use.ts

@@ -1,13 +1,13 @@
 export const defineUse = <CreatorFn extends () => Promise<unknown> | unknown>(creatorFn: CreatorFn): (() => Promise<Awaited<ReturnType<CreatorFn>>>) => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let use: any | undefined
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let use: any | undefined;
 
-  const getUse = async () => {
-    if (use === undefined) {
-      use = await creatorFn()
-    }
-    return use
-  }
+	const getUse = async () => {
+		if (use === undefined) {
+			use = await creatorFn();
+		}
+		return use;
+	};
 
-  return getUse
-}
+	return getUse;
+};

package/index.ts

@@ -1,36 +1,36 @@
 // types
-export * from "./types"
+export * from "./types";
 
 // utils
-export * from "./utils/tson"
-export * from "./utils/create-ulid"
-export * from "./utils/env-to-string"
-export * from "./utils/env-to-number"
-export * from "./utils/env-to-boolean"
+export * from "./utils/tson";
+export * from "./utils/create-ulid";
+export * from "./utils/env-to-string";
+export * from "./utils/env-to-number";
+export * from "./utils/env-to-boolean";
 // export * from "./utils/create-template"
-export * from "./utils/header-to-plain-object"
+export * from "./utils/header-to-plain-object";
 
 // defines
-export * from "./defines/define-use"
-export * from "./defines/define-api"
-export * from "./defines/define-api-test"
-export * from "./defines/define-middleware"
+export * from "./defines/define-use";
+export * from "./defines/define-api";
+export * from "./defines/define-api-test";
+export * from "./defines/define-middleware";
 
 // kernel
-export * from "./kernel/runtime"
-export * from "./kernel/logger"
-export * from "./kernel/fail"
-export * from "./kernel/meta"
-export * from "./kernel/context"
-export * from "./kernel/validate"
-export * from "./kernel/middleware"
+export * from "./kernel/runtime";
+export * from "./kernel/logger";
+export * from "./kernel/fail";
+export * from "./kernel/meta";
+export * from "./kernel/context";
+export * from "./kernel/validate";
+export * from "./kernel/middleware";
 
 // handler
-export * from "./defines/define-http-handler"
-export * from "./defines/define-command-handler"
+export * from "./defines/define-http-handler";
+export * from "./defines/define-command-handler";
 
 // api test
-export * from "./api-test/index"
+export * from "./api-test/index";
 
 // milkio
-export * from "./kernel/milkio"
+export * from "./kernel/milkio";

package/kernel/context.ts

@@ -1,23 +1,23 @@
-import type { ExecuteId, Logger, MilkioHTTPResponse } from ".."
+import type { ExecuteId, Logger, MilkioHTTPResponse } from "..";
 
 export type MilkioContext = {
-  path: string;
-  executeId: ExecuteId;
-  headers: Headers;
-  logger: Logger;
-  /**
-   * Additional information about the request
-   * These are usually only fully implemented when called by an HTTP server
-   * During testing or when calling between microservices, some or all of the values may be undefined
-   */
-  detail: Partial<FrameworkHTTPDetail>;
+	path: string;
+	executeId: ExecuteId;
+	headers: Headers;
+	logger: Logger;
+	/**
+	 * Additional information about the request
+	 * These are usually only fully implemented when called by an HTTP server
+	 * During testing or when calling between microservices, some or all of the values may be undefined
+	 */
+	detail: Partial<FrameworkHTTPDetail>;
 };
 
 export type FrameworkHTTPDetail = {
-  path: string;
-  executeId: ExecuteId;
-  fullurl: URL;
-  ip: string;
-  request: Request;
-  response: MilkioHTTPResponse;
+	path: string;
+	executeId: ExecuteId;
+	fullurl: URL;
+	ip: string;
+	request: Request;
+	response: MilkioHTTPResponse;
 };

package/kernel/fail.ts

@@ -1,19 +1,19 @@
-import { failCode } from "../../../src/fail-code"
+import { failCode } from "../../../src/fail-code";
 
 export function reject<Code extends keyof typeof failCode, FailData extends (typeof failCode)[Code]>(code: Code, data: Parameters<FailData>[0]) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-  const message = failCode[code]?.(data as any) ?? ""
-  const error = {
-    name: "MilkioReject",
-    code,
-    message,
-    data,
-    stack: ""
-  }
-  Error.captureStackTrace(error)
-  error.stack = error.stack.replace(/\n.*\n/, "\n")
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+	const message = failCode[code]?.(data as any) ?? "";
+	const error = {
+		name: "MilkioReject",
+		code,
+		message,
+		data,
+		stack: "",
+	};
+	Error.captureStackTrace(error);
+	error.stack = error.stack.replace(/\n.*\n/, "\n");
 
-  return error
+	return error;
 }
 
 export type MilkioReject = ReturnType<typeof reject>;