milkio 0.2.13 → 0.2.14

package/defines/define-api.ts

@@ -2,10 +2,7 @@ import type { Meta } from "../../../src/meta";
 import type { Context } from "../../../src/context";
 
 export function defineApi<ApiT extends Api>(api: ApiT): ApiT & { isApi: true } {
-	return {
-		...api,
-		isApi: true,
-	};
+	return { ...api, isApi: true };
 }
 
 export type Api = {

package/defines/define-http-handler.ts

@@ -1,6 +1,6 @@
-import { loggerPushTags, loggerSubmit, useLogger, runtime, MiddlewareEvent } from "..";
+import { loggerPushTags, loggerSubmit, useLogger, runtime, MiddlewareEvent, reject } from "..";
 import type { ExecuteId, MilkioApp, Mixin } from "..";
-import { hanldeCatchError } from "../utils/handle-catch-error";
+import { handleCatchError } from "../utils/handle-catch-error";
 import { routerHandler } from "../../../src/router";
 import schema from "../../../generated/api-schema";
 import { failCode } from "../../../src/fail-code";
@@ -122,13 +122,13 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 			// execute api
 			// after request middleware
 			await MiddlewareEvent.handle("afterHttpRequest", [headers, detail]);
+			const mode = headers.get("Accept") === "text/event-stream" ? "stream" : "execute";
 
 			const rawbody = await request.request.text();
 			loggerPushTags(executeId, {
 				body: rawbody || "no body",
 			});
 
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 			let params: any;
 			if (rawbody === "") {
 				params = undefined;
@@ -146,29 +146,94 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 				params,
 			});
 
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-			// @ts-ignore
-			const result = await app._executeCoreToJson(pathstr, params, headers, {
-				executeId,
-				logger,
-				detail,
-			});
+			const resultsRaw = await app._call(mode, pathstr, params, headers, { executeId, logger, detail });
 
-			// @ts-ignore
-			// eslint-disable-next-line @typescript-eslint/no-confusing-void-expression, @typescript-eslint/no-explicit-any
-			if (!detail.response.body) detail.response.body = result;
+			let fn: any;
+			try {
+				fn = await schema.apiValidator.validate[pathstr]();
+			} catch (error) {
+				throw reject("BUSINESS_FAIL", "This is the new API, which takes effect after restarting the server or saving any changes. It will be fixed in the future.");
+			}
 
-			// before response middleware
-			const middlewareResponse = {
-				value: detail.response.body,
-			};
-			await MiddlewareEvent.handle("beforeHttpResponse", [middlewareResponse, detail]);
+			if (mode === "execute") {
+				const result: string = await fn.validateResults(TSON.encode(resultsRaw.$result));
+				if (!detail.response.body) detail.response.body = result;
+
+				// before response middleware
+				const middlewareResponse = {
+					value: detail.response.body,
+				};
+				await MiddlewareEvent.handle("beforeHttpResponse", [middlewareResponse, detail]);
 
-			if (!detail.response.headers["Content-Type"]) detail.response.headers["Content-Type"] = "application/json";
-			if (!detail.response.headers["Cache-Control"]) detail.response.headers["Cache-Control"] = "no-cache";
-			if (!detail.response.body) detail.response.body = middlewareResponse.value;
+				if (!detail.response.headers["Content-Type"]) detail.response.headers["Content-Type"] = "application/json";
+				if (!detail.response.headers["Cache-Control"]) detail.response.headers["Cache-Control"] = "no-cache";
+				if (!detail.response.body) detail.response.body = middlewareResponse.value;
+			}
+
+			if (mode === "stream") {
+				const generator = (resultsRaw as any).$generator as AsyncGenerator;
+				let stream: ReadableStream;
+				let control: ReadableStreamDirectController | ReadableStreamDefaultController;
+				// SSE has a default timeout, which helps prevent memory leaks, especially when you are writing code with a while (true) loop
+
+				if (global?.Bun) {
+					// bun
+					stream = new ReadableStream({
+						type: "direct",
+						async pull(controller: ReadableStreamDirectController) {
+							control = controller;
+							try {
+								for await (const value of generator) {
+									if (!request.request.signal.aborted) {
+										const result: string = JSON.stringify(TSON.encode(value));
+										controller.write(`data:${result}\n\n`);
+									} else {
+										generator.return(undefined);
+										controller.close();
+									}
+								}
+							} catch (error) {
+								controller.close();
+								throw error;
+							}
+							controller.close();
+						},
+						cancel() {
+							control.close();
+						},
+					} as unknown as UnderlyingByteSource);
+				} else {
+					// node.js or others
+					stream = new ReadableStream({
+						async pull(controller) {
+							control = controller;
+							try {
+								for await (const value of generator) {
+									if (!request.request.signal.aborted) {
+										const result: string = JSON.stringify(TSON.encode(value));
+										controller.enqueue(`data:${result}\n\n`);
+									} else {
+										generator.return(undefined);
+										controller.close();
+									}
+								}
+							} catch (error) {
+								controller.close();
+								throw error;
+							}
+							controller.close();
+						},
+						cancel() {
+							control.close();
+						},
+					});
+				}
+				detail.response.headers["Content-Type"] = "text/event-stream";
+				detail.response.headers["Cache-Control"] = "no-cache";
+				detail.response.body = stream;
+			}
 		} catch (error) {
-			const result = hanldeCatchError(error, executeId);
+			const result = handleCatchError(error, executeId);
 			if (!response.headers["Content-Type"]) response.headers["Content-Type"] = "application/json";
 			if (!response.headers["Cache-Control"]) response.headers["Cache-Control"] = "no-cache";
 			if (!response.body) response.body = TSON.stringify(result);
@@ -177,7 +242,6 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 		loggerPushTags(executeId, {
 			status: response.status,
 			responseHeaders: response.headers,
-			// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
 			body: response.body?.toString() ?? "",
 			timeout: new Date().getTime(),
 		});

package/kernel/execute.ts

@@ -0,0 +1,146 @@
+import type { Context } from "../../../src/context";
+import { failCode } from "../../../src/fail-code";
+import schema from "../../../generated/api-schema";
+import { type ExecuteId, type ExecuteOptions, type ExecuteResult, createUlid, useLogger, runtime, loggerPushTags, headerToPlainObject, loggerSubmit, type ExecuteCoreOptions, TSON, MiddlewareEvent, reject, _validate } from "..";
+import { handleCatchError } from "../utils/handle-catch-error";
+
+const apis = new Map<string, any>();
+
+/**
+ * call is a low-level API that is useful only when you want to execute the Milkio Api without using execute or httpServer.
+ * It only does the most basic thing internally, which is calling the API. The external handling of functions such as making executeId, logging, middleware, etc., are all handled externally.
+ * Both execute and httpServer essentially call call.
+ */
+export async function _call(
+	mode: "execute" | "stream",
+	path: string,
+	params: unknown | string,
+	headersInit: Record<string, string> | Headers = {},
+	options: ExecuteCoreOptions,
+): Promise<{ $type: "result"; $result: ExecuteResult<unknown> } | { $type: "stream"; $result: ExecuteResult<unknown>; $generator: AsyncGenerator }> {
+	const executeId = options.executeId as ExecuteId;
+
+	params = TSON.decode(params);
+
+	if (!(path in schema.apiMethodsSchema)) {
+		const result = {
+			executeId,
+			success: false,
+			fail: {
+				code: "NOT_FOUND",
+				message: failCode.NOT_FOUND(),
+				data: undefined,
+			},
+		} as ExecuteResult<unknown>;
+
+		return { $type: "result", $result: result };
+	}
+
+	let headers: Headers;
+	if (!(headersInit instanceof Headers)) {
+		// @ts-ignore
+		headers = new Headers({
+			...headersInit,
+		});
+	} else {
+		headers = headersInit;
+	}
+
+	if (options?.onAfterHeaders) {
+		await options.onAfterHeaders(headers);
+	}
+
+	const context: Context = {
+		executeId,
+		path: path as string,
+		headers,
+		logger: options.logger,
+		detail: options?.detail ?? {},
+	};
+
+	let result: { value: unknown };
+	try {
+		// before execute middleware
+		await MiddlewareEvent.handle("beforeExecute", [context]);
+
+		let fn: any;
+		// check type
+		try {
+			// @ts-ignore
+			fn = await schema.apiValidator.validate[path]();
+		} catch (error) {
+			throw reject("BUSINESS_FAIL", "This is the new API, which takes effect after restarting the server or saving any changes. It will be fixed in the future.");
+		}
+		params = _validate(await fn.validateParams(params));
+
+		// execute api
+		let api: any;
+		if (apis.has(path as string)) api = apis.get(path as string);
+		else {
+			// @ts-ignore
+			api = schema.apiMethodsSchema[path as string]();
+			apis.set(path as string, api);
+		}
+		const apiModuleAwaited = await api.module;
+		const apiMethod = apiModuleAwaited.api.action;
+		// @ts-ignore
+		result = { value: await apiMethod(params, context) };
+		// after execute middleware
+		await MiddlewareEvent.handle("afterExecute", [context, result]);
+
+		if (mode === "execute" && !(result.value as AsyncGenerator)[Symbol.asyncIterator]) return { $type: "result", $result: { executeId, success: true, data: result.value } };
+		if (mode === "stream" && (result.value as AsyncGenerator)[Symbol.asyncIterator]) return { $type: "stream", $result: { executeId, success: true, data: "$" }, $generator: result.value as AsyncGenerator };
+		throw reject("BUSINESS_FAIL", `It looks like you used the wrong syntax, for this API you should use "client.${mode}(...)"`);
+	} catch (error: any) {
+		const errorResult = handleCatchError(error, executeId);
+
+		return { $type: "result", $result: errorResult };
+	}
+}
+
+export async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
+	path: Path,
+	params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
+	headersInit: Record<string, string> | Headers = {},
+	options?: ExecuteOptions,
+): Promise<ExecuteResult<Result>> {
+	const executeId = (options?.executeId ?? createUlid()) as ExecuteId;
+	const logger = useLogger(executeId);
+	runtime.execute.executeIds.add(executeId);
+
+	loggerPushTags(executeId, {
+		from: "execute",
+		executeId,
+		params,
+		path,
+	});
+
+	const result = await _call("execute", path, params, headersInit, {
+		...options,
+		executeId,
+		logger,
+		onAfterHeaders: (headers) => {
+			loggerPushTags(executeId, {
+				headers: headerToPlainObject(headers),
+			});
+		},
+	});
+
+	loggerPushTags(executeId, { result: result.$result });
+	await loggerSubmit(executeId);
+	runtime.execute.executeIds.delete(executeId);
+
+	return result.$result as ExecuteResult<Result>;
+}
+
+export async function _executeToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options?: ExecuteOptions): Promise<string> {
+	const resultsRaw = await _execute(path, params, headersInit, options);
+	let fn: any;
+	try {
+		fn = await schema.apiValidator.validate[path]();
+	} catch (error) {
+		throw reject("BUSINESS_FAIL", "This is the new API, which takes effect after restarting the server or saving any changes. It will be fixed in the future.");
+	}
+	const results = await fn.validateResults(TSON.encode(resultsRaw));
+	return results;
+}

package/kernel/milkio.ts

@@ -1,13 +1,9 @@
 import { type MiddlewareOptions, _middlewares, MiddlewareEvent } from "./middleware";
 import schema from "../../../generated/api-schema";
-import type { Context } from "../../../src/context";
-import { failCode } from "../../../src/fail-code";
-import type { MilkioContext } from "./context";
-import { headerToPlainObject } from "../utils/header-to-plain-object";
-import { type Mixin, type ExecuteId, type Fail, type FailEnumerates, loggerPushTags, loggerSubmit, runtime, TSON, type Logger, useLogger, reject } from "..";
-import { hanldeCatchError } from "../utils/handle-catch-error";
+import { runtime } from "..";
 import { createUlid } from "../utils/create-ulid";
 import { _validate } from "./validate";
+import { _execute, _call, _executeToJson } from "./execute";
 
 export type MilkioAppOptions = {
 	/**
@@ -45,11 +41,10 @@ export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
 	}
 
 	const MilkioApp = {
+		randParams: _randParams,
 		execute: _execute,
 		executeToJson: _executeToJson,
-		_executeCore,
-		_executeCoreToJson,
-		randParams: _randParams,
+		_call,
 	};
 
 	if (MilkioAppOptions.bootstraps) {
@@ -86,202 +81,6 @@ export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
 	return MilkioApp;
 }
 
-async function _execute<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
-	path: Path,
-	params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
-	headersInit: Record<string, string> | Headers = {},
-	options?: ExecuteOptions,
-): Promise<ExecuteResult<Result>> {
-	const executeId = (options?.executeId ?? createUlid()) as ExecuteId;
-	const logger = useLogger(executeId);
-	runtime.execute.executeIds.add(executeId);
-
-	loggerPushTags(executeId, {
-		from: "execute",
-		executeId,
-		params,
-		path,
-	});
-
-	const result: any = await _executeCore(path, params, headersInit, {
-		...options,
-		executeId,
-		logger,
-		onAfterHeaders: (headers) => {
-			loggerPushTags(executeId, {
-				headers: headerToPlainObject(headers),
-			});
-		},
-	});
-
-	loggerPushTags(executeId, { result });
-	await loggerSubmit(executeId);
-	runtime.execute.executeIds.delete(executeId);
-
-	return result;
-}
-
-/**
- * executeCore is a low-level API that is useful only when you want to execute the Milkio Api without using execute or httpServer.
- * It only does the most basic thing internally, which is calling the API. The external handling of functions such as making executeId, logging, middleware, etc., are all handled externally.
- * Both execute and httpServer essentially call executeCore.
- */
-async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
-	path: Path,
-	params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
-	headersInit: Record<string, string> | Headers = {},
-	options: ExecuteCoreOptions,
-): Promise<ExecuteResult<Result>> {
-	const executeId = options.executeId as ExecuteId;
-
-	params = TSON.decode(params);
-
-	if (!(path in schema.apiMethodsSchema)) {
-		const result = {
-			executeId,
-			success: false,
-			fail: {
-				code: "NOT_FOUND",
-				message: failCode.NOT_FOUND(),
-				data: undefined,
-			},
-		} satisfies ExecuteResult<Result>;
-
-		return result;
-	}
-
-	let headers: Headers;
-	if (!(headersInit instanceof Headers)) {
-		// @ts-ignore
-		headers = new Headers({
-			...headersInit,
-		});
-	} else {
-		headers = headersInit;
-	}
-
-	if (options?.onAfterHeaders) {
-		await options.onAfterHeaders(headers);
-	}
-
-	const context: Context = {
-		executeId,
-		path,
-		headers,
-		logger: options.logger,
-		detail: options?.detail ?? {},
-	};
-
-	let result: { value: Result };
-	try {
-		// before execute middleware
-		await MiddlewareEvent.handle("beforeExecute", [context]);
-
-		let fn: any;
-		// check type
-		// @ts-ignore
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-		try {
-			fn = await schema.apiValidator.validate[path]();
-		} catch (error) {
-			throw reject("BUSINESS_FAIL", "This is the new API, which takes effect after restarting the server or saving any changes. It will be fixed in the future.");
-		}
-
-		params = _validate(await fn.validateParams(params));
-
-		// execute api
-		let api: any;
-		if (apis.has(path)) api = apis.get(path);
-		else {
-			// @ts-ignore
-			api = schema.apiMethodsSchema[path]();
-			apis.set(path, api);
-		}
-		const apiModuleAwaited = await api.module;
-
-		const apiMethod = apiModuleAwaited.api.action;
-
-		// @ts-ignore
-		result = { value: await apiMethod(params, context) };
-
-		// after execute middleware
-		await MiddlewareEvent.handle("afterExecute", [context, result]);
-	} catch (error: any) {
-		const errorResult = hanldeCatchError(error, executeId);
-
-		return errorResult;
-	}
-
-	return {
-		executeId,
-		success: true,
-		data: result.value,
-	};
-}
-
-async function _executeToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options?: ExecuteOptions): Promise<string> {
-	const resultsRaw = await _execute(path, params, headersInit, options);
-	let fn: any;
-	try {
-		fn = await schema.apiValidator.validate[path]();
-	} catch (error) {
-		throw reject("BUSINESS_FAIL", "This is the new API, which takes effect after restarting the server or saving any changes. It will be fixed in the future.");
-	}
-	const results = await fn.validateResults(TSON.encode(resultsRaw));
-	return results;
-}
-
-async function _executeCoreToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options: ExecuteCoreOptions): Promise<string> {
-	const resultsRaw = await _executeCore(path, params, headersInit, options);
-	let fn: any;
-	try {
-		fn = await schema.apiValidator.validate[path]();
-	} catch (error) {
-		throw reject("BUSINESS_FAIL", "This is the new API, which takes effect after restarting the server or saving any changes. It will be fixed in the future.");
-	}
-	const results = await fn.validateResults(TSON.encode(resultsRaw));
-	return results;
-}
-
 export async function _randParams<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path): Promise<Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0]> {
 	return await (await schema.apiValidator.validate[path]()).randParams();
 }
-
-const apis = new Map<string, any>();
-
-export type ExecuteResult<Result> = ExecuteResultSuccess<Result> | ExecuteResultFail;
-
-export type ExecuteResultSuccess<Result> = {
-	executeId: ExecuteId;
-	success: true;
-	data: Result;
-};
-
-export type ExecuteResultFail<FailT extends Fail<keyof FailEnumerates> = Fail<keyof FailEnumerates>> = {
-	executeId: ExecuteId;
-	success: false;
-	fail: FailT;
-};
-
-export type ExecuteOptions = {
-	/**
-	 * The executeId of the request
-	 * executeId may be generated by the serverless provider, if not, a random string will be generated instead
-	 */
-	executeId?: string;
-	/**
-	 * Additional information about the request
-	 * These are usually only fully implemented when called by an Http server
-	 * During testing or when calling between microservices, some or all of the values may be undefined
-	 */
-	detail?: MilkioContext["detail"];
-};
-
-export type ExecuteCoreOptions = Mixin<
-	ExecuteOptions,
-	{
-		executeId: string;
-		logger: Logger;
-		onAfterHeaders?: (headers: Headers) => void | Promise<void>;
-	}
->;

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/types.ts

@@ -1,6 +1,12 @@
-import type { createMilkioApp } from ".";
+import type { Logger, MilkioContext, createMilkioApp } from ".";
 import type { failCode } from "../../src/fail-code";
 
+export type Override<P, S> = Omit<P, keyof S> & S;
+
+export type Mixin<T, U> = U & Omit<T, keyof U>;
+
+export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
+
 export type MilkioApp = Awaited<ReturnType<typeof createMilkioApp>>;
 
 export type ExecuteId = string | "global";
@@ -33,10 +39,6 @@ export type CookbookItem = {
 	}>;
 };
 
-export type Override<P, S> = Omit<P, keyof S> & S;
-
-export type Mixin<T, U> = U & Omit<T, keyof U>;
-
 export type MilkioConfig = {
 	generate?: {
 		significant?: Array<string>;
@@ -47,3 +49,42 @@ export type MilkioConfig = {
 		commands?: Array<{ name?: string; script?: string; icon?: string }>;
 	};
 };
+
+export type ExecuteResult<Result> = ExecuteResultSuccess<Result> | ExecuteResultFail;
+
+export type ExecuteResultSuccess<Result> = {
+	executeId: ExecuteId;
+	success: true;
+	data: Result;
+};
+
+export type ExecuteResultFail<FailT extends Fail<keyof FailEnumerates> = Fail<keyof FailEnumerates>> = {
+	executeId: ExecuteId;
+	success: false;
+	fail: FailT;
+};
+
+export type ExecuteOptions = {
+	/**
+	 * The executeId of the request
+	 * executeId may be generated by the serverless provider, if not, a random string will be generated instead
+	 */
+	executeId?: string;
+	/**
+	 * Additional information about the request
+	 * These are usually only fully implemented when called by an Http server
+	 * During testing or when calling between microservices, some or all of the values may be undefined
+	 */
+	detail?: MilkioContext["detail"];
+};
+
+export type ExecuteCoreOptions = Mixin<
+	ExecuteOptions,
+	{
+		executeId: string;
+		logger: Logger;
+		onAfterHeaders?: (headers: Headers) => void | Promise<void>;
+	}
+>;
+
+export type MilkioEvent<Result> = Awaited<GeneratorGeneric<ExecuteResultSuccess<Result>["data"] extends { $type: any } ? ExecuteResultSuccess<Result>["data"]["$type"] : never>>;

package/utils/handle-catch-error.ts

@@ -3,7 +3,7 @@ import { useLogger, type ExecuteId, type ExecuteResult } from "..";
 import { configMilkio } from "../../../src/config/milkio";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function hanldeCatchError(error: any, executeId: ExecuteId): ExecuteResult<any> {
+export function handleCatchError(error: any, executeId: ExecuteId): ExecuteResult<any> {
 	const logger = useLogger(executeId);
 
 	if (configMilkio.debug === true) {