libmodulor 0.21.0 → 0.23.0

package/dist/esm/target/lib/server-node/funcs.js

@@ -5,16 +5,26 @@ export function listen(server, entrypointsBuilder, logger, settingsManager) {
         logger.info(`Listening on ${entrypointsBuilder.exec().http}`);
     });
 }
-export async function stop(server) {
+export async function stop(server, settingsManager) {
     if (!server?.listening) {
         return;
     }
+    const mode = settingsManager.get()('server_stop_mode');
     // As stated in the docs of `close`, only awaiting `.close` is not enough to make sure all the connections are closed.
     // Hence the wrapping in a promise, where the callback is called when the 'close' event is emitted.
     return new Promise((resolve, reject) => {
         if (!server) {
             return resolve();
         }
+        switch (mode) {
+            case 'aggressive':
+                server.closeAllConnections();
+                break;
+            case 'patient':
+                break;
+            default:
+                ((_) => { })(mode);
+        }
         server.close((err) => {
             if (err) {
                 return reject(err);

package/dist/esm/target/lib/server-node/types.d.ts

@@ -3,3 +3,4 @@ import type https from 'node:https';
 import type { ServerManagerSettings } from '../server/ServerManager.js';
 export type Server = http.Server | https.Server;
 export type ListenSettings = Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port'>;
+export type StopSettings = Pick<ServerManagerSettings, 'server_stop_mode'>;

package/dist/esm/target/node-express-server/NodeExpressServerManager.d.ts

@@ -8,8 +8,8 @@ import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerM
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
 import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
-import type { ListenSettings } from '../lib/server-node/types.js';
-type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'>;
+import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
+type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'> & StopSettings;
 export declare class NodeExpressServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;

package/dist/esm/target/node-express-server/NodeExpressServerManager.js

@@ -47,6 +47,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
             logger_level: this.settingsManager.get()('logger_level'),
             server_binding_host: this.settingsManager.get()('server_binding_host'),
             server_binding_port: this.settingsManager.get()('server_binding_port'),
+            server_stop_mode: this.settingsManager.get()('server_stop_mode'),
             server_tmp_path: this.settingsManager.get()('server_tmp_path'),
         };
     }
@@ -79,7 +80,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
-        await stop(this.server);
+        await stop(this.server, this.settingsManager);
     }
     async warmUp() {
         // Nothing to do

package/dist/esm/target/node-hono-server/NodeHonoServerManager.d.ts

@@ -7,8 +7,8 @@ import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import type { ListenSettings } from '../lib/server-node/types.js';
-type S = ListenSettings;
+import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
+type S = ListenSettings & StopSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;

package/dist/esm/target/node-hono-server/NodeHonoServerManager.js

@@ -44,6 +44,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         return {
             server_binding_host: this.settingsManager.get()('server_binding_host'),
             server_binding_port: this.settingsManager.get()('server_binding_port'),
+            server_stop_mode: this.settingsManager.get()('server_stop_mode'),
         };
     }
     getRuntime() {
@@ -75,7 +76,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
-        await stop(this.server);
+        await stop(this.server, this.settingsManager);
     }
     async warmUp() {
         // Nothing to do

package/dist/esm/testing/impl/newNodeAppTester.js

@@ -18,8 +18,8 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
     const settings = {
         ...STD_DEFAULT_JWT_MANAGER_SETTINGS,
         ...TARGET_DEFAULT_SERVER_MANAGER_SETTINGS,
-        jwt_manager_audience: 'fik',
-        jwt_manager_issuer: 'fik',
+        jwt_manager_audience: 'libmodulor-test',
+        jwt_manager_issuer: 'libmodulor-test',
         jwt_manager_secret: new TPassword().example(),
         logger_level,
         server_basic_auth_entries: {
@@ -28,6 +28,7 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
         server_binding_port: serverPortRangeStart + idx,
         server_private_api_key_entries: [new TApiKey().example()],
         server_public_api_key_entries: [new TApiKey().example()],
+        server_stop_mode: 'aggressive',
     };
     const container = new Container(CONTAINER_OPTS);
     bindCommon(container, () => settings);

package/dist/esm/testing/workers/UCExecutor.js

@@ -13,6 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var UCExecutor_1;
 import { inject, injectable } from 'inversify';
 import { rInput, UCBuilder, } from '../../uc/index.js';
+const ERR_CLIENT_EXPECTED_UCOR = (name) => `${name} client is expected to return an ucor`;
 const ERR_CLIENT_EXPECTED_OUTPUT = (name) => `${name} client is expected to return an output but returned nothing`;
 const ERR_CLIENT_UNEXPECTED_OUTPUT = (name) => `${name} client is expected to return nothing but returned an output`;
 let UCExecutor = class UCExecutor {
@@ -70,7 +71,44 @@ let UCExecutor = class UCExecutor {
         out.io.i = input;
         out.hash = this.cryptoManager.hash(UCExecutor_1.HASH_ALG, [name, JSON.stringify(args), JSON.stringify(input)].join(UCExecutor_1.HASH_SEP), UCExecutor_1.HASH_BTT_ENCODING);
         try {
-            const ucor = await this.ucManager.execClient(uc);
+            let ucor;
+            const transportType = ucd.ext?.http?.transportType ?? 'standard';
+            switch (transportType) {
+                case 'standard':
+                    ucor = await this.ucManager.execClient(uc);
+                    break;
+                case 'stream': {
+                    try {
+                        let abort;
+                        await this.ucManager.execClient(uc, {
+                            registerAbort: (func) => {
+                                abort = func;
+                            },
+                            stream: {
+                                onClose: async () => { },
+                                onData: async (ucor2) => {
+                                    if (!ucor) {
+                                        ucor = ucor2;
+                                        abort();
+                                    }
+                                },
+                                onDone: async () => { },
+                            },
+                        });
+                    }
+                    catch (err) {
+                        if (err.name !== 'AbortError') {
+                            throw err;
+                        }
+                    }
+                    break;
+                }
+                default:
+                    ((_) => { })(transportType);
+            }
+            if (!ucor) {
+                throw new Error(ERR_CLIENT_EXPECTED_UCOR(name));
+            }
             const output = ucor.output();
             if (uc.hasOutputParts() && !output) {
                 throw new Error(ERR_CLIENT_EXPECTED_OUTPUT(name));

package/dist/esm/uc/ext.d.ts

@@ -1,4 +1,4 @@
-import type { HTTPMethod, URLPath } from '../dt/index.js';
+import type { HTTPMethod, TransportType, URLPath } from '../dt/index.js';
 import type { UCOPIBase } from './opi.js';
 import type { UCOutput } from './output.js';
 import type { UCMountingPoint } from './utils/ucMountingPoint.js';
@@ -41,5 +41,11 @@ export interface UCExt<OPI0 extends UCOPIBase | undefined = undefined, OPI1 exte
          * @returns
          */
         transform?: (output: UCOutput<OPI0, OPI1>) => object;
+        /**
+         * The way the output is transported
+         *
+         * By default, it's `standard`.
+         */
+        transportType?: TransportType;
     };
 }

package/dist/esm/uc/impl/HTTPUCTransporter.d.ts

@@ -3,7 +3,7 @@ import type { ServerClientManager, ServerClientManagerSettings } from '../../tar
 import type { UCInput } from '../input.js';
 import type { UCOPIBase } from '../opi.js';
 import type { UCOutputOrNothing } from '../output.js';
-import type { UCTransporter } from '../transporter.js';
+import type { UCTransporter, UCTransporterOpts } from '../transporter.js';
 import type { UC } from '../UC.js';
 type S = Pick<ServerClientManagerSettings, 'server_cookies_name_auth' | 'server_public_api_key_header_name'>;
 export declare class HTTPUCTransporter implements Configurable<S>, UCTransporter {
@@ -12,6 +12,6 @@ export declare class HTTPUCTransporter implements Configurable<S>, UCTransporter
     private settingsManager;
     constructor(httpAPICaller: HTTPAPICaller, serverClientManager: ServerClientManager, settingsManager: SettingsManager<S>);
     s(): S;
-    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts: UCTransporterOpts<OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
 }
 export {};

package/dist/esm/uc/impl/HTTPUCTransporter.js

@@ -29,7 +29,7 @@ let HTTPUCTransporter = class HTTPUCTransporter {
             server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
         };
     }
-    async send(uc) {
+    async send(uc, opts) {
         const { auth, def: { sec }, } = uc;
         const baseURL = await this.serverClientManager.baseURL({ auth });
         const { contentType, envelope, method, path } = ucHTTPContract(uc);
@@ -96,10 +96,12 @@ let HTTPUCTransporter = class HTTPUCTransporter {
             contentType,
             errBuilder: async (error) => error.message,
             method,
+            registerAbort: opts.registerAbort,
             req: {
                 builder: async () => rInput(uc, { ignoreUndefined: true }),
                 envelope,
             },
+            stream: opts.stream,
             urlBuilder: async () => `${baseURL}${path}`,
         });
         // In case of 204, we get an empty object.

package/dist/esm/uc/impl/SimpleUCManager.d.ts

@@ -7,7 +7,7 @@ import { UCOutputReader } from '../helpers/UCOutputReader.js';
 import type { UCInit } from '../init.js';
 import type { UCInput } from '../input.js';
 import type { UCMain } from '../main.js';
-import type { UCManager, UCManagerPersistOpts } from '../manager.js';
+import type { UCManager, UCManagerExecClientOpts, UCManagerExecServerOpts, UCManagerPersistOpts } from '../manager.js';
 import type { UCOPIBase } from '../opi.js';
 import type { UCOutputOrNothing } from '../output.js';
 import type { UC } from '../UC.js';
@@ -29,8 +29,8 @@ export declare class SimpleUCManager implements UCManager {
     constructor(ucClientConfirmManager: UCClientConfirmManager, clockManager: ClockManager, cryptoManager: CryptoManager, logger: Logger, ucDataStore: UCDataStore, ucExecChecker: UCExecChecker, ucInputFilesProcessor: UCInputFilesProcessor, ucInputValidator: UCInputValidator, ucInitProvider: Provider<UCInit>, ucMainProvider: Provider<UCMain>);
     commitTx(): Promise<void>;
     confirmClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<boolean>;
-    execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;
-    execServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: UCManagerExecClientOpts<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;
+    execServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: UCManagerExecServerOpts<OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
     initServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<void>;
     startTx(): Promise<void>;
     persist<I extends UCInput | undefined = undefined, D extends UCData | null = null, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, data?: D, opts?: UCManagerPersistOpts): Promise<UCDataStoreRecord<I, D>>;

package/dist/esm/uc/impl/SimpleUCManager.js

@@ -59,7 +59,7 @@ let SimpleUCManager = class SimpleUCManager {
         }
         return this.ucClientConfirmManager.exec(def);
     }
-    async execClient(uc) {
+    async execClient(uc, opts) {
         const { lifecycle, metadata } = uc.def;
         const { client, server } = lifecycle;
         if (!client) {
@@ -81,10 +81,23 @@ let SimpleUCManager = class SimpleUCManager {
             await this.ucInputFilesProcessor.exec({ uc });
         }
         const main = (await this.ucMainProvider(client.main));
-        const output = await main.exec({ uc });
+        const streamOpts = opts?.stream;
+        const output = await main.exec({
+            opts: {
+                registerAbort: opts?.registerAbort,
+                stream: streamOpts
+                    ? {
+                        onClose: streamOpts.onClose,
+                        onData: (output) => streamOpts.onData(new UCOutputReader(uc.def, output ?? undefined)),
+                        onDone: streamOpts.onDone,
+                    }
+                    : undefined,
+            },
+            uc,
+        });
         return new UCOutputReader(uc.def, output ?? undefined);
     }
-    async execServer(uc) {
+    async execServer(uc, opts) {
         const { lifecycle, metadata } = uc.def;
         const { server } = lifecycle;
         if (typeof server !== 'object') {
@@ -101,7 +114,13 @@ let SimpleUCManager = class SimpleUCManager {
         this.ucInputValidator.exec({ uc });
         await this.ucInputFilesProcessor.exec({ uc });
         const main = (await this.ucMainProvider(server.main));
-        return main.exec({ uc });
+        const output = main.exec({
+            opts: {
+                stream: opts?.stream,
+            },
+            uc,
+        });
+        return output;
     }
     async initServer(uc) {
         const { lifecycle, metadata } = uc.def;

package/dist/esm/uc/lifecycle/client/SendClientMain.d.ts

@@ -6,5 +6,5 @@ import type { UCTransporter } from '../../transporter.js';
 export declare class SendClientMain<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> implements UCMain<I, OPI0, OPI1> {
     private ucTransporter;
     constructor(ucTransporter: UCTransporter);
-    exec({ uc, }: UCMainInput<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    exec({ opts, uc, }: UCMainInput<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
 }

package/dist/esm/uc/lifecycle/client/SendClientMain.js

@@ -16,8 +16,11 @@ let SendClientMain = class SendClientMain {
     constructor(ucTransporter) {
         this.ucTransporter = ucTransporter;
     }
-    async exec({ uc, }) {
-        return this.ucTransporter.send(uc);
+    async exec({ opts, uc, }) {
+        return this.ucTransporter.send(uc, {
+            registerAbort: opts?.registerAbort,
+            stream: opts?.stream,
+        });
     }
 };
 SendClientMain = __decorate([

package/dist/esm/uc/main.d.ts

@@ -1,9 +1,16 @@
 import type { Worker } from '../std/index.js';
+import type { RegisterAbortFunc, StreamConfig } from '../utils/index.js';
 import type { UCInput } from './input.js';
 import type { UCOPIBase } from './opi.js';
-import type { UCOutputOrNothing } from './output.js';
+import type { UCOutput, UCOutputOrNothing } from './output.js';
 import type { UC } from './UC.js';
+export type UCMainStream<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = StreamConfig<UCOutput<OPI0, OPI1>>;
+export interface UCMainOpts<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    registerAbort?: RegisterAbortFunc | undefined;
+    stream?: UCMainStream<OPI0, OPI1> | undefined;
+}
 export interface UCMainInput<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    opts?: UCMainOpts<OPI0, OPI1>;
     uc: UC<I, OPI0, OPI1>;
 }
 export interface UCMain<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> extends Worker<UCMainInput<I, OPI0, OPI1>, Promise<UCOutputOrNothing<OPI0, OPI1>>> {

package/dist/esm/uc/manager.d.ts

@@ -1,9 +1,11 @@
 import type { UUID } from '../dt/index.js';
+import type { RegisterAbortFunc, StreamConfig } from '../utils/index.js';
 import type { UCData } from './data.js';
 import type { UCDataStoreRecord } from './data-store.js';
 import type { UCExecMode } from './exec.js';
 import type { UCOutputReader } from './helpers/UCOutputReader.js';
 import type { UCInput } from './input.js';
+import type { UCMainStream } from './main.js';
 import type { UCOPIBase } from './opi.js';
 import type { UCOutputOrNothing } from './output.js';
 import type { UC } from './UC.js';
@@ -23,11 +25,18 @@ export interface UCManagerPersistOpts {
      */
     organizationId?: UUID;
 }
+export interface UCManagerExecClientOpts<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    registerAbort?: RegisterAbortFunc | undefined;
+    stream?: StreamConfig<UCOutputReader<I, OPI0, OPI1>> | undefined;
+}
+export interface UCManagerExecServerOpts<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    stream?: UCMainStream<OPI0, OPI1> | undefined;
+}
 export interface UCManager {
     commitTx(): Promise<void>;
     confirmClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<boolean>;
-    execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;
-    execServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: UCManagerExecClientOpts<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;
+    execServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: UCManagerExecServerOpts<OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
     initServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<void>;
     startTx(): Promise<void>;
     persist<I extends UCInput | undefined = undefined, D extends UCData | null = null, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, data?: D, opts?: UCManagerPersistOpts): Promise<UCDataStoreRecord<I, D>>;

package/dist/esm/uc/output.d.ts

@@ -20,3 +20,4 @@ export interface UCOutputDef<OPI0 extends UCOPIBase | undefined = undefined, OPI
     };
     sideEffects?: UCOutputSideEffect[];
 }
+export declare function buildSingleItemOutput<OPI0 extends UCOPIBase>(item: OPI0): UCOutput<OPI0>;

package/dist/esm/uc/output.js

@@ -1 +1,10 @@
-export {};
+export function buildSingleItemOutput(item) {
+    return {
+        parts: {
+            _0: {
+                items: [item],
+                total: 1,
+            },
+        },
+    };
+}

package/dist/esm/uc/transporter.d.ts

@@ -1,7 +1,13 @@
+import type { RegisterAbortFunc } from '../utils/index.js';
 import type { UCInput } from './input.js';
+import type { UCMainStream } from './main.js';
 import type { UCOPIBase } from './opi.js';
 import type { UCOutputOrNothing } from './output.js';
 import type { UC } from './UC.js';
+export interface UCTransporterOpts<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    registerAbort?: RegisterAbortFunc | undefined;
+    stream?: UCMainStream<OPI0, OPI1> | undefined;
+}
 export interface UCTransporter {
-    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    send<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: UCTransporterOpts<OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
 }

package/dist/esm/utils/async/types.d.ts

@@ -0,0 +1,2 @@
+export type AbortFunc = () => void;
+export type RegisterAbortFunc = (func: AbortFunc) => void;

package/dist/esm/utils/async/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/http/NDJSONStreamManager.d.ts

@@ -0,0 +1,13 @@
+import type { HTTPAPICallExecutorResBody, Worker } from '../../std/index.js';
+type Encoding = 'utf-8';
+interface I<D extends object = object> {
+    abortController: AbortController;
+    encoding?: Encoding | undefined;
+    onData: (data: D) => Promise<void>;
+    reader: ReturnType<HTTPAPICallExecutorResBody['getReader']>;
+}
+export declare class NDJSONStreamManager implements Worker<I, Promise<void>> {
+    private static DEFAULT_ENCODING;
+    exec({ abortController, encoding, onData, reader, }: I): Promise<void>;
+}
+export {};

package/dist/esm/utils/http/NDJSONStreamManager.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var NDJSONStreamManager_1;
+import { injectable } from 'inversify';
+import { NDJSON_DATA_SEP } from './nd-json.js';
+let NDJSONStreamManager = class NDJSONStreamManager {
+    static { NDJSONStreamManager_1 = this; }
+    static DEFAULT_ENCODING = 'utf-8';
+    async exec({ abortController, encoding = NDJSONStreamManager_1.DEFAULT_ENCODING, onData, reader, }) {
+        const decoder = new TextDecoder(encoding);
+        let buffer = '';
+        while (true) {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const parts = buffer.split(NDJSON_DATA_SEP);
+            // Remove the last part that is potentially not complete yet.
+            buffer = parts.pop() ?? '';
+            for (const part of parts) {
+                const lines = part.split(NDJSON_DATA_SEP);
+                for (const line of lines) {
+                    try {
+                        onData(JSON.parse(line));
+                    }
+                    catch (_err) {
+                        // Ignore invalid message
+                    }
+                }
+            }
+        }
+    }
+};
+NDJSONStreamManager = NDJSONStreamManager_1 = __decorate([
+    injectable()
+], NDJSONStreamManager);
+export { NDJSONStreamManager };

package/dist/esm/utils/http/SSEStreamManager.d.ts

@@ -0,0 +1,13 @@
+import type { HTTPAPICallExecutorResBody, Worker } from '../../std/index.js';
+type Encoding = 'utf-8';
+interface I<D extends object = object> {
+    abortController: AbortController;
+    encoding?: Encoding | undefined;
+    onData: (data: D) => Promise<void>;
+    reader: ReturnType<HTTPAPICallExecutorResBody['getReader']>;
+}
+export declare class SSEStreamManager implements Worker<I, Promise<void>> {
+    private static DEFAULT_ENCODING;
+    exec({ abortController, encoding, onData, reader, }: I): Promise<void>;
+}
+export {};

package/dist/esm/utils/http/SSEStreamManager.js

@@ -0,0 +1,60 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SSEStreamManager_1;
+import { injectable } from 'inversify';
+import { throwCustomError } from '../../error/index.js';
+import { isSSEError, parseDataLine, SSE_DATA_SEP, SSE_MSG_SEP } from './sse.js';
+let SSEStreamManager = class SSEStreamManager {
+    static { SSEStreamManager_1 = this; }
+    static DEFAULT_ENCODING = 'utf-8';
+    async exec({ abortController, encoding = SSEStreamManager_1.DEFAULT_ENCODING, onData, reader, }) {
+        const decoder = new TextDecoder(encoding);
+        let buffer = '';
+        while (true) {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const parts = buffer.split(SSE_MSG_SEP);
+            // Remove the last part that is potentially not complete yet.
+            buffer = parts.pop() ?? '';
+            for (const part of parts) {
+                const lines = part.split(SSE_DATA_SEP);
+                let data = '';
+                for (const line of lines) {
+                    data += parseDataLine(line);
+                }
+                if (!data) {
+                    continue;
+                }
+                let parsedData;
+                try {
+                    parsedData = JSON.parse(data);
+                }
+                catch (_err) {
+                    // Ignore invalid message
+                    continue;
+                }
+                if (isSSEError(parsedData)) {
+                    const { message, status } = parsedData;
+                    throwCustomError(message, status);
+                }
+                else {
+                    onData(parsedData);
+                }
+            }
+        }
+    }
+};
+SSEStreamManager = SSEStreamManager_1 = __decorate([
+    injectable()
+], SSEStreamManager);
+export { SSEStreamManager };

package/dist/esm/utils/http/nd-json.d.ts

@@ -0,0 +1 @@
+export declare const NDJSON_DATA_SEP = "\n";

package/dist/esm/utils/http/nd-json.js

@@ -0,0 +1,2 @@
+// https://github.com/ndjson/ndjson-spec
+export const NDJSON_DATA_SEP = '\n';

package/dist/esm/utils/http/sse.d.ts

@@ -0,0 +1,14 @@
+import type { ErrorMessage, HTTPStatusNumber } from '../../dt/index.js';
+export declare const SSE_HEADERS: [string, string][];
+export declare const SSE_DATA_PREFIX = "data:";
+export declare const SSE_DATA_SEP = "\n";
+export declare const SSE_MSG_SEP = "\n\n";
+export type SSEStreamDataCleanUpFunc = () => void;
+export interface SSEError {
+    message: ErrorMessage;
+    status: HTTPStatusNumber;
+}
+export declare function fmtSSEError(err: SSEError): string;
+export declare function fmtSingleDataMsg<D extends object = object>(data: D): string;
+export declare function isSSEError(err: unknown): err is SSEError;
+export declare function parseDataLine(line: string): string;

package/dist/esm/utils/http/sse.js

@@ -0,0 +1,24 @@
+// https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events
+export const SSE_HEADERS = [
+    ['Cache-Control', 'no-cache'],
+    ['Content-Type', 'text/event-stream'],
+    ['Connection', 'keep-alive'],
+];
+export const SSE_DATA_PREFIX = 'data:';
+export const SSE_DATA_SEP = '\n';
+export const SSE_MSG_SEP = '\n\n';
+export function fmtSSEError(err) {
+    return `${SSE_DATA_PREFIX} ${JSON.stringify(err)}${SSE_MSG_SEP}`;
+}
+export function fmtSingleDataMsg(data) {
+    return `${SSE_DATA_PREFIX} ${JSON.stringify(data)}${SSE_MSG_SEP}`;
+}
+export function isSSEError(err) {
+    return 'message' in err && 'status' in err;
+}
+export function parseDataLine(line) {
+    if (!line.startsWith(SSE_DATA_PREFIX)) {
+        return '';
+    }
+    return `${line.slice(SSE_DATA_PREFIX.length).trim()}${SSE_DATA_SEP}`;
+}

package/dist/esm/utils/http/status.d.ts

@@ -0,0 +1,4 @@
+import type { HTTPStatusNumber } from '../../dt/index.js';
+export declare function isError(status: HTTPStatusNumber): boolean;
+export declare function isClientError(status: HTTPStatusNumber): boolean;
+export declare function isServerError(status: HTTPStatusNumber): boolean;

package/dist/esm/utils/http/status.js

@@ -0,0 +1,9 @@
+export function isError(status) {
+    return status >= 400;
+}
+export function isClientError(status) {
+    return status >= 400 && status < 500;
+}
+export function isServerError(status) {
+    return status >= 500;
+}