milkio 1.0.0-alpha.5 → 1.0.0-alpha.50

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>;
-};
+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 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,24 +1,27 @@
-import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, type Steps, type Execute } 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>>;
-  step: Steps<{}>["step"];
-  execute: Execute;
+  _: MilkioRuntimeInit<MilkioInit>
+  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"]["$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;
+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 } 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; context: $context };
-  "milkio:executeAfter": { executeId: string; path: string; logger: Logger; 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,44 +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;
-  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 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
+}