milkio 0.2.18 → 0.3.1

package/api-test/index.ts

@@ -42,8 +42,9 @@ export const executeApiTests = async <Path extends Array<keyof (typeof schema)["
 						...((await apiTestHooks.default.onBefore()) ?? {}),
 						log: (...args: Array<unknown>) => console.log(...args),
 						// @ts-ignore
-						execute: async (params: any, headers?: any, options?: any) => app.execute(path, params, headers ?? {}, options),
-						executeOther: async (path: any, params: any, headers?: any, options?: any) => app.execute(path, params, headers ?? {}, options),
+						execute: async (options?: any) => app.execute((path as any), options),
+						executeOther: async (path: any, options?: any) => app.execute((path as any), options),
+						executeStream: async (options?: any) => app.executeStream((path as any), options),
 						randParams: () => app.randParams(path as any),
 						randOtherParams: (path: any) => app.randParams(path),
 						reject: (message?: string) => {

package/defines/define-api-test.ts

@@ -1,4 +1,4 @@
-import type { Api, ExecuteResult, ExecuteOptions } from "..";
+import type { Api, ExecuteResult, ExecuteOptions, GeneratorGeneric, ExecuteResultSuccess } from "..";
 import type schema from "../../../generated/api-schema";
 import type apiTestHooks from "../../../src/api-test.ts";
 
@@ -13,13 +13,18 @@ export type ApiTestCases<ApiT extends Api> = {
 	handler: (
 		test: {
 			log: (...params: Array<unknown>) => void;
-			execute: (params: Parameters<ApiT["action"]>[0], headers?: Record<string, string>, options?: ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
+			execute: (options: { params: Parameters<ApiT["action"]>[0], headers?: Record<string, string> } & ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
 			executeOther: <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,
-				headers?: Record<string, string>,
-				options?: ExecuteOptions,
+				options: {
+					params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string,
+					headers?: Record<string, string>
+				} & ExecuteOptions,
 			) => Promise<ExecuteResult<Result>>;
+			executeStream: (options: { params: Parameters<ApiT["action"]>[0], headers?: Record<string, string> } & ExecuteOptions) => Promise<{
+				getResult: () => ExecuteResult<undefined>,
+				stream: AsyncGenerator<Awaited<ReturnType<ApiT["action"]>>>
+			}>;
 			randParams: () => Promise<Parameters<ApiT["action"]>[0]>;
 			randOtherParams: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path) => Promise<Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0]>;
 			reject: (message?: string) => void;

package/defines/define-api.ts

@@ -5,8 +5,7 @@ export function defineApi<ApiT extends Api>(api: ApiT): ApiT & { isApi: true } {
 	return { ...api, isApi: true };
 }
 
-export type Api<ActionT = unknown> = {
+export type Api = {
 	meta: Meta;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	action: (params: any, context: Context) => Promise<unknown> | unknown;
 };

package/defines/define-http-handler.ts

@@ -211,8 +211,8 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 								} catch (error) {
 									const result = handleCatchError(error, executeId);
 									controller.write(`data:@${JSON.stringify(TSON.encode(result))}\n\n`);
-									await new Promise((resolve) => setTimeout(resolve, 1));
 								}
+								await new Promise((resolve) => setTimeout(resolve, 0));
 								controller.close();
 							},
 							cancel() {
@@ -238,8 +238,8 @@ export function defineHttpHandler(app: MilkioApp, options: ExecuteHttpServerOpti
 								} catch (error) {
 									const result = handleCatchError(error, executeId);
 									controller.enqueue(`data:@${JSON.stringify(TSON.encode(result))}\n\n`);
-									await new Promise((resolve) => setTimeout(resolve, 1));
 								}
+								await new Promise((resolve) => setTimeout(resolve, 0));
 								controller.close();
 							},
 							cancel() {

package/kernel/execute.ts

@@ -1,7 +1,7 @@
 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 { type ExecuteId, type ExecuteOptions, type ExecuteResult, createUlid, useLogger, runtime, loggerPushTags, headerToPlainObject, loggerSubmit, type ExecuteCoreOptions, TSON, MiddlewareEvent, reject, _validate, ExecuteStreamResult } from "..";
 import { handleCatchError } from "../utils/handle-catch-error";
 
 const apis = new Map<string, any>();
@@ -102,10 +102,12 @@ export async function _call(
 
 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,
+	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);
@@ -113,11 +115,11 @@ export async function _execute<Path extends keyof (typeof schema)["apiMethodsTyp
 	loggerPushTags(executeId, {
 		from: "execute",
 		executeId,
-		params,
+		params: options.params,
 		path,
 	});
 
-	const result = await _call("execute", path, params, headersInit, {
+	const result = await _call("execute", path, options.params, options.headers, {
 		...options,
 		executeId,
 		logger,
@@ -135,8 +137,14 @@ export async function _execute<Path extends keyof (typeof schema)["apiMethodsTyp
 	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);
+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]();
@@ -146,3 +154,42 @@ export async function _executeToJson<Path extends keyof (typeof schema)["apiMeth
 	const results = await fn.validateResults(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, {
+				headers: 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/milkio.ts

@@ -3,7 +3,7 @@ import schema from "../../../generated/api-schema";
 import { runtime } from "..";
 import { createUlid } from "../utils/create-ulid";
 import { _validate } from "./validate";
-import { _execute, _call, _executeToJson } from "./execute";
+import { _execute, _call, _executeToJson, _executeStream } from "./execute";
 
 export type MilkioAppOptions = {
 	/**
@@ -44,6 +44,7 @@ export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
 		randParams: _randParams,
 		execute: _execute,
 		executeToJson: _executeToJson,
+		executeStream: _executeStream,
 		_call,
 	};
 

package/package.json

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

package/types.ts

@@ -52,6 +52,11 @@ export type MilkioConfig = {
 
 export type ExecuteResult<Result> = ExecuteResultSuccess<Result> | ExecuteResultFail;
 
+export type ExecuteStreamResult<Path, Result> = {
+	getResult: () => ExecuteResultSuccess<Result> | ExecuteResultFail,
+	stream: AsyncGenerator<MilkioEvent<Path>>
+};
+
 export type ExecuteResultSuccess<Result> = {
 	executeId: ExecuteId;
 	success: true;