milkio 0.0.1

package/kernel/loongbao.ts

@@ -0,0 +1,269 @@
+/* eslint-disable no-console, @typescript-eslint/no-invalid-void-type, @typescript-eslint/await-thenable, @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any */
+import { type MiddlewareOptions, _middlewares, MiddlewareEvent } from "./middleware";
+import schema from "../../../generate/api-schema";
+import type { Context } from "../../../src/context";
+import { failCode } from "../../../src/fail-code";
+import type { FrameworkContext } from "./context";
+import { type Mixin, type ExecuteId, type Fail, type FailEnumerates, loggerPushTags, loggerSubmit, runtime, TSON, type Logger, useLogger } from "..";
+import { hanldeCatchError } from "../utils/handle-catch-error";
+import { _validate } from "./validate";
+import { cwd, exit } from "node:process";
+import { createUlid } from "../utils/create-ulid";
+
+export type LoongbaoAppOptions = {
+  /**
+   * bootstraps
+   * @description
+   * When Loongbao is launched, all methods in this array will run **in parallel**.
+   */
+  bootstraps?: () => Array</* This type is long, and its intention is to prevent someone from forgetting to add parentheses when adding bootstraps. Therefore, it allows all types except methods */ Promise<unknown> | void | string | number | boolean | null | undefined | Record<string | number | symbol, unknown> | Array<unknown>>;
+  /**
+   * middlewares
+   * @description
+   * When Loongbao is launched, the closer it is to the front of the array, the more it is on the outer layer of the "onion".
+   */
+  middlewares?: () => Array<MiddlewareOptions>;
+  /**
+   * maxRequest
+   * @description
+   * When the function runs for a long time, it is possible that the memory will continuously expand (not necessarily due to memory leaks, but also possibly due to having a large number of routes).
+   * Set a maximum number of requests, when the number of requests reaches this value, kill the process and automatically restart it from outside (K8S or whatever).
+   */
+  enableMaxRequestLimit?: number | null | undefined;
+  /**
+   * maxRunningTime (minutes)
+   * @description
+   * When the function runs for a long time, it is possible that the memory will continuously expand (not necessarily due to memory leaks, but also possibly due to having a large number of routes).
+   * Set the maximum running time (in minutes). When Loongbao's running time reaches this value, terminate the process and automatically restart it from outside (K8S or other means).
+   */
+  enableMaxRunningTimeoutLimit?: number | null | undefined;
+};
+
+export async function createLoongbaoApp(loongbaoAppOptions: LoongbaoAppOptions = {}) {
+  if (loongbaoAppOptions?.enableMaxRequestLimit && loongbaoAppOptions.enableMaxRequestLimit >= 1) {
+    runtime.maxRequest.expected = loongbaoAppOptions.enableMaxRequestLimit;
+    runtime.maxRequest.enable = true;
+  }
+
+  if (loongbaoAppOptions.enableMaxRunningTimeoutLimit && loongbaoAppOptions.enableMaxRunningTimeoutLimit >= 1) {
+    setTimeout(() => {
+      console.log('❌ Loongbao reached the limit of "maxRunningTimeout" in the options and automatically exited.');
+      exit(0);
+    }, loongbaoAppOptions.enableMaxRunningTimeoutLimit * 60 * 1000);
+    runtime.maxRunningTimeout.enable = true;
+  }
+
+  const loongbaoApp = {
+    execute: _execute,
+    executeToJson: _executeToJson,
+    _executeCore,
+    _executeCoreToJson
+  };
+
+  if (loongbaoAppOptions.bootstraps) {
+    await Promise.all(loongbaoAppOptions.bootstraps());
+  }
+
+  if (loongbaoAppOptions.middlewares) {
+    MiddlewareEvent.define("bootstrap", (a, b) => a.index - b.index);
+    MiddlewareEvent.define("beforeExecute", (a, b) => a.index - b.index);
+    MiddlewareEvent.define("afterExecute", (a, b) => b.index - a.index);
+    MiddlewareEvent.define("afterHTTPRequest", (a, b) => a.index - b.index);
+    MiddlewareEvent.define("beforeHTTPResponse", (a, b) => b.index - a.index);
+
+    const middlewares = loongbaoAppOptions.middlewares();
+
+    for (let index = 0; index < middlewares.length; index++) {
+      const middlewareOptions = middlewares[index];
+      for (const name in middlewareOptions) {
+        let middleware = _middlewares.get(name);
+        if (middleware === undefined) {
+          middleware = [];
+          _middlewares.set(name, middleware);
+        }
+        const id = createUlid();
+        middleware.push({ id, index, middleware: middlewareOptions[name] });
+      }
+    }
+    MiddlewareEvent._sort();
+
+    await MiddlewareEvent.handle("bootstrap", [loongbaoApp]);
+  }
+
+  console.log(`🧊 Loongbao is running on : ${cwd()}`);
+
+  return loongbaoApp;
+}
+
+async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options?: ExecuteOptions): Promise<ExecuteResult<Result>> {
+  const executeId = (options?.executeId ?? createUlid()) as ExecuteId;
+  const logger = useLogger(executeId);
+  runtime.execute.executeIds.add(executeId);
+
+  loggerPushTags(executeId, {
+    from: "execute",
+    executeId,
+    params,
+    path
+  });
+
+  const result: any = await _executeCore(path, params, headersInit, {
+    ...options,
+    executeId,
+    logger,
+    onAfterHeaders: (headers) => {
+      loggerPushTags(executeId, {
+        headers: headers.toJSON()
+      });
+    }
+  });
+
+  loggerPushTags(executeId, { result });
+  await loggerSubmit(executeId);
+  runtime.execute.executeIds.delete(executeId);
+
+  return result;
+}
+
+/**
+ * executeCore is a low-level API that is useful only when you want to execute the loongbao API without using execute or httpServer.
+ * It only does the most basic thing internally, which is calling the API. The external handling of functions such as making executeId, logging, middleware, etc., are all handled externally.
+ * Both execute and httpServer essentially call executeCore.
+ */
+async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options: ExecuteCoreOptions): Promise<ExecuteResult<Result>> {
+  const executeId = options.executeId as ExecuteId;
+
+  params = TSON.decode(params);
+
+  if (runtime.maxRequest.enable) {
+    if (runtime.maxRequest.counter >= runtime.maxRequest.expected) {
+      console.log("❌ Loongbao reached the limit of 'maxRequest' in the options and automatically exited.");
+      exit(0);
+    }
+    runtime.maxRequest.counter++;
+  }
+
+  if (!(path in schema.apiMethodsSchema)) {
+    const result = {
+      executeId,
+      success: false,
+      fail: {
+        code: "not-found",
+        message: failCode["not-found"](),
+        data: undefined
+      }
+    } satisfies ExecuteResult<Result>;
+
+    return result;
+  }
+
+  let headers: Headers;
+  if (!(headersInit instanceof Headers)) {
+    headers = new Headers({
+      ...headersInit
+    });
+  } else {
+    headers = headersInit;
+  }
+
+  if (options?.onAfterHeaders) {
+    await options.onAfterHeaders(headers);
+  }
+
+  const context: Context = {
+    executeId,
+    path,
+    headers,
+    logger: options.logger,
+    detail: options?.detail ?? {}
+  };
+
+  let result: { value: Result };
+  try {
+    // before execute middleware
+    await MiddlewareEvent.handle("beforeExecute", [context]);
+
+    // check type
+    // @ts-ignore
+    _validate(await (await schema.apiValidator.validate[path]()).params(params));
+
+    // execute api
+    let api: any;
+    if (apis.has(path)) api = apis.get(path);
+    else {
+      // @ts-ignore
+      api = schema.apiMethodsSchema[path]();
+      apis.set(path, api);
+    }
+    const apiModuleAwaited = await api.module;
+
+    const apiMethod = apiModuleAwaited.api.action;
+
+    // @ts-ignore
+    result = { value: await apiMethod(params, context) };
+
+    // after execute middleware
+    await MiddlewareEvent.handle("afterExecute", [context, result]);
+  } catch (error: any) {
+    const errorResult = hanldeCatchError(error, executeId);
+
+    return errorResult;
+  }
+
+  return {
+    executeId,
+    success: true,
+    data: result.value
+  };
+}
+
+async function _executeToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options?: ExecuteOptions): Promise<string> {
+  const resultsRaw = await _execute(path, params, headersInit, options);
+  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw));
+  return results;
+}
+
+async function _executeCoreToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options: ExecuteCoreOptions): Promise<string> {
+  const resultsRaw = await _executeCore(path, params, headersInit, options);
+  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw));
+  return results;
+}
+
+const apis = new Map<string, any>();
+
+export type ExecuteResult<Result> = ExecuteResultSuccess<Result> | ExecuteResultFail;
+
+export type ExecuteResultSuccess<Result> = {
+  executeId: ExecuteId;
+  success: true;
+  data: Result;
+};
+
+export type ExecuteResultFail<FailT extends Fail<keyof FailEnumerates> = Fail<keyof FailEnumerates>> = {
+  executeId: ExecuteId;
+  success: false;
+  fail: FailT;
+};
+
+export type ExecuteOptions = {
+  /**
+   * The executeId of the request
+   * executeId may be generated by the serverless provider, if not, a random string will be generated instead
+   */
+  executeId?: string;
+  /**
+   * 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?: FrameworkContext["detail"];
+};
+
+export type ExecuteCoreOptions = Mixin<
+  ExecuteOptions,
+  {
+    executeId: string;
+    logger: Logger;
+    onAfterHeaders?: (headers: Headers) => void | Promise<void>;
+  }
+>;

package/kernel/meta.ts

@@ -0,0 +1,9 @@
+import type { Meta } from "../../../src/meta";
+import schema from "../../../generate/api-schema";
+
+export async function useMeta(path: string): Promise<Meta> {
+  // @ts-ignore
+  const api = schema.apiMethodsSchema[path as keyof (typeof schema)["apiMethodsTypeSchema"]]();
+  const module = await api.module;
+  return module.api.meta;
+}

package/kernel/middleware.ts

@@ -0,0 +1,50 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument */
+
+import type { Context } from "../../../src/context";
+import type { FrameworkHTTPDetail } from "./context";
+import { type LoongbaoApp } from "loongbao";
+
+export type BootstrapMiddleware = (loongbao: LoongbaoApp) => Promise<void> | void;
+export type BeforeExecuteMiddleware = (context: Context) => Promise<void> | void;
+export type AfterExecuteMiddleware = (context: Context, response: { value: unknown }) => Promise<void> | void;
+export type AfterHTTPRequestMiddleware = (headers: Headers, detail: FrameworkHTTPDetail) => Promise<void> | void;
+export type BeforeHTTPResponseMiddleware = (response: { value: string }, detail: FrameworkHTTPDetail) => Promise<void> | void;
+export type MiddlewareOptions = {
+  bootstrap?: BootstrapMiddleware;
+  beforeExecute?: BeforeExecuteMiddleware;
+  afterExecute?: AfterExecuteMiddleware;
+  afterHTTPRequest?: AfterHTTPRequestMiddleware;
+  beforeHTTPResponse?: BeforeHTTPResponseMiddleware;
+} & Record<string, (...args: Array<any>) => Promise<void> | void>;
+export type MiddlewareFn = (...args: Array<any>) => Promise<void> | void;
+export type MiddlewareT<T extends MiddlewareFn = MiddlewareFn> = { id: string; index: number; middleware: T };
+
+export const _middlewareEvents = new Map<string, (a: MiddlewareT, b: MiddlewareT) => number>();
+export const _middlewares = new Map<string, Array<MiddlewareT>>();
+
+export const MiddlewareEvent = (() => {
+  const defineMiddlewareEvent = (name: string, sortFn: (a: MiddlewareT, b: MiddlewareT) => number) => {
+    _middlewareEvents.set(name, sortFn);
+  };
+
+  const sortMiddlewareEvent = () => {
+    for (const [key, middleware] of _middlewares) {
+      const sort = _middlewareEvents.get(key);
+      if (sort) middleware.sort(sort);
+    }
+  };
+
+  const handleMiddleware = async (name: string, args: Array<any> /* Parameters<MiddlewareOptions[Name]> */) => {
+    const mds = _middlewares.get(name);
+    if (!mds) return;
+    for (const md of mds) {
+      await md.middleware(...args);
+    }
+  };
+
+  return {
+    define: defineMiddlewareEvent,
+    handle: handleMiddleware,
+    _sort: sortMiddlewareEvent
+  };
+})();

package/kernel/runtime.ts

@@ -0,0 +1,16 @@
+import { type ExecuteId } from "..";
+
+export const runtime = {
+  execute: {
+    executeIds: new Set<ExecuteId>()
+  },
+  maxRequest: {
+    enable: false,
+    counter: 0,
+    expected: 0
+  },
+  maxRunningTimeout: {
+    enable: false,
+    expectedEndedAt: 0
+  }
+};

package/kernel/validate.ts

@@ -0,0 +1,13 @@
+import type { IValidation } from "typia";
+import { reject } from "../kernel/fail";
+
+export function _validate(validator: IValidation.IFailure | IValidation.ISuccess): void {
+  if (validator.success) return;
+  const error = validator.errors[0];
+
+  throw reject("general-type-safe-error", {
+    path: error.path,
+    expected: error.expected,
+    value: error.value
+  });
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "milkio",
+  "type": "module",
+  "module": "index.ts",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "typescript": "^5.4.2"
+  },
+  "dependencies": {
+    "@poech/camel-hump-under": "^1.1.0",
+    "@southern-aurora/tson": "2.0.2",
+    "ulidx": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "walk-sync": "^3.0.0",
+    "typia": "5.5.5",
+    "ejs": "^3.1.9",
+    "@types/ejs": "^3.1.5",
+    "@types/js-beautify": "^1.14.3",
+    "ts-patch": "^3.1.2",
+    "typescript": "^5.3.3"
+  }
+}

package/scripts/build-cookbook.ts

@@ -0,0 +1,233 @@
+/* eslint-disable no-console, @typescript-eslint/no-dynamic-delete */
+
+import { TSON, type Cookbook } from "..";
+import { join } from "node:path";
+import { cwd } from "node:process";
+import { writeFile, readFile } from "node:fs/promises";
+
+export async function buildCookbook() {
+  const schema = await import("../../../generate/api-schema");
+  const paths = Object.keys(schema.default.apiMethodsSchema);
+
+  const cookbook: Cookbook = {};
+  for (const path of paths) {
+    // const module = await import(/* @vite-ignore */ join(`../../../src/apps/${path}`));
+    const code = (await readFile(join(cwd(), `./src/apps/${path}.ts`))).toString();
+    const codeLines = code.split("\n");
+    let title;
+    let desc;
+    const descRaw = /\n\/\*\*\n[\s\S]+?\*\//.exec(code)?.[0] ?? "";
+
+    if (descRaw) {
+      const descRawLines = descRaw.split("\n");
+      if (descRawLines.at(0)?.trim() === "") descRawLines.shift();
+      if (descRawLines.at(-1)?.trim() === "") descRawLines.pop();
+      let first = true;
+      for (let index = 0; index < descRawLines.length; index++) {
+        const descRawLine = descRawLines[index].replace(/^[/ ]+?[*]*/, "").replace(/[*]*\/$/, "");
+
+        if (!descRawLine) continue;
+        if (first) {
+          title = descRawLine.replace(/#/g, "").trim();
+          // Originally the title was in the first line, desc is the rest of it, now desc contains complete markdown content.
+          // continue;
+        }
+        first = false;
+        desc = (desc ?? "") + "\n" + descRawLine.trim();
+      }
+    }
+
+    let apiParams = /action\([\s\S]+?\)/.exec(code)?.[0] ?? ""; // The intention of the following code is to extract the parameter part of the action.
+    apiParams = /\([\s\S]*,/.exec(apiParams)?.[0] ?? "";
+    apiParams = apiParams.slice(0, -1);
+    apiParams = apiParams.slice(/[\s\S]+?:/.exec(apiParams)?.[0].length);
+    const apiParamsLines = apiParams.split("\n"); // The intention of the following code is to remove extra spaces, which will make the code look more beautiful.
+    if (apiParamsLines.at(-1)?.trim() === "") apiParamsLines.pop();
+    if (apiParamsLines.at(-1)?.trim() === "") apiParamsLines.pop();
+    let spaceNumber = 0;
+    for (const char of apiParamsLines.at(-1) ?? "") {
+      if (char === " ") spaceNumber++;
+      else break;
+    }
+    for (let index = 0; index < apiParamsLines.length; index++) {
+      const line = apiParamsLines[index];
+      let spaceNumberForThisLine = 0;
+      for (const char of line) {
+        if (char === " ") spaceNumberForThisLine++;
+        else break;
+      }
+      if (spaceNumberForThisLine >= spaceNumber) {
+        apiParamsLines[index] = line.slice(spaceNumber);
+      } else {
+        apiParamsLines[index] = line.slice(spaceNumberForThisLine);
+      }
+    }
+    apiParams = apiParamsLines.join("\n");
+
+    // Find the code for the API testing section.
+    const apiTestsCodeChars = [];
+    let apiTestsStartIndex = undefined as undefined | number;
+    let semicolonMatch = 0;
+    let semicolonMax = 0;
+    for (let index = 0; index < codeLines.length; index++) {
+      const codeLine = codeLines[index];
+      if (apiTestsStartIndex === undefined && !codeLine.includes("defineApiTest(")) continue;
+      if (apiTestsStartIndex === undefined) apiTestsStartIndex = index;
+      const codeChars = codeLine.split("");
+      for (const codeChar of codeChars) {
+        if (codeChar === "[") {
+          semicolonMatch++;
+          semicolonMax++;
+        }
+        if (semicolonMatch !== 0) apiTestsCodeChars.push(codeChar);
+        if (codeChar === "]") semicolonMatch--;
+      }
+      if (semicolonMatch === 0 && semicolonMax >= 1) {
+        break;
+      }
+      apiTestsCodeChars.push("\n");
+    }
+
+    // Find the code for each API test case.
+    const apiCaseCodes: Array<string> = [];
+    let currentApiCaseCode = undefined as undefined | Array<string>;
+    let apiTestCaseStartIndex = undefined as undefined | number;
+    let apiTestCaseMatch = 0;
+    for (let index = 0; index < apiTestsCodeChars.length; index++) {
+      const apiTestsCodeChar = apiTestsCodeChars[index];
+      if (apiTestCaseStartIndex === undefined && apiTestsCodeChar === "{") {
+        currentApiCaseCode = [];
+        apiTestCaseStartIndex = index;
+      }
+      if (apiTestsCodeChar === "{") {
+        apiTestCaseMatch++;
+      }
+
+      if (apiTestCaseMatch !== 0) currentApiCaseCode!.push(apiTestsCodeChar);
+
+      if (apiTestsCodeChar === "}") {
+        apiTestCaseMatch--;
+        if (apiTestCaseMatch === 0) {
+          apiCaseCodes.push(currentApiCaseCode!.join(""));
+          currentApiCaseCode = undefined;
+          apiTestCaseStartIndex = undefined;
+        }
+      }
+    }
+
+    const apiCases: Array<{
+      name: string;
+      handler: string;
+    }> = [];
+
+    for (let index = 0; index < apiCaseCodes.length; index++) {
+      const code = apiCaseCodes[index];
+      const name = /name:[\s\S]+?,/.exec(code)?.[0]?.slice(5, -1)?.trim().slice(1, -1) ?? "";
+      const handlerChars = /handler:[\s\S]*/.exec(code)?.[0]?.split("") ?? [];
+      let handler = ""; // Find the main code of the handler.
+      let handlerStartIndex = undefined as undefined | number;
+      let handlerMatch = 0;
+      for (let index = 0; index < handlerChars.length; index++) {
+        const handlerChar = handlerChars[index];
+        if (handlerStartIndex !== undefined && handlerChar === "{") handlerStartIndex = index;
+        if (handlerChar === "{") handlerMatch++;
+        if (handlerMatch !== 0) handler = handler + handlerChar;
+        if (handlerChar === "}") handlerMatch--;
+        if (handlerStartIndex !== undefined && handlerMatch === 0) break;
+      }
+      handler = handler.slice(1, -1);
+
+      const handlerLines = handler.split("\n"); // The intention of the following code is to remove extra spaces, which will make the code look more beautiful.
+      if (handlerLines.at(-1)?.trim() === "") handlerLines.pop();
+      if (handlerLines.at(-1)?.trim() === "") handlerLines.pop();
+      if (handlerLines.at(0)?.trim() === "") handlerLines.shift();
+      if (handlerLines.at(0)?.trim() === "") handlerLines.shift();
+      let spaceNumber = 0;
+      for (const char of handlerLines.at(-1) ?? "") {
+        if (char === " ") spaceNumber++;
+        else break;
+      }
+      for (let index = 0; index < handlerLines.length; index++) {
+        const line = handlerLines[index];
+        let spaceNumberForThisLine = 0;
+        for (const char of line) {
+          if (char === " ") spaceNumberForThisLine++;
+          else break;
+        }
+        if (spaceNumberForThisLine >= spaceNumber) {
+          handlerLines[index] = line.slice(spaceNumber);
+        } else {
+          handlerLines[index] = line.slice(spaceNumberForThisLine);
+        }
+      }
+      handler = handlerLines.join("\n");
+
+      apiCases.push({
+        name,
+        handler
+      });
+    }
+
+    // This value has been deprecated because TypeScript types can already replace it well
+    // let paramsSchema;
+    // try {
+    //   const moduleGenerated = await import(/* @vite-ignore */ `../../../generate/products/apps/${path}`);
+    //   paramsSchema = moduleGenerated.paramsSchema.schemas[0]?.properties?.data;
+    // } catch (error) {}
+
+    cookbook[path] = {
+      title,
+      desc,
+      params: apiParams,
+      cases: apiCases
+    };
+  }
+
+  /**
+   * -- indexes
+   */
+
+  const indexes: Record<string, Array<string>> = {};
+  const folderIndexes: Record<string, Array<string>> = {};
+  indexes["(root)"] = [];
+  folderIndexes["(root)"] = [];
+  for (const path in cookbook) {
+    if (!path.includes("/")) indexes["(root)"].push(path);
+  }
+  for (const path in cookbook) {
+    const dirnames = path.split("/");
+    for (let index = 0; index < dirnames.length - 1; index++) {
+      const dirpath = dirnames.slice(0, index + 1).join("/");
+      if (!indexes[dirpath]) indexes[dirpath] = [];
+      if (!folderIndexes[dirpath]) folderIndexes[dirpath] = [];
+      if (index + 1 === dirnames.length - 1) {
+        indexes[dirpath].push(path);
+      } else {
+        const childDirpath = dirnames.slice(0, index + 2).join("/");
+        if (folderIndexes[dirpath].includes(childDirpath)) continue;
+        folderIndexes[dirpath].push(childDirpath);
+      }
+    }
+  }
+  for (const path in folderIndexes) {
+    if (path.includes("/") || path === "(root)") continue;
+    folderIndexes["(root)"].push(path);
+  }
+
+  const readme = (await readFile(join(cwd(), "src", "apps", "README.md"))).toString();
+  Object.keys(indexes).forEach((key) => indexes[key].length === 0 && delete indexes[key]);
+  const generatedAt = new Date();
+
+  await writeFile(
+    join(cwd(), `./generate/cookbook.json`),
+    TSON.stringify({
+      cookbook,
+      readme,
+      indexes,
+      folderIndexes,
+      generatedAt
+    })
+  );
+}
+
+void buildCookbook();

package/scripts/build-dto.ts

@@ -0,0 +1,65 @@
+/* eslint-disable no-console */
+import { cwd, platform } from "node:process";
+import { exec as nodeExec } from "node:child_process";
+import { removeDir } from "../utils/remove-dir";
+import { join } from "node:path";
+import { copyFile, mkdir } from "node:fs/promises";
+
+export async function buildDTO() {
+  console.log("🧊 Loongbao DTO Building..");
+
+  removeDir(join(cwd(), "packages", "dto", "dist"));
+  removeDir(join(cwd(), "packages", "dto", "generate"));
+  await mkdir(join(cwd(), "packages", "dto", "dist"));
+  await mkdir(join(cwd(), "packages", "dto", "generate"));
+
+  // Generate the corresponding types for the files in the project and output them to the /packages/dto/generate directory.
+  await new Promise((resolve) =>
+    nodeExec("bun ./node_modules/typescript/bin/tsc --project tsconfig.build-dto.json", (e, stdout) => {
+      resolve(e);
+    })
+  );
+  await copyFile(join(cwd(), "src", "fail-code.ts"), join(cwd(), "packages", "dto", "generate", "src", "fail-code.ts"));
+
+  // Packaging type for the dto
+  await new Promise((resolve) =>
+    nodeExec("cd ./packages/dto && bunx tsc", (e) => {
+      resolve(e);
+    })
+  );
+
+  // build /src/dto/index.ts to js
+  await Bun.build({
+    entrypoints: ["./packages/dto/index.ts"],
+    outdir: "./packages/dto"
+  });
+
+  const root = join(cwd(), "packages", "dto");
+
+  console.log("🧊 Loongbao DTO Build Finished");
+  console.log("\x1B[2m");
+  console.log("Now, your latest code (including changes to your interface) is built to the latest version and waiting for your release!");
+  console.log("");
+  console.log("If you want to publish it to NPM, you can use a command similar to the following.");
+  console.log(`(But before that, you may need to modify the package name (${join(cwd(), "packages", "dto", "package.json")}) and login to your NPM account or private NPM repository)`);
+
+  if (platform !== "win32") {
+    console.log("You can publish it to npm by running this commands:\n");
+    console.log("\u001B[0m---");
+    console.log(`cd ${join(root)} \\`);
+    console.log("  && npm version major \\");
+    console.log("  && npm publish --access public \\");
+    console.log(`  && cd ${join(cwd())}`);
+  } else {
+    console.log("You can publish it to npm by running this commands (use \x1B[42mPowerShell\x1B[0m):");
+    console.log("\u001B[0m---");
+    console.log('$ErrorActionPreference = "Stop";');
+    console.log(`Set-Location ${join(root)};`);
+    console.log("npm version major;");
+    console.log("npm publish --access public;");
+    console.log(`Set-Location ${join(cwd())};`);
+  }
+  console.log("---");
+}
+
+await buildDTO();