+ {#if $form.tls}
+
-
{
- $form.tls = e.currentTarget.checked ? { verification: 'Full' } : undefined;
+ $form.tls = { verification: e.currentTarget.checked ? 'Full' : 'None' };
}}
/>
+ {/if}
- {#if $form.tls}
-
-
-
-
- {m.storage_connect_tls_verification_hint()}
-
-
-
{
- $form.tls = { verification: e.currentTarget.checked ? 'Full' : 'None' };
- }}
- />
-
- {/if}
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+ {#if $errors?.region?.name}
+
{$errors.region.name}
+ {/if}
+
-
-
-
-
- {#if $errors?.region?.name}
-
{$errors.region.name}
- {/if}
-
+
+
+
+
+ {#if $errors?.credentials?.accessKey}
+
{$errors.credentials.accessKey}
+ {/if}
+
-
-
-
-
- {#if $errors?.credentials?.accessKey}
-
{$errors.credentials.accessKey}
- {/if}
-
+
+
+
+
+
+ {m.storage_connection_edit_credentials_hint()}
+
+ {#if $errors?.credentials?.secretKey}
+
{$errors.credentials.secretKey}
+ {/if}
+
-
-
-
-
-
- {m.storage_connection_edit_credentials_hint()}
-
- {#if $errors?.credentials?.secretKey}
-
{$errors.credentials.secretKey}
- {/if}
-
+ {#if $message?.type === 'error'}
+
{$message.message}
+ {/if}
- {#if $message?.type === 'error'}
-
{$message.message}
+
+
-
-
-
-
-{/if}
+
diff --git a/src/routes/(app)/settings/connections/[id]/edit/page.server.test.ts b/src/routes/(app)/settings/connections/[id]/edit/page.server.test.ts
new file mode 100644
index 00000000..7de6b1c4
--- /dev/null
+++ b/src/routes/(app)/settings/connections/[id]/edit/page.server.test.ts
@@ -0,0 +1,204 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockConnectionProvider = { listContainers: vi.fn() };
+const mockGetConnectionProvider = vi.fn((config: unknown) => {
+ void config;
+ return mockConnectionProvider;
+});
+vi.mock('$lib/server/storage/utils.js', () => ({
+ getConnectionProvider: (config: unknown) => mockGetConnectionProvider(config)
+}));
+
+vi.mock('$lib/storage/schemas.js', () => ({
+ EditStorageConnectionSchema: {},
+ ConnectionIdSchema: {},
+ StoredStorageConnectionSchema: { parse: (value: unknown) => value }
+}));
+
+vi.mock('$lib/server/auth.js', () => ({
+ auth: { api: { updateSession: vi.fn() } }
+}));
+
+vi.mock('$lib/server/storage/connections-db.js', () => ({
+ isConnectionNameConflict: () => false,
+ deleteConnection: vi.fn()
+}));
+
+vi.mock('sveltekit-superforms', () => ({
+ superValidate: vi.fn(),
+ message: vi.fn((form, msg, opts) => ({ form, message: msg, status: opts?.status })),
+ setError: vi.fn((form, field, msg) => ({ form, field, error: msg }))
+}));
+
+vi.mock('sveltekit-superforms/adapters', () => ({
+ zod4: vi.fn((schema) => schema)
+}));
+
+const mockDbSelect = vi.fn();
+const mockDbUpdate = vi.fn().mockResolvedValue(undefined);
+vi.mock('$lib/server/db.js', () => ({
+ db: {
+ select: () => ({ from: () => ({ where: () => ({ limit: mockDbSelect }) }) }),
+ update: () => ({ set: () => ({ where: mockDbUpdate }) })
+ }
+}));
+
+const mockFingerprint = vi.fn(() => 'changed-hash');
+vi.mock('$lib/server/storage/encryption.js', () => ({
+ encrypt: vi.fn(() => 'encrypted-payload'),
+ decrypt: vi.fn((payload: string) => payload),
+ fingerprint: () => mockFingerprint()
+}));
+
+vi.mock('$lib/server/storage/encryption-key.js', () => ({
+ storageEncryptionKey: () => Buffer.alloc(32)
+}));
+
+vi.mock('$lib/server/schema.js', () => ({
+ userStorageConnections: {}
+}));
+
+import { actions } from './+page.server.js';
+import { superValidate } from 'sveltekit-superforms';
+
+const storedCredentials = { accessKey: 'stored-ak', secretKey: 'stored-sk' };
+
+const storedPayload = {
+ host: 's3.example.com',
+ port: 9000,
+ accessStyle: 'Path',
+ region: { name: 'us-east-1' },
+ credentials: storedCredentials
+};
+
+function mockForm(credentials = { accessKey: '', secretKey: '' }) {
+ vi.mocked(superValidate).mockResolvedValue({
+ valid: true,
+ data: {
+ id: 'conn-1',
+ name: 'Renamed',
+ type: 's3',
+ host: 's3.example.com',
+ port: 9000,
+ accessStyle: 'Path',
+ region: { name: 'us-east-1' },
+ credentials
+ }
+ } as unknown as Awaited
>);
+}
+
+function mockStoredRow(payload: object = storedPayload) {
+ mockDbSelect.mockResolvedValue([
+ { encryptedPayload: JSON.stringify(payload), hash: 'stored-hash' }
+ ]);
+}
+
+function update() {
+ return actions.update({
+ request: new Request('http://localhost', { method: 'POST' }),
+ params: { id: 'conn-1' },
+ locals: {
+ logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+ user: { id: 'test-user' }
+ }
+ } as unknown as Parameters[0]);
+}
+
+describe('connection edit update action', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockFingerprint.mockReturnValue('changed-hash');
+ mockConnectionProvider.listContainers.mockResolvedValue(['bucket']);
+ mockDbUpdate.mockResolvedValue(undefined);
+ });
+
+ it('tests the connection with the stored credentials when the fields are blank', async () => {
+ mockForm();
+ mockStoredRow();
+
+ const result = await update();
+
+ expect(mockGetConnectionProvider).toHaveBeenCalledWith(
+ expect.objectContaining({ credentials: storedCredentials })
+ );
+ expect(result).toMatchObject({ message: { type: 'success' } });
+ });
+
+ it('tests a connection without stored credentials anonymously', async () => {
+ mockForm();
+ mockStoredRow({ ...storedPayload, credentials: undefined });
+
+ await update();
+
+ expect(mockGetConnectionProvider).toHaveBeenCalledWith(
+ expect.objectContaining({ credentials: undefined })
+ );
+ });
+
+ it('skips the connection test when only the name changed', async () => {
+ mockForm();
+ mockStoredRow();
+ mockFingerprint.mockReturnValue('stored-hash');
+ mockConnectionProvider.listContainers.mockRejectedValue(new Error('backend down'));
+
+ const result = await update();
+
+ expect(mockConnectionProvider.listContainers).not.toHaveBeenCalled();
+ expect(mockDbUpdate).toHaveBeenCalled();
+ expect(result).toMatchObject({ message: { type: 'success' } });
+ });
+
+ it('does not save when the connection test of changed settings fails', async () => {
+ mockForm({ accessKey: 'new-ak', secretKey: 'new-sk' });
+ mockStoredRow();
+ mockConnectionProvider.listContainers.mockRejectedValue(
+ Object.assign(new Error(''), { code: 'ECONNREFUSED' })
+ );
+
+ const result = await update();
+
+ expect(mockDbUpdate).not.toHaveBeenCalled();
+ expect(result).toMatchObject({
+ status: 400,
+ message: {
+ type: 'error',
+ message: 'Could not reach the storage backend — check the host and port.'
+ }
+ });
+ });
+
+ it('requires the secret key when the access key changed', async () => {
+ mockForm({ accessKey: 'new-ak', secretKey: '' });
+ mockStoredRow();
+
+ const result = await update();
+
+ expect(mockConnectionProvider.listContainers).not.toHaveBeenCalled();
+ expect(result).toMatchObject({ field: 'credentials.secretKey' });
+ });
+
+ it('returns a not-found message for a missing row', async () => {
+ mockForm();
+ mockDbSelect.mockResolvedValue([]);
+
+ const result = await update();
+
+ expect(result).toMatchObject({
+ status: 404,
+ message: { type: 'error', message: 'Connection not found.' }
+ });
+ });
+
+ it('returns an error message instead of throwing when the update fails', async () => {
+ mockForm();
+ mockStoredRow();
+ mockDbUpdate.mockRejectedValueOnce(new Error('database is locked'));
+
+ const result = await update();
+
+ expect(result).toMatchObject({
+ status: 500,
+ message: { type: 'error', message: 'Could not save the connection. Please try again.' }
+ });
+ });
+});
diff --git a/src/routes/(app)/storage/+page.server.ts b/src/routes/(app)/storage/+page.server.ts
index 73d2e4eb..06421935 100644
--- a/src/routes/(app)/storage/+page.server.ts
+++ b/src/routes/(app)/storage/+page.server.ts
@@ -1,4 +1,4 @@
-import { fail, redirect, isHttpError } from '@sveltejs/kit';
+import { fail, redirect } from '@sveltejs/kit';
import { superValidate, message } from 'sveltekit-superforms';
import { zod4 as zod } from 'sveltekit-superforms/adapters';
import { desc, eq } from 'drizzle-orm';
@@ -11,11 +11,9 @@ import {
type StorageConnectionMessage
} from '$lib/storage/schemas.js';
import { getConnectionProvider } from '$lib/server/storage/utils.js';
-import {
- saveConnection,
- getConnectionForUser,
- deleteConnection
-} from '$lib/server/storage/connections-db.js';
+import { connectionTestErrorMessage } from '$lib/server/storage/connection-test-error.js';
+import { saveConnection, getConnectionForUser } from '$lib/server/storage/connections-db.js';
+import { deleteConnectionAction } from '$lib/server/storage/delete-connection-action.js';
import { auth } from '$lib/server/auth.js';
import { db } from '$lib/server/db.js';
import { userStorageConnections } from '$lib/server/schema.js';
@@ -106,37 +104,38 @@ export const actions: Actions = {
log.info({ storage_type: type }, 'user storage connection verified');
} catch (err) {
log.warn({ err }, 'storage connection test failed');
+ return message(
+ form,
+ { type: 'error', message: connectionTestErrorMessage(err) },
+ { status: 400 }
+ );
+ }
- let msg: string;
- if (isHttpError(err)) {
- if (err.status === 403) {
- msg = m.storage_connect_error_access_denied();
- } else if (err.status === 404) {
- msg = m.storage_connect_error_not_found();
- } else if (err.status === 502) {
- msg = m.storage_connect_error_server_error();
- } else {
- msg = m.storage_connect_error();
- }
- } else if (err instanceof Error) {
- const e = (err.message ?? '').toLowerCase();
- if (/econnrefused|enotfound|eai_again|etimedout|network/.test(e)) {
- msg = m.storage_connect_error_network();
- } else {
- msg = m.storage_connect_error();
- }
- } else {
- msg = m.storage_connect_error();
- }
-
- return message(form, { type: 'error', message: msg }, { status: 400 });
+ let id: string;
+ try {
+ id = await saveConnection(locals.user!.id, config);
+ } catch (err) {
+ log.error({ err }, 'failed to save storage connection');
+ return message(
+ form,
+ { type: 'error', message: m.storage_connect_save_failed() },
+ { status: 500 }
+ );
}
- const id = await saveConnection(locals.user!.id, config);
- await auth.api.updateSession({
- headers: request.headers,
- body: { activeStorageConnectionId: id }
- });
+ try {
+ await auth.api.updateSession({
+ headers: request.headers,
+ body: { activeStorageConnectionId: id }
+ });
+ } catch (err) {
+ log.error({ err, connection_id: id }, 'failed to activate saved storage connection');
+ return message(
+ form,
+ { type: 'error', message: m.storage_connect_activate_failed() },
+ { status: 500 }
+ );
+ }
throw redirect(303, '/storage');
},
@@ -155,55 +154,43 @@ export const actions: Actions = {
const form = await superValidate(request, zod(ConnectionIdSchema));
if (!form.valid) {
- return fail(400, { error: 'Invalid connection ID' });
+ log.debug({ errors: form.errors }, 'invalid connection id for use');
+ return fail(400, { error: m.storage_connection_edit_not_found() });
}
const { connectionId } = form.data;
const userId = locals.user!.id;
- const config = await getConnectionForUser(userId, connectionId);
- if (!config) {
- return fail(400, { error: 'Connection not found' });
- }
-
try {
- await getConnectionProvider(config).listContainers();
- log.info({ connectionId }, 'user switched storage connection');
- } catch (err) {
- log.warn({ err, connectionId }, 'storage connection test failed on use');
- return fail(400, { error: 'Could not connect — check the endpoint and credentials.' });
- }
-
- await auth.api.updateSession({
- headers: request.headers,
- body: { activeStorageConnectionId: connectionId }
- });
-
- throw redirect(303, '/storage');
- },
-
- deleteConnection: async ({ request, locals }) => {
- const log = locals.logger;
- const form = await superValidate(request, zod(ConnectionIdSchema));
-
- if (!form.valid) {
- return fail(400, { error: 'Invalid connection ID' });
- }
+ const config = await getConnectionForUser(userId, connectionId);
+ if (!config) {
+ log.debug({ connection_id: connectionId }, 'storage connection to use not found');
+ return fail(400, { error: m.storage_connection_edit_not_found() });
+ }
- const { connectionId } = form.data;
- const userId = locals.user!.id;
- const activeId = locals.session?.activeStorageConnectionId ?? null;
+ try {
+ await getConnectionProvider(config).listContainers();
+ } catch (err) {
+ log.warn({ err, connection_id: connectionId }, 'storage connection test failed on use');
+ return fail(400, { error: connectionTestErrorMessage(err) });
+ }
- if (connectionId === activeId) {
await auth.api.updateSession({
headers: request.headers,
- body: { activeStorageConnectionId: null }
+ body: { activeStorageConnectionId: connectionId }
});
- log.info({ connectionId }, 'active storage connection deleted, session cleared');
+ log.info({ connection_id: connectionId }, 'user switched storage connection');
+ } catch (err) {
+ log.error({ err, connection_id: connectionId }, 'failed to switch storage connection');
+ return fail(500, { error: m.storage_connection_switch_failed() });
}
- await deleteConnection(userId, connectionId);
+ throw redirect(303, '/storage');
+ },
+ deleteConnection: async (event) => {
+ const failure = await deleteConnectionAction(event);
+ if (failure) return failure;
throw redirect(303, '/storage');
}
};
diff --git a/src/routes/(app)/storage/page.server.test.ts b/src/routes/(app)/storage/page.server.test.ts
index fe5c3d98..1cd40bad 100644
--- a/src/routes/(app)/storage/page.server.test.ts
+++ b/src/routes/(app)/storage/page.server.test.ts
@@ -63,7 +63,10 @@ import { load, actions } from './+page.server.js';
import { superValidate } from 'sveltekit-superforms';
function mockLocals() {
- return { logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn() }, user: { id: 'test-user' } };
+ return {
+ logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+ user: { id: 'test-user' }
+ };
}
const validFormData = {
@@ -166,6 +169,61 @@ describe('storage page actions', () => {
).rejects.toThrow(expect.objectContaining({ status: 303, location: '/storage' }));
});
+ it('connect: returns an error message instead of throwing when saving fails', async () => {
+ vi.mocked(superValidate).mockResolvedValue({
+ valid: true,
+ data: {
+ type: 's3',
+ host: 's3.example.com',
+ accessStyle: 'Path',
+ region: { name: 'us-east-1' },
+ credentials: { accessKey: 'ak', secretKey: 'sk' }
+ }
+ } as unknown as Awaited>);
+ mockConnectionProvider.listContainers.mockResolvedValue(['b1']);
+ mockSaveConnection.mockRejectedValueOnce(new Error('database is locked'));
+
+ const result = await actions.connect({
+ request: new Request('http://localhost', { method: 'POST' }),
+ locals: mockLocals()
+ } as unknown as Parameters[0]);
+
+ expect(result).toMatchObject({
+ status: 500,
+ message: { type: 'error', message: 'Could not save the connection. Please try again.' }
+ });
+ });
+
+ it('connect: says the connection was saved when only activating it fails', async () => {
+ vi.mocked(superValidate).mockResolvedValue({
+ valid: true,
+ data: {
+ type: 's3',
+ host: 's3.example.com',
+ accessStyle: 'Path',
+ region: { name: 'us-east-1' },
+ credentials: { accessKey: 'ak', secretKey: 'sk' }
+ }
+ } as unknown as Awaited>);
+ mockConnectionProvider.listContainers.mockResolvedValue(['b1']);
+ mockUpdateSession.mockRejectedValueOnce(new Error('session store down'));
+
+ const result = await actions.connect({
+ request: new Request('http://localhost', { method: 'POST' }),
+ locals: mockLocals()
+ } as unknown as Parameters[0]);
+
+ expect(mockSaveConnection).toHaveBeenCalled();
+ expect(result).toMatchObject({
+ status: 500,
+ message: {
+ type: 'error',
+ message:
+ 'The connection was saved but could not be activated. Reload the page and select it from the saved connections.'
+ }
+ });
+ });
+
it('disconnect: redirects to /storage', async () => {
await expect(
actions.disconnect({
@@ -203,7 +261,29 @@ describe('storage page actions', () => {
locals: mockLocals()
} as unknown as Parameters[0]);
- expect(result).toMatchObject({ status: 400, data: { error: 'Connection not found' } });
+ expect(result).toMatchObject({ status: 400, data: { error: 'Connection not found.' } });
+ });
+
+ it('use: explains why the connection test failed', async () => {
+ vi.mocked(superValidate).mockResolvedValue({
+ valid: true,
+ data: { connectionId: 'saved-connection' }
+ } as unknown as Awaited>);
+ mockGetConnectionForUser.mockResolvedValue(validFormData);
+ mockConnectionProvider.listContainers.mockRejectedValue(
+ Object.assign(new Error(''), { code: 'ENOTFOUND' })
+ );
+
+ const result = await actions.use({
+ request: new Request('http://localhost', { method: 'POST' }),
+ locals: mockLocals()
+ } as unknown as Parameters[0]);
+
+ expect(result).toMatchObject({
+ status: 400,
+ data: { error: 'Could not reach the storage backend — check the host and port.' }
+ });
+ expect(mockUpdateSession).not.toHaveBeenCalled();
});
it('use: sets the selected connection as active and redirects', async () => {
@@ -260,4 +340,22 @@ describe('storage page actions', () => {
expect(mockUpdateSession).not.toHaveBeenCalled();
expect(mockDeleteConnection).toHaveBeenCalledWith('test-user', 'inactive-connection');
});
+
+ it('deleteConnection: returns an error instead of throwing when deleting fails', async () => {
+ vi.mocked(superValidate).mockResolvedValue({
+ valid: true,
+ data: { connectionId: 'inactive-connection' }
+ } as unknown as Awaited>);
+ mockDeleteConnection.mockRejectedValueOnce(new Error('database is locked'));
+
+ const result = await actions.deleteConnection({
+ request: new Request('http://localhost', { method: 'POST' }),
+ locals: mockLocals()
+ } as unknown as Parameters[0]);
+
+ expect(result).toMatchObject({
+ status: 500,
+ data: { error: 'Could not delete the connection. Please try again.' }
+ });
+ });
});