@autonomys/auto-drive 1.0.3 → 1.0.4

package/dist/api/models/uploads.d.ts

@@ -0,0 +1,117 @@
+import { FileUploadOptions } from '@autonomys/auto-dag-data';
+import { z } from 'zod';
+export declare enum UploadType {
+    FILE = "file",
+    FOLDER = "folder"
+}
+export declare enum UploadStatus {
+    PENDING = "pending",
+    COMPLETED = "completed",
+    MIGRATING = "migrating",
+    CANCELLED = "cancelled",
+    FAILED = "failed"
+}
+export declare const fileUploadSchema: z.ZodObject<{
+    id: z.ZodString;
+    rootId: z.ZodString;
+    relativeId: z.ZodNullable<z.ZodString>;
+    type: z.ZodNativeEnum<typeof UploadType>;
+    status: z.ZodNativeEnum<typeof UploadStatus>;
+    fileTree: z.ZodNull;
+    name: z.ZodString;
+    mimeType: z.ZodNullable<z.ZodString>;
+    oauthProvider: z.ZodString;
+    oauthUserId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: null;
+    mimeType: string | null;
+    oauthProvider: string;
+    oauthUserId: string;
+}, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: null;
+    mimeType: string | null;
+    oauthProvider: string;
+    oauthUserId: string;
+}>;
+export type FileUpload = z.infer<typeof fileUploadSchema> & {
+    uploadOptions: FileUploadOptions | null;
+};
+export declare const folderUploadSchema: z.ZodObject<{
+    id: z.ZodString;
+    rootId: z.ZodString;
+    relativeId: z.ZodNullable<z.ZodString>;
+    type: z.ZodNativeEnum<typeof UploadType>;
+    status: z.ZodNativeEnum<typeof UploadStatus>;
+    fileTree: z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"folder">;
+        children: z.ZodArray<z.ZodLazy<z.ZodType<import("./folderTree.js").FolderTree, z.ZodTypeDef, import("./folderTree.js").FolderTree>>, "many">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    }, {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    }>;
+    name: z.ZodString;
+    mimeType: z.ZodNull;
+    oauthProvider: z.ZodString;
+    oauthUserId: z.ZodString;
+    uploadOptions: z.ZodNull;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    };
+    mimeType: null;
+    oauthProvider: string;
+    oauthUserId: string;
+    uploadOptions: null;
+}, {
+    name: string;
+    type: UploadType;
+    status: UploadStatus;
+    id: string;
+    rootId: string;
+    relativeId: string | null;
+    fileTree: {
+        children: import("./folderTree.js").FolderTree[];
+        name: string;
+        type: "folder";
+        id: string;
+    };
+    mimeType: null;
+    oauthProvider: string;
+    oauthUserId: string;
+    uploadOptions: null;
+}>;
+export type FolderUpload = z.infer<typeof folderUploadSchema>;
+export type CompleteUploadResponse = {
+    cid: string;
+};
+//# sourceMappingURL=uploads.d.ts.map

package/dist/api/models/uploads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.d.ts","sourceRoot":"","sources":["../../../src/api/models/uploads.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,oBAAY,UAAU;IACpB,IAAI,SAAS;IACb,MAAM,WAAW;CAClB;AAED,oBAAY,YAAY;IACtB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,MAAM,WAAW;CAClB;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,GAAG;IAC1D,aAAa,EAAE,iBAAiB,GAAG,IAAI,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA"}

package/dist/api/models/uploads.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { FolderTreeFolderSchema } from './folderTree.js';
+export var UploadType;
+(function (UploadType) {
+    UploadType["FILE"] = "file";
+    UploadType["FOLDER"] = "folder";
+})(UploadType || (UploadType = {}));
+export var UploadStatus;
+(function (UploadStatus) {
+    UploadStatus["PENDING"] = "pending";
+    UploadStatus["COMPLETED"] = "completed";
+    UploadStatus["MIGRATING"] = "migrating";
+    UploadStatus["CANCELLED"] = "cancelled";
+    UploadStatus["FAILED"] = "failed";
+})(UploadStatus || (UploadStatus = {}));
+export const fileUploadSchema = z.object({
+    id: z.string(),
+    rootId: z.string(),
+    relativeId: z.string().nullable(),
+    type: z.nativeEnum(UploadType),
+    status: z.nativeEnum(UploadStatus),
+    fileTree: z.null(),
+    name: z.string(),
+    mimeType: z.string().nullable(),
+    oauthProvider: z.string(),
+    oauthUserId: z.string(),
+});
+export const folderUploadSchema = z.object({
+    id: z.string(),
+    rootId: z.string(),
+    relativeId: z.string().nullable(),
+    type: z.nativeEnum(UploadType),
+    status: z.nativeEnum(UploadStatus),
+    fileTree: FolderTreeFolderSchema,
+    name: z.string(),
+    mimeType: z.null(),
+    oauthProvider: z.string(),
+    oauthUserId: z.string(),
+    uploadOptions: z.null(),
+});

package/dist/{cjs/api → api}/wrappers.d.ts

@@ -1,3 +1,4 @@
+import { CID } from '@autonomys/auto-dag-data';
 import { AutoDriveApi } from './connection.js';
 type UploadFileOptions = {
     password?: string;
@@ -19,7 +20,7 @@ type UploadFileOptions = {
  * @returns {Promise<void>} - A promise that resolves when the upload is complete.
  * @throws {Error} - Throws an error if the upload fails at any stage.
  */
-export declare const uploadFile: (api: AutoDriveApi, filePath: string, { password, compression }: UploadFileOptions, uploadChunkSize?: number) => Promise<void>;
+export declare const uploadFile: (api: AutoDriveApi, filePath: string, { password, compression }: UploadFileOptions, uploadChunkSize?: number) => Promise<CID>;
 /**
  * Uploads an entire folder to the server.
  *
@@ -33,7 +34,7 @@ export declare const uploadFile: (api: AutoDriveApi, filePath: string, { passwor
  * @returns {Promise<void>} - A promise that resolves when the folder upload is complete.
  * @throws {Error} - Throws an error if the upload fails at any stage.
  */
-export declare const uploadFolder: (api: AutoDriveApi, folderPath: string, uploadChunkSize?: number) => Promise<void>;
+export declare const uploadFolder: (api: AutoDriveApi, folderPath: string, uploadChunkSize?: number) => Promise<CID>;
 /**
  * Uploads a file within an existing folder upload session.
  *
@@ -43,7 +44,7 @@ export declare const uploadFolder: (api: AutoDriveApi, folderPath: string, uploa
  *
  * @returns {Promise<void>} A promise that resolves when the file upload is complete.
  */
-export declare const uploadFileWithinFolderUpload: (api: AutoDriveApi, uploadId: string, filepath: string, uploadChunkSize?: number) => Promise<void>;
+export declare const uploadFileWithinFolderUpload: (api: AutoDriveApi, uploadId: string, filepath: string, uploadChunkSize?: number) => Promise<CID>;
 /**
  * Downloads a file from the AutoDrive service.
  *
@@ -64,3 +65,4 @@ export declare const downloadFile: (api: AutoDriveApi, cid: string, password?: s
  */
 export declare const downloadFolderWithoutEncryption: (api: AutoDriveApi, cid: string) => Promise<ReadableStream<Uint8Array>>;
 export {};
+//# sourceMappingURL=wrappers.d.ts.map

package/dist/api/wrappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrappers.d.ts","sourceRoot":"","sources":["../../src/api/wrappers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EAQJ,MAAM,0BAA0B,CAAA;AAcjC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAG9C,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAiBD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,QAChB,YAAY,YACP,MAAM,6BACkB,iBAAiB,oBACjC,MAAM,KACvB,OAAO,CAAC,GAAG,CAwCb,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,QAClB,YAAY,cACL,MAAM,oBACA,MAAM,KACvB,OAAO,CAAC,GAAG,CAsBb,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,QAClC,YAAY,YACP,MAAM,YACN,MAAM,oBACE,MAAM,KACvB,OAAO,CAAC,GAAG,CAeb,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,QAClB,YAAY,OACZ,MAAM,aACA,MAAM,KAChB,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAoB/B,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B,QACrC,YAAY,OACZ,MAAM,KACV,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CASpC,CAAA"}

package/dist/api/wrappers.js

@@ -0,0 +1,192 @@
+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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { compressFile, CompressionAlgorithm, decompressFile, decryptFile, encryptFile, EncryptionAlgorithm, stringToCid, } from '@autonomys/auto-dag-data';
+import fs from 'fs';
+import mime from 'mime-types';
+import { asyncByChunk, asyncFromStream } from '../utils/async.js';
+import { getFiles } from '../utils/folder.js';
+import { completeUpload, createFileUpload, createFileUploadWithinFolderUpload, createFolderUpload, downloadObject, getObjectMetadata, uploadFileChunk, } from './calls/index.js';
+import { constructFromFileSystemEntries } from './models/folderTree.js';
+const UPLOAD_FILE_CHUNK_SIZE = 1024 * 1024;
+const uploadFileChunks = (api_1, fileUploadId_1, asyncIterable_1, ...args_1) => __awaiter(void 0, [api_1, fileUploadId_1, asyncIterable_1, ...args_1], void 0, function* (api, fileUploadId, asyncIterable, uploadChunkSize = UPLOAD_FILE_CHUNK_SIZE) {
+    var _a, e_1, _b, _c;
+    let index = 0;
+    try {
+        for (var _d = true, _e = __asyncValues(asyncByChunk(asyncIterable, uploadChunkSize)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+            _c = _f.value;
+            _d = false;
+            const chunk = _c;
+            yield uploadFileChunk(api, { uploadId: fileUploadId, chunk, index });
+            index++;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+});
+/**
+ * Uploads a file to the server with optional encryption and compression.
+ *
+ * This function reads a file from the specified file path, optionally encrypts it
+ * using the provided password, and compresses it using the ZLIB algorithm if specified.
+ * It then uploads the file in chunks to the server, creating an upload session and
+ * completing it once all chunks have been uploaded.
+ *
+ * @param {AutoDriveApi} api - The API instance used to send requests.
+ * @param {string} filePath - The path to the file to be uploaded.
+ * @param {UploadFileOptions} options - Options for the upload process.
+ * @param {string} [options.password] - The password for encryption (optional).
+ * @param {boolean} [options.compression=true] - Whether to compress the file (optional).
+ * @returns {Promise<void>} - A promise that resolves when the upload is complete.
+ * @throws {Error} - Throws an error if the upload fails at any stage.
+ */
+export const uploadFile = (api_1, filePath_1, _a, uploadChunkSize_1) => __awaiter(void 0, [api_1, filePath_1, _a, uploadChunkSize_1], void 0, function* (api, filePath, { password, compression = true }, uploadChunkSize) {
+    let asyncIterable = fs.createReadStream(filePath);
+    if (compression) {
+        asyncIterable = compressFile(asyncIterable, {
+            level: 9,
+            algorithm: CompressionAlgorithm.ZLIB,
+        });
+    }
+    if (password) {
+        asyncIterable = encryptFile(asyncIterable, password, {
+            algorithm: EncryptionAlgorithm.AES_256_GCM,
+        });
+    }
+    const uploadOptions = {
+        compression: compression
+            ? {
+                level: 9,
+                algorithm: CompressionAlgorithm.ZLIB,
+            }
+            : undefined,
+        encryption: password
+            ? {
+                algorithm: EncryptionAlgorithm.AES_256_GCM,
+            }
+            : undefined,
+    };
+    const fileUpload = yield createFileUpload(api, {
+        mimeType: mime.lookup(filePath) || undefined,
+        filename: filePath.split('/').pop(),
+        uploadOptions,
+    });
+    yield uploadFileChunks(api, fileUpload.id, asyncIterable, uploadChunkSize);
+    const result = yield completeUpload(api, { uploadId: fileUpload.id });
+    return stringToCid(result.cid);
+});
+/**
+ * Uploads an entire folder to the server.
+ *
+ * This function retrieves all files within the specified folder,
+ * constructs a file tree representation, and initiates the upload
+ * process. It also handles optional compression of the files during
+ * the upload.
+ *
+ * @param {AutoDriveApi} api - The API instance used to send requests.
+ * @param {string} folderPath - The path of the folder to be uploaded.
+ * @returns {Promise<void>} - A promise that resolves when the folder upload is complete.
+ * @throws {Error} - Throws an error if the upload fails at any stage.
+ */
+export const uploadFolder = (api, folderPath, uploadChunkSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const files = yield getFiles(folderPath);
+    const fileTree = constructFromFileSystemEntries(files);
+    const folderUpload = yield createFolderUpload(api, {
+        fileTree,
+        uploadOptions: {
+            compression: {
+                algorithm: CompressionAlgorithm.ZLIB,
+                level: 9,
+            },
+        },
+    });
+    for (const file of files) {
+        yield uploadFileWithinFolderUpload(api, folderUpload.id, file, uploadChunkSize);
+    }
+    const result = yield completeUpload(api, { uploadId: folderUpload.id });
+    return stringToCid(result.cid);
+});
+/**
+ * Uploads a file within an existing folder upload session.
+ *
+ * @param {AutoDriveApi} api - The API instance to interact with the AutoDrive service.
+ * @param {string} uploadId - The ID of the folder upload session to which the file will be added.
+ * @param {string} filepath - The path of the file to be uploaded.
+ *
+ * @returns {Promise<void>} A promise that resolves when the file upload is complete.
+ */
+export const uploadFileWithinFolderUpload = (api, uploadId, filepath, uploadChunkSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const name = filepath.split('/').pop();
+    const fileUpload = yield createFileUploadWithinFolderUpload(api, {
+        uploadId,
+        name,
+        mimeType: mime.lookup(name) || undefined,
+        relativeId: filepath,
+        uploadOptions: {},
+    });
+    yield uploadFileChunks(api, fileUpload.id, fs.createReadStream(filepath), uploadChunkSize);
+    const result = yield completeUpload(api, { uploadId: fileUpload.id });
+    return stringToCid(result.cid);
+});
+/**
+ * Downloads a file from the AutoDrive service.
+ *
+ * @param {AutoDriveApi} api - The API instance to interact with the AutoDrive service.
+ * @param {string} cid - The CID of the file to be downloaded.
+ * @returns {Promise<ReadableStream<Uint8Array>>} A promise that resolves to a ReadableStream of the downloaded file.
+ */
+export const downloadFile = (api, cid, password) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const metadata = yield getObjectMetadata(api, { cid });
+    let iterable = asyncFromStream(yield downloadObject(api, { cid }));
+    if ((_a = metadata.uploadOptions) === null || _a === void 0 ? void 0 : _a.encryption) {
+        if (!password) {
+            throw new Error('Password is required to decrypt the file');
+        }
+        iterable = decryptFile(iterable, password, {
+            algorithm: EncryptionAlgorithm.AES_256_GCM,
+        });
+    }
+    if ((_b = metadata.uploadOptions) === null || _b === void 0 ? void 0 : _b.compression) {
+        iterable = decompressFile(iterable, {
+            algorithm: CompressionAlgorithm.ZLIB,
+        });
+    }
+    return iterable;
+});
+/**
+ * Downloads a folder from the AutoDrive service without encryption.
+ *
+ * @param {AutoDriveApi} api - The API instance to interact with the AutoDrive service.
+ * @param {string} cid - The CID of the folder to be downloaded.
+ *
+ * @returns {Promise<ReadableStream<Uint8Array>>} A promise that resolves to a ReadableStream of the downloaded folder.
+ *
+ * @warning If the folder is encrypted, a warning will be logged, but the download will proceed without decryption.
+ */
+export const downloadFolderWithoutEncryption = (api, cid) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const metadata = yield getObjectMetadata(api, { cid });
+    if ((_a = metadata.uploadOptions) === null || _a === void 0 ? void 0 : _a.encryption) {
+        console.warn('Downloading encrypted folder. Folder support encryption but it is not recommended.');
+    }
+    return downloadObject(api, { cid });
+});

package/dist/{esm/index.d.ts → index.d.ts}

@@ -1,2 +1,3 @@
 export * from './api/index.js';
 export * from './utils/index.js';
+//# 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,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA"}

package/dist/{cjs/utils → utils}/async.d.ts

@@ -1,2 +1,3 @@
 export declare const asyncByChunk: (asyncIterable: AsyncIterable<Buffer>, chunkSize: number) => AsyncGenerator<Buffer, void, unknown>;
 export declare const asyncFromStream: (stream: ReadableStream<Uint8Array>) => AsyncIterable<Buffer>;
+//# sourceMappingURL=async.d.ts.map

package/dist/utils/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/utils/async.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,kBACR,aAAa,CAAC,MAAM,CAAC,aACzB,MAAM,0CAelB,CAAA;AAED,eAAO,MAAM,eAAe,WAClB,cAAc,CAAC,UAAU,CAAC,KACjC,aAAa,CAAC,MAAM,CAOtB,CAAA"}

package/dist/utils/async.js

@@ -0,0 +1,58 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+export const asyncByChunk = function (asyncIterable, chunkSize) {
+    return __asyncGenerator(this, arguments, function* () {
+        var _a, e_1, _b, _c;
+        let buffer = Buffer.alloc(0);
+        try {
+            for (var _d = true, asyncIterable_1 = __asyncValues(asyncIterable), asyncIterable_1_1; asyncIterable_1_1 = yield __await(asyncIterable_1.next()), _a = asyncIterable_1_1.done, !_a; _d = true) {
+                _c = asyncIterable_1_1.value;
+                _d = false;
+                const chunk = _c;
+                buffer = Buffer.concat([buffer, chunk]);
+                while (buffer.length >= chunkSize) {
+                    yield yield __await(buffer.subarray(0, chunkSize));
+                    buffer = buffer.subarray(chunkSize);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = asyncIterable_1.return)) yield __await(_b.call(asyncIterable_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (buffer.length > 0) {
+            yield yield __await(buffer);
+        }
+    });
+};
+export const asyncFromStream = function (stream) {
+    return __asyncGenerator(this, arguments, function* () {
+        const reader = stream.getReader();
+        let result = yield __await(reader.read());
+        while (!result.done) {
+            yield yield __await(Buffer.from(result.value));
+            result = yield __await(reader.read());
+        }
+    });
+};

package/dist/{cjs/utils → utils}/folder.d.ts

@@ -1 +1,2 @@
 export declare const getFiles: (folderPath: string) => Promise<string[]>;
+//# sourceMappingURL=folder.d.ts.map

package/dist/utils/folder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder.d.ts","sourceRoot":"","sources":["../../src/utils/folder.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,eAAsB,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAWnE,CAAA"}

package/dist/utils/folder.js

@@ -0,0 +1,23 @@
+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());
+    });
+};
+import fs from 'fs/promises';
+import path from 'path';
+export const getFiles = (folderPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const stat = yield fs.stat(folderPath);
+    if (stat.isDirectory()) {
+        const files = yield fs.readdir(folderPath);
+        const promises = files.map((file) => getFiles(path.join(folderPath, file)));
+        const allFiles = yield Promise.all(promises);
+        return allFiles.flat();
+    }
+    else {
+        return [folderPath];
+    }
+});

package/dist/{esm/utils → utils}/index.d.ts

@@ -2,3 +2,4 @@ export * from './async.js';
 export * from './folder.js';
 export * from './stream.js';
 export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

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

package/dist/{cjs/utils → utils}/stream.d.ts

@@ -1,2 +1,3 @@
 import { WriteStream } from 'fs';
 export declare const createWriteStreamAdapter: (nodeWriteStream: WriteStream) => WritableStream<Uint8Array>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/utils/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/utils/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,IAAI,CAAA;AAEhC,eAAO,MAAM,wBAAwB,oBAClB,WAAW,KAC3B,cAAc,CAAC,UAAU,CAoB3B,CAAA"}

package/dist/utils/stream.js

@@ -0,0 +1,22 @@
+export const createWriteStreamAdapter = (nodeWriteStream) => {
+    return new WritableStream({
+        write(chunk) {
+            return new Promise((resolve, reject) => {
+                nodeWriteStream.write(chunk, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        },
+        close() {
+            nodeWriteStream.end();
+        },
+        abort(err) {
+            nodeWriteStream.destroy(err);
+        },
+    });
+};

package/dist/{cjs/utils → utils}/types.d.ts

@@ -3,3 +3,4 @@ export type ArgsWithPagination<T = {}> = T & {
     offset: number;
 };
 export type ArgsWithoutPagination<T = {}> = T;
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,qBAAqB,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA"}

package/dist/utils/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -3,7 +3,7 @@
   "packageManager": "yarn@4.2.2",
   "type": "module",
   "main": "dist/index.js",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "author": {
     "name": "Autonomys",
     "url": "https://autonomys.net"
@@ -16,9 +16,9 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@autonomys/auto-dag-data": "^1.0.3",
+    "@autonomys/auto-dag-data": "^1.0.4",
     "mime-types": "^2.1.35",
     "zod": "^3.23.8"
   },
-  "gitHead": "15b7535a4e4f0ff7d66b20941b76dcf6a3e56005"
+  "gitHead": "7cf7c4940f48d88322bdfc2ab6e1e28d34dd396a"
 }

package/dist/cjs/api/connection.d.ts

@@ -1,7 +0,0 @@
-export interface AutoDriveApi {
-    sendRequest: (relativeUrl: string, request: Partial<Request>, body?: BodyInit) => Promise<Response>;
-}
-export declare const createAutoDriveApi: ({ apiKey, url, }: {
-    apiKey: string;
-    url?: string;
-}) => AutoDriveApi;

package/dist/cjs/api/models/folderTree.d.ts

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-export type FolderTreeFolder = {
-    name: string;
-    type: 'folder';
-    children: FolderTree[];
-    id: string;
-};
-export type FolderTreeFile = {
-    name: string;
-    type: 'file';
-    id: string;
-};
-export type FolderTree = FolderTreeFolder | FolderTreeFile;
-export declare const FolderTreeFolderSchema: any;
-export declare const FolderTreeFileSchema: z.ZodObject<{
-    name: z.ZodString;
-    type: z.ZodLiteral<"file">;
-    id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name?: string;
-    type?: "file";
-    id?: string;
-}, {
-    name?: string;
-    type?: "file";
-    id?: string;
-}>;
-export declare const FolderTreeSchema: any;
-export declare const constructFromFileSystemEntries: (entries: string[]) => FolderTree;