@tstdl/base 0.93.116 → 0.93.118

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/notification/types.d.ts

@@ -0,0 +1,9 @@
+import { InAppNotificationView, type NotificationDefinitionMap } from './models/index.js';
+export declare const notificationStreamItemSchema: import("../schema/index.js").ObjectSchema<{
+    unreadCount: number;
+    notification?: InAppNotificationView<Record<string, import("./models/notification-log.model.js").NotificationDefinition<import("../types/types.js").ObjectLiteral, import("../types/types.js").ObjectLiteral>>> | undefined;
+}>;
+export type NotificationStreamItem<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
+    notification?: InAppNotificationView<Definitions>;
+    unreadCount: number;
+};

package/notification/types.js

@@ -0,0 +1,6 @@
+import { number, object, optional } from '../schema/index.js';
+import { InAppNotificationView } from './models/index.js';
+export const notificationStreamItemSchema = object({
+    notification: optional(InAppNotificationView),
+    unreadCount: number(),
+});

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;
 }

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

@@ -9,20 +9,19 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 var S3ObjectStorage_1;
 import { Readable } from 'node:stream';
-import { CopyDestinationOptions, CopySourceOptions } from 'minio';
+import { CopyObjectCommand, CreateBucketCommand, DeleteBucketLifecycleCommand, DeleteObjectCommand, DeleteObjectsCommand, GetBucketLifecycleConfigurationCommand, GetObjectCommand, HeadBucketCommand, HeadObjectCommand, ListObjectsV2Command, PutBucketLifecycleConfigurationCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { match, P } from 'ts-pattern';
 import { Singleton } from '../../injector/decorators.js';
 import { registerAfterResolve } from '../../injector/resolution.js';
 import { ObjectStorage } from '../../object-storage/index.js';
-import { toArray } from '../../utils/array/array.js';
-import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { now } from '../../utils/date-time.js';
 import { mapObjectKeys } from '../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../utils/stream/index.js';
 import { readBinaryStream } from '../../utils/stream/stream-reader.js';
 import { _throw } from '../../utils/throw.js';
-import { assertDefinedPass, isDefined, isObject, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
+import { assertDefinedPass, isBlob, isDate, isDefined, isObject, isReadableStream, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
 import { secondsPerDay } from '../../utils/units.js';
 import { S3ObjectStorageProvider } from './s3.object-storage-provider.js';
 import { S3Object } from './s3.object.js';
@@ -42,27 +41,37 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
         });
     }
     async ensureBucketExists(region, options) {
-        const exists = await this.client.bucketExists(this.bucket);
-        if (exists) {
+        try {
+            await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }));
             return;
         }
-        await this.client.makeBucket(this.bucket, region ?? '', { ObjectLocking: options?.objectLocking ?? false });
+        catch (error) {
+            // ignore error if bucket already exists (e.g. 403 Forbidden when we have no head permission but it might still exist)
+            if (this.isNotFoundError(error)) {
+                await this.client.send(new CreateBucketCommand({
+                    Bucket: this.bucket,
+                    CreateBucketConfiguration: isDefined(region) ? { LocationConstraint: region } : undefined,
+                    ObjectLockEnabledForBucket: options?.objectLocking,
+                }));
+                return;
+            }
+            throw error;
+        }
     }
     async configureBucket(configuration) {
         if (isUndefined(configuration.lifecycle)) {
             return;
         }
-        let currentLifecycle = null;
+        let currentLifecycleRules;
         try {
-            currentLifecycle = await this.client.getBucketLifecycle(this.bucket);
+            const result = await this.client.send(new GetBucketLifecycleConfigurationCommand({ Bucket: this.bucket }));
+            currentLifecycleRules = result.Rules;
         }
         catch (error) {
-            // ignore error if lifecycle configuration is not set
-            if (!isObject(error) || (error.code != 'NoSuchLifecycleConfiguration')) {
+            if (!this.isError(error, 'NoSuchLifecycleConfiguration')) {
                 throw error;
             }
         }
-        const currentLifecycleRules = isDefined(currentLifecycle?.Rule) ? toArray(currentLifecycle.Rule) : undefined; // https://github.com/minio/minio-js/issues/1407
         const tstdlRule = currentLifecycleRules?.find((rule) => rule.ID == 'TstdlExpireObjects');
         const tstdlRuleExpiration = tstdlRule?.Expiration?.Days;
         const targetExpirationDays = configuration.lifecycle?.expiration?.after;
@@ -73,35 +82,43 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
         const nonTstdlRules = currentLifecycleRules?.filter((rule) => rule.ID != 'TstdlExpireObjects') ?? [];
         if (isUndefined(targetExpiration)) {
             if (nonTstdlRules.length == 0) {
-                await this.client.removeBucketLifecycle(this.bucket);
+                await this.client.send(new DeleteBucketLifecycleCommand({
+                    Bucket: this.bucket,
+                }));
             }
             else {
-                await this.client.setBucketLifecycle(this.bucket, { Rule: nonTstdlRules });
+                await this.client.send(new PutBucketLifecycleConfigurationCommand({
+                    Bucket: this.bucket,
+                    LifecycleConfiguration: { Rules: nonTstdlRules },
+                }));
             }
         }
         else {
-            await this.client.setBucketLifecycle(this.bucket, {
-                Rule: [
-                    ...nonTstdlRules,
-                    {
-                        ID: 'TstdlExpireObjects',
-                        Status: 'Enabled',
-                        Expiration: {
-                            Days: targetExpiration,
+            await this.client.send(new PutBucketLifecycleConfigurationCommand({
+                Bucket: this.bucket,
+                LifecycleConfiguration: {
+                    Rules: [
+                        ...nonTstdlRules,
+                        {
+                            ID: 'TstdlExpireObjects',
+                            Status: 'Enabled',
+                            Expiration: {
+                                Days: targetExpiration,
+                            },
                         },
-                    },
-                ],
-            });
+                    ],
+                },
+            }));
         }
     }
     async exists(key) {
         const bucketKey = this.getBucketKey(key);
         try {
-            await this.client.statObject(this.bucket, bucketKey);
+            await this.client.send(new HeadObjectCommand({ Bucket: this.bucket, Key: bucketKey }));
             return true;
         }
         catch (error) {
-            if (isObject(error) && error.code == 'NotFound') {
+            if (this.isNotFoundError(error)) {
                 return false;
             }
             throw error;
@@ -109,21 +126,28 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
     }
     async statObject(key) {
         const bucketKey = this.getBucketKey(key);
-        return await this.client.statObject(this.bucket, bucketKey);
+        const result = await this.client.send(new HeadObjectCommand({ Bucket: this.bucket, Key: bucketKey }));
+        return {
+            size: result.ContentLength ?? 0,
+            etag: result.ETag ?? '',
+            lastModified: result.LastModified?.getTime(),
+            metadata: result.Metadata ?? {},
+        };
     }
     async uploadObject(key, content, options) {
         const bucketKey = this.getBucketKey(key);
-        if (isUint8Array(content)) {
-            await this.client.putObject(this.bucket, bucketKey, Buffer.from(content), options?.contentLength, options?.metadata);
-        }
-        else {
-            const readable = Readable.fromWeb(content);
-            const errorPromise = new Promise((_, reject) => readable.on('error', reject));
-            await Promise.race([
-                this.client.putObject(this.bucket, bucketKey, readable, options?.contentLength, options?.metadata),
-                errorPromise,
-            ]);
-        }
+        const body = isUint8Array(content) ? content : Readable.fromWeb(content);
+        const metadata = isDefined(options?.metadata) ? mapObjectKeys(options.metadata, (key) => key.toLowerCase()) : undefined;
+        await this.client.send(new PutObjectCommand({
+            Bucket: this.bucket,
+            Key: bucketKey,
+            Body: body,
+            ContentLength: options?.contentLength,
+            ContentType: options?.contentType,
+            ContentDisposition: options?.contentDisposition,
+            CacheControl: options?.cacheControl,
+            Metadata: metadata,
+        }));
         return await this.getObject(key);
     }
     async copyObject(source, destination, options) {
@@ -137,11 +161,16 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
             .with([P.instanceOf(S3ObjectStorage_1), P.string], async ([storage, key]) => await storage.getObject(key))
             .otherwise(() => _throw(new Error('Destination must be a S3Object, string key, or [S3ObjectStorage, string] tuple.')));
         const sourceMetadata = await sourceObject.getMetadata();
-        await this.client.copyObject(new CopySourceOptions({ Bucket: this.bucket, Object: sourceObject.storage.getBucketKey(sourceObject.key) }), new CopyDestinationOptions({
+        const metadata = mapObjectKeys({ ...sourceMetadata, ...options?.metadata }, (key) => key.toLowerCase());
+        await this.client.send(new CopyObjectCommand({
+            CopySource: `${this.bucket}/${sourceObject.storage.getBucketKey(sourceObject.key)}`,
             Bucket: destinationObject.storage.bucket,
-            Object: destinationObject.storage.getBucketKey(destinationObject.key),
+            Key: destinationObject.storage.getBucketKey(destinationObject.key),
             MetadataDirective: 'REPLACE',
-            UserMetadata: { ...sourceMetadata, ...options?.metadata },
+            ContentType: options?.contentType,
+            ContentDisposition: options?.contentDisposition,
+            CacheControl: options?.cacheControl,
+            Metadata: metadata,
         }));
         return destinationObject;
     }
@@ -153,22 +182,45 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
     }
     async getContent(key) {
         const bucketKey = this.getBucketKey(key);
-        const result = await this.client.getObject(this.bucket, bucketKey);
-        return await readBinaryStream(result);
+        const result = await this.client.send(new GetObjectCommand({ Bucket: this.bucket, Key: bucketKey }));
+        if (isUint8Array(result.Body)) {
+            return result.Body;
+        }
+        return await readBinaryStream(result.Body);
     }
     getContentStream(key) {
         const bucketKey = this.getBucketKey(key);
         return readableStreamFromPromise(async () => {
-            const readable = await this.client.getObject(this.bucket, bucketKey);
-            return Readable.toWeb(readable);
+            const result = await this.client.send(new GetObjectCommand({ Bucket: this.bucket, Key: bucketKey }));
+            if (isReadableStream(result.Body)) {
+                return result.Body;
+            }
+            if (isBlob(result.Body)) {
+                return result.Body.stream();
+            }
+            return Readable.toWeb(result.Body);
         });
     }
     async getObjects() {
         return await toArrayAsync(this.getObjectsCursor());
     }
-    getObjectsCursor() {
-        const stream = this.client.listObjectsV2(this.bucket, this.prefix, true);
-        return mapAsync(stream, (item) => new S3Object(this.module, this.getKey(item.name), `s3://${this.bucket}/${item.name}`, item.size, this));
+    async *getObjectsCursor() {
+        let continuationToken;
+        do {
+            const result = await this.client.send(new ListObjectsV2Command({
+                Bucket: this.bucket,
+                Prefix: this.prefix,
+                ContinuationToken: continuationToken,
+            }));
+            if (isDefined(result.Contents)) {
+                for (const item of result.Contents) {
+                    if (isDefined(item.Key)) {
+                        yield new S3Object(this.module, this.getKey(item.Key), `s3://${this.bucket}/${item.Key}`, item.Size, this);
+                    }
+                }
+            }
+            continuationToken = result.NextContinuationToken;
+        } while (isDefined(continuationToken));
     }
     // eslint-disable-next-line @typescript-eslint/require-await
     async getObject(key) {
@@ -180,22 +232,42 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
     }
     async getDownloadUrl(key, expirationTimestamp, responseHeaders) {
         const bucketKey = this.getBucketKey(key);
-        const { date, expiration } = getDateAndExpiration(expirationTimestamp);
-        return await this.client.presignedGetObject(this.bucket, bucketKey, expiration, responseHeaders ?? {}, date);
+        const expiration = getExpiration(expirationTimestamp);
+        const expiresHeader = responseHeaders?.['Expires'];
+        const mappedExpiresHeader = isDefined(expiresHeader) ? (isDate(expiresHeader) ? expiresHeader : new Date(expiresHeader)) : undefined;
+        return await getSignedUrl(this.client, new GetObjectCommand({
+            Bucket: this.bucket,
+            Key: bucketKey,
+            ResponseContentType: responseHeaders?.['Content-Type'],
+            ResponseContentDisposition: responseHeaders?.['Content-Disposition'],
+            ResponseCacheControl: responseHeaders?.['Cache-Control'],
+            ResponseContentLanguage: responseHeaders?.['Content-Language'],
+            ResponseContentEncoding: responseHeaders?.['Content-Encoding'],
+            ResponseExpires: mappedExpiresHeader,
+        }), { expiresIn: expiration });
     }
     async getUploadUrl(key, expirationTimestamp, options) {
         const bucketKey = this.getBucketKey(key);
-        const { date, expiration } = getDateAndExpiration(expirationTimestamp);
-        const query = mapObjectKeys(options?.metadata ?? {}, (key) => `X-Amz-Meta-${key}`);
-        return await this.client.presignedUrl('PUT', this.bucket, bucketKey, expiration, query, date);
+        const expiration = getExpiration(expirationTimestamp);
+        return await getSignedUrl(this.client, new PutObjectCommand({
+            Bucket: this.bucket,
+            Key: bucketKey,
+            Metadata: options?.metadata,
+            ContentType: options?.contentType,
+            ContentDisposition: options?.contentDisposition,
+            CacheControl: options?.cacheControl,
+        }), { expiresIn: expiration });
     }
     async deleteObject(key) {
         const bucketKey = this.getBucketKey(key);
-        await this.client.removeObject(this.bucket, bucketKey);
+        await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: bucketKey }));
     }
     async deleteObjects(keys) {
-        const bucketKeys = keys.map((key) => this.getBucketKey(key));
-        await this.client.removeObjects(this.bucket, bucketKeys);
+        const bucketKeys = keys.map((key) => ({ Key: this.getBucketKey(key) }));
+        await this.client.send(new DeleteObjectsCommand({
+            Bucket: this.bucket,
+            Delete: { Objects: bucketKeys },
+        }));
     }
     getResourceUriSync(key) {
         const bucketKey = this.getBucketKey(key);
@@ -207,6 +279,15 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
     getKey(bucketKey) {
         return bucketKey.slice(this.prefix.length);
     }
+    isNotFoundError(error) {
+        return this.isError(error, 'NotFound', 'NoSuchKey');
+    }
+    isForbiddenError(error) {
+        return this.isError(error, 'Forbidden', 'AccessDenied', 'InvalidAccessKeyId', 'SignatureDoesNotMatch') || ((isObject(error) && isObject(error.$metadata) && error.$metadata.httpStatusCode == 403));
+    }
+    isError(error, ...names) {
+        return isObject(error) && names.includes(error.name);
+    }
 };
 S3ObjectStorage = S3ObjectStorage_1 = __decorate([
     Singleton({
@@ -218,11 +299,11 @@ S3ObjectStorage = S3ObjectStorage_1 = __decorate([
         },
         argumentIdentityProvider: JSON.stringify,
     }),
-    __metadata("design:paramtypes", [Function, String, String, String])
+    __metadata("design:paramtypes", [S3Client, String, String, String])
 ], S3ObjectStorage);
 export { S3ObjectStorage };
-function getDateAndExpiration(expirationTimestamp) {
+function getExpiration(expirationTimestamp) {
     const date = now();
     const diffSeconds = Math.floor((expirationTimestamp - date.getTime()) / 1000);
-    return { date, expiration: diffSeconds };
+    return diffSeconds;
 }

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

@@ -1,6 +1,12 @@
 import type { ObjectMetadata } from '../../object-storage/object.js';
 import { ObjectStorageObject } from '../../object-storage/object.js';
 import type { S3ObjectStorage } from './s3.object-storage.js';
+export type S3BucketItemStat = {
+    size: number;
+    etag?: string;
+    lastModified?: number;
+    metadata: ObjectMetadata;
+};
 export declare class S3Object extends ObjectStorageObject {
     private readonly resourceUri;
     private contentLength;