milkio 0.1.2 → 0.2.0

package/kernel/logger.ts

@@ -1,113 +1,113 @@
 /* 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;
-  loggerLevel: LoggerLevel;
-  description: string;
-  params: Array<unknown>;
+	executeId: ExecuteId;
+	loggerLevel: LoggerLevel;
+	description: string;
+	params: Array<unknown>;
 };
 
 export type LoggerTags = Record<string, any>;
 
 export type LoggerOptions = {
-  onInsert: (options: LoggerItem) => boolean;
-  onSubmit: (tags: LoggerTags, logs: Array<LoggerItem>) => Promise<void> | void;
+	onInsert: (options: LoggerItem) => boolean;
+	onSubmit: (tags: LoggerTags, logs: Array<LoggerItem>) => Promise<void> | void;
 };
 
 export type Logger = {
-  debug: (description: string, ...params: Array<unknown>) => void;
-  log: (description: string, ...params: Array<unknown>) => void;
-  warn: (description: string, ...params: Array<unknown>) => void;
-  error: (description: string, ...params: Array<unknown>) => void;
+	debug: (description: string, ...params: Array<unknown>) => void;
+	log: (description: string, ...params: Array<unknown>) => void;
+	warn: (description: string, ...params: Array<unknown>) => void;
+	error: (description: string, ...params: Array<unknown>) => void;
 };
 
 export const loggerController = (() => {
-  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)
-    for (const key in tags) {
-      logItem![key] = tags[key]
-    }
-  }
-
-  const loggerSubmit = async (executeId: ExecuteId) => {
-    if (!logs.has(executeId)) return
-    if (executeId === "global") return
-    const loggerSubmitOptions: Record<string, string> = {
-      executeId
-    }
-    const log = logs.get(executeId)!
-    for (const key in log) {
-      if (key === "__LOG_DEATIL__") continue
-      loggerSubmitOptions[key] = log[key]
-    }
-    logs.delete(executeId)
-    loggerOptions.onSubmit(loggerSubmitOptions, log.__LOG_DEATIL__)
-  }
-
-  const loggerSubmitAll = async () => {
-    for (const executeId of logs.keys()) {
-      await loggerSubmit(executeId)
-    }
-  }
-
-  const insertItem = (executeId: ExecuteId, level: LoggerLevel, description: string, params: Array<unknown>): void => {
-    let executeIds: Array<string> = []
-    if (executeId === "global") {
-      executeIds = Array.from(new Set([...Array.from(runtime.execute.executeIds), ...Array.from(runtime.execute.executeIds)]))
-    } else {
-      executeIds = [executeId]
-    }
-
-    for (const executeId of executeIds) {
-      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)
-    }
-  }
-
-  const useLogger = (executeId: ExecuteId) => {
-    return {
-      debug(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "debug", description, params)
-      },
-      log(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "log", description, params)
-      },
-      warn(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "warn", description, params)
-      },
-      error(description: string, ...params: Array<unknown>) {
-        insertItem(executeId, "error", description, params)
-      }
-    } satisfies Logger
-  }
-
-  return {
-    loggerPushTags,
-    loggerSubmit,
-    loggerSubmitAll,
-    useLogger
-  }
-})()
-
-export const useLogger = loggerController.useLogger
-
-export const loggerPushTags = loggerController.loggerPushTags
-
-export const loggerSubmit = loggerController.loggerSubmit
-
-export const loggerSubmitAll = loggerController.loggerSubmitAll
+	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);
+		for (const key in tags) {
+			logItem![key] = tags[key];
+		}
+	};
+
+	const loggerSubmit = async (executeId: ExecuteId) => {
+		if (!logs.has(executeId)) return;
+		if (executeId === "global") return;
+		const loggerSubmitOptions: Record<string, string> = {
+			executeId,
+		};
+		const log = logs.get(executeId)!;
+		for (const key in log) {
+			if (key === "__LOG_DEATIL__") continue;
+			loggerSubmitOptions[key] = log[key];
+		}
+		logs.delete(executeId);
+		loggerOptions.onSubmit(loggerSubmitOptions, log.__LOG_DEATIL__);
+	};
+
+	const loggerSubmitAll = async () => {
+		for (const executeId of logs.keys()) {
+			await loggerSubmit(executeId);
+		}
+	};
+
+	const insertItem = (executeId: ExecuteId, level: LoggerLevel, description: string, params: Array<unknown>): void => {
+		let executeIds: Array<string> = [];
+		if (executeId === "global") {
+			executeIds = Array.from(new Set([...Array.from(runtime.execute.executeIds), ...Array.from(runtime.execute.executeIds)]));
+		} else {
+			executeIds = [executeId];
+		}
+
+		for (const executeId of executeIds) {
+			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);
+		}
+	};
+
+	const useLogger = (executeId: ExecuteId) => {
+		return {
+			debug(description: string, ...params: Array<unknown>) {
+				insertItem(executeId, "debug", description, params);
+			},
+			log(description: string, ...params: Array<unknown>) {
+				insertItem(executeId, "log", description, params);
+			},
+			warn(description: string, ...params: Array<unknown>) {
+				insertItem(executeId, "warn", description, params);
+			},
+			error(description: string, ...params: Array<unknown>) {
+				insertItem(executeId, "error", description, params);
+			},
+		} satisfies Logger;
+	};
+
+	return {
+		loggerPushTags,
+		loggerSubmit,
+		loggerSubmitAll,
+		useLogger,
+	};
+})();
+
+export const useLogger = loggerController.useLogger;
+
+export const loggerPushTags = loggerController.loggerPushTags;
+
+export const loggerSubmit = loggerController.loggerSubmit;
+
+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 "../../../generated/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
+	// @ts-ignore
+	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;
@@ -10,41 +10,41 @@ export type AfterExecuteMiddleware = (context: Context, response: { value: unkno
 export type AfterHTTPRequestMiddleware = (headers: Headers, detail: FrameworkHTTPDetail) => Promise<void> | void;
 export type BeforeHTTPResponseMiddleware = (response: { value: string }, detail: FrameworkHTTPDetail) => Promise<void> | void;
 export type MiddlewareOptions = {
-  bootstrap?: BootstrapMiddleware;
-  beforeExecute?: BeforeExecuteMiddleware;
-  afterExecute?: AfterExecuteMiddleware;
-  afterHTTPRequest?: AfterHTTPRequestMiddleware;
-  beforeHTTPResponse?: BeforeHTTPResponseMiddleware;
+	bootstrap?: BootstrapMiddleware;
+	beforeExecute?: BeforeExecuteMiddleware;
+	afterExecute?: AfterExecuteMiddleware;
+	afterHTTPRequest?: AfterHTTPRequestMiddleware;
+	beforeHTTPResponse?: BeforeHTTPResponseMiddleware;
 } & Record<string, (...args: Array<any>) => Promise<void> | void>;
 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)
-  }
+	const defineMiddlewareEvent = (name: string, sortFn: (a: MiddlewareT, b: MiddlewareT) => number) => {
+		_middlewareEvents.set(name, sortFn);
+	};
 
-  const sortMiddlewareEvent = () => {
-    for (const [key, middleware] of _middlewares) {
-      const sort = _middlewareEvents.get(key)
-      if (sort) middleware.sort(sort)
-    }
-  }
+	const sortMiddlewareEvent = () => {
+		for (const [key, middleware] of _middlewares) {
+			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
-    for (const md of mds) {
-      await md.middleware(...args)
-    }
-  }
+	const handleMiddleware = async (name: string, args: Array<any> /* Parameters<MiddlewareOptions[Name]> */) => {
+		const mds = _middlewares.get(name);
+		if (!mds) return;
+		for (const md of mds) {
+			await md.middleware(...args);
+		}
+	};
 
-  return {
-    define: defineMiddlewareEvent,
-    handle: handleMiddleware,
-    _sort: sortMiddlewareEvent
-  }
-})()
+	return {
+		define: defineMiddlewareEvent,
+		handle: handleMiddleware,
+		_sort: sortMiddlewareEvent,
+	};
+})();