@tstdl/base 0.93.127 → 0.93.128

package/authentication/tests/authentication.client-error-handling.test.js

@@ -70,6 +70,12 @@ describe('AuthenticationClientService Error Handling & Stuck States', () => {
     afterEach(async () => {
         await service.dispose();
     });
+    function setupServiceWithToken(iatOffset = -10, expOffset = 5) {
+        const now = Math.floor(Date.now() / 1000);
+        const initialToken = { iat: now + iatOffset, exp: now + expOffset, jti: 'initial' };
+        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
+        service = injector.resolve(AuthenticationClientService);
+    }
     test('Corrupt Storage: should handle invalid JSON in storage gracefully', async () => {
         // initialize with corrupt token
         globalThis.localStorage.setItem('AuthenticationService:token', '{ invalid-json');
@@ -77,84 +83,35 @@ describe('AuthenticationClientService Error Handling & Stuck States', () => {
         expect(service.token()).toBeUndefined();
         expect(mockLogger.warn).toHaveBeenCalled(); // Should warn about parse error
     });
-    test('Unrecoverable Errors: should logout on InvalidTokenError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new InvalidTokenError());
+    test.each([
+        ['InvalidTokenError', new InvalidTokenError()],
+        ['NotFoundError', new NotFoundError('Session not found')],
+        ['ForbiddenError', new ForbiddenError()],
+        ['UnauthorizedError', new UnauthorizedError()],
+        ['NotSupportedError', new NotSupportedError()],
+        ['BadRequestError', new BadRequestError()],
+    ])('Unrecoverable Errors: should logout on %s during refresh', async (_, error) => {
+        setupServiceWithToken();
+        mockApiClient.refresh.mockRejectedValue(error);
         // Wait for loop to pick up refresh
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on NotFoundError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new NotFoundError('Session not found'));
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on ForbiddenError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new ForbiddenError());
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on UnauthorizedError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new UnauthorizedError());
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on NotSupportedError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new NotSupportedError());
-        await timeout(100);
-        expect(mockApiClient.endSession).toHaveBeenCalled();
-        expect(service.token()).toBeUndefined();
-    });
-    test('Unrecoverable Errors: should logout on BadRequestError during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
-        mockApiClient.refresh.mockRejectedValue(new BadRequestError());
-        await timeout(100);
+        await timeout(20);
         expect(mockApiClient.endSession).toHaveBeenCalled();
         expect(service.token()).toBeUndefined();
     });
     test('Recoverable Errors: should NOT logout on generic Error during refresh', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
+        setupServiceWithToken();
         mockApiClient.refresh.mockRejectedValue(new Error('Network failure'));
-        await timeout(100);
+        await timeout(20);
         // Should NOT have called endSession (logout)
         expect(mockApiClient.endSession).not.toHaveBeenCalled();
         // Token should still be present (retry logic handles it)
         expect(service.token()).toBeDefined();
+        // Trigger immediate retry to finish test quickly
+        service.requestRefresh();
+        await timeout(20);
     });
     test('Logout Failure: should clear local token even if server logout fails', async () => {
-        const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 1000, jti: 'initial' };
-        globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
-        service = injector.resolve(AuthenticationClientService);
+        setupServiceWithToken(-1000, 1000);
         mockApiClient.endSession.mockRejectedValue(new Error('Network error during logout'));
         await service.logout();
         expect(mockApiClient.endSession).toHaveBeenCalled();

package/authentication/tests/authentication.client-service-refresh.test.js

@@ -65,59 +65,59 @@ describe('AuthenticationClientService Refresh Loop Reproduction', () => {
     test('Zombie Timer: loop should wake up immediately when token changes', async () => {
         // 1. Mock a long expiration
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 3600, jti: 'initial' };
+        const initialToken = { iat: now - 3600, exp: now + 3600, jti: 'initial' };
         // Set in storage so initialize() (called by resolve) loads it
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         service = injector.resolve(AuthenticationClientService);
         // Wait for loop to enter the race condition (wait phase)
-        await timeout(100);
+        await timeout(20);
         // 2. Change token
-        const newToken = { exp: now + 3600, jti: 'new' };
+        const newToken = { iat: now - 1800, exp: now + 3600, jti: 'new' };
         mockApiClient.refresh.mockResolvedValue(newToken);
         service.requestRefresh(); // This should trigger immediate wake up
         // Wait for loop to process
-        await timeout(100);
+        await timeout(20);
         expect(mockApiClient.refresh).toHaveBeenCalled();
     });
     test('Forced Refresh Loss: forceRefreshToken should not be cleared on failure', async () => {
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 3600, jti: 'initial' };
+        const initialToken = { iat: now - 3600, exp: now + 3600, jti: 'initial' };
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         service = injector.resolve(AuthenticationClientService);
-        await timeout(100);
+        await timeout(20);
         // 1. Mock refresh failure
         mockApiClient.refresh.mockRejectedValue(new Error('Network Error'));
         service.requestRefresh();
         // Wait for loop to attempt refresh and fail
-        await timeout(200);
+        await timeout(50);
         expect(mockApiClient.refresh).toHaveBeenCalled();
         expect(service.forceRefreshToken.isSet).toBe(true); // Should STILL be set
     });
     test('Lock Contention Backoff: should wait 5 seconds and not busy-loop', async () => {
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 5, jti: 'initial' }; // Expiring soon
+        const initialToken = { iat: now - 3600, exp: now + 5, jti: 'initial' }; // Expiring soon
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         // 1. Mock lock already held
         mockLock.tryUse.mockResolvedValue(undefined); // lockAcquired = false
         const startTime = Date.now();
         service = injector.resolve(AuthenticationClientService);
-        // We expect it to try once, fail to get lock, and then wait 5 seconds.
-        await timeout(300);
+        // We expect it to try once, fail to get lock, and then wait some time.
+        await timeout(50);
         expect(mockLock.tryUse).toHaveBeenCalledTimes(1);
         // Check if it's still waiting (not finished loop)
         const duration = Date.now() - startTime;
-        expect(duration).toBeLessThan(1000);
+        expect(duration).toBeLessThan(500);
     });
     test('Busy Loop: should not busy loop when forceRefreshToken is set and lock is held', async () => {
         const now = Math.floor(Date.now() / 1000);
-        const initialToken = { exp: now + 3600, jti: 'initial' };
+        const initialToken = { iat: now - 3600, exp: now + 3600, jti: 'initial' };
         globalThis.localStorage.setItem('AuthenticationService:token', JSON.stringify(initialToken));
         // Mock lock already held
         mockLock.tryUse.mockResolvedValue(undefined);
         service = injector.resolve(AuthenticationClientService);
-        await timeout(100);
+        await timeout(20);
         service.requestRefresh(); // Set the flag
-        await timeout(300);
+        await timeout(50);
         // If it busy loops, this will be much higher than 1.
         expect(mockLock.tryUse.mock.calls.length).toBeLessThan(5);
     });

package/cancellation/token.d.ts

@@ -46,6 +46,7 @@ export type ConnectConfig = {
  * (emits when set).
  */
 export declare class CancellationSignal implements PromiseLike<void>, Subscribable<void> {
+    #private;
     protected readonly _stateSubject: BehaviorSubject<boolean>;
     /**
      * Observable which emits the current state (true for set, false for unset)
@@ -91,6 +92,11 @@ export declare class CancellationSignal implements PromiseLike<void>, Subscribab
      * @internal
      */
     constructor(stateSubject: BehaviorSubject<boolean>);
+    /**
+     * Returns a standard `AbortSignal` that is aborted when this token is set.
+     * Useful for interoperability with APIs like `fetch`.
+     */
+    get abortSignal(): AbortSignal;
     /**
      * Returns a standard `AbortSignal` that is aborted when this token is set.
      * Useful for interoperability with APIs like `fetch`.

package/cancellation/token.js

@@ -15,6 +15,7 @@ import { isBoolean } from '../utils/type-guards.js';
  */
 export class CancellationSignal {
     _stateSubject;
+    #abortSignal;
     /**
      * Observable which emits the current state (true for set, false for unset)
      * and any subsequent state changes.
@@ -74,6 +75,13 @@ export class CancellationSignal {
     constructor(stateSubject) {
         this._stateSubject = stateSubject;
     }
+    /**
+     * Returns a standard `AbortSignal` that is aborted when this token is set.
+     * Useful for interoperability with APIs like `fetch`.
+     */
+    get abortSignal() {
+        return (this.#abortSignal ??= this.asAbortSignal());
+    }
     /**
      * Returns a standard `AbortSignal` that is aborted when this token is set.
      * Useful for interoperability with APIs like `fetch`.

package/http/client/adapters/undici.adapter.js

@@ -20,7 +20,6 @@ export class UndiciHttpClientAdapterOptions {
 ;
 let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAdapter {
     options = inject(UndiciHttpClientAdapterOptions, undefined, { optional: true }) ?? {};
-    // eslint-disable-next-line max-lines-per-function, max-statements
     async call(httpClientRequest) {
         let body;
         if (isDefined(httpClientRequest.body?.json)) {
@@ -64,7 +63,6 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
             const httpClientResponse = new HttpClientResponse({
                 request: httpClientRequest,
                 statusCode: response.statusCode,
-                statusMessage: '?',
                 headers: new HttpHeaders(response.headers),
                 body: response.body,
                 closeHandler: () => response.body.destroy(),

package/http/client/http-client-request.d.ts

@@ -34,6 +34,7 @@ export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url
         formData?: HttpFormDataObject | FormData;
     };
     abortSignal?: CancellationSignal;
+    priority?: RequestPriority;
 };
 export type HttpRequestCredentials = 'omit' | 'same-origin' | 'include';
 export type HttpClientRequestObject = HttpClientRequestOptions & {
@@ -95,6 +96,7 @@ export declare class HttpClientRequest implements Disposable {
     credentials: HttpRequestCredentials | undefined;
     authorization: HttpRequestAuthorization | undefined;
     body: HttpRequestBody | undefined;
+    priority: RequestPriority | undefined;
     /**
      * Request timeout in milliseconds
      * @default 30000

package/http/client/http-client-request.js

@@ -61,6 +61,7 @@ export class HttpClientRequest {
     credentials;
     authorization;
     body;
+    priority;
     /**
      * Request timeout in milliseconds
      * @default 30000
@@ -101,6 +102,7 @@ export class HttpClientRequest {
         this.authorization = requestOptions.authorization;
         this.body = normalizeBody(requestOptions.body);
         this.credentials = requestOptions.credentials;
+        this.priority = requestOptions.priority;
         this.timeout = requestOptions.timeout ?? 30000;
         this.throwOnNon200 = requestOptions.throwOnNon200 ?? true;
         this.context = requestOptions.context ?? {};
@@ -122,6 +124,7 @@ export class HttpClientRequest {
         request.authorization = clone(request.authorization, true);
         request.urlParameters = new HttpUrlParameters(request.urlParameters);
         request.body = normalizeBody(request.body);
+        request.priority = this.priority;
         return request;
     }
     asObject() {
@@ -135,6 +138,7 @@ export class HttpClientRequest {
             query: this.query.asObject(),
             authorization: this.authorization,
             body,
+            priority: this.priority,
             timeout: this.timeout,
             throwOnNon200: this.throwOnNon200,
             context: this.context,

package/http/client/http-client-response.d.ts

@@ -9,7 +9,7 @@ export type HttpClientResponseObject = TypedOmit<HttpClientResponse, 'hasBody' |
 export type HttpClientResponseOptions = {
     request: HttpClientRequest;
     statusCode: number;
-    statusMessage: string | null;
+    statusMessage?: string | null;
     headers: HttpHeadersObject | HttpHeaders;
     body: HttpBody | HttpBodySource;
     closeHandler: () => void;

package/http/client/http-client-response.js

@@ -1,6 +1,7 @@
 import { isString } from '../../utils/type-guards.js';
 import { HttpBody } from '../http-body.js';
 import { HttpHeaders } from '../http-headers.js';
+import { getHttpStatusMessage } from '../utils.js';
 export class HttpClientResponse {
     closeHandler;
     request;
@@ -14,7 +15,7 @@ export class HttpClientResponse {
     constructor(options) {
         this.request = options.request;
         this.statusCode = options.statusCode;
-        this.statusMessage = (isString(options.statusMessage) && (options.statusMessage.length > 0)) ? options.statusMessage : null;
+        this.statusMessage = (isString(options.statusMessage) && (options.statusMessage.length > 0)) ? options.statusMessage : getHttpStatusMessage(this.statusCode);
         this.headers = new HttpHeaders(options.headers);
         this.body = (options.body instanceof HttpBody) ? options.body : new HttpBody(options.body, this.headers);
         this.closeHandler = options.closeHandler;
@@ -28,7 +29,7 @@ export class HttpClientResponse {
             statusCode: this.statusCode,
             statusMessage: this.statusMessage,
             headers: this.headers.asObject(),
-            body: this.body
+            body: this.body,
         };
         return obj;
     }

package/http/utils.d.ts

@@ -15,4 +15,10 @@ export declare function readBodyAsTextStream(body: Body, headers: HttpHeaders, o
 export declare function readBodyAsJson(body: Body, headers: HttpHeaders, options?: ReadBodyAsJsonOptions): Promise<UndefinableJson>;
 export declare function readBody(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): Promise<string | UndefinableJson | Uint8Array>;
 export declare function readBodyAsStream(body: Body, headers: HttpHeaders, options?: ReadBodyOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
+/**
+ * Returns the standard HTTP status message for a given status code.
+ * @param statusCode The HTTP status code.
+ * @returns The standard status message, or 'Unknown' if the code is not recognized.
+ */
+export declare function getHttpStatusMessage(statusCode: number): string;
 export {};

package/http/utils.js

@@ -104,3 +104,74 @@ function ensureSize(length, options) {
         throw MaxBytesExceededError.fromBytes(options.maxBytes);
     }
 }
+const httpStatusMessages = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    103: 'Early Hints',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    207: 'Multi-Status',
+    208: 'Already Reported',
+    226: 'IM Used',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Content Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: 'I\'m a teapot',
+    421: 'Misdirected Request',
+    422: 'Unprocessable Content',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required',
+};
+/**
+ * Returns the standard HTTP status message for a given status code.
+ * @param statusCode The HTTP status code.
+ * @returns The standard status message, or 'Unknown' if the code is not recognized.
+ */
+export function getHttpStatusMessage(statusCode) {
+    return httpStatusMessages[statusCode] ?? `Unknown (${statusCode})`;
+}

package/injector/injector.js

@@ -7,6 +7,7 @@ import { DeferredPromise } from '../promise/deferred-promise.js';
 import { reflectionRegistry } from '../reflection/registry.js';
 import { toArray } from '../utils/array/array.js';
 import { FactoryMap } from '../utils/factory-map.js';
+import { noop } from '../utils/noop.js';
 import { ForwardRef } from '../utils/object/forward-ref.js';
 import { objectEntries } from '../utils/object/object.js';
 import { assert, isArray, isDefined, isFunction, isNotNull, isNotObject, isNull, isPromise, isUndefined } from '../utils/type-guards.js';
@@ -597,6 +598,7 @@ function newInternalResolveContext(injector) {
         forwardRefs: new Set(),
         $done: new DeferredPromise(),
     };
+    void context.$done.catch(noop); // prevent unhandled rejection if no one is awaiting it
     return context;
 }
 function postProcess(context) {

package/mail/drizzle/0000_numerous_the_watchers.sql

@@ -0,0 +1,8 @@
+CREATE TABLE "mail"."log" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"timestamp" timestamp with time zone NOT NULL,
+	"template" text,
+	"data" jsonb NOT NULL,
+	"send_result" jsonb,
+	"errors" text[]
+);

package/mail/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "f8cdba37-11b9-477a-9f5a-5ef4b5026011",
+  "id": "0c48afa4-9ab0-4965-a93e-05a6c1b88e58",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -44,37 +44,6 @@
           "type": "text[]",
           "primaryKey": false,
           "notNull": false
-        },
-        "revision": {
-          "name": "revision",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "revision_timestamp": {
-          "name": "revision_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "create_timestamp": {
-          "name": "create_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "delete_timestamp": {
-          "name": "delete_timestamp",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "attributes": {
-          "name": "attributes",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "'{}'::jsonb"
         }
       },
       "indexes": {},

package/mail/drizzle/meta/_journal.json

@@ -5,15 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1740059198387,
-      "tag": "0000_previous_malcolm_colcord",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "7",
-      "when": 1761124592125,
-      "tag": "0001_flimsy_bloodscream",
+      "when": 1771240070681,
+      "tag": "0000_numerous_the_watchers",
       "breakpoints": true
     }
   ]

package/object-storage/s3/tests/s3.object-storage.integration.test.js

@@ -1,27 +1,20 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { setupIntegrationTest } from '../../../testing/index.js';
 import { readBinaryStream } from '../../../utils/stream/stream-reader.js';
-import { configureS3ObjectStorage } from '../s3.object-storage-provider.js';
+import { isUndefined } from '../../../utils/type-guards.js';
 import { S3ObjectStorage } from '../s3.object-storage.js';
 describe('S3ObjectStorage Integration', () => {
     let storage;
-    const bucketName = 'integration-test-bucket';
     beforeAll(async () => {
         const { injector } = await setupIntegrationTest({
             modules: { objectStorage: true },
         });
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucket: bucketName,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
-        });
         storage = await injector.resolveAsync(S3ObjectStorage, 'test-module');
     });
     afterAll(async () => {
+        if (isUndefined(storage)) {
+            return;
+        }
         const objects = await storage.getObjects();
         for (const obj of objects) {
             await storage.deleteObject(obj.key);
@@ -80,7 +73,7 @@ describe('S3ObjectStorage Integration', () => {
         const key = 'signed-download.txt';
         await storage.uploadObject(key, new TextEncoder().encode('signed download'));
         const url = await storage.getDownloadUrl(key, Date.now() + 60000);
-        expect(url).toContain('http://127.0.0.1:9000');
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
         expect(await response.text()).toBe('signed download');
@@ -154,15 +147,8 @@ describe('S3ObjectStorage Integration', () => {
         expect(stat.metadata['extra-key']).toBe('extra-value');
     });
     it('should work with bucket per module', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucketPerModule: true,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
         const moduleName = `test-bucket-per-module-${Math.floor(Math.random() * 1000000)}`;
         const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, moduleName);
@@ -177,7 +163,7 @@ describe('S3ObjectStorage Integration', () => {
         const metadata = { 's3-test': 'true' };
         await storage.uploadObject(key, content, { metadata });
         const obj = await storage.getObject(key);
-        expect(await obj.getResourceUri()).toBe(`s3://integration-test-bucket/test-module/${key}`);
+        expect(await obj.getResourceUri()).toBe(`s3://test-module/${key}`);
         expect(await obj.getContentLength()).toBe(content.length);
         expect(await obj.getMetadata()).toMatchObject(metadata);
         expect(new TextDecoder().decode(await obj.getContent())).toBe('s3 object');
@@ -242,25 +228,22 @@ describe('S3ObjectStorage Integration', () => {
         const key = 'signed-download-expires.txt';
         await storage.uploadObject(key, new TextEncoder().encode('signed download expires'));
         const url = await storage.getDownloadUrl(key, Date.now() + 60000, {
-            'Expires': new Date(Date.now() + 60000).toUTCString(),
+            Expires: new Date(Date.now() + 60000).toUTCString(),
         });
-        expect(url).toContain('http://127.0.0.1:9000');
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
     });
     it('should handle Forbidden error in ensureBucketExists with wrong credentials', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'wrong',
-            secretKey: 'wrong',
-            bucket: 'forbidden-bucket',
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
+            s3: {
+                accessKey: 'wrong',
+                secretKey: 'wrong',
+            },
         });
         try {
-            await injector.resolveAsync(S3ObjectStorage, 'test-module');
+            await injector.resolveAsync(S3ObjectStorage, 'forbidden-bucket');
             expect.fail('Should have thrown');
         }
         catch (error) {
@@ -268,17 +251,10 @@ describe('S3ObjectStorage Integration', () => {
         }
     });
     it('should copy object between different storages', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucket: 'another-bucket',
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
-        const anotherStorage = await injector.resolveAsync(S3ObjectStorage, 'another-module');
+        const anotherStorage = await injector.resolveAsync(S3ObjectStorage, 'another-bucket');
         const sourceKey = 'cross-storage-source.txt';
         const destKey = 'cross-storage-dest.txt';
         await storage.uploadObject(sourceKey, new TextEncoder().encode('cross storage content'));
@@ -288,15 +264,8 @@ describe('S3ObjectStorage Integration', () => {
         expect(new TextDecoder().decode(content)).toBe('cross storage content');
     });
     it('should cover ensureBucketExists with region', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucketPerModule: true,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
         const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, `region-test-${Math.floor(Math.random() * 1000000)}`);
         await perModuleStorage.ensureBucketExists('us-east-1', { objectLocking: true });