milkio 0.0.10 → 0.0.11

package/kernel/logger.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { runtime, type ExecuteId } from "..";
-import { loggerOptions } from "../../../src/logger";
+import { runtime, type ExecuteId } from ".."
+import { loggerOptions } from "../../../src/logger"
 
 export type LoggerItem = {
   executeId: ExecuteId;
@@ -25,89 +25,89 @@ export type Logger = {
 };
 
 export const loggerController = (() => {
-  const logs = new Map<ExecuteId, { __LOG_DEATIL__: Array<LoggerItem>; [key: string]: any }>();
+  const logs = new Map<ExecuteId, { __LOG_DEATIL__: Array<LoggerItem>; [key: string]: any }>()
 
   const loggerPushTags = (executeId: ExecuteId, tags: Record<string, any>) => {
-    if (!logs.has(executeId)) logs.set(executeId, { __LOG_DEATIL__: [] });
-    const logItem = logs.get(executeId);
+    if (!logs.has(executeId)) logs.set(executeId, { __LOG_DEATIL__: [] })
+    const logItem = logs.get(executeId)
     for (const key in tags) {
-      logItem![key] = tags[key];
+      logItem![key] = tags[key]
     }
-  };
+  }
 
   const loggerSubmit = async (executeId: ExecuteId) => {
-    if (!logs.has(executeId)) return;
-    if (executeId === "global") return;
+    if (!logs.has(executeId)) return
+    if (executeId === "global") return
     const loggerSubmitOptions: Record<string, string> = {
       executeId
-    };
-    const log = logs.get(executeId)!;
+    }
+    const log = logs.get(executeId)!
     for (const key in log) {
-      if (key === "__LOG_DEATIL__") continue;
-      loggerSubmitOptions[key] = log[key];
+      if (key === "__LOG_DEATIL__") continue
+      loggerSubmitOptions[key] = log[key]
     }
-    logs.delete(executeId);
-    loggerOptions.onSubmit(loggerSubmitOptions, log.__LOG_DEATIL__);
-  };
+    logs.delete(executeId)
+    loggerOptions.onSubmit(loggerSubmitOptions, log.__LOG_DEATIL__)
+  }
 
   const loggerSubmitAll = async () => {
     for (const executeId of logs.keys()) {
-      await loggerSubmit(executeId);
+      await loggerSubmit(executeId)
     }
-  };
+  }
 
   const insertItem = (executeId: ExecuteId, level: LoggerLevel, description: string, params: Array<unknown>): void => {
-    let executeIds: Array<string> = [];
+    let executeIds: Array<string> = []
     if (executeId === "global") {
-      executeIds = Array.from(new Set([...Array.from(runtime.execute.executeIds), ...Array.from(runtime.execute.executeIds)]));
+      executeIds = Array.from(new Set([...Array.from(runtime.execute.executeIds), ...Array.from(runtime.execute.executeIds)]))
     } else {
-      executeIds = [executeId];
+      executeIds = [executeId]
     }
 
     for (const executeId of executeIds) {
-      if (!logs.has(executeId as ExecuteId)) logs.set(executeId as ExecuteId, { __LOG_DEATIL__: [] });
+      if (!logs.has(executeId as ExecuteId)) logs.set(executeId as ExecuteId, { __LOG_DEATIL__: [] })
       const loggerItem = {
         executeId: executeId as ExecuteId,
         loggerLevel: level,
         description,
         params
-      } satisfies LoggerItem;
-      if (!loggerOptions.onInsert(loggerItem)) return;
-      logs.get(executeId as ExecuteId)!.__LOG_DEATIL__.push(loggerItem);
+      } satisfies LoggerItem
+      if (!loggerOptions.onInsert(loggerItem)) return
+      logs.get(executeId as ExecuteId)!.__LOG_DEATIL__.push(loggerItem)
     }
-  };
+  }
 
   const useLogger = (executeId: ExecuteId) => {
     return {
       debug(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "debug", description, params);
+        insertItem(executeId, "debug", description, params)
       },
       log(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "log", description, params);
+        insertItem(executeId, "log", description, params)
       },
       warn(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "warn", description, params);
+        insertItem(executeId, "warn", description, params)
       },
       error(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "error", description, params);
+        insertItem(executeId, "error", description, params)
       }
-    } satisfies Logger;
-  };
+    } satisfies Logger
+  }
 
   return {
     loggerPushTags,
     loggerSubmit,
     loggerSubmitAll,
     useLogger
-  };
-})();
+  }
+})()
 
-export const useLogger = loggerController.useLogger;
+export const useLogger = loggerController.useLogger
 
-export const loggerPushTags = loggerController.loggerPushTags;
+export const loggerPushTags = loggerController.loggerPushTags
 
-export const loggerSubmit = loggerController.loggerSubmit;
+export const loggerSubmit = loggerController.loggerSubmit
 
-export const loggerSubmitAll = loggerController.loggerSubmitAll;
+export const loggerSubmitAll = loggerController.loggerSubmitAll
 
 export type LoggerLevel = "debug" | "log" | "warn" | "error";

package/kernel/meta.ts

@@ -1,9 +1,9 @@
-import type { Meta } from "../../../src/meta";
-import schema from "../../../generate/api-schema";
+import type { Meta } from "../../../src/meta"
+import schema from "../../../generated/api-schema"
 
 export async function useMeta(path: string): Promise<Meta> {
   // @ts-ignore
-  const api = schema.apiMethodsSchema[path as keyof (typeof schema)["apiMethodsTypeSchema"]]();
-  const module = await api.module;
-  return module.api.meta;
+  const api = schema.apiMethodsSchema[path as keyof (typeof schema)["apiMethodsTypeSchema"]]()
+  const module = await api.module
+  return module.api.meta
 }

package/kernel/middleware.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-type-constraint, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument */
 
-import type { Context } from "../../../src/context";
-import type { FrameworkHTTPDetail } from "./context";
-import { type MilkioApp } from "milkio";
+import type { Context } from "../../../src/context"
+import type { FrameworkHTTPDetail } from "./context"
+import { type MilkioApp } from "milkio"
 
 export type BootstrapMiddleware = (milkio: MilkioApp) => Promise<void> | void;
 export type BeforeExecuteMiddleware = (context: Context) => Promise<void> | void;
@@ -19,32 +19,32 @@ export type MiddlewareOptions = {
 export type MiddlewareFn = (...args: Array<any>) => Promise<void> | void;
 export type MiddlewareT<T extends MiddlewareFn = MiddlewareFn> = { id: string; index: number; middleware: T };
 
-export const _middlewareEvents = new Map<string, (a: MiddlewareT, b: MiddlewareT) => number>();
-export const _middlewares = new Map<string, Array<MiddlewareT>>();
+export const _middlewareEvents = new Map<string, (a: MiddlewareT, b: MiddlewareT) => number>()
+export const _middlewares = new Map<string, Array<MiddlewareT>>()
 
 export const MiddlewareEvent = (() => {
   const defineMiddlewareEvent = (name: string, sortFn: (a: MiddlewareT, b: MiddlewareT) => number) => {
-    _middlewareEvents.set(name, sortFn);
-  };
+    _middlewareEvents.set(name, sortFn)
+  }
 
   const sortMiddlewareEvent = () => {
     for (const [key, middleware] of _middlewares) {
-      const sort = _middlewareEvents.get(key);
-      if (sort) middleware.sort(sort);
+      const sort = _middlewareEvents.get(key)
+      if (sort) middleware.sort(sort)
     }
-  };
+  }
 
   const handleMiddleware = async (name: string, args: Array<any> /* Parameters<MiddlewareOptions[Name]> */) => {
-    const mds = _middlewares.get(name);
-    if (!mds) return;
+    const mds = _middlewares.get(name)
+    if (!mds) return
     for (const md of mds) {
-      await md.middleware(...args);
+      await md.middleware(...args)
     }
-  };
+  }
 
   return {
     define: defineMiddlewareEvent,
     handle: handleMiddleware,
     _sort: sortMiddlewareEvent
-  };
-})();
+  }
+})()

package/kernel/milkio.ts

@@ -1,14 +1,13 @@
 /* eslint-disable no-console, @typescript-eslint/no-invalid-void-type, @typescript-eslint/await-thenable, @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any */
-import { type MiddlewareOptions, _middlewares, MiddlewareEvent } from "./middleware";
-import schema from "../../../generate/api-schema";
-import type { Context } from "../../../src/context";
-import { failCode } from "../../../src/fail-code";
-import type { MilkioContext } from "./context";
-import { type Mixin, type ExecuteId, type Fail, type FailEnumerates, loggerPushTags, loggerSubmit, runtime, TSON, type Logger, useLogger, configMilkio } from "..";
-import { hanldeCatchError } from "../utils/handle-catch-error";
-import { _validate } from "./validate";
-import { cwd, exit, argv } from "node:process";
-import { createUlid } from "../utils/create-ulid";
+import { type MiddlewareOptions, _middlewares, MiddlewareEvent } from "./middleware"
+import schema from "../../../generated/api-schema"
+import type { Context } from "../../../src/context"
+import { failCode } from "../../../src/fail-code"
+import type { MilkioContext } from "./context"
+import { type Mixin, type ExecuteId, type Fail, type FailEnumerates, loggerPushTags, loggerSubmit, runtime, TSON, type Logger, useLogger } from ".."
+import { hanldeCatchError } from "../utils/handle-catch-error"
+import { createUlid } from "../utils/create-ulid"
+import { _validate } from "./validate"
 
 export type MilkioAppOptions = {
   /**
@@ -23,13 +22,6 @@ export type MilkioAppOptions = {
    * When Milkio is launched, the closer it is to the front of the array, the more it is on the outer layer of the "onion".
    */
   middlewares?: () => Array<MiddlewareOptions>;
-  /**
-   * maxRequest
-   * @description
-   * When the function runs for a long time, it is possible that the memory will continuously expand (not necessarily due to memory leaks, but also possibly due to having a large number of routes).
-   * Set a maximum number of requests, when the number of requests reaches this value, kill the process and automatically restart it from outside (K8S or whatever).
-   */
-  enableMaxRequestLimit?: number | null | undefined;
   /**
    * maxRunningTime (minutes)
    * @description
@@ -40,19 +32,11 @@ export type MilkioAppOptions = {
 };
 
 export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
-  if (argv.length > 3 && argv[2].startsWith("--run-mode:")) configMilkio.milkioRunMode = process.argv[2].split("--run-mode:")[1];
-
-  if (MilkioAppOptions?.enableMaxRequestLimit && MilkioAppOptions.enableMaxRequestLimit >= 1) {
-    runtime.maxRequest.expected = MilkioAppOptions.enableMaxRequestLimit;
-    runtime.maxRequest.enable = true;
-  }
-
   if (MilkioAppOptions.enableMaxRunningTimeoutLimit && MilkioAppOptions.enableMaxRunningTimeoutLimit >= 1) {
     setTimeout(() => {
-      console.log('❌ Milkio reached the limit of "maxRunningTimeout" in the options and automatically exited.');
-      exit(0);
-    }, MilkioAppOptions.enableMaxRunningTimeoutLimit * 60 * 1000);
-    runtime.maxRunningTimeout.enable = true;
+      throw new Error('Milkio reached the limit of "maxRunningTimeout" in the options and automatically exited.')
+    }, MilkioAppOptions.enableMaxRunningTimeoutLimit * 60 * 1000)
+    runtime.maxRunningTimeout.enable = true
   }
 
   const MilkioApp = {
@@ -60,54 +44,52 @@ export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
     executeToJson: _executeToJson,
     _executeCore,
     _executeCoreToJson
-  };
+  }
 
   if (MilkioAppOptions.bootstraps) {
-    await Promise.all(MilkioAppOptions.bootstraps());
+    await Promise.all(MilkioAppOptions.bootstraps())
   }
 
   if (MilkioAppOptions.middlewares) {
-    MiddlewareEvent.define("bootstrap", (a, b) => a.index - b.index);
-    MiddlewareEvent.define("beforeExecute", (a, b) => a.index - b.index);
-    MiddlewareEvent.define("afterExecute", (a, b) => b.index - a.index);
-    MiddlewareEvent.define("afterHTTPRequest", (a, b) => a.index - b.index);
-    MiddlewareEvent.define("beforeHTTPResponse", (a, b) => b.index - a.index);
+    MiddlewareEvent.define("bootstrap", (a, b) => a.index - b.index)
+    MiddlewareEvent.define("beforeExecute", (a, b) => a.index - b.index)
+    MiddlewareEvent.define("afterExecute", (a, b) => b.index - a.index)
+    MiddlewareEvent.define("afterHTTPRequest", (a, b) => a.index - b.index)
+    MiddlewareEvent.define("beforeHTTPResponse", (a, b) => b.index - a.index)
 
-    const middlewares = MilkioAppOptions.middlewares();
+    const middlewares = MilkioAppOptions.middlewares()
 
     for (let index = 0; index < middlewares.length; index++) {
-      const middlewareOptions = middlewares[index];
+      const middlewareOptions = middlewares[index]
       for (const name in middlewareOptions) {
-        let middleware = _middlewares.get(name);
+        let middleware = _middlewares.get(name)
         if (middleware === undefined) {
-          middleware = [];
-          _middlewares.set(name, middleware);
+          middleware = []
+          _middlewares.set(name, middleware)
         }
-        const id = createUlid();
-        middleware.push({ id, index, middleware: middlewareOptions[name] });
+        const id = createUlid()
+        middleware.push({ id, index, middleware: middlewareOptions[name] })
       }
     }
-    MiddlewareEvent._sort();
+    MiddlewareEvent._sort()
 
-    await MiddlewareEvent.handle("bootstrap", [MilkioApp]);
+    await MiddlewareEvent.handle("bootstrap", [MilkioApp])
   }
 
-  console.log(`🧊 Milkio is running on : ${cwd()}`);
-
-  return MilkioApp;
+  return MilkioApp
 }
 
 async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options?: ExecuteOptions): Promise<ExecuteResult<Result>> {
-  const executeId = (options?.executeId ?? createUlid()) as ExecuteId;
-  const logger = useLogger(executeId);
-  runtime.execute.executeIds.add(executeId);
+  const executeId = (options?.executeId ?? createUlid()) as ExecuteId
+  const logger = useLogger(executeId)
+  runtime.execute.executeIds.add(executeId)
 
   loggerPushTags(executeId, {
     from: "execute",
     executeId,
     params,
     path
-  });
+  })
 
   const result: any = await _executeCore(path, params, headersInit, {
     ...options,
@@ -116,15 +98,15 @@ async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema
     onAfterHeaders: (headers) => {
       loggerPushTags(executeId, {
         headers: headers.toJSON()
-      });
+      })
     }
-  });
+  })
 
-  loggerPushTags(executeId, { result });
-  await loggerSubmit(executeId);
-  runtime.execute.executeIds.delete(executeId);
+  loggerPushTags(executeId, { result })
+  await loggerSubmit(executeId)
+  runtime.execute.executeIds.delete(executeId)
 
-  return result;
+  return result
 }
 
 /**
@@ -133,17 +115,9 @@ async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema
  * Both execute and httpServer essentially call executeCore.
  */
 async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options: ExecuteCoreOptions): Promise<ExecuteResult<Result>> {
-  const executeId = options.executeId as ExecuteId;
-
-  params = TSON.decode(params);
+  const executeId = options.executeId as ExecuteId
 
-  if (runtime.maxRequest.enable) {
-    if (runtime.maxRequest.counter >= runtime.maxRequest.expected) {
-      console.log("❌ Milkio reached the limit of 'maxRequest' in the options and automatically exited.");
-      exit(0);
-    }
-    runtime.maxRequest.counter++;
-  }
+  params = TSON.decode(params)
 
   if (!(path in schema.apiMethodsSchema)) {
     const result = {
@@ -154,22 +128,23 @@ async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSc
         message: failCode.NOT_FOUND(),
         data: undefined
       }
-    } satisfies ExecuteResult<Result>;
+    } satisfies ExecuteResult<Result>
 
-    return result;
+    return result
   }
 
-  let headers: Headers;
+  let headers: Headers
   if (!(headersInit instanceof Headers)) {
+    // @ts-ignore
     headers = new Headers({
       ...headersInit
-    });
+    })
   } else {
-    headers = headersInit;
+    headers = headersInit
   }
 
   if (options?.onAfterHeaders) {
-    await options.onAfterHeaders(headers);
+    await options.onAfterHeaders(headers)
   }
 
   const context: Context = {
@@ -178,61 +153,61 @@ async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSc
     headers,
     logger: options.logger,
     detail: options?.detail ?? {}
-  };
+  }
 
-  let result: { value: Result };
+  let result: { value: Result }
   try {
     // before execute middleware
-    await MiddlewareEvent.handle("beforeExecute", [context]);
+    await MiddlewareEvent.handle("beforeExecute", [context])
 
     // check type
     // @ts-ignore
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    _validate(await (await schema.apiValidator.validate[path]()).params(params));
+    _validate(await (await schema.apiValidator.validate[path]()).params(params))
 
     // execute api
-    let api: any;
-    if (apis.has(path)) api = apis.get(path);
+    let api: any
+    if (apis.has(path)) api = apis.get(path)
     else {
       // @ts-ignore
-      api = schema.apiMethodsSchema[path]();
-      apis.set(path, api);
+      api = schema.apiMethodsSchema[path]()
+      apis.set(path, api)
     }
-    const apiModuleAwaited = await api.module;
+    const apiModuleAwaited = await api.module
 
-    const apiMethod = apiModuleAwaited.api.action;
+    const apiMethod = apiModuleAwaited.api.action
 
     // @ts-ignore
-    result = { value: await apiMethod(params, context) };
+    result = { value: await apiMethod(params, context) }
 
     // after execute middleware
-    await MiddlewareEvent.handle("afterExecute", [context, result]);
+    await MiddlewareEvent.handle("afterExecute", [context, result])
   } catch (error: any) {
-    const errorResult = hanldeCatchError(error, executeId);
+    const errorResult = hanldeCatchError(error, executeId)
 
-    return errorResult;
+    return errorResult
   }
 
   return {
     executeId,
     success: true,
     data: result.value
-  };
+  }
 }
 
 async function _executeToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options?: ExecuteOptions): Promise<string> {
-  const resultsRaw = await _execute(path, params, headersInit, options);
-  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw));
-  return results;
+  const resultsRaw = await _execute(path, params, headersInit, options)
+  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw))
+  return results
 }
 
 async function _executeCoreToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options: ExecuteCoreOptions): Promise<string> {
-  const resultsRaw = await _executeCore(path, params, headersInit, options);
-  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw));
-  return results;
+  const resultsRaw = await _executeCore(path, params, headersInit, options)
+  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw))
+  return results
 }
 
-const apis = new Map<string, any>();
+const apis = new Map<string, any>()
 
 export type ExecuteResult<Result> = ExecuteResultSuccess<Result> | ExecuteResultFail;
 

package/kernel/runtime.ts

@@ -1,16 +1,11 @@
-import { type ExecuteId } from "..";
+import { type ExecuteId } from ".."
 
 export const runtime = {
   execute: {
     executeIds: new Set<ExecuteId>()
   },
-  maxRequest: {
-    enable: false,
-    counter: 0,
-    expected: 0
-  },
   maxRunningTimeout: {
     enable: false,
     expectedEndedAt: 0
   }
-};
+}

package/kernel/validate.ts

@@ -1,13 +1,13 @@
-import type { IValidation } from "typia";
-import { reject } from "../kernel/fail";
+import type { IValidation } from "typia"
+import { reject } from "../kernel/fail"
 
 export function _validate(validator: IValidation.IFailure | IValidation.ISuccess): void {
-  if (validator.success) return;
-  const error = validator.errors[0];
+  if (validator.success) return
+  const error = validator.errors[0]
 
   throw reject("TYPE_SAFE_ERROR", {
     path: error.path,
     expected: error.expected,
     value: error.value
-  });
+  })
 }

package/package.json

@@ -2,10 +2,13 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
+  "bin": {
+    "milkio": "./c.ts"
+  },
   "dependencies": {
     "@poech/camel-hump-under": "^1.1.0",
     "@southern-aurora/tson": "2.0.2",