Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

refractor(locker):update-collections-refractor-remote

Aswin Asok41e5186f442d
diff --git a/web/apps/locker/src/components/locker/use-item-actions.tsx b/web/apps/locker/src/components/locker/use-item-actions.tsx
index 72a788b176..09da0c8539 100644
--- a/web/apps/locker/src/components/locker/use-item-actions.tsx
+++ b/web/apps/locker/src/components/locker/use-item-actions.tsx
@@ -2,10 +2,10 @@ import { updateItemCollections } from "@/services/collection-membership";
import {
createInfoItem,
setItemImportant,
- trashFiles,
updateFileItem,
updateInfoItem,
-} from "@/services/remote";
+} from "@/services/items";
+import { trashFiles } from "@/services/trash";
import type { LockerCollection, LockerItem, LockerItemType } from "@/types";
import { getItemTitle } from "@/types";
import { t } from "i18next";
diff --git a/web/apps/locker/src/components/locker/use-trash-actions.ts b/web/apps/locker/src/components/locker/use-trash-actions.ts
index 4c856723b8..064295648c 100644
--- a/web/apps/locker/src/components/locker/use-trash-actions.ts
+++ b/web/apps/locker/src/components/locker/use-trash-actions.ts
@@ -2,7 +2,7 @@ import {
emptyTrash as emptyTrashAPI,
permanentlyDeleteFromTrash,
restoreFromTrash,
-} from "@/services/remote";
+} from "@/services/trash";
import type { LockerItem } from "@/types";
import log from "ente-base/log";
import { t } from "i18next";
diff --git a/web/apps/locker/src/services/collections.ts b/web/apps/locker/src/services/collections.ts
index 4afeaf6999..47a372c08c 100644
--- a/web/apps/locker/src/services/collections.ts
+++ b/web/apps/locker/src/services/collections.ts
@@ -110,3 +110,11 @@ export const deleteCollection = async (
);
ensureOk(res);
};
+
+export const resolveCollectionIDsWithUncategorizedFallback = async (
+ collectionIDs: number[],
+ masterKey: string,
+) =>
+ collectionIDs.length > 0
+ ? Array.from(new Set(collectionIDs))
+ : [(await ensureUncategorizedCollection(masterKey)).id];
diff --git a/web/apps/locker/src/services/items.ts b/web/apps/locker/src/services/items.ts
new file mode 100644
index 0000000000..20332f1f54
--- /dev/null
+++ b/web/apps/locker/src/services/items.ts
@@ -0,0 +1,270 @@
+import type { LockerItemType } from "@/types";
+import { ensureLocalUser } from "ente-accounts/services/user";
+import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
+import { apiURL } from "ente-base/origins";
+import {
+ decryptBox,
+ decryptMetadataJSON,
+ encryptBlob,
+ encryptBox,
+ generateKey,
+} from "ente-locker-wasm";
+import {
+ addFileToCollections,
+ createCollectionMutationDeps,
+ updateItemCollectionsWithDeps,
+} from "./collection-membership";
+import {
+ ensureFavoritesCollection,
+ resolveCollectionIDsWithUncategorizedFallback,
+} from "./collections";
+import {
+ findCollectionByType,
+ getCollectionIDsForFile,
+ getCollectionRecord,
+ getEncryptedFileRecord,
+ updateCachedPubMagicMetadata,
+} from "./locker-cache";
+import { RemoteIDResponseSchema } from "./remote-types";
+import { decryptCollectionKey } from "./sync/decrypt";
+
+const infoItemTitle = (
+ infoType: LockerItemType,
+ infoData: Record<string, unknown>,
+) => {
+ const namedTitle =
+ (infoData.title as string | undefined)?.trim() ||
+ (infoData.name as string | undefined)?.trim();
+ if (namedTitle) {
+ return namedTitle;
+ }
+
+ switch (infoType) {
+ case "note":
+ return "Note";
+ case "physicalRecord":
+ return "Location";
+ case "accountCredential":
+ return "Secret";
+ case "emergencyContact":
+ return "Emergency Contact";
+ case "file":
+ return "File";
+ }
+};
+
+export const createInfoItem = async (
+ collectionIDs: number[],
+ infoType: LockerItemType,
+ infoData: Record<string, unknown>,
+ masterKey: string,
+): Promise<void> => {
+ const [collectionID, ...additionalCollectionIDs] =
+ await resolveCollectionIDsWithUncategorizedFallback(
+ collectionIDs,
+ masterKey,
+ );
+ if (collectionID === undefined) {
+ throw new Error("No collection selected");
+ }
+ const collectionRecord = getCollectionRecord(collectionID);
+ if (!collectionRecord)
+ throw new Error(`Collection ${collectionID} not in cache`);
+
+ const collectionKey = await decryptCollectionKey(collectionRecord);
+
+ const fileKey = await generateKey();
+
+ const encryptedFileKey = await encryptBox(fileKey, collectionKey);
+
+ // Locker timestamps are epoch milliseconds, unlike photos which uses
+ // microseconds.
+ const now = Date.now();
+ const title = infoItemTitle(infoType, infoData);
+ const metadata = {
+ title,
+ creationTime: now,
+ modificationTime: now,
+ fileType: 4, // FileType.info in the mobile client's enum
+ };
+ const metadataJSON = JSON.stringify(metadata);
+ const encryptedMetadata = await encryptBlob(
+ new TextEncoder().encode(metadataJSON),
+ fileKey,
+ );
+
+ const pubMagicMetadata = {
+ info: { type: infoType, data: infoData },
+ noThumb: true,
+ };
+ const pubMMJSON = JSON.stringify(pubMagicMetadata);
+ const encryptedPubMM = await encryptBlob(
+ new TextEncoder().encode(pubMMJSON),
+ fileKey,
+ );
+
+ const res = await fetch(await apiURL("/files/meta"), {
+ method: "POST",
+ headers: {
+ ...(await authenticatedRequestHeaders()),
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ collectionID,
+ encryptedKey: encryptedFileKey.encryptedData,
+ keyDecryptionNonce: encryptedFileKey.nonce,
+ metadata: {
+ encryptedData: encryptedMetadata.encryptedData,
+ decryptionHeader: encryptedMetadata.decryptionHeader,
+ },
+ pubMagicMetadata: {
+ version: 1,
+ count: Object.keys(pubMagicMetadata).length,
+ data: encryptedPubMM.encryptedData,
+ header: encryptedPubMM.decryptionHeader,
+ },
+ }),
+ });
+ ensureOk(res);
+
+ const created = RemoteIDResponseSchema.parse(await res.json());
+ if (additionalCollectionIDs.length > 0) {
+ await addFileToCollections(
+ created.id,
+ fileKey,
+ additionalCollectionIDs,
+ );
+ }
+};
+
+export const updateInfoItem = async (
+ fileID: number,
+ infoType: LockerItemType,
+ infoData: Record<string, unknown>,
+): Promise<void> =>
+ updateItemMetadata(fileID, {
+ info: { type: infoType, data: infoData },
+ editedName: infoItemTitle(infoType, infoData),
+ });
+
+export const updateFileItem = async (
+ fileID: number,
+ title: string,
+): Promise<void> => updateItemMetadata(fileID, { editedName: title.trim() });
+
+const updateItemMetadata = async (
+ fileID: number,
+ updates: Record<string, unknown>,
+): Promise<void> => {
+ const fileRecord = getEncryptedFileRecord(fileID);
+ if (!fileRecord) throw new Error(`File ${fileID} not in cache`);
+
+ const collectionRecord = getCollectionRecord(fileRecord.collectionID);
+ if (!collectionRecord)
+ throw new Error(`Collection ${fileRecord.collectionID} not in cache`);
+
+ const collectionKey = await decryptCollectionKey(collectionRecord);
+ const fileKey = await decryptBox(
+ {
+ encryptedData: fileRecord.encryptedKey,
+ nonce: fileRecord.keyDecryptionNonce,
+ },
+ collectionKey,
+ );
+
+ const existingPubMagicMetadata = fileRecord.pubMagicMetadata
+ ? ((await decryptMetadataJSON(
+ {
+ encryptedData: fileRecord.pubMagicMetadata.data,
+ decryptionHeader: fileRecord.pubMagicMetadata.header,
+ },
+ fileKey,
+ )) as Record<string, unknown>)
+ : {};
+
+ const pubMagicMetadata = {
+ ...existingPubMagicMetadata,
+ ...updates,
+ noThumb: true,
+ editedTime: Date.now(),
+ };
+ const pubMMJSON = JSON.stringify(pubMagicMetadata);
+ const encryptedPubMM = await encryptBlob(
+ new TextEncoder().encode(pubMMJSON),
+ fileKey,
+ );
+ const version = fileRecord.pubMagicMetadata?.version ?? 1;
+
+ const res = await fetch(await apiURL("/files/public-magic-metadata"), {
+ method: "PUT",
+ headers: {
+ ...(await authenticatedRequestHeaders()),
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ metadataList: [
+ {
+ id: fileID,
+ magicMetadata: {
+ version,
+ count: Object.keys(pubMagicMetadata).length,
+ data: encryptedPubMM.encryptedData,
+ header: encryptedPubMM.decryptionHeader,
+ },
+ },
+ ],
+ }),
+ });
+ ensureOk(res);
+
+ updateCachedPubMagicMetadata(fileID, {
+ version: version + 1,
+ data: encryptedPubMM.encryptedData,
+ header: encryptedPubMM.decryptionHeader,
+ });
+};
+
+export const setItemImportant = async (
+ fileID: number,
+ shouldBeImportant: boolean,
+ masterKey: string,
+): Promise<boolean> => {
+ const currentUserID = ensureLocalUser().id;
+ const currentCollectionIDs = getCollectionIDsForFile(fileID);
+ if (currentCollectionIDs.length === 0) {
+ throw new Error(`File ${fileID} not found in cache`);
+ }
+
+ const favoritesCollection = findCollectionByType(
+ "favorites",
+ currentUserID,
+ );
+ if (!shouldBeImportant && !favoritesCollection) {
+ return false;
+ }
+
+ const favoritesCollectionID =
+ favoritesCollection?.id ??
+ (await ensureFavoritesCollection(masterKey)).id;
+ const nextCollectionIDs = shouldBeImportant
+ ? Array.from(new Set([...currentCollectionIDs, favoritesCollectionID]))
+ : currentCollectionIDs.filter(
+ (collectionID) => collectionID !== favoritesCollectionID,
+ );
+
+ const hasChanged =
+ nextCollectionIDs.length !== currentCollectionIDs.length ||
+ nextCollectionIDs.some(
+ (collectionID) => !currentCollectionIDs.includes(collectionID),
+ );
+ if (!hasChanged) {
+ return false;
+ }
+
+ await updateItemCollectionsWithDeps(fileID, nextCollectionIDs, {
+ currentUserID,
+ masterKey,
+ deps: createCollectionMutationDeps(),
+ });
+ return true;
+};
diff --git a/web/apps/locker/src/services/remote.ts b/web/apps/locker/src/services/remote.ts
index b5502fde5f..6ad1600d7b 100644
--- a/web/apps/locker/src/services/remote.ts
+++ b/web/apps/locker/src/services/remote.ts
@@ -1,42 +1,11 @@
-import type { LockerItem, LockerItemType } from "@/types";
-import { ensureLocalUser } from "ente-accounts/services/user";
-import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
-import log from "ente-base/log";
-import { apiURL } from "ente-base/origins";
-import {
- decryptBox,
- decryptMetadataJSON,
- encryptBlob,
- encryptBox,
- generateKey,
-} from "ente-locker-wasm";
-import {
- addFileToCollections,
- createCollectionMutationDeps,
- updateItemCollectionsWithDeps,
-} from "./collection-membership";
-import {
- ensureFavoritesCollection,
- ensureUncategorizedCollection,
-} from "./collections";
-import {
- findCollectionByType,
- getCollectionIDsForFile,
- getCollectionRecord,
- getEncryptedFileRecord,
- updateCachedPubMagicMetadata,
-} from "./locker-cache";
-import { RemoteIDResponseSchema } from "./remote-types";
+import { addFileToCollections } from "./collection-membership";
+import { resolveCollectionIDsWithUncategorizedFallback } from "./collections";
+import { getCollectionRecord } from "./locker-cache";
import {
type LockerUploadProgress,
uploadLockerFileWithDeps,
} from "./remote-uploads";
import { decryptCollectionKey } from "./sync/decrypt";
-import {
- fetchLockerTrash,
- loadPersistedLockerState,
- syncLockerState,
-} from "./sync/sync";
export {
deleteCollectionKeepingFiles,
updateItemCollections,
@@ -58,387 +27,20 @@ export {
deleteLockerFileShareLink,
getOrCreateLockerFileShareLink,
} from "./file-links";
-export { loadPersistedLockerState, syncLockerState };
-
-const infoItemTitle = (
- infoType: LockerItemType,
- infoData: Record<string, unknown>,
-) => {
- const namedTitle =
- (infoData.title as string | undefined)?.trim() ||
- (infoData.name as string | undefined)?.trim();
- if (namedTitle) {
- return namedTitle;
- }
-
- switch (infoType) {
- case "note":
- return "Note";
- case "physicalRecord":
- return "Location";
- case "accountCredential":
- return "Secret";
- case "emergencyContact":
- return "Emergency Contact";
- case "file":
- return "File";
- }
-};
-
-const resolveCollectionIDsWithUncategorizedFallback = async (
- collectionIDs: number[],
- masterKey: string,
-) =>
- collectionIDs.length > 0
- ? Array.from(new Set(collectionIDs))
- : [(await ensureUncategorizedCollection(masterKey)).id];
-
-export const createInfoItem = async (
- collectionIDs: number[],
- infoType: LockerItemType,
- infoData: Record<string, unknown>,
- masterKey: string,
-): Promise<void> => {
- const [collectionID, ...additionalCollectionIDs] =
- await resolveCollectionIDsWithUncategorizedFallback(
- collectionIDs,
- masterKey,
- );
- if (collectionID === undefined) {
- throw new Error("No collection selected");
- }
- const collectionRecord = getCollectionRecord(collectionID);
- if (!collectionRecord)
- throw new Error(`Collection ${collectionID} not in cache`);
-
- const collectionKey = await decryptCollectionKey(collectionRecord);
-
- const fileKey = await generateKey();
-
- const encryptedFileKey = await encryptBox(fileKey, collectionKey);
-
- // Locker timestamps are epoch milliseconds, unlike photos which uses
- // microseconds.
- const now = Date.now();
- const title = infoItemTitle(infoType, infoData);
- const metadata = {
- title,
- creationTime: now,
- modificationTime: now,
- fileType: 4, // FileType.info in the mobile client's enum
- };
- const metadataJSON = JSON.stringify(metadata);
- const encryptedMetadata = await encryptBlob(
- new TextEncoder().encode(metadataJSON),
- fileKey,
- );
-
- const pubMagicMetadata = {
- info: { type: infoType, data: infoData },
- noThumb: true,
- };
- const pubMMJSON = JSON.stringify(pubMagicMetadata);
- const encryptedPubMM = await encryptBlob(
- new TextEncoder().encode(pubMMJSON),
- fileKey,
- );
-
- const res = await fetch(await apiURL("/files/meta"), {
- method: "POST",
- headers: {
- ...(await authenticatedRequestHeaders()),
- "Content-Type": "application/json",
- },
- body: JSON.stringify({
- collectionID,
- encryptedKey: encryptedFileKey.encryptedData,
- keyDecryptionNonce: encryptedFileKey.nonce,
- metadata: {
- encryptedData: encryptedMetadata.encryptedData,
- decryptionHeader: encryptedMetadata.decryptionHeader,
- },
- pubMagicMetadata: {
- version: 1,
- count: Object.keys(pubMagicMetadata).length,
- data: encryptedPubMM.encryptedData,
- header: encryptedPubMM.decryptionHeader,
- },
- }),
- });
- ensureOk(res);
-
- const created = RemoteIDResponseSchema.parse(await res.json());
- if (additionalCollectionIDs.length > 0) {
- await addFileToCollections(
- created.id,
- fileKey,
- additionalCollectionIDs,
- );
- }
-};
-
-export const updateInfoItem = async (
- fileID: number,
- infoType: LockerItemType,
- infoData: Record<string, unknown>,
-): Promise<void> =>
- updateItemMetadata(fileID, {
- info: { type: infoType, data: infoData },
- editedName: infoItemTitle(infoType, infoData),
- });
-
-export const updateFileItem = async (
- fileID: number,
- title: string,
-): Promise<void> => updateItemMetadata(fileID, { editedName: title.trim() });
-
-const updateItemMetadata = async (
- fileID: number,
- updates: Record<string, unknown>,
-): Promise<void> => {
- const fileRecord = getEncryptedFileRecord(fileID);
- if (!fileRecord) throw new Error(`File ${fileID} not in cache`);
-
- const collectionRecord = getCollectionRecord(fileRecord.collectionID);
- if (!collectionRecord)
- throw new Error(`Collection ${fileRecord.collectionID} not in cache`);
-
- const collectionKey = await decryptCollectionKey(collectionRecord);
- const fileKey = await decryptBox(
- {
- encryptedData: fileRecord.encryptedKey,
- nonce: fileRecord.keyDecryptionNonce,
- },
- collectionKey,
- );
+export { loadPersistedLockerState, syncLockerState } from "./sync/sync";
- const existingPubMagicMetadata = fileRecord.pubMagicMetadata
- ? ((await decryptMetadataJSON(
- {
- encryptedData: fileRecord.pubMagicMetadata.data,
- decryptionHeader: fileRecord.pubMagicMetadata.header,
- },
- fileKey,
- )) as Record<string, unknown>)
- : {};
-
- const pubMagicMetadata = {
- ...existingPubMagicMetadata,
- ...updates,
- noThumb: true,
- editedTime: Date.now(),
- };
- const pubMMJSON = JSON.stringify(pubMagicMetadata);
- const encryptedPubMM = await encryptBlob(
- new TextEncoder().encode(pubMMJSON),
- fileKey,
- );
- const version = fileRecord.pubMagicMetadata?.version ?? 1;
-
- const res = await fetch(await apiURL("/files/public-magic-metadata"), {
- method: "PUT",
- headers: {
- ...(await authenticatedRequestHeaders()),
- "Content-Type": "application/json",
- },
- body: JSON.stringify({
- metadataList: [
- {
- id: fileID,
- magicMetadata: {
- version,
- count: Object.keys(pubMagicMetadata).length,
- data: encryptedPubMM.encryptedData,
- header: encryptedPubMM.decryptionHeader,
- },
- },
- ],
- }),
- });
- ensureOk(res);
-
- updateCachedPubMagicMetadata(fileID, {
- version: version + 1,
- data: encryptedPubMM.encryptedData,
- header: encryptedPubMM.decryptionHeader,
- });
-};
-
-export const trashFiles = async (
- fileIDs: number[],
- collectionID: number,
-): Promise<void> => {
- const res = await fetch(await apiURL("/files/trash"), {
- method: "POST",
- headers: {
- ...(await authenticatedRequestHeaders()),
- "Content-Type": "application/json",
- },
- body: JSON.stringify({
- items: fileIDs.map((fileID) => ({ fileID, collectionID })),
- }),
- });
- ensureOk(res);
-};
-
-export const permanentlyDeleteFromTrash = async (
- fileIDs: number[],
-): Promise<void> => {
- const res = await fetch(await apiURL("/trash/delete"), {
- method: "POST",
- headers: {
- ...(await authenticatedRequestHeaders()),
- "Content-Type": "application/json",
- },
- body: JSON.stringify({ fileIDs }),
- });
- ensureOk(res);
-};
-
-export const emptyTrash = async (lastUpdatedAt: number): Promise<void> => {
- const res = await fetch(await apiURL("/trash/empty"), {
- method: "POST",
- headers: {
- ...(await authenticatedRequestHeaders()),
- "Content-Type": "application/json",
- },
- body: JSON.stringify({ lastUpdatedAt }),
- });
- ensureOk(res);
-};
-
-export const restoreFromTrash = async (
- items: Pick<LockerItem, "id" | "collectionID">[],
- targetCollectionID: number,
-): Promise<void> => {
- const collectionRecord = getCollectionRecord(targetCollectionID);
- if (!collectionRecord)
- throw new Error(`Collection ${targetCollectionID} not in cache`);
-
- const collectionKey = await decryptCollectionKey(collectionRecord);
-
- const buildRestorePayload = async (
- candidateItems: Pick<LockerItem, "id" | "collectionID">[],
- ) => {
- const files: {
- id: number;
- encryptedKey: string;
- keyDecryptionNonce: string;
- }[] = [];
- const skippedFileIDs: number[] = [];
-
- for (const item of candidateItems) {
- const fileRecord = getEncryptedFileRecord(
- item.id,
- item.collectionID,
- );
- if (!fileRecord) {
- skippedFileIDs.push(item.id);
- continue;
- }
-
- const origCollectionRecord = getCollectionRecord(
- fileRecord.collectionID,
- );
- if (!origCollectionRecord) {
- skippedFileIDs.push(item.id);
- continue;
- }
-
- const origCollectionKey =
- await decryptCollectionKey(origCollectionRecord);
- const fileKey = await decryptBox(
- {
- encryptedData: fileRecord.encryptedKey,
- nonce: fileRecord.keyDecryptionNonce,
- },
- origCollectionKey,
- );
-
- const encryptedFileKey = await encryptBox(fileKey, collectionKey);
- files.push({
- id: item.id,
- encryptedKey: encryptedFileKey.encryptedData,
- keyDecryptionNonce: encryptedFileKey.nonce,
- });
- }
-
- return { files, skippedFileIDs };
- };
-
- let { files, skippedFileIDs } = await buildRestorePayload(items);
- if (files.length === 0 && skippedFileIDs.length > 0) {
- await fetchLockerTrash();
- ({ files, skippedFileIDs } = await buildRestorePayload(items));
- }
-
- if (skippedFileIDs.length > 0) {
- log.warn(
- `Skipping ${skippedFileIDs.length} trash files during restore due to missing cache records`,
- skippedFileIDs,
- );
- }
- if (files.length === 0) {
- throw new Error(
- "Unable to restore files: missing encrypted metadata in local cache. Please refresh and try again.",
- );
- }
-
- const res = await fetch(await apiURL("/collections/restore-files"), {
- method: "POST",
- headers: {
- ...(await authenticatedRequestHeaders()),
- "Content-Type": "application/json",
- },
- body: JSON.stringify({ collectionID: targetCollectionID, files }),
- });
- ensureOk(res);
-};
-
-export const setItemImportant = async (
- fileID: number,
- shouldBeImportant: boolean,
- masterKey: string,
-): Promise<boolean> => {
- const currentUserID = ensureLocalUser().id;
- const currentCollectionIDs = getCollectionIDsForFile(fileID);
- if (currentCollectionIDs.length === 0) {
- throw new Error(`File ${fileID} not found in cache`);
- }
-
- const favoritesCollection = findCollectionByType(
- "favorites",
- currentUserID,
- );
- if (!shouldBeImportant && !favoritesCollection) {
- return false;
- }
-
- const favoritesCollectionID =
- favoritesCollection?.id ??
- (await ensureFavoritesCollection(masterKey)).id;
- const nextCollectionIDs = shouldBeImportant
- ? Array.from(new Set([...currentCollectionIDs, favoritesCollectionID]))
- : currentCollectionIDs.filter(
- (collectionID) => collectionID !== favoritesCollectionID,
- );
-
- const hasChanged =
- nextCollectionIDs.length !== currentCollectionIDs.length ||
- nextCollectionIDs.some(
- (collectionID) => !currentCollectionIDs.includes(collectionID),
- );
- if (!hasChanged) {
- return false;
- }
-
- await updateItemCollectionsWithDeps(fileID, nextCollectionIDs, {
- currentUserID,
- masterKey,
- deps: createCollectionMutationDeps(),
- });
- return true;
-};
+export {
+ createInfoItem,
+ setItemImportant,
+ updateFileItem,
+ updateInfoItem,
+} from "./items";
+export {
+ emptyTrash,
+ permanentlyDeleteFromTrash,
+ restoreFromTrash,
+ trashFiles,
+} from "./trash";
export type { LockerUploadProgress } from "./remote-uploads";
diff --git a/web/apps/locker/src/services/trash.ts b/web/apps/locker/src/services/trash.ts
new file mode 100644
index 0000000000..9f9971a1ba
--- /dev/null
+++ b/web/apps/locker/src/services/trash.ts
@@ -0,0 +1,139 @@
+import type { LockerItem } from "@/types";
+import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
+import log from "ente-base/log";
+import { apiURL } from "ente-base/origins";
+import { decryptBox, encryptBox } from "ente-locker-wasm";
+import { getCollectionRecord, getEncryptedFileRecord } from "./locker-cache";
+import { decryptCollectionKey } from "./sync/decrypt";
+import { fetchLockerTrash } from "./sync/sync";
+
+export const trashFiles = async (
+ fileIDs: number[],
+ collectionID: number,
+): Promise<void> => {
+ const res = await fetch(await apiURL("/files/trash"), {
+ method: "POST",
+ headers: {
+ ...(await authenticatedRequestHeaders()),
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ items: fileIDs.map((fileID) => ({ fileID, collectionID })),
+ }),
+ });
+ ensureOk(res);
+};
+
+export const permanentlyDeleteFromTrash = async (
+ fileIDs: number[],
+): Promise<void> => {
+ const res = await fetch(await apiURL("/trash/delete"), {
+ method: "POST",
+ headers: {
+ ...(await authenticatedRequestHeaders()),
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({ fileIDs }),
+ });
+ ensureOk(res);
+};
+
+export const emptyTrash = async (lastUpdatedAt: number): Promise<void> => {
+ const res = await fetch(await apiURL("/trash/empty"), {
+ method: "POST",
+ headers: {
+ ...(await authenticatedRequestHeaders()),
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({ lastUpdatedAt }),
+ });
+ ensureOk(res);
+};
+
+export const restoreFromTrash = async (
+ items: Pick<LockerItem, "id" | "collectionID">[],
+ targetCollectionID: number,
+): Promise<void> => {
+ const collectionRecord = getCollectionRecord(targetCollectionID);
+ if (!collectionRecord)
+ throw new Error(`Collection ${targetCollectionID} not in cache`);
+
+ const collectionKey = await decryptCollectionKey(collectionRecord);
+
+ const buildRestorePayload = async (
+ candidateItems: Pick<LockerItem, "id" | "collectionID">[],
+ ) => {
+ const files: {
+ id: number;
+ encryptedKey: string;
+ keyDecryptionNonce: string;
+ }[] = [];
+ const skippedFileIDs: number[] = [];
+
+ for (const item of candidateItems) {
+ const fileRecord = getEncryptedFileRecord(
+ item.id,
+ item.collectionID,
+ );
+ if (!fileRecord) {
+ skippedFileIDs.push(item.id);
+ continue;
+ }
+
+ const origCollectionRecord = getCollectionRecord(
+ fileRecord.collectionID,
+ );
+ if (!origCollectionRecord) {
+ skippedFileIDs.push(item.id);
+ continue;
+ }
+
+ const origCollectionKey =
+ await decryptCollectionKey(origCollectionRecord);
+ const fileKey = await decryptBox(
+ {
+ encryptedData: fileRecord.encryptedKey,
+ nonce: fileRecord.keyDecryptionNonce,
+ },
+ origCollectionKey,
+ );
+
+ const encryptedFileKey = await encryptBox(fileKey, collectionKey);
+ files.push({
+ id: item.id,
+ encryptedKey: encryptedFileKey.encryptedData,
+ keyDecryptionNonce: encryptedFileKey.nonce,
+ });
+ }
+
+ return { files, skippedFileIDs };
+ };
+
+ let { files, skippedFileIDs } = await buildRestorePayload(items);
+ if (files.length === 0 && skippedFileIDs.length > 0) {
+ await fetchLockerTrash();
+ ({ files, skippedFileIDs } = await buildRestorePayload(items));
+ }
+
+ if (skippedFileIDs.length > 0) {
+ log.warn(
+ `Skipping ${skippedFileIDs.length} trash files during restore due to missing cache records`,
+ skippedFileIDs,
+ );
+ }
+ if (files.length === 0) {
+ throw new Error(
+ "Unable to restore files: missing encrypted metadata in local cache. Please refresh and try again.",
+ );
+ }
+
+ const res = await fetch(await apiURL("/collections/restore-files"), {
+ method: "POST",
+ headers: {
+ ...(await authenticatedRequestHeaders()),
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({ collectionID: targetCollectionID, files }),
+ });
+ ensureOk(res);
+};
diff --git a/web/apps/locker/tests/item-metadata.test.ts b/web/apps/locker/tests/item-metadata.test.ts
index feb389cde7..66dbd177ed 100644
--- a/web/apps/locker/tests/item-metadata.test.ts
+++ b/web/apps/locker/tests/item-metadata.test.ts
@@ -1,10 +1,10 @@
import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { updateFileItem, updateInfoItem } from "../src/services/items";
import {
getEncryptedFileRecord,
replaceLockerCache,
type EncryptedFileRecord,
} from "../src/services/locker-cache";
-import { updateFileItem, updateInfoItem } from "../src/services/remote";
const { encryptBlob, decryptMetadataJSON } = vi.hoisted(() => ({
encryptBlob: vi.fn(),
diff --git a/web/apps/locker/tests/trash.test.ts b/web/apps/locker/tests/trash.test.ts
new file mode 100644
index 0000000000..70697e6321
--- /dev/null
+++ b/web/apps/locker/tests/trash.test.ts
@@ -0,0 +1,152 @@
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import {
+ emptyTrash,
+ permanentlyDeleteFromTrash,
+ restoreFromTrash,
+ trashFiles,
+} from "../src/services/trash";
+
+const {
+ getCollectionRecord,
+ getEncryptedFileRecord,
+ fetchLockerTrash,
+ encryptBox,
+ warn,
+} = vi.hoisted(() => ({
+ getCollectionRecord: vi.fn(),
+ getEncryptedFileRecord: vi.fn(),
+ fetchLockerTrash: vi.fn(),
+ encryptBox: vi.fn(),
+ warn: vi.fn(),
+}));
+vi.mock("../src/services/locker-cache", () => ({
+ getCollectionRecord,
+ getEncryptedFileRecord,
+}));
+vi.mock("../src/services/sync/decrypt", () => ({
+ decryptCollectionKey: (record: { id: number }) => `collection-${record.id}`,
+}));
+vi.mock("../src/services/sync/sync", () => ({ fetchLockerTrash }));
+vi.mock("ente-locker-wasm", () => ({
+ decryptBox: () => "file-key",
+ encryptBox,
+}));
+vi.mock("ente-base/http", () => ({
+ authenticatedRequestHeaders: () => ({}),
+ ensureOk: (res: Response) => {
+ if (!res.ok) throw new Error("Request failed");
+ },
+}));
+vi.mock("ente-base/origins", () => ({ apiURL: (path: string) => path }));
+vi.mock("ente-base/log", () => ({ default: { warn } }));
+vi.mock("ente-accounts/services/user", () => ({}));
+vi.mock("../src/services/authenticated-session", () => ({}));
+const fetchMock = vi.fn<typeof fetch>();
+const items = [{ id: 1, collectionID: 2 }];
+beforeEach(() => {
+ vi.resetAllMocks();
+ vi.stubGlobal("fetch", fetchMock);
+ fetchMock.mockResolvedValue(new Response(null, { status: 200 }));
+ getCollectionRecord.mockImplementation((id: number) => ({ id }));
+ getEncryptedFileRecord.mockReturnValue({
+ collectionID: 2,
+ encryptedKey: "key",
+ keyDecryptionNonce: "nonce",
+ });
+ encryptBox.mockResolvedValue({
+ encryptedData: "rewrapped",
+ nonce: "new-nonce",
+ });
+});
+afterEach(() => vi.unstubAllGlobals());
+
+test("trash mutations preserve endpoints and payloads", async () => {
+ await trashFiles([1, 3], 2);
+ await permanentlyDeleteFromTrash([1, 3]);
+ await emptyTrash(123);
+ expect(
+ fetchMock.mock.calls.map(([url, init]) => [
+ url,
+ init?.method,
+ JSON.parse(init?.body as string) as unknown,
+ ]),
+ ).toEqual([
+ [
+ "/files/trash",
+ "POST",
+ {
+ items: [
+ { fileID: 1, collectionID: 2 },
+ { fileID: 3, collectionID: 2 },
+ ],
+ },
+ ],
+ ["/trash/delete", "POST", { fileIDs: [1, 3] }],
+ ["/trash/empty", "POST", { lastUpdatedAt: 123 }],
+ ]);
+});
+test("restore rewraps the original file key for the chosen destination", async () => {
+ await restoreFromTrash(items, 9);
+ expect(getEncryptedFileRecord).toHaveBeenCalledWith(1, 2);
+ expect(encryptBox).toHaveBeenCalledWith("file-key", "collection-9");
+ expect(fetchMock).toHaveBeenCalledWith(
+ "/collections/restore-files",
+ expect.objectContaining({
+ body: JSON.stringify({
+ collectionID: 9,
+ files: [
+ {
+ id: 1,
+ encryptedKey: "rewrapped",
+ keyDecryptionNonce: "new-nonce",
+ },
+ ],
+ }),
+ }),
+ );
+});
+test("restore refreshes missing cache records once before retrying", async () => {
+ getEncryptedFileRecord.mockReturnValueOnce(undefined);
+ await restoreFromTrash(items, 9);
+ expect(fetchLockerTrash).toHaveBeenCalledTimes(1);
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+});
+test("restore rejects when cache records remain missing", async () => {
+ getEncryptedFileRecord.mockReturnValue(undefined);
+ await expect(restoreFromTrash(items, 9)).rejects.toThrow(
+ "missing encrypted metadata",
+ );
+ expect(fetchLockerTrash).toHaveBeenCalledTimes(1);
+ expect(fetchMock).not.toHaveBeenCalled();
+});
+test("partial restore submits available files without retrying missing ones", async () => {
+ getEncryptedFileRecord.mockReturnValueOnce(undefined);
+ await restoreFromTrash([{ id: 3, collectionID: 2 }, ...items], 9);
+ expect(fetchLockerTrash).not.toHaveBeenCalled();
+ expect(warn).toHaveBeenCalledWith(expect.any(String), [3]);
+ expect(
+ (
+ JSON.parse(fetchMock.mock.calls[0]![1]!.body as string) as {
+ files: unknown[];
+ }
+ ).files,
+ ).toHaveLength(1);
+});
+test("restore rejects a missing destination before sending a request", async () => {
+ getCollectionRecord.mockReturnValue(undefined);
+ await expect(restoreFromTrash(items, 9)).rejects.toThrow(
+ "Collection 9 not in cache",
+ );
+ expect(fetchMock).not.toHaveBeenCalled();
+});
+test("mutation failures propagate", async () => {
+ fetchMock.mockImplementation(() =>
+ Promise.resolve(new Response(null, { status: 500 })),
+ );
+ await expect(trashFiles([1], 2)).rejects.toThrow("Request failed");
+ await expect(permanentlyDeleteFromTrash([1])).rejects.toThrow(
+ "Request failed",
+ );
+ await expect(emptyTrash(123)).rejects.toThrow("Request failed");
+ await expect(restoreFromTrash(items, 9)).rejects.toThrow("Request failed");
+});