@tstdl/base 0.93.117 → 0.93.118

package/api/server/gateway.js

@@ -190,7 +190,7 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
         const decodedUrlParameters = mapObjectValues(context.resourcePatternResult.pathname.groups, (value) => isDefined(value) ? decodeURIComponent(value) : undefined);
         const parameters = { ...context.request.query.asObject(), ...bodyAsParameters, ...decodedUrlParameters };
         const validatedParameters = isDefined(context.endpoint.definition.parameters)
-            ? Schema.parse(context.endpoint.definition.parameters, parameters)
+            ? Schema.parse(context.endpoint.definition.parameters, parameters, { coerce: true })
             : parameters;
         const requestTokenProvider = this.#requestTokenProvider;
         const auditor = this.#auditor;
@@ -279,5 +279,5 @@ async function getBody(request, options, schema) {
             body = await request.body.readAsBuffer(options);
         }
     }
-    return Schema.parse(schema, body);
+    return Schema.parse(schema, body, { coerce: true });
 }

package/index.d.ts

@@ -5,4 +5,5 @@
  */
 export * from './core.js';
 export * from './import.js';
+export * from './internal.js';
 export * from './require.js';

package/index.js

@@ -5,4 +5,5 @@
  */
 export * from './core.js';
 export * from './import.js';
+export * from './internal.js';
 export * from './require.js';

package/internal.d.ts

@@ -0,0 +1 @@
+export declare const internal: unique symbol;

package/internal.js

@@ -0,0 +1 @@
+export const internal = Symbol('internal');

package/notification/api/notification.api.d.ts

@@ -14,6 +14,12 @@ export declare const notificationApiDefinition: {
             };
             credentials: true;
         };
+        types: {
+            resource: string;
+            method: "GET";
+            result: import("../../schema/index.js").ObjectSchema<Partial<import("../../schema/index.js").Record<string, string>>>;
+            credentials: true;
+        };
         listInApp: {
             resource: string;
             method: "GET";
@@ -77,9 +83,9 @@ export declare const notificationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly type: string;
-                readonly channel: "email" | "in-app" | "web-push";
-                readonly enabled: boolean;
+                type: string;
+                enabled: boolean;
+                channel: "email" | "in-app" | "web-push";
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;
@@ -88,11 +94,11 @@ export declare const notificationApiDefinition: {
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly endpoint: string;
-                readonly keys: {
+                keys: {
                     p256dhBase64: string;
                     authBase64: string;
                 };
+                endpoint: string;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;
@@ -111,6 +117,12 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             };
             credentials: true;
         };
+        types: {
+            resource: string;
+            method: "GET";
+            result: import("../../schema/index.js").ObjectSchema<Partial<import("../../schema/index.js").Record<string, string>>>;
+            credentials: true;
+        };
         listInApp: {
             resource: string;
             method: "GET";
@@ -174,9 +186,9 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly type: string;
-                readonly channel: "email" | "in-app" | "web-push";
-                readonly enabled: boolean;
+                type: string;
+                enabled: boolean;
+                channel: "email" | "in-app" | "web-push";
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;
@@ -185,11 +197,11 @@ declare const _NotificationApiClient: import("../../api/client/index.js").ApiCli
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                readonly endpoint: string;
-                readonly keys: {
+                keys: {
                     p256dhBase64: string;
                     authBase64: string;
                 };
+                endpoint: string;
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;

package/notification/api/notification.api.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/types.js';
 import { ReplaceClass } from '../../injector/decorators.js';
-import { array, boolean, enumeration, explicitObject, literal, number, object, optional, string } from '../../schema/index.js';
+import { array, boolean, enumeration, literal, number, object, optional, record, string } from '../../schema/index.js';
 import { DataStream } from '../../sse/data-stream.js';
 import { InAppNotificationView } from '../models/in-app-notification.model.js';
 import { NotificationChannel } from '../models/index.js';
@@ -20,6 +20,12 @@ export const notificationApiDefinition = defineApi({
             result: (DataStream),
             credentials: true,
         },
+        types: {
+            resource: 'types',
+            method: 'GET',
+            result: record(string(), string()),
+            credentials: true,
+        },
         listInApp: {
             resource: 'in-app',
             method: 'GET',
@@ -78,7 +84,7 @@ export const notificationApiDefinition = defineApi({
         updatePreference: {
             resource: 'preferences',
             method: 'POST',
-            parameters: explicitObject({
+            parameters: object({
                 type: string(),
                 channel: enumeration(NotificationChannel),
                 enabled: boolean(),
@@ -89,7 +95,7 @@ export const notificationApiDefinition = defineApi({
         registerWebPush: {
             resource: 'web-push/register',
             method: 'POST',
-            parameters: explicitObject({
+            parameters: object({
                 endpoint: string(),
                 keys: object({
                     p256dhBase64: string(),

package/notification/client/notification-client.d.ts

@@ -10,9 +10,11 @@ export declare class NotificationClient<Definitions extends NotificationDefiniti
     readonly state$: import("rxjs").Observable<NotificationState<Definitions>>;
     readonly notifications$: import("rxjs").Observable<InAppNotificationView<Definitions>[]>;
     readonly unreadCount$: import("rxjs").Observable<number>;
+    readonly types$: import("rxjs").Observable<Record<keyof Definitions, string>>;
     readonly state: import("../../signals/api.js").Signal<NotificationState<Definitions>>;
     readonly notifications: import("../../signals/api.js").Signal<InAppNotificationView<Definitions>[]>;
     readonly unreadCount: import("../../signals/api.js").Signal<number>;
+    readonly types: import("../../signals/api.js").Signal<Record<keyof Definitions, string>>;
     loadNext(count?: number): void;
 }
 export {};

package/notification/client/notification-client.js

@@ -47,9 +47,16 @@ let NotificationClient = class NotificationClient {
     }), shareReplay({ bufferSize: 1, refCount: true }));
     notifications$ = this.state$.pipe(map((state) => state.notifications));
     unreadCount$ = this.state$.pipe(map((state) => state.unreadCount));
+    types$ = this.#authenticationService.sessionId$.pipe(switchMap((sessionId) => {
+        if (isUndefined(sessionId)) {
+            return of({});
+        }
+        return this.api.types();
+    }), shareReplay({ bufferSize: 1, refCount: true }));
     state = toSignal(this.state$, { initialValue: { notifications: [], unreadCount: 0 } });
     notifications = computed(() => this.state().notifications);
     unreadCount = computed(() => this.state().unreadCount);
+    types = toSignal(this.types$, { initialValue: {} });
     loadNext(count = 20) {
         const current = this.notifications();
         const after = current[current.length - 1]?.id;

package/notification/server/api/notification.api-controller.d.ts

@@ -1,11 +1,14 @@
 import type { ApiController, ApiRequestContext, ApiServerResult } from '../../../api/types.js';
 import type { NotificationApiDefinition } from '../../api/notification.api.js';
 import { NotificationSseService } from '../services/notification-sse.service.js';
+import { NotificationTypeService } from '../services/notification-type.service.js';
 import { NotificationService } from '../services/notification.service.js';
 export declare class NotificationApiController implements ApiController<NotificationApiDefinition> {
     protected readonly notificationService: NotificationService<Record<string, import("../../index.js").NotificationDefinition<import("../../../types/types.js").ObjectLiteral, import("../../../types/types.js").ObjectLiteral>>>;
+    protected readonly notificationTypeService: NotificationTypeService;
     protected readonly sseService: NotificationSseService;
     stream({ abortSignal, getToken }: ApiRequestContext<NotificationApiDefinition, 'stream'>): ApiServerResult<NotificationApiDefinition, 'stream'>;
+    types(): Promise<Record<string, string>>;
     listInApp({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'listInApp'>): Promise<any>;
     markRead({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'markRead'>): Promise<'ok'>;
     markAllRead({ getToken }: ApiRequestContext<NotificationApiDefinition, 'markAllRead'>): Promise<'ok'>;

package/notification/server/api/notification.api-controller.js

@@ -10,9 +10,11 @@ import { toAsyncIterable } from '../../../rxjs-utils/index.js';
 import { decodeBase64 } from '../../../utils/base64.js';
 import { notificationApiDefinition } from '../../api/notification.api.js';
 import { NotificationSseService } from '../services/notification-sse.service.js';
+import { NotificationTypeService } from '../services/notification-type.service.js';
 import { NotificationService } from '../services/notification.service.js';
 let NotificationApiController = class NotificationApiController {
     notificationService = inject(NotificationService);
+    notificationTypeService = inject(NotificationTypeService);
     sseService = inject(NotificationSseService);
     async *stream({ abortSignal, getToken }) {
         const token = await getToken();
@@ -26,6 +28,9 @@ let NotificationApiController = class NotificationApiController {
             this.sseService.unregister(token.payload.tenant, token.payload.subject, source);
         }
     }
+    async types() {
+        return await this.notificationTypeService.getTypes();
+    }
     async listInApp({ parameters, getToken }) {
         const token = await getToken();
         return await this.notificationService.listInApp(token.payload.tenant, token.payload.subject, parameters);

package/notification/server/services/notification-type.service.d.ts

@@ -8,4 +8,5 @@ export type TypeInitializationData = {
 export declare class NotificationTypeService extends Transactional {
     readonly repository: import("../../../orm/server/index.js").EntityRepository<NotificationType>;
     initializeTypes<T extends string>(typeData: Record<T, TypeInitializationData>): Promise<Record<T, NotificationType>>;
+    getTypes(): Promise<Record<string, string>>;
 }

package/notification/server/services/notification-type.service.js

@@ -34,6 +34,11 @@ let NotificationTypeService = class NotificationTypeService extends Transactiona
         const mappedTypes = typeEntries.map(([key]) => [key, assertDefinedPass(typeMap.get(key), 'Could not map notification type.')]);
         return fromEntries(mappedTypes);
     }
+    async getTypes() {
+        const types = await this.repository.loadAll();
+        const entries = types.map((type) => [type.key, type.label]);
+        return fromEntries(entries);
+    }
 };
 NotificationTypeService = __decorate([
     Singleton()

package/notification/tests/notification-api.test.js

@@ -5,6 +5,7 @@ import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
 import { NotificationChannel } from '../models/index.js';
 import { NotificationApiController } from '../server/api/notification.api-controller.js';
 import { NotificationSseService } from '../server/services/notification-sse.service.js';
+import { NotificationTypeService } from '../server/services/notification-type.service.js';
 import { NotificationService } from '../server/services/notification.service.js';
 describe('Notification API (Integration)', () => {
     let injector;
@@ -64,6 +65,13 @@ describe('Notification API (Integration)', () => {
         await nextPromise;
         expect(registerSpy).toHaveBeenCalledWith(tenantId, userId);
     });
+    test('types should call service', async () => {
+        const notificationTypeService = injector.resolve(NotificationTypeService);
+        const getTypesSpy = vi.spyOn(notificationTypeService, 'getTypes').mockResolvedValue({ test: 'Test' });
+        const result = await controller.types();
+        expect(result).toEqual({ test: 'Test' });
+        expect(getTypesSpy).toHaveBeenCalled();
+    });
     test('listInApp should call service', async () => {
         const listInAppSpy = vi.spyOn(notificationService, 'listInApp').mockResolvedValue([]);
         const params = { limit: 10, offset: 0, includeArchived: false };

package/notification/tests/notification-sse.service.test.js

@@ -17,4 +17,13 @@ describe('NotificationSseService', () => {
             await expect(service.send(msg, 1)).resolves.not.toThrow();
         });
     });
+    test('should dispatch unread count update', async () => {
+        const { injector } = await setupIntegrationTest({ modules: { messageBus: true, signals: true } });
+        const service = injector.resolve(NotificationSseService);
+        const tenantId = 't1';
+        const userId = 'u1';
+        await runInInjectionContext(injector, async () => {
+            await expect(service.dispatchUnreadCountUpdate(tenantId, userId, 5)).resolves.not.toThrow();
+        });
+    });
 });

package/notification/tests/unit/notification-client.test.d.ts

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

package/notification/tests/unit/notification-client.test.js

@@ -0,0 +1,112 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { AuthenticationClientService } from '../../../authentication/client/authentication.service.js';
+import { Injector, runInInjectionContext } from '../../../injector/index.js';
+import { NotificationApiClient } from '../../../notification/api/index.js';
+import { NotificationClient } from '../../../notification/client/notification-client.js';
+import { configureDefaultSignalsImplementation } from '../../../signals/implementation/configure.js';
+import { BehaviorSubject, of, Subject } from 'rxjs';
+describe('NotificationClient', () => {
+    let injector;
+    let authenticationServiceMock;
+    let notificationApiClientMock;
+    let notificationClient;
+    const sessionId$ = new BehaviorSubject(undefined);
+    const stream$ = new Subject();
+    beforeEach(() => {
+        configureDefaultSignalsImplementation();
+        injector = new Injector('TestInjector');
+        authenticationServiceMock = {
+            sessionId$,
+        };
+        notificationApiClientMock = {
+            listInApp: vi.fn().mockResolvedValue([]),
+            unreadCount: vi.fn().mockResolvedValue(0),
+            types: vi.fn().mockResolvedValue({}),
+            stream: vi.fn().mockReturnValue(of(stream$)),
+        };
+        injector.register(AuthenticationClientService, { useValue: authenticationServiceMock });
+        injector.register(NotificationApiClient, { useValue: notificationApiClientMock });
+        notificationClient = injector.resolve(NotificationClient);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+        sessionId$.next(undefined);
+    });
+    test('should initialize with empty state', () => {
+        runInInjectionContext(injector, () => {
+            expect(notificationClient.notifications()).toEqual([]);
+            expect(notificationClient.unreadCount()).toBe(0);
+            expect(notificationClient.types()).toEqual({});
+        });
+    });
+    test('should load notifications on session start', async () => {
+        const notifications = [{ id: '1', type: 'test' }];
+        const unreadCount = 5;
+        const types = { test: 'Test' };
+        notificationApiClientMock.listInApp.mockResolvedValue(notifications);
+        notificationApiClientMock.unreadCount.mockResolvedValue(unreadCount);
+        notificationApiClientMock.types.mockResolvedValue(types);
+        await runInInjectionContext(injector, async () => {
+            sessionId$.next('session-1');
+            // Wait for async operations (microtasks)
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(notificationClient.notifications()).toEqual(notifications);
+            expect(notificationClient.unreadCount()).toBe(unreadCount);
+            expect(notificationClient.types()).toEqual(types);
+            expect(notificationApiClientMock.listInApp).toHaveBeenCalledWith({ limit: 20 });
+            expect(notificationApiClientMock.unreadCount).toHaveBeenCalled();
+            expect(notificationApiClientMock.types).toHaveBeenCalled();
+            expect(notificationApiClientMock.stream).toHaveBeenCalled();
+        });
+    });
+    test('should clear notifications on session end', async () => {
+        const notifications = [{ id: '1', type: 'test' }];
+        notificationApiClientMock.listInApp.mockResolvedValue(notifications);
+        await runInInjectionContext(injector, async () => {
+            sessionId$.next('session-1');
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(notificationClient.notifications()).toHaveLength(1);
+            sessionId$.next(undefined);
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(notificationClient.notifications()).toEqual([]);
+            expect(notificationClient.unreadCount()).toBe(0);
+        });
+    });
+    test('should handle new notification from stream', async () => {
+        const initialNotifications = [{ id: '1', type: 'test' }];
+        notificationApiClientMock.listInApp.mockResolvedValue(initialNotifications);
+        await runInInjectionContext(injector, async () => {
+            sessionId$.next('session-1');
+            await new Promise(resolve => setTimeout(resolve, 0));
+            const newNotification = { id: '2', type: 'test' };
+            stream$.next({ notification: newNotification, unreadCount: 1 });
+            expect(notificationClient.notifications()).toEqual([newNotification, ...initialNotifications]);
+            expect(notificationClient.unreadCount()).toBe(1);
+        });
+    });
+    test('should handle unread count update from stream', async () => {
+        notificationApiClientMock.listInApp.mockResolvedValue([]);
+        await runInInjectionContext(injector, async () => {
+            sessionId$.next('session-1');
+            await new Promise(resolve => setTimeout(resolve, 0));
+            stream$.next({ unreadCount: 10 });
+            expect(notificationClient.unreadCount()).toBe(10);
+        });
+    });
+    test('should load next page of notifications', async () => {
+        const page1 = [{ id: '2', type: 'test' }];
+        const page2 = [{ id: '1', type: 'test' }];
+        notificationApiClientMock.listInApp
+            .mockResolvedValueOnce(page1) // Initial load
+            .mockResolvedValueOnce(page2); // Pagination
+        await runInInjectionContext(injector, async () => {
+            sessionId$.next('session-1');
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(notificationClient.notifications()).toEqual(page1);
+            notificationClient.loadNext(10);
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(notificationClient.notifications()).toEqual([...page1, ...page2]);
+            expect(notificationApiClientMock.listInApp).toHaveBeenCalledWith({ limit: 10, after: '2' });
+        });
+    });
+});

package/object-storage/object-storage.d.ts

@@ -3,17 +3,27 @@ import type { ObjectMetadata, ObjectStorageObject } from './object.js';
 export type UploadObjectOptions = {
     contentLength?: number;
     contentType?: string;
+    contentDisposition?: string;
+    cacheControl?: string;
     metadata?: ObjectMetadata;
 };
 export type UploadUrlOptions = {
     contentLength?: number;
     contentType?: string;
+    contentDisposition?: string;
+    cacheControl?: string;
     metadata?: ObjectMetadata;
 };
 export type CopyObjectOptions = {
+    contentType?: string;
+    contentDisposition?: string;
+    cacheControl?: string;
     metadata?: ObjectMetadata;
 };
 export type MoveObjectOptions = {
+    contentType?: string;
+    contentDisposition?: string;
+    cacheControl?: string;
     metadata?: ObjectMetadata;
 };
 export type ObjectStorageConfiguration = {

package/object-storage/s3/s3.object-storage-provider.d.ts

@@ -1,3 +1,4 @@
+import { Injector } from '../../injector/injector.js';
 import { ObjectStorageProvider } from '../../object-storage/index.js';
 import { S3ObjectStorage } from './s3.object-storage.js';
 export declare class S3ObjectStorageProviderConfig {
@@ -29,11 +30,15 @@ export declare class S3ObjectStorageProviderConfig {
      * S3 secret key
      */
     secretKey: string;
+    /**
+     * Whether to use path-style addressing (e.g., http://s3.endpoint.tld/BUCKET/KEY) instead of virtual-host addressing (e.g., http://BUCKET.s3.endpoint.tld/KEY).
+     * Useful for local development with alternative s3 implementations.
+     */
+    forcePathStyle?: boolean;
 }
 export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3ObjectStorage> {
-    private readonly client;
-    private readonly bucket;
-    constructor(config: S3ObjectStorageProviderConfig);
+    #private;
+    constructor();
     get(module: string): S3ObjectStorage;
 }
 /**
@@ -41,4 +46,6 @@ export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3Obj
  * @param config s3 config
  * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
  */
-export declare function configureS3ObjectStorage(config: S3ObjectStorageProviderConfig, register?: boolean): void;
+export declare function configureS3ObjectStorage(config: S3ObjectStorageProviderConfig & {
+    injector?: Injector;
+}): void;

package/object-storage/s3/s3.object-storage-provider.js

@@ -7,8 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Client } from 'minio';
-import { Singleton } from '../../injector/decorators.js';
+import { S3Client } from '@aws-sdk/client-s3';
+import { inject, Singleton } from '../../injector/index.js';
 import { Injector } from '../../injector/injector.js';
 import { ObjectStorage, ObjectStorageProvider } from '../../object-storage/index.js';
 import { assertDefinedPass, assertStringPass, isDefined } from '../../utils/type-guards.js';
@@ -42,35 +42,39 @@ export class S3ObjectStorageProviderConfig {
      * S3 secret key
      */
     secretKey;
+    /**
+     * Whether to use path-style addressing (e.g., http://s3.endpoint.tld/BUCKET/KEY) instead of virtual-host addressing (e.g., http://BUCKET.s3.endpoint.tld/KEY).
+     * Useful for local development with alternative s3 implementations.
+     */
+    forcePathStyle;
 }
 let S3ObjectStorageProvider = class S3ObjectStorageProvider extends ObjectStorageProvider {
-    client;
-    bucket;
-    constructor(config) {
+    #config = inject(S3ObjectStorageProviderConfig);
+    #client = new S3Client({
+        endpoint: this.#config.endpoint,
+        region: this.#config.region ?? 'garage',
+        credentials: {
+            accessKeyId: this.#config.accessKey,
+            secretAccessKey: this.#config.secretKey,
+        },
+        forcePathStyle: this.#config.forcePathStyle,
+    });
+    #bucket = assertDefinedPass((this.#config.bucketPerModule == true) ? true : this.#config.bucket, 'either bucket or bucketPerModule must be specified');
+    constructor() {
         super();
-        const { hostname, port, protocol } = new URL(config.endpoint);
-        if (isDefined(config.bucket) && (config.bucketPerModule == true)) {
+        if (isDefined(this.#config.bucket) && (this.#config.bucketPerModule == true)) {
             throw new Error('bucket and bucketPerModule is mutually exclusive');
         }
-        this.client = new Client({
-            endPoint: hostname,
-            region: config.region,
-            port: (port.length > 0) ? parseInt(port, 10) : undefined,
-            useSSL: protocol == 'https:',
-            accessKey: config.accessKey,
-            secretKey: config.secretKey,
-        });
-        this.bucket = assertDefinedPass((config.bucketPerModule == true) ? true : config.bucket, 'either bucket or bucketPerModule must be specified');
     }
     get(module) {
-        const bucket = (this.bucket == true) ? module : assertStringPass(this.bucket);
-        const prefix = (this.bucket == true) ? '' : ((module == '') ? '' : `${module}/`);
-        return new S3ObjectStorage(this.client, bucket, module, prefix);
+        const bucket = (this.#bucket == true) ? module : assertStringPass(this.#bucket);
+        const prefix = (this.#bucket == true) ? '' : ((module == '') ? '' : `${module}/`);
+        return new S3ObjectStorage(this.#client, bucket, module, prefix);
     }
 };
 S3ObjectStorageProvider = __decorate([
     Singleton(),
-    __metadata("design:paramtypes", [S3ObjectStorageProviderConfig])
+    __metadata("design:paramtypes", [])
 ], S3ObjectStorageProvider);
 export { S3ObjectStorageProvider };
 /**
@@ -78,10 +82,9 @@ export { S3ObjectStorageProvider };
  * @param config s3 config
  * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
  */
-export function configureS3ObjectStorage(config, register = true) {
-    Injector.register(S3ObjectStorageProviderConfig, { useValue: config });
-    if (register) {
-        Injector.registerSingleton(ObjectStorageProvider, { useToken: S3ObjectStorageProvider });
-        Injector.registerSingleton(ObjectStorage, { useToken: S3ObjectStorage });
-    }
+export function configureS3ObjectStorage(config) {
+    const targetInjector = config.injector ?? Injector;
+    targetInjector.register(S3ObjectStorageProviderConfig, { useValue: config });
+    targetInjector.registerSingleton(ObjectStorageProvider, { useToken: S3ObjectStorageProvider });
+    targetInjector.registerSingleton(ObjectStorage, { useToken: S3ObjectStorage });
 }

package/object-storage/s3/s3.object-storage.d.ts

@@ -1,17 +1,17 @@
-import { type BucketItemStat, type Client } from 'minio';
+import { S3Client } from '@aws-sdk/client-s3';
 import { ObjectStorage, type CopyObjectOptions, type MoveObjectOptions, type ObjectStorageConfiguration, type UploadObjectOptions, type UploadUrlOptions } from '../../object-storage/index.js';
-import { S3Object } from './s3.object.js';
+import { S3Object, type S3BucketItemStat } from './s3.object.js';
 export declare class S3ObjectStorage extends ObjectStorage {
     private readonly client;
     private readonly bucket;
     private readonly prefix;
-    constructor(client: Client, bucket: string, module: string, keyPrefix: string);
+    constructor(client: S3Client, bucket: string, module: string, keyPrefix: string);
     ensureBucketExists(region?: string, options?: {
         objectLocking?: boolean;
     }): Promise<void>;
     configureBucket(configuration: ObjectStorageConfiguration): Promise<void>;
     exists(key: string): Promise<boolean>;
-    statObject(key: string): Promise<BucketItemStat>;
+    statObject(key: string): Promise<S3BucketItemStat>;
     uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<S3Object>;
     copyObject(source: S3Object | string, destination: S3Object | string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<S3Object>;
     moveObject(source: S3Object | string, destination: S3Object | string | [ObjectStorage, string], options?: MoveObjectOptions): Promise<S3Object>;
@@ -28,4 +28,7 @@ export declare class S3ObjectStorage extends ObjectStorage {
     private getResourceUriSync;
     private getBucketKey;
     private getKey;
+    isNotFoundError(error: unknown): boolean;
+    isForbiddenError(error: unknown): boolean;
+    isError(error: unknown, ...names: string[]): boolean;
 }