@kazurolabs/psql-explorer 0.0.0-stage → 0.3.0

package/dist/db/store.js

@@ -0,0 +1,323 @@
+import { chmodSync, closeSync, mkdirSync, openSync } from 'node:fs';
+import { databaseFile } from './paths.js';
+// node:sqlite (Node 22.13+) prints an ExperimentalWarning when it loads, which would land on top of
+// the TUI. Drop only that warning, and load the module afterwards: a static import would be
+// evaluated before this filter could be installed.
+const emitWarning = process.emitWarning.bind(process);
+process.emitWarning = ((warning, ...rest) => {
+    const [options] = rest;
+    const type = typeof options === 'string' ? options : options?.type;
+    const message = typeof warning === 'string' ? warning : warning.message;
+    const name = typeof warning === 'string' ? type : warning.name;
+    if (name === 'ExperimentalWarning' && message.includes('SQLite'))
+        return;
+    emitWarning(warning, ...rest);
+});
+const { DatabaseSync: Database } = process.getBuiltinModule('node:sqlite');
+export class StoreError extends Error {
+    name = 'StoreError';
+}
+export class DuplicateNameError extends StoreError {
+    connectionName;
+    name = 'DuplicateNameError';
+    constructor(connectionName) {
+        super(`A connection named '${connectionName}' already exists`);
+        this.connectionName = connectionName;
+    }
+}
+export class ConnectionNotFoundError extends StoreError {
+    id;
+    name = 'ConnectionNotFoundError';
+    constructor(id) {
+        super(`Connection ${id} does not exist`);
+        this.id = id;
+    }
+}
+// Thrown by openStore when the file or its directory can't be created, opened or migrated.
+export class StoreOpenError extends StoreError {
+    file;
+    name = 'StoreOpenError';
+    constructor(file, cause) {
+        super(`Could not open the local database at ${file}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        this.file = file;
+    }
+}
+// Ordered schema migrations: migrations[i] takes the file from user_version i to i + 1. Only ever
+// append to this list; never edit a migration that has shipped.
+const migrations = [
+    `CREATE TABLE connections (
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL UNIQUE COLLATE NOCASE,
+		type TEXT NOT NULL,
+		host TEXT NOT NULL,
+		port INTEGER NOT NULL,
+		database TEXT NOT NULL,
+		username TEXT NOT NULL,
+		password TEXT NOT NULL,
+		schema TEXT NOT NULL,
+		ssl INTEGER NOT NULL DEFAULT 0,
+		last_test_status TEXT NULL CHECK (last_test_status IN ('ok', 'failed')),
+		last_test_message TEXT NULL,
+		last_tested_at TEXT NULL,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	)`,
+    `CREATE TABLE settings (
+		key TEXT PRIMARY KEY,
+		value TEXT NOT NULL
+	)`,
+    // Values the user keeps for config fields written as `source: stored`.
+    `CREATE TABLE secrets (
+		key TEXT PRIMARY KEY,
+		value TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	)`,
+    `CREATE TABLE history (
+		id INTEGER PRIMARY KEY,
+		at TEXT NOT NULL,
+		env_name TEXT NOT NULL,
+		sql TEXT NOT NULL,
+		duration_ms INTEGER NOT NULL,
+		row_count INTEGER NULL,
+		error TEXT NULL
+	);
+	CREATE INDEX history_env ON history (env_name, id)`,
+    // Queries kept by name, per environment, for the web UI.
+    `CREATE TABLE saved_queries (
+		id INTEGER PRIMARY KEY,
+		env_name TEXT NOT NULL,
+		name TEXT NOT NULL,
+		folder TEXT NOT NULL DEFAULT '',
+		sql TEXT NOT NULL,
+		pinned INTEGER NOT NULL DEFAULT 0,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL
+	);
+	CREATE INDEX saved_queries_env ON saved_queries (env_name)`,
+];
+export const schemaVersion = migrations.length;
+function migrate(db) {
+    const { user_version: current } = db.prepare('PRAGMA user_version').get();
+    if (current > migrations.length) {
+        throw new Error(`it was created by a newer version of psql-explorer (schema version ${current}, this version knows ${migrations.length})`);
+    }
+    for (let version = current; version < migrations.length; version++) {
+        db.exec('BEGIN IMMEDIATE');
+        try {
+            db.exec(migrations[version]);
+            db.exec(`PRAGMA user_version = ${version + 1}`);
+            db.exec('COMMIT');
+        }
+        catch (error) {
+            db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+}
+const toSaved = (row) => ({
+    id: row.id,
+    envName: row.env_name,
+    name: row.name,
+    folder: row.folder,
+    sql: row.sql,
+    pinned: row.pinned === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+});
+const toHistory = (row) => ({
+    id: row.id,
+    at: row.at,
+    envName: row.env_name,
+    sql: row.sql,
+    durationMs: row.duration_ms,
+    rowCount: row.row_count,
+    error: row.error,
+});
+const toConnection = (row) => ({
+    id: row.id,
+    name: row.name,
+    type: 'postgres',
+    host: row.host,
+    port: row.port,
+    database: row.database,
+    username: row.username,
+    password: row.password,
+    schema: row.schema,
+    ssl: row.ssl === 1,
+    lastTest: row.last_test_status && row.last_tested_at
+        ? {
+            status: row.last_test_status,
+            message: row.last_test_message,
+            testedAt: row.last_tested_at,
+        }
+        : null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+});
+// SQLITE_CONSTRAINT_UNIQUE; name is the only unique column besides the primary key.
+const isUniqueViolation = (error) => error?.errcode === 2067;
+const inputParams = (input) => ({
+    name: input.name,
+    host: input.host,
+    port: input.port,
+    database: input.database,
+    username: input.username,
+    password: input.password,
+    schema: input.schema,
+    ssl: input.ssl ? 1 : 0,
+});
+// Opens (creating if needed) the store in `dir`: the directory is created owner-only, the file is
+// kept at 0600 because it holds passwords, and pending migrations are applied.
+export function openStore(dir) {
+    const file = databaseFile(dir);
+    let db;
+    try {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        // Create the file ourselves so it is never readable by others, even briefly.
+        closeSync(openSync(file, 'a', 0o600));
+        chmodSync(file, 0o600);
+        db = new Database(file);
+        db.exec('PRAGMA foreign_keys = ON');
+        migrate(db);
+    }
+    catch (error) {
+        db?.close();
+        throw new StoreOpenError(file, error);
+    }
+    const database = db;
+    let closed = false;
+    const now = () => new Date().toISOString();
+    const select = database.prepare('SELECT * FROM connections WHERE id = ?');
+    const get = (id) => {
+        const row = select.get(id);
+        return row ? toConnection(row) : undefined;
+    };
+    const mustGet = (id) => {
+        const connection = get(id);
+        if (!connection)
+            throw new ConnectionNotFoundError(id);
+        return connection;
+    };
+    const write = (input, run) => {
+        try {
+            return run();
+        }
+        catch (error) {
+            if (isUniqueViolation(error))
+                throw new DuplicateNameError(input.name);
+            throw error;
+        }
+    };
+    const insert = database.prepare(`INSERT INTO connections (name, type, host, port, database, username, password, schema, ssl, created_at, updated_at)
+		VALUES (:name, 'postgres', :host, :port, :database, :username, :password, :schema, :ssl, :now, :now)`);
+    const change = database.prepare(`UPDATE connections SET name = :name, host = :host, port = :port, database = :database,
+			username = :username, password = :password, schema = :schema, ssl = :ssl,
+			last_test_status = NULL, last_test_message = NULL, last_tested_at = NULL, updated_at = :now
+		WHERE id = :id`);
+    const test = database.prepare(`UPDATE connections SET last_test_status = :status, last_test_message = :message,
+			last_tested_at = :testedAt WHERE id = :id`);
+    const remove = database.prepare('DELETE FROM connections WHERE id = ?');
+    const all = database.prepare('SELECT * FROM connections ORDER BY name COLLATE NOCASE, id');
+    const insertHistory = database.prepare(`INSERT INTO history (at, env_name, sql, duration_ms, row_count, error)
+		VALUES (:at, :envName, :sql, :durationMs, :rowCount, :error)`);
+    const selectHistory = database.prepare('SELECT * FROM history WHERE id = ?');
+    // The latest run of each distinct statement.
+    const historyByEnv = database.prepare(`SELECT * FROM history WHERE id IN (
+			SELECT MAX(id) FROM history WHERE env_name = ? GROUP BY sql
+		) ORDER BY id DESC LIMIT ?`);
+    const insertSaved = database.prepare(`INSERT INTO saved_queries (env_name, name, folder, sql, pinned, created_at, updated_at)
+		VALUES (:envName, :name, :folder, :sql, :pinned, :now, :now)`);
+    const selectSaved = database.prepare('SELECT * FROM saved_queries WHERE id = ?');
+    const savedByEnv = database.prepare(`SELECT * FROM saved_queries WHERE env_name = ?
+		ORDER BY pinned DESC, folder COLLATE NOCASE, name COLLATE NOCASE, id`);
+    const changeSaved = database.prepare(`UPDATE saved_queries SET name = :name, folder = :folder, sql = :sql, pinned = :pinned,
+			updated_at = :now WHERE id = :id`);
+    const removeSaved = database.prepare('DELETE FROM saved_queries WHERE id = ?');
+    const selectSetting = database.prepare('SELECT value FROM settings WHERE key = ?');
+    const upsertSetting = database.prepare('INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value');
+    const selectSecret = database.prepare('SELECT value FROM secrets WHERE key = ?');
+    const upsertSecret = database.prepare('INSERT INTO secrets (key, value, updated_at) VALUES (?, ?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at');
+    const removeSecret = database.prepare('DELETE FROM secrets WHERE key = ?');
+    return {
+        file,
+        list: () => all.all().map(toConnection),
+        get,
+        create: (input) => write(input, () => {
+            const { lastInsertRowid } = insert.run({ ...inputParams(input), now: now() });
+            return mustGet(Number(lastInsertRowid));
+        }),
+        update: (id, input) => write(input, () => {
+            const { changes } = change.run({ ...inputParams(input), now: now(), id });
+            if (Number(changes) === 0)
+                throw new ConnectionNotFoundError(id);
+            return mustGet(id);
+        }),
+        delete: (id) => Number(remove.run(id).changes) > 0,
+        recordTest: (id, result) => {
+            const { changes } = test.run({
+                id,
+                status: result.status,
+                message: result.message ?? null,
+                testedAt: result.testedAt ?? now(),
+            });
+            if (Number(changes) === 0)
+                throw new ConnectionNotFoundError(id);
+            return mustGet(id);
+        },
+        recordQuery: (entry) => {
+            const { lastInsertRowid } = insertHistory.run({
+                at: entry.at ?? now(),
+                envName: entry.envName,
+                sql: entry.sql,
+                durationMs: Math.round(entry.durationMs),
+                rowCount: entry.rowCount ?? null,
+                error: entry.error ?? null,
+            });
+            return toHistory(selectHistory.get(Number(lastInsertRowid)));
+        },
+        historyFor: (envName, limit = 200) => historyByEnv.all(envName, limit).map(toHistory),
+        savedQueries: (envName) => savedByEnv.all(envName).map(toSaved),
+        saveQuery: (input) => {
+            const { lastInsertRowid } = insertSaved.run({
+                envName: input.envName,
+                name: input.name,
+                folder: input.folder ?? '',
+                sql: input.sql,
+                pinned: input.pinned ? 1 : 0,
+                now: now(),
+            });
+            return toSaved(selectSaved.get(Number(lastInsertRowid)));
+        },
+        updateSavedQuery: (id, changes) => {
+            const row = selectSaved.get(id);
+            if (!row)
+                return undefined;
+            changeSaved.run({
+                id,
+                name: changes.name ?? row.name,
+                folder: changes.folder ?? row.folder,
+                sql: changes.sql ?? row.sql,
+                pinned: (changes.pinned ?? row.pinned === 1) ? 1 : 0,
+                now: now(),
+            });
+            return toSaved(selectSaved.get(id));
+        },
+        deleteSavedQuery: (id) => Number(removeSaved.run(id).changes) > 0,
+        getSetting: (key) => selectSetting.get(key)?.value,
+        setSetting: (key, value) => {
+            upsertSetting.run(key, value);
+        },
+        getSecret: (key) => selectSecret.get(key)?.value,
+        setSecret: (key, value) => {
+            upsertSecret.run(key, value, now());
+        },
+        deleteSecret: (key) => Number(removeSecret.run(key).changes) > 0,
+        close: () => {
+            // DatabaseSync#isOpen only exists from Node 22.15; engines allow 22.13.
+            if (closed)
+                return;
+            closed = true;
+            database.close();
+        },
+    };
+}

package/dist/db/tester.js

@@ -0,0 +1,190 @@
+import { createClient, DEFAULT_TIMEOUT_MS, sslOptions, } from './connect.js';
+export { sslOptions };
+/** The tester config for a saved or entered connection (SSL on means mode "require"). */
+export const testerConfigFor = (input) => ({
+    host: input.host,
+    port: input.port,
+    database: input.database,
+    username: input.username,
+    password: input.password,
+    schema: input.schema,
+    tls: { mode: input.ssl ? 'require' : 'disable' },
+});
+export { DEFAULT_TIMEOUT_MS };
+const CLEANUP_GRACE_MS = 1000;
+class SchemaMissingError extends Error {
+}
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms).unref());
+/**
+ * Connects to the server described by `config` with a throwaway client, reads the server version
+ * and checks the schema exists. Never throws: every failure becomes `{ok: false}`. The client is
+ * always ended, and the whole test gives up after `timeoutMs`.
+ */
+export const testConnection = async (config, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}) => {
+    const client = createClient(config, { timeoutMs, statementTimeoutMs: timeoutMs });
+    const work = probe(client, config.schema);
+    let driverError;
+    work.catch((error) => {
+        driverError = error;
+    });
+    // Whatever happens, end the client once the work has settled.
+    const cleanup = work.then(() => dispose(client), () => dispose(client));
+    let timer;
+    const timedOut = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), timeoutMs);
+    });
+    try {
+        const outcome = await Promise.race([
+            work.then((serverVersion) => ({ serverVersion }), (error) => ({ error })),
+            timedOut,
+        ]);
+        if (outcome === 'timeout') {
+            // The driver's own timeouts (same length) end the work almost at
+            // once; give its cleanup a short, bounded moment so no socket is left.
+            await Promise.race([cleanup, delay(CLEANUP_GRACE_MS)]);
+            return failure('timeout', timeoutReason(timeoutMs), driverError === undefined ? `No response within ${timeoutMs} ms` : rawMessage(driverError));
+        }
+        // Do not report until the connection is really closed.
+        await cleanup;
+        if ('error' in outcome)
+            return describeError(outcome.error, config, timeoutMs);
+        return { ok: true, serverVersion: outcome.serverVersion };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+async function probe(client, schema) {
+    await client.connect();
+    const versionRows = (await client.query('SHOW server_version')).rows;
+    // pg_namespace sees every schema, unlike information_schema.schemata,
+    // which hides schemas the user has no privileges on.
+    const schemaRows = (await client.query('SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = $1', [schema])).rows;
+    if (schemaRows.length === 0) {
+        throw new SchemaMissingError(`schema "${schema}" does not exist`);
+    }
+    return shortVersion(versionRows[0]?.server_version ?? '');
+}
+/** "16.4 (Debian 16.4-1.pgdg120+1)" → "16.4" */
+export const shortVersion = (raw) => raw.trim().split(/\s+/)[0] ?? raw;
+async function dispose(client) {
+    try {
+        await client.end();
+    }
+    catch {
+        // Cleanup failures must not mask the test result.
+    }
+}
+export function describeError(error, config, timeoutMs) {
+    const detail = rawMessage(error);
+    if (error instanceof SchemaMissingError) {
+        return failure('schema-missing', `Schema '${config.schema}' not found`, detail);
+    }
+    const code = errorCode(error);
+    const message = detail.toLowerCase();
+    if (code === 'ECONNREFUSED') {
+        return failure('refused', `Connection refused at ${config.host}:${config.port}`, detail);
+    }
+    if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') {
+        return failure('host-not-found', `Host not found: ${config.host}`, detail);
+    }
+    if (code === '28P01') {
+        return failure('auth', `Password authentication failed for user '${config.username}'`, detail);
+    }
+    if (code === '3D000') {
+        return failure('database-missing', `Database '${config.database}' does not exist`, detail);
+    }
+    if (message.includes('does not support ssl')) {
+        return failure('ssl-unsupported', 'The server does not support SSL', detail);
+    }
+    // pg_hba.conf rejects unencrypted connections with "... no encryption".
+    if (config.tls.mode === 'disable' &&
+        (code === '28000' || code === '28P01') &&
+        message.includes('no encryption')) {
+        return failure('ssl-required', 'The server requires SSL', detail);
+    }
+    const tlsFailure = describeTlsError(code, message, detail);
+    if (tlsFailure)
+        return tlsFailure;
+    if (code === 'ETIMEDOUT' ||
+        message.includes('timeout expired') ||
+        message.includes('connection timeout') ||
+        message.includes('query read timeout')) {
+        return failure('timeout', timeoutReason(timeoutMs), detail);
+    }
+    return failure('unknown', 'Connection failed', detail);
+}
+const untrustedCodes = new Set([
+    'DEPTH_ZERO_SELF_SIGNED_CERT',
+    'SELF_SIGNED_CERT_IN_CHAIN',
+    'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+    'UNABLE_TO_GET_ISSUER_CERT_LOCALLY',
+    'CERT_UNTRUSTED',
+]);
+// Certificate problems, on either side of the handshake. `message` is lower-cased.
+function describeTlsError(code, message, detail) {
+    if (code === 'CERT_HAS_EXPIRED') {
+        return failure('cert-untrusted', "The server's certificate has expired", detail);
+    }
+    if (code !== undefined && untrustedCodes.has(code)) {
+        return failure('cert-untrusted', "The server's certificate is not trusted", detail);
+    }
+    if (code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+        return failure('cert-hostname', "The server's certificate does not match the host", detail);
+    }
+    // A bad passphrase or unreadable key fails while the client's TLS context is built.
+    if (code === 'ERR_MISSING_PASSPHRASE' ||
+        code?.startsWith('ERR_OSSL_BAD_DECRYPT') ||
+        code?.startsWith('ERR_OSSL_PEM') ||
+        message.includes('bad decrypt') ||
+        message.includes('passphrase') ||
+        message.includes('pem routines')) {
+        return failure('key-passphrase', 'The client key could not be read (check its passphrase)', detail);
+    }
+    if (message.includes('certificate required') ||
+        message.includes('requires a valid client certificate')) {
+        return failure('client-cert-required', 'The server requires a client certificate', detail);
+    }
+    if (message.includes('unknown ca') ||
+        message.includes('bad certificate') ||
+        message.includes('certificate unknown') ||
+        message.includes('certificate authentication failed') ||
+        message.includes('certificate verify failed')) {
+        return failure('client-cert-rejected', 'The server rejected the client certificate', detail);
+    }
+    return undefined;
+}
+function errorCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const { code, errors } = error;
+    if (typeof code === 'string')
+        return code;
+    // Node reports a host with several addresses (e.g. localhost → ::1 and
+    // 127.0.0.1) as an AggregateError of the per-address errors.
+    if (Array.isArray(errors)) {
+        for (const inner of errors) {
+            const innerCode = errorCode(inner);
+            if (innerCode)
+                return innerCode;
+        }
+    }
+    return undefined;
+}
+function rawMessage(error) {
+    if (error instanceof Error) {
+        const { errors } = error;
+        if (!error.message && Array.isArray(errors) && errors.length > 0) {
+            return errors.map(rawMessage).join('; ');
+        }
+        return error.message;
+    }
+    return String(error);
+}
+function timeoutReason(timeoutMs) {
+    const seconds = Number((timeoutMs / 1000).toFixed(1));
+    return `Timed out after ${seconds} s`;
+}
+function failure(kind, reason, detail) {
+    return { ok: false, kind, reason, detail };
+}

package/dist/db/validate.js

@@ -0,0 +1,99 @@
+import { isIP } from 'node:net';
+export const defaultSchema = 'public';
+export const defaultPort = '5432';
+// Postgres truncates identifiers longer than 63 bytes (NAMEDATALEN - 1).
+const maxIdentifierBytes = 63;
+const maxNameLength = 64;
+const maxHostLength = 253;
+const hostLabel = /^[A-Za-z0-9_]([A-Za-z0-9_-]{0,61}[A-Za-z0-9_])?$/;
+const isHostname = (host) => host.length <= maxHostLength &&
+    host
+        .replace(/\.$/, '')
+        .split('.')
+        .every((l) => hostLabel.test(l));
+const hasControlCharacter = (value) => [...value].some((c) => c.charCodeAt(0) < 0x20);
+/** Per-field rules. Each returns an error message, or undefined when the value is valid. */
+export function identifierError(label, value) {
+    if (!value)
+        return `${label} is required`;
+    if (hasControlCharacter(value))
+        return `${label} cannot contain control characters`;
+    if (Buffer.byteLength(value) > maxIdentifierBytes) {
+        return `${label} must be at most ${maxIdentifierBytes} bytes`;
+    }
+    return undefined;
+}
+export function hostError(host) {
+    if (!host)
+        return 'Host is required';
+    if (!isHostname(host) && !isIP(host))
+        return 'Host must be a hostname or IP address';
+    return undefined;
+}
+export function portError(portText) {
+    if (!portText)
+        return 'Port is required';
+    const port = Number(portText);
+    if (!/^\d+$/.test(portText) || port < 1 || port > 65_535) {
+        return 'Port must be a whole number from 1 to 65535';
+    }
+    return undefined;
+}
+export function passwordError(password) {
+    if (!password)
+        return 'Password is required';
+    if (password.includes('\0'))
+        return 'Password cannot contain a null character';
+    return undefined;
+}
+// Validates the form and, when it is valid, returns the connection to save. Name, host, database
+// and username are trimmed; the password is kept exactly as typed. A blank schema means "public".
+export function validateConnection(form) {
+    const name = form.name.trim();
+    const host = form.host.trim();
+    const database = form.database.trim();
+    const username = form.username.trim();
+    const schema = form.schema.trim() || defaultSchema;
+    const portText = form.port.trim();
+    const port = Number(portText);
+    const errors = {};
+    if (!name)
+        errors.name = 'Name is required';
+    else if (name.length > maxNameLength)
+        errors.name = `Name must be at most ${maxNameLength} characters`;
+    else if (hasControlCharacter(name))
+        errors.name = 'Name cannot contain control characters';
+    const hostMessage = hostError(host);
+    if (hostMessage)
+        errors.host = hostMessage;
+    const portMessage = portError(portText);
+    if (portMessage)
+        errors.port = portMessage;
+    const databaseError = identifierError('Database', database);
+    if (databaseError)
+        errors.database = databaseError;
+    const usernameError = identifierError('Username', username);
+    if (usernameError)
+        errors.username = usernameError;
+    const passwordMessage = passwordError(form.password);
+    if (passwordMessage)
+        errors.password = passwordMessage;
+    const schemaError = form.schema.trim() ? identifierError('Schema', schema) : undefined;
+    if (schemaError)
+        errors.schema = schemaError;
+    if (Object.keys(errors).length > 0)
+        return { ok: false, errors };
+    return {
+        ok: true,
+        input: {
+            name,
+            host,
+            port,
+            database,
+            username,
+            password: form.password,
+            schema,
+            ssl: form.ssl ?? false,
+        },
+    };
+}