@oxy.so/services 11.8.0 → 11.10.0

package/src/ui/screens/fileManagement/__tests__/trashActions.test.ts

@@ -0,0 +1,177 @@
+/**
+ * The file manager's trash decisions (ADR 0043 D5), without the UI: "delete"
+ * in the library moves to trash (a blocked file, which cannot be trashed, is
+ * deleted); permanent deletion forces past remaining uses only after the
+ * person says yes; restore reports a stale trash list instead of failing.
+ */
+import {
+  deletePermanently,
+  errorStatus,
+  libraryRemovalFor,
+  remainingUses,
+  removeFromLibrary,
+  restoreFromTrash,
+  type TrashAssetsApi,
+} from '../trashActions';
+
+/** An `OxyApiError`-shaped refusal, as `@oxy.so/core` throws it. */
+function apiError(status: number, code: string, details?: Record<string, unknown>) {
+  return Object.assign(new Error(code), { status, code, details });
+}
+
+const stillUsed = (remainingLinks: number) =>
+  apiError(409, 'CONFLICT', {
+    summary: { fileId: 'f', wouldDelete: false, affectedApps: ['a'], remainingLinks, variants: [] },
+    message: 'Use ?force=true to delete anyway',
+  });
+
+function assetsApi(overrides: Partial<Record<keyof TrashAssetsApi, jest.Mock>> = {}) {
+  return {
+    trash: overrides.trash ?? jest.fn(async () => ({})),
+    restore: overrides.restore ?? jest.fn(async () => ({})),
+    delete: overrides.delete ?? jest.fn(async () => ({})),
+  };
+}
+
+describe('libraryRemovalFor', () => {
+  it('trashes an active file (or one whose status the server did not say)', () => {
+    expect(libraryRemovalFor({ status: 'active' })).toBe('trash');
+    expect(libraryRemovalFor({ status: undefined })).toBe('trash');
+  });
+
+  it('deletes a blocked file, which cannot go to trash', () => {
+    expect(libraryRemovalFor({ status: 'blocked' })).toBe('delete');
+  });
+});
+
+describe('errorStatus and remainingUses', () => {
+  it('read the status from the error or its response', () => {
+    expect(errorStatus(apiError(404, 'NOT_FOUND'))).toBe(404);
+    expect(errorStatus({ response: { status: 409 } })).toBe(409);
+    expect(errorStatus(new Error('network'))).toBeUndefined();
+  });
+
+  it('count remaining uses only on the 409 that carries a delete summary', () => {
+    expect(remainingUses(stillUsed(3))).toBe(3);
+    expect(remainingUses(apiError(409, 'FILE_NOT_IN_TRASH', { status: 'active' }))).toBeNull();
+    expect(remainingUses(apiError(500, 'INTERNAL'))).toBeNull();
+    expect(remainingUses(stillUsed(0))).toBeNull();
+  });
+});
+
+describe('deletePermanently', () => {
+  it('deletes without force when nothing uses the file', async () => {
+    const assets = assetsApi();
+    const confirm = jest.fn();
+    await expect(deletePermanently(assets, 'f', confirm)).resolves.toBe('deleted');
+    expect(assets.delete).toHaveBeenCalledTimes(1);
+    expect(assets.delete).toHaveBeenCalledWith('f');
+    expect(confirm).not.toHaveBeenCalled();
+  });
+
+  it('asks before forcing past remaining uses, and forces only on a yes', async () => {
+    const assets = assetsApi({
+      delete: jest.fn(async (_id: string, options?: { force?: boolean }) => {
+        if (!options?.force) throw stillUsed(2);
+        return {};
+      }),
+    });
+    const confirm = jest.fn(async () => true);
+    await expect(deletePermanently(assets, 'f', confirm)).resolves.toBe('deleted');
+    expect(confirm).toHaveBeenCalledWith(2);
+    expect(assets.delete).toHaveBeenLastCalledWith('f', { force: true });
+  });
+
+  it('keeps the file when the person says no', async () => {
+    const assets = assetsApi({
+      delete: jest.fn(async () => {
+        throw stillUsed(1);
+      }),
+    });
+    await expect(deletePermanently(assets, 'f', async () => false)).resolves.toBe('cancelled');
+    expect(assets.delete).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports a file already gone, and throws any other failure', async () => {
+    const gone = assetsApi({
+      delete: jest.fn(async () => {
+        throw apiError(404, 'NOT_FOUND');
+      }),
+    });
+    await expect(deletePermanently(gone, 'f', jest.fn())).resolves.toBe('gone');
+    const broken = assetsApi({
+      delete: jest.fn(async () => {
+        throw apiError(500, 'INTERNAL');
+      }),
+    });
+    await expect(deletePermanently(broken, 'f', jest.fn())).rejects.toMatchObject({ status: 500 });
+  });
+});
+
+describe('restoreFromTrash', () => {
+  it('restores', async () => {
+    const assets = assetsApi();
+    await expect(restoreFromTrash(assets, 'f')).resolves.toBe('restored');
+    expect(assets.restore).toHaveBeenCalledWith('f');
+  });
+
+  it('reports a file no longer in trash (restored elsewhere, or blocked) or gone', async () => {
+    const notInTrash = assetsApi({
+      restore: jest.fn(async () => {
+        throw apiError(409, 'FILE_NOT_IN_TRASH', { status: 'blocked' });
+      }),
+    });
+    await expect(restoreFromTrash(notInTrash, 'f')).resolves.toBe('not_in_trash');
+    const gone = assetsApi({
+      restore: jest.fn(async () => {
+        throw apiError(404, 'NOT_FOUND');
+      }),
+    });
+    await expect(restoreFromTrash(gone, 'f')).resolves.toBe('gone');
+    const otherConflict = assetsApi({
+      restore: jest.fn(async () => {
+        throw apiError(409, 'CONFLICT');
+      }),
+    });
+    await expect(restoreFromTrash(otherConflict, 'f')).rejects.toMatchObject({ status: 409 });
+  });
+});
+
+describe('removeFromLibrary', () => {
+  it('trashes the active files and deletes the blocked ones; one failure stops nothing', async () => {
+    const assets = assetsApi({
+      trash: jest.fn(async (id: string) => {
+        if (id === 'broken') throw apiError(500, 'INTERNAL');
+        return {};
+      }),
+    });
+    const result = await removeFromLibrary(
+      assets,
+      [
+        { id: 'a', filename: 'a.png', status: 'active' },
+        { id: 'broken', filename: 'b.png', status: 'active' },
+        { id: 'taken-down', filename: 'c.png', status: 'blocked' },
+      ],
+      jest.fn(),
+    );
+    expect(result).toEqual({ trashed: ['a'], deleted: ['taken-down'], failed: ['broken'] });
+    expect(assets.trash).not.toHaveBeenCalledWith('taken-down');
+    expect(assets.delete).toHaveBeenCalledWith('taken-down');
+  });
+
+  it('asks about a used blocked file by name, and leaves it out when kept', async () => {
+    const assets = assetsApi({
+      delete: jest.fn(async () => {
+        throw stillUsed(4);
+      }),
+    });
+    const confirm = jest.fn(async () => false);
+    const result = await removeFromLibrary(
+      assets,
+      [{ id: 'x', filename: 'claimed.jpg', status: 'blocked' }],
+      confirm,
+    );
+    expect(confirm).toHaveBeenCalledWith(4, 'claimed.jpg');
+    expect(result).toEqual({ trashed: [], deleted: [], failed: [] });
+  });
+});

package/src/ui/screens/fileManagement/trashActions.ts

@@ -0,0 +1,161 @@
+/**
+ * What the file manager does when the person removes, restores or deletes a
+ * file (ADR 0043 D5). Pure of React and of the UI: every call takes the asset
+ * API and the confirmation it may need, so the decisions are testable on their
+ * own and the screens only render.
+ *
+ * - "Delete" in the library MOVES TO TRASH: the file stops being served, is
+ *   kept, and can be restored from Trash. A `blocked` file (taken down after a
+ *   content claim, D10) cannot be trashed — it is already served to nobody —
+ *   so removing it is the permanent delete, which is its owner's to make.
+ * - Permanent deletion happens only from Trash (or for a blocked file). The
+ *   API refuses to delete a file an application still uses (409, with the
+ *   number of uses); the person is told and decides, and only then is the
+ *   delete forced.
+ */
+import type { FileMetadata } from '@oxy.so/core';
+
+/** The part of `oxyServices.assets` these actions use. */
+export interface TrashAssetsApi {
+  trash(fileId: string): Promise<unknown>;
+  restore(fileId: string): Promise<unknown>;
+  delete(fileId: string, options?: { force?: boolean }): Promise<unknown>;
+}
+
+/** What removing a file from the library does to it. */
+export type LibraryRemoval = 'trash' | 'delete';
+
+/** A `blocked` file is deleted (it cannot go to trash); every other is trashed. */
+export function libraryRemovalFor(file: Pick<FileMetadata, 'status'>): LibraryRemoval {
+  return file.status === 'blocked' ? 'delete' : 'trash';
+}
+
+/** The HTTP status of a failed asset call, when it carries one. */
+export function errorStatus(error: unknown): number | undefined {
+  if (error && typeof error === 'object') {
+    const status = (error as { status?: unknown }).status;
+    if (typeof status === 'number') return status;
+    const response = (error as { response?: { status?: unknown } }).response;
+    if (response && typeof response.status === 'number') return response.status;
+  }
+  return undefined;
+}
+
+/** The API's machine code of a failed asset call, when it carries one. */
+function errorCode(error: unknown): string | undefined {
+  if (error && typeof error === 'object') {
+    const code = (error as { code?: unknown }).code;
+    if (typeof code === 'string') return code;
+  }
+  return undefined;
+}
+
+/**
+ * How many uses an application still has of a file the API refused to delete
+ * (409, `details.summary.remainingLinks`), or `null` when the refusal is not
+ * that one.
+ */
+export function remainingUses(error: unknown): number | null {
+  if (errorStatus(error) !== 409 || !error || typeof error !== 'object') return null;
+  const details = (error as { details?: unknown }).details;
+  const summary =
+    details && typeof details === 'object' ? (details as { summary?: unknown }).summary : undefined;
+  const remaining =
+    summary && typeof summary === 'object'
+      ? (summary as { remainingLinks?: unknown }).remainingLinks
+      : undefined;
+  return typeof remaining === 'number' && remaining > 0 ? remaining : null;
+}
+
+/** Outcome of {@link deletePermanently}. */
+export type PermanentDeleteOutcome = 'deleted' | 'cancelled' | 'gone';
+
+/**
+ * Delete a file for good. When applications still use it the API refuses;
+ * `confirmStillUsed(count)` asks the person, and only a yes forces the delete.
+ * A file already gone (404) is `gone` — the caller just refreshes. Any other
+ * failure is thrown.
+ */
+export async function deletePermanently(
+  assets: TrashAssetsApi,
+  fileId: string,
+  confirmStillUsed: (uses: number) => Promise<boolean>,
+): Promise<PermanentDeleteOutcome> {
+  try {
+    await assets.delete(fileId);
+    return 'deleted';
+  } catch (error) {
+    if (errorStatus(error) === 404) return 'gone';
+    const uses = remainingUses(error);
+    if (uses === null) throw error;
+    if (!(await confirmStillUsed(uses))) return 'cancelled';
+    await assets.delete(fileId, { force: true });
+    return 'deleted';
+  }
+}
+
+/** Outcome of {@link restoreFromTrash}. */
+export type RestoreOutcome = 'restored' | 'not_in_trash' | 'gone';
+
+/**
+ * Bring a file back from trash. One that is no longer in trash — restored
+ * elsewhere, or blocked after a claim (409 `FILE_NOT_IN_TRASH`) — or no longer
+ * exists (404) is reported, not thrown: the trash list is just stale.
+ */
+export async function restoreFromTrash(
+  assets: TrashAssetsApi,
+  fileId: string,
+): Promise<RestoreOutcome> {
+  try {
+    await assets.restore(fileId);
+    return 'restored';
+  } catch (error) {
+    if (errorStatus(error) === 404) return 'gone';
+    if (errorStatus(error) === 409 && errorCode(error) === 'FILE_NOT_IN_TRASH') {
+      return 'not_in_trash';
+    }
+    throw error;
+  }
+}
+
+/** Per-file outcome of removing several files from the library. */
+export interface LibraryRemovalResult {
+  trashed: string[];
+  deleted: string[];
+  failed: string[];
+}
+
+/**
+ * Remove several files from the library at once: each goes to trash, except a
+ * blocked one, which is deleted (asking about remaining uses as
+ * {@link deletePermanently} does). One failure never stops the others.
+ */
+export async function removeFromLibrary(
+  assets: TrashAssetsApi,
+  files: ReadonlyArray<Pick<FileMetadata, 'id' | 'status' | 'filename'>>,
+  confirmStillUsed: (uses: number, filename: string) => Promise<boolean>,
+): Promise<LibraryRemovalResult> {
+  const result: LibraryRemovalResult = { trashed: [], deleted: [], failed: [] };
+  const toTrash = files.filter((file) => libraryRemovalFor(file) === 'trash');
+  const toDelete = files.filter((file) => libraryRemovalFor(file) === 'delete');
+
+  const trashed = await Promise.allSettled(toTrash.map((file) => assets.trash(file.id)));
+  trashed.forEach((settled, index) => {
+    (settled.status === 'fulfilled' ? result.trashed : result.failed).push(toTrash[index].id);
+  });
+
+  // One at a time: each may ask the person a question, and two questions at
+  // once would stack.
+  for (const file of toDelete) {
+    try {
+      const outcome = await deletePermanently(assets, file.id, (uses) =>
+        confirmStillUsed(uses, file.filename),
+      );
+      // `cancelled`: the person kept it; nothing to report.
+      if (outcome !== 'cancelled') result.deleted.push(file.id);
+    } catch {
+      result.failed.push(file.id);
+    }
+  }
+  return result;
+}

package/src/ui/stores/assetStore.ts

@@ -1,6 +1,20 @@
 import { create } from 'zustand';
 import type { Asset, AssetUploadProgress, AssetLink } from '@oxy.so/core';
 
+/**
+ * Whether a link is the given application's use. The Oxy API names the using
+ * application by ID (`applicationId`, mirrored in `app` since ADR 0043 D4);
+ * a link added locally before the server answered may still carry the name
+ * the caller passed in `app`. Either matches.
+ */
+function linkIsApp(link: AssetLink, app: string): boolean {
+  return (link.applicationId ?? link.app) === app || link.app === app;
+}
+
+function sameLink(link: AssetLink, app: string, entityType: string, entityId: string): boolean {
+  return linkIsApp(link, app) && link.entityType === entityType && link.entityId === entityId;
+}
+
 interface AssetState {
   // Asset data
   assets: Record<string, Asset>;
@@ -145,7 +159,8 @@ export const useAssetStore = create<AssetState>((set, get) => ({
       // Check if link already exists
       const existingLink = asset.links.find(
         (l: AssetLink) =>
-          l.app === link.app && l.entityType === link.entityType && l.entityId === link.entityId,
+          sameLink(l, link.applicationId ?? link.app, link.entityType, link.entityId) ||
+          sameLink(l, link.app, link.entityType, link.entityId),
       );
 
       if (existingLink) return state;
@@ -154,6 +169,7 @@ export const useAssetStore = create<AssetState>((set, get) => ({
         ...asset,
         links: [...asset.links, link],
         usageCount: asset.links.length + 1,
+        inUse: true,
       };
 
       return {
@@ -171,15 +187,16 @@ export const useAssetStore = create<AssetState>((set, get) => ({
       if (!asset) return state;
 
       const filteredLinks = asset.links.filter(
-        (link: AssetLink) =>
-          !(link.app === app && link.entityType === entityType && link.entityId === entityId),
+        (link: AssetLink) => !sameLink(link, app, entityType, entityId),
       );
 
       const updatedAsset = {
         ...asset,
         links: filteredLinks,
         usageCount: filteredLinks.length,
-        status: filteredLinks.length === 0 ? ('trash' as const) : asset.status,
+        // The last link going never trashes the file (ADR 0043 D5): it stays
+        // where it is and is only no longer in use.
+        inUse: filteredLinks.length > 0,
       };
 
       return {
@@ -237,17 +254,14 @@ export const useAssetStore = create<AssetState>((set, get) => ({
   getAssetsByApp: (app: string) => {
     const { assets } = get();
     return Object.values(assets).filter((asset) =>
-      asset.links.some((link: AssetLink) => link.app === app),
+      asset.links.some((link: AssetLink) => linkIsApp(link, app)),
     );
   },
 
   getAssetsByEntity: (app: string, entityType: string, entityId: string) => {
     const { assets } = get();
     return Object.values(assets).filter((asset) =>
-      asset.links.some(
-        (link: AssetLink) =>
-          link.app === app && link.entityType === entityType && link.entityId === entityId,
-      ),
+      asset.links.some((link: AssetLink) => sameLink(link, app, entityType, entityId)),
     );
   },
 
@@ -262,10 +276,7 @@ export const useAssetStore = create<AssetState>((set, get) => ({
     const asset = assets[assetId];
     if (!asset) return false;
 
-    return asset.links.some(
-      (link: AssetLink) =>
-        link.app === app && link.entityType === entityType && link.entityId === entityId,
-    );
+    return asset.links.some((link: AssetLink) => sameLink(link, app, entityType, entityId));
   },
 
   // Reset store