milkio 0.8.2 → 1.0.0-alpha.0

package/action/index.ts

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

package/command/index.ts

@@ -0,0 +1,53 @@
+import { type MilkioRuntimeInit, type MilkioInit, type GeneratedInit } from "..";
+
+export const command = <CommandInitT extends CommandInit>(init: CommandInitT): Command<CommandInitT> => {
+  const command = init as unknown as Command<CommandInitT>;
+  command.$milkioType = "command";
+  return command;
+};
+
+export type CommandInit = {
+  handler: (commands: Array<string>, options: Record<string, string>) => Promise<unknown>;
+};
+
+export type Command<CommandInitT extends CommandInit> = {
+  $milkioType: "command";
+  handler: CommandInitT["handler"];
+};
+
+export const __initCommander = <MilkioRuntime extends MilkioRuntimeInit<MilkioInit> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
+  const commander = async (argv: Array<string>, options?: { onNotFound?: () => any }) => {
+    const params = {
+      path: "index",
+      commands: [] as Array<string>,
+      options: {} as Record<string, string | true>,
+    };
+    for (const v of argv.slice(3)) {
+      if (v.startsWith("--") && v.includes("=")) {
+        const vSplited = v.split("=");
+        params.options[vSplited[0].slice(2)] = vSplited.slice(1, vSplited.length).join("=");
+      } else if (v.startsWith("--")) {
+        params.options[v.slice(2)] = "1";
+      } else if (v.startsWith("-") && v.includes("=")) {
+        const vSplited = v.split("=");
+        params.options[vSplited[0].slice(1)] = vSplited.slice(1, vSplited.length).join("=");
+      } else if (v.startsWith("-")) {
+        params.options[v.slice(1)] = "1";
+      } else {
+        params.commands.push(v);
+      }
+    }
+    if (argv.length === 2) params.path = `index`;
+    else params.path = `${argv[2] ?? "index"}`;
+
+    if (!(params.path in generated.commandSchema.commands)) {
+      if (options?.onNotFound) return await options.onNotFound();
+      console.log(`\x1B[44m UwU \x1B[0m \x1B[2mCommand not found:\x1B[0m \x1B[32m${params.path}\x1B[0m`);
+      return undefined;
+    }
+
+    return await generated.commandSchema.commands[params.path].module.handler(params.commands, params.options);
+  };
+
+  return commander;
+};

package/context/index.ts

@@ -0,0 +1,18 @@
+import { type $types, type Logger } from "..";
+
+export interface $context {
+  executeId: string;
+  path: string;
+  logger: Logger;
+  http?: ContextHttp<Record<any, any>>;
+}
+
+export type ContextHttp<ParamsParsed> = {
+  url: URL;
+  ip: string;
+  path: { string: keyof $types["generated"]["routeSchema"]["$types"]; array: Array<string> };
+  params: {
+    string: string;
+    parsed: ParamsParsed;
+  };
+};

package/exception/index.ts

@@ -0,0 +1,45 @@
+import { TSON } from "@southern-aurora/tson";
+import { type MilkioResponseReject, type Logger } from "..";
+
+export interface $rejectCode {
+  FAIL: string;
+  REQUEST_FAIL: any;
+  NOT_DEVELOP_MODE: string;
+  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;
+}
+
+export function reject<Code extends keyof $rejectCode, RejectData extends $rejectCode[Code]>(code: Code, data: RejectData): MilkioRejectError<Code, RejectData> {
+  const error = { $milkioReject: true, code: code, data: data } as MilkioRejectError<Code, RejectData>;
+  Error.captureStackTrace(error);
+  return error;
+}
+
+export type MilkioRejectError<Code extends keyof $rejectCode = keyof $rejectCode, RejectData extends $rejectCode[Code] = $rejectCode[Code]> = { code: Code; data: RejectData; stack: string; $milkioReject: true };
+
+export function exceptionHandler(executeId: string, logger: Logger, error: MilkioRejectError<any, any> | any): MilkioResponseReject {
+  const name = error?.code ?? error?.name ?? error?.constructor?.name ?? "Unnamed Exception";
+
+  if (error?.$milkioReject === true && error?.code === "NOT_FOUND") {
+    logger.info(name, error?.data?.path ?? "Unknown path");
+  } else {
+    try {
+      const stack = error?.$milkioReject ? (error?.stack ?? "").split("\n").slice(2).join("\n") : error?.stack ?? "";
+      logger.error(name, `\n${TSON.stringify(error?.data)}`, `\n${stack}\n`);
+    } catch (_) {
+      logger.error(name, `\n${error?.toString()}`, `\n${error?.stack}\n`);
+    }
+  }
+
+  let result: MilkioResponseReject;
+
+  if (error?.$milkioReject === true) result = { success: false, code: error.code, reject: error.data, executeId };
+  else result = { success: false, code: "INTERNAL_SERVER_ERROR", reject: undefined, executeId };
+
+  return result;
+}

package/execute/execute-id-generator.ts

@@ -0,0 +1,7 @@
+import { createId } from "../utils/create-id";
+
+export type ExecuteIdGenerator = (request?: Request) => string | Promise<string>;
+
+export const defineDefaultExecuteIdGenerator = () => {
+  return createId;
+};

package/execute/index.ts

@@ -0,0 +1,160 @@
+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;
+};
+
+export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
+  const __call = async (
+    routeSchema: any,
+    options: {
+      createdExecuteId: string;
+      createdLogger: Logger;
+      path: string;
+      headers: Record<string, string> | Headers;
+      mixinContext: Record<any, any> | undefined;
+    } & (
+      | {
+          params: Record<any, any>;
+          paramsType: "raw";
+        }
+      | {
+          params: string;
+          paramsType: "string";
+        }
+    ),
+  ): Promise<{ executeId: string; headers: Headers; params: Record<any, unknown>; results: Results<any>; context: $context; meta: Readonly<$meta>; type: "action" | "stream" }> => {
+    const executeId = options.createdExecuteId;
+    let headers: Headers;
+    if (!(options.headers instanceof Headers)) {
+      // @ts-ignore
+      headers = new Headers({
+        ...options.headers,
+      });
+    } else {
+      headers = options.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 = {};
+    } else {
+      if (options.params === "") params = {};
+      else {
+        try {
+          params = TSON.parse(options.params);
+        } catch (error) {
+          throw reject("PARAMS_TYPE_NOT_SUPPORTED", { expected: "json" });
+        }
+        if (typeof params === "undefined") params = {};
+      }
+    }
+    if (typeof params !== "object" || Array.isArray(params)) throw reject("PARAMS_TYPE_NOT_SUPPORTED", { expected: "json" });
+    if ("$milkioGenerateParams" in params && params.$milkioGenerateParams === "enable") {
+      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;
+
+    const results: Results<unknown> = { value: undefined };
+
+    const module = await routeSchema.module();
+    let meta = (module.meta ? module.meta : {}) as unknown as Readonly<$meta>;
+
+    if (!meta.typeSafety || meta.typeSafety.includes("params")) {
+      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.` });
+    }
+
+    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.` });
+    }
+
+    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 ping = async (): Promise<Ping> => [
+    null,
+    {
+      connect: true,
+      delay: 0,
+      serverTimestamp: Date.now(),
+    },
+  ];
+
+  return {
+    __call,
+    execute,
+    ping,
+  };
+};

package/index.ts

@@ -1,36 +1,11 @@
-// types
-export * from "./types";
-
-// utils
-export * from "./utils/tson";
-export * from "./utils/create-ulid";
-export * from "./utils/env-to-string";
-export * from "./utils/env-to-number";
-export * from "./utils/env-to-boolean";
-export * from "./utils/header-to-plain-object";
-
-// defines
-export * from "./defines/define-use";
-export * from "./defines/define-api";
-export * from "./defines/define-config";
-export * from "./defines/define-api-test";
-export * from "./defines/define-middleware";
-
-// kernel
-export * from "./kernel/runtime";
-export * from "./kernel/logger";
-export * from "./kernel/fail";
-export * from "./kernel/meta";
-export * from "./kernel/context";
-export * from "./kernel/validate";
-export * from "./kernel/middleware";
-
-// handler
-export * from "./defines/define-http-handler";
-export * from "./defines/define-command-handler";
-
-// api test
-export * from "./api-test/index";
-
-// milkio
-export * from "./kernel/milkio";
+export * from "./types";
+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 "./listener";
+export * from "./exception";

package/listener/index.ts

@@ -0,0 +1,199 @@
+import { TSON } from "@southern-aurora/tson";
+import { type $context, type MilkioRuntimeInit, type Mixin, type GeneratedInit, type MilkioInit, type $types, createLogger, type ContextHttp, exceptionHandler, type MilkioResponseReject, type Results, type MilkioResponseSuccess, reject } from "..";
+import { type __initExecuter } from "../execute";
+import { createId } from "../utils/create-id";
+
+export type MilkioHttpRequest = Request;
+
+export type MilkioHttpResponse = Mixin<
+  ResponseInit,
+  {
+    body: string | Blob | FormData | URLSearchParams | ReadableStream<Uint8Array>;
+    status: number;
+    headers: Record<string, string>;
+  }
+>;
+
+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") {
+      return new Response(undefined, {
+        headers: {
+          "Access-Control-Allow-Methods": runtime.corsAllowMethods ?? "*",
+          "Access-Control-Allow-Origin": runtime.corsAllowOrigin ?? "*",
+          "Access-Control-Allow-Headers": runtime.corsAllowHeaders ?? "*",
+        },
+      });
+    }
+
+    if (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 ?? "*",
+          "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);
+    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 ?? "*",
+        "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 params = {
+          string: await request.text(),
+          parsed: undefined,
+        };
+
+        return {
+          url,
+          path: { string: pathString as keyof $types["generated"]["routeSchema"]["$types"], array: pathArray },
+          ip,
+          params,
+        } as ContextHttp<undefined>;
+      })())!;
+
+      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 });
+        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,
+          headers: request.headers as Headers,
+          mixinContext: { detail },
+          params: detail.params.string,
+          paramsType: "string",
+        });
+
+        if (executed.results.value !== undefined) response.body = TSON.stringify({ success: true, data: executed.results.value, executeId } satisfies MilkioResponseSuccess<any>);
+
+        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 });
+        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,
+          headers: request.headers as Headers,
+          mixinContext: { detail },
+          params: detail.params.string,
+          paramsType: "string",
+        });
+        let stream: ReadableStream;
+        let control: ReadableStreamDirectController | ReadableStreamDefaultController;
+
+        if (typeof Bun !== "undefined") {
+          // @ts-ignore: bun
+          stream = new ReadableStream({
+            type: "direct",
+            async pull(controller: ReadableStreamDirectController) {
+              control = controller;
+              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) {
+                    const result: string = JSON.stringify([null, TSON.encode(value)]);
+                    controller.write(`data:${result}\n\n`);
+                  } else {
+                    executed.results.value.return(undefined);
+                    controller.close();
+                  }
+                }
+              } catch (error) {
+                const exception = exceptionHandler(executeId, logger, error);
+                const result: any = {};
+                result[exception.code] = exception.reject;
+                controller.write(`data:${JSON.stringify([TSON.encode(result), null])}\n\n`);
+              }
+              await new Promise((resolve) => setTimeout(resolve, 0));
+              controller.close();
+            },
+            cancel() {
+              control.close();
+            },
+          });
+        } else {
+          // node.js or others
+          stream = new ReadableStream({
+            async pull(controller) {
+              control = controller;
+              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) {
+                    const result: string = JSON.stringify([null, TSON.encode(value)]);
+                    controller.enqueue(`data:${result}\n\n`);
+                  } else {
+                    executed.results.value.return(undefined);
+                    controller.close();
+                  }
+                }
+              } catch (error) {
+                const exception = exceptionHandler(executeId, logger, error);
+                const result: any = {};
+                result[exception.code] = exception.reject;
+                controller.enqueue(`data:${JSON.stringify([TSON.encode(result), null])}\n\n`);
+              }
+              await new Promise((resolve) => setTimeout(resolve, 0));
+              controller.close();
+            },
+            cancel() {
+              control.close();
+            },
+          });
+        }
+
+        response.body = stream;
+        response.headers["Content-Type"] = "text/event-stream";
+        response.headers["Cache-Control"] = "no-cache";
+
+        runtime.runtime.request.delete(executeId);
+        return new Response(response.body, response);
+      }
+    } catch (error) {
+      const results: Results<MilkioResponseReject> = {
+        value: exceptionHandler(executeId, logger, error),
+      };
+      if (results.value !== undefined) response.body = TSON.stringify(results.value);
+
+      runtime.runtime.request.delete(executeId);
+      return new Response(response.body, response);
+    }
+  };
+
+  return {
+    port,
+    fetch,
+  };
+};

package/logger/index.ts

@@ -0,0 +1,67 @@
+import { TSON } from "@southern-aurora/tson";
+import { format } from "date-fns";
+import { type MilkioInit, type MilkioRuntimeInit } from "..";
+
+export type Log = [string /* executeId */, "[DEBUG]" | "[INFO]" | "[WARN]" | "[ERROR]", string, string, ...Array<unknown>];
+
+export type Logger = {
+  _: {
+    logs: Array<Log>;
+    tags: Map<string, unknown>;
+  };
+  setTag: (key: string, value: unknown) => void;
+  setLog: (...log: Log) => void;
+  debug: (description: string, ...params: Array<unknown>) => Log;
+  info: (description: string, ...params: Array<unknown>) => Log;
+  warn: (description: string, ...params: Array<unknown>) => Log;
+  error: (description: string, ...params: Array<unknown>) => Log;
+};
+
+export const createLogger = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(runtime: MilkioRuntime, executeId: string): Logger => {
+  const logger = {} as Logger;
+
+  logger._ = {
+    logs: new Array(),
+    tags: new Map(),
+  };
+
+  const __tagPush = (key: string, value: unknown): void => {
+    logger._.tags.set(key, value);
+  };
+  const __logPush = (log: Log): 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);
+        }
+      })();
+    }
+    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)");
+
+  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]);
+
+  return logger;
+};

package/meta/index.ts

@@ -0,0 +1,12 @@
+export interface $meta {
+  /**
+   * type safety
+   * @default ["params","results"]
+   */
+  typeSafety?: Array<"params" | "results">;
+  /**
+   * methods
+   * @default ["POST"]
+   */
+  methods?: Array<"GET" | "POST" | "PUT" | "DELETE" | "PATCH" | string>;
+}

package/middleware/index.ts

@@ -0,0 +1,19 @@
+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"];
+};