Merge pull request #51 from internxt/feat/pb-1339-upload-webdav-content

[PB-1339]: Feat/Upload webdav content

package.json

@@ -44,6 +44,7 @@
     "express-basic-auth": "^1.2.1",
     "fast-xml-parser": "^4.3.5",
     "mime-types": "^2.1.35",
+    "node-fetch": "2",
     "openpgp": "^5.11.1",
     "pm2": "^5.3.1",
     "realm": "^12.6.2",
@@ -60,6 +61,7 @@
     "@types/mime-types": "^2.1.4",
     "@types/mocha": "^10",
     "@types/node": "^18",
+    "@types/node-fetch": "^2.6.11",
     "@types/sinon-chai": "^3.2.12",
     "@types/sinon-express-mock": "^1.3.12",
     "@types/superagent": "^8.1.3",

src/commands/upload.ts

@@ -11,7 +11,6 @@ import { DriveFileService } from '../services/drive/drive-file.service';
 import { UploadService } from '../services/network/upload.service';
 import { CryptoService } from '../services/crypto.service';
 import { DownloadService } from '../services/network/download.service';
-import { StreamUtils } from '../utils/stream.utils';
 import { ErrorUtils } from '../utils/errors.utils';
 import { DriveFolderService } from '../services/drive/drive-folder.service';
 
@@ -76,7 +75,7 @@ export default class Upload extends Command {
       user.bucket,
       mnemonic,
       stat.size,
-      StreamUtils.readStreamToReadableStream(fileStream),
+      fileStream,
       {
         progressCallback: (progress) => {
           progressBar.update(progress);

src/services/auth.service.ts

@@ -5,6 +5,7 @@ import { CryptoService } from './crypto.service';
 import { ConfigService } from './config.service';
 import { LoginCredentials } from '../types/command.types';
 import { ValidationService } from './validation.service';
+import { UserSettings } from '@internxt/sdk/dist/shared/types/userSettings';
 
 export class AuthService {
   public static readonly instance: AuthService = new AuthService();
@@ -88,7 +89,12 @@ export class AuthService {
    *
    * @returns The user plain mnemonic and the auth tokens
    */
-  public getAuthDetails = async (): Promise<{ token: string; newToken: string; mnemonic: string }> => {
+  public getAuthDetails = async (): Promise<{
+    token: string;
+    newToken: string;
+    mnemonic: string;
+    user: UserSettings;
+  }> => {
     const loginCredentials = await ConfigService.instance.readUser();
     if (!loginCredentials) {
       throw new Error('Credentials not found, please login first');
@@ -116,6 +122,7 @@ export class AuthService {
       token,
       newToken,
       mnemonic,
+      user: loginCredentials.user,
     };
   };
 }

src/services/crypto.service.ts

@@ -1,9 +1,10 @@
 import { CryptoProvider } from '@internxt/sdk';
 import { Keys, Password } from '@internxt/sdk/dist/auth';
-import crypto, { Cipher, createCipheriv, createDecipheriv, createHash } from 'crypto';
+import crypto, { createCipheriv, createDecipheriv } from 'node:crypto';
 import { KeysService } from './keys.service';
 import { ConfigService } from '../services/config.service';
 import { StreamUtils } from '../utils/stream.utils';
+import { Transform } from 'stream';
 
 export class CryptoService {
   public static readonly instance: CryptoService = new CryptoService();
@@ -109,29 +110,6 @@ export class CryptoService {
     return Buffer.concat([decipher.update(contentsToDecrypt), decipher.final()]).toString('utf8');
   };
 
-  private encryptReadable(readable: ReadableStream<Uint8Array>, cipher: Cipher): ReadableStream<Uint8Array> {
-    const reader = readable.getReader();
-
-    const encryptedFileReadable = new ReadableStream({
-      async start(controller) {
-        let done = false;
-
-        while (!done) {
-          const status = await reader.read();
-
-          if (!status.done) {
-            controller.enqueue(cipher.update(status.value));
-          }
-
-          done = status.done;
-        }
-        controller.close();
-      },
-    });
-
-    return encryptedFileReadable;
-  }
-
   public async decryptStream(inputSlices: ReadableStream<Uint8Array>[], key: Buffer, iv: Buffer) {
     const decipher = createDecipheriv('aes-256-ctr', key, iv);
     const encryptedStream = StreamUtils.joinReadableBinaryStreams(inputSlices);
@@ -161,36 +139,11 @@ export class CryptoService {
     return decryptedStream;
   }
 
-  public async encryptStream(
-    input: ReadableStream<Uint8Array>,
-    key: Buffer,
-    iv: Buffer,
-  ): Promise<{ blob: Blob; hash: Buffer }> {
+  public async getEncryptionTransform(key: Buffer, iv: Buffer): Promise<Transform> {
     const cipher = createCipheriv('aes-256-ctr', key, iv);
 
-    const readable = this.encryptReadable(input, cipher).getReader();
-    const hasher = createHash('sha256');
-    const blobParts: ArrayBuffer[] = [];
-
-    let done = false;
-
-    while (!done) {
-      const status = await readable.read();
-
-      if (!status.done) {
-        hasher.update(status.value);
-        blobParts.push(status.value);
-      }
-
-      done = status.done;
-    }
-
-    return {
-      blob: new Blob(blobParts, { type: 'application/octet-stream' }),
-      hash: createHash('ripemd160').update(Buffer.from(hasher.digest())).digest(),
-    };
+    return cipher;
   }
-
   /**
    * Generates the key and the iv by transforming a secret and a salt.
    * It will generate the same key and iv if the same secret and salt is used.

src/services/drive/drive-file.service.ts

@@ -36,7 +36,7 @@ export class DriveFileService {
     });
 
     return {
-      size: driveFile.size,
+      size: Number(driveFile.size),
       uuid: driveFile.uuid,
       encryptedName,
       name: payload.name,

src/services/network/network-facade.service.ts

@@ -15,6 +15,9 @@ import { CryptoService } from '../crypto.service';
 import { UploadService } from './upload.service';
 import { DownloadService } from './download.service';
 import { ValidationService } from '../validation.service';
+import { Readable } from 'node:stream';
+import { Transform } from 'stream';
+import { HashStream } from '../../utils/hash.utils';
 
 export class NetworkFacade {
   private readonly cryptoLib: Network.Crypto;
@@ -122,12 +125,13 @@ export class NetworkFacade {
     bucketId: string,
     mnemonic: string,
     size: number,
-    from: ReadableStream<Uint8Array>,
+    from: Readable,
     options?: UploadOptions,
   ): Promise<[Promise<{ fileId: string; hash: Buffer }>, AbortController]> {
+    const hashStream = new HashStream();
     const abortable = options?.abortController ?? new AbortController();
     let fileHash: Buffer;
-    let encryptedBlob: Blob;
+    let encryptionTransform: Transform;
 
     const onProgress: UploadProgressCallback = (progress: number) => {
       if (!options?.progressCallback) return;
@@ -139,23 +143,23 @@ export class NetworkFacade {
     };
 
     const encryptFile: EncryptFileFunction = async (_, key, iv) => {
-      const { blob, hash } = await this.cryptoService.encryptStream(
-        from,
-        Buffer.from(key as ArrayBuffer),
-        Buffer.from(iv as ArrayBuffer),
-      );
-
-      fileHash = hash;
-      encryptedBlob = blob;
+      encryptionTransform = from
+        .pipe(
+          await this.cryptoService.getEncryptionTransform(
+            Buffer.from(key as ArrayBuffer),
+            Buffer.from(iv as ArrayBuffer),
+          ),
+        )
+        .pipe(hashStream);
     };
 
     const uploadFile: UploadFileFunction = async (url) => {
-      await this.uploadService.uploadFile(url, encryptedBlob, {
+      await this.uploadService.uploadFile(url, encryptionTransform, {
         abortController: abortable,
         progressCallback: onUploadProgress,
       });
 
-      return fileHash.toString('hex');
+      return hashStream.getHash().toString('hex');
     };
     const uploadOperation = async () => {
       const uploadResult = await NetworkUpload.uploadFile(

src/services/network/upload.service.ts

@@ -1,29 +1,14 @@
+import { Readable } from 'node:stream';
 import { UploadOptions } from '../../types/network.types';
-import superagent from 'superagent';
 
+import fetch from 'node-fetch';
 export class UploadService {
   public static readonly instance: UploadService = new UploadService();
 
-  async uploadFile(url: string, data: Blob, options: UploadOptions): Promise<{ etag: string }> {
-    const request = superagent
-      .put(url)
-      .set('Content-Length', data.size.toString())
-      .set('Content-Type', data.type)
-      .send(Buffer.from(await data.arrayBuffer()))
-      .on('progress', (progressEvent) => {
-        if (options.progressCallback && progressEvent.total) {
-          const reportedProgress = progressEvent.loaded / parseInt(progressEvent.total);
-          options.progressCallback(reportedProgress);
-        }
-      });
+  async uploadFile(url: string, from: Readable, options: UploadOptions): Promise<{ etag: string }> {
+    const response = await fetch(url, { method: 'PUT', body: from, signal: options.abortController?.signal });
 
-    options.abortController?.signal.addEventListener('abort', () => {
-      request.abort();
-    });
-
-    const response = await request;
-
-    const etag = response.headers.etag;
+    const etag = response.headers.get('etag');
     options.progressCallback(1);
     if (!etag) {
       throw new Error('Missing Etag in response when uploading file');

src/types/webdav.types.ts

@@ -10,7 +10,7 @@ export type WebDavMethodHandlerOptions = {
 };
 
 export type WebDavRequestedResource = {
-  type: 'file' | 'folder' | 'root';
+  type: 'file' | 'folder';
   url: string;
   name: string;
   path: ParsedPath;

src/utils/errors.utils.ts

@@ -30,6 +30,16 @@ export class BadRequestError extends Error {
   }
 }
 
+export class UnsupportedMediaTypeError extends Error {
+  public statusCode = 415;
+
+  constructor(message: string) {
+    super(message);
+    this.name = 'UnsupportedMediaTypeError';
+    Object.setPrototypeOf(this, UnsupportedMediaTypeError.prototype);
+  }
+}
+
 export class NotImplementedError extends Error {
   public statusCode = 501;
 

src/utils/hash.utils.ts

@@ -0,0 +1,42 @@
+import { createHash, Hash } from 'crypto';
+import { Transform, TransformCallback, TransformOptions } from 'stream';
+
+export class HashStream extends Transform {
+  hasher: Hash;
+  finalHash: Buffer;
+
+  constructor(opts?: TransformOptions) {
+    super(opts);
+    this.hasher = createHash('sha256');
+    this.finalHash = Buffer.alloc(0);
+  }
+
+  _transform(chunk: Buffer, enc: BufferEncoding, cb: TransformCallback) {
+    this.hasher.update(chunk);
+    cb(null, chunk);
+  }
+
+  _flush(cb: (err: Error | null) => void) {
+    return this.hasher.end(cb);
+  }
+
+  reset() {
+    this.hasher = createHash('sha256');
+  }
+
+  readHash() {
+    if (!this.finalHash.length) {
+      this.finalHash = this.hasher.read();
+    }
+
+    return this.finalHash;
+  }
+
+  getHash() {
+    if (!this.finalHash.length) {
+      this.readHash();
+    }
+
+    return createHash('ripemd160').update(this.finalHash).digest();
+  }
+}

src/webdav/handlers/PROPFIND.handler.ts

@@ -22,7 +22,7 @@ export class PROPFINDRequestHandler implements WebDavMethodHandler {
 
     switch (resource.type) {
       case 'file': {
-        res.status(200).send(await this.getFileMetaXML(resource));
+        res.status(207).send(await this.getFileMetaXML(resource));
         break;
       }
 
@@ -39,7 +39,7 @@ export class PROPFINDRequestHandler implements WebDavMethodHandler {
             createdAt: new Date(rootFolder.createdAt),
             updatedAt: new Date(rootFolder.updatedAt),
           });
-          res.status(200).send(await this.getFolderContentXML('/', rootFolder.uuid, depth, true));
+          res.status(207).send(await this.getFolderContentXML('/', rootFolder.uuid, depth, true));
           break;
         }
 
@@ -50,7 +50,7 @@ export class PROPFINDRequestHandler implements WebDavMethodHandler {
           return;
         }
 
-        res.status(200).send(await this.getFolderContentXML(resource.url, driveParentFolder.uuid, depth));
+        res.status(207).send(await this.getFolderContentXML(resource.url, driveParentFolder.uuid, depth));
         break;
       }
     }