milkio 1.0.0-alpha.3 → 1.0.0-alpha.31

package/.publish/releases/1.0.0-alpha.21.md

@@ -0,0 +1,13 @@
+# 1.0.0-alpha.21 - 某章节名
+
+> 一段编纂出来的虚构科幻小说的摘抄片段
+
+## ...更新内容...
+
+...更新内容...
+
+## 升级
+
+```
+bun i milkio@1.0.0-alpha.21
+```

package/command/index.ts

@@ -15,7 +15,7 @@ export type Command<CommandInitT extends CommandInit> = {
   handler: CommandInitT["handler"];
 };
 
-export const __initCommander = <MilkioRuntime extends MilkioRuntimeInit<MilkioInit> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
+export const __initCommander = (generated: GeneratedInit, runtime: any) => {
   const commander = async (argv: Array<string>, options?: { onNotFound?: () => any }) => {
     const params = {
       path: "index",

package/config/index.ts

@@ -0,0 +1,48 @@
+import { type $types, type GeneratedInit } from "../types";
+
+export const config = <ConfigDefaultT extends ConfigDefault, ConfigEnvironmentsT extends ConfigEnvironments<ConfigDefaultT>>(def: ConfigDefaultT, envs: ConfigEnvironmentsT = {} as Record<any, any>): [ConfigDefaultT, ConfigEnvironmentsT] => {
+  return [def, envs];
+};
+
+export const __getConfig = async <Namespace extends keyof $types["generated"]["configSchema"]>(generated: GeneratedInit, env: Record<any, any>, envMode: string, namespace: Namespace) => {
+  if (generated.configSchema[namespace][1] && envMode in generated.configSchema[namespace][1]) {
+    return {
+      ...(await generated.configSchema[namespace][0](env)),
+      ...(await generated.configSchema[namespace][1][envMode](env)),
+    };
+  } else {
+    return {
+      ...(await generated.configSchema[namespace][0](env)),
+    };
+  }
+};
+
+export type ConfigDefault = (env: Record<string, string>) => Promise<Record<string, unknown>> | Record<string, unknown>;
+
+export type ConfigEnvironments<T extends ConfigDefault> = {
+  [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,11 +1,14 @@
-import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, Steps } from "..";
+import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, type Steps, type Mixin, type ExecuteOptions, type Action } from "..";
 
 export interface $context {
+  develop: boolean;
   executeId: string;
+  environment: string;
   path: string;
   logger: Logger;
-  http?: ContextHttp<Record<any, any>>;
-  step: Steps<{}>["step"];
+  http: ContextHttp<Record<any, any>>;
+  getConfig: <Namespace extends keyof $types["generated"]["configSchema"]>(namespace: Namespace) => Promise<Readonly<Awaited<ReturnType<$types["generated"]["configSchema"][Namespace][0]>>>>;
+  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> = {

package/events/index.ts

@@ -1,11 +1,11 @@
-import { type $context, type ContextHttp, type Results, type Logger } from "..";
+import { type $context, type ContextHttp, type Results, type Logger, type $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: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 = () => {

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,11 +1,12 @@
-import { type IValidation } from "typia";
+import typia, { 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, createStep } from "..";
+import { reject, type $context, type $meta, type Logger, type Results, type GeneratedInit, __getConfig } from "..";
 import { headersToJSON } from "../utils/headers-to-json";
 
-export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
-  const __call = async (
+export const __initExecuter = (generated: GeneratedInit, runtime: any) => {
+  const __execute = async (
+    env: Record<any, any> | undefined,
+    envMode: string | undefined,
     routeSchema: any,
     options: {
       createdExecuteId: string;
@@ -23,8 +24,10 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
           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;
+  ): 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";
     let headers: Headers;
     if (!(options.headers instanceof Headers)) {
       // @ts-ignore
@@ -53,7 +56,7 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
     }
     if (typeof params !== "object" || Array.isArray(params)) throw reject("PARAMS_TYPE_NOT_SUPPORTED", { expected: "json" });
     if ("$milkioGenerateParams" in params && params.$milkioGenerateParams === "enable") {
-      if (!runtime.cookbook) throw reject("NOT_DEVELOP_MODE", "This feature must be in cookbook to use.");
+      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 = {};
@@ -62,102 +65,59 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
     if (options.mixinContext?.http?.params?.string) options.mixinContext.http.params.parsed = params; // listen でパースしたパラメータを渡す
     const context = {
       ...(options.mixinContext ? options.mixinContext : {}),
+      develop: runtime.develop,
+      envMode,
       path: options.path,
       logger: options.createdLogger,
       executeId: options.createdExecuteId,
-      step: createStep(),
+      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.cookbook) {
+    if (runtime.develop) {
       options.createdLogger.request(`headers - ${TSON.stringify(headers.toJSON())}`, `\nparams - ${TSON.stringify(params)}`);
     }
 
     const module = await routeSchema.module();
-    let meta = (module.meta ? module.meta : {}) as unknown as Readonly<$meta>;
+    let meta = (module.default?.meta ? module.default?.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.` });
     }
 
-    await runtime.emit("milkio:executeBefore", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, 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);
 
-    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 };
-  };
-
-  const execute = async (path: string, options?: ExecuteOptions): Promise<any> => {
-    if (!options) options = {};
-    const executeId = createId();
-    const logger = createLogger(runtime, path, executeId);
-    runtime.runtime.request.set(executeId, { logger: logger });
-
-    try {
-      const routeSchema = generated.routeSchema.routes.get(path);
-      if (routeSchema === undefined) {
-        throw reject("NOT_FOUND", { path: path });
-      }
-
-      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 };
   };
 
-  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,
   };
 };

package/index.ts

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

package/listener/index.ts

@@ -14,10 +14,14 @@ export type MilkioHttpResponse = Mixin<
   }
 >;
 
-export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime, executer: ReturnType<typeof __initExecuter>) => {
+export const __initListener = (generated: GeneratedInit, runtime: any, executer: ReturnType<typeof __initExecuter>) => {
   const port = runtime.port;
-  const fetch = async (request: MilkioHttpRequest): Promise<Response> => {
-    if (request.method === "OPTIONS") {
+  const fetch = async (options: {
+    request: MilkioHttpRequest;
+    envMode?: string;
+    env?: Record<any, any>;
+  }): Promise<Response> => {
+    if (options.request.method === "OPTIONS") {
       return new Response(undefined, {
         headers: {
           "Access-Control-Allow-Methods": runtime.cors?.corsAllowMethods ?? "*",
@@ -27,7 +31,7 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
       });
     }
 
-    if (request.url.endsWith("/generate_204")) {
+    if (options.request.url.endsWith("/generate_204")) {
       return new Response("", {
         status: 204,
         headers: {
@@ -40,12 +44,12 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
       });
     }
 
-    const url = new URL(request.url);
+    const url = new URL(options.request.url);
     let pathArray = url.pathname.substring(1).split("/");
     if (runtime.ignorePathLevel !== undefined && runtime.ignorePathLevel !== 0) pathArray = pathArray.slice(runtime.ignorePathLevel);
     const pathString = `/${pathArray.join("/")}`;
 
-    const executeId = runtime?.executeId ? await runtime.executeId(request) : createId();
+    const executeId = runtime?.executeId ? await runtime.executeId(options.request) : createId();
     const logger = createLogger(runtime, pathString, executeId);
     runtime.runtime.request.set(executeId, { logger: logger });
     const response: MilkioHttpResponse = {
@@ -62,9 +66,9 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
 
     try {
       const http = (await (async () => {
-        const ip = runtime.realIp ? runtime.realIp(request) : "::1";
+        const ip = runtime.realIp ? runtime.realIp(options.request) : "::1";
         const params = {
-          string: await request.text(),
+          string: await options.request.text(),
           parsed: undefined,
         };
 
@@ -73,14 +77,19 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
           ip,
           path: { string: pathString as keyof $types["generated"]["routeSchema"]["$types"], array: pathArray },
           params,
-          request,
+          request: options.request,
           response,
         } as ContextHttp;
       })())!;
 
       await runtime.emit("milkio:httpRequest", { executeId, logger, path: http.path.string as string, http });
 
-      if (!request.headers.get("Accept")?.startsWith("text/event-stream")) {
+      if (!runtime.develop && ((http.path.string as string).includes("__") || (http.path.string as string).startsWith("/$call/"))) {
+        await runtime.emit("milkio:httpNotFound", { executeId, logger, path: http.path.string as string, http });
+        throw reject("NOT_FOUND", { path: http.path.string as string });
+      }
+
+      if (!options.request.headers.get("Accept")?.startsWith("text/event-stream")) {
         // action
         const routeSchema = generated.routeSchema.routes.get(http.path.string);
         if (routeSchema === undefined) {
@@ -89,17 +98,25 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         }
         if (routeSchema.type !== "action") throw reject("UNACCEPTABLE", { expected: "stream", message: `Not acceptable, the Accept in the request header should be "text/event-stream". If you are using the "@milkio/stargate" package, please add \`type: "stream"\` to the execute options.` });
 
-        const executed = await executer.__call(routeSchema, {
+        const executed = await executer.__execute(options.env, options.envMode, routeSchema, {
           createdExecuteId: executeId,
           createdLogger: logger,
           path: http.path.string as string,
-          headers: request.headers as Headers,
+          headers: options.request.headers as Headers,
           mixinContext: { http },
           params: http.params.string,
           paramsType: "string",
         });
 
-        if (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 });
 
@@ -111,11 +128,11 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         if (routeSchema === undefined) throw reject("NOT_FOUND", { path: http.path.string as string });
         if (routeSchema.type !== "stream") throw reject("UNACCEPTABLE", { expected: "stream", message: `Not acceptable, the Accept in the request header should be "application/json". If you are using the "@milkio/stargate" package, please remove \`type: "stream"\` to the execute options.` });
 
-        const executed = await executer.__call(routeSchema, {
+        const executed = await executer.__execute(options.env, options.envMode, routeSchema, {
           createdExecuteId: executeId,
           createdLogger: logger,
           path: http.path.string as string,
-          headers: request.headers as Headers,
+          headers: options.request.headers as Headers,
           mixinContext: { http },
           params: http.params.string,
           paramsType: "string",
@@ -132,7 +149,7 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
               try {
                 controller.write(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\n\n`);
                 for await (const value of executed.results.value) {
-                  if (!request.signal.aborted) {
+                  if (!options.request.signal.aborted) {
                     const result: string = JSON.stringify([null, TSON.encode(value)]);
                     controller.write(`data:${result}\n\n`);
                   } else {
@@ -161,7 +178,7 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
               try {
                 controller.enqueue(`data:@${JSON.stringify({ success: true, data: undefined, executeId } satisfies MilkioResponseSuccess<any>)}\n\n`);
                 for await (const value of executed.results.value) {
-                  if (!request.signal.aborted) {
+                  if (!options.request.signal.aborted) {
                     const result: string = JSON.stringify([null, TSON.encode(value)]);
                     controller.enqueue(`data:${result}\n\n`);
                   } else {

package/logger/index.ts

@@ -52,7 +52,7 @@ export const createLogger = <MilkioRuntime extends MilkioRuntimeInit<MilkioRunti
     if (!inserting(log)) return log;
 
     logger._.logs.push([...log]);
-    if (runtime.cookbook) {
+    if (runtime.develop) {
       void sendCookbookEvent(runtime, {
         type: "milkio@logger",
         log: log,

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.31",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
@@ -10,10 +10,10 @@
   "dependencies": {
     "@paralleldrive/cuid2": "^2.2.2",
     "@poech/camel-hump-under": "^1.1.0",
-    "@southern-aurora/tson": "^2.0.2",
+    "@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/step/index.ts

@@ -1,5 +1,3 @@
-import type { ToEmptyObject } from "..";
-
 export type Steps<StageT extends Record<any, any>> = {
   step: StepFunction<StageT>;
   run: () => Promise<Remove_<StageT>>;
@@ -9,9 +7,11 @@ type Remove_<T> = {
   [K in keyof T as K extends `_${string}` ? never : K]: T[K];
 };
 
+type ToEmptyObject<T> = T extends undefined | null | never ? {} : T extends object ? T : {};
+
 export type StepFunction<StageT extends Record<any, any>> = <HandlerT extends (stage: Readonly<StageT>) => Record<any, any> | Promise<Record<any, any>>>(handler: HandlerT) => Steps<Awaited<StageT> & ToEmptyObject<Awaited<ReturnType<HandlerT>>>>;
 
-export const createStep = (): Steps<{}>["step"] => {
+export const createStep = (): Steps<{}> => {
   const stepController = {
     $milkioType: "step",
     _steps: [] as Array<(stage: any) => Promise<any>>,
@@ -32,5 +32,5 @@ export const createStep = (): Steps<{}>["step"] => {
       return result;
     },
   };
-  return stepController.step as any as Steps<{}>["step"];
+  return stepController as any as Steps<{}>;
 };

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

@@ -1,4 +1,4 @@
-import { type $rejectCode } from "..";
+import { type $context, type $rejectCode } from "..";
 
 export interface $types {
   [key: string]: Record<any, any>;
@@ -10,7 +10,15 @@ export type Mixin<T, U> = U & Omit<T, keyof U>;
 
 export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
 
-export type ToEmptyObject<T> = T extends undefined | null | never ? {} : T extends object ? T : {};
+export type DBSelect<T extends Record<any, any>, K extends keyof T> = Omit<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>;
+};
+
+export type DBUpdate<T, KO extends keyof T | never = never, TO extends Partial<Omit<T, KO>> = Partial<Omit<T, KO>>> = {
+  [K in keyof TO]?: TO[K] extends null ? undefined : Exclude<TO[K], null>;
+};
 
 export type ExecuteId = string | "global";
 
@@ -20,6 +28,7 @@ export type ExecuteId = string | "global";
 export type GeneratedInit = {
   routeSchema: any;
   commandSchema: any;
+  configSchema: any;
   testSchema: any;
 };
 
@@ -50,21 +59,6 @@ export type Ping =
       },
     ];
 
-export type Execute = <Path extends keyof $types["generated"]["routeSchema"]["$types"]>(
-  path: Path,
-  options?: Mixin<
-    ExecuteOptions,
-    {
-      headers?: Record<string, string>;
-      params?: $types["generated"]["routeSchema"]["$types"][Path]["params"];
-    }
-  >,
-) => $types["generated"]["routeSchema"]["$types"][Path]["🐣"] extends boolean
-  ? // action
-    Promise<[Partial<$rejectCode>, null, ExecuteResultsOption] | [null, ExecuteActionResults<Path>, ExecuteResultsOption]>
-  : // stream
-    Promise<[Partial<$rejectCode>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<$rejectCode>, null] | [null, ExecuteStreamResults<Path>], null>, ExecuteResultsOption]>;
-
 export type ExecuteResultsOption = { executeId: string };
 
 export type ExecuteActionResults<Path extends keyof Generated["routeSchema"]["$types"], Generated extends $types["generated"] = $types["generated"]> = Generated["routeSchema"]["$types"][Path]["result"];

package/utils/send-cookbook-event.ts

@@ -8,7 +8,7 @@ type CookbookEvent = {
 
 export const sendCookbookEvent = async (runtime: MilkioRuntimeInit<MilkioInit>, event: CookbookEvent) => {
   try {
-    const response = await fetch(`http://localhost:${runtime.cookbook?.cookbookPort}/$action`, {
+    const response = await fetch(`http://localhost:${runtime.cookbook.cookbookPort}/$action`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",

package/world/index.ts

@@ -1,9 +1,10 @@
-import { __initCommander, __initListener, __initExecuter, __initEventManager, type ExecuteId, type Logger, type Mixin, type GeneratedInit, type Execute, type Ping, type ContextCreatedHandler, LoggerSubmittingHandler, LoggerInsertingHandler } from "..";
+import { __initCommander, __initListener, __initExecuter, __initEventManager, type ExecuteId, type Logger, type Mixin, type GeneratedInit, type Ping, type LoggerSubmittingHandler, type LoggerInsertingHandler, type $context, $types, __getConfig } from "..";
 import { defineDefaultExecuteIdGenerator } from "../execute/execute-id-generator";
 
 export type MilkioInit = {
   port: number;
-  cookbook?: {
+  develop: boolean;
+  cookbook: {
     cookbookPort: number;
   };
   cors?: {
@@ -24,6 +25,7 @@ export type MilkioRuntimeInit<T extends MilkioInit> = Mixin<
     executeId: (request: Request) => string | Promise<string>;
     runtime: {
       request: Map<ExecuteId, { logger: Logger }>;
+      app: any;
     };
     on: Awaited<ReturnType<typeof __initEventManager>>["on"];
     off: Awaited<ReturnType<typeof __initEventManager>>["off"];
@@ -52,6 +54,8 @@ export const createWorld = async <MilkioOptions extends MilkioInit>(generated: G
   const executer = __initExecuter(generated, _);
   const commander = __initCommander(generated, _);
   const listener = __initListener(generated, _, executer);
+  // functions
+  const getConfig = (namespace: keyof $types["generated"]["configSchema"], env: Record<any, any>, envMode: string) => __getConfig(generated, env, envMode, namespace);
 
   // Initialize the app
   const app = {
@@ -60,16 +64,16 @@ export const createWorld = async <MilkioOptions extends MilkioInit>(generated: G
     on: eventManager.on,
     off: eventManager.off,
     emit: eventManager.emit,
-    // executer
-    _executer: executer,
-    execute: executer.execute,
-    ping: executer.ping,
     // commander
     commander,
     // listener
     listener,
+    // functions
+    getConfig,
   };
 
+  runtime.app = app;
+
   return app as MilkioWorld<MilkioOptions>;
 };
 
@@ -79,12 +83,10 @@ export type MilkioWorld<MilkioOptions extends MilkioInit = MilkioInit> = {
   on: Awaited<ReturnType<typeof __initEventManager>>["on"];
   off: Awaited<ReturnType<typeof __initEventManager>>["off"];
   emit: Awaited<ReturnType<typeof __initEventManager>>["emit"];
-  // executer
-  _executer: Awaited<ReturnType<typeof __initExecuter<MilkioRuntimeInit<MilkioOptions>>>>;
-  execute: Execute;
   ping: (options?: { timeout?: number }) => Promise<Ping>;
   // commander
-  commander: Awaited<ReturnType<typeof __initCommander<MilkioRuntimeInit<MilkioOptions>>>>;
+  commander: Awaited<ReturnType<typeof __initCommander>>;
   // listener
-  listener: Awaited<ReturnType<typeof __initListener<MilkioRuntimeInit<MilkioOptions>>>>;
+  listener: Awaited<ReturnType<typeof __initListener>>;
+  getConfig: <Namespace extends keyof $types["generated"]["configSchema"]>(namespace: Namespace, env: Record<any, any>, envMode: string) => Promise<Readonly<Awaited<ReturnType<$types["generated"]["configSchema"][Namespace][0]>>>>;
 };