@autonomys/auto-files 1.4.34 → 1.5.1

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2024 Autonomys Network (autonomys.xyz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+1. **Attribution**: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+2. **No Warranty**: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+3. **Limitation of Liability**: IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---

package/dist/api.d.ts

@@ -0,0 +1,28 @@
+import { CompressionOptions, EncryptionOptions } from '@autonomys/auto-drive';
+import { Readable } from 'stream';
+interface FetchedFile {
+    length: bigint;
+    compression: CompressionOptions | undefined;
+    encryption: EncryptionOptions | undefined;
+    data: Readable;
+}
+/**
+ * Creates an API client for interacting with the Auto Files service
+ * @param baseUrl - The base URL of the Auto Files API
+ * @param apiSecret - The API secret key for authentication
+ * @returns An object containing methods to interact with the API
+ */
+export declare const createAutoFilesApi: (baseUrl: string, apiSecret: string) => {
+    getFile: (cid: string, { retriesPerFetch, onProgress, ignoreCache, }?: {
+        retriesPerFetch?: number;
+        onProgress?: (progress: number) => void;
+        ignoreCache?: boolean;
+    }) => Promise<Readable>;
+    isFileCached: (cid: string) => Promise<any>;
+    getChunkedFile: (cid: string, { retriesPerFetch, onProgress, }?: {
+        retriesPerFetch?: number;
+        onProgress?: (progress: number) => void;
+    }) => Promise<FetchedFile>;
+};
+export {};
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAEjC,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,kBAAkB,GAAG,SAAS,CAAA;IAC3C,UAAU,EAAE,iBAAiB,GAAG,SAAS,CAAA;IACzC,IAAI,EAAE,QAAQ,CAAA;CACf;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,EAAE,WAAW,MAAM;mBA+H5D,MAAM,kDAKR;QACD,eAAe,CAAC,EAAE,MAAM,CAAA;QACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;QACvC,WAAW,CAAC,EAAE,OAAO,CAAA;KACtB;wBAxC8B,MAAM;0BAlDhC,MAAM,qCAIR;QAAE,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,KACvE,OAAO,CAAC,WAAW,CAAC;CAmGxB,CAAA"}

package/dist/api.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutoFilesApi = void 0;
+const asynchronous_1 = require("@autonomys/asynchronous");
+const stream_1 = require("stream");
+const utils_1 = require("./utils");
+/**
+ * Creates an API client for interacting with the Auto Files service
+ * @param baseUrl - The base URL of the Auto Files API
+ * @param apiSecret - The API secret key for authentication
+ * @returns An object containing methods to interact with the API
+ */
+const createAutoFilesApi = (baseUrl, apiSecret) => {
+    /**
+     * Makes an authenticated fetch request to the API
+     * @param url - The URL to fetch from
+     * @param options - Optional fetch request options
+     * @returns A Promise that resolves to the fetch Response
+     */
+    const authFetch = (url, options = {}) => {
+        const urlObj = new URL(url);
+        return fetch(urlObj.toString(), Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { Authorization: `Bearer ${apiSecret}` }) }));
+    };
+    /**
+     * Fetches a specific chunk of a file from the API
+     * @param cid - The content identifier of the file
+     * @param chunk - The chunk number to fetch
+     * @returns A Promise that resolves to the chunk data as ArrayBuffer, or null if chunk doesn't exist
+     * @throws Error if the chunk fetch fails
+     */
+    const getChunk = (cid, chunk) => __awaiter(void 0, void 0, void 0, function* () {
+        const response = yield authFetch(`${baseUrl}/files/${cid}/partial?chunk=${chunk}`);
+        if (!response.ok) {
+            throw new Error(`Error fetching chunk: ${response.status} ${response.statusText}`);
+        }
+        if (response.status === 204) {
+            return null;
+        }
+        const buffer = yield response.arrayBuffer();
+        return buffer;
+    });
+    /**
+     * Fetches a complete file from the API with support for progress tracking and retries
+     * @param cid - The content identifier of the file to fetch
+     * @param options - Optional configuration for the fetch operation
+     * @param options.retriesPerFetch - Number of retry attempts for failed requests (default: 3)
+     * @param options.onProgress - Optional callback function to track download progress (0-1)
+     * @returns A Promise that resolves to a FetchedFile object containing the file data and metadata
+     * @throws Error if the file metadata fetch fails
+     */
+    const getChunkedFile = (cid_1, ...args_1) => __awaiter(void 0, [cid_1, ...args_1], void 0, function* (cid, { retriesPerFetch = 3, onProgress, } = {}) {
+        var _a, _b, _c;
+        const response = yield (0, utils_1.withRetries)(() => authFetch(`${baseUrl}/files/${cid}/metadata`), {
+            retries: retriesPerFetch,
+            onRetry: (error, pendingRetries) => {
+                console.error(`Error fetching file header, pending retries: ${pendingRetries}`, error);
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Error fetching file header: ${response.status} ${response.statusText}`);
+        }
+        const metadata = yield response.json();
+        // Parse size from string to bigint
+        const length = BigInt((_a = metadata.size) !== null && _a !== void 0 ? _a : 0);
+        const compression = (_b = metadata.uploadOptions) === null || _b === void 0 ? void 0 : _b.compression;
+        const encryption = (_c = metadata.uploadOptions) === null || _c === void 0 ? void 0 : _c.encryption;
+        let i = 0;
+        let totalDownloaded = BigInt(0);
+        const precision = Math.pow(10, 4);
+        return {
+            data: new stream_1.Readable({
+                read() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const chunk = yield (0, utils_1.withRetries)(() => getChunk(cid, i++), {
+                            retries: retriesPerFetch,
+                        });
+                        this.push(chunk ? Buffer.from(chunk) : null);
+                        totalDownloaded += BigInt((_a = chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) !== null && _a !== void 0 ? _a : 0);
+                        onProgress === null || onProgress === void 0 ? void 0 : onProgress(Number((BigInt(precision) * totalDownloaded) / length) / precision);
+                    });
+                },
+            }),
+            length,
+            compression,
+            encryption,
+        };
+    });
+    /**
+     * Checks if a file is cached on the gateway
+     * @param cid - The content identifier of the file
+     * @returns A Promise that resolves to true if the file is cached, false otherwise
+     * @throws Error if the file status check fails
+     */
+    const isFileCached = (cid) => __awaiter(void 0, void 0, void 0, function* () {
+        const response = yield authFetch(`${baseUrl}/files/${cid}/status`);
+        if (!response.ok) {
+            throw new Error(`Error checking file status: ${response.status} ${response.statusText}`);
+        }
+        const status = yield response.json();
+        return status.isCached;
+    });
+    const getFileFromCache = (cid) => __awaiter(void 0, void 0, void 0, function* () {
+        const response = yield authFetch(`${baseUrl}/files/${cid}`);
+        if (!response.ok) {
+            throw new Error(`Error fetching file from cache: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error('No body in response');
+        }
+        return (0, asynchronous_1.httpBodyToStream)(response.body);
+    });
+    /**
+     * Fetches a complete file from the API with support for progress tracking and retries
+     * @param cid - The content identifier of the file to fetch
+     * @returns A Promise that resolves to a FetchedFile object containing the file data and metadata
+     * @throws Error if the file metadata fetch fails
+     */
+    const getFile = (cid_1, ...args_1) => __awaiter(void 0, [cid_1, ...args_1], void 0, function* (cid, { retriesPerFetch = 3, onProgress, ignoreCache = false, } = {}) {
+        if (!ignoreCache && (yield isFileCached(cid))) {
+            return getFileFromCache(cid);
+        }
+        const file = yield getChunkedFile(cid, {
+            retriesPerFetch,
+            onProgress,
+        });
+        return file.data;
+    });
+    return { getFile, isFileCached, getChunkedFile };
+};
+exports.createAutoFilesApi = createAutoFilesApi;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './api';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const withRetries: <T>(fn: () => Promise<T>, { retries, delay, onRetry, }?: {
+    retries?: number;
+    delay?: number;
+    onRetry?: (error: Error, pendingRetries: number) => void;
+}) => Promise<T>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,+BAIG;IACD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,IAAI,CAAA;CACpD,eAmBP,CAAA"}

package/dist/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetries = void 0;
+const withRetries = (fn, { retries = 3, delay = 1000, onRetry, } = {}) => {
+    return new Promise((resolve, reject) => {
+        const attempt = () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const result = yield fn();
+                resolve(result);
+            }
+            catch (error) {
+                if (retries > 0) {
+                    onRetry === null || onRetry === void 0 ? void 0 : onRetry(error, retries);
+                    yield new Promise((resolve) => setTimeout(resolve, delay));
+                    attempt();
+                }
+                else {
+                    reject(error);
+                }
+            }
+        });
+        attempt();
+    });
+};
+exports.withRetries = withRetries;

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@autonomys/auto-files",
-  "version": "1.4.34",
+  "version": "1.5.1",
   "packageManager": "yarn@4.7.0",
-  "private": false,
   "scripts": {
     "build": "tsc"
   },
   "devDependencies": {
     "typescript": "^5.5.4"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "require": "./dist/index.js",
@@ -17,6 +21,7 @@
     }
   },
   "dependencies": {
-    "@autonomys/auto-drive": "^1.4.34"
-  }
+    "@autonomys/auto-drive": "^1.5.1"
+  },
+  "gitHead": "91ccdc57a7bc69d3587915ac654b770aba1681a4"
 }

package/src/api.ts

@@ -1,106 +0,0 @@
-import { CompressionOptions, EncryptionOptions } from '@autonomys/auto-drive'
-import { Readable } from 'stream'
-import { withRetries } from './utils'
-
-interface FetchedFile {
-  length: bigint
-  compression: CompressionOptions | undefined
-  encryption: EncryptionOptions | undefined
-  data: Readable
-}
-
-/**
- * Creates an API client for interacting with the Auto Files service
- * @param baseUrl - The base URL of the Auto Files API
- * @param apiSecret - The API secret key for authentication
- * @returns An object containing methods to interact with the API
- */
-export const createAutoFilesApi = (baseUrl: string, apiSecret: string) => {
-  /**
-   * Makes an authenticated fetch request to the API
-   * @param url - The URL to fetch from
-   * @param options - Optional fetch request options
-   * @returns A Promise that resolves to the fetch Response
-   */
-  const authFetch = (url: string, options: RequestInit = {}) => {
-    const urlObj = new URL(url)
-    return fetch(urlObj.toString(), {
-      ...options,
-      headers: { ...options.headers, Authorization: `Bearer ${apiSecret}` },
-    })
-  }
-
-  /**
-   * Fetches a specific chunk of a file from the API
-   * @param cid - The content identifier of the file
-   * @param chunk - The chunk number to fetch
-   * @returns A Promise that resolves to the chunk data as ArrayBuffer, or null if chunk doesn't exist
-   * @throws Error if the chunk fetch fails
-   */
-  const getChunk = async (cid: string, chunk: number): Promise<ArrayBuffer | null> => {
-    const response = await authFetch(`${baseUrl}/files/${cid}/partial?chunk=${chunk}`)
-    if (!response.ok) {
-      throw new Error('Error fetching chunk')
-    }
-
-    if (response.status === 204) {
-      return null
-    }
-
-    const buffer = await response.arrayBuffer()
-    console.log('Chunk download finished:', buffer.byteLength)
-    return buffer
-  }
-
-  /**
-   * Fetches a complete file from the API with support for progress tracking and retries
-   * @param cid - The content identifier of the file to fetch
-   * @param options - Optional configuration for the fetch operation
-   * @param options.retriesPerFetch - Number of retry attempts for failed requests (default: 3)
-   * @param options.onProgress - Optional callback function to track download progress (0-1)
-   * @returns A Promise that resolves to a FetchedFile object containing the file data and metadata
-   * @throws Error if the file metadata fetch fails
-   */
-  const getFile = async (
-    cid: string,
-    {
-      retriesPerFetch = 3,
-      onProgress,
-    }: { retriesPerFetch?: number; onProgress?: (progress: number) => void } = {},
-  ): Promise<FetchedFile> => {
-    const response = await withRetries(
-      () => authFetch(`${baseUrl}/files/${cid}/metadata`),
-      retriesPerFetch,
-    )
-    if (!response.ok) {
-      throw new Error('Error fetching file header')
-    }
-
-    const metadata = await response.json()
-
-    // Parse size from string to bigint
-    const length = BigInt(metadata.size ?? 0)
-
-    const compression = metadata.uploadOptions?.compression
-    const encryption = metadata.uploadOptions?.encryption
-
-    let i = 0
-    let totalDownloaded = BigInt(0)
-    const precision = 10 ** 4
-    return {
-      data: new Readable({
-        async read() {
-          const chunk = await withRetries(() => getChunk(cid, i++), retriesPerFetch)
-          this.push(chunk ? Buffer.from(chunk) : null)
-          totalDownloaded += BigInt(chunk?.byteLength ?? 0)
-          onProgress?.(Number((BigInt(precision) * totalDownloaded) / length) / precision)
-        },
-      }),
-      length,
-      compression,
-      encryption,
-    }
-  }
-
-  return { getFile }
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from './api'

package/src/utils.ts

@@ -1,18 +0,0 @@
-export const withRetries = <T>(fn: () => Promise<T>, retries: number, delay: number = 1000) => {
-  return new Promise<T>((resolve, reject) => {
-    const attempt = async () => {
-      try {
-        const result = await fn()
-        resolve(result)
-      } catch (error) {
-        if (retries > 0) {
-          await new Promise((resolve) => setTimeout(resolve, delay))
-          attempt()
-        } else {
-          reject(error)
-        }
-      }
-    }
-    attempt()
-  })
-}

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "resolveJsonModule": true
-  },
-  "include": ["src"]
-}