@futo-org/backups-orchestrator-ui 0.1.71

package/dist/services/runHistory.service.d.ts

@@ -0,0 +1,26 @@
+import { sdk } from '..';
+import { SocketEvent } from '../events';
+import { type RunDto } from '../fetch-client';
+import { type ActionItem } from '@immich/ui';
+export declare const runHistoryKeys: {
+    byRepository: (id: string) => readonly ["runHistory", string];
+};
+export declare const runKeys: {
+    byId: (id: string) => readonly ["run", string];
+};
+export declare const useRunHistory: (repositoryId: string) => import("@tanstack/svelte-query").CreateQueryResult<sdk.RunDto[], Error>;
+export declare const useRun: (logId: string) => import("@tanstack/svelte-query").CreateQueryResult<sdk.RunDto, Error>;
+export declare const useRunEventHandler: () => {
+    onRunCreate(event: SocketEvent<{
+        run: RunDto;
+    }>): void;
+    onRunUpdate(event: SocketEvent<{
+        runId: string;
+        repositoryId: string;
+        run: Partial<RunDto>;
+    }>): void;
+};
+export declare const handleGetRunHistory: (id: string) => Promise<sdk.RunHistoryResponseDto>;
+export declare const getRunActions: (run: RunDto) => {
+    ViewLog: ActionItem;
+};

package/dist/services/runHistory.service.js

@@ -0,0 +1,54 @@
+import { sdk } from '..';
+import ViewLogModal from '../components/backups/dialogs/ViewLogModal.svelte';
+import { SocketEvent } from '../events';
+import { getRun, getRunHistory } from '../fetch-client';
+import { queryClient } from '../query-client';
+import { handleError } from '../utils/handle-error';
+import { modalManager } from '@immich/ui';
+import { createQuery } from '@tanstack/svelte-query';
+export const runHistoryKeys = {
+    byRepository: (id) => ['runHistory', id],
+};
+export const runKeys = {
+    byId: (id) => ['run', id],
+};
+export const useRunHistory = (repositoryId) => createQuery(() => ({
+    queryKey: runHistoryKeys.byRepository(repositoryId),
+    queryFn: () => getRunHistory(repositoryId).then(({ runs }) => runs.toSorted((a, b) => b.start.localeCompare(a.start))),
+}), () => queryClient);
+export const useRun = (logId) => createQuery(() => ({
+    queryKey: runKeys.byId(logId),
+    queryFn: () => getRun(logId).then(({ run }) => run),
+}), () => queryClient);
+export const useRunEventHandler = () => {
+    return {
+        onRunCreate(event) {
+            queryClient.setQueryData(runKeys.byId(event.data.run.id), event.data.run);
+            queryClient.setQueryData(runHistoryKeys.byRepository(event.data.run.repositoryId), (data) => data ? [event.data.run, ...data] : void 0);
+        },
+        onRunUpdate(event) {
+            queryClient.setQueryData(runKeys.byId(event.data.runId), (data) => data ? { ...data, ...event.data.run } : void 0);
+            queryClient.setQueryData(runHistoryKeys.byRepository(event.data.repositoryId), (data) => data
+                ? data.map((entry) => entry.id === event.data.runId
+                    ? { ...entry, ...event.data.run }
+                    : entry)
+                : void 0);
+        },
+    };
+};
+export const handleGetRunHistory = async (id) => {
+    try {
+        return await sdk.getRunHistory(id);
+    }
+    catch (error) {
+        handleError(error, 'Failed to load run history');
+        throw error;
+    }
+};
+export const getRunActions = (run) => {
+    const ViewLog = {
+        title: 'View Log',
+        onAction: () => void modalManager.open(ViewLogModal, { logId: run.id }),
+    };
+    return { ViewLog };
+};

package/dist/services/schedule.service.d.ts

@@ -0,0 +1,35 @@
+import { sdk } from '..';
+import { type ScheduleDto, type ScheduleUpdateRequestDto } from '../fetch-client';
+import { SocketEvent } from '../events';
+import { type ActionItem } from '@immich/ui';
+export declare const scheduleKeys: {
+    all: readonly ["schedules"];
+};
+export declare const useSchedules: () => import("@tanstack/svelte-query").CreateQueryResult<sdk.ScheduleDto[], Error>;
+export declare const useScheduleEventHandler: () => {
+    onScheduleCreate(event: SocketEvent<{
+        schedule: ScheduleDto;
+    }>): void;
+    onScheduleUpdate(event: SocketEvent<{
+        scheduleId: string;
+        schedule: Partial<ScheduleDto>;
+    }>): void;
+    onScheduleDelete(event: SocketEvent<{
+        scheduleId: string;
+    }>): void;
+};
+export declare const handleGetSchedules: () => Promise<sdk.ScheduleListResponseDto>;
+export declare const useCreateSchedule: () => import("@tanstack/svelte-query").CreateMutationResult<sdk.ScheduleCreateResponseDto, Error, sdk.ScheduleCreateRequestDto, unknown>;
+export declare const useUpdateSchedule: () => import("@tanstack/svelte-query").CreateMutationResult<sdk.ScheduleUpdateResponseDto, Error, {
+    id: string;
+    dto: ScheduleUpdateRequestDto;
+}, unknown>;
+export declare const handlePauseSchedule: (id: string, name: string) => Promise<void>;
+export declare const handleResumeSchedule: (id: string, name: string) => Promise<void>;
+export declare const handleRemoveSchedule: (id: string, name: string) => Promise<void>;
+export declare const getScheduleActions: (schedule: ScheduleDto) => {
+    Resume: ActionItem;
+    Pause: ActionItem;
+    Configure: ActionItem;
+    Delete: ActionItem;
+};

package/dist/services/schedule.service.js

@@ -0,0 +1,126 @@
+import { sdk } from '..';
+import ConfigureScheduleModal from '../components/schedules/dialogs/ConfigureScheduleModal.svelte';
+import { getSchedules, } from '../fetch-client';
+import { SocketEvent } from '../events';
+import { modalManager, toastManager } from '@immich/ui';
+import { mdiCog, mdiDelete, mdiPause, mdiPlay } from '@mdi/js';
+import { handleError } from '../utils/handle-error';
+import { queryClient } from '../query-client';
+import { createMutation, createQuery } from '@tanstack/svelte-query';
+export const scheduleKeys = {
+    all: ['schedules'],
+};
+export const useSchedules = () => createQuery(() => ({
+    queryKey: scheduleKeys.all,
+    queryFn: () => getSchedules().then(({ schedules }) => schedules),
+}), () => queryClient);
+export const useScheduleEventHandler = () => {
+    return {
+        onScheduleCreate(event) {
+            queryClient.setQueryData(scheduleKeys.all, (data) => {
+                return data ? [...data, event.data.schedule] : void 0;
+            });
+        },
+        onScheduleUpdate(event) {
+            queryClient.setQueryData(scheduleKeys.all, (data) => {
+                return data
+                    ? data.map((entry) => entry.id === event.data.scheduleId
+                        ? { ...entry, ...event.data.schedule }
+                        : entry)
+                    : void 0;
+            });
+        },
+        onScheduleDelete(event) {
+            queryClient.setQueryData(scheduleKeys.all, (data) => {
+                return data
+                    ? data.filter((entry) => entry.id !== event.data.scheduleId)
+                    : void 0;
+            });
+        },
+    };
+};
+export const handleGetSchedules = async () => {
+    try {
+        return await sdk.getSchedules();
+    }
+    catch (error) {
+        handleError(error, 'Failed to load schedules');
+        throw error;
+    }
+};
+export const useCreateSchedule = () => createMutation(() => ({
+    mutationFn: (dto) => sdk.createSchedule(dto),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: scheduleKeys.all }),
+    onError: (error) => handleError(error, 'Failed to create schedule'),
+}), () => queryClient);
+export const useUpdateSchedule = () => createMutation(() => ({
+    mutationFn: ({ id, dto, }) => sdk.updateSchedule(id, dto),
+    onSuccess: () => void queryClient.invalidateQueries({ queryKey: scheduleKeys.all }),
+    onError: (error) => handleError(error, 'Failed to update schedule'),
+}), () => queryClient);
+export const handlePauseSchedule = async (id, name) => {
+    try {
+        await sdk.updateSchedule(id, { paused: true });
+        toastManager.info(`Paused schedule "${name}"`);
+    }
+    catch (error) {
+        handleError(error, 'Failed to pause schedule');
+        throw error;
+    }
+};
+export const handleResumeSchedule = async (id, name) => {
+    try {
+        await sdk.updateSchedule(id, { paused: false });
+        toastManager.success(`Resumed schedule "${name}"`);
+    }
+    catch (error) {
+        handleError(error, 'Failed to resume schedule');
+        throw error;
+    }
+};
+export const handleRemoveSchedule = async (id, name) => {
+    try {
+        await sdk.removeSchedule(id);
+        toastManager.info(`Deleted schedule "${name}"`);
+    }
+    catch (error) {
+        handleError(error, 'Failed to delete schedule');
+        throw error;
+    }
+};
+export const getScheduleActions = (schedule) => {
+    const Resume = {
+        title: 'Resume',
+        icon: mdiPlay,
+        onAction: () => void handleResumeSchedule(schedule.id, schedule.name),
+        $if: () => schedule.paused,
+    };
+    const Pause = {
+        title: 'Pause',
+        icon: mdiPause,
+        onAction: () => void handlePauseSchedule(schedule.id, schedule.name),
+        $if: () => !schedule.paused,
+    };
+    const Configure = {
+        title: 'Configure',
+        icon: mdiCog,
+        onAction: () => void modalManager.open(ConfigureScheduleModal, { schedule }),
+    };
+    const Delete = {
+        title: 'Delete',
+        icon: mdiDelete,
+        color: 'danger',
+        onAction: async () => {
+            const confirm = await modalManager.showDialog({
+                confirmText: 'Delete',
+                title: 'Delete Schedule',
+                prompt: 'This schedule will be removed.',
+            });
+            if (!confirm) {
+                return;
+            }
+            await handleRemoveSchedule(schedule.id, schedule.name);
+        },
+    };
+    return { Resume, Pause, Configure, Delete };
+};

package/dist/services/snapshot.service.d.ts

@@ -0,0 +1,29 @@
+import { sdk } from '..';
+import { SocketEvent } from '../events';
+import { type RepositorySnapshotRestoreFromPointRequestDto, type RepositorySnapshotRestoreRequestDto, type RunDto, type SnapshotDto } from '../fetch-client';
+import { type ActionItem } from '@immich/ui';
+export declare const snapshotKeys: {
+    byRepository: (id: string) => readonly ["snapshots", string];
+};
+export declare const useSnapshots: (repositoryId: string) => import("@tanstack/svelte-query").CreateQueryResult<sdk.SnapshotDto[], Error>;
+export declare const useSnapshotEventHandler: () => {
+    onRunUpdate(event: SocketEvent<{
+        runId: string;
+        repositoryId: string;
+        run: Partial<RunDto>;
+    }>): void;
+};
+export declare const useRemoveSnapshot: (repositoryId: string) => (snapshotId: string) => void;
+export declare const handleGetSnapshots: (repositoryId: string) => Promise<sdk.ListSnapshotsResponseDto>;
+export declare const useRestoreSnapshot: () => import("@tanstack/svelte-query").CreateMutationResult<sdk.LogResponseDto, Error, {
+    repositoryId: string;
+    snapshotId: string;
+    options: RepositorySnapshotRestoreRequestDto;
+}, unknown>;
+export declare const handleRestoreFromPoint: (repositoryId: string, snapshotId: string, backendId: string, options: RepositorySnapshotRestoreFromPointRequestDto) => Promise<sdk.LogResponseDto>;
+export declare const handleForgetSnapshot: (repositoryId: string, snapshotId: string) => Promise<void>;
+export declare const handleGetSnapshotListing: (id: string, snapshotId: string, path?: string) => Promise<sdk.FilesystemListingResponseDto>;
+export declare const getSnapshotActions: (repositoryId: string, snapshot: SnapshotDto) => {
+    Restore: ActionItem;
+    Delete: ActionItem;
+};

package/dist/services/snapshot.service.js

@@ -0,0 +1,108 @@
+import { sdk } from '..';
+import RestoreSnapshotModal from '../components/backups/dialogs/RestoreSnapshotModal.svelte';
+import { SocketEvent } from '../events';
+import { getSnapshots, } from '../fetch-client';
+import { queryClient } from '../query-client';
+import { handleError } from '../utils/handle-error';
+import { modalManager, toastManager } from '@immich/ui';
+import { mdiBackupRestore, mdiDeleteOutline } from '@mdi/js';
+import { createMutation, createQuery } from '@tanstack/svelte-query';
+export const snapshotKeys = {
+    byRepository: (id) => ['snapshots', id],
+};
+export const useSnapshots = (repositoryId) => createQuery(() => ({
+    queryKey: snapshotKeys.byRepository(repositoryId),
+    queryFn: () => getSnapshots(repositoryId).then(({ snapshots }) => snapshots.toSorted((a, b) => b.time.localeCompare(a.time))),
+}), () => queryClient);
+export const useSnapshotEventHandler = () => {
+    return {
+        onRunUpdate(event) {
+            if (event.data.run.status === 'complete') {
+                void queryClient.invalidateQueries({
+                    queryKey: snapshotKeys.byRepository(event.data.repositoryId),
+                });
+            }
+        },
+    };
+};
+export const useRemoveSnapshot = (repositoryId) => {
+    return (snapshotId) => {
+        queryClient.setQueryData(snapshotKeys.byRepository(repositoryId), (data) => {
+            return data ? data.filter((entry) => entry.id !== snapshotId) : void 0;
+        });
+    };
+};
+export const handleGetSnapshots = async (repositoryId) => {
+    try {
+        return await sdk.getSnapshots(repositoryId);
+    }
+    catch (error) {
+        handleError(error, 'Failed to load snapshots');
+        throw error;
+    }
+};
+export const useRestoreSnapshot = () => createMutation(() => ({
+    mutationFn: ({ repositoryId, snapshotId, options, }) => sdk.restoreSnapshot(repositoryId, snapshotId, options),
+    onError: (error) => handleError(error, 'Failed to start restore'),
+}), () => queryClient);
+export const handleRestoreFromPoint = async (repositoryId, snapshotId, backendId, options) => {
+    return await sdk.restoreFromPoint(repositoryId, snapshotId, backendId, options);
+};
+export const handleForgetSnapshot = async (repositoryId, snapshotId) => {
+    toastManager.info('Deleting snapshot', {
+        id: snapshotId,
+        closable: false,
+        timeout: null,
+    });
+    try {
+        await sdk.forgetSnapshot(repositoryId, snapshotId);
+        toastManager.success('Deleted snapshot');
+    }
+    catch (error) {
+        handleError(error, 'Failed to delete snapshot');
+        throw error;
+    }
+    finally {
+        toastManager.remove({
+            id: snapshotId,
+        });
+    }
+};
+export const handleGetSnapshotListing = async (id, snapshotId, path) => {
+    try {
+        return await sdk.getSnapshotListing(id, snapshotId, { path });
+    }
+    catch (error) {
+        handleError(error, 'Failed to load directory listing');
+        throw error;
+    }
+};
+export const getSnapshotActions = (repositoryId, snapshot) => {
+    const removeSnapshot = useRemoveSnapshot(repositoryId);
+    const Restore = {
+        title: 'Restore',
+        icon: mdiBackupRestore,
+        onAction: () => void modalManager.open(RestoreSnapshotModal, {
+            repository: repositoryId,
+            snapshot: snapshot.id,
+        }),
+    };
+    const Delete = {
+        title: 'Delete',
+        icon: mdiDeleteOutline,
+        color: 'danger',
+        onAction: async () => {
+            const confirm = await modalManager.showDialog({
+                confirmText: 'Delete',
+                title: 'Delete Snapshot',
+                prompt: 'This snapshot will be permanently removed.',
+            });
+            if (!confirm) {
+                return;
+            }
+            await handleForgetSnapshot(repositoryId, snapshot.id);
+            removeSnapshot(snapshot.id);
+        },
+    };
+    return { Restore, Delete };
+};

package/dist/services/task.service.d.ts

@@ -0,0 +1,3 @@
+import { sdk } from '..';
+export declare const handleGetRunningTasks: () => Promise<sdk.RunningTaskListResponse>;
+export declare const handleCancelTask: (parentId: string) => Promise<void>;

package/dist/services/task.service.js

@@ -0,0 +1,20 @@
+import { sdk } from '..';
+import { handleError } from '../utils/handle-error';
+export const handleGetRunningTasks = async () => {
+    try {
+        return await sdk.getRunningTasks();
+    }
+    catch (error) {
+        handleError(error, 'Failed to load running tasks');
+        throw error;
+    }
+};
+export const handleCancelTask = async (parentId) => {
+    try {
+        await sdk.cancelTask(parentId);
+    }
+    catch (error) {
+        handleError(error, 'Failed to cancel task');
+        throw error;
+    }
+};

package/dist/utils/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionItem } from '@immich/ui';
+export declare function hasActions(actions: ActionItem[]): boolean;

package/dist/utils/actions.js

@@ -0,0 +1,3 @@
+export function hasActions(actions) {
+    return actions.some((action) => !action.$if || action.$if?.());
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,2 @@
+export declare const formatDuration: (ms: number) => string;
+export declare const humanizeBackupPath: (path: string) => string;

package/dist/utils/format.js

@@ -0,0 +1,24 @@
+import { Duration } from 'luxon';
+export const formatDuration = (ms) => {
+    const seconds = Math.round(ms / 1000);
+    return seconds < 1
+        ? '<1s'
+        : Duration.fromMillis(seconds * 1000)
+            .rescale()
+            .toHuman({ unitDisplay: 'narrow' });
+};
+const IMMICH_FOLDER_LABELS = {
+    upload: 'Photos and videos',
+    profile: 'Photos and videos',
+    library: 'Photos and videos',
+    backups: 'Database backups',
+    thumbs: 'Thumbnails and previews',
+    'encoded-video': 'Encoded videos',
+};
+export const humanizeBackupPath = (path) => {
+    if (path.includes('yucca')) {
+        return 'Backup configuration';
+    }
+    const basename = path.replace(/\/+$/, '').split('/').pop() ?? path;
+    return IMMICH_FOLDER_LABELS[basename] ?? basename;
+};

package/dist/utils/handle-error.d.ts

@@ -0,0 +1,9 @@
+export declare function getServerErrorMessage(error: {
+    data?: {
+        message?: string;
+    };
+    message?: string;
+}): string | undefined;
+export declare function standardizeError(error: unknown): Error;
+export declare function getReadableErrorMessage(error: unknown): string;
+export declare function handleError(error: unknown, localizedMessage: string): string | undefined;

package/dist/utils/handle-error.js

@@ -0,0 +1,42 @@
+import { toastManager } from '@immich/ui';
+export function getServerErrorMessage(error) {
+    // errors for endpoints without return types aren't parsed as json
+    let data = error.data;
+    if (typeof data === 'string') {
+        try {
+            data = JSON.parse(data);
+        }
+        catch {
+            // Not a JSON string
+        }
+    }
+    return data?.message || error.message;
+}
+export function standardizeError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+export function getReadableErrorMessage(error) {
+    return (getServerErrorMessage(error) ||
+        standardizeError(error).message ||
+        'An unknown error occurred');
+}
+export function handleError(error, localizedMessage) {
+    const standardizedError = standardizeError(error);
+    if (standardizedError.name === 'AbortError') {
+        return;
+    }
+    console.error(`[handleError]: ${standardizedError}`, error, standardizedError.stack);
+    try {
+        let serverMessage = getServerErrorMessage(error);
+        if (serverMessage) {
+            serverMessage = `${String(serverMessage).slice(0, 75)}\n(Yucca Server Error)`;
+        }
+        const errorMessage = serverMessage || localizedMessage;
+        toastManager.danger(errorMessage);
+        return errorMessage;
+    }
+    catch (error) {
+        console.error(error);
+        return localizedMessage;
+    }
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@futo-org/backups-orchestrator-ui",
+  "version": "0.1.71",
+  "license": "Source First License 1.1",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    },
+    "./sdk": {
+      "types": "./dist/fetch-client.d.ts",
+      "default": "./dist/fetch-client.js"
+    }
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.57.0",
+    "@sveltejs/adapter-auto": "^7.0.0",
+    "@sveltejs/kit": "^2.50.1",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@tailwindcss/vite": "^4.1.18",
+    "@types/d3": "^7.4.3",
+    "@types/lodash.debounce": "^4.0.9",
+    "@types/luxon": "^3.7.1",
+    "@vitest/browser-playwright": "^4.0.18",
+    "oazapfts": "^7.0.1",
+    "playwright": "^1.57.0",
+    "prettier-plugin-tailwindcss": "^0.7.2",
+    "publint": "^0.3.17",
+    "svelte": "^5.48.2",
+    "svelte-check": "^4.3.5",
+    "tailwindcss": "^4.1.18",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18",
+    "vitest-browser-svelte": "^2.0.2"
+  },
+  "keywords": [
+    "svelte"
+  ],
+  "dependencies": {
+    "@immich/ui": "^0.59.0",
+    "@mdi/js": "^7.4.47",
+    "@oazapfts/runtime": "^1.1.0",
+    "@tanstack/svelte-query": "^6.1.3",
+    "cron-validate": "^1.5.3",
+    "cronstrue": "^3.14.0",
+    "lodash.debounce": "^4.0.8",
+    "luxon": "^3.7.2",
+    "socket.io-client": "^4.8.3",
+    "@futo-org/backups-api-client": "^0.1.71"
+  },
+  "scripts": {
+    "dev": "vite dev --port 5174",
+    "build": "vite build && npm run prepack",
+    "preview": "vite preview --port 4174",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "test:unit": "vitest --run",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:e2e": "playwright test",
+    "test:e2e:create": "playwright codegen http://localhost:36066",
+    "generate:fetch-client": "oazapfts --optimistic ../orchestration-api/openapi-specs.json src/lib/fetch-client.ts"
+  }
+}