@tstdl/base 0.93.51 → 0.93.53

package/browser/utils.js

@@ -1,4 +1,4 @@
-import { objectKeys } from '../utils/object/object.js';
+import { objectEntries, objectKeys } from '../utils/object/object.js';
 import { timeout } from '../utils/timing.js';
 import { assert, isDefined, isNull, isString, isUndefined } from '../utils/type-guards.js';
 import { resolveValueOrProvider } from '../utils/value-or-provider.js';
@@ -49,7 +49,7 @@ export function attachLogger(loggable, logger) {
         const location = consoleMessage.location();
         const rawLocationText = (location.lineNumber == 0) ? location.url : `${location.url}:${location.lineNumber}:${location.columnNumber}`;
         const locationText = rawLocationText.length == 0 ? undefined : rawLocationText;
-        const additions = Object.entries({ location: locationText }).filter(([_, value]) => isDefined(value)).map(([key, value]) => `${key}: ${value}`).join(', ');
+        const additions = objectEntries({ location: locationText }).filter(([_, value]) => isDefined(value)).map(([key, value]) => `${key}: ${value}`).join(', ');
         const message = `${url}: ${consoleMessage.text()}${(additions.length > 0) ? ` (${additions})` : ''}`;
         switch (consoleMessage.type()) {
             case 'debug':

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

@@ -0,0 +1,44 @@
+import { ObjectStorageProvider } from '../../object-storage/index.js';
+import { GoogleObjectStorage } from './google.object-storage.js';
+export declare class GoogleObjectStorageProviderConfig {
+    /**
+     * Google Cloud Project ID
+     */
+    projectId?: string;
+    /**
+     * Path to the JSON key file.
+     * Mutually exclusive with credentials.
+     */
+    keyFilename?: string;
+    /**
+     * Object containing client_email and private_key.
+     * Mutually exclusive with keyFilename.
+     */
+    credentials?: {
+        client_email: string;
+        private_key: string;
+    };
+    /**
+     * Use a single bucket for all modules (which will become transparent key prefixes)
+     * mutually exclusive with bucketPerModule
+     */
+    bucket?: string;
+    /**
+     * Use an own bucket for every module
+     * mutually exclusive with bucket
+     */
+    bucketPerModule?: boolean;
+}
+export declare const bucketPerModule: unique symbol;
+export declare class GoogleObjectStorageProvider extends ObjectStorageProvider<GoogleObjectStorage> {
+    private readonly client;
+    private readonly bucket;
+    constructor(config: GoogleObjectStorageProviderConfig);
+    get(module: string): GoogleObjectStorage;
+}
+/**
+ * Configure google object storage provider
+ * @param config google storage config
+ * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
+ */
+export declare function configureGoogleObjectStorage(config: GoogleObjectStorageProviderConfig, register?: boolean): void;

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

@@ -0,0 +1,81 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Storage } from '@google-cloud/storage';
+import { Singleton } from '../../injector/decorators.js';
+import { Injector } from '../../injector/injector.js';
+import { ObjectStorage, ObjectStorageProvider } from '../../object-storage/index.js';
+import { assertDefinedPass, assertStringPass, isDefined } from '../../utils/type-guards.js';
+import { GoogleObjectStorage } from './google.object-storage.js';
+export class GoogleObjectStorageProviderConfig {
+    /**
+     * Google Cloud Project ID
+     */
+    projectId;
+    /**
+     * Path to the JSON key file.
+     * Mutually exclusive with credentials.
+     */
+    keyFilename;
+    /**
+     * Object containing client_email and private_key.
+     * Mutually exclusive with keyFilename.
+     */
+    credentials;
+    /**
+     * Use a single bucket for all modules (which will become transparent key prefixes)
+     * mutually exclusive with bucketPerModule
+     */
+    bucket;
+    /**
+     * Use an own bucket for every module
+     * mutually exclusive with bucket
+     */
+    bucketPerModule;
+}
+export const bucketPerModule = Symbol('bucket per module');
+let GoogleObjectStorageProvider = class GoogleObjectStorageProvider extends ObjectStorageProvider {
+    client;
+    bucket;
+    constructor(config) {
+        super();
+        if (isDefined(config.bucket) && (config.bucketPerModule == true)) {
+            throw new Error('bucket and bucketPerModule is mutually exclusive');
+        }
+        const storageOptions = {
+            projectId: config.projectId,
+            keyFilename: config.keyFilename,
+            credentials: config.credentials,
+        };
+        this.client = new Storage(storageOptions);
+        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 GoogleObjectStorage(this.client, bucket, module, prefix);
+    }
+};
+GoogleObjectStorageProvider = __decorate([
+    Singleton(),
+    __metadata("design:paramtypes", [GoogleObjectStorageProviderConfig])
+], GoogleObjectStorageProvider);
+export { GoogleObjectStorageProvider };
+/**
+ * Configure google object storage provider
+ * @param config google storage config
+ * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
+ */
+export function configureGoogleObjectStorage(config, register = true) {
+    Injector.register(GoogleObjectStorageProviderConfig, { useValue: config });
+    if (register) {
+        Injector.registerSingleton(ObjectStorageProvider, { useToken: GoogleObjectStorageProvider });
+        Injector.registerSingleton(ObjectStorage, { useToken: GoogleObjectStorage });
+    }
+}

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

@@ -0,0 +1,32 @@
+import { Storage, type Bucket, type File } from '@google-cloud/storage';
+import { ObjectStorage, type CopyObjectOptions, type MoveObjectOptions, type ObjectStorageConfiguration, type UploadObjectOptions, type UploadUrlOptions } from '../../object-storage/index.js';
+import { GoogleObject } from './google.object.js';
+export declare class GoogleObjectStorage extends ObjectStorage {
+    readonly client: Storage;
+    readonly bucket: Bucket;
+    readonly prefix: string;
+    constructor(client: Storage, bucket: string, module: string, keyPrefix: string);
+    ensureBucketExists(location?: string, options?: {
+        objectLocking?: boolean;
+    }): Promise<void>;
+    configureBucket(configuration: ObjectStorageConfiguration): Promise<void>;
+    getFile(key: string): File;
+    exists(key: string): Promise<boolean>;
+    uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<GoogleObject>;
+    copyObject(source: GoogleObject | string, destination: GoogleObject | string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<GoogleObject>;
+    moveObject(source: GoogleObject | string, destination: GoogleObject | string | [ObjectStorage, string], options?: MoveObjectOptions): Promise<GoogleObject>;
+    getContent(key: string): Promise<Uint8Array<ArrayBuffer>>;
+    getContentStream(key: string): ReadableStream<Uint8Array<ArrayBuffer>>;
+    getObjects(): Promise<GoogleObject[]>;
+    getObjectsCursor(): AsyncIterable<GoogleObject>;
+    getObject(key: string): Promise<GoogleObject>;
+    getResourceUri(key: string): Promise<string>;
+    getDownloadUrl(key: string, expirationTimestamp: number, responseHeaders?: Record<string, string>): Promise<string>;
+    getUploadUrl(key: string, expirationTimestamp: number, options?: UploadUrlOptions): Promise<string>;
+    deleteObject(key: string): Promise<void>;
+    deleteObjects(keys: string[]): Promise<void>;
+    private _getObject;
+    getBucketKey(key: string): string;
+    getResourceUriSync(key: string): string;
+    private getKey;
+}

package/object-storage/google/google.object-storage.js

@@ -0,0 +1,220 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var GoogleObjectStorage_1;
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { Storage } from '@google-cloud/storage';
+import { match, P } from 'ts-pattern';
+import { AsyncEnumerable } from '../../enumerable/async-enumerable.js';
+import { Singleton } from '../../injector/decorators.js';
+import { registerAfterResolve } from '../../injector/resolution.js';
+import { ObjectStorage } from '../../object-storage/index.js';
+import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
+import { mapObjectKeys, objectKeys } from '../../utils/object/object.js';
+import { _throw } from '../../utils/throw.js';
+import { assertDefinedPass, isDefined, isNotNull, isString, isUint8Array } from '../../utils/type-guards.js';
+import { secondsPerDay } from '../../utils/units.js';
+import { GoogleObjectStorageProvider } from './google.object-storage-provider.js';
+import { GoogleObject } from './google.object.js';
+let GoogleObjectStorage = GoogleObjectStorage_1 = class GoogleObjectStorage extends ObjectStorage {
+    client;
+    bucket;
+    prefix;
+    constructor(client, bucket, module, keyPrefix) {
+        super(module);
+        this.client = client;
+        this.bucket = client.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(location, options) {
+        const [exists] = await this.bucket.exists();
+        if (exists) {
+            return;
+        }
+        if (isDefined(options?.objectLocking) && options.objectLocking) {
+            throw new Error('Object locking not yet supported for GoogleObjectStorage.');
+        }
+        await this.client.createBucket(this.bucket.name, { location });
+    }
+    async configureBucket(configuration) {
+        const [metadata] = await this.bucket.getMetadata();
+        // Check for existing rules. GCS doesn't strictly use string IDs like AWS/Minio for rules,
+        // so we identify our "TstdlExpireObjects" rule by its specific condition and action.
+        const currentLifecycleRules = metadata.lifecycle?.rule ?? [];
+        const targetExpirationDays = configuration.lifecycle?.expiration?.after;
+        const targetExpiration = isDefined(targetExpirationDays) ? Math.ceil(targetExpirationDays / secondsPerDay) : undefined;
+        // Identify if our specific rule exists
+        const tstdlRuleIndex = currentLifecycleRules.findIndex((rule) => (rule.action.type == 'Delete') && isDefined(rule.condition.age) && (objectKeys(rule.condition).length == 1));
+        const tstdlRule = (tstdlRuleIndex >= 0) ? currentLifecycleRules[tstdlRuleIndex] : undefined;
+        const currentExpiration = tstdlRule?.condition.age;
+        if (currentExpiration == targetExpiration) {
+            return;
+        }
+        // Filter out the rule we manage (if it exists) to preserve others
+        const otherRules = currentLifecycleRules.filter((_, index) => index != tstdlRuleIndex);
+        const newRules = [
+            ...otherRules,
+            isDefined(targetExpiration) ? { action: { type: 'Delete' }, condition: { age: targetExpiration } } : null,
+        ].filter(isNotNull);
+        // Update the bucket lifecycle configuration
+        // null removes all rules
+        await this.bucket.setMetadata({ lifecycle: (newRules.length > 0) ? { rule: newRules } : null });
+    }
+    getFile(key) {
+        const bucketKey = this.getBucketKey(key);
+        return this.bucket.file(bucketKey);
+    }
+    async exists(key) {
+        const object = await this.getObject(key);
+        const [exists] = await object.file.exists();
+        return exists;
+    }
+    async uploadObject(key, content, options) {
+        const object = await this.getObject(key);
+        const saveOptions = { contentType: options?.contentType, metadata: { contentLength: options?.contentLength, ...options?.metadata } };
+        if (isUint8Array(content)) {
+            await object.file.save(content, saveOptions);
+        }
+        else {
+            const readable = Readable.fromWeb(content);
+            const writeStream = object.file.createWriteStream(saveOptions);
+            await pipeline(readable, writeStream);
+        }
+        return object;
+    }
+    async copyObject(source, destination, options) {
+        const sourceObject = await match(source)
+            .with(P.instanceOf(GoogleObject), (obj) => obj)
+            .with(P.string, async (key) => await this.getObject(key))
+            .exhaustive();
+        const destinationObject = await match(destination)
+            .with(P.instanceOf(GoogleObject), (obj) => obj)
+            .with(P.string, async (key) => await this.getObject(key))
+            .with([P.instanceOf(GoogleObjectStorage_1), P.string], async ([storage, key]) => await storage.getObject(key))
+            .otherwise(() => _throw(new Error('Destination must be a GoogleObject, string key, or [GoogleObjectStorage, string] tuple.')));
+        const metadata = await match(options?.metadata)
+            .with(P.nullish, () => undefined)
+            .with(P.any, async (newMetadata) => {
+            const sourceMetadata = await sourceObject.getMetadata();
+            return { ...sourceMetadata, ...newMetadata };
+        })
+            .exhaustive();
+        await sourceObject.file.copy(destinationObject.file, { metadata });
+        return destinationObject;
+    }
+    async moveObject(source, destination, options) {
+        const sourceObject = await match(source)
+            .with(P.instanceOf(GoogleObject), (obj) => obj)
+            .with(P.string, async (key) => await this.getObject(key))
+            .exhaustive();
+        const destinationObject = await match(destination)
+            .with(P.instanceOf(GoogleObject), (obj) => obj)
+            .with(P.string, async (key) => await this.getObject(key))
+            .with([P.instanceOf(GoogleObjectStorage_1), P.string], async ([storage, key]) => await storage.getObject(key))
+            .otherwise(() => _throw(new Error('Destination must be a GoogleObject, string key, or [GoogleObjectStorage, string] tuple.')));
+        if (isDefined(options?.metadata)) {
+            throw new Error('Metadata update on move is not supported in GoogleObjectStorage.');
+        }
+        if (sourceObject.file.bucket.name == destinationObject.file.bucket.name) {
+            await sourceObject.file.moveFileAtomic(destinationObject.file);
+        }
+        else {
+            await sourceObject.file.move(destinationObject.file);
+        }
+        return destinationObject;
+    }
+    async getContent(key) {
+        const object = this._getObject(key);
+        return await object.getContent();
+    }
+    getContentStream(key) {
+        const object = this._getObject(key);
+        return object.getContentStream();
+    }
+    async getObjects() {
+        return await toArrayAsync(this.getObjectsCursor());
+    }
+    async *getObjectsCursor() {
+        const nodeStream = this.bucket.getFilesStream({ prefix: this.prefix, autoPaginate: true });
+        const stream = Readable.toWeb(nodeStream);
+        for await (const file of stream) {
+            yield new GoogleObject(this.module, this.getKey(file.name), this, file);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getObject(key) {
+        return this._getObject(key);
+    }
+    async getResourceUri(key) {
+        return this.getResourceUriSync(key);
+    }
+    async getDownloadUrl(key, expirationTimestamp, responseHeaders) {
+        const object = await this.getObject(key);
+        const [url] = await object.file.getSignedUrl({
+            action: 'read',
+            expires: new Date(expirationTimestamp),
+            extensionHeaders: responseHeaders,
+        });
+        return url;
+    }
+    async getUploadUrl(key, expirationTimestamp, options) {
+        const bucketKey = this.getBucketKey(key);
+        const [url] = await this.bucket.file(bucketKey).getSignedUrl({
+            action: 'write',
+            expires: new Date(expirationTimestamp),
+            contentType: options?.contentType,
+            extensionHeaders: options?.metadata ? convertMetadataToHeaders(options.metadata) : undefined,
+        });
+        return url;
+    }
+    async deleteObject(key) {
+        const bucketKey = this.getBucketKey(key);
+        await this.bucket.file(bucketKey).delete({ ignoreNotFound: true });
+    }
+    async deleteObjects(keys) {
+        await AsyncEnumerable.from(keys)
+            .parallelForEach(25, async (key) => await this.deleteObject(key));
+    }
+    _getObject(key) {
+        const resourceUri = this.getResourceUriSync(key);
+        return new GoogleObject(this.module, key, this, resourceUri);
+    }
+    getBucketKey(key) {
+        return `${this.prefix}${key}`;
+    }
+    getResourceUriSync(key) {
+        const bucketKey = this.getBucketKey(key);
+        return `gs://${this.bucket.name}/${bucketKey}`;
+    }
+    getKey(bucketKey) {
+        return bucketKey.slice(this.prefix.length);
+    }
+};
+GoogleObjectStorage = GoogleObjectStorage_1 = __decorate([
+    Singleton({
+        provider: {
+            useFactory: (argument, context) => {
+                const { module } = (isString(argument) ? { module: argument } : assertDefinedPass(argument, 'argument must be a string or an object'));
+                return context.resolve(GoogleObjectStorageProvider).get(module);
+            },
+        },
+        argumentIdentityProvider: JSON.stringify,
+    }),
+    __metadata("design:paramtypes", [Storage, String, String, String])
+], GoogleObjectStorage);
+export { GoogleObjectStorage };
+function convertMetadataToHeaders(metadata) {
+    return mapObjectKeys(metadata, (key) => `x-goog-meta-${key}`);
+}

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

@@ -0,0 +1,16 @@
+import type { File } from '@google-cloud/storage';
+import { ObjectStorageObject, type ObjectMetadata } from '../../object-storage/object.js';
+import type { GoogleObjectStorage } from './google.object-storage.js';
+export declare class GoogleObject extends ObjectStorageObject {
+    #private;
+    get file(): File;
+    constructor(module: string, key: string, objectStorage: GoogleObjectStorage, fileOrResourceUri: File | string);
+    getResourceUri(): Promise<string>;
+    getContentLength(): Promise<number>;
+    getMetadata(): Promise<ObjectMetadata>;
+    getContent(): Promise<Uint8Array<ArrayBuffer>>;
+    getContentStream(): ReadableStream<Uint8Array<ArrayBuffer>>;
+    private getFileMetadata;
+    private _getFileMetadata;
+    private _getContentLength;
+}

package/object-storage/google/google.object.js

@@ -0,0 +1,69 @@
+import { Readable } from 'node:stream';
+import { ObjectStorageObject } from '../../object-storage/object.js';
+import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+export class GoogleObject extends ObjectStorageObject {
+    #objectStorage;
+    #file;
+    #contentLength;
+    #fileMetadata;
+    #resourceUri;
+    get file() {
+        if (isUndefined(this.#file)) {
+            this.#file = this.#objectStorage.getFile(this.key);
+        }
+        return this.#file;
+    }
+    constructor(module, key, objectStorage, fileOrResourceUri) {
+        super(module, key);
+        this.#objectStorage = objectStorage;
+        if (isString(fileOrResourceUri)) {
+            this.#resourceUri = fileOrResourceUri;
+        }
+        else {
+            this.#file = fileOrResourceUri;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getResourceUri() {
+        if (isUndefined(this.#resourceUri)) {
+            this.#resourceUri = this.#file?.cloudStorageURI.href ?? this.#objectStorage.getResourceUriSync(this.key);
+        }
+        return this.#resourceUri;
+    }
+    async getContentLength() {
+        if (isDefined(this.#contentLength)) {
+            return await this.#contentLength;
+        }
+        this.#contentLength = this._getContentLength(); // without await to avoid double fetching in case of concurrent calls
+        this.#contentLength = await this.#contentLength;
+        return this.#contentLength;
+    }
+    async getMetadata() {
+        const fileMetadata = await this.getFileMetadata();
+        return fileMetadata.metadata ?? {};
+    }
+    async getContent() {
+        const [buffer] = await this.file.download();
+        return buffer;
+    }
+    getContentStream() {
+        const stream = this.file.createReadStream();
+        return Readable.toWeb(stream);
+    }
+    async getFileMetadata() {
+        if (isDefined(this.#fileMetadata)) {
+            return await this.#fileMetadata;
+        }
+        this.#fileMetadata = this._getFileMetadata(); // without await to avoid double fetching in case of concurrent calls
+        this.#fileMetadata = await this.#fileMetadata;
+        return this.#fileMetadata;
+    }
+    async _getFileMetadata() {
+        const [metadata] = await this.file.getMetadata();
+        return metadata;
+    }
+    async _getContentLength() {
+        const fileMetadata = await this.getFileMetadata();
+        return Number(fileMetadata.size);
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './google.object.js';
+export * from './google.object-storage.js';
+export * from './google.object-storage-provider.js';

package/object-storage/google/index.js

@@ -0,0 +1,3 @@
+export * from './google.object.js';
+export * from './google.object-storage.js';
+export * from './google.object-storage-provider.js';

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

@@ -43,22 +43,25 @@ export declare abstract class ObjectStorage implements Resolvable<ObjectStorageA
      * @param key object key
      * @param content content of object
      * @param options options
+     * @return uploaded object
      */
-    abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
+    abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<ObjectStorageObject>;
     /**
      * Copies an object
      * @param sourceKey source object key
-     * @param destinationKey destination object key or destination storage and key
+     * @param destination destination object, key or destination storage and key
      * @param options options
+     * @return copied object
      */
-    abstract copyObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<void>;
+    abstract copyObject(sourceKey: ObjectStorageObject | string, destination: ObjectStorageObject | string | [ObjectStorage, string], options?: CopyObjectOptions): Promise<ObjectStorageObject>;
     /**
      * Moves an object
      * @param sourceKey source object key
      * @param destinationKey destination object key or destination storage and key
      * @param options options
+     * @return moved object
      */
-    abstract moveObject(sourceKey: string, destinationKey: string | [ObjectStorage, string], options?: MoveObjectOptions): Promise<void>;
+    abstract moveObject(sourceKey: ObjectStorageObject | string, destinationKey: ObjectStorageObject | string | [ObjectStorage, string], options?: MoveObjectOptions): Promise<ObjectStorageObject>;
     /**
      * Get an url which can be used to upload the object without further authorization
      * @param key object key

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

@@ -7,11 +7,11 @@ 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 { Injector } from '../../injector/injector.js';
 import { ObjectStorage, ObjectStorageProvider } from '../../object-storage/index.js';
 import { assertDefinedPass, assertStringPass, isDefined } from '../../utils/type-guards.js';
-import { Client } from 'minio';
 import { S3ObjectStorage } from './s3.object-storage.js';
 export class S3ObjectStorageProviderConfig {
     /**

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

@@ -12,9 +12,9 @@ export declare class S3ObjectStorage extends ObjectStorage {
     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>;
+    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>;
     getContent(key: string): Promise<Uint8Array<ArrayBuffer>>;
     getContentStream(key: string): ReadableStream<Uint8Array<ArrayBuffer>>;
     getObjects(): Promise<S3Object[]>;

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

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var S3ObjectStorage_1;
 import { Readable } from 'node:stream';
 import { CopyDestinationOptions, CopySourceOptions } from 'minio';
+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';
@@ -20,7 +21,8 @@ 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 { assertDefinedPass, assertInstanceOfPass, isDefined, isObject, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
+import { _throw } from '../../utils/throw.js';
+import { assertDefinedPass, 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';
@@ -119,24 +121,32 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
                 errorPromise,
             ]);
         }
+        return await this.getObject(key);
     }
     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 sourceObject = await match(source)
+            .with(P.instanceOf(S3Object), (obj) => obj)
+            .with(P.string, async (key) => await this.getObject(key))
+            .exhaustive();
+        const destinationObject = await match(destination)
+            .with(P.instanceOf(S3Object), (obj) => obj)
+            .with(P.string, async (key) => await this.getObject(key))
+            .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: sourceBucketKey }), new CopyDestinationOptions({
-            Bucket: destinationBucket,
-            Object: destinationBucketKey,
+        await this.client.copyObject(new CopySourceOptions({ Bucket: this.bucket, Object: sourceObject.storage.getBucketKey(sourceObject.key) }), new CopyDestinationOptions({
+            Bucket: destinationObject.storage.bucket,
+            Object: destinationObject.storage.getBucketKey(destinationObject.key),
             MetadataDirective: 'REPLACE',
             UserMetadata: { ...sourceMetadata, ...options?.metadata },
         }));
+        return destinationObject;
     }
-    async moveObject(sourceKey, destinationKey, options) {
-        await this.copyObject(sourceKey, destinationKey, options);
+    async moveObject(source, destination, options) {
+        const object = await this.copyObject(source, destination, options);
+        const sourceKey = isString(source) ? source : source.key;
         await this.deleteObject(sourceKey);
+        return object;
     }
     async getContent(key) {
         const bucketKey = this.getBucketKey(key);

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

@@ -2,10 +2,10 @@ import type { ObjectMetadata } from '../../object-storage/object.js';
 import { ObjectStorageObject } from '../../object-storage/object.js';
 import type { S3ObjectStorage } from './s3.object-storage.js';
 export declare class S3Object extends ObjectStorageObject {
-    private readonly storage;
     private readonly resourceUri;
     private contentLength;
     private statPromise;
+    readonly storage: S3ObjectStorage;
     constructor(module: string, key: string, resourceUri: string, contentLength: number | undefined, storage: S3ObjectStorage);
     getResourceUri(): Promise<string>;
     getContentLength(): Promise<number>;

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

@@ -1,10 +1,10 @@
 import { ObjectStorageObject } from '../../object-storage/object.js';
 import { isUndefined } from '../../utils/type-guards.js';
 export class S3Object extends ObjectStorageObject {
-    storage;
     resourceUri;
     contentLength;
     statPromise;
+    storage;
     constructor(module, key, resourceUri, contentLength, storage) {
         super(module, key);
         this.resourceUri = resourceUri;