milkio 1.0.0-alpha.12 → 1.0.0-alpha.14

package/context/index.ts

@@ -1,4 +1,4 @@
-import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, type Steps, type Execute } from "..";
+import { type MilkioHttpRequest, type MilkioHttpResponse, type $types, type Logger, type Steps, type Mixin, type ExecuteOptions, type Action } from "..";
 
 export interface $context {
   executeId: string;
@@ -6,7 +6,7 @@ export interface $context {
   logger: Logger;
   http?: ContextHttp<Record<any, any>>;
   step: Steps<{}>["step"];
-  execute: Execute;
+  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/execute/index.ts

@@ -5,7 +5,7 @@ import { reject, type $context, type $meta, type ExecuteOptions, type Logger, ty
 import { headersToJSON } from "../utils/headers-to-json";
 
 export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRuntimeInit<MilkioInit>> = MilkioRuntimeInit<MilkioInit>>(generated: GeneratedInit, runtime: MilkioRuntime) => {
-  const __call = async (
+  const __execute = async (
     routeSchema: any,
     options: {
       createdExecuteId: string;
@@ -13,7 +13,6 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
       path: string;
       headers: Record<string, string> | Headers;
       mixinContext: Record<any, any> | undefined;
-      extendContext?: $context;
     } & (
       | {
           params: Record<any, any>;
@@ -61,16 +60,14 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
       params = { ...paramsRand, ...params };
     }
     if (options.mixinContext?.http?.params?.string) options.mixinContext.http.params.parsed = params; // listen でパースしたパラメータを渡す
-    const context =
-      options.extendContext ??
-      ({
-        ...(options.mixinContext ? options.mixinContext : {}),
-        path: options.path,
-        logger: options.createdLogger,
-        executeId: options.createdExecuteId,
-        execute: (path: any, options: any) => runtime.runtime.app.execute(path, options, context),
-        step: createStep(),
-      } as unknown as $context);
+    const context = {
+      ...(options.mixinContext ? options.mixinContext : {}),
+      path: options.path,
+      logger: options.createdLogger,
+      executeId: options.createdExecuteId,
+      call: (module: any, options: any) => __call(context, module, options),
+      step: createStep(),
+    } as unknown as $context;
     const results: Results<unknown> = { value: undefined };
 
     if (runtime.develop) {
@@ -85,85 +82,22 @@ export const __initExecuter = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
       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.` });
     }
 
-    if (!options.extendContext) 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, context });
 
     results.value = await module.default.handler(context, params);
 
-    if (!options.extendContext) await runtime.emit("milkio:executeAfter", { executeId: options.createdExecuteId, logger: options.createdLogger, path: options.path, context, results });
+    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, context?: $context): Promise<any> => {
-    if (!options) options = {};
-
-    const executeId = context?.executeId ?? createId();
-    const logger = context?.logger ?? createLogger(runtime, path, executeId);
-    if (!context?.logger) 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",
-        extendContext: context,
-      });
-
-      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;
-
-              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;
-
-      return [result, null, { executeId: executeId }];
-    }
+  const __call = async (context: $context, module: { default: any }, params?: any): Promise<any> => {
+    const moduleAwaited = await module;
+    return await moduleAwaited.default.handler(context, params);
   };
 
-  const ping = async (): Promise<Ping> => [
-    null,
-    {
-      connect: true,
-      delay: 0,
-      serverTimestamp: Date.now(),
-    },
-  ];
-
   return {
     __call,
-    execute,
-    ping,
+    __execute,
   };
 };

package/listener/index.ts

@@ -80,6 +80,11 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
 
       await runtime.emit("milkio:httpRequest", { executeId, logger, path: http.path.string as string, http });
 
+      if (!runtime.develop && (http.path.string as string).includes("#")) {
+        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 (!request.headers.get("Accept")?.startsWith("text/event-stream")) {
         // action
         const routeSchema = generated.routeSchema.routes.get(http.path.string);
@@ -89,7 +94,7 @@ 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(routeSchema, {
           createdExecuteId: executeId,
           createdLogger: logger,
           path: http.path.string as string,
@@ -111,7 +116,7 @@ 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(routeSchema, {
           createdExecuteId: executeId,
           createdLogger: logger,
           path: http.path.string as string,

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "1.0.0-alpha.12",
+  "version": "1.0.0-alpha.14",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
@@ -10,7 +10,7 @@
   "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"

package/types/index.ts

@@ -56,21 +56,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/world/index.ts

@@ -1,4 +1,4 @@
-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 } from "..";
 import { defineDefaultExecuteIdGenerator } from "../execute/execute-id-generator";
 
 export type MilkioInit = {
@@ -62,10 +62,6 @@ 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
@@ -83,9 +79,6 @@ 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>>>>;