milkio 0.0.1 → 0.0.3

package/c.ts

@@ -14,18 +14,18 @@ const params = argv.slice(3) as Parameters<(typeof commands)[keyof typeof comman
 
 const commands = {
   async gen() {
-    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/generate.ts"]);
+    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/generate.ts"]);
   },
   async "gen:database"() {
-    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/generate-database.ts"]);
+    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/generate-database.ts"]);
   },
   async "build:cookbook"() {
-    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/build-cookbook.ts"]);
+    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/loongbao/scripts/generate.ts"]);
-    await exec(rootPath, ["bun", "./node_modules/loongbao/scripts/build-dto.ts"]);
+    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/generate.ts"]);
+    await exec(rootPath, ["bun", "./node_modules/milkio/scripts/build-dto.ts"]);
   },
   async test(files?: string, reserved?: string) {
     const run = async () => {
@@ -34,19 +34,19 @@ const commands = {
       // Therefore, temporarily switch to another implementation.
       // await $`${{ raw: packageJson.scripts.start }}`.env({
       //   ...env,
-      //   LOONGBAO_RUN_MODE: "API_TEST",
-      //   LOONGBAO_TEST: files ?? "1"
+      //   milkio_RUN_MODE: "API_TEST",
+      //   milkio_TEST: files ?? "1"
       // });
       //
       await exec(rootPath, ["bash", "-c", packageJson.scripts.start as string], {
         env: {
           ...env,
-          LOONGBAO_RUN_MODE: "API_TEST",
-          LOONGBAO_TEST: files ?? "1"
+          milkio_RUN_MODE: "API_TEST",
+          milkio_TEST: files ?? "1"
         }
       });
     };
-    if (!env.LOONGBAO_TEST_RESERVED && reserved !== "1") {
+    if (!env.milkio_TEST_RESERVED && reserved !== "1") {
       // Normal test
       await run();
     } else {

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

@@ -1,10 +1,10 @@
 /* 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 "..";
+import { type MilkioApp } 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`);
+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) {
     console.log("🧊 No paths specified.");
@@ -65,6 +65,6 @@ export const defineApiTestHandler = async <Paths extends Array<keyof (typeof sch
   const endedAt = new Date().getTime();
 
   console.log(`\n✅ All tests passed.`);
-  console.log(`🧊 Loongbao Api Testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`);
+  console.log(`🧊 Milkio Api Testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`);
   exit(0);
 };

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, LoongbaoApp, 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: LoongbaoApp, 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.
@@ -33,7 +33,7 @@ export function defineHttpHandler(app: LoongbaoApp, options: ExecuteHttpServerOp
     exit(1);
   });
 
-  const fetch = async (request: LoongbaoHTTPRequest) => {
+  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);
@@ -50,7 +50,7 @@ export function defineHttpHandler(app: LoongbaoApp, options: ExecuteHttpServerOp
       timein: new Date().getTime()
     });
 
-    const response: LoongbaoHTTPResponse = {
+    const response: milkioHTTPResponse = {
       body: "",
       status: 200,
       headers: {
@@ -92,7 +92,7 @@ export function defineHttpHandler(app: LoongbaoApp, options: ExecuteHttpServerOp
           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,
@@ -188,11 +188,11 @@ export function defineHttpHandler(app: LoongbaoApp, options: ExecuteHttpServerOp
   return fetch;
 }
 
-export type LoongbaoHTTPRequest = {
+export type milkioHTTPRequest = {
   request: Request;
 };
 
-export type LoongbaoHTTPResponse = Mixin<
+export type milkioHTTPResponse = Mixin<
   ResponseInit,
   {
     //

package/index.ts

@@ -29,5 +29,5 @@ export * from "./kernel/middleware";
 export * from "./defines/define-http-handler";
 export * from "./defines/define-api-test-handler";
 
-// loongbao
-export * from "./kernel/loongbao";
+// milkio
+export * from "./kernel/milkio";

package/kernel/config.ts

@@ -4,8 +4,8 @@ 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, ""),
+  milkioRunMode: envToString(env.milkio_RUN_MODE, "DEFAULT"),
+  milkioTest: envToString(env.milkio_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),

package/kernel/context.ts

@@ -1,7 +1,7 @@
 import type { URL } from "node:url";
-import type { ExecuteId, Logger, LoongbaoHTTPResponse } from "..";
+import type { ExecuteId, Logger, milkioHTTPResponse } from "..";
 
-export type FrameworkContext = {
+export type MilkioContext = {
   path: string;
   executeId: ExecuteId;
   headers: Headers;
@@ -20,5 +20,5 @@ export type FrameworkHTTPDetail = {
   fullurl: URL;
   ip: string;
   request: Request;
-  response: LoongbaoHTTPResponse;
+  response: milkioHTTPResponse;
 };

package/kernel/fail.ts

@@ -4,7 +4,7 @@ export function reject<Code extends keyof typeof failCode, FailData extends (typ
   // 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",
+    name: "milkioReject",
     code,
     message,
     data,
@@ -16,7 +16,7 @@ export function reject<Code extends keyof typeof failCode, FailData extends (typ
   return error;
 }
 
-export type LoongbaoReject = ReturnType<typeof reject>;
+export type milkioReject = ReturnType<typeof reject>;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type LoongbaoFailCode = 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 LoongbaoApp } from "loongbao";
+import { type MilkioApp } from "milkio";
 
-export type BootstrapMiddleware = (loongbao: LoongbaoApp) => 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/{loongbao.ts → milkio.ts}

@@ -3,24 +3,24 @@ 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 LoongbaoAppOptions = {
+export type MilkioAppOptions = {
   /**
    * bootstraps
    * @description
-   * When Loongbao is launched, all methods in this array will run **in parallel**.
+   * When Milkio 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".
+   * When Milkio 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>;
   /**
@@ -34,44 +34,44 @@ export type LoongbaoAppOptions = {
    * 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).
+   * Set the maximum running time (in minutes). When milkio'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;
+export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
+  if (MilkioAppOptions?.enableMaxRequestLimit && MilkioAppOptions.enableMaxRequestLimit >= 1) {
+    runtime.maxRequest.expected = MilkioAppOptions.enableMaxRequestLimit;
     runtime.maxRequest.enable = true;
   }
 
-  if (loongbaoAppOptions.enableMaxRunningTimeoutLimit && loongbaoAppOptions.enableMaxRunningTimeoutLimit >= 1) {
+  if (MilkioAppOptions.enableMaxRunningTimeoutLimit && MilkioAppOptions.enableMaxRunningTimeoutLimit >= 1) {
     setTimeout(() => {
-      console.log('❌ Loongbao reached the limit of "maxRunningTimeout" in the options and automatically exited.');
+      console.log('❌ milkio reached the limit of "maxRunningTimeout" in the options and automatically exited.');
       exit(0);
-    }, loongbaoAppOptions.enableMaxRunningTimeoutLimit * 60 * 1000);
+    }, MilkioAppOptions.enableMaxRunningTimeoutLimit * 60 * 1000);
     runtime.maxRunningTimeout.enable = true;
   }
 
-  const loongbaoApp = {
+  const MilkioApp = {
     execute: _execute,
     executeToJson: _executeToJson,
     _executeCore,
     _executeCoreToJson
   };
 
-  if (loongbaoAppOptions.bootstraps) {
-    await Promise.all(loongbaoAppOptions.bootstraps());
+  if (MilkioAppOptions.bootstraps) {
+    await Promise.all(MilkioAppOptions.bootstraps());
   }
 
-  if (loongbaoAppOptions.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 = loongbaoAppOptions.middlewares();
+    const middlewares = MilkioAppOptions.middlewares();
 
     for (let index = 0; index < middlewares.length; index++) {
       const middlewareOptions = middlewares[index];
@@ -87,12 +87,12 @@ export async function createLoongbaoApp(loongbaoAppOptions: LoongbaoAppOptions =
     }
     MiddlewareEvent._sort();
 
-    await MiddlewareEvent.handle("bootstrap", [loongbaoApp]);
+    await MiddlewareEvent.handle("bootstrap", [MilkioApp]);
   }
 
-  console.log(`🧊 Loongbao is running on : ${cwd()}`);
+  console.log(`🧊 Milkio is running on : ${cwd()}`);
 
-  return loongbaoApp;
+  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>> {
@@ -126,7 +126,7 @@ async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema
 }
 
 /**
- * executeCore is a low-level API that is useful only when you want to execute the loongbao API without using execute or httpServer.
+ * executeCore is a low-level API that is useful only when you want to execute the Milkio 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.
  */
@@ -137,7 +137,7 @@ async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSc
 
   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.");
+      console.log("❌ milkio reached the limit of 'maxRequest' in the options and automatically exited.");
       exit(0);
     }
     runtime.maxRequest.counter++;
@@ -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>;
@@ -185,6 +185,7 @@ async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSc
 
     // check type
     // @ts-ignore
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     _validate(await (await schema.apiValidator.validate[path]()).params(params));
 
     // execute api
@@ -256,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.1",
+  "version": "0.0.3",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/scripts/build-dto.ts

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { copyFile, mkdir } from "node:fs/promises";
 
 export async function buildDTO() {
-  console.log("🧊 Loongbao DTO Building..");
+  console.log("🧊 milkio DTO Building..");
 
   removeDir(join(cwd(), "packages", "dto", "dist"));
   removeDir(join(cwd(), "packages", "dto", "generate"));
@@ -36,7 +36,7 @@ export async function buildDTO() {
 
   const root = join(cwd(), "packages", "dto");
 
-  console.log("🧊 Loongbao DTO Build Finished");
+  console.log("🧊 milkio 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("");

package/scripts/generate/generate-app-partial.ts

@@ -53,7 +53,7 @@ export async function generateAppPartial(path?: string) {
   importPath = importPath + "src/apps";
   const template = `
 import typia from "typia";
-import { _validate, type ExecuteResultSuccess } from "loongbao";
+import { _validate, type ExecuteResultSuccess } from "milkio";
 import { type TSONEncode } from "@southern-aurora/tson";
 import type * as <%= utils.camel(path.slice(0, -3).replaceAll('/', '$')) %> from '${importPath}/<%= path.slice(0, -3) %>';
 

package/scripts/generate/generate-app.ts

@@ -21,7 +21,7 @@ export async function generateApp() {
   } catch (error) {} // Maybe the file does not exist
 
   if (!existsSync(join("generate", "README.md"))) {
-    await writeFile(join("generate", "README.md"), "⚠️ All files in this directory are generated by Loongbao. Please do not modify the content, otherwise your modifications will be overwritten in the next generation.");
+    await writeFile(join("generate", "README.md"), "⚠️ All files in this directory are generated by milkio. Please do not modify the content, otherwise your modifications will be overwritten in the next generation.");
   }
 
   // Write a basic framework to ensure that there are no errors when reading later
@@ -81,7 +81,7 @@ export async function generateApp() {
       importPath = importPath + "src/apps";
       const template = `
 import typia from "typia";
-import { _validate, type ExecuteResultSuccess } from "loongbao";
+import { _validate, type ExecuteResultSuccess } from "milkio";
 import { type TSONEncode } from "@southern-aurora/tson";
 import type * as <%= utils.camel(path.slice(0, -3).replaceAll('/', '$')) %> from '${importPath}/<%= path.slice(0, -3) %>';
 

package/scripts/generate-database.ts

@@ -14,10 +14,10 @@ export async function generate() {
   await generateDatabase();
 }
 
-console.log("Loongbao Database Generating..");
+console.log("milkio Database Generating..");
 
 await generate();
 
-console.log("\n✅ Loongbao Database Generated!\n");
+console.log("\n✅ milkio Database Generated!\n");
 
 exit(0);

package/scripts/generate-partial.ts

@@ -2,7 +2,7 @@
 
 import { argv, exit } from "node:process";
 import { generateApp } from "./generate/generate-app";
-console.log("Loongbao Quick Generating..");
+console.log("milkio Quick Generating..");
 
 export async function generatePartial(path?: string) {
   await generateApp();
@@ -10,6 +10,6 @@ export async function generatePartial(path?: string) {
 
 await generatePartial(...(argv.slice(3) as any));
 
-console.log("\n✅ Loongbao Generated!");
+console.log("\n✅ milkio Generated!");
 
 exit(0);

package/scripts/generate.ts

@@ -14,10 +14,10 @@ export async function generate() {
   await generateApp();
 }
 
-console.log("Loongbao Generating..");
+console.log("milkio Generating..");
 
 await generate();
 
-console.log("\n✅ Loongbao Generated!");
+console.log("\n✅ milkio Generated!");
 
 exit(0);

package/templates/api.ts

@@ -5,7 +5,7 @@ await createTemplate(async (tools) => {
   return {
     path: join(tools.directory, `${tools.hyphen(tools.name)}.ts`),
     content: `
-import { defineApi, defineApiTest } from "loongbao";
+import { defineApi, defineApiTest } from "milkio";
 
 /**
  * ${tools.hyphen(tools.name)}

package/types.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any */
 
-import { type createLoongbaoApp } from ".";
+import { type createMilkioApp } from ".";
 import type { failCode } from "../../src/fail-code";
 
-export type LoongbaoApp = Awaited<ReturnType<typeof createLoongbaoApp>>;
+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 LoongbaoMeta = {
+export type MilkioMeta = {
   //
 };
 

package/utils/handle-catch-error.ts

@@ -9,16 +9,16 @@ export function hanldeCatchError(error: any, executeId: ExecuteId): ExecuteResul
   if (error.stack) logger.error("\nError Stack: ", error.stack);
   else logger.error("\nError Stack: ", error);
 
-  if (error.name !== "LoongbaoReject") {
-    // If it is not LoongbaoReject, it is considered an internal server error that should not be exposed
-    logger.error(`FailCode: internal-server-error`);
+  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`);
 
     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
       }
     };