milkio 0.0.10 → 0.0.11

package/api-test/index.ts

@@ -0,0 +1,64 @@
+/* eslint-disable no-constant-condition, @typescript-eslint/no-unsafe-argument, no-console, @typescript-eslint/no-explicit-any */
+
+import schema from "../../../generated/api-schema"
+import { type MilkioApp } from ".."
+
+export const executeApiTests = async <Path extends Array<keyof (typeof schema)["apiTestsSchema"]>>(app: MilkioApp, path: Path | string | true | 1 | undefined) => {
+  console.log(`🥛 Milkio Api Testing..\n`)
+  
+  let pathArr = [] as Array<string>
+  if (!path || path === "1" || path === 1 || path === true) {
+    pathArr = Object.keys(schema.apiTestsSchema) as unknown as Path
+  } else if (typeof path === "string") {
+    pathArr = [path] as Path
+  }
+  
+  const tests = []
+  const startedAt = new Date().getTime()
+  
+  for (let path of pathArr) {
+    if (path.startsWith("/")) path = path.slice(1) as Path[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 ?? 8192}ms`)
+            console.error(`   ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i}`)
+            console.error(`------`)
+            throw new Error("")
+          }, cs.timeout ?? 8192)
+          await cs.handler({
+            // @ts-ignore
+            execute: async (params: any, headers?: any, options?: any) => app.execute(path, params, headers ?? {}, options),
+            executeOther: async (path: any, 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(`------`)
+              throw new Error("")
+            }
+          } as any)
+          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(`🥛 Milkio Api Testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`)
+}

package/c.ts

@@ -1,73 +1,55 @@
 #!/usr/bin/env bun
 
-/* eslint-disable @typescript-eslint/no-misused-promises, no-console, @typescript-eslint/no-explicit-any */
+/* eslint-disable no-constant-condition, @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";
+import { argv, exit } from "node:process"
+import process from "process"
+import { $ } from "bun"
 
-const rootPath = cwd();
-const method = argv[2] as keyof typeof commands;
-const params = argv.slice(3) as Parameters<(typeof commands)[keyof typeof commands]>;
+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/milkio/scripts/generate.ts"]);
+    console.log("🥛 Milkio Generating..\n")
+    await (await import('./scripts/gen-significant')).default()
+    await (await import('./scripts/gen-insignificant')).default()
+    console.log("\n✅ Milkio Generated!")
   },
-  async "gen:database"() {
-    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/generate-database.ts"]);
+  async "gen:significant"() {
+    console.log("🥛 Milkio Significant Generating..\n")
+    await (await import('./scripts/gen-significant')).default()
+    console.log("\n✅ Milkio Significant Generated!")
   },
-  async "build:cookbook"() {
-    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/build-cookbook.ts"]);
+  async "gen:insignificant"() {
+    console.log("🥛 Milkio Insignificant Generating..\n")
+    await (await import('./scripts/gen-insignificant')).default()
+    console.log("\n✅ Milkio Insignificant Generated!")
   },
-  async "build:dto"() {
-    await exec(join(rootPath, "packages", "dto"), ["bun", "i"]);
-    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/generate.ts"]);
-    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/build-dto.ts"]);
+  // async "build:cookbook"() {
+  //   await exec(rootPath, ["bun", "./node_modules/milkio/scripts/build-cookbook.ts"])
+  // },
+  // async "build:dto"() {
+  //   await exec(join(rootPath, "packages", "dto"), ["bun", "i"])
+  //   await exec(rootPath, ["bun", "./node_modules/milkio/scripts/generate.ts"])
+  //   await exec(rootPath, ["bun", "./node_modules/milkio/scripts/build-dto.ts"])
+  // },
+  async EAR(commandBase64ed: string) {
+    try { await $`clear` } catch (e) {}
+    const command = Buffer.from(commandBase64ed, 'base64').toString('utf-8')
+    await $`${{ raw: command }}`
+    process.on('SIGINT', () => {}) // prevent users from exiting by pressing ctrl + c
+    while (true) await new Promise((resolve) => process.stdin.on('keypress', resolve))
   },
-  async test(files?: string, reserved?: string) {
-    const run = async () => {
-      const packageJson = await JSON.parse((await readFile(join(rootPath, "package.json"))).toString());
-      await $`${{ raw: packageJson.scripts.start }}`.env({
-        ...env,
-        MILKIO_RUN_MODE: "API_TEST",
-        MILKIO_TEST: files ?? "1"
-      });
-    };
-    if (!env.MILKIO_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);
+  console.log("Command does not exist, Supported commands are:")
+  console.log("  " + Object.keys(commands).join(", "))
+  exit(1)
 }
 
-await commands[method](...params);
+// @ts-ignore
+await commands[method](...params)
 
-exit(0);
+exit(0)

package/defines/define-api-test.ts

@@ -1,11 +1,11 @@
-import { type Api, type ExecuteResult, type ExecuteOptions } from "..";
-import type schema from "../../../generate/api-schema";
+import { type Api, type ExecuteResult, type ExecuteOptions } from ".."
+import type schema from "../../../generated/api-schema"
 
 export function defineApiTest<ApiT extends Api>(_api: ApiT, cases: Array<ApiTestCases<ApiT>>) {
   return {
     getCases: () => cases,
     isApiTest: true
-  };
+  }
 }
 
 export type ApiTestCases<ApiT extends Api> = {

package/defines/define-api.ts

@@ -1,11 +1,11 @@
-import type { Meta } from "../../../src/meta";
-import type { Context } from "../../../src/context";
+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 = {

package/defines/define-http-handler.ts

@@ -1,13 +1,13 @@
 /* eslint-disable no-console */
-import { configMilkio, loggerPushTags, loggerSubmit, useLogger, loggerSubmitAll, runtime, MiddlewareEvent } from "..";
-import type { ExecuteId, MilkioApp, 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";
+import { loggerPushTags, loggerSubmit, useLogger, runtime, MiddlewareEvent } from ".."
+import type { ExecuteId, MilkioApp, Mixin } from ".."
+import { hanldeCatchError } from "../utils/handle-catch-error"
+import { routerHandler } from "../../../src/router"
+import schema from "../../../generated/api-schema"
+import { failCode } from "../../../src/fail-code"
+import { TSON } from "@southern-aurora/tson"
+import { createUlid } from "../utils/create-ulid"
+import { configMilkio } from "../../../src/apps/config/milkio"
 
 export type ExecuteHttpServerOptions = {
   /**
@@ -21,34 +21,23 @@ export type ExecuteHttpServerOptions = {
 };
 
 export function defineHttpHandler(app: MilkioApp, 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: MilkioHTTPRequest) => {
-    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;
+    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,
+      // @ts-ignore
       requestHeaders: request.request.headers.toJSON(),
       timein: new Date().getTime()
-    });
+    })
 
     const response: MilkioHTTPResponse = {
       body: "",
@@ -59,13 +48,13 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
         "Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
         "Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*"
       }
-    };
+    }
 
     try {
       // Process OPTIONS pre inspection requests
       if (request.request.method === "OPTIONS") {
-        await loggerSubmit(executeId);
-        runtime.execute.executeIds.delete(executeId);
+        await loggerSubmit(executeId)
+        runtime.execute.executeIds.delete(executeId)
 
         return new Response("", {
           headers: {
@@ -73,44 +62,45 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
             "Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
             "Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*"
           }
-        });
+        })
       }
 
-      let path = fullurl.pathname.substring(1).split("/");
+      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 (configMilkio.ignorePathLevel !== 0) path = path.slice(configMilkio.ignorePathLevel);
+      if (configMilkio.ignorePathLevel !== 0) path = path.slice(configMilkio.ignorePathLevel)
 
-      let pathstr = path.join("/") as keyof (typeof schema)["apiMethodsSchema"];
+      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);
+        // @ts-ignore
+        const redirectPath = await routerHandler(pathstr, fullurl)
         if (!redirectPath) {
-          const rawbody = await request.request.text();
+          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())}}}`;
+          })
+          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);
+          await loggerSubmit(executeId)
+          runtime.execute.executeIds.delete(executeId)
 
-          return new Response(response.body, response);
+          return new Response(response.body, response)
         }
-        pathstr = redirectPath as typeof pathstr;
+        pathstr = redirectPath as typeof pathstr
       }
 
       loggerPushTags(executeId, {
         path: pathstr
-      });
+      })
 
       const detail = {
         path: pathstr,
@@ -119,56 +109,57 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
         fullurl,
         request: request.request,
         response
-      };
+      }
 
       // execute api
       // after request middleware
-      await MiddlewareEvent.handle("afterHTTPRequest", [headers, detail]);
+      await MiddlewareEvent.handle("afterHTTPRequest", [headers, detail])
 
-      const rawbody = await request.request.text();
+      const rawbody = await request.request.text()
       loggerPushTags(executeId, {
         body: rawbody || "no body"
-      });
+      })
 
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      let params: any;
+      let params: any
       if (rawbody === "") {
-        params = undefined;
+        params = undefined
       } else {
         try {
-          params = JSON.parse(rawbody);
+          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;
+          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
+      // @ts-ignore
       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}`;
+      response.body = `${response.body ?? ""}${result}`
 
       // before response middleware
       const middlewareResponse = {
         value: response.body
-      };
-      await MiddlewareEvent.handle("beforeHTTPResponse", [middlewareResponse, detail]);
+      }
+      await MiddlewareEvent.handle("beforeHTTPResponse", [middlewareResponse, detail])
 
-      response.body = middlewareResponse.value;
+      response.body = middlewareResponse.value
     } catch (error) {
-      const result = hanldeCatchError(error, executeId);
-      response.body = TSON.stringify(result);
+      const result = hanldeCatchError(error, executeId)
+      response.body = TSON.stringify(result)
     }
 
     loggerPushTags(executeId, {
@@ -177,15 +168,15 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
       // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
       body: response.body || "",
       timeout: new Date().getTime()
-    });
+    })
 
-    await loggerSubmit(executeId);
-    runtime.execute.executeIds.delete(executeId);
+    await loggerSubmit(executeId)
+    runtime.execute.executeIds.delete(executeId)
 
-    return new Response(response.body, response);
-  };
+    return new Response(response.body, response)
+  }
 
-  return fetch;
+  return fetch
 }
 
 export type MilkioHTTPRequest = {

package/defines/define-middleware.ts

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

package/defines/define-use.ts

@@ -1,13 +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;
+  let use: any | undefined
 
   const getUse = async () => {
     if (use === undefined) {
-      use = await creatorFn();
+      use = await creatorFn()
     }
-    return use;
-  };
+    return use
+  }
 
-  return getUse;
-};
+  return getUse
+}

package/index.ts

@@ -1,33 +1,34 @@
 // types
-export * from "./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";
+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";
+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";
+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-api-test-handler";
+export * from "./defines/define-http-handler"
+
+// api test
+export * from "./api-test/index"
 
 // milkio
-export * from "./kernel/milkio";
+export * from "./kernel/milkio"

package/kernel/context.ts

@@ -1,5 +1,4 @@
-import type { URL } from "node:url";
-import type { ExecuteId, Logger, MilkioHTTPResponse } from "..";
+import type { ExecuteId, Logger, MilkioHTTPResponse } from ".."
 
 export type MilkioContext = {
   path: string;

package/kernel/fail.ts

@@ -1,19 +1,19 @@
-import { failCode } from "../../../src/fail-code";
+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 message = failCode[code]?.(data as any) ?? ""
   const error = {
     name: "MilkioReject",
     code,
     message,
     data,
     stack: ""
-  };
-  Error.captureStackTrace(error);
-  error.stack = error.stack.replace(/\n.*\n/, "\n");
+  }
+  Error.captureStackTrace(error)
+  error.stack = error.stack.replace(/\n.*\n/, "\n")
 
-  return error;
+  return error
 }
 
 export type MilkioReject = ReturnType<typeof reject>;