Merge branch 'main' into fix/download-using-bucket-from-file

Author: larryrider

package-lock.json

@@ -38,10 +38,10 @@
   "dependencies": {
     "@dashlane/pqc-kem-kyber512-node": "1.0.0",
     "@inquirer/prompts": "8.5.2",
-    "@internxt/inxt-js": "3.3.1",
+    "@internxt/inxt-js": "3.3.5",
     "@internxt/lib": "1.5.1",
-    "@internxt/sdk": "1.17.13",
-    "@oclif/core": "4.11.14",
+    "@internxt/sdk": "1.17.17",
+    "@oclif/core": "4.13.0",
     "@oclif/plugin-autocomplete": "3.2.53",
     "axios": "1.18.1",
     "better-sqlite3": "12.11.1",
@@ -52,8 +52,8 @@
     "dotenv": "17.4.2",
     "express": "5.2.1",
     "express-async-handler": "1.2.0",
-    "fast-xml-builder": "1.2.1",
-    "fast-xml-parser": "5.9.3",
+    "fast-xml-builder": "1.3.0",
+    "fast-xml-parser": "5.10.1",
     "hash-wasm": "4.12.0",
     "mime-types": "3.0.2",
     "open": "11.0.0",
@@ -63,7 +63,7 @@
     "range-parser": "1.3.0",
     "selfsigned": "5.5.0",
     "tty-table": "5.0.0",
-    "typeorm": "1.0.0",
+    "typeorm": "1.1.0",
     "winston": "3.19.0"
   },
   "devDependencies": {
@@ -77,12 +77,12 @@
     "@types/range-parser": "^1.2.7",
     "@vitest/coverage-istanbul": "^4.1.10",
     "@vitest/spy": "^4.1.10",
-    "eslint": "^10.6.0",
+    "eslint": "^10.8.0",
     "husky": "^9.1.7",
-    "lint-staged": "^17.0.8",
+    "lint-staged": "^17.2.0",
     "nodemon": "^3.1.14",
     "oclif": "^4.23.27",
-    "prettier": "^3.9.4",
+    "prettier": "^3.9.6",
     "rimraf": "^6.1.3",
     "sql.js": "^1.14.1",
     "ts-node": "^10.9.2",
@@ -91,7 +91,7 @@
     "vitest-mock-express": "^2.2.0"
   },
   "optionalDependencies": {
-    "sharp": "0.35.2"
+    "sharp": "0.35.3"
   },
   "engines": {
     "node": "^22.13.0 || >=24.11.0"

package.json

@@ -107,7 +107,9 @@ export class AuthService {
         );
         credentialsChanged = true;
       } catch (error) {
-        await ConfigService.instance.clearUser();
+        if (this.shouldClearUserAfterRefreshError(error)) {
+          await ConfigService.instance.clearUser();
+        }
         throw error;
       }
     }
@@ -126,6 +128,38 @@ export class AuthService {
     return loginCreds;
   };
 
+  private readonly shouldClearUserAfterRefreshError = (error: unknown): boolean => {
+    if (error instanceof InvalidCredentialsError || error instanceof ExpiredCredentialsError) {
+      return true;
+    }
+
+    const status = this.getHttpStatusFromError(error);
+    if (status === undefined) {
+      return false;
+    }
+
+    return status >= 400 && status < 500 && status !== 408 && status !== 429;
+  };
+
+  private readonly getHttpStatusFromError = (error: unknown): number | undefined => {
+    if (typeof error !== 'object' || error === null) {
+      return undefined;
+    }
+
+    const response = 'response' in error ? (error as { response?: { status?: unknown } }).response : undefined;
+    if (typeof response?.status === 'number') {
+      return response.status;
+    }
+
+    const status = 'status' in error ? (error as { status?: unknown }).status : undefined;
+    if (typeof status === 'number') {
+      return status;
+    }
+
+    const statusCode = 'statusCode' in error ? (error as { statusCode?: unknown }).statusCode : undefined;
+    return typeof statusCode === 'number' ? statusCode : undefined;
+  };
+
   /**
    * Refreshes the user tokens
    *

src/services/auth.service.ts

@@ -31,6 +31,32 @@ export class DriveFileService {
     return driveFileItem;
   };
 
+  public replaceFile = async (uuid: string, payload: StorageTypes.FileEntryByUuid): Promise<DriveFileItem> => {
+    const storageClient = SdkManager.instance.getStorage();
+    const driveFile = await storageClient.replaceFile(uuid, {
+      fileId: payload.fileId ?? '',
+      size: payload.size,
+    });
+
+    const driveFileItem: DriveFileItem = {
+      itemType: 'file',
+      name: driveFile.plainName ?? driveFile.name,
+      uuid: driveFile.uuid,
+      size: driveFile.size,
+      bucket: driveFile.bucket,
+      createdAt: new Date(driveFile.createdAt),
+      updatedAt: new Date(driveFile.updatedAt),
+      fileId: driveFile.fileId ?? null,
+      type: driveFile.type ?? null,
+      status: driveFile.status as DriveFileItem['status'],
+      folderUuid: driveFile.folderUuid,
+      creationTime: new Date(driveFile.creationTime ?? driveFile.createdAt),
+      modificationTime: new Date(driveFile.modificationTime ?? driveFile.updatedAt),
+    };
+
+    return driveFileItem;
+  };
+
   private readonly createDriveFileEntry = async (
     payload: StorageTypes.FileEntryByUuid,
   ): Promise<StorageTypes.DriveFileData> => {

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

@@ -52,12 +52,6 @@ export class PUTRequestHandler implements WebDavMethodHandler {
       webdavLogger.info(
         `[PUT] File '${resource.name}' already exists in '${resource.path.dir}', it will be replaced...`,
       );
-      try {
-        await WebDavUtils.deleteOrTrashItem(driveFileItem);
-        await DriveItemRepository.instance.delete([driveFileItem.uuid]);
-      } catch {
-        //noop
-      }
     }
 
     const { user } = await AuthService.instance.getAuthDetails();
@@ -104,15 +98,37 @@ export class PUTRequestHandler implements WebDavMethodHandler {
     }
 
     const driveTimer = CLIUtils.timer();
-    const file = await DriveFileService.instance.createFile({
+    const filePayload = {
       plainName: resource.path.name,
       type: fileType,
       size: contentLength,
       folderUuid: parentDriveFolderItem.uuid,
       fileId,
       bucket,
       encryptVersion: EncryptionVersion.Aes03,
-    });
+    };
+
+    let file;
+    if (driveFileItem?.itemType === 'file' && contentLength > 0) {
+      try {
+        file = await DriveFileService.instance.replaceFile(driveFileItem.uuid, filePayload);
+      } catch (error) {
+        webdavLogger.warn(
+          `[PUT] File replace failed for '${resource.url}', falling back to delete and create: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+        await WebDavUtils.deleteOrTrashItem(driveFileItem);
+        await DriveItemRepository.instance.delete([driveFileItem.uuid]);
+        file = await DriveFileService.instance.createFile(filePayload);
+      }
+    } else {
+      if (driveFileItem?.itemType === 'file') {
+        await WebDavUtils.deleteOrTrashItem(driveFileItem);
+        await DriveItemRepository.instance.delete([driveFileItem.uuid]);
+      }
+      file = await DriveFileService.instance.createFile(filePayload);
+    }
     timings.driveUpload = driveTimer.stop();
 
     await DriveItemRepository.instance.createOrUpdate([

src/webdav/handlers/PUT.handler.ts

@@ -217,12 +217,14 @@ describe('Auth service', () => {
     expect(refreshTokensStub).toHaveBeenCalledOnce();
   });
 
-  test('when the token refresh fails, then stored credentials are cleared and an error is thrown', async () => {
+  test('when the token refresh fails with an auth error, then stored credentials are cleared and an error is thrown', async () => {
     const sut = AuthService.instance;
 
     const mockTokenStatus = TokenStatus.REFRESH_REQUIRED;
 
-    const oldTokenError = new Error('Old token version detected');
+    const oldTokenError = Object.assign(new Error('Old token version detected'), {
+      response: { status: 401 },
+    });
 
     vi.spyOn(ConfigService.instance, 'readUser').mockResolvedValue(UserCredentialsFixture);
     vi.spyOn(ValidationService.instance, 'validateTokenAndCheckExpiration').mockImplementationOnce(
@@ -236,4 +238,26 @@ describe('Auth service', () => {
     expect(refreshTokenStub).toHaveBeenCalledOnce();
     expect(clearUserStub).toHaveBeenCalledOnce();
   });
+
+  test('when the token refresh fails with a retryable server error, then stored credentials are preserved', async () => {
+    const sut = AuthService.instance;
+
+    const mockTokenStatus = TokenStatus.REFRESH_REQUIRED;
+
+    const retryableError = Object.assign(new Error('Service unavailable'), {
+      response: { status: 503 },
+    });
+
+    vi.spyOn(ConfigService.instance, 'readUser').mockResolvedValue(UserCredentialsFixture);
+    vi.spyOn(ValidationService.instance, 'validateTokenAndCheckExpiration').mockImplementationOnce(
+      () => mockTokenStatus,
+    );
+    vi.spyOn(ValidationService.instance, 'validateMnemonic').mockReturnValue(true);
+    const refreshTokenStub = vi.spyOn(sut, 'refreshUserToken').mockRejectedValue(retryableError);
+    const clearUserStub = vi.spyOn(ConfigService.instance, 'clearUser').mockResolvedValue();
+
+    await expect(() => sut.getAuthDetails()).rejects.toThrow(retryableError);
+    expect(refreshTokenStub).toHaveBeenCalledOnce();
+    expect(clearUserStub).not.toHaveBeenCalled();
+  });
 });

test/services/auth.service.test.ts

@@ -168,6 +168,7 @@ describe('PUT request handler', () => {
       .mockResolvedValue(UserCredentialsFixture);
     const uploadStub = vi.spyOn(networkFacade, 'uploadFile').mockResolvedValue('uploaded-file-id');
     const createDriveFileStub = vi.spyOn(DriveFileService.instance, 'createFile').mockResolvedValue(fileFixture);
+    const replaceDriveFileStub = vi.spyOn(DriveFileService.instance, 'replaceFile').mockResolvedValue(fileFixture);
 
     await sut.handle(request, response);
     expect(response.status).toHaveBeenCalledWith(204);
@@ -176,7 +177,16 @@ describe('PUT request handler', () => {
     expect(getDriveFolderFromResourceStub).toHaveBeenCalledOnce();
     expect(getAuthDetailsStub).toHaveBeenCalledOnce();
     expect(uploadStub).toHaveBeenCalledOnce();
-    expect(createDriveFileStub).toHaveBeenCalledOnce();
-    expect(deleteDriveFileStub).toHaveBeenCalledOnce();
+    expect(replaceDriveFileStub).toHaveBeenCalledWith(
+      fileFixture.uuid,
+      expect.objectContaining({
+        fileId: 'uploaded-file-id',
+        folderUuid: folderFixture.uuid,
+        plainName: requestedFileResource.path.name,
+        size: 100,
+      }),
+    );
+    expect(createDriveFileStub).not.toHaveBeenCalled();
+    expect(deleteDriveFileStub).not.toHaveBeenCalled();
   });
 });