milkio 1.0.0-alpha.42 → 1.0.0-alpha.43

package/.co.toml

@@ -1,2 +1,2 @@
-["general"]
-includes = ["co:bun"]
+[general]
+includes = [ "co:bun" ]

package/README.md

@@ -1,3 +1,3 @@
 # Milkio
 
-Document: [milkio.fun](https://milkio.fun)
+Document: [milkio.fun](https://milkio.fun)

package/action/index.ts

@@ -1,19 +1,19 @@
-import { type $context, type $meta } from "..";
+import type { $context, $meta } from '..'
 
-export const action = <ActionInitT extends ActionInit>(init: ActionInitT): Action<ActionInitT> => {
-  const action = init as unknown as Action<ActionInitT>;
-  action.$milkioType = "action";
-  if (action.meta === undefined) action.meta = {};
-  return action;
-};
+export function action<ActionInitT extends ActionInit>(init: ActionInitT): Action<ActionInitT> {
+  const action = init as unknown as Action<ActionInitT>
+  action.$milkioType = 'action'
+  if (action.meta === undefined) action.meta = {}
+  return action
+}
 
-export type ActionInit = {
-  meta?: $meta;
-  handler: (context: $context, params: any) => Promise<unknown>;
-};
+export interface ActionInit {
+  meta?: $meta
+  handler: (context: $context, params: any) => Promise<unknown>
+}
 
-export type Action<ActionInitT extends ActionInit> = {
-  $milkioType: "action";
-  meta: ActionInitT["meta"] extends undefined ? {} : ActionInitT["meta"];
-  handler: ActionInitT["handler"];
-};
+export interface Action<ActionInitT extends ActionInit> {
+  $milkioType: 'action'
+  meta: ActionInitT['meta'] extends undefined ? {} : ActionInitT['meta']
+  handler: ActionInitT['handler']
+}

package/command/index.ts

@@ -1,53 +1,57 @@
-import { type GeneratedInit } from "..";
+import type { GeneratedInit } from '..'
 
-export const command = <CommandInitT extends CommandInit>(init: CommandInitT): Command<CommandInitT> => {
-  const command = init as unknown as Command<CommandInitT>;
-  command.$milkioType = "command";
-  return command;
-};
+export function command<CommandInitT extends CommandInit>(init: CommandInitT): Command<CommandInitT> {
+  const command = init as unknown as Command<CommandInitT>
+  command.$milkioType = 'command'
+  return command
+}
 
-export type CommandInit = {
-  handler: (commands: Array<string>, options: Record<string, string>) => Promise<unknown>;
-};
+export interface CommandInit {
+  handler: (commands: Array<string>, options: Record<string, string>) => Promise<unknown>
+}
 
-export type Command<CommandInitT extends CommandInit> = {
-  $milkioType: "command";
-  handler: CommandInitT["handler"];
-};
+export interface Command<CommandInitT extends CommandInit> {
+  $milkioType: 'command'
+  handler: CommandInitT['handler']
+}
 
-export const __initCommander = (generated: GeneratedInit, runtime: any) => {
+export function __initCommander(generated: GeneratedInit, runtime: any) {
   const commander = async (argv: Array<string>, options?: { onNotFound?: () => any }) => {
     const params = {
-      path: "index",
+      path: 'index',
       commands: [] as Array<string>,
       options: {} as Record<string, string | true>,
-    };
+    }
     for (const v of argv.slice(3)) {
-      if (v.startsWith("--") && v.includes("=")) {
-        const vSplited = v.split("=");
-        params.options[vSplited[0].slice(2)] = vSplited.slice(1, vSplited.length).join("=");
-      } else if (v.startsWith("--")) {
-        params.options[v.slice(2)] = "1";
-      } else if (v.startsWith("-") && v.includes("=")) {
-        const vSplited = v.split("=");
-        params.options[vSplited[0].slice(1)] = vSplited.slice(1, vSplited.length).join("=");
-      } else if (v.startsWith("-")) {
-        params.options[v.slice(1)] = "1";
-      } else {
-        params.commands.push(v);
+      if (v.startsWith('--') && v.includes('=')) {
+        const vSplited = v.split('=')
+        params.options[vSplited[0].slice(2)] = vSplited.slice(1, vSplited.length).join('=')
+      }
+      else if (v.startsWith('--')) {
+        params.options[v.slice(2)] = '1'
+      }
+      else if (v.startsWith('-') && v.includes('=')) {
+        const vSplited = v.split('=')
+        params.options[vSplited[0].slice(1)] = vSplited.slice(1, vSplited.length).join('=')
+      }
+      else if (v.startsWith('-')) {
+        params.options[v.slice(1)] = '1'
+      }
+      else {
+        params.commands.push(v)
       }
     }
-    if (argv.length === 2) params.path = `index`;
-    else params.path = `${argv[2] ?? "index"}`;
+    if (argv.length === 2) params.path = `index`
+    else params.path = `${argv[2] ?? 'index'}`
 
     if (!(params.path in generated.commandSchema.commands)) {
-      if (options?.onNotFound) return await options.onNotFound();
-      console.log(`\x1B[44m UwU \x1B[0m \x1B[2mCommand not found:\x1B[0m \x1B[32m${params.path}\x1B[0m`);
-      return undefined;
+      if (options?.onNotFound) return await options.onNotFound()
+      console.log(`\x1B[44m UwU \x1B[0m \x1B[2mCommand not found:\x1B[0m \x1B[32m${params.path}\x1B[0m`)
+      return undefined
     }
 
-    return await generated.commandSchema.commands[params.path].module.handler(params.commands, params.options);
-  };
+    return await generated.commandSchema.commands[params.path].module.handler(params.commands, params.options)
+  }
 
-  return commander;
-};
+  return commander
+}

package/config/index.ts

@@ -1,33 +1,33 @@
-export const config = <ConfigT extends Config>(config: ConfigT): ConfigT => {
-  return config;
-};
+export function config<ConfigT extends Config>(config: ConfigT): ConfigT {
+  return config
+}
 
-export type Config = (mode: string) => Promise<Record<string, unknown>> | Record<string, unknown>;
+export type Config = (mode: string) => Promise<Record<string, unknown>> | Record<string, unknown>
 
-export type ConfigEnvironments<T extends Config> = {
-  [key: string]: (env: Record<string, string>) => Partial<Awaited<ReturnType<T>>> | Promise<Partial<Awaited<ReturnType<T>>>>;
-};
+export interface ConfigEnvironments<T extends Config> {
+  [key: string]: (env: Record<string, string>) => Partial<Awaited<ReturnType<T>>> | Promise<Partial<Awaited<ReturnType<T>>>>
+}
 
 export function envToString(value: string | number | undefined, defaultValue: string) {
-  if (value === undefined) return defaultValue;
+  if (value === undefined) return defaultValue
 
-  return `${value}`;
+  return `${value}`
 }
 
 export function envToNumber(value: string | undefined, defaultValue: number) {
-  if (value === undefined) return defaultValue;
+  if (value === undefined) return defaultValue
 
-  return Number.parseInt(value, 10);
+  return Number.parseInt(value, 10)
 }
 
 export function envToBoolean(value: string | number | undefined, defaultValue: boolean) {
-  if (value === "true") return true;
+  if (value === 'true') return true
 
-  if (value === "false") return false;
+  if (value === 'false') return false
 
-  if (value === "") return false;
+  if (value === '') return false
 
-  if (undefined === value) return defaultValue;
+  if (undefined === value) return defaultValue
 
-  return Boolean(value);
+  return Boolean(value)
 }

package/context/index.ts

@@ -1,26 +1,26 @@
-import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, type Steps, type Mixin, type ExecuteOptions, type Action } from "..";
+import type { MilkioHttpRequest, MilkioHttpResponse, $types, Logger, Action } from '..'
 
 export interface $context {
-  develop: boolean;
-  executeId: string;
-  environment: string;
-  path: string;
-  logger: Logger;
-  http: ContextHttp<Record<any, any>>;
-  config: Readonly<Awaited<ReturnType<$types["configSchema"]["get"]>>>;
-  call: <Module extends Promise<{ default: Action<any> }>>(module: Module, params: Parameters<Awaited<Module>["default"]["handler"]>[1]) => Promise<ReturnType<Awaited<Module>["default"]["handler"]>>;
+  develop: boolean
+  executeId: string
+  environment: string
+  path: string
+  logger: Logger
+  http: ContextHttp<Record<any, any>>
+  config: Readonly<Awaited<ReturnType<$types['configSchema']['get']>>>
+  call: <Module extends Promise<{ default: Action<any> }>>(module: Module, params: Parameters<Awaited<Module>['default']['handler']>[1]) => Promise<ReturnType<Awaited<Module>['default']['handler']>>
 }
 
-export type ContextHttp<ParamsParsed = any> = {
-  url: URL;
-  ip: string;
-  path: { string: keyof $types["generated"]["routeSchema"]; array: Array<string> };
+export interface ContextHttp<ParamsParsed = any> {
+  url: URL
+  ip: string
+  path: { string: keyof $types['generated']['routeSchema'], array: Array<string> }
   params: {
-    string: string;
-    parsed: ParamsParsed;
-  };
-  request: MilkioHttpRequest;
-  response: MilkioHttpResponse;
-};
+    string: string
+    parsed: ParamsParsed
+  }
+  request: MilkioHttpRequest
+  response: MilkioHttpResponse
+}
 
-export type ContextCreatedHandler = (context: $context) => Promise<void> | void;
+export type ContextCreatedHandler = (context: $context) => Promise<void> | void

package/events/index.ts

@@ -1,47 +1,47 @@
-import { type $context, type ContextHttp, type Results, type Logger, type $meta } from "..";
+import type { $context, ContextHttp, Results, Logger, $meta } from '..'
 
 export interface $events {
-  "milkio:httpRequest": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };
-  "milkio:httpResponse": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>>; context: $context };
-  "milkio:httpNotFound": { executeId: string; path: string; logger: Logger; http: ContextHttp<Record<string, any>> };
-  "milkio:executeBefore": { executeId: string; path: string; logger: Logger; meta: $meta; context: $context };
-  "milkio:executeAfter": { executeId: string; path: string; logger: Logger; meta: $meta; context: $context; results: Results<any> };
+  'milkio:httpRequest': { executeId: string, path: string, logger: Logger, http: ContextHttp<Record<string, any>> }
+  'milkio:httpResponse': { executeId: string, path: string, logger: Logger, http: ContextHttp<Record<string, any>>, context: $context }
+  'milkio:httpNotFound': { executeId: string, path: string, logger: Logger, http: ContextHttp<Record<string, any>> }
+  'milkio:executeBefore': { executeId: string, path: string, logger: Logger, meta: $meta, context: $context }
+  'milkio:executeAfter': { executeId: string, path: string, logger: Logger, meta: $meta, context: $context, results: Results<any> }
 }
 
-export const __initEventManager = () => {
-  const handlers = new Map<(event: any) => void, string>();
-  const indexed = new Map<string, Set<(event: any) => void>>();
+export function __initEventManager() {
+  const handlers = new Map<(event: any) => void, string>()
+  const indexed = new Map<string, Set<(event: any) => void>>()
 
   const eventManager = {
     on: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => {
-      handlers.set(handler, key as string);
+      handlers.set(handler, key as string)
       if (indexed.has(key as string) === false) {
-        indexed.set(key as string, new Set());
+        indexed.set(key as string, new Set())
       }
-      const set = indexed.get(key as string)!;
-      set.add(handler);
-      handlers.set(handler, key as string);
+      const set = indexed.get(key as string)!
+      set.add(handler)
+      handlers.set(handler, key as string)
 
       return () => {
-        handlers.delete(handler);
-        set.delete(handler);
-      };
+        handlers.delete(handler)
+        set.delete(handler)
+      }
     },
     off: <Key extends keyof $events, Handler extends (event: $events[Key]) => void>(key: Key, handler: Handler) => {
-      const set = indexed.get(key as string);
-      if (!set) return;
-      handlers.delete(handler);
-      set.delete(handler);
+      const set = indexed.get(key as string)
+      if (!set) return
+      handlers.delete(handler)
+      set.delete(handler)
     },
     emit: async <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<void> => {
-      const h = indexed.get(key as string);
+      const h = indexed.get(key as string)
       if (h) {
         for (const handler of h) {
-          await handler(value);
+          await handler(value)
         }
       }
     },
-  };
+  }
 
-  return eventManager;
-};
+  return eventManager
+}

package/exception/index.ts

@@ -1,46 +1,48 @@
-import { TSON } from "@southern-aurora/tson";
-import { type MilkioResponseReject, type Logger } from "..";
+import { TSON } from '@southern-aurora/tson'
+import type { MilkioResponseReject, Logger } from '..'
 
 export interface $rejectCode {
-  FAIL: string;
-  REQUEST_FAIL: any;
-  NOT_DEVELOP_MODE: string;
-  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;
+  FAIL: string
+  REQUEST_FAIL: any
+  NOT_DEVELOP_MODE: string
+  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
 }
 
 export function reject<Code extends keyof $rejectCode, RejectData extends $rejectCode[Code]>(code: Code, data: RejectData): MilkioRejectError<Code, RejectData> {
-  const error = { $milkioReject: true, code: code, data: data } as MilkioRejectError<Code, RejectData>;
-  Error.captureStackTrace(error);
-  return error;
+  const error = { $milkioReject: true, code, data } as MilkioRejectError<Code, RejectData>
+  Error.captureStackTrace(error)
+  return error
 }
 
-export type MilkioRejectError<Code extends keyof $rejectCode = keyof $rejectCode, RejectData extends $rejectCode[Code] = $rejectCode[Code]> = { code: Code; data: RejectData; stack: string; $milkioReject: true };
+export interface MilkioRejectError<Code extends keyof $rejectCode = keyof $rejectCode, RejectData extends $rejectCode[Code] = $rejectCode[Code]> { code: Code, data: RejectData, stack: string, $milkioReject: true }
 
 export function exceptionHandler(executeId: string, logger: Logger, error: MilkioRejectError<any, any> | any): MilkioResponseReject {
-  const name = error?.code ?? error?.name ?? error?.constructor?.name ?? "Unnamed Exception";
+  const name = error?.code ?? error?.name ?? error?.constructor?.name ?? 'Unnamed Exception'
 
-  if (error?.$milkioReject === true && error?.code === "NOT_FOUND") {
-    logger.info(name, error?.data?.path ?? "Unknown path");
-  } else {
+  if (error?.$milkioReject === true && error?.code === 'NOT_FOUND') {
+    logger.info(name, error?.data?.path ?? 'Unknown path')
+  }
+  else {
     try {
-      const stack = error?.$milkioReject ? (error?.stack ?? "").split("\n").slice(2).join("\n") : error?.stack ?? "";
-      logger.error(name, `\n${TSON.stringify(error?.data)}`, `\n${stack}\n`);
-    } catch (_) {
-      logger.error(name, `\n${error?.toString()}`, `\n${error?.stack}\n`);
+      const stack = error?.$milkioReject ? (error?.stack ?? '').split('\n').slice(2).join('\n') : error?.stack ?? ''
+      logger.error(name, `\n${TSON.stringify(error?.data)}`, `\n${stack}\n`)
+    }
+    catch (_) {
+      logger.error(name, `\n${error?.toString()}`, `\n${error?.stack}\n`)
     }
   }
 
-  let result: MilkioResponseReject;
+  let result: MilkioResponseReject
 
-  if (error?.$milkioReject === true) result = { success: false, code: error.code, reject: error.data, executeId };
-  else result = { success: false, code: "INTERNAL_SERVER_ERROR", reject: undefined, executeId };
+  if (error?.$milkioReject === true) result = { success: false, code: error.code, reject: error.data, executeId }
+  else result = { success: false, code: 'INTERNAL_SERVER_ERROR', reject: undefined, executeId }
 
-  return result;
+  return result
 }

package/execute/execute-id-generator.ts

@@ -1,7 +1,7 @@
-import { createId } from "../utils/create-id";
+import { createId } from '../utils/create-id'
 
-export type ExecuteIdGenerator = (request?: Request) => string | Promise<string>;
+export type ExecuteIdGenerator = (request?: Request) => string | Promise<string>
 
-export const defineDefaultExecuteIdGenerator = () => {
-  return createId;
-};
+export function defineDefaultExecuteIdGenerator() {
+  return createId
+}

package/execute/index.ts

@@ -1,64 +1,70 @@
-import typia, { type IValidation } from "typia";
-import { TSON } from "@southern-aurora/tson";
-import { reject, type $context, type $meta, type Logger, type Results, type GeneratedInit } from "..";
-import { headersToJSON } from "../utils/headers-to-json";
+import type { IValidation } from 'typia'
+import { TSON } from '@southern-aurora/tson'
+import { reject } from '..'
+import type { $context, $meta, Logger, Results, GeneratedInit } from '..'
+import { headersToJSON } from '../utils/headers-to-json'
 
-export const __initExecuter = (generated: GeneratedInit, runtime: any) => {
+export function __initExecuter(generated: GeneratedInit, runtime: any) {
   const __execute = async (
     routeSchema: any,
     options: {
-      createdExecuteId: string;
-      createdLogger: Logger;
-      path: string;
-      headers: Record<string, string> | Headers;
-      mixinContext: Record<any, any> | undefined;
+      createdExecuteId: string
+      createdLogger: Logger
+      path: string
+      headers: Record<string, string> | Headers
+      mixinContext: Record<any, any> | undefined
     } & (
       | {
-          params: Record<any, any>;
-          paramsType: "raw";
-        }
+        params: Record<any, any>
+        paramsType: 'raw'
+      }
       | {
-          params: string;
-          paramsType: "string";
-        }
+        params: string
+        paramsType: 'string'
+      }
     ),
-  ): 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;
-    let headers: Headers;
+  ): 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
+    let headers: Headers
     if (!(options.headers instanceof Headers)) {
       // @ts-ignore
       headers = new Headers({
         ...options.headers,
-      });
-    } else {
-      headers = options.headers;
+      })
+    }
+    else {
+      headers = options.headers
     }
-    if (!("toJSON" in headers)) (headers as any).toJSON = () => headersToJSON(headers);
+    if (!('toJSON' in headers)) (headers as any).toJSON = () => headersToJSON(headers)
 
-    let params: Record<any, unknown>;
-    if (options.paramsType === "raw") {
-      params = options.params;
-      if (typeof params === "undefined") params = {};
-    } else {
-      if (options.params === "") params = {};
+    let params: Record<any, unknown>
+    if (options.paramsType === 'raw') {
+      params = options.params
+      if (typeof params === 'undefined') params = {}
+    }
+    else {
+      if (options.params === '') {
+        params = {}
+      }
       else {
         try {
-          params = TSON.parse(options.params);
-        } catch (error) {
-          throw reject("PARAMS_TYPE_NOT_SUPPORTED", { expected: "json" });
+          params = TSON.parse(options.params)
+        }
+        catch (error) {
+          throw reject('PARAMS_TYPE_NOT_SUPPORTED', { expected: 'json' })
         }
-        if (typeof params === "undefined") params = {};
+        if (typeof params === 'undefined') params = {}
       }
     }
-    if (typeof params !== "object" || Array.isArray(params)) throw reject("PARAMS_TYPE_NOT_SUPPORTED", { expected: "json" });
-    if ("$milkioGenerateParams" in params && params.$milkioGenerateParams === "enable") {
-      if (!runtime.develop) throw reject("NOT_DEVELOP_MODE", "This feature must be in cookbook to use.");
-      delete params.$milkioGenerateParams;
-      let paramsRand = routeSchema.randomParams();
-      if (paramsRand === undefined || paramsRand === null) paramsRand = {};
-      params = { ...paramsRand, ...params };
+    if (typeof params !== 'object' || Array.isArray(params)) throw reject('PARAMS_TYPE_NOT_SUPPORTED', { expected: 'json' })
+    if ('$milkioGenerateParams' in params && params.$milkioGenerateParams === 'enable') {
+      if (!runtime.develop) throw reject('NOT_DEVELOP_MODE', 'This feature must be in cookbook to use.')
+      delete params.$milkioGenerateParams
+      let paramsRand = routeSchema.randomParams()
+      if (paramsRand === undefined || paramsRand === null) paramsRand = {}
+      params = { ...paramsRand, ...params }
     }
-    if (options.mixinContext?.http?.params?.string) options.mixinContext.http.params.parsed = params; // listen でパースしたパラメータを渡す
+    if (options.mixinContext?.http?.params?.string) options.mixinContext.http.params.parsed = params // listen でパースしたパラメータを渡す
     const context = {
       ...(options.mixinContext ? options.mixinContext : {}),
       develop: runtime.develop,
@@ -67,52 +73,57 @@ export const __initExecuter = (generated: GeneratedInit, runtime: any) => {
       executeId: options.createdExecuteId,
       config: runtime.runtime.config,
       call: (module: any, options: any) => __call(context, module, options),
-    } as unknown as $context;
-    const results: Results<any> = { value: undefined };
+    } as unknown as $context
+    const results: Results<any> = { value: undefined }
 
     if (runtime.develop) {
-      options.createdLogger.request(`headers - ${TSON.stringify(headers.toJSON())}`, `\nparams - ${TSON.stringify(params)}`);
+      options.createdLogger.request(`headers - ${TSON.stringify(headers.toJSON())}`, `\nparams - ${TSON.stringify(params)}`)
     }
 
-    const module = await routeSchema.module();
-    let meta = (module.default?.meta ? module.default?.meta : {}) as unknown as Readonly<$meta>;
+    const module = await routeSchema.module()
+    const meta = (module.default?.meta ? module.default?.meta : {}) as unknown as Readonly<$meta>
 
     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.` });
+      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.` })
     }
 
-    await runtime.emit("milkio:executeBefore", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context });
+    await runtime.emit('milkio:executeBefore', { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context })
 
-    results.value = await module.default.handler(context, params);
+    results.value = await module.default.handler(context, params)
 
-    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 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.");
+    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, meta, context, results });
+    await runtime.emit('milkio:executeAfter', { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context, results })
 
-    return { executeId, headers, params, results, context, meta, type: module.$milkioType, emptyResult, resultsTypeSafety };
-  };
+    return { executeId, headers, params, results, context, meta, type: module.$milkioType, emptyResult, resultsTypeSafety }
+  }
 
   const __call = async (context: $context, module: { default: any }, params?: any): Promise<any> => {
-    const moduleAwaited = await module;
-    return await moduleAwaited.default.handler(context, params);
-  };
+    const moduleAwaited = await module
+    return await moduleAwaited.default.handler(context, params)
+  }
 
   return {
     __call,
     __execute,
-  };
-};
+  }
+}