@secrecy/lib 1.61.3 → 1.62.0-feat-storage-providers.1

package/dist/lib/client/SecrecyCloudClient.js

@@ -50,7 +50,7 @@ export class SecrecyCloudClient {
         }
         return internalNodeFullToNodeFull(node);
     }
-    async uploadData({ storageType, data, encrypted = true, encryptProgress, uploadProgress, signal, meta, }) {
+    async uploadData({ storage, data, encrypted = true, encryptProgress, uploadProgress, signal, meta, }) {
         const dataBuffer = data instanceof File ? new Uint8Array(await data.arrayBuffer()) : data;
         let filetype;
         if (meta === true) {
@@ -62,7 +62,8 @@ export class SecrecyCloudClient {
         else if (!encrypted) {
             filetype = await fileTypeFromBuffer(dataBuffer);
         }
-        if (storageType === 'lite' && dataBuffer.byteLength > kiloToBytes(1024)) {
+        if (storage.protocol === 'mongo' &&
+            dataBuffer.byteLength > kiloToBytes(1024)) {
             throw new Error('The data is too big for lite upload!');
         }
         const compressed = encrypted ? compress(dataBuffer) : dataBuffer;
@@ -81,11 +82,11 @@ export class SecrecyCloudClient {
             current: 0,
             percent: 0,
         });
-        if (storageType === 'lite') {
+        if (storage.protocol === 'mongo') {
             const uploadDataArgs = encryptedDataKey && md5Encrypted
                 ? {
                     type: 'encrypted',
-                    content: Buffer.from(encryptedData),
+                    bytes: Buffer.from(encryptedData),
                     sizeEncrypted: BigInt(encryptedData.byteLength),
                     size: BigInt(dataBuffer.byteLength),
                     key: sodium.to_hex(encryptedDataKey),
@@ -95,13 +96,13 @@ export class SecrecyCloudClient {
                 }
                 : {
                     type: 'unencrypted',
-                    content: Buffer.from(encryptedData),
+                    bytes: Buffer.from(encryptedData),
                     md5: md5Data,
                     sizeEncrypted: undefined,
                     size: BigInt(dataBuffer.byteLength),
                     ...filetype,
                 };
-            const uploadData = await this.#apiClient.cloud.uploadLiteData.mutate(uploadDataArgs, { signal });
+            const uploadData = await this.#apiClient.cloud.uploadMongoData.mutate(uploadDataArgs, { signal });
             await uploadProgress?.({
                 total: encryptedData.byteLength,
                 current: encryptedData.byteLength,
@@ -109,7 +110,7 @@ export class SecrecyCloudClient {
             });
             const localData = {
                 id: uploadData.id,
-                storageType: 'lite',
+                storage: storage,
                 size: uploadDataArgs.size,
                 sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
                 data: dataBuffer,
@@ -118,7 +119,7 @@ export class SecrecyCloudClient {
             dataContentCache.set(uploadData.id, localData);
             return localData;
         }
-        if (storageType === 's3' || storageType === 'cold') {
+        if (storage.protocol === 's3') {
             const uploadDataArgs = encryptedDataKey && md5Encrypted
                 ? {
                     type: 'encrypted',
@@ -136,7 +137,7 @@ export class SecrecyCloudClient {
                     sizeEncrypted: undefined,
                     ...filetype,
                 };
-            const uploadDataCaller = storageType === 's3'
+            const uploadDataCaller = storage.protocol === 's3'
                 ? this.#apiClient.cloud.uploadData
                 : this.#apiClient.cloud.uploadColdData;
             const uploadData = await uploadDataCaller.mutate(uploadDataArgs, {
@@ -153,7 +154,7 @@ export class SecrecyCloudClient {
                 });
                 const localData = {
                     id: uploadData.id,
-                    storageType: storageType,
+                    storage: storage,
                     size: uploadDataArgs.size,
                     sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
                     data: dataBuffer,
@@ -210,7 +211,7 @@ export class SecrecyCloudClient {
             }));
             const localData = {
                 id: uploadData.id,
-                storageType: storageType,
+                storage: storage,
                 size: uploadDataArgs.size,
                 sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
                 data: dataBuffer,
@@ -219,11 +220,11 @@ export class SecrecyCloudClient {
             dataContentCache.set(uploadData.id, localData);
             return localData;
         }
-        throw new Error(`The "${storageType}" is not implemented yet!`);
+        throw new Error(`Not implemented yet!`);
     }
-    async uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storageType = 's3', signal, }) {
+    async uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storage, signal, }) {
         const uploadedData = await this.uploadData({
-            storageType,
+            storage,
             data,
             encryptProgress,
             uploadProgress,
@@ -397,13 +398,13 @@ export class SecrecyCloudClient {
                 id: data.id,
                 size: data.size,
                 sizeEncrypted: data.sizeEncrypted,
-                storageType: data.storageType,
+                storage: data.storage,
             })),
             ...cachedData.map((data) => ({
                 id: data.id,
                 size: data.size,
                 sizeEncrypted: data.sizeEncrypted,
-                storageType: data.storageType,
+                storage: data.storage,
             })),
         ];
         const allDataContentsBytes = Number(allDataContents.reduce((curr, next) => curr + (next.sizeEncrypted ?? next.size), 0n));
@@ -573,13 +574,18 @@ export class SecrecyCloudClient {
                 : null,
         });
     }
-    async updateDataStorageType(input) {
+    async updateDataStorage(input) {
         const data = dataContentCache.get(input.dataId);
         if (data) {
-            if (data.storageType === input.storageType) {
-                throw new Error(`The data is already on "${data.storageType}`);
+            if (data.storage.protocol === input.protocol &&
+                data.storage.provider === input.provider &&
+                data.storage.mode === input.mode &&
+                data.storage.region === input.region) {
+                throw new Error(`The data is already on "${data.storage}`);
             }
-            if (data.storageType === 'cold' && input.storageType === 'lite') {
+            if (data.storage.protocol === 's3' &&
+                data.storage.mode === 'glacier' &&
+                input.protocol === 'mongo') {
                 throw new Error("It's not possible to transfer a cold stored data to a lite storage!");
             }
         }
@@ -641,19 +647,25 @@ export class SecrecyCloudClient {
                 .sort((a, b) => a.order - b.order)
                 .map((p) => p.data));
         };
-        const encryptedContent = dataContent.type === 'lite'
-            ? new Uint8Array(dataContent.content)
-            : dataContent.type === 'cloud'
+        const encryptedContent = dataContent.type === 'mongo'
+            ? new Uint8Array(dataContent.bytes)
+            : dataContent.type === 's3'
                 ? await encryptedContentFromParts({
                     dataId: dataContent.id,
-                    dataParts: dataContent.parts,
+                    dataParts: dataContent.parts.map(({ url, ...part }) => ({
+                        ...part,
+                        contentUrl: url,
+                    })),
                 })
-                : dataContent.maybeContent !== null
-                    ? new Uint8Array(dataContent.maybeContent)
+                : dataContent.maybeBytes !== null
+                    ? new Uint8Array(dataContent.maybeBytes)
                     : dataContent.maybeParts !== null
                         ? await encryptedContentFromParts({
                             dataId: dataContent.id,
-                            dataParts: dataContent.maybeParts,
+                            dataParts: dataContent.maybeParts.map(({ url, ...part }) => ({
+                                ...part,
+                                contentUrl: url,
+                            })),
                         })
                         : null;
         if (encryptedContent === null) {
@@ -666,7 +678,7 @@ export class SecrecyCloudClient {
         const key = dataContent.key
             ? decryptCryptoBox(sodium.from_hex(dataContent.key), dataContent.type === 'received_mail'
                 ? dataContent.senderPublicKey
-                : dataContent.type === 'cloud'
+                : dataContent.type === 's3'
                     ? dataContent.publicKey
                     : this.#keys.publicKey, this.#keys.privateKey)
             : null;
@@ -678,11 +690,20 @@ export class SecrecyCloudClient {
             throw new Error(`Content does not match`);
         }
         const decompressed = decompress(src);
+        const storageOptions = dataContent.storage.protocol === 'mongo'
+            ? dataContent.storage.mongoStorageOptions
+            : dataContent.storage.s3StorageOptions;
+        const storage = {
+            protocol: dataContent.storage.protocol,
+            provider: dataContent.storage.provider,
+            mode: storageOptions.mode,
+            region: storageOptions.region,
+        };
         dataContentCache.set(dataContent.id, {
             id: dataContent.id,
             size: dataContent.size,
             sizeEncrypted: dataContent.sizeEncrypted,
-            storageType: dataContent.storageType,
+            storage: storage,
             data: decompressed,
             mime: dataContent.mime ?? undefined,
             ext: dataContent.ext ?? undefined,
@@ -691,7 +712,7 @@ export class SecrecyCloudClient {
             id: dataContent.id,
             size: dataContent.size,
             sizeEncrypted: dataContent.sizeEncrypted,
-            storageType: dataContent.storageType,
+            storage: storage,
             data: decompressed,
             mime: dataContent.mime ?? undefined,
             ext: dataContent.ext ?? undefined,

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

@@ -1,5 +1,5 @@
 import type { ProgressCallback, SecrecyClient } from '../index.js';
-import type { DataMetadata, DataStorageType, KeyPair, LocalData, Node, NodeFull, NodeType, Rights } from './types/index.js';
+import type { DataMetadata, DataStorageInput, KeyPair, LocalData, Node, NodeFull, NodeType, Rights } from './types/index.js';
 import { type RouterInputs, type ApiClient, type RouterOutputs } from '../client.js';
 import { type DownloadProgress } from '../types.js';
 import { FileTypeResult } from 'file-type';
@@ -10,8 +10,8 @@ export declare class SecrecyCloudClient {
         dataId: string;
         nodeId: string;
     }): Promise<NodeFull>;
-    uploadData({ storageType, data, encrypted, encryptProgress, uploadProgress, signal, meta, }: {
-        storageType: DataStorageType;
+    uploadData({ storage, data, encrypted, encryptProgress, uploadProgress, signal, meta, }: {
+        storage: DataStorageInput;
         data: globalThis.File | Uint8Array;
         encrypted?: boolean;
         encryptProgress?: ProgressCallback;
@@ -19,14 +19,14 @@ export declare class SecrecyCloudClient {
         signal?: AbortSignal;
         meta?: FileTypeResult | true;
     }): Promise<LocalData>;
-    uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storageType, signal, }: {
+    uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storage, signal, }: {
         data: globalThis.File | Uint8Array;
         name: string;
         nodeId?: string;
         encryptProgress?: ProgressCallback;
         uploadProgress?: ProgressCallback;
         signal?: AbortSignal;
-        storageType?: DataStorageType;
+        storage: DataStorageInput;
     }): Promise<NodeFull>;
     deletedNodes(): Promise<Node[]>;
     sharedNodes(): Promise<Node[]>;
@@ -102,10 +102,14 @@ export declare class SecrecyCloudClient {
     }): Promise<NodeFull>;
     private readonly perNode;
     reportData({ id, reasons, }: Omit<RouterInputs['cloud']['reportData'], 'encryptedDataKey'>): Promise<RouterOutputs['cloud']['reportData']>;
-    updateDataStorageType(input: RouterInputs['cloud']['moveToStorageType']): Promise<{
+    updateDataStorage(input: RouterInputs['cloud']['moveToStorageType']): Promise<{
         isMoved: boolean;
-        fromType: "s3" | "cold" | "lite";
-        toType: "s3" | "cold" | "lite";
+        fromProtocol?: "s3" | "mongo" | undefined;
+        fromMode?: "standard" | "glacier" | undefined;
+        fromRegion?: string | undefined;
+        toProtocol?: "s3" | "mongo" | undefined;
+        toMode?: "standard" | "glacier" | undefined;
+        toRegion?: string | undefined;
     }>;
     getPublicDataLink(input: RouterInputs['cloud']['dataLink']): Promise<{
         name: string;

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

@@ -1,10 +1,23 @@
 import { type RouterOutputs } from '../../client.js';
 export type ApiData = NonNullable<RouterOutputs['cloud']['dataById']>;
-export type ApiExtendedData = NonNullable<RouterOutputs['cloud']['dataContentByIds'][number]>;
-export type DataStorageType = ApiData['storageType'];
+export type ApiExtendedData = NonNullable<RouterOutputs['cloud']['dataContentById']>;
+export type DataStorageInput = {
+    protocol: 's3';
+    provider: 'scaleway' | 'ovh';
+    mode: 'standard' | 'glacier';
+    region: string;
+} | {
+    protocol: 'mongo';
+    provider: 'secrecy';
+    mode: 'standard';
+    region: string;
+};
+export type DataStorage = ApiData['storage'];
+export type DataStorageProtocol = ApiData['storage']['protocol'];
+export type DataStorageProvider = ApiData['storage']['provider'];
 export type LocalData = {
     id: string;
-    storageType: DataStorageType;
+    storage: DataStorageInput;
     size: bigint;
     sizeEncrypted: bigint | null;
     data: Uint8Array;