milkio 1.0.0-alpha.16 → 1.0.0-alpha.17

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

@@ -2,10 +2,12 @@ import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logg
 
 export interface $context {
   executeId: string;
+  environment: string;
   path: string;
   logger: Logger;
   http?: ContextHttp<Record<any, any>>;
   step: Steps<{}>["step"];
+  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"]>>;
 }
 

package/execute/index.ts

@@ -1,11 +1,12 @@
 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, createStep } from "..";
+import { reject, type $context, type $meta, type Logger, type MilkioRuntimeInit, type Results, type GeneratedInit, type MilkioInit, createStep, getConfig } from "..";
 import { headersToJSON } from "../utils/headers-to-json";
 
 export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
   const __execute = async (
+    env: Record<any, any> | undefined,
+    envMode: string | undefined,
     routeSchema: any,
     options: {
       createdExecuteId: string;
@@ -24,7 +25,9 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         }
     ),
   ): Promise<{ executeId: string; headers: Headers; params: Record<any, unknown>; results: Results<any>; context: $context; meta: Readonly<$meta>; type: "action" | "stream" }> => {
-    const executeId = options.createdExecuteId;
+    const executeId: string = options.createdExecuteId;
+    env = env ?? {};
+    envMode = envMode ?? "production";
     let headers: Headers;
     if (!(options.headers instanceof Headers)) {
       // @ts-ignore
@@ -62,9 +65,11 @@ 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 : {}),
+      envMode,
       path: options.path,
       logger: options.createdLogger,
       executeId: options.createdExecuteId,
+      getConfig: (namespace: string) => getConfig(generated, env, envMode, namespace),
       call: (module: any, options: any) => __call(context, module, options),
       step: createStep(),
     } as unknown as $context;

package/index.ts

@@ -1,4 +1,5 @@
 export * from "./types";
+export * from "./config";
 export * from "./execute";
 export * from "./events";
 export * from "./world";

package/listener/index.ts

@@ -16,8 +16,12 @@ export type MilkioHttpResponse = Mixin<
 
 export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime, 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,7 +77,7 @@ 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;
       })())!;
@@ -85,7 +89,7 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         throw reject("NOT_FOUND", { path: http.path.string as string });
       }
 
-      if (!request.headers.get("Accept")?.startsWith("text/event-stream")) {
+      if (!options.request.headers.get("Accept")?.startsWith("text/event-stream")) {
         // action
         const routeSchema = generated.routeSchema.routes.get(http.path.string);
         if (routeSchema === undefined) {
@@ -94,11 +98,11 @@ 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.__execute(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",
@@ -116,11 +120,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.__execute(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",
@@ -137,7 +141,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 {
@@ -166,7 +170,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/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "1.0.0-alpha.16",
+  "version": "1.0.0-alpha.17",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/types/index.ts

@@ -26,6 +26,7 @@ export type ExecuteId = string | "global";
 export type GeneratedInit = {
   routeSchema: any;
   commandSchema: any;
+  configSchema: any;
   testSchema: any;
 };