@miguelmorales13/nestkit 0.4.0 → 0.5.0

package/dist/storage/index.cjs

@@ -0,0 +1,528 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk2REOCMUDcjs = require('../chunk-2REOCMUD.cjs');
+
+// src/storage/storage.port.ts
+var STORAGE = /* @__PURE__ */ Symbol("STORAGE");
+
+// src/storage/storage.options.ts
+var STORAGE_OPTIONS = /* @__PURE__ */ Symbol("STORAGE_OPTIONS");
+
+// src/storage/storage.module.ts
+var _common = require('@nestjs/common');
+
+// src/storage/adapters/local.storage.ts
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _path = require('path');
+var _promises3 = require('stream/promises');
+
+var LocalStorage = class {
+  constructor(options) {
+    this.root = _path.resolve.call(void 0, options.root);
+    this.publicBaseUrl = _optionalChain([options, 'access', _ => _.publicBaseUrl, 'optionalAccess', _2 => _2.replace, 'call', _3 => _3(/\/$/, "")]);
+  }
+  /** Resolve a key to an absolute path, refusing anything that escapes the root. */
+  pathOf(key) {
+    const target = _path.resolve.call(void 0, _path.join.call(void 0, this.root, _path.normalize.call(void 0, key)));
+    if (target !== this.root && !target.startsWith(this.root + _path.sep)) {
+      throw new Error(`LocalStorage: key escapes the storage root: ${key}`);
+    }
+    return target;
+  }
+  async put(key, data) {
+    const path = this.pathOf(key);
+    await _promises.mkdir.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+    await _promises.writeFile.call(void 0, path, data);
+    return { key, size: data.byteLength };
+  }
+  async putStream(key, stream) {
+    const path = this.pathOf(key);
+    await _promises.mkdir.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+    await _promises3.pipeline.call(void 0, stream, _fs.createWriteStream.call(void 0, path));
+    const s = await _promises.stat.call(void 0, path);
+    return { key, size: s.size, lastModified: s.mtime };
+  }
+  async get(key) {
+    return _promises.readFile.call(void 0, this.pathOf(key));
+  }
+  async getStream(key, range) {
+    const path = this.pathOf(key);
+    const s = await _promises.stat.call(void 0, path);
+    if (!range) {
+      return { stream: _fs.createReadStream.call(void 0, path), contentLength: s.size, totalSize: s.size, lastModified: s.mtime };
+    }
+    const end = _nullishCoalesce(range.end, () => ( s.size - 1));
+    return {
+      stream: _fs.createReadStream.call(void 0, path, { start: range.start, end }),
+      contentLength: end - range.start + 1,
+      totalSize: s.size,
+      contentRange: `bytes ${range.start}-${end}/${s.size}`,
+      lastModified: s.mtime
+    };
+  }
+  async stat(key) {
+    try {
+      const s = await _promises.stat.call(void 0, this.pathOf(key));
+      return { key, size: s.size, lastModified: s.mtime };
+    } catch (e2) {
+      return null;
+    }
+  }
+  async exists(key) {
+    return await this.stat(key) !== null;
+  }
+  async delete(key) {
+    await _promises.rm.call(void 0, this.pathOf(key), { force: true });
+  }
+  async list(prefix, options) {
+    const base = this.pathOf(prefix);
+    const objects = [];
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await _promises.readdir.call(void 0, dir, { withFileTypes: true });
+      } catch (e3) {
+        return;
+      }
+      for (const entry of entries) {
+        if (_optionalChain([options, 'optionalAccess', _4 => _4.limit]) && objects.length >= options.limit) return;
+        const full = _path.join.call(void 0, dir, String(entry.name));
+        if (entry.isDirectory()) await walk(full);
+        else {
+          const s = await _promises.stat.call(void 0, full);
+          objects.push({ key: _path.relative.call(void 0, this.root, full).split(_path.sep).join("/"), size: s.size, lastModified: s.mtime });
+        }
+      }
+    };
+    await walk(base);
+    return { objects };
+  }
+  publicUrl(key) {
+    return this.publicBaseUrl ? `${this.publicBaseUrl}/${key}` : `/${key}`;
+  }
+  async signedReadUrl(key) {
+    return _nullishCoalesce(this.publicUrl(key), () => ( `/${key}`));
+  }
+  async signedUploadUrl() {
+    throw new Error(
+      "LocalStorage does not support direct signed uploads \u2014 a client cannot PUT to the server disk. Upload through your API in dev, or use the S3/R2 or Bunny adapter."
+    );
+  }
+};
+
+// src/storage/adapters/s3.storage.ts
+var S3Storage = class {
+  constructor(options) {
+    this.bucket = options.bucket;
+    this.publicBaseUrl = _optionalChain([options, 'access', _5 => _5.publicBaseUrl, 'optionalAccess', _6 => _6.replace, 'call', _7 => _7(/\/$/, "")]);
+    this.config = {
+      region: _nullishCoalesce(options.region, () => ( "us-east-1")),
+      endpoint: options.endpoint,
+      forcePathStyle: options.forcePathStyle,
+      credentials: {
+        accessKeyId: options.accessKeyId,
+        secretAccessKey: options.secretAccessKey
+      }
+    };
+  }
+  /** Lazily construct (and memoize) the S3 client, loading the SDK on first use. */
+  async client() {
+    if (!this.clientPromise) {
+      this.clientPromise = Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3"))).then(
+        ({ S3Client }) => new S3Client(this.config)
+      );
+    }
+    return this.clientPromise;
+  }
+  async put(key, data, options) {
+    const [client, { PutObjectCommand }] = await Promise.all([
+      this.client(),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3")))
+    ]);
+    const out = await client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: data,
+        ContentType: _optionalChain([options, 'optionalAccess', _8 => _8.contentType]),
+        CacheControl: _optionalChain([options, 'optionalAccess', _9 => _9.cacheControl]),
+        ContentDisposition: _optionalChain([options, 'optionalAccess', _10 => _10.contentDisposition]),
+        Metadata: _optionalChain([options, 'optionalAccess', _11 => _11.metadata])
+      })
+    );
+    return { key, size: data.byteLength, contentType: _optionalChain([options, 'optionalAccess', _12 => _12.contentType]), etag: out.ETag };
+  }
+  async putStream(key, stream, options) {
+    const [client, { Upload }] = await Promise.all([this.client(), Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/lib-storage")))]);
+    const upload = new Upload({
+      client,
+      params: {
+        Bucket: this.bucket,
+        Key: key,
+        Body: stream,
+        ContentType: _optionalChain([options, 'optionalAccess', _13 => _13.contentType]),
+        CacheControl: _optionalChain([options, 'optionalAccess', _14 => _14.cacheControl]),
+        ContentDisposition: _optionalChain([options, 'optionalAccess', _15 => _15.contentDisposition]),
+        Metadata: _optionalChain([options, 'optionalAccess', _16 => _16.metadata])
+      }
+    });
+    const out = await upload.done();
+    const info = await this.stat(key);
+    return { key, size: _nullishCoalesce(_optionalChain([info, 'optionalAccess', _17 => _17.size]), () => ( 0)), contentType: _optionalChain([options, 'optionalAccess', _18 => _18.contentType]), etag: _optionalChain([out, 'optionalAccess', _19 => _19.ETag]) };
+  }
+  async get(key) {
+    const { stream } = await this.getStream(key);
+    const chunks = [];
+    for await (const chunk of stream) chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks);
+  }
+  async getStream(key, range) {
+    const [client, { GetObjectCommand }] = await Promise.all([
+      this.client(),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3")))
+    ]);
+    const out = await client.send(
+      new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Range: range ? `bytes=${range.start}-${_nullishCoalesce(range.end, () => ( ""))}` : void 0
+      })
+    );
+    return {
+      stream: out.Body,
+      contentType: out.ContentType,
+      contentLength: out.ContentLength,
+      contentRange: out.ContentRange,
+      totalSize: out.ContentRange ? Number(out.ContentRange.split("/")[1]) : out.ContentLength,
+      lastModified: out.LastModified,
+      etag: out.ETag
+    };
+  }
+  async stat(key) {
+    const [client, { HeadObjectCommand }] = await Promise.all([
+      this.client(),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3")))
+    ]);
+    try {
+      const out = await client.send(new HeadObjectCommand({ Bucket: this.bucket, Key: key }));
+      return {
+        key,
+        size: _nullishCoalesce(out.ContentLength, () => ( 0)),
+        contentType: out.ContentType,
+        lastModified: out.LastModified,
+        etag: out.ETag
+      };
+    } catch (err) {
+      if (_optionalChain([err, 'optionalAccess', _20 => _20.$metadata, 'optionalAccess', _21 => _21.httpStatusCode]) === 404 || _optionalChain([err, 'optionalAccess', _22 => _22.name]) === "NotFound") return null;
+      throw err;
+    }
+  }
+  async exists(key) {
+    return await this.stat(key) !== null;
+  }
+  async delete(key) {
+    const [client, { DeleteObjectCommand }] = await Promise.all([
+      this.client(),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3")))
+    ]);
+    await client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
+  }
+  async list(prefix, options) {
+    const [client, { ListObjectsV2Command }] = await Promise.all([
+      this.client(),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3")))
+    ]);
+    const out = await client.send(
+      new ListObjectsV2Command({
+        Bucket: this.bucket,
+        Prefix: prefix,
+        MaxKeys: _optionalChain([options, 'optionalAccess', _23 => _23.limit]),
+        ContinuationToken: _optionalChain([options, 'optionalAccess', _24 => _24.cursor])
+      })
+    );
+    return {
+      objects: (_nullishCoalesce(out.Contents, () => ( []))).map((o) => ({
+        key: o.Key,
+        size: _nullishCoalesce(o.Size, () => ( 0)),
+        lastModified: o.LastModified,
+        etag: o.ETag
+      })),
+      cursor: out.NextContinuationToken
+    };
+  }
+  async signedReadUrl(key, ttlSeconds = 3600) {
+    const [client, { GetObjectCommand }, { getSignedUrl }] = await Promise.all([
+      this.client(),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3"))),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/s3-request-presigner")))
+    ]);
+    return getSignedUrl(client, new GetObjectCommand({ Bucket: this.bucket, Key: key }), {
+      expiresIn: ttlSeconds
+    });
+  }
+  async signedUploadUrl(key, options) {
+    const [client, { PutObjectCommand }, { getSignedUrl }] = await Promise.all([
+      this.client(),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/client-s3"))),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@aws-sdk/s3-request-presigner")))
+    ]);
+    const ttl = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _25 => _25.ttlSeconds]), () => ( 900));
+    const url = await getSignedUrl(
+      client,
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        ContentType: _optionalChain([options, 'optionalAccess', _26 => _26.contentType]),
+        CacheControl: _optionalChain([options, 'optionalAccess', _27 => _27.cacheControl])
+      }),
+      { expiresIn: ttl }
+    );
+    return {
+      url,
+      method: "PUT",
+      headers: _optionalChain([options, 'optionalAccess', _28 => _28.contentType]) ? { "Content-Type": options.contentType } : void 0,
+      key,
+      expiresAt: new Date(Date.now() + ttl * 1e3)
+    };
+  }
+  publicUrl(key) {
+    return this.publicBaseUrl ? `${this.publicBaseUrl}/${key}` : null;
+  }
+};
+
+// src/storage/adapters/bunny.storage.ts
+var _crypto = require('crypto');
+var _stream = require('stream');
+var BunnyStorage = class {
+  constructor(options) {
+    const host = `${options.region ? `${options.region}.` : ""}storage.bunnycdn.com`;
+    this.base = `https://${host}/${options.storageZone}`;
+    this.apiKey = options.apiKey;
+    this.pullZoneUrl = _optionalChain([options, 'access', _29 => _29.pullZoneUrl, 'optionalAccess', _30 => _30.replace, 'call', _31 => _31(/\/$/, "")]);
+    this.tokenSecurityKey = options.tokenSecurityKey;
+  }
+  url(key) {
+    return `${this.base}/${key.split("/").map(encodeURIComponent).join("/")}`;
+  }
+  async put(key, data, options) {
+    const res = await fetch(this.url(key), {
+      method: "PUT",
+      headers: {
+        AccessKey: this.apiKey,
+        "Content-Type": _nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.contentType]), () => ( "application/octet-stream"))
+      },
+      body: data
+    });
+    if (!res.ok) throw new Error(`Bunny put ${key} failed: ${res.status} ${await res.text()}`);
+    return { key, size: data.byteLength, contentType: _optionalChain([options, 'optionalAccess', _33 => _33.contentType]) };
+  }
+  async putStream(key, stream, options) {
+    const res = await fetch(this.url(key), {
+      method: "PUT",
+      headers: {
+        AccessKey: this.apiKey,
+        "Content-Type": _nullishCoalesce(_optionalChain([options, 'optionalAccess', _34 => _34.contentType]), () => ( "application/octet-stream"))
+      },
+      body: _stream.Readable.toWeb(stream),
+      // Required by fetch when the body is a stream.
+      duplex: "half"
+    });
+    if (!res.ok) throw new Error(`Bunny putStream ${key} failed: ${res.status} ${await res.text()}`);
+    const info = await this.stat(key);
+    return { key, size: _nullishCoalesce(_nullishCoalesce(_optionalChain([info, 'optionalAccess', _35 => _35.size]), () => ( _optionalChain([options, 'optionalAccess', _36 => _36.contentLength]))), () => ( 0)), contentType: _optionalChain([options, 'optionalAccess', _37 => _37.contentType]) };
+  }
+  async get(key) {
+    const res = await fetch(this.url(key), { headers: { AccessKey: this.apiKey } });
+    if (!res.ok) throw new Error(`Bunny get ${key} failed: ${res.status}`);
+    return Buffer.from(await res.arrayBuffer());
+  }
+  async getStream(key, range) {
+    const headers = { AccessKey: this.apiKey };
+    if (range) headers.Range = `bytes=${range.start}-${_nullishCoalesce(range.end, () => ( ""))}`;
+    const res = await fetch(this.url(key), { headers });
+    if (!res.ok && res.status !== 206) throw new Error(`Bunny getStream ${key} failed: ${res.status}`);
+    if (!res.body) throw new Error(`Bunny getStream ${key}: empty body`);
+    const contentLength = Number(res.headers.get("content-length")) || void 0;
+    const contentRange = _nullishCoalesce(res.headers.get("content-range"), () => ( void 0));
+    return {
+      stream: _stream.Readable.fromWeb(res.body),
+      contentType: _nullishCoalesce(res.headers.get("content-type"), () => ( void 0)),
+      contentLength,
+      contentRange,
+      totalSize: contentRange ? Number(contentRange.split("/")[1]) : contentLength
+    };
+  }
+  async stat(key) {
+    const slash = key.lastIndexOf("/");
+    const dir = slash >= 0 ? key.slice(0, slash) : "";
+    const name = slash >= 0 ? key.slice(slash + 1) : key;
+    const entries = await this.listRaw(dir);
+    const found = entries.find((e) => !e.IsDirectory && e.ObjectName === name);
+    if (!found) return null;
+    return {
+      key,
+      size: found.Length,
+      contentType: found.ContentType || void 0,
+      lastModified: found.LastChanged ? new Date(found.LastChanged) : void 0
+    };
+  }
+  async exists(key) {
+    return await this.stat(key) !== null;
+  }
+  async delete(key) {
+    const res = await fetch(this.url(key), { method: "DELETE", headers: { AccessKey: this.apiKey } });
+    if (!res.ok && res.status !== 404) {
+      throw new Error(`Bunny delete ${key} failed: ${res.status} ${await res.text()}`);
+    }
+  }
+  async listRaw(prefix) {
+    const path = prefix ? `${prefix.replace(/\/$/, "")}/` : "";
+    const res = await fetch(`${this.base}/${path}`, { headers: { AccessKey: this.apiKey } });
+    if (res.status === 404) return [];
+    if (!res.ok) throw new Error(`Bunny list ${prefix} failed: ${res.status}`);
+    return await res.json();
+  }
+  async list(prefix, options) {
+    const entries = await this.listRaw(prefix);
+    const base = prefix ? `${prefix.replace(/\/$/, "")}/` : "";
+    let objects = entries.filter((e) => !e.IsDirectory).map((e) => ({
+      key: `${base}${e.ObjectName}`,
+      size: e.Length,
+      contentType: e.ContentType || void 0,
+      lastModified: e.LastChanged ? new Date(e.LastChanged) : void 0
+    }));
+    if (_optionalChain([options, 'optionalAccess', _38 => _38.limit])) objects = objects.slice(0, options.limit);
+    return { objects };
+  }
+  publicUrl(key) {
+    if (!this.pullZoneUrl) return null;
+    return `${this.pullZoneUrl}/${key.split("/").map(encodeURIComponent).join("/")}`;
+  }
+  async signedReadUrl(key, ttlSeconds = 3600) {
+    if (!this.pullZoneUrl) {
+      throw new Error("BunnyStorage.signedReadUrl: set pullZoneUrl (Bunny signs Pull Zone URLs).");
+    }
+    if (!this.tokenSecurityKey) {
+      return this.publicUrl(key);
+    }
+    const path = `/${key.split("/").map(encodeURIComponent).join("/")}`;
+    const expires = Math.floor(Date.now() / 1e3) + ttlSeconds;
+    const token = _crypto.createHash.call(void 0, "sha256").update(this.tokenSecurityKey + path + expires).digest("base64").replace(/\n/g, "").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    return `${this.pullZoneUrl}${path}?token=${token}&expires=${expires}`;
+  }
+  async signedUploadUrl() {
+    throw new Error(
+      "BunnyStorage does not support presigned direct uploads (Storage has no PUT signature that hides the zone password). Upload through your API, or use Bunny Stream/TUS for large video."
+    );
+  }
+};
+
+// src/storage/storage.module.ts
+var env = (k) => process.env[k] || void 0;
+function r2ToS3Options(r2) {
+  return {
+    bucket: r2.bucket,
+    region: "auto",
+    endpoint: `https://${r2.accountId}.r2.cloudflarestorage.com`,
+    accessKeyId: r2.accessKeyId,
+    secretAccessKey: r2.secretAccessKey,
+    publicBaseUrl: r2.publicBaseUrl
+  };
+}
+function resolveStorageOptions(options = {}) {
+  const provider = _nullishCoalesce(_nullishCoalesce(options.provider, () => ( env("STORAGE_PROVIDER"))), () => ( "local"));
+  return {
+    provider,
+    local: _nullishCoalesce(options.local, () => ( {
+      root: _nullishCoalesce(env("STORAGE_LOCAL_ROOT"), () => ( ".storage")),
+      publicBaseUrl: env("STORAGE_PUBLIC_BASE_URL")
+    })),
+    s3: _nullishCoalesce(options.s3, () => ( (env("S3_BUCKET") ? {
+      bucket: env("S3_BUCKET"),
+      region: env("S3_REGION"),
+      endpoint: env("S3_ENDPOINT"),
+      accessKeyId: _nullishCoalesce(env("S3_ACCESS_KEY_ID"), () => ( "")),
+      secretAccessKey: _nullishCoalesce(env("S3_SECRET_ACCESS_KEY"), () => ( "")),
+      publicBaseUrl: env("S3_PUBLIC_BASE_URL"),
+      forcePathStyle: env("S3_FORCE_PATH_STYLE") === "true"
+    } : void 0))),
+    r2: _nullishCoalesce(options.r2, () => ( (env("R2_ACCOUNT_ID") ? {
+      accountId: env("R2_ACCOUNT_ID"),
+      bucket: _nullishCoalesce(env("R2_BUCKET"), () => ( "")),
+      accessKeyId: _nullishCoalesce(env("R2_ACCESS_KEY_ID"), () => ( "")),
+      secretAccessKey: _nullishCoalesce(env("R2_SECRET_ACCESS_KEY"), () => ( "")),
+      publicBaseUrl: env("R2_PUBLIC_BASE_URL")
+    } : void 0))),
+    bunny: _nullishCoalesce(options.bunny, () => ( (env("BUNNY_STORAGE_ZONE") ? {
+      storageZone: env("BUNNY_STORAGE_ZONE"),
+      apiKey: _nullishCoalesce(env("BUNNY_API_KEY"), () => ( "")),
+      region: env("BUNNY_REGION"),
+      pullZoneUrl: env("BUNNY_PULL_ZONE_URL"),
+      tokenSecurityKey: env("BUNNY_TOKEN_SECURITY_KEY")
+    } : void 0)))
+  };
+}
+function createStorageAdapter(options) {
+  const resolved = resolveStorageOptions(options);
+  switch (resolved.provider) {
+    case "local":
+      return new LocalStorage(resolved.local);
+    case "s3":
+      if (!resolved.s3) throw new Error('StorageModule: provider "s3" selected but no s3 options / S3_* env set.');
+      return new S3Storage(resolved.s3);
+    case "r2":
+      if (!resolved.r2) throw new Error('StorageModule: provider "r2" selected but no r2 options / R2_* env set.');
+      return new S3Storage(r2ToS3Options(resolved.r2));
+    case "bunny":
+      if (!resolved.bunny)
+        throw new Error('StorageModule: provider "bunny" selected but no bunny options / BUNNY_* env set.');
+      return new BunnyStorage(resolved.bunny);
+    default:
+      throw new Error(`StorageModule: unknown provider "${resolved.provider}".`);
+  }
+}
+var StorageModule = class {
+  static forRoot(options = {}) {
+    const providers = [
+      { provide: STORAGE_OPTIONS, useValue: options },
+      { provide: STORAGE, useFactory: () => createStorageAdapter(options) }
+    ];
+    return { module: StorageModule, providers, exports: [STORAGE, STORAGE_OPTIONS] };
+  }
+  static forRootAsync(config) {
+    const providers = [
+      {
+        provide: STORAGE_OPTIONS,
+        useFactory: config.useFactory,
+        inject: _nullishCoalesce(config.inject, () => ( []))
+      },
+      {
+        provide: STORAGE,
+        useFactory: (options) => createStorageAdapter(options),
+        inject: [STORAGE_OPTIONS]
+      }
+    ];
+    return {
+      module: StorageModule,
+      imports: _nullishCoalesce(config.imports, () => ( [])),
+      providers,
+      exports: [STORAGE, STORAGE_OPTIONS]
+    };
+  }
+};
+StorageModule = exports.StorageModule = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Global.call(void 0, ),
+  _common.Module.call(void 0, {})
+], StorageModule);
+
+
+
+
+
+
+
+
+
+
+exports.BunnyStorage = BunnyStorage; exports.LocalStorage = LocalStorage; exports.S3Storage = S3Storage; exports.STORAGE = STORAGE; exports.STORAGE_OPTIONS = STORAGE_OPTIONS; exports.StorageModule = StorageModule; exports.createStorageAdapter = createStorageAdapter; exports.r2ToS3Options = r2ToS3Options; exports.resolveStorageOptions = resolveStorageOptions;

package/dist/storage/index.d.ts

@@ -0,0 +1,8 @@
+export { STORAGE } from './storage.port.js';
+export type { StoragePort, PutOptions, ObjectInfo, ByteRange, ReadStream, SignedUploadTarget, ListResult, } from './storage.port.js';
+export { STORAGE_OPTIONS } from './storage.options.js';
+export type { StorageOptions, StorageProvider, LocalStorageOptions, S3StorageOptions, R2StorageOptions, BunnyStorageOptions, } from './storage.options.js';
+export { StorageModule, createStorageAdapter, resolveStorageOptions, r2ToS3Options, } from './storage.module.js';
+export { LocalStorage } from './adapters/local.storage.js';
+export { S3Storage } from './adapters/s3.storage.js';
+export { BunnyStorage } from './adapters/bunny.storage.js';