milkio 1.0.0-alpha.2 → 1.0.0-alpha.20

package/config/index.ts

@@ -0,0 +1,48 @@
+import { type $types, type GeneratedInit } from "../types";
+
+export const config = <ConfigDefaultT extends ConfigDefault, ConfigEnvironmentsT extends ConfigEnvironments<ConfigDefaultT>>(def: ConfigDefaultT, envs: ConfigEnvironmentsT = {} as Record<any, any>): [ConfigDefaultT, ConfigEnvironmentsT] => {
+  return [def, envs];
+};
+
+export const getConfig = async <Namespace extends keyof $types["generated"]["configSchema"]>(generated: GeneratedInit, env: Record<any, any>, envMode: string, namespace: Namespace) => {
+  if (generated.configSchema[namespace][1] && envMode in generated.configSchema[namespace][1]) {
+    return {
+      ...(await generated.configSchema[namespace][0](env)),
+      ...(await generated.configSchema[namespace][1][envMode](env)),
+    };
+  } else {
+    return {
+      ...(await generated.configSchema[namespace][0](env)),
+    };
+  }
+};
+
+export type ConfigDefault = (env: Record<string, string>) => Promise<Record<string, unknown>> | Record<string, unknown>;
+
+export type ConfigEnvironments<T extends ConfigDefault> = {
+  [key: string]: (env: Record<string, string>) => Partial<Awaited<ReturnType<T>>> | Promise<Partial<Awaited<ReturnType<T>>>>;
+};
+
+export function envToString(value: string | number | undefined, defaultValue: string) {
+  if (value === undefined) return defaultValue;
+
+  return `${value}`;
+}
+
+export function envToNumber(value: string | undefined, defaultValue: number) {
+  if (value === undefined) return defaultValue;
+
+  return Number.parseInt(value, 10);
+}
+
+export function envToBoolean(value: string | number | undefined, defaultValue: boolean) {
+  if (value === "true") return true;
+
+  if (value === "false") return false;
+
+  if (value === "") return false;
+
+  if (undefined === value) return defaultValue;
+
+  return Boolean(value);
+}

package/context/index.ts

@@ -1,13 +1,17 @@
-import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger } from "..";
+import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, type Steps, type Mixin, type ExecuteOptions, type Action } from "..";
 
 export interface $context {
   executeId: string;
+  environment: string;
   path: string;
   logger: Logger;
   http?: ContextHttp<Record<any, any>>;
+  step: Steps<{}>["step"];
+  getConfig: <Namespace extends keyof $types["generated"]["configSchema"]>(namespace: Namespace) => Promise<Readonly<Awaited<ReturnType<$types["generated"]["configSchema"][Namespace][0]>>>>;
+  call: <Module extends Promise<{ default: Action<any> }>>(module: Module, params: Parameters<Awaited<Module>["default"]["handler"]>[1]) => Promise<ReturnType<Awaited<Module>["default"]["handler"]>>;
 }
 
-export type ContextHttp<ParamsParsed> = {
+export type ContextHttp<ParamsParsed = any> = {
   url: URL;
   ip: string;
   path: { string: keyof $types["generated"]["routeSchema"]["$types"]; array: Array<string> };
@@ -18,3 +22,5 @@ export type ContextHttp<ParamsParsed> = {
   request: MilkioHttpRequest;
   response: MilkioHttpResponse;
 };
+
+export type ContextCreatedHandler = (context: $context) => Promise<void> | void;

package/events/index.ts

@@ -0,0 +1,47 @@
+import { type $context, type ContextHttp, type Results, type Logger } from "..";
+
+export interface $events {
+  "milkio:httpRequest": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };
+  "milkio:httpResponse": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>>; context: $context };
+  "milkio:httpNotFound": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };
+  "milkio:executeBefore": { executeId: string; path: string; logger: Logger; context: $context };
+  "milkio:executeAfter": { executeId: string; path: string; logger: Logger; context: $context; results: Results<any> };
+}
+
+export const __initEventManager = () => {
+  const handlers = new Map<(event: any) => void, string>();
+  const indexed = new Map<string, Set<(event: any) => void>>();
+
+  const eventManager = {
+    on: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => {
+      handlers.set(handler, key as string);
+      if (indexed.has(key as string) === false) {
+        indexed.set(key as string, new Set());
+      }
+      const set = indexed.get(key as string)!;
+      set.add(handler);
+      handlers.set(handler, key as string);
+
+      return () => {
+        handlers.delete(handler);
+        set.delete(handler);
+      };
+    },
+    off: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => {
+      const set = indexed.get(key as string);
+      if (!set) return;
+      handlers.delete(handler);
+      set.delete(handler);
+    },
+    emit: async <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<void> => {
+      const h = indexed.get(key as string);
+      if (h) {
+        for (const handler of h) {
+          await handler(value);
+        }
+      }
+    },
+  };
+
+  return eventManager;
+};

package/exception/index.ts

@@ -8,7 +8,6 @@ export interface $rejectCode {
   REQUEST_TIMEOUT: { timeout: number; message: string };
   NOT_FOUND: { path: string };
   PARAMS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;
-  RESULTS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;
   UNACCEPTABLE: { expected: string; message: string };
   PARAMS_TYPE_NOT_SUPPORTED: { expected: string };
   INTERNAL_SERVER_ERROR: undefined;

package/execute/index.ts

@@ -1,14 +1,12 @@
 import { type IValidation } from "typia";
 import { TSON } from "@southern-aurora/tson";
-import { createId } from "../utils/create-id";
-import { reject, type $context, type $meta, type ExecuteOptions, type Logger, type MilkioRuntimeInit, type Results, type GeneratedInit, type MilkioInit, createLogger, exceptionHandler, Ping } from "..";
-
-export type MilkioHttpRequest = {
-  request: Request;
-};
+import { reject, type $context, type $meta, type Logger, type MilkioRuntimeInit, type Results, type GeneratedInit, type MilkioInit, createStep, getConfig } from "..";
+import { headersToJSON } from "../utils/headers-to-json";
 
 export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
-  const __call = async (
+  const __execute = async (
+    env: Record<any, any> | undefined,
+    envMode: string | undefined,
     routeSchema: any,
     options: {
       createdExecuteId: string;
@@ -27,7 +25,9 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         }
     ),
   ): Promise<{ executeId: string; headers: Headers; params: Record<any, unknown>; results: Results<any>; context: $context; meta: Readonly<$meta>; type: "action" | "stream" }> => {
-    const executeId = options.createdExecuteId;
+    const executeId: string = options.createdExecuteId;
+    env = env ?? {};
+    envMode = envMode ?? "production";
     let headers: Headers;
     if (!(options.headers instanceof Headers)) {
       // @ts-ignore
@@ -37,6 +37,8 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
     } else {
       headers = options.headers;
     }
+    if (!("toJSON" in headers)) (headers as any).toJSON = () => headersToJSON(headers);
+
     let params: Record<any, unknown>;
     if (options.paramsType === "raw") {
       params = options.params;
@@ -54,107 +56,56 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
     }
     if (typeof params !== "object" || Array.isArray(params)) throw reject("PARAMS_TYPE_NOT_SUPPORTED", { expected: "json" });
     if ("$milkioGenerateParams" in params && params.$milkioGenerateParams === "enable") {
-      if (runtime.port.develop === "disabled") throw reject("NOT_DEVELOP_MODE", "This feature must be in developer mode to use. Usually entering developer mode requires using a cookbook to start milkio and accessing it through localhost.");
+      if (!runtime.develop) throw reject("NOT_DEVELOP_MODE", "This feature must be in cookbook to use.");
       delete params.$milkioGenerateParams;
       let paramsRand = routeSchema.randomParams();
       if (paramsRand === undefined || paramsRand === null) paramsRand = {};
       params = { ...paramsRand, ...params };
-      options.createdLogger.debug("[milkio]", "🪄 generate params:", options.path, TSON.stringify(params));
     }
     if (options.mixinContext?.http?.params?.string) options.mixinContext.http.params.parsed = params; // listen でパースしたパラメータを渡す
     const context = {
       ...(options.mixinContext ? options.mixinContext : {}),
+      envMode,
       path: options.path,
       logger: options.createdLogger,
       executeId: options.createdExecuteId,
+      getConfig: (namespace: string) => getConfig(generated, env, envMode, namespace),
+      call: (module: any, options: any) => __call(context, module, options),
+      step: createStep(),
     } as unknown as $context;
-
     const results: Results<unknown> = { value: undefined };
 
+    if (runtime.develop) {
+      options.createdLogger.request(`headers - ${TSON.stringify(headers.toJSON())}`, `\nparams - ${TSON.stringify(params)}`);
+    }
+
     const module = await routeSchema.module();
     let meta = (module.meta ? module.meta : {}) as unknown as Readonly<$meta>;
 
-    if (!meta.typeSafety || meta.typeSafety.includes("params")) {
+    if (!meta.typeSafety || meta.typeSafety === true) {
       const validation = routeSchema.validateParams(params) as IValidation<any>;
       if (!validation.success) throw reject("PARAMS_TYPE_INCORRECT", { ...validation.errors[0], message: `The value '${validation.errors[0].path}' is '${validation.errors[0].value}', which does not meet '${validation.errors[0].expected}' requirements.` });
     }
 
+    await runtime.emit("milkio:executeBefore", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, context });
+
     results.value = await module.default.handler(context, params);
+    if (results.value === undefined || results.value === null || results.value === "") results.value = {};
+    else if (Array.isArray(results.value)) throw reject("FAIL", "The return type of the handler must be an object, which is currently an array.");
+    else if (typeof results.value !== "object") throw reject("FAIL", "The return type of the handler must be an object, which is currently a primitive type.");
 
-    if (!meta.typeSafety || meta.typeSafety.includes("results")) {
-      const validation = routeSchema.validateResults(results.value) as IValidation<any>;
-      if (!validation.success) throw reject("RESULTS_TYPE_INCORRECT", { ...validation.errors[0], message: `The value '${validation.errors[0].path}' is '${validation.errors[0].value}', which does not meet '${validation.errors[0].expected}' requirements.` });
-    }
+    await runtime.emit("milkio:executeAfter", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, context, results });
 
     return { executeId, headers, params, results, context, meta, type: module.$milkioType };
   };
 
-  const execute = async (path: string, options?: ExecuteOptions): Promise<any> => {
-    if (!options) options = {};
-    const executeId = createId();
-    const logger = createLogger(runtime, executeId);
-    runtime.runtime.request.set(executeId, { logger: logger });
-
-    try {
-      const routeSchema = generated.routeSchema.routes.get(path);
-      if (routeSchema === undefined) throw reject("NOT_FOUND", { path: path });
-
-      const executed = await __call(routeSchema, {
-        createdExecuteId: executeId,
-        createdLogger: logger,
-        path: path,
-        headers: options.headers ?? {},
-        mixinContext: {},
-        params: options.params ?? {},
-        paramsType: "raw",
-      });
-
-      if (routeSchema.type === "stream") {
-        // stream
-        return [
-          undefined,
-          (async function* () {
-            try {
-              for await (const result of executed.results.value) {
-                yield [null, result];
-              }
-              return undefined;
-            } catch (error) {
-              const reject = exceptionHandler(executeId, logger, error);
-              const result: any = {};
-              result[reject.code] = reject.reject;
-
-              yield [result, null];
-              return undefined;
-            }
-          })(),
-          { executeId: executeId },
-        ];
-      } else {
-        // action
-        return [null, executed.results.value, { executeId: executeId }];
-      }
-    } catch (error) {
-      const reject = exceptionHandler(executeId, logger, error);
-      const result: any = {};
-      result[reject.code] = reject.reject;
-
-      return [result, null, { executeId: executeId }];
-    }
+  const __call = async (context: $context, module: { default: any }, params?: any): Promise<any> => {
+    const moduleAwaited = await module;
+    return await moduleAwaited.default.handler(context, params);
   };
 
-  const ping = async (): Promise<Ping> => [
-    null,
-    {
-      connect: true,
-      delay: 0,
-      serverTimestamp: Date.now(),
-    },
-  ];
-
   return {
     __call,
-    execute,
-    ping,
+    __execute,
   };
 };

package/index.ts

@@ -1,11 +1,15 @@
+export * from "@southern-aurora/tson";
 export * from "./types";
+export * from "./config";
+export * from "./execute";
+export * from "./events";
 export * from "./world";
 export * from "./command";
 export * from "./action";
 export * from "./stream";
-export * from "./test";
 export * from "./logger";
 export * from "./context";
 export * from "./meta";
+export * from "./step";
 export * from "./listener";
 export * from "./exception";

package/listener/index.ts

@@ -15,41 +15,50 @@ export type MilkioHttpResponse = Mixin<
 >;
 
 export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime, executer: ReturnType<typeof __initExecuter>) => {
-  const port = runtime.port.app;
-  const fetch = async (request: MilkioHttpRequest): Promise<Response> => {
-    if (request.method === "OPTIONS") {
+  const port = runtime.port;
+  const fetch = async (options: {
+    request: MilkioHttpRequest;
+    envMode?: string;
+    env?: Record<any, any>;
+  }): Promise<Response> => {
+    if (options.request.method === "OPTIONS") {
       return new Response(undefined, {
         headers: {
-          "Access-Control-Allow-Methods": runtime.corsAllowMethods ?? "*",
-          "Access-Control-Allow-Origin": runtime.corsAllowOrigin ?? "*",
-          "Access-Control-Allow-Headers": runtime.corsAllowHeaders ?? "*",
+          "Access-Control-Allow-Methods": runtime.cors?.corsAllowMethods ?? "*",
+          "Access-Control-Allow-Origin": runtime.cors?.corsAllowOrigin ?? "*",
+          "Access-Control-Allow-Headers": runtime.cors?.corsAllowHeaders ?? "*",
         },
       });
     }
 
-    if (request.url.endsWith("/generate_204")) {
+    if (options.request.url.endsWith("/generate_204")) {
       return new Response("", {
         status: 204,
         headers: {
-          "Access-Control-Allow-Methods": runtime.corsAllowMethods ?? "*",
-          "Access-Control-Allow-Origin": runtime.corsAllowOrigin ?? "*",
-          "Access-Control-Allow-Headers": runtime.corsAllowHeaders ?? "*",
+          "Access-Control-Allow-Methods": runtime.cors?.corsAllowMethods ?? "*",
+          "Access-Control-Allow-Origin": runtime.cors?.corsAllowOrigin ?? "*",
+          "Access-Control-Allow-Headers": runtime.cors?.corsAllowHeaders ?? "*",
           "Cache-Control": "no-store",
           "Content-Type": "text/plain; time=" + Date.now(),
         },
       });
     }
 
-    const executeId = runtime?.executeIdGenerator ? await runtime.executeIdGenerator(request) : createId();
-    const logger = createLogger(runtime, executeId);
+    const url = new URL(options.request.url);
+    let pathArray = url.pathname.substring(1).split("/");
+    if (runtime.ignorePathLevel !== undefined && runtime.ignorePathLevel !== 0) pathArray = pathArray.slice(runtime.ignorePathLevel);
+    const pathString = `/${pathArray.join("/")}`;
+
+    const executeId = runtime?.executeId ? await runtime.executeId(options.request) : createId();
+    const logger = createLogger(runtime, pathString, executeId);
     runtime.runtime.request.set(executeId, { logger: logger });
     const response: MilkioHttpResponse = {
       body: "",
       status: 200,
       headers: {
-        "Access-Control-Allow-Methods": runtime.corsAllowMethods ?? "*",
-        "Access-Control-Allow-Origin": runtime.corsAllowOrigin ?? "*",
-        "Access-Control-Allow-Headers": runtime.corsAllowHeaders ?? "*",
+        "Access-Control-Allow-Methods": runtime.cors?.corsAllowMethods ?? "*",
+        "Access-Control-Allow-Origin": runtime.cors?.corsAllowOrigin ?? "*",
+        "Access-Control-Allow-Headers": runtime.cors?.corsAllowHeaders ?? "*",
         "Cache-Control": "no-store",
         "Content-Type": "application/json",
       },
@@ -57,13 +66,9 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
 
     try {
       const http = (await (async () => {
-        const url = new URL(request.url);
-        let pathArray = url.pathname.substring(1).split("/");
-        if (runtime.ignorePathLevel !== undefined && runtime.ignorePathLevel !== 0) pathArray = pathArray.slice(runtime.ignorePathLevel);
-        const pathString = `/${pathArray.join("/")}`;
-        const ip = runtime.getRealIp ? runtime.getRealIp(request) : "::1";
+        const ip = runtime.realIp ? runtime.realIp(options.request) : "::1";
         const params = {
-          string: await request.text(),
+          string: await options.request.text(),
           parsed: undefined,
         };
 
@@ -72,22 +77,32 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
           ip,
           path: { string: pathString as keyof $types["generated"]["routeSchema"]["$types"], array: pathArray },
           params,
-          request,
+          request: options.request,
           response,
-        } as ContextHttp<undefined>;
+        } as ContextHttp;
       })())!;
 
-      if (!request.headers.get("Accept")?.startsWith("text/event-stream")) {
+      await runtime.emit("milkio:httpRequest", { executeId, logger, path: http.path.string as string, http });
+
+      if (!runtime.develop && ((http.path.string as string).includes("__") || (http.path.string as string).startsWith("/$call/"))) {
+        await runtime.emit("milkio:httpNotFound", { executeId, logger, path: http.path.string as string, http });
+        throw reject("NOT_FOUND", { path: http.path.string as string });
+      }
+
+      if (!options.request.headers.get("Accept")?.startsWith("text/event-stream")) {
         // action
         const routeSchema = generated.routeSchema.routes.get(http.path.string);
-        if (routeSchema === undefined) throw reject("NOT_FOUND", { path: http.path.string as string });
+        if (routeSchema === undefined) {
+          await runtime.emit("milkio:httpNotFound", { executeId, logger, path: http.path.string as string, http });
+          throw reject("NOT_FOUND", { path: http.path.string as string });
+        }
         if (routeSchema.type !== "action") throw reject("UNACCEPTABLE", { expected: "stream", message: `Not acceptable, the Accept in the request header should be "text/event-stream". If you are using the "@milkio/stargate" package, please add \`type: "stream"\` to the execute options.` });
 
-        const executed = await executer.__call(routeSchema, {
+        const executed = await executer.__execute(options.env, options.envMode, routeSchema, {
           createdExecuteId: executeId,
           createdLogger: logger,
           path: http.path.string as string,
-          headers: request.headers as Headers,
+          headers: options.request.headers as Headers,
           mixinContext: { http },
           params: http.params.string,
           paramsType: "string",
@@ -95,6 +110,8 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
 
         if (executed.results.value !== undefined) response.body = TSON.stringify({ success: true, data: executed.results.value, executeId } satisfies MilkioResponseSuccess<any>);
 
+        await runtime.emit("milkio:httpResponse", { executeId, logger, path: http.path.string as string, http, context: executed.context });
+
         runtime.runtime.request.delete(executeId);
         return new Response(response.body, response);
       } else {
@@ -103,11 +120,11 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         if (routeSchema === undefined) throw reject("NOT_FOUND", { path: http.path.string as string });
         if (routeSchema.type !== "stream") throw reject("UNACCEPTABLE", { expected: "stream", message: `Not acceptable, the Accept in the request header should be "application/json". If you are using the "@milkio/stargate" package, please remove \`type: "stream"\` to the execute options.` });
 
-        const executed = await executer.__call(routeSchema, {
+        const executed = await executer.__execute(options.env, options.envMode, routeSchema, {
           createdExecuteId: executeId,
           createdLogger: logger,
           path: http.path.string as string,
-          headers: request.headers as Headers,
+          headers: options.request.headers as Headers,
           mixinContext: { http },
           params: http.params.string,
           paramsType: "string",
@@ -124,7 +141,7 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
               try {
                 controller.write(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\n\n`);
                 for await (const value of executed.results.value) {
-                  if (!request.signal.aborted) {
+                  if (!options.request.signal.aborted) {
                     const result: string = JSON.stringify([null, TSON.encode(value)]);
                     controller.write(`data:${result}\n\n`);
                   } else {
@@ -153,7 +170,7 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
               try {
                 controller.enqueue(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\n\n`);
                 for await (const value of executed.results.value) {
-                  if (!request.signal.aborted) {
+                  if (!options.request.signal.aborted) {
                     const result: string = JSON.stringify([null, TSON.encode(value)]);
                     controller.enqueue(`data:${result}\n\n`);
                   } else {
@@ -180,6 +197,8 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         response.headers["Content-Type"] = "text/event-stream";
         response.headers["Cache-Control"] = "no-cache";
 
+        await runtime.emit("milkio:httpResponse", { executeId, logger, path: http.path.string as string, http, context: executed.context });
+
         runtime.runtime.request.delete(executeId);
         return new Response(response.body, response);
       }

package/logger/index.ts

@@ -1,13 +1,14 @@
-import { TSON } from "@southern-aurora/tson";
 import { format } from "date-fns";
-import { type MilkioInit, type MilkioRuntimeInit } from "..";
+import { type $context, type MilkioInit, type MilkioRuntimeInit } from "..";
+import { sendCookbookEvent } from "../utils/send-cookbook-event";
 
-export type Log = [string /* executeId */, "[DEBUG]" | "[INFO]" | "[WARN]" | "[ERROR]", string, string, ...Array<unknown>];
+export type Log = ["[DEBUG]" | "[INFO]" | "[WARN]" | "[ERROR]" | "[REQUEST]" | "[RESPONSE]", string /* executeId */, string, string, string, ...Array<unknown>];
 
 export type Logger = {
   _: {
     logs: Array<Log>;
     tags: Map<string, unknown>;
+    submit: (context: $context) => Promise<void> | void;
   };
   setTag: (key: string, value: unknown) => void;
   setLog: (...log: Log) => void;
@@ -15,53 +16,63 @@ export type Logger = {
   info: (description: string, ...params: Array<unknown>) => Log;
   warn: (description: string, ...params: Array<unknown>) => Log;
   error: (description: string, ...params: Array<unknown>) => Log;
+  request: (description: string, ...params: Array<unknown>) => Log;
+  response: (description: string, ...params: Array<unknown>) => Log;
 };
 
-export const createLogger = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(runtime: MilkioRuntime, executeId: string): Logger => {
+export type LoggerInsertingHandler = (log: Log) => boolean;
+
+export type LoggerSubmittingHandler = (context: $context, logs: Array<Log>, tags: Map<string, unknown>) => Promise<void> | void;
+
+export const createLogger = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(runtime: MilkioRuntime, path: string, executeId: string): Logger => {
   const logger = {} as Logger;
 
   logger._ = {
     logs: new Array(),
     tags: new Map(),
+    submit: (context: $context) => {
+      if (!runtime.onLoggerSubmitting) return;
+      return runtime.onLoggerSubmitting(context, logger._.logs, logger._.tags);
+    },
   };
 
   const __tagPush = (key: string, value: unknown): void => {
     logger._.tags.set(key, value);
   };
   const __logPush = (log: Log): Log => {
+    const inserting = runtime.onLoggerInserting
+      ? runtime.onLoggerInserting
+      : (log: Log) => {
+          log = [...log];
+          log[0] = `\n${log[0]}` as any;
+          console.log(...log);
+          return true;
+        };
+
+    if (!inserting(log)) return log;
+
     logger._.logs.push([...log]);
-    if (runtime.port.develop !== "disabled") {
-      void (async () => {
-        try {
-          const response = await fetch(`http://localhost:${runtime.port.develop}/$action`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-            },
-            body: TSON.stringify({
-              type: "milkio@logger",
-              log: log,
-            }),
-          });
-          if (!response.ok) console.log("[COOKBOOK]", await response.text());
-        } catch (error) {
-          console.log("[COOKBOOK]", error);
-        }
-      })();
+    if (runtime.cookbook) {
+      void sendCookbookEvent(runtime, {
+        type: "milkio@logger",
+        log: log,
+      });
     }
-    console.log(...log);
+
     return log;
   };
 
   logger.setTag = (key: string, value: unknown) => __tagPush(key, value);
   logger.setLog = (...log: Log) => __logPush(log);
 
-  const getNow = () => format(new Date(), "(yyyy-MM-dd hh:mm:ss)");
+  const getNow = () => `${format(new Date(), "(yyyy-MM-dd hh:mm:ss)")}`;
 
-  logger.debug = (description: string, ...params: Array<unknown>) => __logPush([executeId, "[DEBUG]", description, getNow(), ...params]);
-  logger.info = (description: string, ...params: Array<unknown>) => __logPush([executeId, "[INFO]", description, getNow(), ...params]);
-  logger.warn = (description: string, ...params: Array<unknown>) => __logPush([executeId, "[WARN]", description, getNow(), ...params]);
-  logger.error = (description: string, ...params: Array<unknown>) => __logPush([executeId, "[ERROR]", description, getNow(), ...params]);
+  logger.debug = (description: string, ...params: Array<unknown>) => __logPush(["[DEBUG]", path, executeId, getNow(), `\n${description}`, ...params]);
+  logger.info = (description: string, ...params: Array<unknown>) => __logPush(["[INFO]", path, executeId, getNow(), `\n${description}`, ...params]);
+  logger.warn = (description: string, ...params: Array<unknown>) => __logPush(["[WARN]", path, executeId, getNow(), `\n${description}`, ...params]);
+  logger.error = (description: string, ...params: Array<unknown>) => __logPush(["[ERROR]", path, executeId, getNow(), `\n${description}`, ...params]);
+  logger.request = (description: string, ...params: Array<unknown>) => __logPush(["[REQUEST]", path, executeId, getNow(), `\n${description}`, ...params]);
+  logger.response = (description: string, ...params: Array<unknown>) => __logPush(["[RESPONSE]", path, executeId, getNow(), `\n${description}`, ...params]);
 
   return logger;
 };

package/meta/index.ts

@@ -3,7 +3,7 @@ export interface $meta {
    * type safety
    * @default ["params","results"]
    */
-  typeSafety?: Array<"params" | "results">;
+  typeSafety?: boolean;
   /**
    * methods
    * @default ["POST"]

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.20",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
@@ -10,7 +10,7 @@
   "dependencies": {
     "@paralleldrive/cuid2": "^2.2.2",
     "@poech/camel-hump-under": "^1.1.0",
-    "@southern-aurora/tson": "^2.0.2",
+    "@southern-aurora/tson": "*",
     "chalk": "^5.3.0",
     "date-fns": "^4.1.0",
     "typia": "6.9.0"

package/step/index.ts

@@ -0,0 +1,36 @@
+export type Steps<StageT extends Record<any, any>> = {
+  step: StepFunction<StageT>;
+  run: () => Promise<Remove_<StageT>>;
+};
+
+type Remove_<T> = {
+  [K in keyof T as K extends `_${string}` ? never : K]: T[K];
+};
+
+type ToEmptyObject<T> = T extends undefined | null | never ? {} : T extends object ? T : {};
+
+export type StepFunction<StageT extends Record<any, any>> = <HandlerT extends (stage: Readonly<StageT>) => Record<any, any> | Promise<Record<any, any>>>(handler: HandlerT) => Steps<Awaited<StageT> & ToEmptyObject<Awaited<ReturnType<HandlerT>>>>;
+
+export const createStep = (): Steps<{}>["step"] => {
+  const stepController = {
+    $milkioType: "step",
+    _steps: [] as Array<(stage: any) => Promise<any>>,
+    step(handler: (stage: any) => Promise<any>) {
+      stepController._steps.push(handler);
+      return stepController;
+    },
+    async run() {
+      let stage = {};
+      for (const step of stepController._steps) {
+        stage = { ...stage, ...(await step(stage)) };
+      }
+      let result: Record<any, any> = {};
+      for (const key in stage) {
+        const value = (stage as any)[key];
+        if (!key.startsWith("_")) result[key] = value;
+      }
+      return result;
+    },
+  };
+  return stepController.step as any as Steps<{}>["step"];
+};

package/types/index.ts

@@ -1,4 +1,4 @@
-import { type $rejectCode } from "..";
+import { type $context, type $rejectCode } from "..";
 
 export interface $types {
   [key: string]: Record<any, any>;
@@ -10,6 +10,14 @@ export type Mixin<T, U> = U & Omit<T, keyof U>;
 
 export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
 
+export type DBCreate<T, KO extends keyof T | never = never, TO extends Omit<T, KO> = Omit<T, KO>> = {
+  [K in keyof TO]?: TO[K] extends null ? undefined : Exclude<TO[K], null>;
+};
+
+export type DBUpdate<T, KO extends keyof T | never = never, TO extends Partial<Omit<T, KO>> = Partial<Omit<T, KO>>> = {
+  [K in keyof TO]?: TO[K] extends null ? undefined : Exclude<TO[K], null>;
+};
+
 export type ExecuteId = string | "global";
 
 // DON'T TRY TO WRITE A MORE DETAILED TYPE FOR THIS TYPE
@@ -18,6 +26,7 @@ export type ExecuteId = string | "global";
 export type GeneratedInit = {
   routeSchema: any;
   commandSchema: any;
+  configSchema: any;
   testSchema: any;
 };
 
@@ -48,21 +57,6 @@ export type Ping =
       },
     ];
 
-export type Execute = <Path extends keyof $types["generated"]["routeSchema"]["$types"]>(
-  path: Path,
-  options?: Mixin<
-    ExecuteOptions,
-    {
-      headers?: Record<string, string>;
-      params?: $types["generated"]["routeSchema"]["$types"][Path]["params"];
-    }
-  >,
-) => $types["generated"]["routeSchema"]["$types"][Path]["🐣"] extends boolean
-  ? // action
-    Promise<[Partial<$rejectCode>, null, ExecuteResultsOption] | [null, ExecuteActionResults<Path>, ExecuteResultsOption]>
-  : // stream
-    Promise<[Partial<$rejectCode>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<$rejectCode>, null] | [null, ExecuteStreamResults<Path>], null>, ExecuteResultsOption]>;
-
 export type ExecuteResultsOption = { executeId: string };
 
 export type ExecuteActionResults<Path extends keyof Generated["routeSchema"]["$types"], Generated extends $types["generated"] = $types["generated"]> = Generated["routeSchema"]["$types"][Path]["result"];

package/utils/headers-to-json.ts

@@ -0,0 +1,7 @@
+export function headersToJSON(headers: Headers) {
+  const json: Record<string, string> = {};
+  for (const [key, value] of (headers as Headers).entries()) {
+    json[key] = value;
+  }
+  return json;
+}

package/utils/send-cookbook-event.ts

@@ -0,0 +1,26 @@
+import type { Log, MilkioInit, MilkioRuntimeInit } from "..";
+import { TSON } from "@southern-aurora/tson";
+
+type CookbookEvent = {
+  type: "milkio@logger";
+  log: Log;
+};
+
+export const sendCookbookEvent = async (runtime: MilkioRuntimeInit<MilkioInit>, event: CookbookEvent) => {
+  try {
+    const response = await fetch(`http://localhost:${runtime.cookbook.cookbookPort}/$action`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: TSON.stringify(event),
+    });
+    if (!response.ok) {
+      console.log("[COOKBOOK]", await response.text());
+      console.log("[COOKBOOK]", "Is Cookbook closed? There is an abnormality in the communication with Cookbook.");
+    }
+  } catch (error) {
+    console.log("[COOKBOOK]", error);
+    console.log("[COOKBOOK]", "Is Cookbook closed? There is an abnormality in the communication with Cookbook.");
+  }
+};

package/world/index.ts

@@ -1,41 +1,54 @@
-import { __initCommander, __initListener, ExecuteId, type Logger, type Mixin, type GeneratedInit, $types, Execute, Ping } from "..";
-import { __initExecuter } from "../execute";
+import { __initCommander, __initListener, __initExecuter, __initEventManager, type ExecuteId, type Logger, type Mixin, type GeneratedInit, type Ping, type LoggerSubmittingHandler, type LoggerInsertingHandler, type $context } from "..";
 import { defineDefaultExecuteIdGenerator } from "../execute/execute-id-generator";
 
 export type MilkioInit = {
-  port: {
-    app: number;
-    develop: number | "disabled";
+  port: number;
+  develop: boolean;
+  cookbook: {
+    cookbookPort: number;
+  };
+  cors?: {
+    corsAllowMethods?: string;
+    corsAllowHeaders?: string;
+    corsAllowOrigin?: string;
   };
-  getRealIp?: (request: Request) => string;
-  executeIdGenerator?: (request: Request) => string | Promise<string>;
-  corsAllowMethods?: string;
-  corsAllowHeaders?: string;
-  corsAllowOrigin?: string;
   ignorePathLevel?: number;
+  realIp?: (request: Request) => string;
+  executeId?: (request: Request) => string | Promise<string>;
+  onLoggerSubmitting?: LoggerSubmittingHandler;
+  onLoggerInserting?: LoggerInsertingHandler;
 };
 
 export type MilkioRuntimeInit<T extends MilkioInit> = Mixin<
   T,
   {
-    executeIdGenerator: (request: Request) => string | Promise<string>;
+    executeId: (request: Request) => string | Promise<string>;
     runtime: {
       request: Map<ExecuteId, { logger: Logger }>;
+      app: any;
     };
+    on: Awaited<ReturnType<typeof __initEventManager>>["on"];
+    off: Awaited<ReturnType<typeof __initEventManager>>["off"];
+    emit: Awaited<ReturnType<typeof __initEventManager>>["emit"];
   }
 >;
 
-export const createWorld = async <CookbookOptions extends MilkioInit>(generated: GeneratedInit, options: CookbookOptions): Promise<MilkioWorld<CookbookOptions>> => {
-  const executeIdGenerator = options.executeIdGenerator ?? defineDefaultExecuteIdGenerator();
+export const createWorld = async <MilkioOptions extends MilkioInit>(generated: GeneratedInit, options: MilkioOptions): Promise<MilkioWorld<MilkioOptions>> => {
+  const executeId = options.executeId ?? defineDefaultExecuteIdGenerator();
 
   const runtime = {
     request: new Map(),
-  } as MilkioRuntimeInit<CookbookOptions>["runtime"];
+  } as MilkioRuntimeInit<MilkioOptions>["runtime"];
+
+  const eventManager = __initEventManager();
 
-  const _: MilkioRuntimeInit<CookbookOptions> = {
+  const _: MilkioRuntimeInit<MilkioOptions> = {
     ...options,
-    executeIdGenerator,
+    executeId,
     runtime,
+    on: eventManager.on,
+    off: eventManager.off,
+    emit: eventManager.emit,
   };
 
   const executer = __initExecuter(generated, _);
@@ -45,21 +58,30 @@ export const createWorld = async <CookbookOptions extends MilkioInit>(generated:
   // Initialize the app
   const app = {
     _: _,
-    _executer: executer,
-    execute: executer.execute,
-    ping: executer.ping,
+    // event manager
+    on: eventManager.on,
+    off: eventManager.off,
+    emit: eventManager.emit,
+    // commander
     commander,
+    // listener
     listener,
   };
 
-  return app as MilkioWorld<CookbookOptions>;
+  runtime.app = app;
+
+  return app as MilkioWorld<MilkioOptions>;
 };
 
-export type MilkioWorld<CookbookOptions extends MilkioInit = MilkioInit> = {
-  _: MilkioRuntimeInit<CookbookOptions>;
-  _executer: Awaited<ReturnType<typeof __initExecuter<MilkioRuntimeInit<CookbookOptions>>>>;
-  commander: Awaited<ReturnType<typeof __initCommander<MilkioRuntimeInit<CookbookOptions>>>>;
-  listener: Awaited<ReturnType<typeof __initListener<MilkioRuntimeInit<CookbookOptions>>>>;
-  execute: Execute;
+export type MilkioWorld<MilkioOptions extends MilkioInit = MilkioInit> = {
+  _: MilkioRuntimeInit<MilkioOptions>;
+  // event manager
+  on: Awaited<ReturnType<typeof __initEventManager>>["on"];
+  off: Awaited<ReturnType<typeof __initEventManager>>["off"];
+  emit: Awaited<ReturnType<typeof __initEventManager>>["emit"];
   ping: (options?: { timeout?: number }) => Promise<Ping>;
+  // commander
+  commander: Awaited<ReturnType<typeof __initCommander<MilkioRuntimeInit<MilkioOptions>>>>;
+  // listener
+  listener: Awaited<ReturnType<typeof __initListener<MilkioRuntimeInit<MilkioOptions>>>>;
 };

package/middleware/index.ts

@@ -1,19 +0,0 @@
-import { type $context, type $meta } from "..";
-
-export const middleware = <MiddlewareInitT extends MiddlewareInit>(init: MiddlewareInitT): Middleware<MiddlewareInitT> => {
-  const middleware = init as unknown as Middleware<MiddlewareInitT>;
-  middleware.$milkioType = "middleware";
-  if (middleware.meta === undefined) middleware.meta = {};
-  return middleware;
-};
-
-export type MiddlewareInit = {
-  meta?: $meta;
-  handler: (context: $context, params: any) => Promise<unknown>;
-};
-
-export type Middleware<MiddlewareInitT extends MiddlewareInit> = {
-  $milkioType: "middleware";
-  meta: MiddlewareInitT["meta"] extends undefined ? {} : MiddlewareInitT["meta"];
-  handler: MiddlewareInitT["handler"];
-};

package/test/index.ts

@@ -1,21 +0,0 @@
-import { type context, type meta } from "..";
-
-export const test = <TestInitT extends TestInit>(init: TestInitT): Test<TestInitT> => {
-  const test = init as unknown as Test<TestInitT>;
-  test.$milkioType = "test";
-  if (test.name === undefined) test.name = {};
-  return test;
-};
-
-export type TestInit = {
-  name: meta;
-  handler: (test: TestTools) => Promise<unknown>;
-};
-
-export type Test<TestInitT extends TestInit> = {
-  $milkioType: "test";
-  name: TestInitT["name"] extends undefined ? {} : TestInitT["name"];
-  handler: TestInitT["handler"];
-};
-
-export type TestTools = {};