@milkio/astra 1.0.0-alpha.0 → 1.0.0-alpha.100

package/README.md

@@ -1,4 +1,4 @@
-# milkio-test
+# milkio-astra
 
 To install dependencies:
 

package/index.ts

@@ -1,36 +1,49 @@
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { format } from "date-fns";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { cwd } from "node:process";
 import { load } from "js-toml";
-import typia from "typia";
 import { TSON } from "@southern-aurora/tson";
+import { format } from "date-fns";
+import type { CookbookOptions } from "./utils/cookbook-dto-types";
 
 export type AstraOptionsInit = {
-  stargate: { $types: any; execute: any; ping: any; cookbook: any };
+  stargate: { $types: any; execute: any; ping: any; __cookbook: any };
   bootstrap: () => Promise<Record<string, any>>;
 };
 
-export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
+type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
 
-export type Mixin<T, U> = U & Omit<T, keyof U>;
+type Mixin<T, U> = U & Omit<T, keyof U>;
 
-export type ExecuteOptions = {
+type ExecuteOptions = {
   headers?: Record<string, string>;
   timeout?: number;
   type?: "action" | "stream";
 };
 
-export type ExecuteResultsOption = { executeId: string };
+type ExecuteResultsOption = { executeId: string };
+
+type Context = {
+  logger: Logger;
+};
+
+type Logger = {
+  debug: (description: string, ...params: Array<unknown>) => Log;
+  info: (description: string, ...params: Array<unknown>) => Log;
+  warn: (description: string, ...params: Array<unknown>) => Log;
+  error: (description: string, ...params: Array<unknown>) => Log;
+  response: (description: string, ...params: Array<unknown>) => Log;
+};
+
+type Log = [string /* executeId */, "[DEBUG]" | "[INFO]" | "[WARN]" | "[ERROR]" | "[RESPONSE]", string, string, ...Array<unknown>];
 
-export type Reject = (description: string, ...params: Array<unknown>) => Error;
+type Reject = (description: string, ...params: Array<unknown>) => Error;
 
-export const createAstra = async <AstraOptions extends AstraOptionsInit, Generated extends AstraOptions["stargate"]["$types"]["generated"]>(astraOptions: AstraOptions) => {
-  let cookbookOptions: any = undefined;
+export async function createAstra<AstraOptions extends AstraOptionsInit, Generated extends AstraOptions["stargate"]["$types"]["generated"]>(astraOptions: AstraOptions) {
   if (!existsSync(join(cwd(), "cookbook.toml"))) throw new Error(`The "cookbook.toml" file does not exist in the current directory. If you are running the test with the VS Code extension, make sure it exists in the root directory of the folder you are opening with VS Code.`);
-  cookbookOptions = load((await readFile(join(cwd(), "cookbook.toml"))).toString());
+  const cookbookOptions = load((await readFile(join(cwd(), "cookbook.toml"))).toString()) as CookbookOptions;
   // wait for all milkio projects to start and can be accessed
   // the reason why stargate's ping method is not used directly is that even if only one project is tested, it is necessary to wait for all milkio projects to start
   await Promise.all([
@@ -40,7 +53,7 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
         const project = cookbookOptions.projects[projectName];
         if (project.type !== "milkio") continue;
         projectStatus.set(projectName, withResolvers());
-        let counter = 256;
+        let counter = 65;
         let timer: Timer | null = setInterval(async () => {
           if (--counter <= 0) {
             clearInterval(timer!);
@@ -50,6 +63,7 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
             return;
           }
           try {
+            console.log("\n[ASTRA]", `connecting.. ${counter >= 64 ? "" : `(${counter})`}`);
             const response = await fetchWithTimeout(`http://localhost:${project.port}/generate_204`, { method: "HEAD", timeout: 1024 });
             if (response.status === 204) {
               if (timer) clearTimeout(timer);
@@ -57,30 +71,30 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
               return projectStatus.get(projectName)!.resolve(undefined);
             }
           } catch (error) {}
-        }, 42);
+        }, 100);
       }
       return Array.from(projectStatus.values()).map((v) => v.promise);
     })(),
   ]);
 
-  type Execute = <Path extends keyof Generated["routeSchema"]["$types"]>(
+  type Execute = <Path extends keyof Generated["routeSchema"]>(
     path: Path,
     options?: Mixin<
       ExecuteOptions,
       | {
-          params?: Generated["routeSchema"]["$types"][Path]["params"];
+          params?: Generated["routeSchema"][Path]["types"]["params"];
         }
       | {
-          params?: Partial<Generated["routeSchema"]["$types"][Path]["params"]>;
+          params?: Partial<Generated["routeSchema"][Path]["types"]["params"]>;
           generateParams: true;
         }
     >,
   ) => Promise<
-    Generated["routeSchema"]["$types"][Path]["🐣"] extends boolean
+    Generated["routeSchema"][Path]["types"]["🐣"] extends boolean
       ? // action
-        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"]["$types"][Path]["result"], ExecuteResultsOption]
+        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"][Path]["types"]["result"], ExecuteResultsOption]
       : // stream
-        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated["rejectCode"]>, null] | [null, GeneratorGeneric<Generated["routeSchema"]["$types"][Path]["result"]>], ExecuteResultsOption>]
+        [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated["rejectCode"]>, null] | [null, GeneratorGeneric<Generated["routeSchema"][Path]["types"]["result"]>], ExecuteResultsOption>]
   >;
 
   type MirrorWorld = Mixin<
@@ -93,11 +107,11 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
 
   return {
     options: astraOptions,
-    async createMirrorWorld(importMetaUrl: string): Promise<[MirrorWorld, Reject]> {
+    async createMirrorWorld(importMetaUrl: string): Promise<[Context, Reject, MirrorWorld]> {
       const thisFilePath = join(fileURLToPath(importMetaUrl));
       const thisFileDirPath = join(dirname(thisFilePath)).replaceAll("\\", "/");
       const thisFileDirPathArr = thisFileDirPath.split("/");
-      let projectName: string = "";
+      let projectName = "";
 
       await (async () => {
         let isProjectsDirectory = false;
@@ -124,35 +138,71 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
       const paths = {
         cwd: join(cwd(), "projects", projectName),
         milkio: join(cwd(), "projects", projectName, ".milkio"),
-        generated: join(cwd(), "projects", projectName, ".milkio", "generated"),
+        generated: join(cwd(), "projects", projectName, ".milkio"),
       };
 
       const execute = async (path: Parameters<MirrorWorld["execute"]>[0], optionsInit?: Parameters<MirrorWorld["execute"]>[1]) => {
-        let options = (optionsInit as any) ?? {};
+        const options = (optionsInit as any) ?? {};
         if (options?.generateParams === true) {
           if (!options?.params) options.params = {};
           options.params.$milkioGenerateParams = "enable";
         }
 
-        const results = await this.options.stargate.cookbook.subscribe(`http://localhost:${cookbookOptions.general.cookbookPort}`);
-        console.log("[MILKIO]", "--- server logs start ---");
+        const results = await this.options.stargate.__cookbook.subscribe(`http://localhost:${cookbookOptions.general.cookbookPort}`);
         void (async () => {
           for await (const result of results) {
             if (result.type !== "milkio@logger") continue;
-            console.log("[MILKIO]", ...(result.log ?? []));
+            console.log("\n[MILKIO]", ...(result.log ?? []));
           }
         })();
 
         const response = await this.options.stargate.execute(path, options);
 
         await new Promise((resolve) => setTimeout(resolve, 40));
-        results.return();
-
-        console.log("[MILKIO]", "---  server logs end  ---");
+        context.logger.response(path as string, `\nerror - ${TSON.stringify(response[0])}`, `\nresult - ${typeof response[1]?.next === "function" ? "AsyncGenerator" : TSON.stringify(response[1])}`);
 
         return response;
       };
 
+      const getNow = () => format(new Date(), "(yyyy-MM-dd hh:mm:ss)");
+      const onLoggerInserting = (log: Log) => {
+        // biome-ignore lint/style/noParameterAssign: <explanation>
+        log = [...log];
+        log[0] = `\n${log[0]}` as any;
+        console.log(...log);
+        return true;
+      };
+
+      const context = {
+        logger: {
+          debug: (description: string, ...params: Array<unknown>): Log => {
+            const log: Log = ["[TEST]", "[DEBUG]", description, getNow(), ...params];
+            onLoggerInserting(log);
+            return log;
+          },
+          info: (description: string, ...params: Array<unknown>): Log => {
+            const log: Log = ["[TEST]", "[INFO]", description, getNow(), ...params];
+            onLoggerInserting(log);
+            return log;
+          },
+          warn: (description: string, ...params: Array<unknown>): Log => {
+            const log: Log = ["[TEST]", "[WARN]", description, getNow(), ...params];
+            onLoggerInserting(log);
+            return log;
+          },
+          error: (description: string, ...params: Array<unknown>): Log => {
+            const log: Log = ["[TEST]", "[ERROR]", description, getNow(), ...params];
+            onLoggerInserting(log);
+            return log;
+          },
+          response: (path: string, ...params: Array<unknown>): Log => {
+            const log: Log = ["[TEST]", "[RESPONSE]", path, getNow(), ...params];
+            onLoggerInserting(log);
+            return log;
+          },
+        },
+      } as Context;
+
       const world = {
         ...(await astraOptions.bootstrap()),
         paths,
@@ -160,25 +210,31 @@ export const createAstra = async <AstraOptions extends AstraOptionsInit, Generat
       } as any;
 
       const reject = (...params: Array<unknown>): Error => {
-        const output: Array<any> = ["[REJECT]", ...params];
+        const output: Array<any> = [
+          "[REJECT]",
+          ...params.map((param) => {
+            try {
+              const result = TSON.stringify(param);
+              return result;
+            } catch (error) {
+              return error?.toString?.() ?? typeof error;
+            }
+          }),
+        ];
         console.log(...output);
         for (let index = 1; index < output.length; index++) {
-          if (output[index] !== null && typeof output[index] === "object") {
-            if (output[index] instanceof Error || (output[index].message && output[index].stack)) {
-              output[index] = output[index].toString();
-            } else {
-              output[index] = TSON.stringify(output[index]);
-            }
+          if (typeof output[index] === "object") {
+            output[index] = output[index].toString();
           }
         }
         const message = output.join(" ");
         return new Error(message);
       };
 
-      return [world, reject];
+      return [context, reject, world];
     },
   };
-};
+}
 
 export async function fetchWithTimeout(url: string, options: FetchRequestInit & { timeout?: number } = {}) {
   const { timeout = 8000 } = options;

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "@milkio/astra",
-  "module": "index.ts",
-  "version": "1.0.0-alpha.0",
   "type": "module",
-  "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "5.6.0"
-  },
+  "version": "1.0.0-alpha.100",
+  "module": "index.ts",
   "dependencies": {
-    "@southern-aurora/tson": "^2.0.2",
+    "@southern-aurora/tson": "*",
     "date-fns": "^4.1.0",
     "js-toml": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
   }
 }

package/tsconfig.json

@@ -1,27 +1,28 @@
 {
   "compilerOptions": {
+    "target": "ESNext",
+    "jsx": "react-jsx",
+    "erasableSyntaxOnly":true,
     // Enable latest features
     "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "ESNext",
     "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
+    "module": "ESNext",
 
     // Bundler mode
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
+    "allowJs": true,
 
     // Best practices
     "strict": true,
-    "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
 
+    "noPropertyAccessFromIndexSignature": false,
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,
     "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
+    "noEmit": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
   }
 }

package/utils/cookbook-dto-checks.ts

@@ -0,0 +1,570 @@
+/**
+  * The content of this file is automatically generated by Typia.
+  * It can be edited in the /packages/cookbook-dto/src/* file, and each time you run bun run dev, the generated file will be synced to another location based on the content of the /develop.ts.
+  */
+
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
+import * as __typia_transform__throwTypeGuardError from "typia/lib/internal/_throwTypeGuardError.js";
+import typia from 'typia';
+import type { CookbookActionParams, CookbookOptions, CookbookSubscribeEmits } from './cookbook-dto-types';
+export async function checkCookbookOptions(cookbookTomlParsed: any): Promise<[
+    Record<any, any> & {
+        message: string;
+        stack: string;
+    },
+    null
+] | [
+    null,
+    CookbookOptions
+]> {
+    const cookbookToml = { ...cookbookTomlParsed };
+    const checkResult = (() => { const _io0 = (input: any, _exceptionable: boolean = true): boolean => "object" === typeof input.projects && null !== input.projects && false === Array.isArray(input.projects) && _io1(input.projects, true && _exceptionable) && ("object" === typeof input.general && null !== input.general && _io3(input.general, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key: any) => {
+        if (["projects", "general"].some((prop: any) => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    })); const _io1 = (input: any, _exceptionable: boolean = true): boolean => Object.keys(input).every((key: any) => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && _io2(value, true && _exceptionable);
+    }); const _io2 = (input: any, _exceptionable: boolean = true): boolean => ("milkio" === input.type || "custom" === input.type) && "number" === typeof input.port && (Array.isArray(input.start) && input.start.every((elem: any, _index1: number) => "string" === typeof elem)) && (Array.isArray(input.build) && input.build.every((elem: any, _index2: number) => "string" === typeof elem)) && (undefined === input.watch || "boolean" === typeof input.watch) && (undefined === input.lazyRoutes || "boolean" === typeof input.lazyRoutes) && (undefined === input.typiaMode || "generation" === input.typiaMode || "bundler" === input.typiaMode) && (undefined === input.significant || Array.isArray(input.significant) && input.significant.every((elem: any, _index3: number) => "string" === typeof elem)) && (undefined === input.insignificant || Array.isArray(input.insignificant) && input.insignificant.every((elem: any, _index4: number) => "string" === typeof elem)) && (4 === Object.keys(input).length || Object.keys(input).every((key: any) => {
+        if (["type", "port", "start", "build", "watch", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    })); const _io3 = (input: any, _exceptionable: boolean = true): boolean => "string" === typeof input.start && "number" === typeof input.cookbookPort && (2 === Object.keys(input).length || Object.keys(input).every((key: any) => {
+        if (["start", "cookbookPort"].some((prop: any) => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    })); const _vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => [("object" === typeof input.projects && null !== input.projects && false === Array.isArray(input.projects) || _report(_exceptionable, {
+            path: _path + ".projects",
+            expected: "Record<string, __type>",
+            value: input.projects
+        })) && _vo1(input.projects, _path + ".projects", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".projects",
+            expected: "Record<string, __type>",
+            value: input.projects
+        }), ("object" === typeof input.general && null !== input.general || _report(_exceptionable, {
+            path: _path + ".general",
+            expected: "__type.o1",
+            value: input.general
+        })) && _vo3(input.general, _path + ".general", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".general",
+            expected: "__type.o1",
+            value: input.general
+        }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key: any) => {
+            if (["projects", "general"].some((prop: any) => key === prop))
+                return true;
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            });
+        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const _vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => [false === _exceptionable || Object.keys(input).map((key: any) => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "__type",
+                value: value
+            })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "__type",
+                value: value
+            });
+        }).every((flag: boolean) => flag)].every((flag: boolean) => flag); const _vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio" === input.type || "custom" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "(\"milkio\" | \"custom\")",
+            value: input.type
+        }), "number" === typeof input.port || _report(_exceptionable, {
+            path: _path + ".port",
+            expected: "number",
+            value: input.port
+        }), (Array.isArray(input.start) || _report(_exceptionable, {
+            path: _path + ".start",
+            expected: "Array<string>",
+            value: input.start
+        })) && input.start.map((elem: any, _index5: number) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".start[" + _index5 + "]",
+            expected: "string",
+            value: elem
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
+            path: _path + ".start",
+            expected: "Array<string>",
+            value: input.start
+        }), (Array.isArray(input.build) || _report(_exceptionable, {
+            path: _path + ".build",
+            expected: "Array<string>",
+            value: input.build
+        })) && input.build.map((elem: any, _index6: number) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".build[" + _index6 + "]",
+            expected: "string",
+            value: elem
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
+            path: _path + ".build",
+            expected: "Array<string>",
+            value: input.build
+        }), undefined === input.watch || "boolean" === typeof input.watch || _report(_exceptionable, {
+            path: _path + ".watch",
+            expected: "(boolean | undefined)",
+            value: input.watch
+        }), undefined === input.lazyRoutes || "boolean" === typeof input.lazyRoutes || _report(_exceptionable, {
+            path: _path + ".lazyRoutes",
+            expected: "(boolean | undefined)",
+            value: input.lazyRoutes
+        }), undefined === input.typiaMode || "generation" === input.typiaMode || "bundler" === input.typiaMode || _report(_exceptionable, {
+            path: _path + ".typiaMode",
+            expected: "(\"bundler\" | \"generation\" | undefined)",
+            value: input.typiaMode
+        }), undefined === input.significant || (Array.isArray(input.significant) || _report(_exceptionable, {
+            path: _path + ".significant",
+            expected: "(Array<string> | undefined)",
+            value: input.significant
+        })) && input.significant.map((elem: any, _index7: number) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".significant[" + _index7 + "]",
+            expected: "string",
+            value: elem
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
+            path: _path + ".significant",
+            expected: "(Array<string> | undefined)",
+            value: input.significant
+        }), undefined === input.insignificant || (Array.isArray(input.insignificant) || _report(_exceptionable, {
+            path: _path + ".insignificant",
+            expected: "(Array<string> | undefined)",
+            value: input.insignificant
+        })) && input.insignificant.map((elem: any, _index8: number) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".insignificant[" + _index8 + "]",
+            expected: "string",
+            value: elem
+        })).every((flag: boolean) => flag) || _report(_exceptionable, {
+            path: _path + ".insignificant",
+            expected: "(Array<string> | undefined)",
+            value: input.insignificant
+        }), 4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key: any) => {
+            if (["type", "port", "start", "build", "watch", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
+                return true;
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            });
+        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const _vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["string" === typeof input.start || _report(_exceptionable, {
+            path: _path + ".start",
+            expected: "string",
+            value: input.start
+        }), "number" === typeof input.cookbookPort || _report(_exceptionable, {
+            path: _path + ".cookbookPort",
+            expected: "number",
+            value: input.cookbookPort
+        }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key: any) => {
+            if (["start", "cookbookPort"].some((prop: any) => key === prop))
+                return true;
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "undefined",
+                value: value
+            });
+        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const __is = (input: any, _exceptionable: boolean = true): input is CookbookOptions => "object" === typeof input && null !== input && _io0(input, true); let errors: any; let _report: any; return (input: any): import("typia").IValidation<CookbookOptions> => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = (__typia_transform__validateReport._validateReport as any)(errors);
+            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: "CookbookOptions",
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "CookbookOptions",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            } as any;
+        }
+        return {
+            success: true,
+            data: input
+        } as any;
+    }; })()(cookbookTomlParsed);
+    const error = null;
+    if (!checkResult.success) {
+        const error: any = checkResult.errors.at(0)!;
+        error.message = `The "cookbook.toml" format is incorrect, [${error.path.slice(7)}] should be ${error.expected}, but it is actually ${error.value}. You may be missing some properties in the configuration item, or adding some properties that will not be used. If you have extra properties, these properties are likely due to a misspelling.`;
+        Error.captureStackTrace(error);
+        cookbookTomlParsed = null;
+    }
+    return [error, cookbookToml];
+}
+export async function checkCookbookActionParams(resultsRaw: any): Promise<[
+    Record<any, any> & {
+        message: string;
+        stack: string;
+    },
+    null
+] | [
+    null,
+    CookbookActionParams
+]> {
+    let results = { ...resultsRaw };
+    if (typeof Bun === 'undefined')
+        throw new Error('Bun is not defined');
+    const checkResult = (() => { const _io0 = (input: any): boolean => "milkio@ping" === input.type; const _io1 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const _io2 = (input: any): boolean => "milkio@template" === input.type && "string" === typeof input.name && "string" === typeof input.fsPath && "string" === typeof input.template; const _io3 = (input: any): boolean => "workers@list" === input.type; const _io4 = (input: any): boolean => "workers@get" === input.type && "string" === typeof input.key && "number" === typeof input.index; const _iu0 = (input: any): any => (() => {
+        if ("milkio@ping" === input.type)
+            return _io0(input);
+        else if ("milkio@logger" === input.type)
+            return _io1(input);
+        else if ("milkio@template" === input.type)
+            return _io2(input);
+        else if ("workers@list" === input.type)
+            return _io3(input);
+        else if ("workers@get" === input.type)
+            return _io4(input);
+        else
+            return false;
+    })(); const _vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@ping" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"milkio@ping\"",
+            value: input.type
+        })].every((flag: boolean) => flag); const _vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"milkio@logger\"",
+            value: input.type
+        }), Array.isArray(input.log) || _report(_exceptionable, {
+            path: _path + ".log",
+            expected: "Array<any>",
+            value: input.log
+        })].every((flag: boolean) => flag); const _vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@template" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"milkio@template\"",
+            value: input.type
+        }), "string" === typeof input.name || _report(_exceptionable, {
+            path: _path + ".name",
+            expected: "string",
+            value: input.name
+        }), "string" === typeof input.fsPath || _report(_exceptionable, {
+            path: _path + ".fsPath",
+            expected: "string",
+            value: input.fsPath
+        }), "string" === typeof input.template || _report(_exceptionable, {
+            path: _path + ".template",
+            expected: "string",
+            value: input.template
+        })].every((flag: boolean) => flag); const _vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@list" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"workers@list\"",
+            value: input.type
+        })].every((flag: boolean) => flag); const _vo4 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@get" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"workers@get\"",
+            value: input.type
+        }), "string" === typeof input.key || _report(_exceptionable, {
+            path: _path + ".key",
+            expected: "string",
+            value: input.key
+        }), "number" === typeof input.index || _report(_exceptionable, {
+            path: _path + ".index",
+            expected: "number",
+            value: input.index
+        })].every((flag: boolean) => flag); const _vu0 = (input: any, _path: string, _exceptionable: boolean = true): any => (() => {
+        if ("milkio@ping" === input.type)
+            return _vo0(input, _path, true && _exceptionable);
+        else if ("milkio@logger" === input.type)
+            return _vo1(input, _path, true && _exceptionable);
+        else if ("milkio@template" === input.type)
+            return _vo2(input, _path, true && _exceptionable);
+        else if ("workers@list" === input.type)
+            return _vo3(input, _path, true && _exceptionable);
+        else if ("workers@get" === input.type)
+            return _vo4(input, _path, true && _exceptionable);
+        else
+            return _report(_exceptionable, {
+                path: _path,
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
+                value: input
+            });
+    })(); const _po0 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po1 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "log" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po2 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "name" === key || "fsPath" === key || "template" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po3 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po4 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "key" === key || "index" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _pu0 = (input: any): any => (() => {
+        if ("milkio@ping" === input.type)
+            return _po0(input);
+        else if ("milkio@logger" === input.type)
+            return _po1(input);
+        else if ("milkio@template" === input.type)
+            return _po2(input);
+        else if ("workers@list" === input.type)
+            return _po3(input);
+        else if ("workers@get" === input.type)
+            return _po4(input);
+        else
+            __typia_transform__throwTypeGuardError._throwTypeGuardError({
+                method: "typia.misc.validatePrune",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
+                value: input
+            });
+    })(); const __is = (input: any): input is CookbookActionParams => "object" === typeof input && null !== input && _iu0(input); let errors: any; let _report: any; const __validate = (input: any): import("typia").IValidation<CookbookActionParams> => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = (__typia_transform__validateReport._validateReport as any)(errors);
+            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
+                value: input
+            })) && _vu0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4)",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            } as any;
+        }
+        return {
+            success: true,
+            data: input
+        } as any;
+    }; const __prune = (input: CookbookActionParams): void => {
+        if ("object" === typeof input && null !== input)
+            _pu0(input);
+    }; return (input: any): import("typia").IValidation<CookbookActionParams> => {
+        const result = __validate(input);
+        if (result.success)
+            __prune(input);
+        return result;
+    }; })()(resultsRaw);
+    const error = null;
+    if (!checkResult.success) {
+        const error: any = checkResult.errors.at(0)!;
+        error.message = `The "cookbook.toml" format is incorrect, [${error.path.slice(7)}] should be ${error.expected}, but it is actually ${error.value}. You may be missing some properties in the configuration item, or adding some properties that will not be used. If you have extra properties, these properties are likely due to a misspelling.`;
+        Error.captureStackTrace(error);
+        results = null;
+    }
+    return [error, results];
+}
+export async function checkCookbookSubscribeEmits(results: any): Promise<[
+    Record<any, any> & {
+        message: string;
+        stack: string;
+    },
+    null
+] | [
+    null,
+    CookbookSubscribeEmits
+]> {
+    const typia = await import('typia');
+    const checkResult = (() => { const _io0 = (input: any): boolean => "workers@stdout" === input.type && "string" === typeof input.key && "string" === typeof input.chunk; const _io1 = (input: any): boolean => "workers@state" === input.type && "string" === typeof input.key && ("running" === input.state || "stopped" === input.state) && (null === input.code || "running" === input.code || "kill" === input.code || "number" === typeof input.code); const _io2 = (input: any): boolean => "watcher@change" === input.type && ("rename" === input.event || "change" === input.event) && "string" === typeof input.path; const _io3 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const _iu0 = (input: any): any => (() => {
+        if ("workers@stdout" === input.type)
+            return _io0(input);
+        else if ("workers@state" === input.type)
+            return _io1(input);
+        else if ("watcher@change" === input.type)
+            return _io2(input);
+        else if ("milkio@logger" === input.type)
+            return _io3(input);
+        else
+            return false;
+    })(); const _vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@stdout" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"workers@stdout\"",
+            value: input.type
+        }), "string" === typeof input.key || _report(_exceptionable, {
+            path: _path + ".key",
+            expected: "string",
+            value: input.key
+        }), "string" === typeof input.chunk || _report(_exceptionable, {
+            path: _path + ".chunk",
+            expected: "string",
+            value: input.chunk
+        })].every((flag: boolean) => flag); const _vo1 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["workers@state" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"workers@state\"",
+            value: input.type
+        }), "string" === typeof input.key || _report(_exceptionable, {
+            path: _path + ".key",
+            expected: "string",
+            value: input.key
+        }), "running" === input.state || "stopped" === input.state || _report(_exceptionable, {
+            path: _path + ".state",
+            expected: "(\"running\" | \"stopped\")",
+            value: input.state
+        }), null === input.code || "running" === input.code || "kill" === input.code || "number" === typeof input.code || _report(_exceptionable, {
+            path: _path + ".code",
+            expected: "(\"kill\" | \"running\" | null | number)",
+            value: input.code
+        })].every((flag: boolean) => flag); const _vo2 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["watcher@change" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"watcher@change\"",
+            value: input.type
+        }), "rename" === input.event || "change" === input.event || _report(_exceptionable, {
+            path: _path + ".event",
+            expected: "(\"change\" | \"rename\")",
+            value: input.event
+        }), "string" === typeof input.path || _report(_exceptionable, {
+            path: _path + ".path",
+            expected: "string",
+            value: input.path
+        })].every((flag: boolean) => flag); const _vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || _report(_exceptionable, {
+            path: _path + ".type",
+            expected: "\"milkio@logger\"",
+            value: input.type
+        }), Array.isArray(input.log) || _report(_exceptionable, {
+            path: _path + ".log",
+            expected: "Array<any>",
+            value: input.log
+        })].every((flag: boolean) => flag); const _vu0 = (input: any, _path: string, _exceptionable: boolean = true): any => (() => {
+        if ("workers@stdout" === input.type)
+            return _vo0(input, _path, true && _exceptionable);
+        else if ("workers@state" === input.type)
+            return _vo1(input, _path, true && _exceptionable);
+        else if ("watcher@change" === input.type)
+            return _vo2(input, _path, true && _exceptionable);
+        else if ("milkio@logger" === input.type)
+            return _vo3(input, _path, true && _exceptionable);
+        else
+            return _report(_exceptionable, {
+                path: _path,
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
+                value: input
+            });
+    })(); const _po0 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "key" === key || "chunk" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po1 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "key" === key || "state" === key || "code" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po2 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "event" === key || "path" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _po3 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "log" === key)
+                continue;
+            delete input[key];
+        }
+    }; const _pu0 = (input: any): any => (() => {
+        if ("workers@stdout" === input.type)
+            return _po0(input);
+        else if ("workers@state" === input.type)
+            return _po1(input);
+        else if ("watcher@change" === input.type)
+            return _po2(input);
+        else if ("milkio@logger" === input.type)
+            return _po3(input);
+        else
+            __typia_transform__throwTypeGuardError._throwTypeGuardError({
+                method: "typia.misc.validatePrune",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
+                value: input
+            });
+    })(); const __is = (input: any): input is CookbookSubscribeEmits => "object" === typeof input && null !== input && _iu0(input); let errors: any; let _report: any; const __validate = (input: any): import("typia").IValidation<CookbookSubscribeEmits> => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = (__typia_transform__validateReport._validateReport as any)(errors);
+            ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
+                value: input
+            })) && _vu0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "(__type | __type.o1 | __type.o2 | __type.o3)",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            } as any;
+        }
+        return {
+            success: true,
+            data: input
+        } as any;
+    }; const __prune = (input: CookbookSubscribeEmits): void => {
+        if ("object" === typeof input && null !== input)
+            _pu0(input);
+    }; return (input: any): import("typia").IValidation<CookbookSubscribeEmits> => {
+        const result = __validate(input);
+        if (result.success)
+            __prune(input);
+        return result;
+    }; })()(results);
+    const error = null;
+    if (!checkResult.success) {
+        const error: any = checkResult.errors.at(0)!;
+        error.message = `The "cookbook.toml" format is incorrect, [${error.path.slice(7)}] should be ${error.expected}, but it is actually ${error.value}. You may be missing some properties in the configuration item, or adding some properties that will not be used. If you have extra properties, these properties are likely due to a misspelling.`;
+        Error.captureStackTrace(error);
+        results = null;
+    }
+    return [error, results];
+}

package/utils/cookbook-dto-types.ts

@@ -0,0 +1,56 @@
+/**
+  * The content of this file is automatically generated by Typia.
+  * It can be edited in the /packages/cookbook-dto/src/* file, and each time you run bun run dev, the generated file will be synced to another location based on the content of the /develop.ts.
+  */
+
+export interface CookbookOptions {
+    projects: Record<string, {
+        type: 'milkio' | 'custom';
+        port: number;
+        start: Array<string>;
+        build: Array<string>;
+        watch?: boolean;
+        lazyRoutes?: boolean;
+        typiaMode?: 'generation' | 'bundler';
+        significant?: Array<string>;
+        insignificant?: Array<string>;
+    }>;
+    general: {
+        start: string;
+        cookbookPort: number;
+    };
+}
+export type CookbookActionParams = {
+    type: 'milkio@ping';
+} | {
+    type: 'milkio@logger';
+    log: Array<any>;
+} | {
+    type: 'milkio@template';
+    name: string;
+    fsPath: string;
+    template: string;
+} | {
+    type: 'workers@list';
+} | {
+    type: 'workers@get';
+    key: string;
+    index: number;
+};
+export type CookbookSubscribeEmits = {
+    type: 'workers@stdout';
+    key: string;
+    chunk: string;
+} | {
+    type: 'workers@state';
+    key: string;
+    state: 'running' | 'stopped';
+    code: number | null | 'kill' | 'running';
+} | {
+    type: 'watcher@change';
+    event: 'rename' | 'change';
+    path: string;
+} | {
+    type: 'milkio@logger';
+    log: Array<any>;
+};