@secrecy/lib 1.83.0 → 1.83.2-fix-upload-data-error-handling.1

package/dist/lib/client/SecrecyCloudClient.js

@@ -179,19 +179,24 @@ export class SecrecyCloudClient {
             deleted,
             fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
-        const errors = apiNodes.missingIds.map((id) => `Node ${id} not found`);
-        const decryptedNodes = await Promise.allSettled(apiNodes.nodes.map((node) => apiNodeToExternal(node, this.#client.keyPairs)));
-        const nodes = decryptedNodes
-            .filter((result) => result.status === 'fulfilled')
-            .map((result) => result.value);
-        const errorNodes = decryptedNodes
-            .filter((result) => result.status === 'rejected')
-            .map((result) => result.reason);
-        errors.push(...errorNodes.map((err) => typeof err === 'string'
-            ? err
-            : err instanceof Error
-                ? err.message
-                : JSON.stringify(err)));
+        const errors = apiNodes.missingIds.map((id) => ({
+            message: `Node ${id} not found`,
+            nodeId: id,
+        }));
+        const nodes = [];
+        const handleNode = async (node) => {
+            try {
+                const externalNode = await apiNodeToExternal(node, this.#client.keyPairs);
+                nodes.push(externalNode);
+            }
+            catch (error) {
+                errors.push({
+                    message: error instanceof Error ? error.message : String(error),
+                    nodeId: node.id,
+                });
+            }
+        };
+        await Promise.all(apiNodes.nodes.map(handleNode));
         return { nodes, errors };
     }
     async nodesFull({ ids, deleted, }) {
@@ -200,19 +205,24 @@ export class SecrecyCloudClient {
             deleted,
             fromIdentityPubKey: this.#client.currentIdentity.identityPubKey,
         });
-        const errors = apiNodes.missingIds.map((id) => `Node ${id} not found`);
-        const decryptedNodes = await Promise.allSettled(apiNodes.nodes.map((node) => apiNodeToExternalNodeFull(node, this.#client.keyPairs)));
-        const nodes = decryptedNodes
-            .filter((result) => result.status === 'fulfilled')
-            .map((result) => result.value);
-        const errorNodes = decryptedNodes
-            .filter((result) => result.status === 'rejected')
-            .map((result) => result.reason);
-        errors.push(...errorNodes.map((err) => typeof err === 'string'
-            ? err
-            : err instanceof Error
-                ? err.message
-                : JSON.stringify(err)));
+        const errors = apiNodes.missingIds.map((id) => ({
+            message: `Node ${id} not found`,
+            nodeId: id,
+        }));
+        const nodes = [];
+        const handleNode = async (node) => {
+            try {
+                const externalNode = await apiNodeToExternalNodeFull(node, this.#client.keyPairs);
+                nodes.push(externalNode);
+            }
+            catch (error) {
+                errors.push({
+                    message: error instanceof Error ? error.message : String(error),
+                    nodeId: node.id,
+                });
+            }
+        };
+        await Promise.all(apiNodes.nodes.map(handleNode));
         return { nodes, errors };
     }
     async dataMetadata({ id }) {

package/dist/lib/client/upload.js

@@ -7,7 +7,6 @@ import { dataContentCache } from '../cache.js';
 import { chunks, enumerate } from '../utils/array.js';
 import { getTrpcGuestClient, } from '../client.js';
 import axios from 'axios';
-import { promiseAllLimit } from '../utils/promise.js';
 import { encryptDataAndKey } from '../crypto/domain.js';
 import { derivePassword, generatePassword } from '../crypto/helpers.js';
 import { decryptCryptoBox, encryptSecretBox } from '../crypto/index.js';
@@ -213,13 +212,13 @@ export async function uploadData({ storageType, data, password, forcePassword =
             const formData = new FormData();
             const chunk = chunkParts.find((p) => p.order === part.order);
             if (chunk === undefined) {
-                return;
+                throw new Error(`Unable to find chunk data for part ${part.order} of data ${uploadData.id}`);
             }
             for (const [key, value] of Object.entries(part.fields)) {
                 formData.append(key, value);
             }
             formData.append('file', new Blob([chunk.data], { type: filetype?.mime }), `${uploadData.id}-${chunk.order}`);
-            await axios.post(part.url, formData, {
+            const response = await axios.post(part.url, formData, {
                 onUploadProgress: (progressEvent) => {
                     onProgress(part.order, {
                         percent: progressEvent.progress ?? 0,
@@ -227,12 +226,33 @@ export async function uploadData({ storageType, data, password, forcePassword =
                         transferredBytes: progressEvent.loaded,
                     });
                 },
+                signal,
             });
+            // TODO implement retry etc
+            if (response.status !== 204 && response.status !== 201) {
+                throw new Error(`Failed to upload data part ${part.order} of data ${uploadData.id}`);
+            }
             return uploadDataPartEnd(chunk.md5, chunk.order);
         };
-        await promiseAllLimit(3, uploadData.parts.map((p) => async () => {
-            await byPart(p);
-        }));
+        let lastValidatedCalled = false;
+        for (const part of uploadData.parts) {
+            const res = await byPart(part);
+            if (!res.isUploadPartEnded) {
+                throw new Error(`Failed to confirm upload of part ${part.order} of data ${uploadData.id}`);
+            }
+            if (res.isLastValidatedPart) {
+                lastValidatedCalled = true;
+                await uploadProgress?.({
+                    total: encryptedData.byteLength,
+                    current: encryptedData.byteLength,
+                    percent: 1,
+                });
+                break;
+            }
+        }
+        if (!lastValidatedCalled) {
+            throw new Error(`Failed to validate the last part of data ${uploadData.id}`);
+        }
         const sharing = createSharing({ data: uploadData });
         const localData = {
             id: uploadData.id,

package/dist/lib/crypto/domain.js

@@ -3,7 +3,6 @@ import { secretStreamKeygen } from './data';
 import { encrypt } from '../worker/sodium';
 import ky from 'ky';
 import { md5 } from '../worker/md5.js';
-import { promiseAllLimit } from '../utils/promise.js';
 import { concatenate } from '../utils/array.js';
 /**
  * Encrypt the dataKey and the data as logged or guest user.
@@ -53,7 +52,9 @@ const encryptedContentFromParts = async (arg) => {
         parts[arg.dataId] ??= [];
         parts[arg.dataId].push({ data: buf, order: part.order });
     };
-    await promiseAllLimit(3, arg.dataParts.map((p) => async () => byPart(p)));
+    for (const part of arg.dataParts) {
+        await byPart(part);
+    }
     return concatenate(...parts[arg.dataId].sort((a, b) => a.order - b.order).map((p) => p.data));
 };
 export async function buildBytesFromApiData({ dataContent, totalBytes, progressParts, onDownloadProgress, signal, }) {

package/dist/types/client/SecrecyCloudClient.d.ts

@@ -61,14 +61,20 @@ export declare class SecrecyCloudClient {
         deleted?: boolean | null | undefined;
     }): Promise<{
         nodes: Node[];
-        errors: string[];
+        errors: {
+            message: string;
+            nodeId: string;
+        }[];
     }>;
     nodesFull({ ids, deleted, }: {
         ids: string[];
         deleted?: boolean | null | undefined;
     }): Promise<{
         nodes: NodeFull[];
-        errors: string[];
+        errors: {
+            message: string;
+            nodeId: string;
+        }[];
     }>;
     dataMetadata({ id }: {
         id: string;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@secrecy/lib",
   "author": "Anonymize <anonymize@gmail.com>",
   "description": "Anonymize Secrecy Library",
-  "version": "1.83.0",
+  "version": "1.83.2-fix-upload-data-error-handling.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/anonymize-org/lib.git"

package/dist/lib/utils/promise.js

@@ -1,20 +0,0 @@
-export const promiseAllLimit = async (n, list) => {
-    const head = list.slice(0, n);
-    const tail = list.slice(n);
-    const result = [];
-    const execute = async (promise, i, runNext) => {
-        result[i] = await promise();
-        await runNext();
-    };
-    const runNext = async () => {
-        const i = list.length - tail.length;
-        const promise = tail.shift();
-        if (promise !== undefined) {
-            await execute(promise, i, runNext);
-        }
-    };
-    await Promise.all(head.map(async (promise, i) => {
-        await execute(promise, i, runNext);
-    }));
-    return result;
-};

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

@@ -1 +0,0 @@
-export declare const promiseAllLimit: <T>(n: number, list: Array<() => Promise<T>>) => Promise<T[]>;