milkio 0.0.2 → 0.0.3

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

@@ -1,9 +1,9 @@
 /* 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 milkioApp } from "..";
+import { type MilkioApp } from "..";
 
-export const defineApiTestHandler = async <Paths extends Array<keyof (typeof schema)["apiTestsSchema"]>>(app: milkioApp, paths: Paths | string | 1 | undefined) => {
+export const defineApiTestHandler = async <Paths extends Array<keyof (typeof schema)["apiTestsSchema"]>>(app: MilkioApp, paths: Paths | string | 1 | undefined) => {
   console.log(`🧊 Milkio Api Testing..\n`);
 
   if (!paths) {

package/defines/define-http-handler.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
 import { configFramework, loggerPushTags, loggerSubmit, useLogger, loggerSubmitAll, runtime, MiddlewareEvent } from "..";
-import type { ExecuteId, milkioApp, Mixin } 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";
@@ -20,7 +20,7 @@ export type ExecuteHttpServerOptions = {
   executeIdGenerator?: (request: Request) => string | Promise<string>;
 };
 
-export function defineHttpHandler(app: milkioApp, options: 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.
@@ -92,7 +92,7 @@ export function defineHttpHandler(app: milkioApp, options: ExecuteHttpServerOpti
           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,

package/kernel/context.ts

@@ -1,7 +1,7 @@
 import type { URL } from "node:url";
 import type { ExecuteId, Logger, milkioHTTPResponse } from "..";
 
-export type FrameworkContext = {
+export type MilkioContext = {
   path: string;
   executeId: ExecuteId;
   headers: Headers;

package/kernel/fail.ts

@@ -19,4 +19,4 @@ export function reject<Code extends keyof typeof failCode, FailData extends (typ
 export type milkioReject = ReturnType<typeof reject>;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type milkioFailCode = Record<string, (arg: any) => string>;
+export type MilkioFailCode = Record<string, (arg: any) => string>;

package/kernel/middleware.ts

@@ -2,9 +2,9 @@
 
 import type { Context } from "../../../src/context";
 import type { FrameworkHTTPDetail } from "./context";
-import { type milkioApp } from "milkio";
+import { type MilkioApp } from "milkio";
 
-export type BootstrapMiddleware = (milkio: milkioApp) => Promise<void> | void;
+export type BootstrapMiddleware = (milkio: MilkioApp) => 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;

package/kernel/milkio.ts

@@ -3,14 +3,14 @@ import { type MiddlewareOptions, _middlewares, MiddlewareEvent } from "./middlew
 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 { MilkioContext } 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 milkioAppOptions = {
+export type MilkioAppOptions = {
   /**
    * bootstraps
    * @description
@@ -39,39 +39,39 @@ export type milkioAppOptions = {
   enableMaxRunningTimeoutLimit?: number | null | undefined;
 };
 
-export async function createMilkioApp(milkioAppOptions: milkioAppOptions = {}) {
-  if (milkioAppOptions?.enableMaxRequestLimit && milkioAppOptions.enableMaxRequestLimit >= 1) {
-    runtime.maxRequest.expected = milkioAppOptions.enableMaxRequestLimit;
+export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
+  if (MilkioAppOptions?.enableMaxRequestLimit && MilkioAppOptions.enableMaxRequestLimit >= 1) {
+    runtime.maxRequest.expected = MilkioAppOptions.enableMaxRequestLimit;
     runtime.maxRequest.enable = true;
   }
 
-  if (milkioAppOptions.enableMaxRunningTimeoutLimit && milkioAppOptions.enableMaxRunningTimeoutLimit >= 1) {
+  if (MilkioAppOptions.enableMaxRunningTimeoutLimit && MilkioAppOptions.enableMaxRunningTimeoutLimit >= 1) {
     setTimeout(() => {
       console.log('❌ milkio reached the limit of "maxRunningTimeout" in the options and automatically exited.');
       exit(0);
-    }, milkioAppOptions.enableMaxRunningTimeoutLimit * 60 * 1000);
+    }, MilkioAppOptions.enableMaxRunningTimeoutLimit * 60 * 1000);
     runtime.maxRunningTimeout.enable = true;
   }
 
-  const milkioApp = {
+  const MilkioApp = {
     execute: _execute,
     executeToJson: _executeToJson,
     _executeCore,
     _executeCoreToJson
   };
 
-  if (milkioAppOptions.bootstraps) {
-    await Promise.all(milkioAppOptions.bootstraps());
+  if (MilkioAppOptions.bootstraps) {
+    await Promise.all(MilkioAppOptions.bootstraps());
   }
 
-  if (milkioAppOptions.middlewares) {
+  if (MilkioAppOptions.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 = milkioAppOptions.middlewares();
+    const middlewares = MilkioAppOptions.middlewares();
 
     for (let index = 0; index < middlewares.length; index++) {
       const middlewareOptions = middlewares[index];
@@ -87,12 +87,12 @@ export async function createMilkioApp(milkioAppOptions: milkioAppOptions = {}) {
     }
     MiddlewareEvent._sort();
 
-    await MiddlewareEvent.handle("bootstrap", [milkioApp]);
+    await MiddlewareEvent.handle("bootstrap", [MilkioApp]);
   }
 
   console.log(`🧊 Milkio is running on : ${cwd()}`);
 
-  return milkioApp;
+  return MilkioApp;
 }
 
 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>> {
@@ -148,8 +148,8 @@ async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSc
       executeId,
       success: false,
       fail: {
-        code: "not-found",
-        message: failCode["not-found"](),
+        code: "NOT_FOUND",
+        message: failCode["NOT_FOUND"](),
         data: undefined
       }
     } satisfies ExecuteResult<Result>;
@@ -257,7 +257,7 @@ export type ExecuteOptions = {
    * 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"];
+  detail?: MilkioContext["detail"];
 };
 
 export type ExecuteCoreOptions = Mixin<

package/kernel/validate.ts

@@ -5,7 +5,7 @@ export function _validate(validator: IValidation.IFailure | IValidation.ISuccess
   if (validator.success) return;
   const error = validator.errors[0];
 
-  throw reject("general-type-safe-error", {
+  throw reject("PARAMS_TYPE_ERROR", {
     path: error.path,
     expected: error.expected,
     value: error.value

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/types.ts

@@ -3,7 +3,7 @@
 import { type createMilkioApp } from ".";
 import type { failCode } from "../../src/fail-code";
 
-export type milkioApp = Awaited<ReturnType<typeof createMilkioApp>>;
+export type MilkioApp = Awaited<ReturnType<typeof createMilkioApp>>;
 
 export type ExecuteId = string | "global";
 
@@ -19,7 +19,7 @@ export type Fail<FailCode extends keyof FailEnumerates> = {
   data: Parameters<FailEnumerates[FailCode]>[0];
 };
 
-export type milkioMeta = {
+export type MilkioMeta = {
   //
 };
 

package/utils/handle-catch-error.ts

@@ -11,14 +11,14 @@ export function hanldeCatchError(error: any, executeId: ExecuteId): ExecuteResul
 
   if (error.name !== "milkioReject") {
     // If it is not milkioReject, it is considered an internal server error that should not be exposed
-    logger.error(`FailCode: internal-server-error`);
+    logger.error(`FailCode: INTERNAL_SERVER_ERROR`);
 
     return {
       executeId,
       success: false,
       fail: {
-        code: "internal-server-error",
-        message: failCode["internal-server-error"](),
+        code: "INTERNAL_SERVER_ERROR",
+        message: failCode["INTERNAL_SERVER_ERROR"](),
         data: undefined
       }
     };