@milkio/astra 1.0.0-alpha.1 → 1.0.0-alpha.3

package/index.ts

@@ -208,15 +208,21 @@ 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(" ");

package/package.json

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

package/utils/cookbook-dto-checks.ts

@@ -15,6 +15,7 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
     null,
     CookbookOptions
 ]> => {
+    let cookbookToml = { ...cookbookTomlParsed };
     const checkResult = (() => { const $join = (typia.validateEquals as any).join; 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;
@@ -27,15 +28,15 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
         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 || "other" === 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.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", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
+    }); const $io2 = (input: any, _exceptionable: boolean = true): boolean => ("milkio" === input.type || "other" === 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 => "number" === typeof input.cookbookPort && (1 === Object.keys(input).length || Object.keys(input).every((key: any) => {
-        if (["cookbookPort"].some((prop: any) => key === prop))
+    })); 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)
@@ -113,6 +114,10 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
             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)",
@@ -146,7 +151,7 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
             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", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
+            if (["type", "port", "start", "build", "watch", "lazyRoutes", "typiaMode", "significant", "insignificant"].some((prop: any) => key === prop))
                 return true;
             const value = input[key];
             if (undefined === value)
@@ -156,12 +161,16 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
                 expected: "undefined",
                 value: value
             });
-        }).every((flag: boolean) => flag))].every((flag: boolean) => flag); const $vo3 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["number" === typeof input.cookbookPort || $report(_exceptionable, {
+        }).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
-        }), 1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key: any) => {
-            if (["cookbookPort"].some((prop: any) => key === prop))
+        }), 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)
@@ -204,9 +213,9 @@ export const checkCookbookOptions = async (cookbookTomlParsed: any): Promise<[
         Error.captureStackTrace(error);
         cookbookTomlParsed = null;
     }
-    return [error, cookbookTomlParsed];
+    return [error, cookbookToml];
 };
-export const checkCookbookActionParams = async (results: any): Promise<[
+export const checkCookbookActionParams = async (resultsRaw: any): Promise<[
     Record<any, any> & {
         message: string;
         stack: string;
@@ -216,9 +225,17 @@ export const checkCookbookActionParams = async (results: any): Promise<[
     null,
     CookbookActionParams
 ]> => {
+    let results = { ...resultsRaw };
     if (typeof Bun === "undefined")
         throw new Error("Bun is not defined");
-    const checkResult = (() => { const $io0 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const $vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || $report(_exceptionable, {
+    const checkResult = (() => { const $throws = (typia.misc.validatePrune as any).throws; const $io0 = (input: any): boolean => "milkio@logger" === input.type && Array.isArray(input.log); const $io1 = (input: any): boolean => "milkio@template" === input.type && "string" === typeof input.name && "string" === typeof input.fsPath && "string" === typeof input.template; const $iu0 = (input: any): any => (() => {
+        if ("milkio@logger" === input.type)
+            return $io0(input);
+        else if ("milkio@template" === input.type)
+            return $io1(input);
+        else
+            return false;
+    })(); const $vo0 = (input: any, _path: string, _exceptionable: boolean = true): boolean => ["milkio@logger" === input.type || $report(_exceptionable, {
             path: _path + ".type",
             expected: "\"milkio@logger\"",
             value: input.type
@@ -226,23 +243,66 @@ export const checkCookbookActionParams = async (results: any): Promise<[
             path: _path + ".log",
             expected: "Array<any>",
             value: input.log
-        })].every((flag: boolean) => flag); const $po0 = (input: any): any => {
+        })].every((flag: boolean) => flag); const $vo1 = (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 $vu0 = (input: any, _path: string, _exceptionable: boolean = true): any => (() => {
+        if ("milkio@logger" === input.type)
+            return $vo0(input, _path, true && _exceptionable);
+        else if ("milkio@template" === input.type)
+            return $vo1(input, _path, true && _exceptionable);
+        else
+            return $report(_exceptionable, {
+                path: _path,
+                expected: "(__type | __type.o1)",
+                value: input
+            });
+    })(); const $po0 = (input: any): any => {
         for (const key of Object.keys(input)) {
             if ("type" === key || "log" === key)
                 continue;
             delete input[key];
         }
-    }; const __is = (input: any): input is CookbookActionParams => "object" === typeof input && null !== input && $io0(input); let errors: any; let $report: any; const __validate = (input: any): typia.IValidation<CookbookActionParams> => {
+    }; const $po1 = (input: any): any => {
+        for (const key of Object.keys(input)) {
+            if ("type" === key || "name" === key || "fsPath" === key || "template" === key)
+                continue;
+            delete input[key];
+        }
+    }; const $pu0 = (input: any): any => (() => {
+        if ("milkio@logger" === input.type)
+            return $po0(input);
+        else if ("milkio@template" === input.type)
+            return $po1(input);
+        else
+            $throws({
+                expected: "(__type | __type.o1)",
+                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): typia.IValidation<CookbookActionParams> => {
         if (false === __is(input)) {
             errors = [];
             $report = (typia.misc.validatePrune as any).report(errors);
             ((input: any, _path: string, _exceptionable: boolean = true) => ("object" === typeof input && null !== input || $report(true, {
                 path: _path + "",
-                expected: "CookbookActionParams",
+                expected: "(__type | __type.o1)",
                 value: input
-            })) && $vo0(input, _path + "", true) || $report(true, {
+            })) && $vu0(input, _path + "", true) || $report(true, {
                 path: _path + "",
-                expected: "CookbookActionParams",
+                expected: "(__type | __type.o1)",
                 value: input
             }))(input, "$input", true);
             const success = 0 === errors.length;
@@ -259,13 +319,13 @@ export const checkCookbookActionParams = async (results: any): Promise<[
         } as any;
     }; const __prune = (input: CookbookActionParams): void => {
         if ("object" === typeof input && null !== input)
-            $po0(input);
+            $pu0(input);
     }; return (input: any): typia.IValidation<CookbookActionParams> => {
         const result = __validate(input);
         if (result.success)
             __prune(input);
         return result;
-    }; })()(results);
+    }; })()(resultsRaw);
     let error = null;
     if (!checkResult.success) {
         const error: any = checkResult.errors.at(0)!;

package/utils/cookbook-dto-types.ts

@@ -9,18 +9,25 @@ export type CookbookOptions = {
         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@logger";
     log: Array<any>;
+} | {
+    type: "milkio@template";
+    name: string;
+    fsPath: string;
+    template: string;
 };
 export type CookbookSubscribeEmits = {
     type: "workers@stdout";