@nestm/storage 0.1.0-alpha.0

package/dist/storage-module.options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-module.options.d.ts","sourceRoot":"","sources":["../src/storage-module.options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,cAAc,EACd,IAAI,EACL,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACnC,uFAAuF;IACvF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC1C,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACnC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC3E;AAED,UAAU,uBAAuB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,6BAA8B,SAAQ,uBAAuB;IAC5E,MAAM,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IACnC,UAAU,EAAE,CACV,GAAG,YAAY,EAAE,KAAK,EAAE,KACrB,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAC5C,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,WAAW,CAAC,EAAE,KAAK,CAAC;CACrB;AAED,MAAM,WAAW,2BAA4B,SAAQ,uBAAuB;IAC1E,QAAQ,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,WAAW,CAAC,EAAE,KAAK,CAAC;CACrB;AAED,MAAM,WAAW,8BAA+B,SAAQ,uBAAuB;IAC7E,WAAW,EAAE,cAAc,CAAC,oBAAoB,CAAC,CAAC;IAClD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,UAAU,CAAC,EAAE,KAAK,CAAC;CACpB;AAED,MAAM,MAAM,2BAA2B,GACnC,6BAA6B,GAC7B,2BAA2B,GAC3B,8BAA8B,CAAC;AAEnC,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IACpC,uFAAuF;IACvF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC/C,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;CACrC"}

package/dist/storage-module.options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=storage-module.options.js.map

package/dist/storage-module.options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-module.options.js","sourceRoot":"","sources":["../src/storage-module.options.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  FactoryProvider,\n  InjectionToken,\n  ModuleMetadata,\n  Type,\n} from '@nestjs/common';\n\nimport type { StorageDriver } from './storage.driver.js';\nimport type { StoragePlugin } from './storage.types.js';\n\nexport interface StorageStoreDefinition {\n  name?: string;\n  driver: StorageDriver;\n  plugins?: readonly StoragePlugin[];\n}\n\nexport interface StorageModuleOptions {\n  stores: readonly StorageStoreDefinition[];\n  default?: string;\n  plugins?: readonly StoragePlugin[];\n  /** Makes the configured clients and manager globally injectable. Defaults to false. */\n  isGlobal?: boolean;\n}\n\nexport interface StorageFeatureOptions {\n  stores: readonly StorageStoreDefinition[];\n  plugins?: readonly StoragePlugin[];\n  imports?: ModuleMetadata['imports'];\n}\n\nexport interface StorageDriverFactory {\n  createStorageDriver(name: string): StorageDriver | Promise<StorageDriver>;\n}\n\ninterface StorageAsyncStoreCommon {\n  name?: string;\n  imports?: ModuleMetadata['imports'];\n  plugins?: readonly StoragePlugin[];\n}\n\nexport interface StorageFactoryStoreDefinition extends StorageAsyncStoreCommon {\n  inject?: FactoryProvider['inject'];\n  useFactory: (\n    ...dependencies: never[]\n  ) => StorageDriver | Promise<StorageDriver>;\n  useClass?: never;\n  useExisting?: never;\n}\n\nexport interface StorageClassStoreDefinition extends StorageAsyncStoreCommon {\n  useClass: Type<StorageDriverFactory>;\n  inject?: never;\n  useFactory?: never;\n  useExisting?: never;\n}\n\nexport interface StorageExistingStoreDefinition extends StorageAsyncStoreCommon {\n  useExisting: InjectionToken<StorageDriverFactory>;\n  inject?: never;\n  useClass?: never;\n  useFactory?: never;\n}\n\nexport type StorageAsyncStoreDefinition =\n  | StorageFactoryStoreDefinition\n  | StorageClassStoreDefinition\n  | StorageExistingStoreDefinition;\n\nexport interface StorageModuleAsyncOptions {\n  stores: readonly StorageAsyncStoreDefinition[];\n  default?: string;\n  plugins?: readonly StoragePlugin[];\n  imports?: ModuleMetadata['imports'];\n  /** Makes the configured clients and manager globally injectable. Defaults to false. */\n  isGlobal?: boolean;\n}\n\nexport interface StorageFeatureAsyncOptions {\n  stores: readonly StorageAsyncStoreDefinition[];\n  plugins?: readonly StoragePlugin[];\n  imports?: ModuleMetadata['imports'];\n}\n"]}

package/dist/storage-upload-control.d.ts

@@ -0,0 +1,22 @@
+export type StorageUploadStatus = 'idle' | 'uploading' | 'paused' | 'completed' | 'aborted' | 'error';
+/**
+ * Opaque, JSON-serializable resume token. Its payload is deliberately unknown:
+ * provider session fields are an implementation detail of the pinned engine.
+ */
+export interface StorageResumableToken {
+    readonly version: 1;
+    readonly format: '@nestm/storage/resumable';
+    readonly session: unknown;
+}
+export declare class StorageUploadControl {
+    constructor();
+    static from(token: unknown): StorageUploadControl;
+    get status(): StorageUploadStatus;
+    get loaded(): number;
+    get total(): number | undefined;
+    pause(): void;
+    resume(): void;
+    abort(reason?: unknown): Promise<void>;
+    toJSON(): StorageResumableToken | undefined;
+}
+//# sourceMappingURL=storage-upload-control.d.ts.map

package/dist/storage-upload-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-upload-control.d.ts","sourceRoot":"","sources":["../src/storage-upload-control.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,mBAAmB,GAC7B,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEtE;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,0BAA0B,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAkHD,qBAAa,oBAAoB;;IAK/B,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB;IAmBjD,IAAI,MAAM,IAAI,mBAAmB,CAEhC;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,KAAK,IAAI,IAAI;IAIb,MAAM,IAAI,IAAI;IAId,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,MAAM,IAAI,qBAAqB,GAAG,SAAS;CAY5C"}

package/dist/storage-upload-control.js

@@ -0,0 +1,139 @@
+import { UploadControl } from 'files-sdk';
+import { StorageError, StorageErrorCode } from './storage.error.js';
+const controls = new WeakMap();
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function positiveNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+function nonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function recordOf(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function validParts(value) {
+    return (Array.isArray(value) &&
+        value.every((part) => {
+            const record = recordOf(part);
+            return (record !== undefined &&
+                positiveNumber(record.partNumber) &&
+                nonNegativeNumber(record.size) &&
+                (record.etag === undefined || nonEmptyString(record.etag)));
+        }));
+}
+function validResumableSession(value) {
+    const session = recordOf(value);
+    if (session === undefined || !nonEmptyString(session.provider)) {
+        return false;
+    }
+    const strings = (...fields) => fields.every((field) => nonEmptyString(session[field]));
+    switch (session.provider) {
+        case 's3':
+            return (strings('bucket', 'key', 'uploadId') && positiveNumber(session.partSize));
+        case 'gcs':
+            return strings('bucket', 'key', 'uri');
+        case 'google-drive':
+            return strings('key', 'uri');
+        case 'azure':
+            return (strings('container', 'blob', 'contentType') &&
+                positiveNumber(session.blockSize));
+        case 'onedrive':
+            return strings('itemPath', 'uploadUrl');
+        case 'dropbox':
+            return (strings('path', 'sessionId', 'contentType') &&
+                nonNegativeNumber(session.offset));
+        case 'vercel-blob':
+            return (strings('key', 'storageKey', 'uploadId', 'contentType') &&
+                positiveNumber(session.partSize) &&
+                validParts(session.parts));
+        case 'fs':
+            return strings('key', 'tempPath', 'contentType');
+        case 'memory':
+            return strings('key', 'uploadId', 'contentType');
+        case 'ftp':
+        case 'sftp':
+            return strings('key');
+        case 'bun-s3':
+            return strings('key', 'uploadId', 'contentType');
+        case 'supabase':
+            return strings('key', 'uri', 'contentType');
+        case 'appwrite':
+            return (strings('key', 'fileId', 'contentType') &&
+                nonNegativeNumber(session.offset));
+        case 'cloudinary':
+            return (strings('key', 'uploadId', 'contentType') &&
+                nonNegativeNumber(session.offset));
+        case 'box':
+            return strings('key', 'uploadId', 'contentType');
+        default:
+            return false;
+    }
+}
+function controlOf(control) {
+    const delegate = controls.get(control);
+    if (delegate === undefined) {
+        throw new StorageError('Invalid storage upload control.', {
+            code: StorageErrorCode.INVALID_ARGUMENT,
+            permanent: true,
+        });
+    }
+    return delegate;
+}
+export class StorageUploadControl {
+    constructor() {
+        controls.set(this, new UploadControl());
+    }
+    static from(token) {
+        const value = recordOf(token);
+        if (value === undefined ||
+            value.version !== 1 ||
+            value.format !== '@nestm/storage/resumable' ||
+            !validResumableSession(value.session)) {
+            throw new StorageError('Invalid storage resumable-upload token.', {
+                code: StorageErrorCode.INVALID_ARGUMENT,
+                permanent: true,
+            });
+        }
+        const wrapper = new StorageUploadControl();
+        controls.set(wrapper, UploadControl.from(value.session));
+        return wrapper;
+    }
+    get status() {
+        return controlOf(this).status;
+    }
+    get loaded() {
+        return controlOf(this).loaded;
+    }
+    get total() {
+        return controlOf(this).total;
+    }
+    pause() {
+        controlOf(this).pause();
+    }
+    resume() {
+        controlOf(this).resume();
+    }
+    abort(reason) {
+        return controlOf(this).abort(reason);
+    }
+    toJSON() {
+        const session = controlOf(this).toJSON();
+        if (session === undefined) {
+            return undefined;
+        }
+        return {
+            format: '@nestm/storage/resumable',
+            session,
+            version: 1,
+        };
+    }
+}
+/** @internal */
+export function getFilesSdkUploadControl(control) {
+    return controlOf(control);
+}
+//# sourceMappingURL=storage-upload-control.js.map

package/dist/storage-upload-control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-upload-control.js","sourceRoot":"","sources":["../src/storage-upload-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { UploadControl, type ResumableUploadSession } from 'files-sdk';\n\nimport { StorageError, StorageErrorCode } from './storage.error.js';\n\nexport type StorageUploadStatus =\n  'idle' | 'uploading' | 'paused' | 'completed' | 'aborted' | 'error';\n\n/**\n * Opaque, JSON-serializable resume token. Its payload is deliberately unknown:\n * provider session fields are an implementation detail of the pinned engine.\n */\nexport interface StorageResumableToken {\n  readonly version: 1;\n  readonly format: '@nestm/storage/resumable';\n  readonly session: unknown;\n}\n\nconst controls = new WeakMap<StorageUploadControl, UploadControl>();\n\nfunction nonEmptyString(value: unknown): value is string {\n  return typeof value === 'string' && value.length > 0;\n}\n\nfunction positiveNumber(value: unknown): value is number {\n  return typeof value === 'number' && Number.isFinite(value) && value > 0;\n}\n\nfunction nonNegativeNumber(value: unknown): value is number {\n  return typeof value === 'number' && Number.isFinite(value) && value >= 0;\n}\n\nfunction recordOf(value: unknown): Record<string, unknown> | undefined {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined;\n}\n\nfunction validParts(value: unknown): boolean {\n  return (\n    Array.isArray(value) &&\n    value.every((part) => {\n      const record = recordOf(part);\n      return (\n        record !== undefined &&\n        positiveNumber(record.partNumber) &&\n        nonNegativeNumber(record.size) &&\n        (record.etag === undefined || nonEmptyString(record.etag))\n      );\n    })\n  );\n}\n\nfunction validResumableSession(\n  value: unknown,\n): value is ResumableUploadSession {\n  const session = recordOf(value);\n  if (session === undefined || !nonEmptyString(session.provider)) {\n    return false;\n  }\n\n  const strings = (...fields: string[]): boolean =>\n    fields.every((field) => nonEmptyString(session[field]));\n\n  switch (session.provider) {\n    case 's3':\n      return (\n        strings('bucket', 'key', 'uploadId') && positiveNumber(session.partSize)\n      );\n    case 'gcs':\n      return strings('bucket', 'key', 'uri');\n    case 'google-drive':\n      return strings('key', 'uri');\n    case 'azure':\n      return (\n        strings('container', 'blob', 'contentType') &&\n        positiveNumber(session.blockSize)\n      );\n    case 'onedrive':\n      return strings('itemPath', 'uploadUrl');\n    case 'dropbox':\n      return (\n        strings('path', 'sessionId', 'contentType') &&\n        nonNegativeNumber(session.offset)\n      );\n    case 'vercel-blob':\n      return (\n        strings('key', 'storageKey', 'uploadId', 'contentType') &&\n        positiveNumber(session.partSize) &&\n        validParts(session.parts)\n      );\n    case 'fs':\n      return strings('key', 'tempPath', 'contentType');\n    case 'memory':\n      return strings('key', 'uploadId', 'contentType');\n    case 'ftp':\n    case 'sftp':\n      return strings('key');\n    case 'bun-s3':\n      return strings('key', 'uploadId', 'contentType');\n    case 'supabase':\n      return strings('key', 'uri', 'contentType');\n    case 'appwrite':\n      return (\n        strings('key', 'fileId', 'contentType') &&\n        nonNegativeNumber(session.offset)\n      );\n    case 'cloudinary':\n      return (\n        strings('key', 'uploadId', 'contentType') &&\n        nonNegativeNumber(session.offset)\n      );\n    case 'box':\n      return strings('key', 'uploadId', 'contentType');\n    default:\n      return false;\n  }\n}\n\nfunction controlOf(control: StorageUploadControl): UploadControl {\n  const delegate = controls.get(control);\n  if (delegate === undefined) {\n    throw new StorageError('Invalid storage upload control.', {\n      code: StorageErrorCode.INVALID_ARGUMENT,\n      permanent: true,\n    });\n  }\n  return delegate;\n}\n\nexport class StorageUploadControl {\n  constructor() {\n    controls.set(this, new UploadControl());\n  }\n\n  static from(token: unknown): StorageUploadControl {\n    const value = recordOf(token);\n    if (\n      value === undefined ||\n      value.version !== 1 ||\n      value.format !== '@nestm/storage/resumable' ||\n      !validResumableSession(value.session)\n    ) {\n      throw new StorageError('Invalid storage resumable-upload token.', {\n        code: StorageErrorCode.INVALID_ARGUMENT,\n        permanent: true,\n      });\n    }\n\n    const wrapper = new StorageUploadControl();\n    controls.set(wrapper, UploadControl.from(value.session));\n    return wrapper;\n  }\n\n  get status(): StorageUploadStatus {\n    return controlOf(this).status;\n  }\n\n  get loaded(): number {\n    return controlOf(this).loaded;\n  }\n\n  get total(): number | undefined {\n    return controlOf(this).total;\n  }\n\n  pause(): void {\n    controlOf(this).pause();\n  }\n\n  resume(): void {\n    controlOf(this).resume();\n  }\n\n  abort(reason?: unknown): Promise<void> {\n    return controlOf(this).abort(reason);\n  }\n\n  toJSON(): StorageResumableToken | undefined {\n    const session = controlOf(this).toJSON();\n    if (session === undefined) {\n      return undefined;\n    }\n\n    return {\n      format: '@nestm/storage/resumable',\n      session,\n      version: 1,\n    };\n  }\n}\n\n/** @internal */\nexport function getFilesSdkUploadControl(\n  control: StorageUploadControl,\n): UploadControl {\n  return controlOf(control);\n}\n"]}

package/dist/storage.client.d.ts

@@ -0,0 +1,51 @@
+import type { OnApplicationShutdown } from '@nestjs/common';
+import type { StorageDriver } from './storage.driver.js';
+import type { StorageBody, StorageBufferedDownloadOptions, StorageBulkOptions, StorageCapabilities, StorageDeleteManyResult, StorageDownloadManyResult, StorageDownloadOptions, StorageExistsManyResult, StorageHeadManyResult, StorageListOptions, StorageListResult, StorageObject, StorageObjectMetadata, StorageOperationOptions, StoragePlugin, StorageSearchOptions, StorageSignedDownloadOptions, StorageSignedUpload, StorageSignedUploadOptions, StorageUploadManyItem, StorageUploadManyOptions, StorageUploadManyResult, StorageUploadOptions, StorageUploadResult } from './storage.types.js';
+export declare const DEFAULT_BUFFER_LIMIT: number;
+type BulkOperationOptions = StorageBulkOptions & StorageOperationOptions;
+type DownloadManyOptions = StorageBulkOptions & StorageDownloadOptions;
+export interface StorageFileHandle {
+    readonly key: string;
+    upload(body: StorageBody, options?: StorageUploadOptions): Promise<StorageUploadResult>;
+    download(options?: StorageDownloadOptions): Promise<StorageObject>;
+    bytes(options?: StorageBufferedDownloadOptions): Promise<Uint8Array>;
+    text(options?: StorageBufferedDownloadOptions): Promise<string>;
+    head(options?: StorageOperationOptions): Promise<StorageObjectMetadata>;
+    exists(options?: StorageOperationOptions): Promise<boolean>;
+    delete(options?: StorageOperationOptions): Promise<void>;
+    signDownload(options?: StorageSignedDownloadOptions): Promise<string>;
+    signUpload(options: StorageSignedUploadOptions): Promise<StorageSignedUpload>;
+    copyTo(destinationKey: string, options?: StorageOperationOptions): Promise<void>;
+    moveTo(destinationKey: string, options?: StorageOperationOptions): Promise<void>;
+}
+export declare class StorageClient implements OnApplicationShutdown {
+    #private;
+    readonly name: string;
+    constructor(name: string, driver: StorageDriver, plugins?: readonly StoragePlugin[]);
+    get driverName(): string;
+    get capabilities(): Readonly<StorageCapabilities>;
+    file(key: string): StorageFileHandle;
+    upload(key: string, body: StorageBody, options?: StorageUploadOptions): Promise<StorageUploadResult>;
+    downloadStream(key: string, options?: StorageDownloadOptions): Promise<StorageObject>;
+    downloadBytes(key: string, options?: StorageBufferedDownloadOptions): Promise<Uint8Array>;
+    downloadText(key: string, options?: StorageBufferedDownloadOptions): Promise<string>;
+    downloadJson<Result = unknown>(key: string, options?: StorageBufferedDownloadOptions): Promise<Result>;
+    head(key: string, options?: StorageOperationOptions): Promise<StorageObjectMetadata>;
+    exists(key: string, options?: StorageOperationOptions): Promise<boolean>;
+    delete(key: string, options?: StorageOperationOptions): Promise<void>;
+    copy(sourceKey: string, destinationKey: string, options?: StorageOperationOptions): Promise<void>;
+    move(sourceKey: string, destinationKey: string, options?: StorageOperationOptions): Promise<void>;
+    list(options?: StorageListOptions): Promise<StorageListResult>;
+    listAll(options?: StorageListOptions): AsyncGenerator<StorageObjectMetadata, void>;
+    search(pattern: string | RegExp, options?: StorageSearchOptions): AsyncIterable<StorageObjectMetadata>;
+    signDownload(key: string, options?: StorageSignedDownloadOptions): Promise<string>;
+    signUpload(key: string, options: StorageSignedUploadOptions): Promise<StorageSignedUpload>;
+    uploadMany(items: readonly StorageUploadManyItem[], options?: StorageUploadManyOptions): Promise<StorageUploadManyResult>;
+    downloadMany(keys: readonly string[], options?: DownloadManyOptions): Promise<StorageDownloadManyResult>;
+    headMany(keys: readonly string[], options?: BulkOperationOptions): Promise<StorageHeadManyResult>;
+    existsMany(keys: readonly string[], options?: BulkOperationOptions): Promise<StorageExistsManyResult>;
+    deleteMany(keys: readonly string[], options?: BulkOperationOptions): Promise<StorageDeleteManyResult>;
+    onApplicationShutdown(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=storage.client.d.ts.map

package/dist/storage.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.client.d.ts","sourceRoot":"","sources":["../src/storage.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAQ5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,WAAW,EACX,8BAA8B,EAC9B,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EAErB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,4BAA4B,EAC5B,mBAAmB,EACnB,0BAA0B,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,oBAAoB,QAAmB,CAAC;AAErD,KAAK,oBAAoB,GAAG,kBAAkB,GAAG,uBAAuB,CAAC;AACzE,KAAK,mBAAmB,GAAG,kBAAkB,GAAG,sBAAsB,CAAC;AAqKvE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,MAAM,CACJ,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACnE,KAAK,CAAC,OAAO,CAAC,EAAE,8BAA8B,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACrE,IAAI,CAAC,OAAO,CAAC,EAAE,8BAA8B,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChE,IAAI,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACxE,MAAM,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,MAAM,CAAC,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,YAAY,CAAC,OAAO,CAAC,EAAE,4BAA4B,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACtE,UAAU,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC9E,MAAM,CACJ,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,CACJ,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAED,qBAAa,aAAc,YAAW,qBAAqB;;IAMvD,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM,EACrB,MAAM,EAAE,aAAa,EACrB,OAAO,GAAE,SAAS,aAAa,EAAO;IAOxC,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,IAAI,YAAY,IAAI,QAAQ,CAAC,mBAAmB,CAAC,CAEhD;IAED,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB;IAoBpC,MAAM,CACJ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,mBAAmB,CAAC;IAO/B,cAAc,CACZ,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,aAAa,CAAC;IAQnB,aAAa,CACjB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC,UAAU,CAAC;IAMhB,YAAY,CAChB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC,MAAM,CAAC;IAIZ,YAAY,CAAC,MAAM,GAAG,OAAO,EACjC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC,MAAM,CAAC;IAgBlB,IAAI,CACF,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,qBAAqB,CAAC;IAOjC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAOxE,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAOrE,IAAI,CACF,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,IAAI,CAAC;IAchB,IAAI,CACF,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,IAAI,CAAC;IAchB,IAAI,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAOvD,OAAO,CACZ,OAAO,CAAC,EAAE,kBAAkB,GAC3B,cAAc,CAAC,qBAAqB,EAAE,IAAI,CAAC;IA8B9C,MAAM,CACJ,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,qBAAqB,CAAC;IAuCvC,YAAY,CACV,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,4BAA4B,GACrC,OAAO,CAAC,MAAM,CAAC;IAQlB,UAAU,CACR,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,mBAAmB,CAAC;IASzB,UAAU,CACd,KAAK,EAAE,SAAS,qBAAqB,EAAE,EACvC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,uBAAuB,CAAC;IA+B7B,YAAY,CAChB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,yBAAyB,CAAC;IAa/B,QAAQ,CACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,qBAAqB,CAAC;IAa3B,UAAU,CACd,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,uBAAuB,CAAC;IAmB7B,UAAU,CACd,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,uBAAuB,CAAC;IAgB7B,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAqC7C"}

package/dist/storage.client.js

@@ -0,0 +1,395 @@
+import { settleMany } from './internal/settle-many.js';
+import { StorageError, StorageErrorCode, normalizeStorageError, } from './storage.error.js';
+export const DEFAULT_BUFFER_LIMIT = 10 * 1024 * 1024;
+function assertKey(key, label = 'key') {
+    if (typeof key !== 'string' || key.length === 0) {
+        throw new StorageError(`${label} must be a non-empty string.`, {
+            code: StorageErrorCode.INVALID_ARGUMENT,
+            permanent: true,
+        });
+    }
+}
+function invalidArgument(message) {
+    throw new StorageError(message, {
+        code: StorageErrorCode.INVALID_ARGUMENT,
+        permanent: true,
+    });
+}
+function assertPositiveSafeInteger(value, label) {
+    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
+        invalidArgument(`${label} must be a positive safe integer.`);
+    }
+}
+function assertDownloadOptions(options) {
+    const range = options?.range;
+    if (range === undefined) {
+        return;
+    }
+    if (!Number.isSafeInteger(range.start) || range.start < 0) {
+        invalidArgument('range.start must be a non-negative safe integer.');
+    }
+    if (range.end !== undefined &&
+        (!Number.isSafeInteger(range.end) || range.end < range.start)) {
+        invalidArgument('range.end must be a safe integer greater than or equal to range.start.');
+    }
+}
+function assertListOptions(options) {
+    if (options?.delimiter !== undefined && options.delimiter.length === 0) {
+        invalidArgument('delimiter must be a non-empty string.');
+    }
+    assertPositiveSafeInteger(options?.limit, 'limit');
+}
+function assertSearchOptions(options) {
+    assertPositiveSafeInteger(options?.limit, 'limit');
+    assertPositiveSafeInteger(options?.maxResults, 'maxResults');
+}
+function assertSignedUploadOptions(options) {
+    assertPositiveSafeInteger(options.expiresIn, 'expiresIn');
+    assertPositiveSafeInteger(options.maxSize, 'maxSize');
+    if (options.minSize !== undefined &&
+        (!Number.isSafeInteger(options.minSize) || options.minSize < 0)) {
+        invalidArgument('minSize must be a non-negative safe integer.');
+    }
+    if (options.minSize !== undefined &&
+        options.maxSize !== undefined &&
+        options.minSize > options.maxSize) {
+        invalidArgument('minSize cannot be greater than maxSize.');
+    }
+}
+function operationOptions(options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    return {
+        ...(options.retries !== undefined && { retries: options.retries }),
+        ...(options.signal !== undefined && { signal: options.signal }),
+        ...(options.timeout !== undefined && { timeout: options.timeout }),
+    };
+}
+function downloadOptions(options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    return {
+        ...operationOptions(options),
+        ...(options.range !== undefined && { range: options.range }),
+    };
+}
+async function collectBody(object, maxBytes) {
+    if (maxBytes !== Infinity && (!Number.isFinite(maxBytes) || maxBytes < 0)) {
+        await object.body.cancel().catch(() => undefined);
+        throw new StorageError('maxBytes must be a non-negative finite number or Infinity.', {
+            code: StorageErrorCode.INVALID_ARGUMENT,
+            key: object.key,
+            permanent: true,
+        });
+    }
+    if (maxBytes !== Infinity && object.size > maxBytes) {
+        await object.body.cancel().catch(() => undefined);
+        throw new StorageError(`Object "${object.key}" is ${object.size} bytes, exceeding the ${maxBytes}-byte buffer limit.`, {
+            code: StorageErrorCode.LIMIT_EXCEEDED,
+            key: object.key,
+            permanent: true,
+        });
+    }
+    const chunks = [];
+    let total = 0;
+    const reader = object.body.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            total += value.byteLength;
+            if (maxBytes !== Infinity && total > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                throw new StorageError(`Object "${object.key}" exceeded the ${maxBytes}-byte buffer limit while downloading.`, {
+                    code: StorageErrorCode.LIMIT_EXCEEDED,
+                    key: object.key,
+                    permanent: true,
+                });
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+export class StorageClient {
+    name;
+    #driver;
+    #plugins;
+    #closed = false;
+    constructor(name, driver, plugins = []) {
+        this.name = name;
+        assertKey(name, 'store name');
+        this.#driver = driver;
+        this.#plugins = [...plugins];
+    }
+    get driverName() {
+        return this.#driver.name;
+    }
+    get capabilities() {
+        return this.#driver.capabilities;
+    }
+    file(key) {
+        assertKey(key);
+        return {
+            copyTo: (destinationKey, options) => this.copy(key, destinationKey, options),
+            delete: (options) => this.delete(key, options),
+            download: (options) => this.downloadStream(key, options),
+            exists: (options) => this.exists(key, options),
+            head: (options) => this.head(key, options),
+            key,
+            moveTo: (destinationKey, options) => this.move(key, destinationKey, options),
+            signDownload: (options) => this.signDownload(key, options),
+            signUpload: (options) => this.signUpload(key, options),
+            bytes: (options) => this.downloadBytes(key, options),
+            text: (options) => this.downloadText(key, options),
+            upload: (body, options) => this.upload(key, body, options),
+        };
+    }
+    upload(key, body, options) {
+        assertKey(key);
+        return this.#execute({ key, operation: 'upload', store: this.name }, () => this.#driver.upload(key, body, options));
+    }
+    downloadStream(key, options) {
+        assertKey(key);
+        assertDownloadOptions(options);
+        return this.#execute({ key, operation: 'download', store: this.name }, () => this.#driver.download(key, options));
+    }
+    async downloadBytes(key, options) {
+        const { maxBytes = DEFAULT_BUFFER_LIMIT, ...download } = options ?? {};
+        const object = await this.downloadStream(key, download);
+        return collectBody(object, maxBytes);
+    }
+    async downloadText(key, options) {
+        return new TextDecoder().decode(await this.downloadBytes(key, options));
+    }
+    async downloadJson(key, options) {
+        const text = await this.downloadText(key, options);
+        try {
+            return JSON.parse(text);
+        }
+        catch (error) {
+            throw new StorageError(`Object "${key}" does not contain valid JSON.`, {
+                cause: error,
+                code: StorageErrorCode.INVALID_ARGUMENT,
+                key,
+                operation: 'download',
+                permanent: true,
+                store: this.name,
+            });
+        }
+    }
+    head(key, options) {
+        assertKey(key);
+        return this.#execute({ key, operation: 'head', store: this.name }, () => this.#driver.head(key, options));
+    }
+    exists(key, options) {
+        assertKey(key);
+        return this.#execute({ key, operation: 'exists', store: this.name }, () => this.#driver.exists(key, options));
+    }
+    delete(key, options) {
+        assertKey(key);
+        return this.#execute({ key, operation: 'delete', store: this.name }, () => this.#driver.delete(key, options));
+    }
+    copy(sourceKey, destinationKey, options) {
+        assertKey(sourceKey, 'source key');
+        assertKey(destinationKey, 'destination key');
+        return this.#execute({
+            from: sourceKey,
+            operation: 'copy',
+            store: this.name,
+            to: destinationKey,
+        }, () => this.#driver.copy(sourceKey, destinationKey, options));
+    }
+    move(sourceKey, destinationKey, options) {
+        assertKey(sourceKey, 'source key');
+        assertKey(destinationKey, 'destination key');
+        return this.#execute({
+            from: sourceKey,
+            operation: 'move',
+            store: this.name,
+            to: destinationKey,
+        }, () => this.#driver.move(sourceKey, destinationKey, options));
+    }
+    list(options) {
+        assertListOptions(options);
+        return this.#execute({ operation: 'list', store: this.name }, () => this.#driver.list(options));
+    }
+    async *listAll(options) {
+        const { delimiter: _delimiter, ...walkOptions } = options ?? {};
+        void _delimiter;
+        let cursor = walkOptions.cursor;
+        const seen = new Set();
+        do {
+            const page = await this.list({
+                ...walkOptions,
+                ...(cursor !== undefined && { cursor }),
+            });
+            yield* page.items;
+            cursor = page.cursor;
+            if (cursor !== undefined) {
+                if (seen.has(cursor)) {
+                    throw new StorageError(`Store "${this.name}" returned a repeated pagination cursor.`, {
+                        code: StorageErrorCode.PROVIDER,
+                        operation: 'list',
+                        permanent: true,
+                        store: this.name,
+                    });
+                }
+                seen.add(cursor);
+            }
+        } while (cursor !== undefined);
+    }
+    search(pattern, options) {
+        assertSearchOptions(options);
+        return this.#search(pattern, options);
+    }
+    async *#search(pattern, options) {
+        const context = {
+            operation: 'search',
+            store: this.name,
+        };
+        try {
+            for (const plugin of this.#plugins) {
+                await plugin.beforeOperation?.(context);
+            }
+            for await (const object of this.#driver.search(pattern, options)) {
+                yield object;
+            }
+            for (const plugin of this.#plugins) {
+                await plugin.afterOperation?.(context, undefined);
+            }
+        }
+        catch (error) {
+            const normalized = normalizeStorageError(error, {
+                operation: 'search',
+                store: this.name,
+            });
+            for (const plugin of this.#plugins) {
+                try {
+                    await plugin.onError?.(context, normalized);
+                }
+                catch {
+                    // Preserve the original storage error.
+                }
+            }
+            throw normalized;
+        }
+    }
+    signDownload(key, options) {
+        assertKey(key);
+        return this.#execute({ key, operation: 'signDownload', store: this.name }, () => this.#driver.signDownload(key, options));
+    }
+    signUpload(key, options) {
+        assertKey(key);
+        assertSignedUploadOptions(options);
+        return this.#execute({ key, operation: 'signUpload', store: this.name }, () => this.#driver.signUpload(key, options));
+    }
+    async uploadMany(items, options) {
+        const settled = await settleMany(items, (item) => item.key, (item) => this.upload(item.key, item.body, {
+            ...operationOptions(options),
+            ...(item.cacheControl !== undefined && {
+                cacheControl: item.cacheControl,
+            }),
+            ...(item.contentType !== undefined && {
+                contentType: item.contentType,
+            }),
+            ...(item.metadata !== undefined && { metadata: item.metadata }),
+            ...(item.multipart !== undefined && {
+                multipart: item.multipart,
+            }),
+            ...(options?.onProgress !== undefined && {
+                onProgress: (progress) => options.onProgress?.({ ...progress, key: item.key }),
+            }),
+        }), options);
+        return {
+            uploaded: settled.results,
+            ...(settled.errors.length > 0 && { errors: settled.errors }),
+        };
+    }
+    async downloadMany(keys, options) {
+        const settled = await settleMany(keys, (key) => key, (key) => this.downloadStream(key, downloadOptions(options)), options);
+        return {
+            downloaded: settled.results,
+            ...(settled.errors.length > 0 && { errors: settled.errors }),
+        };
+    }
+    async headMany(keys, options) {
+        const settled = await settleMany(keys, (key) => key, (key) => this.head(key, operationOptions(options)), options);
+        return {
+            objects: settled.results,
+            ...(settled.errors.length > 0 && { errors: settled.errors }),
+        };
+    }
+    async existsMany(keys, options) {
+        const settled = await settleMany(keys, (key) => key, async (key) => ({ exists: await this.exists(key, options), key }), options);
+        const existing = [];
+        const missing = [];
+        for (const result of settled.results) {
+            (result.exists ? existing : missing).push(result.key);
+        }
+        return {
+            existing,
+            missing,
+            ...(settled.errors.length > 0 && { errors: settled.errors }),
+        };
+    }
+    async deleteMany(keys, options) {
+        const settled = await settleMany(keys, (key) => key, async (key) => {
+            await this.delete(key, operationOptions(options));
+            return key;
+        }, options);
+        return {
+            deleted: settled.results,
+            ...(settled.errors.length > 0 && { errors: settled.errors }),
+        };
+    }
+    async onApplicationShutdown() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        await this.#driver.close?.();
+    }
+    async #execute(context, operation) {
+        try {
+            for (const plugin of this.#plugins) {
+                await plugin.beforeOperation?.(context);
+            }
+            const result = await operation();
+            for (const plugin of this.#plugins) {
+                await plugin.afterOperation?.(context, result);
+            }
+            return result;
+        }
+        catch (error) {
+            const normalized = normalizeStorageError(error, {
+                ...(context.key !== undefined && { key: context.key }),
+                operation: context.operation,
+                store: this.name,
+            });
+            for (const plugin of this.#plugins) {
+                try {
+                    await plugin.onError?.(context, normalized);
+                }
+                catch {
+                    // Preserve the original storage error.
+                }
+            }
+            throw normalized;
+        }
+    }
+}
+//# sourceMappingURL=storage.client.js.map