milkio 1.0.0-alpha.4 → 1.0.0-alpha.41

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/command/index.ts

@@ -1,4 +1,4 @@
-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>;
@@ -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,33 @@
+export const config = <ConfigT extends Config>(config: ConfigT): ConfigT => {
+  return config;
+};
+
+export type Config = (mode: string) => Promise<Record<string, unknown>> | Record<string, unknown>;
+
+export type 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,17 +1,20 @@
-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>>;
+  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> };
+  path: { string: keyof $types["generated"]["routeSchema"]; array: Array<string> };
   params: {
     string: string;
     parsed: ParamsParsed;

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,10 @@
-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 } 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 (
     routeSchema: any,
     options: {
       createdExecuteId: string;
@@ -23,8 +22,8 @@ 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;
     let headers: Headers;
     if (!(options.headers instanceof Headers)) {
       // @ts-ignore
@@ -62,102 +61,58 @@ 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,
       path: options.path,
       logger: options.createdLogger,
       executeId: options.createdExecuteId,
-      step: createStep(),
+      config: runtime.runtime.config,
+      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.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,14 @@ 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();
+    console.log("executeId", await runtime.executeId(options.request), createId());
+
     const logger = createLogger(runtime, pathString, executeId);
     runtime.runtime.request.set(executeId, { logger: logger });
     const response: MilkioHttpResponse = {
@@ -62,44 +68,57 @@ 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,
         };
 
         return {
           url,
           ip,
-          path: { string: pathString as keyof $types["generated"]["routeSchema"]["$types"], array: pathArray },
+          path: { string: pathString as keyof $types["generated"]["routeSchema"], 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("/__/"))) {
+        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);
+        const routeSchema = generated.routeSchema[http.path.string];
         if (routeSchema === undefined) {
           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 (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,
-          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 });
 
@@ -107,15 +126,15 @@ export const __initListener = <MilkioRuntime extends MilkioRuntimeInit<MilkioRun
         return new Response(response.body, response);
       } else {
         // stream
-        const routeSchema = generated.routeSchema.routes.get(http.path.string);
+        const routeSchema = generated.routeSchema[http.path.string];
         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,
-          headers: request.headers as Headers,
+          headers: options.request.headers as Headers,
           mixinContext: { http },
           params: http.params.string,
           paramsType: "string",
@@ -132,7 +151,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 +180,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,18 +2,18 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0-alpha.41",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
   "scripts": {},
   "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"
+    "milkid": "2.0.6",
+    "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,7 +28,6 @@ export type ExecuteId = string | "global";
 export type GeneratedInit = {
   routeSchema: any;
   commandSchema: any;
-  testSchema: any;
 };
 
 export type Results<T extends unknown> = {
@@ -50,27 +57,12 @@ 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"];
+export type ExecuteActionResults<Path extends keyof Generated["routeSchema"], Generated extends $types["generated"] = $types["generated"]> = Generated["routeSchema"][Path]["result"];
 
-export type ExecuteStreamResults<Path extends keyof Generated["routeSchema"]["$types"], Generated extends $types["generated"] = $types["generated"]> = GeneratorGeneric<Generated["routeSchema"]["$types"][Path]["result"]>;
+export type ExecuteStreamResults<Path extends keyof Generated["routeSchema"], Generated extends $types["generated"] = $types["generated"]> = GeneratorGeneric<Generated["routeSchema"][Path]["result"]>;
 
 export type MilkioResponseReject<Code extends keyof $rejectCode = keyof $rejectCode> = { success: false; code: Code; reject: $rejectCode[Code]; executeId: string };
 
-export type MilkioResponseSuccess<Path extends keyof Generated["routeSchema"]["$types"], Generated extends $types["generated"] = $types["generated"]> = { success: true; data: Generated["routeSchema"]["$types"][Path]["result"]; executeId: string };
+export type MilkioResponseSuccess<Path extends keyof Generated["routeSchema"], Generated extends $types["generated"] = $types["generated"]> = { success: true; data: Generated["routeSchema"][Path]["result"]; executeId: string };

package/utils/create-id.ts

@@ -1,3 +1,11 @@
-import { createId as _createId } from "@paralleldrive/cuid2";
+import { defineIdGenerator } from "milkid";
 
-export const createId = _createId;
+const idGenerator = defineIdGenerator({
+  length: 32,
+  hyphen: false,
+  fingerprint: false,
+  timestamp: true,
+  sequential: false,
+});
+
+export const createId = idGenerator.createId;