milkio 0.8.2 → 1.0.0-alpha.0

package/defines/define-http-handler.ts

@@ -1,291 +0,0 @@
-import { loggerPushTags, loggerSubmit, useLogger, runtime, MiddlewareEvent, reject } from "..";
-import type { ExecuteId, MilkioApp, Mixin } from "..";
-import { handleCatchError } from "../utils/handle-catch-error";
-import { routerHandler } from "../../../src/router";
-import schema from "../../../generated/api-schema";
-import { failCode } from "../../../src/fail-code";
-import { TSON } from "@southern-aurora/tson";
-import { createUlid } from "../utils/create-ulid";
-import { configMilkio } from "../../../src/config/milkio";
-import { headerToPlainObject } from "../utils/header-to-plain-object";
-
-export type ExecuteHttpServerOptions = {
-	/**
-	 * The execution ID generator
-	 * If you have enabled this option, the executeId will be generated each time by calling this method. Otherwise, it will be generated using the built-in method.
-	 *
-	 * @param request
-	 * @returns
-	 */
-	executeIdGenerator?: (request: Request) => string | Promise<string>;
-	getRealIp?: (request: Request) => string;
-	mixin?: Record<string, unknown>;
-};
-
-export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOptions = {}) {
-	const fetch = async (request: MilkioHttpRequest) => {
-		const fullurl = new URL(request.request.url, `http://${request.request.headers.get("host") ?? "localhost"}`);
-		const executeId = (options?.executeIdGenerator ? await options.executeIdGenerator(request.request) : createUlid()) as ExecuteId;
-		runtime.execute.executeIds.add(executeId);
-		const logger = useLogger(executeId);
-		const ip = options.getRealIp ? options.getRealIp(request.request) : (request.request.headers.get("X-Forwarded-For") as string | undefined)?.split(",")[0] ?? "0.0.0.0";
-		const headers = request.request.headers as Headers;
-
-		loggerPushTags(executeId, {
-			from: "http-server",
-			url: fullurl.pathname,
-			ip,
-			method: request.request.method,
-			// @ts-ignore
-			requestHeaders: headerToPlainObject(request.request.headers),
-			timein: new Date().getTime(),
-		});
-
-		const response: MilkioHttpResponse = {
-			body: "",
-			status: 200,
-			headers: {
-				"Content-Type": "application/json",
-				"Access-Control-Allow-Methods": configMilkio.corsAllowMethods ?? "*",
-				"Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
-				"Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*",
-			},
-		};
-
-		try {
-			// Process OPTIONS pre inspection requests
-			if (request.request.method === "OPTIONS") {
-				await loggerSubmit(executeId);
-				runtime.execute.executeIds.delete(executeId);
-
-				return new Response("", {
-					headers: {
-						"Access-Control-Allow-Methods": configMilkio.corsAllowMethods ?? "*",
-						"Access-Control-Allow-Headers": configMilkio.corsAllowHeaders ?? "*",
-						"Access-Control-Allow-Origin": configMilkio.corsAllowOrigin ?? "*",
-					},
-				});
-			}
-
-			let path = fullurl.pathname.substring(1).split("/");
-
-			// Compatible with API gateway's ability to differentiate versions by path
-			// see: /src/config/ConfigProgram.ts in "ignorePathLevel"
-			if (configMilkio.ignorePathLevel !== 0) path = path.slice(configMilkio.ignorePathLevel);
-
-			let pathstr = path.join("/") as keyof (typeof schema)["apiMethodsSchema"];
-
-			const detail = {
-				...(options.mixin ?? {}),
-				path: pathstr,
-				ip,
-				executeId,
-				fullurl: fullurl as URL,
-				request: request.request,
-				response,
-			};
-
-			// Special processing: do not run middleware when encountering 404 and return quickly
-			if (!(pathstr in schema.apiMethodsSchema) || pathstr.startsWith("$/")) {
-				// @ts-ignore
-				const redirectPath = await routerHandler(pathstr, fullurl);
-				if (!redirectPath) {
-					const rawbody = await request.request.text();
-					loggerPushTags(executeId, {
-						body: rawbody || "no body",
-					});
-
-					if (!detail.response.body) {
-						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";
-						detail.response.body = `{"executeId":"${executeId}","success":false,"fail":{"code":"NOT_FOUND","message":"${failCode.NOT_FOUND(undefined)}"}}`;
-					}
-					await MiddlewareEvent.handle("httpNotFound", [detail]);
-
-					loggerPushTags(executeId, {
-						status: detail.response.status,
-						responseHeaders: detail.response.headers,
-						timeout: new Date().getTime(),
-					});
-
-					await loggerSubmit(executeId);
-					runtime.execute.executeIds.delete(executeId);
-
-					return new Response(detail.response.body, detail.response);
-				}
-
-				pathstr = redirectPath as typeof pathstr;
-			}
-
-			loggerPushTags(executeId, {
-				path: pathstr,
-			});
-
-			// 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",
-			});
-
-			let params: any;
-			try {
-				if (rawbody) params = JSON.parse(rawbody);
-				else params = undefined;
-				// Doing so may pose security risks, as attackers may trigger your requests through link redirection without being protected by browser CORS.
-				// Therefore, this feature was commented out after v0.3.0.
-				// else if (request.request.method === 'GET' && fullurl.searchParams.get('params')) {  params = JSON.parse(decodeURIComponent(fullurl.searchParams.get('params')!)); }
-			} catch (error) {
-				const logger = useLogger(executeId);
-				logger.log("TIP: body is not json, the content is not empty, but the content is not in a valid JSON format. The original content value can be retrieved via request.request.text()");
-				params = undefined;
-			}
-
-			loggerPushTags(executeId, {
-				params,
-			});
-
-			const resultsRaw = await app._call(mode, pathstr, params, headers, { executeId, logger, detail });
-
-			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.");
-			}
-
-			if (mode === "execute") {
-				const result: string = JSON.stringify(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 (mode === "stream") {
-				let stream: ReadableStream;
-				let control: ReadableStreamDirectController | ReadableStreamDefaultController;
-
-				// Handshake failure (usually due to incorrect parameters)
-				if (resultsRaw.$type === "result" && resultsRaw.$result.success === false) {
-					stream = new ReadableStream({
-						async pull(controller) {
-							control = controller;
-							controller.enqueue(`data:@${JSON.stringify(TSON.encode(resultsRaw.$result))}\n\n`);
-							controller.close();
-						},
-						cancel() {
-							control.close();
-						},
-					});
-				} else {
-					// Handshake successful
-					const generator = (resultsRaw as any).$generator as AsyncGenerator;
-					// 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 {
-									controller.write(`data:@${JSON.stringify(TSON.encode(resultsRaw.$result))}\n\n`);
-									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) {
-									const result = handleCatchError(error, executeId);
-									controller.write(`data:@${JSON.stringify(TSON.encode(result))}\n\n`);
-								}
-								await new Promise((resolve) => setTimeout(resolve, 0));
-								controller.close();
-							},
-							cancel() {
-								control.close();
-							},
-						});
-					} else {
-						// node.js or others
-						stream = new ReadableStream({
-							async pull(controller) {
-								control = controller;
-								try {
-									controller.enqueue(`data:@${JSON.stringify(TSON.encode(resultsRaw.$result))}\n\n`);
-									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) {
-									const result = handleCatchError(error, executeId);
-									controller.enqueue(`data:@${JSON.stringify(TSON.encode(result))}\n\n`);
-								}
-								await new Promise((resolve) => setTimeout(resolve, 0));
-								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 = 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);
-		}
-
-		loggerPushTags(executeId, {
-			status: response.status,
-			responseHeaders: response.headers,
-			body: response.body?.toString() ?? "",
-			timeout: new Date().getTime(),
-		});
-
-		await loggerSubmit(executeId);
-		runtime.execute.executeIds.delete(executeId);
-
-		return new Response(response.body, response);
-	};
-
-	return fetch;
-}
-
-export type MilkioHttpRequest = {
-	request: Request;
-};
-
-export type MilkioHttpResponse = Mixin<
-	ResponseInit,
-	{
-		body: string | Blob | FormData | URLSearchParams | ReadableStream<Uint8Array>;
-		status: number;
-		headers: Record<string, string>;
-	}
->;

package/defines/define-middleware.ts

@@ -1,9 +0,0 @@
-import type { MiddlewareOptions } from "..";
-
-export function defineMiddleware(options: MiddlewareOptions): () => MiddlewareOptions {
-	return () => ({
-		...options,
-		// @ts-ignore
-		isMiddleware: true,
-	});
-}

package/defines/define-use.ts

@@ -1,12 +0,0 @@
-export const defineUse = <CreatorFn extends () => Promise<unknown> | unknown>(creatorFn: CreatorFn): (() => Promise<Awaited<ReturnType<CreatorFn>>>) => {
-	let use: any | undefined;
-
-	const getUse = async () => {
-		if (use === undefined) {
-			use = await creatorFn();
-		}
-		return use;
-	};
-
-	return getUse;
-};

package/kernel/context.ts

@@ -1,55 +0,0 @@
-import type { ExecuteId, Logger, MilkioHttpResponse, Mixin, ToEmptyObject, Remove$ } from "..";
-
-export type MilkioContext = {
-	path: string;
-	executeId: ExecuteId;
-	headers: Headers;
-	logger: Logger;
-	/**
-	 * 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: FrameworkHttpDetail;
-	step: Steps<{}>["step"];
-};
-
-export type FrameworkHttpDetail = {
-	path: string;
-	executeId: ExecuteId;
-	fullurl: URL;
-	ip: string;
-	request: Request;
-	response: MilkioHttpResponse;
-};
-
-export type Steps<StageT extends Record<any, any>> = {
-	step: StepFunction<StageT>;
-	// run: <HandlerT extends (stage: StageT) => Record<any, any> | Promise<Record<any, any>>>(handler: HandlerT) => Promise<Awaited<ReturnType<HandlerT>>>,
-	run: () => Promise<Remove$<StageT>>;
-};
-
-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 = () => {
-	const stepController = {
-		_steps: [] as Array<(stage: any) => Promise<any>>,
-		step(handler: (stage: any) => Promise<any>) {
-			stepController._steps.push(handler);
-			return stepController;
-		},
-		async run() {
-			let stage = {};
-			for (const step of stepController._steps) {
-				stage = { ...stage, ...(await step(stage)) };
-			}
-			let result: Record<any, any> = {};
-			for (const key in stage) {
-				const value = (stage as any)[key];
-				if (!key.startsWith("$")) result[key] = value;
-			}
-			return result;
-		},
-	};
-	return stepController.step as any as Steps<{}>["step"];
-};

package/kernel/execute.ts

@@ -1,194 +0,0 @@
-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, ExecuteStreamResult, createStep, Steps } 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(undefined),
-				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 ?? ({} as any),
-		step: createStep() as any,
-	};
-
-	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 };
-		console.log(mode);
-
-		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,
-	options: {
-		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
-		headers?: Record<string, string> | Headers;
-	} & ExecuteOptions,
-): Promise<ExecuteResult<Result>> {
-	if (!options.headers) options.headers = {};
-	const executeId = (options?.executeId ?? createUlid()) as ExecuteId;
-	const logger = useLogger(executeId);
-	runtime.execute.executeIds.add(executeId);
-
-	loggerPushTags(executeId, {
-		from: "execute",
-		executeId,
-		params: options.params,
-		path,
-	});
-
-	const result = await _call("execute", path, options.params, options.headers, {
-		...options,
-		executeId,
-		logger,
-		onAfterHeaders: (headers) => {
-			loggerPushTags(executeId, {
-				requestHeaders: 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,
-	options: {
-		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
-		headers?: Record<string, string> | Headers;
-	} & ExecuteOptions,
-): Promise<string> {
-	const resultsRaw = await _execute(path, 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 = JSON.stringify(TSON.encode(resultsRaw));
-	return results;
-}
-
-export async function _executeStream<Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
-	path: Path,
-	options: {
-		params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
-		headers?: Record<string, string> | Headers;
-	} & ExecuteOptions,
-): Promise<ExecuteStreamResult<Path, Result>> {
-	if (!options.headers) options.headers = {};
-	const executeId = (options?.executeId ?? createUlid()) as ExecuteId;
-	const logger = useLogger(executeId);
-	runtime.execute.executeIds.add(executeId);
-
-	loggerPushTags(executeId, {
-		from: "execute",
-		executeId,
-		params: options.params,
-		path,
-	});
-
-	const result = await _call("stream", path, options.params, options.headers, {
-		...options,
-		executeId,
-		logger,
-		onAfterHeaders: (headers) => {
-			loggerPushTags(executeId, {
-				requestHeaders: headerToPlainObject(headers),
-			});
-		},
-	});
-
-	loggerPushTags(executeId, { result: result.$result });
-	await loggerSubmit(executeId);
-	runtime.execute.executeIds.delete(executeId);
-
-	return { getResult: () => result.$result, stream: (result as any).$generator } as ExecuteStreamResult<Path, Result>;
-}

package/kernel/fail.ts

@@ -1,20 +0,0 @@
-import { failCode } from "../../../src/fail-code";
-
-export function reject<Code extends keyof typeof failCode, FailData extends (typeof failCode)[Code]>(code: Code, data: Parameters<FailData>[0]) {
-	const message = failCode[code]?.(data as any) ?? "";
-	const error = {
-		name: "MilkioReject",
-		code,
-		message,
-		data,
-		stack: "",
-	};
-	Error.captureStackTrace(error);
-	error.stack = error.stack.replace(/\n.*\n/, "\n");
-
-	return error;
-}
-
-export type MilkioReject = ReturnType<typeof reject>;
-
-export type MilkioFailCode = Record<string, (arg: any) => string>;