milkio 0.0.1

package/.co.toml

@@ -0,0 +1,2 @@
+["general"]
+includes = ["co:bun"]

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 southern-aurora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# bao
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.0.3. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/c.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+
+/* eslint-disable @typescript-eslint/no-misused-promises, no-console, @typescript-eslint/no-explicit-any */
+
+import { argv, cwd, env, exit } from "node:process";
+import { exec } from "./utils/exec";
+import { join } from "node:path";
+import { $ } from "bun";
+import { readFile } from "node:fs/promises";
+
+const rootPath = cwd();
+const method = argv[2] as keyof typeof commands;
+const params = argv.slice(3) as Parameters<(typeof commands)[keyof typeof commands]>;
+
+const commands = {
+  async gen() {
+    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/generate.ts"]);
+  },
+  async "gen:database"() {
+    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/generate-database.ts"]);
+  },
+  async "build:cookbook"() {
+    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/build-cookbook.ts"]);
+  },
+  async "build:dto"() {
+    await exec(join(rootPath, "packages", "dto"), ["bun", "i"]);
+    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/generate.ts"]);
+    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/build-dto.ts"]);
+  },
+  async test(files?: string, reserved?: string) {
+    const run = async () => {
+      const packageJson = await JSON.parse((await readFile(join(rootPath, "package.json"))).toString());
+      // A bug has appeared in the new version of bun: https://github.com/oven-sh/bun/issues/9428
+      // Therefore, temporarily switch to another implementation.
+      // await $`${{ raw: packageJson.scripts.start }}`.env({
+      //   ...env,
+      //   LOONGBAO_RUN_MODE: "API_TEST",
+      //   LOONGBAO_TEST: files ?? "1"
+      // });
+      //
+      await exec(rootPath, ["bash", "-c", packageJson.scripts.start as string], {
+        env: {
+          ...env,
+          LOONGBAO_RUN_MODE: "API_TEST",
+          LOONGBAO_TEST: files ?? "1"
+        }
+      });
+    };
+    if (!env.LOONGBAO_TEST_RESERVED && reserved !== "1") {
+      // Normal test
+      await run();
+    } else {
+      // Keep after testing, the terminal never exits and is usually used for various IDE extensions.
+      try {
+        await run();
+      } catch (error) {}
+      while (true) {
+        const result = await new Promise((resolve) => {
+          const wasRaw = process.stdin.isRaw;
+          process.stdin.setRawMode(true);
+          process.stdin.resume();
+          process.stdin.once("data", (data) => {
+            process.stdin.pause();
+            process.stdin.setRawMode(wasRaw);
+            resolve(data.toString());
+          });
+        });
+        // No exit function is set
+        // if (result === "q") exit(0);
+      }
+    }
+  }
+};
+
+if (method === undefined || !(method in commands)) {
+  console.log("Command does not exist, Supported commands are:");
+  console.log("  " + Object.keys(commands).join(", "));
+  exit(1);
+}
+
+await commands[method](...params);
+
+exit(0);

package/defines/define-api-test-handler.ts

@@ -0,0 +1,70 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument, no-console, @typescript-eslint/no-explicit-any */
+import { exit } from "node:process";
+import schema from "../../../generate/api-schema";
+import { type LoongbaoApp } from "..";
+
+export const defineApiTestHandler = async <Paths extends Array<keyof (typeof schema)["apiTestsSchema"]>>(app: LoongbaoApp, paths: Paths | string | 1 | undefined) => {
+  console.log(`🧊 Loongbao Api Testing..\n`);
+
+  if (!paths) {
+    console.log("🧊 No paths specified.");
+    exit(1);
+  }
+
+  if (paths === "1" || paths === 1) {
+    paths = Object.keys(schema.apiTestsSchema) as unknown as Paths;
+  } else if (typeof paths === "string") {
+    if (!paths.startsWith("[")) {
+      paths = [paths] as Paths;
+    } else {
+      paths = JSON.parse(paths) as Paths;
+    }
+  }
+
+  const tests = [];
+  const startedAt = new Date().getTime();
+
+  for (let path of paths) {
+    if (path.startsWith("/")) path = path.slice(1) as Paths[number];
+    tests.push(
+      // @ts-ignore
+      (async () => {
+        // @ts-ignore
+        const module = await schema.apiTestsSchema[path]().module;
+        const cases = module.test.getCases();
+        let i = 0;
+        for (const cs of cases) {
+          ++i;
+          const csStartedAt = new Date().getTime();
+          const clear = setTimeout(() => {
+            console.error(`------`);
+            console.error(`❌ TIMEOUT -- More than ${cs.timeout ?? 6000}ms`);
+            console.error(`   ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i}`);
+            console.error(`------`);
+            exit(1);
+          }, cs.timeout ?? 6000);
+          await cs.handler({
+            execute: async (params: any, headers?: any, options?: any) => app.execute(path, params, headers ?? {}, options),
+            reject: (message?: string) => {
+              console.error(`------`);
+              console.error(`❌ REJECT -- ${message ?? "Test not satisfied"}`);
+              console.error(`   ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i} | Time: ${new Date().getTime() - csStartedAt}ms`);
+              console.error(`------`);
+              exit(1);
+            }
+          });
+          clearTimeout(clear);
+          console.log(`✅ DIRECT --  ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i} | Time: ${new Date().getTime() - csStartedAt}ms`);
+        }
+      })()
+    );
+  }
+
+  await Promise.all(tests);
+
+  const endedAt = new Date().getTime();
+
+  console.log(`\n✅ All tests passed.`);
+  console.log(`🧊 Loongbao Api Testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`);
+  exit(0);
+};

package/defines/define-api-test.ts

@@ -0,0 +1,14 @@
+import { type Api, type ExecuteResult, type ExecuteOptions } from "..";
+
+export function defineApiTest<ApiT extends Api>(_api: ApiT, cases: Array<ApiTestCases<ApiT>>) {
+  return {
+    getCases: () => cases,
+    isApiTest: true
+  };
+}
+
+export type ApiTestCases<ApiT extends Api> = {
+  handler: (test: { execute: (params: Parameters<ApiT["action"]>[0], headers?: Record<string, string>, options?: ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>; reject: (message?: string) => void }) => Promise<void> | void;
+  name: string;
+  timeout?: number;
+};

package/defines/define-api.ts

@@ -0,0 +1,15 @@
+import type { Meta } from "../../../src/meta";
+import type { Context } from "../../../src/context";
+
+export function defineApi<ApiT extends Api>(api: ApiT): ApiT & { isApi: true } {
+  return {
+    ...api,
+    isApi: true
+  };
+}
+
+export type Api = {
+  meta: Meta;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  action: (params: any, context: Context) => Promise<unknown> | unknown;
+};

package/defines/define-http-handler.ts

@@ -0,0 +1,203 @@
+/* eslint-disable no-console */
+import { configFramework, loggerPushTags, loggerSubmit, useLogger, loggerSubmitAll, runtime, MiddlewareEvent } from "..";
+import type { ExecuteId, LoongbaoApp, Mixin } from "..";
+import { hanldeCatchError } from "../utils/handle-catch-error";
+import { routerHandler } from "../../../src/router";
+import schema from "../../../generate/api-schema";
+import { failCode } from "../../../src/fail-code";
+import process, { exit } from "node:process";
+import { TSON } from "@southern-aurora/tson";
+import { createUlid } from "../utils/create-ulid";
+
+export type ExecuteHttpServerOptions = {
+  /**
+   * The execution ID generator
+   * If you have enabled this option, the executeId will be generated each time by calling this method. Otherwise, it will be generated using the built-in method.
+   *
+   * @param request
+   * @returns
+   */
+  executeIdGenerator?: (request: Request) => string | Promise<string>;
+};
+
+export function defineHttpHandler(app: LoongbaoApp, options: ExecuteHttpServerOptions = {}) {
+  // If an unexpected error occurs, exit the process.
+  // For modern production environments such as Serverless, Kubernetes, or Docker Compose:
+  // The process will automatically restart after exiting.
+  // This helps prevent unexpected errors from contaminating the entire application and causing subsequent requests to fail intermittently.
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.on("uncaughtException", async (error) => {
+    const logger = useLogger("global");
+    logger.error("ErrorCaughtInUncaughtExceptionEvent:", error);
+    await loggerSubmitAll();
+    exit(1);
+  });
+
+  const fetch = async (request: LoongbaoHTTPRequest) => {
+    const fullurl = new URL(request.request.url, `http://${request.request.headers.get("host") ?? "localhost"}`);
+    const executeId = (options?.executeIdGenerator ? await options.executeIdGenerator(request.request) : createUlid()) as ExecuteId;
+    runtime.execute.executeIds.add(executeId);
+    const logger = useLogger(executeId);
+    const ip = (request.request.headers.get("x-forwarded-for") as string | undefined)?.split(",")[0] ?? "0.0.0.0";
+    const headers = request.request.headers;
+
+    loggerPushTags(executeId, {
+      from: "http-server",
+      fullUrl: fullurl.pathname,
+      ip,
+      method: request.request.method,
+      requestHeaders: request.request.headers.toJSON(),
+      timein: new Date().getTime()
+    });
+
+    const response: LoongbaoHTTPResponse = {
+      body: "",
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Methods": configFramework.corsAllowMethods ?? "*",
+        "Access-Control-Allow-Headers": configFramework.corsAllowHeaders ?? "*",
+        "Access-Control-Allow-Origin": configFramework.corsAllowOrigin ?? "*"
+      }
+    };
+
+    try {
+      // Process OPTIONS pre inspection requests
+      if (request.request.method === "OPTIONS") {
+        await loggerSubmit(executeId);
+        runtime.execute.executeIds.delete(executeId);
+
+        return new Response("", {
+          headers: {
+            "Access-Control-Allow-Methods": configFramework.corsAllowMethods ?? "*",
+            "Access-Control-Allow-Headers": configFramework.corsAllowHeaders ?? "*",
+            "Access-Control-Allow-Origin": configFramework.corsAllowOrigin ?? "*"
+          }
+        });
+      }
+
+      let path = fullurl.pathname.substring(1).split("/");
+
+      // Compatible with API gateway's ability to differentiate versions by path
+      // see: /src/config/ConfigProgram.ts in "ignorePathLevel"
+      if (configFramework.ignorePathLevel !== 0) path = path.slice(configFramework.ignorePathLevel);
+
+      let pathstr = path.join("/") as keyof (typeof schema)["apiMethodsSchema"];
+
+      // Special processing: do not run middleware when encountering 404 and return quickly
+      if (!(pathstr in schema.apiMethodsSchema)) {
+        const redirectPath = await routerHandler(pathstr, fullurl);
+        if (!redirectPath) {
+          const rawbody = await request.request.text();
+          loggerPushTags(executeId, {
+            body: rawbody || "no body"
+          });
+          response.body = `{"executeId":"${executeId}","success":false,"fail":{"code":"not-found","message":${JSON.stringify(failCode["not-found"]())}}}`;
+
+          loggerPushTags(executeId, {
+            status: response.status,
+            responseHeaders: response.headers,
+            timeout: new Date().getTime()
+          });
+
+          await loggerSubmit(executeId);
+          runtime.execute.executeIds.delete(executeId);
+
+          return new Response(response.body, response);
+        }
+        pathstr = redirectPath as typeof pathstr;
+      }
+
+      loggerPushTags(executeId, {
+        path: pathstr
+      });
+
+      const detail = {
+        path: pathstr,
+        ip,
+        executeId,
+        fullurl,
+        request: request.request,
+        response
+      };
+
+      // execute api
+      // after request middleware
+      await MiddlewareEvent.handle("afterHTTPRequest", [headers, detail]);
+
+      const rawbody = await request.request.text();
+      loggerPushTags(executeId, {
+        body: rawbody || "no body"
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let params: any;
+      if (rawbody === "") {
+        params = undefined;
+      } else {
+        try {
+          params = JSON.parse(rawbody);
+        } catch (error) {
+          const logger = useLogger(executeId);
+          logger.log("TIP: body is not json, the content is not empty, but the content is not in a valid JSON format. The original content value can be retrieved via request.request.text()");
+          params = undefined;
+        }
+      }
+
+      loggerPushTags(executeId, {
+        params
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      const result = await app._executeCoreToJson(pathstr, params, headers, {
+        executeId,
+        logger,
+        detail
+      });
+
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression, @typescript-eslint/no-explicit-any
+      response.body = `${response.body ?? ""}${result}`;
+
+      // before response middleware
+      const middlewareResponse = {
+        value: response.body
+      };
+      await MiddlewareEvent.handle("beforeHTTPResponse", [middlewareResponse, detail]);
+
+      response.body = middlewareResponse.value;
+    } catch (error) {
+      const result = hanldeCatchError(error, executeId);
+      response.body = TSON.stringify(result);
+    }
+
+    loggerPushTags(executeId, {
+      status: response.status,
+      responseHeaders: response.headers,
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      body: response.body || "",
+      timeout: new Date().getTime()
+    });
+
+    await loggerSubmit(executeId);
+    runtime.execute.executeIds.delete(executeId);
+
+    return new Response(response.body, response);
+  };
+
+  return fetch;
+}
+
+export type LoongbaoHTTPRequest = {
+  request: Request;
+};
+
+export type LoongbaoHTTPResponse = Mixin<
+  ResponseInit,
+  {
+    //
+    body: string;
+    status: number;
+    headers: Record<string, string>;
+  }
+>;

package/defines/define-middleware.ts

@@ -0,0 +1,9 @@
+import { type MiddlewareOptions } from "..";
+
+export function defineMiddleware(options: MiddlewareOptions): () => MiddlewareOptions {
+  return () => ({
+    ...options,
+    // @ts-ignore
+    isMiddleware: true
+  });
+}

package/defines/define-use.ts

@@ -0,0 +1,13 @@
+export const defineUse = <CreatorFn extends () => Promise<unknown> | unknown>(creatorFn: CreatorFn): (() => Promise<Awaited<ReturnType<CreatorFn>>>) => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let use: any | undefined;
+
+  const getUse = async () => {
+    if (use === undefined) {
+      use = await creatorFn();
+    }
+    return use;
+  };
+
+  return getUse;
+};

package/index.ts

@@ -0,0 +1,33 @@
+// 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/create-template";
+
+// defines
+export * from "./defines/define-use";
+export * from "./defines/define-api";
+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/config";
+export * from "./kernel/context";
+export * from "./kernel/validate";
+export * from "./kernel/middleware";
+
+// handler
+export * from "./defines/define-http-handler";
+export * from "./defines/define-api-test-handler";
+
+// loongbao
+export * from "./kernel/loongbao";

package/kernel/config.ts

@@ -0,0 +1,15 @@
+import { cwd, env } from "node:process";
+import { envToBoolean, envToNumber, envToString } from "..";
+
+export const configFramework = {
+  cwd: cwd(),
+  port: envToNumber(env.PORT, 9000),
+  loongbaoRunMode: envToString(env.LOONGBAO_RUN_MODE, "DEFAULT"),
+  loongbaoTest: envToString(env.LOONGBAO_TEST, ""),
+  debug: envToBoolean(env.DEBUG, false),
+  redisUrl: envToString(env.REDIS_URL, "redis://:123456@your-not-redis-url:6379"),
+  ignorePathLevel: envToNumber(env.IGNORE_PATH_LEVEL, 0),
+  corsAllowMethods: envToString(env.CORS_ALLOW_METHODS, "*"),
+  corsAllowHeaders: envToString(env.CORS_ALLOW_HEADERS, "*"),
+  corsAllowOrigin: envToString(env.CORS_ALLOW_ORIGIN, "*")
+};

package/kernel/context.ts

@@ -0,0 +1,24 @@
+import type { URL } from "node:url";
+import type { ExecuteId, Logger, LoongbaoHTTPResponse } from "..";
+
+export type FrameworkContext = {
+  path: string;
+  executeId: ExecuteId;
+  headers: Headers;
+  logger: Logger;
+  /**
+   * Additional information about the request
+   * These are usually only fully implemented when called by an HTTP server
+   * During testing or when calling between microservices, some or all of the values may be undefined
+   */
+  detail: Partial<FrameworkHTTPDetail>;
+};
+
+export type FrameworkHTTPDetail = {
+  path: string;
+  executeId: ExecuteId;
+  fullurl: URL;
+  ip: string;
+  request: Request;
+  response: LoongbaoHTTPResponse;
+};

package/kernel/fail.ts

@@ -0,0 +1,22 @@
+import { failCode } from "../../../src/fail-code";
+
+export function reject<Code extends keyof typeof failCode, FailData extends (typeof failCode)[Code]>(code: Code, data: Parameters<FailData>[0]) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+  const message = failCode[code]?.(data as any) ?? "";
+  const error = {
+    name: "LoongbaoReject",
+    code,
+    message,
+    data,
+    stack: ""
+  };
+  Error.captureStackTrace(error);
+  error.stack = error.stack.replace(/\n.*\n/, "\n");
+
+  return error;
+}
+
+export type LoongbaoReject = ReturnType<typeof reject>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type LoongbaoFailCode = Record<string, (arg: any) => string>;

package/kernel/logger.ts

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