milkio 1.0.0-alpha.0 → 1.0.0-alpha.10

package/context/index.ts

@@ -1,13 +1,15 @@
-import { type $types, type Logger } from "..";
+import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, type Steps, type Execute } from "..";
 
 export interface $context {
   executeId: string;
   path: string;
   logger: Logger;
   http?: ContextHttp<Record<any, any>>;
+  step: Steps<{}>["step"];
+  execute: Execute;
 }
 
-export type ContextHttp<ParamsParsed> = {
+export type ContextHttp<ParamsParsed = any> = {
   url: URL;
   ip: string;
   path: { string: keyof $types["generated"]["routeSchema"]["$types"]; array: Array<string> };
@@ -15,4 +17,8 @@ export type ContextHttp<ParamsParsed> = {
     string: string;
     parsed: 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,11 +1,8 @@
 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 ExecuteOptions, type Logger, type MilkioRuntimeInit, type Results, type GeneratedInit, type MilkioInit, createLogger, exceptionHandler, Ping, createStep } 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 (
@@ -16,6 +13,7 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
       path: string;
       headers: Record<string, string> | Headers;
       mixinContext: Record<any, any> | undefined;
+      extendContext?: $context;
     } & (
       | {
           params: Record<any, any>;
@@ -37,8 +35,9 @@ 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 (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 (options.paramsType === "raw") {
       params = options.params;
       if (typeof params === "undefined") params = {};
@@ -55,49 +54,58 @@ 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.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?.detail?.params?.string) options.mixinContext.detail.params.parsed = params; // listen でパースしたパラメータを渡す
-    const context = {
-      ...(options.mixinContext ? options.mixinContext : {}),
-      path: options.path,
-      logger: options.createdLogger,
-      executeId: options.createdExecuteId,
-    } as unknown as $context;
-
+    if (options.mixinContext?.http?.params?.string) options.mixinContext.http.params.parsed = params; // listen でパースしたパラメータを渡す
+    const context =
+      options.extendContext ??
+      ({
+        ...(options.mixinContext ? options.mixinContext : {}),
+        path: options.path,
+        logger: options.createdLogger,
+        executeId: options.createdExecuteId,
+        execute: (path: any, options: any) => runtime.runtime.app.execute(path, options, context),
+        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.` });
     }
 
+    if (!options.extendContext) await runtime.emit("milkio:executeBefore", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, context });
+
     results.value = await module.default.handler(context, params);
 
-    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.` });
-    }
+    if (!options.extendContext) 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> => {
+  const execute = async (path: string, options?: ExecuteOptions, context?: $context): Promise<any> => {
     if (!options) options = {};
-    const executeId = createId();
-    const logger = createLogger(runtime, executeId);
-    runtime.runtime.request.set(executeId, { logger: logger });
+
+    const executeId = context?.executeId ?? createId();
+    const logger = context?.logger ?? createLogger(runtime, path, executeId);
+    if (!context?.logger) runtime.runtime.request.set(executeId, { logger: logger });
 
     try {
       const routeSchema = generated.routeSchema.routes.get(path);
-      if (routeSchema === undefined) throw reject("NOT_FOUND", { path: path });
+      if (routeSchema === undefined) {
+        throw reject("NOT_FOUND", { path: path });
+      }
 
       const executed = await __call(routeSchema, {
         createdExecuteId: executeId,
@@ -107,6 +115,7 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         mixinContext: {},
         params: options.params ?? {},
         paramsType: "raw",
+        extendContext: context,
       });
 
       if (routeSchema.type === "stream") {

package/index.ts

@@ -1,11 +1,14 @@
 export * from "./types";
+export * from "./use";
+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,14 +15,14 @@ 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 port = runtime.port;
   const fetch = async (request: MilkioHttpRequest): Promise<Response> => {
     if (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 ?? "*",
         },
       });
     }
@@ -31,37 +31,38 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
       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(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(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",
       },
     };
 
     try {
-      const detail = (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 http = (await (async () => {
+        const ip = runtime.realIp ? runtime.realIp(request) : "::1";
         const params = {
           string: await request.text(),
           parsed: undefined,
@@ -69,45 +70,54 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
 
         return {
           url,
-          path: { string: pathString as keyof $types["generated"]["routeSchema"]["$types"], array: pathArray },
           ip,
+          path: { string: pathString as keyof $types["generated"]["routeSchema"]["$types"], array: pathArray },
           params,
-        } as ContextHttp<undefined>;
+          request,
+          response,
+        } as ContextHttp;
       })())!;
 
+      await runtime.emit("milkio:httpRequest", { executeId, logger, path: http.path.string as string, http });
+
       if (!request.headers.get("Accept")?.startsWith("text/event-stream")) {
         // action
-        const routeSchema = generated.routeSchema.routes.get(detail.path.string);
-        if (routeSchema === undefined) throw reject("NOT_FOUND", { path: detail.path.string as string });
+        const routeSchema = generated.routeSchema.routes.get(http.path.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, {
           createdExecuteId: executeId,
           createdLogger: logger,
-          path: detail.path.string as string,
+          path: http.path.string as string,
           headers: request.headers as Headers,
-          mixinContext: { detail },
-          params: detail.params.string,
+          mixinContext: { http },
+          params: http.params.string,
           paramsType: "string",
         });
 
         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 {
         // stream
-        const routeSchema = generated.routeSchema.routes.get(detail.path.string);
-        if (routeSchema === undefined) throw reject("NOT_FOUND", { path: detail.path.string as string });
+        const routeSchema = generated.routeSchema.routes.get(http.path.string);
+        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, {
           createdExecuteId: executeId,
           createdLogger: logger,
-          path: detail.path.string as string,
+          path: http.path.string as string,
           headers: request.headers as Headers,
-          mixinContext: { detail },
-          params: detail.params.string,
+          mixinContext: { http },
+          params: http.params.string,
           paramsType: "string",
         });
         let stream: ReadableStream;
@@ -178,6 +188,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.0",
+  "version": "1.0.0-alpha.10",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/step/index.ts

@@ -0,0 +1,36 @@
+import type { ToEmptyObject } from "..";
+
+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];
+};
+
+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

package/use/index.ts

@@ -0,0 +1,12 @@
+export const defineUse = <CreatorFn extends () => Promise<unknown> | unknown>(creatorFn: CreatorFn): (() => Promise<Awaited<ReturnType<CreatorFn>>>) => {
+  let use: any | undefined;
+
+  const getUse = async () => {
+    if (use === undefined) {
+      use = await creatorFn();
+    }
+    return use;
+  };
+
+  return getUse;
+};

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 Execute, type Ping, type ContextCreatedHandler, LoggerSubmittingHandler, LoggerInsertingHandler } 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,37 @@ export const createWorld = async <CookbookOptions extends MilkioInit>(generated:
   // Initialize the app
   const app = {
     _: _,
+    // event manager
+    on: eventManager.on,
+    off: eventManager.off,
+    emit: eventManager.emit,
+    // executer
     _executer: executer,
     execute: executer.execute,
     ping: executer.ping,
+    // 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>>>>;
+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"];
+  // executer
+  _executer: Awaited<ReturnType<typeof __initExecuter<MilkioRuntimeInit<MilkioOptions>>>>;
   execute: Execute;
   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 = {};