@tstdl/base 0.92.132 → 0.92.135

package/http/client/http-client.js

@@ -35,11 +35,11 @@ let HttpClient = class HttpClient {
     constructor() {
         this.internalStartMiddleware = [
             getBuildRequestUrlMiddleware(this.options.baseUrl),
-            ...((this.options.enableErrorHandling ?? true) ? [errorMiddleware] : [])
+            ...((this.options.enableErrorHandling ?? true) ? [errorMiddleware] : []),
         ];
         this.internalEndMiddleware = [
             getAddRequestHeadersMiddleware(this.headers),
-            getAdapterCallMiddleware(this.adapter)
+            getAdapterCallMiddleware(this.adapter),
         ];
         this.updateMiddleware();
     }
@@ -54,22 +54,22 @@ let HttpClient = class HttpClient {
         this.headers.remove(name);
     }
     async head(url, options) {
-        return this.request('HEAD', url, { ...options });
+        return await this.request('HEAD', url, { ...options });
     }
     async get(url, options) {
-        return this.request('GET', url, options);
+        return await this.request('GET', url, options);
     }
     async getText(url, options) {
         const response = await this.request('GET', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async getJson(url, options) {
         const response = await this.request('GET', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async getBuffer(url, options) {
         const response = await this.request('GET', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     getStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -90,19 +90,19 @@ let HttpClient = class HttpClient {
         });
     }
     async post(url, options) {
-        return this.request('POST', url, options);
+        return await this.request('POST', url, options);
     }
     async postText(url, options) {
         const response = await this.request('POST', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async postJson(url, options) {
         const response = await this.request('POST', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async postBuffer(url, options) {
         const response = await this.request('POST', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     postStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -111,19 +111,19 @@ let HttpClient = class HttpClient {
         });
     }
     async put(url, options) {
-        return this.request('PUT', url, options);
+        return await this.request('PUT', url, options);
     }
     async putText(url, options) {
         const response = await this.request('PUT', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async putJson(url, options) {
         const response = await this.request('PUT', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async putBuffer(url, options) {
         const response = await this.request('PUT', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     putStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -132,19 +132,19 @@ let HttpClient = class HttpClient {
         });
     }
     async patch(url, options) {
-        return this.request('PATCH', url, options);
+        return await this.request('PATCH', url, options);
     }
     async patchText(url, options) {
         const response = await this.request('PATCH', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async patchJson(url, options) {
         const response = await this.request('PATCH', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async patchBuffer(url, options) {
         const response = await this.request('PATCH', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     patchStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -153,19 +153,19 @@ let HttpClient = class HttpClient {
         });
     }
     async delete(url, options) {
-        return this.request('DELETE', url, options);
+        return await this.request('DELETE', url, options);
     }
     async deleteText(url, options) {
         const response = await this.request('DELETE', url, { ...options });
-        return response.body.readAsText();
+        return await response.body.readAsText();
     }
     async deleteJson(url, options) {
         const response = await this.request('DELETE', url, { ...options });
-        return response.body.readAsJson();
+        return await response.body.readAsJson();
     }
     async deleteBuffer(url, options) {
         const response = await this.request('DELETE', url, { ...options });
-        return response.body.readAsBuffer();
+        return await response.body.readAsBuffer();
     }
     deleteStream(url, options) {
         return readableStreamFromPromise(async () => {
@@ -175,7 +175,7 @@ let HttpClient = class HttpClient {
     }
     async request(method, url, options = {}) {
         const request = new HttpClientRequest(url, method, options);
-        return this.rawRequest(request);
+        return await this.rawRequest(request);
     }
     async rawRequest(request) {
         const context = { request };
@@ -197,7 +197,7 @@ function getBuildRequestUrlMiddleware(baseUrl) {
         if (request.mapParameters) {
             mapParameters(request, baseUrl);
         }
-        return next();
+        await next();
     }
     return buildUrlParametersMiddleware;
 }
@@ -238,7 +238,7 @@ function getAddRequestHeadersMiddleware(defaultHeaders) {
                 request.headers.authorization = `Token ${authorization.token}`;
             }
         }
-        return next();
+        await next();
     }
     return addRequestHeadersMiddleware;
 }
@@ -267,7 +267,6 @@ async function errorMiddleware(context, next) {
         throw error;
     }
 }
-// eslint-disable-next-line max-statements, max-lines-per-function, complexity
 function mapParameters(request, baseUrl) {
     const isGetOrHead = (request.method == 'GET') || (request.method == 'HEAD');
     let url;
@@ -299,7 +298,7 @@ function mapParameters(request, baseUrl) {
         }
     }
     if (parameterEntries.size > 0) {
-        throw new HttpError(HttpErrorReason.InvalidRequest, request, undefined, 'Not all parameters could be mapped to url, query and body because request is either GET/HEAD or body is already defined');
+        throw new HttpError(HttpErrorReason.InvalidRequest, request, { cause: 'Not all parameters could be mapped to url, query and body because request is either GET/HEAD or body is already defined' });
     }
     if (isDefined(request.query)) {
         for (const [key, valueOrValues] of request.query) {
@@ -315,8 +314,8 @@ function mapParameters(request, baseUrl) {
 }
 function getAdapterCallMiddleware(adapter) {
     async function adapterCallMiddleware(context, next) {
-        context.response = await adapter.call(context.request); // eslint-disable-line require-atomic-updates
-        return next();
+        context.response = await adapter.call(context.request);
+        await next();
     }
     return adapterCallMiddleware;
 }

package/http/http-body.js

@@ -17,19 +17,19 @@ export class HttpBody {
     }
     async readAsBuffer(options) {
         this.prepareBodyRead();
-        return readBodyAsBuffer(this.body, this.headers, options);
+        return await readBodyAsBuffer(this.body, this.headers, options);
     }
     async readAsText(options) {
         this.prepareBodyRead();
-        return readBodyAsText(this.body, this.headers, options);
+        return await readBodyAsText(this.body, this.headers, options);
     }
     async readAsJson(options) {
         this.prepareBodyRead();
-        return readBodyAsJson(this.body, this.headers, options);
+        return await readBodyAsJson(this.body, this.headers, options);
     }
     async read(options) {
         this.prepareBodyRead();
-        return readBody(this.body, this.headers, options);
+        return await readBody(this.body, this.headers, options);
     }
     readAsBinaryStream(options) {
         this.prepareBodyRead();

package/http/http.error.d.ts

@@ -22,7 +22,11 @@ export declare class HttpError extends CustomError implements ErrorExtraInfo {
     readonly responseBody: UndefinableJson | Uint8Array;
     readonly requestInstance: HttpClientRequest;
     readonly responseInstance: HttpClientResponse | undefined;
-    constructor(reason: HttpErrorReason, request: HttpClientRequest, response?: HttpClientResponse, responseBody?: UndefinableJson | Uint8Array, cause?: Error | string);
+    constructor(reason: HttpErrorReason, request: HttpClientRequest, { response, responseBody, cause }?: {
+        response?: HttpClientResponse;
+        responseBody?: UndefinableJson | Uint8Array;
+        cause?: Error | string;
+    });
     static create(reason: HttpErrorReason, request: HttpClientRequest, response: HttpClientResponse | undefined, cause?: Error | string): Promise<HttpError>;
     getExtraInfo(): UndefinableJson | undefined;
 }

package/http/http.error.js

@@ -22,8 +22,8 @@ export class HttpError extends CustomError {
     responseBody;
     requestInstance;
     responseInstance;
-    constructor(reason, request, response, responseBody, cause) {
-        super({ message: (isString(cause) ? cause : cause?.message) ?? 'An error occurred', cause: (isNotString(cause) ? cause : undefined) });
+    constructor(reason, request, { response, responseBody, cause } = {}) {
+        super({ message: (isString(cause) ? cause : cause?.message) ?? 'An error occurred', cause: (isNotString(cause) ? cause : new Error(cause)) });
         this.reason = reason;
         this.request = request.asObject();
         this.response = response?.asObject();
@@ -35,21 +35,21 @@ export class HttpError extends CustomError {
         }
         Object.defineProperty(this, propertyNameOf((instance) => instance.requestInstance), {
             value: request,
-            enumerable: false
+            enumerable: false,
         });
         Object.defineProperty(this, propertyNameOf((instance) => instance.responseInstance), {
             value: response,
-            enumerable: false
+            enumerable: false,
         });
     }
     static async create(reason, request, response, cause) {
         const body = (response?.body.available == true) ? await response.body.read() : undefined;
-        return new HttpError(reason, request, response, body, cause);
+        return new HttpError(reason, request, { response, responseBody: body, cause });
     }
     getExtraInfo() {
         const extraInfo = {
             url: this.request.url,
-            method: this.request.method
+            method: this.request.method,
         };
         if (isDefined(this.response)) {
             const responseExtraInfo = {};

package/http/utils.js

@@ -20,7 +20,7 @@ export function readBodyAsBinaryStream(body, headers, options = {}) {
                     start: (controller) => {
                         controller.enqueue(body);
                         controller.close();
-                    }
+                    },
                 })
                 : isAnyIterable(body)
                     ? getReadableStreamFromIterable(body)
@@ -83,12 +83,12 @@ export async function readBodyAsJson(body, headers, options) {
 }
 export async function readBody(body, headers, options) {
     if (headers.contentType?.includes('json') == true) {
-        return readBodyAsJson(body, headers, { ...options, fallbackToText: true });
+        return await readBodyAsJson(body, headers, { ...options, fallbackToText: true });
     }
     if (headers.contentType?.includes('text') == true) {
-        return readBodyAsText(body, headers, options);
+        return await readBodyAsText(body, headers, options);
     }
-    return readBodyAsBuffer(body, headers, options);
+    return await readBodyAsBuffer(body, headers, options);
 }
 export function readBodyAsStream(body, headers, options) {
     if ((headers.contentType?.includes('json') == true) || (headers.contentType?.includes('text') == true)) {

package/injector/decorators.d.ts

@@ -28,7 +28,7 @@ export declare function Injectable<T = any, A = any, C extends Record = Record>(
  * Registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
  * @param options registration options
  */
-export declare function Singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+export declare function Singleton<T = any, A = undefined>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
 /**
  * Registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
  * @param options registration options

package/injector/injector.d.ts

@@ -49,7 +49,7 @@ export declare class Injector implements AsyncDisposable {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static registerSingleton<T, A = ResolveArgument<T, any>, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
+    static registerSingleton<T, A = undefined, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     fork(name: string): Injector;

package/injector/interfaces.d.ts

@@ -4,7 +4,7 @@ import type { AfterResolveContext } from './types.js';
 export declare const resolveArgumentType: unique symbol;
 export declare const afterResolve: unique symbol;
 export type ResolveArgumentType = typeof resolveArgumentType;
-export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? (U | undefined) : T extends Type<Resolvable<infer U>> ? (U | undefined) : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
+export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? (U | undefined) : T extends Type<Pick<Required<Resolvable<infer U>>, typeof resolveArgumentType>> ? (U | undefined) : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
 export interface Resolvable<A = unknown, D extends Record = Record> extends Partial<AfterResolve<A, D>> {
     /**
      * Type of resolve argument

package/injector/provider.d.ts

@@ -2,15 +2,15 @@ import type { Constructor, Record, TypedOmit } from '../types.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 import type { AfterResolveContext, ResolveContext } from './types.js';
-export type Factory<T, A = any, D extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<D>) => T;
+export type Factory<T, A = undefined, D extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<D>) => T;
 export type ProviderWithArgument<T, A> = {
     defaultArgument?: ResolveArgument<T, A>;
     defaultArgumentProvider?: () => ResolveArgument<T, A>;
 };
 export type ProviderWithInitializer<T, A, D extends Record> = {
-    afterResolve?: (value: T, argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
+    afterResolve?: (value: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => void | Promise<void>;
 };
-export type Provider<T = any, A = any, D extends Record = Record> = ClassProvider<T, A, D> | ValueProvider<T> | TokenProvider<T, A, D> | FactoryProvider<T, A, D>;
+export type Provider<T = any, A = undefined, D extends Record = Record> = ClassProvider<T, A, D> | ValueProvider<T> | TokenProvider<T, A, D> | FactoryProvider<T, A, D>;
 export type ClassProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
     useClass: Constructor<T>;
 };
@@ -34,7 +34,7 @@ export type TokenProvider<T = any, A = any, D extends Record = Record> = Provide
     useTokenProvider: () => InjectionToken<T extends (infer U)[] ? U : T, A>;
     resolveAll: true;
 });
-export type FactoryProvider<T = any, A = unknown, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
+export type FactoryProvider<T = any, A = undefined, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
     useFactory: Factory<T, A, D>;
 };
 export declare function classProvider<T, A, D extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, D>, 'useClass'>): ClassProvider<T, A, D>;

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

@@ -2,9 +2,30 @@ import { resolveArgumentType, type Resolvable } from '../injector/interfaces.js'
 import type { ObjectMetadata, ObjectStorageObject } from './object.js';
 export type UploadObjectOptions = {
     contentLength?: number;
+    contentType?: string;
     metadata?: ObjectMetadata;
 };
-export type ObjectStorageArgument = string;
+export type UploadUrlOptions = {
+    metadata?: ObjectMetadata;
+};
+export type CopyObjectOptions = {
+    metadata?: ObjectMetadata;
+};
+export type MoveObjectOptions = {
+    metadata?: ObjectMetadata;
+};
+export type ObjectStorageConfiguration = {
+    lifecycle?: {
+        expiration?: {
+            /** Expire (delete) objects after a certain number of seconds. Implementations may round up to supported intervals. */
+            after?: number;
+        };
+    };
+};
+export type ObjectStorageArgument = string | {
+    module: string;
+    configuration?: ObjectStorageConfiguration;
+};
 export declare abstract class ObjectStorage implements Resolvable<ObjectStorageArgument> {
     /** Object storage module */
     readonly module: string;
@@ -19,14 +40,29 @@ export declare abstract class ObjectStorage implements Resolvable<ObjectStorageA
      * Uploads an object
      * @param key object key
      * @param content content of object
+     * @param options options
      */
     abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
+    /**
+     * Copies an object
+     * @param sourceKey source object key
+     * @param destinationKey destination object key or destination storage and key
+     * @param options options
+     */
+    abstract copyObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<void>;
+    /**
+     * Moves an object
+     * @param sourceKey source object key
+     * @param destinationKey destination object key or destination storage and key
+     * @param options options
+     */
+    abstract moveObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: MoveObjectOptions): Promise<void>;
     /**
      * Get an url which can be used to upload the object without further authorization
      * @param key object key
      * @param expirationTimestamp timestamp when the url expires and can no longer be used
      */
-    abstract getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
+    abstract getUploadUrl(key: string, expirationTimestamp: number, options?: UploadUrlOptions): Promise<string>;
     /**
      * Get all objects
      */

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

@@ -54,7 +54,7 @@ let S3ObjectStorageProvider = class S3ObjectStorageProvider extends ObjectStorag
             port: (port.length > 0) ? parseInt(port, 10) : undefined,
             useSSL: protocol == 'https:',
             accessKey: config.accessKey,
-            secretKey: config.secretKey
+            secretKey: config.secretKey,
         });
         this.bucket = assertDefinedPass((config.bucketPerModule == true) ? true : config.bucket, 'either bucket or bucketPerModule must be specified');
     }

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

@@ -1,5 +1,5 @@
-import type { BucketItemStat, Client } from 'minio';
-import { ObjectStorage, type UploadObjectOptions } from '../../object-storage/index.js';
+import { type BucketItemStat, type Client } from 'minio';
+import { ObjectStorage, type CopyObjectOptions, type MoveObjectOptions, type ObjectStorageConfiguration, type UploadObjectOptions, type UploadUrlOptions } from '../../object-storage/index.js';
 import { S3Object } from './s3.object.js';
 export declare class S3ObjectStorage extends ObjectStorage {
     private readonly client;
@@ -9,9 +9,12 @@ export declare class S3ObjectStorage extends ObjectStorage {
     ensureBucketExists(region?: string, options?: {
         objectLocking?: boolean;
     }): Promise<void>;
+    configureBucket(configuration: ObjectStorageConfiguration): Promise<void>;
     exists(key: string): Promise<boolean>;
     statObject(key: string): Promise<BucketItemStat>;
     uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
+    copyObject(source: string, destination: string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<void>;
+    moveObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: MoveObjectOptions): Promise<void>;
     getContent(key: string): Promise<Uint8Array>;
     getContentStream(key: string): ReadableStream<Uint8Array>;
     getObjects(): Promise<S3Object[]>;
@@ -19,7 +22,7 @@ export declare class S3ObjectStorage extends ObjectStorage {
     getObject(key: string): Promise<S3Object>;
     getResourceUri(key: string): Promise<string>;
     getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
-    getUploadUrl(key: string, expirationTimestamp: number): Promise<string>;
+    getUploadUrl(key: string, expirationTimestamp: number, options?: UploadUrlOptions): Promise<string>;
     deleteObject(key: string): Promise<void>;
     deleteObjects(keys: string[]): Promise<void>;
     private getResourceUriSync;

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

@@ -7,18 +7,24 @@ 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);
 };
+var S3ObjectStorage_1;
 import { Readable } from 'node:stream';
+import { CopyDestinationOptions, CopySourceOptions } from 'minio';
 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 { assertStringPass, isObject, isUint8Array } from '../../utils/type-guards.js';
+import { assertDefinedPass, assertInstanceOfPass, isDefined, isObject, 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';
-let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
+let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectStorage {
     client;
     bucket;
     prefix;
@@ -27,6 +33,11 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         this.client = client;
         this.bucket = bucket;
         this.prefix = keyPrefix;
+        registerAfterResolve(this, async (argument) => {
+            const configuration = (isString(argument) ? undefined : argument.configuration) ?? {};
+            await this.ensureBucketExists();
+            await this.configureBucket(configuration);
+        });
     }
     async ensureBucketExists(region, options) {
         const exists = await this.client.bucketExists(this.bucket);
@@ -35,6 +46,49 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         }
         await this.client.makeBucket(this.bucket, region ?? '', { ObjectLocking: options?.objectLocking ?? false });
     }
+    async configureBucket(configuration) {
+        let currentLifecycle = null;
+        try {
+            currentLifecycle = await this.client.getBucketLifecycle(this.bucket);
+        }
+        catch (error) {
+            // ignore error if lifecycle configuration is not set
+            if (!isObject(error) || (error.code != '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;
+        const targetExpiration = isDefined(targetExpirationDays) ? Math.ceil(targetExpirationDays / secondsPerDay) : undefined;
+        if (tstdlRuleExpiration == targetExpiration) {
+            return;
+        }
+        const nonTstdlRules = currentLifecycleRules?.filter((rule) => rule.ID != 'TstdlExpireObjects') ?? [];
+        if (isUndefined(targetExpiration)) {
+            if (nonTstdlRules.length == 0) {
+                await this.client.removeBucketLifecycle(this.bucket);
+            }
+            else {
+                await this.client.setBucketLifecycle(this.bucket, { Rule: nonTstdlRules });
+            }
+        }
+        else {
+            await this.client.setBucketLifecycle(this.bucket, {
+                Rule: [
+                    ...nonTstdlRules,
+                    {
+                        ID: 'TstdlExpireObjects',
+                        Status: 'Enabled',
+                        Expiration: {
+                            Days: targetExpiration,
+                        },
+                    },
+                ],
+            });
+        }
+    }
     async exists(key) {
         const bucketKey = this.getBucketKey(key);
         try {
@@ -50,7 +104,7 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
     }
     async statObject(key) {
         const bucketKey = this.getBucketKey(key);
-        return this.client.statObject(this.bucket, bucketKey);
+        return await this.client.statObject(this.bucket, bucketKey);
     }
     async uploadObject(key, content, options) {
         const bucketKey = this.getBucketKey(key);
@@ -66,10 +120,28 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
             ]);
         }
     }
+    async copyObject(source, destination, options) {
+        const sourceBucketKey = this.getBucketKey(source);
+        const [destinationObjectStorage, destinationKey] = isString(destination) ? [this, destination] : [assertInstanceOfPass(destination[0], S3ObjectStorage_1, 'Destination storage is not an S3ObjectStorage'), destination[1]];
+        const destinationBucket = destinationObjectStorage.bucket;
+        const destinationBucketKey = destinationObjectStorage.getBucketKey(destinationKey);
+        const sourceObject = await this.getObject(source);
+        const sourceMetadata = await sourceObject.getMetadata();
+        await this.client.copyObject(new CopySourceOptions({ Bucket: this.bucket, Object: sourceBucketKey }), new CopyDestinationOptions({
+            Bucket: destinationBucket,
+            Object: destinationBucketKey,
+            MetadataDirective: 'REPLACE',
+            UserMetadata: { ...sourceMetadata, ...options?.metadata },
+        }));
+    }
+    async moveObject(sourceKey, destinationKey, options) {
+        await this.copyObject(sourceKey, destinationKey, options);
+        await this.deleteObject(sourceKey);
+    }
     async getContent(key) {
         const bucketKey = this.getBucketKey(key);
         const result = await this.client.getObject(this.bucket, bucketKey);
-        return readBinaryStream(result);
+        return await readBinaryStream(result);
     }
     getContentStream(key) {
         const bucketKey = this.getBucketKey(key);
@@ -79,7 +151,7 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         });
     }
     async getObjects() {
-        return toArrayAsync(this.getObjectsCursor());
+        return await toArrayAsync(this.getObjectsCursor());
     }
     getObjectsCursor() {
         const stream = this.client.listObjectsV2(this.bucket, this.prefix, true);
@@ -96,12 +168,13 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
     async getDownloadUrl(key, expirationTimestamp, responseHeaders) {
         const bucketKey = this.getBucketKey(key);
         const { date, expiration } = getDateAndExpiration(expirationTimestamp);
-        return this.client.presignedGetObject(this.bucket, bucketKey, expiration, responseHeaders ?? {}, date);
+        return await this.client.presignedGetObject(this.bucket, bucketKey, expiration, responseHeaders ?? {}, date);
     }
-    async getUploadUrl(key, expirationTimestamp) {
+    async getUploadUrl(key, expirationTimestamp, options) {
         const bucketKey = this.getBucketKey(key);
         const { date, expiration } = getDateAndExpiration(expirationTimestamp);
-        return this.client.presignedUrl('PUT', this.bucket, bucketKey, expiration, {}, date);
+        const query = mapObjectKeys(options?.metadata ?? {}, (key) => `X-Amz-Meta-${key}`);
+        return await this.client.presignedUrl('PUT', this.bucket, bucketKey, expiration, query, date);
     }
     async deleteObject(key) {
         const bucketKey = this.getBucketKey(key);
@@ -122,14 +195,15 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         return bucketKey.slice(this.prefix.length);
     }
 };
-S3ObjectStorage = __decorate([
+S3ObjectStorage = S3ObjectStorage_1 = __decorate([
     Singleton({
         provider: {
-            useFactory: (argument, context) => context.resolve(S3ObjectStorageProvider).get(assertStringPass(argument, 'resolve argument must be a string (object storage module)')),
-            async afterResolve(value) {
-                await value.ensureBucketExists();
-            }
-        }
+            useFactory: (argument, context) => {
+                const { module } = (isString(argument) ? { module: argument } : assertDefinedPass(argument, 'argument must be a string or an object'));
+                return context.resolve(S3ObjectStorageProvider).get(module);
+            },
+        },
+        argumentIdentityProvider: JSON.stringify,
     }),
     __metadata("design:paramtypes", [Function, String, String, String])
 ], S3ObjectStorage);

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

@@ -15,7 +15,6 @@ export class S3Object extends ObjectStorageObject {
     async getResourceUri() {
         return this.resourceUri;
     }
-    // eslint-disable-next-line @typescript-eslint/require-await
     async getContentLength() {
         if (isUndefined(this.contentLength)) {
             const stat = await this.stat();
@@ -28,7 +27,7 @@ export class S3Object extends ObjectStorageObject {
         return stat.metaData;
     }
     async getContent() {
-        return this.storage.getContent(this.key);
+        return await this.storage.getContent(this.key);
     }
     getContentStream() {
         return this.storage.getContentStream(this.key);
@@ -37,6 +36,6 @@ export class S3Object extends ObjectStorageObject {
         if (isUndefined(this.statPromise)) {
             this.statPromise = this.storage.statObject(this.key);
         }
-        return this.statPromise;
+        return await this.statPromise;
     }
 }