milkio 1.0.0-alpha.25 → 1.0.0-alpha.27

package/exception/index.ts

@@ -8,8 +8,10 @@ export interface $rejectCode {
   REQUEST_TIMEOUT: { timeout: number; message: string };
   NOT_FOUND: { path: string };
   PARAMS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;
+  RESULTS_TYPE_INCORRECT: { path: string; expected: string; value: any; message: string } | null;
   UNACCEPTABLE: { expected: string; message: string };
   PARAMS_TYPE_NOT_SUPPORTED: { expected: string };
+  RESULTS_TYPE_NOT_SUPPORTED: { expected: string };
   INTERNAL_SERVER_ERROR: undefined;
 }
 

package/execute/index.ts

@@ -1,4 +1,4 @@
-import { type IValidation } from "typia";
+import typia, { type IValidation } from "typia";
 import { TSON } from "@southern-aurora/tson";
 import { reject, type $context, type $meta, type Logger, type Results, type GeneratedInit, getConfig } from "..";
 import { headersToJSON } from "../utils/headers-to-json";
@@ -24,7 +24,7 @@ export const __initExecuter = (generated: GeneratedInit, runtime: any) => {
           paramsType: "string";
         }
     ),
-  ): Promise<{ executeId: string; headers: Headers; params: Record<any, unknown>; results: Results<any>; context: $context; meta: Readonly<$meta>; type: "action" | "stream" }> => {
+  ): Promise<{ executeId: string; headers: Headers; params: Record<any, unknown>; results: Results<any>; context: $context; meta: Readonly<$meta>; type: "action" | "stream"; emptyResult: boolean; resultsTypeSafety: boolean }> => {
     const executeId: string = options.createdExecuteId;
     env = env ?? {};
     envMode = envMode ?? "production";
@@ -73,7 +73,7 @@ export const __initExecuter = (generated: GeneratedInit, runtime: any) => {
       getConfig: (namespace: string) => getConfig(generated, env, envMode, namespace),
       call: (module: any, options: any) => __call(context, module, options),
     } as unknown as $context;
-    const results: Results<unknown> = { value: undefined };
+    const results: Results<any> = { value: undefined };
 
     if (runtime.develop) {
       options.createdLogger.request(`headers - ${TSON.stringify(headers.toJSON())}`, `\nparams - ${TSON.stringify(params)}`);
@@ -82,7 +82,7 @@ export const __initExecuter = (generated: GeneratedInit, runtime: any) => {
     const module = await routeSchema.module();
     let meta = (module.meta ? module.meta : {}) as unknown as Readonly<$meta>;
 
-    if (!meta.typeSafety || meta.typeSafety === true) {
+    if (meta.typeSafety === undefined || meta.typeSafety === true) {
       const validation = routeSchema.validateParams(params) as IValidation<any>;
       if (!validation.success) throw reject("PARAMS_TYPE_INCORRECT", { ...validation.errors[0], message: `The value '${validation.errors[0].path}' is '${validation.errors[0].value}', which does not meet '${validation.errors[0].expected}' requirements.` });
     }
@@ -90,13 +90,25 @@ export const __initExecuter = (generated: GeneratedInit, runtime: any) => {
     await runtime.emit("milkio:executeBefore", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, context });
 
     results.value = await module.default.handler(context, params);
-    if (results.value === undefined || results.value === null || results.value === "") results.value = {};
-    else if (Array.isArray(results.value)) throw reject("FAIL", "The return type of the handler must be an object, which is currently an array.");
+
+    let resultsTypeSafety = false;
+    if (results?.value?.$milkioType === "type-safety") {
+      resultsTypeSafety = true;
+      const validation = routeSchema.validateResults(results.value.value) as IValidation<any>;
+      if (!validation.success) throw reject("RESULTS_TYPE_INCORRECT", { ...validation.errors[0], message: `The value '${validation.errors[0].path}' is '${validation.errors[0].value}', which does not meet '${validation.errors[0].expected}' requirements.` });
+      results.value = results.value.value;
+    }
+
+    let emptyResult = false;
+    if (results.value === undefined || results.value === null || results.value === "") {
+      emptyResult = true;
+      results.value = {};
+    } else if (Array.isArray(results.value)) throw reject("FAIL", "The return type of the handler must be an object, which is currently an array.");
     else if (typeof results.value !== "object") throw reject("FAIL", "The return type of the handler must be an object, which is currently a primitive type.");
 
     await runtime.emit("milkio:executeAfter", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, context, results });
 
-    return { executeId, headers, params, results, context, meta, type: module.$milkioType };
+    return { executeId, headers, params, results, context, meta, type: module.$milkioType, emptyResult, resultsTypeSafety };
   };
 
   const __call = async (context: $context, module: { default: any }, params?: any): Promise<any> => {

package/index.ts

@@ -1,3 +1,4 @@
+export * from "./type-safety";
 export * from "@southern-aurora/tson";
 export * from "./types";
 export * from "./config";

package/listener/index.ts

@@ -108,7 +108,15 @@ export const __initListener = (generated: GeneratedInit, runtime: any, executer:
           paramsType: "string",
         });
 
-        if (response.body === "" && executed.results.value !== undefined) response.body = TSON.stringify({ success: true, data: executed.results.value, executeId } satisfies MilkioResponseSuccess<any>);
+        if (response.body === "" && executed.results.value !== undefined) {
+          if (executed.emptyResult) {
+            response.body = `{"data":{},"executeId":"${executeId}","success":true}`;
+          } else if (executed.resultsTypeSafety) {
+            response.body = `{"data":${routeSchema.resultsToJSON(executed.results.value)},"executeId":"${executeId}","success":true}`;
+          } else {
+            response.body = `{"data":${TSON.stringify(executed.results.value)},"executeId":"${executeId}","success":true}`;
+          }
+        }
 
         await runtime.emit("milkio:httpResponse", { executeId, logger, path: http.path.string as string, http, context: executed.context });
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "1.0.0-alpha.25",
+  "version": "1.0.0-alpha.27",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
@@ -13,7 +13,7 @@
     "@southern-aurora/tson": "*",
     "chalk": "^5.3.0",
     "date-fns": "^4.1.0",
-    "typia": "6.9.0"
+    "typia": "6.11.3"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/type-safety/index.ts

@@ -0,0 +1,16 @@
+export type TypeSafety<Value extends Record<any, any>> = (value: Value) => TypeSafetyValue;
+
+export type TypeSafetyValue = {
+  type: <Type extends Record<any, any>>() => Type;
+};
+
+export type TypeSafetyType<Type extends Record<any, any>> = {
+  $milkioType: "type-safety";
+  value: Type;
+};
+
+export function typeSafety<Value extends Record<any, any>>(value: Value): TypeSafetyValue {
+  return {
+    type: () => ({ $milkioType: "type-safety", value }),
+  } as any;
+}

package/types/index.ts

@@ -10,6 +10,8 @@ export type Mixin<T, U> = U & Omit<T, keyof U>;
 
 export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
 
+export type DBSelect<T, K> = Exclude<T, K>;
+
 export type DBCreate<T, KO extends keyof T | never = never, TO extends Omit<T, KO> = Omit<T, KO>> = {
   [K in keyof TO]?: TO[K] extends null ? undefined : Exclude<TO[K], null>;
 };