milkio 1.0.0-alpha.1 → 1.0.0-alpha.100

package/.co.toml

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

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 southern-aurora
+Copyright (c) 2023 akirarika
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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>;
-};
+  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"];
-};
+  $milkioType: 'action'
+  meta: ActionInitT['meta'] extends undefined ? {} : ActionInitT['meta']
+  handler: ActionInitT['handler']
+}

package/bootstrap/index.ts

@@ -0,0 +1,7 @@
+import type { MilkioWorld } from '..'
+
+export function bootstrap<BootstrapInitT extends BootstrapInit>(init: BootstrapInitT): BootstrapInitT {
+  return init
+}
+
+export type BootstrapInit = (world: MilkioWorld) => Promise<void> | void

package/command/index.ts

@@ -1,53 +1,57 @@
-import { type MilkioRuntimeInit, type MilkioInit, 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 = <MilkioRuntime extends MilkioRuntimeInit<MilkioInit> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
+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

@@ -0,0 +1,33 @@
+export function config<ConfigT extends Config>(config: ConfigT): ConfigT {
+  return config
+}
+
+export type Config = (mode: string) => Promise<Record<string, unknown>> | Record<string, unknown>
+
+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
+
+  return `${value}`
+}
+
+export function envToNumber(value: string | undefined, defaultValue: number) {
+  if (value === undefined) return defaultValue
+
+  return Number.parseInt(value, 10)
+}
+
+export function envToBoolean(value: string | number | undefined, defaultValue: boolean) {
+  if (value === 'true') return true
+
+  if (value === 'false') return false
+
+  if (value === '') return false
+
+  if (undefined === value) return defaultValue
+
+  return Boolean(value)
+}

package/context/index.ts

@@ -1,20 +1,28 @@
-import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger } from "..";
+import type { MilkioHttpRequest, MilkioHttpResponse, $types, Logger, Action, MilkioRuntimeInit, MilkioInit } from '..'
 
 export interface $context {
-  executeId: string;
-  path: string;
-  logger: Logger;
-  http?: ContextHttp<Record<any, any>>;
+  _: MilkioRuntimeInit<MilkioInit>
+  develop: boolean
+  executeId: string
+  emit: MilkioRuntimeInit<MilkioInit>['emit']
+  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']>>
+  onFinally: (handler: () => void | Promise<void>) => void
 }
 
-export type ContextHttp<ParamsParsed> = {
-  url: URL;
-  ip: string;
-  path: { string: keyof $types["generated"]["routeSchema"]["$types"]; 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

package/event/index.ts

@@ -0,0 +1,48 @@
+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> }
+}
+
+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)
+      if (indexed.has(key as string) === false) {
+        indexed.set(key as string, new Set())
+      }
+      const set = indexed.get(key as string)!
+      set.add(handler)
+      handlers.set(handler, key as string)
+
+      return () => {
+        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)
+    },
+    emit: async <Key extends keyof $events, Value extends $events[Key]>(key: Key, value: Value): Promise<void> => {
+      const h = indexed.get(key as string)
+      if (h) {
+        for (const handler of h) {
+          await handler(value)
+        }
+      }
+    },
+  }
+
+  return eventManager
+}

package/exception/index.ts

@@ -1,45 +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 };
-  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 type 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,160 +1,135 @@
-import { type IValidation } from "typia";
-import { TSON } from "@southern-aurora/tson";
-import { createId } from "../utils/create-id";
-import { reject, type $context, type $meta, type ExecuteOptions, type Logger, type MilkioRuntimeInit, type Results, type GeneratedInit, type MilkioInit, createLogger, exceptionHandler, Ping } from "..";
-
-export type MilkioHttpRequest = {
-  request: Request;
-};
-
-export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
-  const __call = async (
+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 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" }> => {
-    const executeId = 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, finales: Array<() => void | Promise<void>> }> => {
+    const executeId: string = options.createdExecuteId
+    let headers: Headers
     if (!(options.headers instanceof Headers)) {
       // @ts-ignore
       headers = new Headers({
         ...options.headers,
-      });
-    } else {
-      headers = options.headers;
+      })
     }
-    let params: Record<any, unknown>;
-    if (runtime.port.develop === "disabled") throw reject("NOT_DEVELOP_MODE", "This feature must be in developer mode to use. Usually entering developer mode requires using a cookbook to start milkio and accessing it through localhost.");
-    if (options.paramsType === "raw") {
-      params = options.params;
-      if (typeof params === "undefined") params = {};
-    } else {
-      if (options.params === "") params = {};
+    else {
+      headers = options.headers
+    }
+    if (!('toJSON' in headers)) (headers as any).toJSON = () => headersToJSON(headers)
+
+    const finales: Array<any> = []
+    const onFinally = (handler: any) => finales.unshift(handler)
+
+    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)
         }
-        if (typeof params === "undefined") params = {};
+        catch (error) {
+          throw reject('PARAMS_TYPE_NOT_SUPPORTED', { expected: 'json' })
+        }
+        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") {
-      delete params.$milkioGenerateParams;
-      let paramsRand = routeSchema.randomParams();
-      if (paramsRand === undefined || paramsRand === null) paramsRand = {};
-      params = { ...paramsRand, ...params };
-      options.createdLogger.debug("[milkio]", "🪄 generate params:", options.path, TSON.stringify(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,
       path: options.path,
       logger: options.createdLogger,
+      emit: runtime.emit,
       executeId: options.createdExecuteId,
-    } as unknown as $context;
-
-    const results: Results<unknown> = { value: undefined };
-
-    const module = await routeSchema.module();
-    let meta = (module.meta ? module.meta : {}) as unknown as Readonly<$meta>;
-
-    if (!meta.typeSafety || meta.typeSafety.includes("params")) {
-      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.` });
+      config: runtime.runtime.config,
+      call: (module: any, options: any) => __call(context, module, options),
+      onFinally: onFinally,
+      _: runtime
+    } 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)}`)
     }
 
-    results.value = await module.default.handler(context, params);
+    const module = routeSchema.module
+    const meta = (module.default?.meta ? module.default?.meta : {}) as unknown as Readonly<$meta>
 
-    if (!meta.typeSafety || meta.typeSafety.includes("results")) {
-      const validation = routeSchema.validateResults(results.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.` });
+    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.` })
     }
 
-    return { executeId, headers, params, results, context, meta, type: module.$milkioType };
-  };
-
-  const execute = async (path: string, options?: ExecuteOptions): Promise<any> => {
-    if (!options) options = {};
-    const executeId = createId();
-    const logger = createLogger(runtime, executeId);
-    runtime.runtime.request.set(executeId, { logger: logger });
+    await runtime.emit('milkio:executeBefore', { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context })
 
-    try {
-      const routeSchema = generated.routeSchema.routes.get(path);
-      if (routeSchema === undefined) throw reject("NOT_FOUND", { path: path });
+    results.value = await module.default.handler(context, params)
 
-      const executed = await __call(routeSchema, {
-        createdExecuteId: executeId,
-        createdLogger: logger,
-        path: path,
-        headers: options.headers ?? {},
-        mixinContext: {},
-        params: options.params ?? {},
-        paramsType: "raw",
-      });
+    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
+    }
 
-      if (routeSchema.type === "stream") {
-        // stream
-        return [
-          undefined,
-          (async function* () {
-            try {
-              for await (const result of executed.results.value) {
-                yield [null, result];
-              }
-              return undefined;
-            } catch (error) {
-              const reject = exceptionHandler(executeId, logger, error);
-              const result: any = {};
-              result[reject.code] = reject.reject;
+    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.')
+    }
 
-              yield [result, null];
-              return undefined;
-            }
-          })(),
-          { executeId: executeId },
-        ];
-      } else {
-        // action
-        return [null, executed.results.value, { executeId: executeId }];
-      }
-    } catch (error) {
-      const reject = exceptionHandler(executeId, logger, error);
-      const result: any = {};
-      result[reject.code] = reject.reject;
+    await runtime.emit('milkio:executeAfter', { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, meta, context, results })
 
-      return [result, null, { executeId: executeId }];
-    }
-  };
+    return { executeId, headers, params, results, context, meta, type: module.$milkioType, emptyResult, resultsTypeSafety, finales }
+  }
 
-  const ping = async (): Promise<Ping> => [
-    null,
-    {
-      connect: true,
-      delay: 0,
-      serverTimestamp: Date.now(),
-    },
-  ];
+  const __call = async (context: $context, module: { default: any }, params?: any): Promise<any> => {
+    const moduleAwaited = await module
+    return await moduleAwaited.default.handler(context, params)
+  }
 
   return {
     __call,
-    execute,
-    ping,
-  };
-};
+    __execute,
+  }
+}