@coffre/vault 0.12.1 → 0.14.0

package/dist/cloudflare.js

@@ -1,5 +1,5 @@
 import { a as verifyCheckpoint, i as checkpointMessage, n as KekUnavailableError, o as derivedSigningKey, r as awsKms, s as resolveVaultConfig, t as KekBadClaimError } from "./src-B0d-W-SI.js";
-import { n as prepareVault, t as openVault } from "./vault-DEjPmLNt.js";
+import { n as prepareVault, t as openVault } from "./vault-C5n9wSvj.js";
 import { createDatabase } from "@coffre/db";
 import { HyperdrivePool, postgres } from "@coffre/db/hyperdrive";
 import { WorkerEntrypoint } from "cloudflare:workers";

package/dist/node.js

@@ -1,8 +1,41 @@
 import { a as verifyCheckpoint, i as checkpointMessage, n as KekUnavailableError, o as derivedSigningKey, r as awsKms, s as resolveVaultConfig, t as KekBadClaimError } from "./src-B0d-W-SI.js";
-import { n as prepareVault, t as openVault } from "./vault-DEjPmLNt.js";
+import { n as prepareVault, t as openVault } from "./vault-C5n9wSvj.js";
+import { isUnavailable } from "@coffre/db/dialect";
 import { chmodSync, existsSync, lstatSync, rmSync } from "node:fs";
 import { Agent, createServer, request } from "node:http";
 import { openDatabase } from "@coffre/db/connect";
+//#region src/failure.ts
+/**
+* A vault call's failure, as `serveVault` answers it: its message, and the
+* code its causes carry, which `connectVault` puts back on its error, so
+* the app reads it as it would in process. Its database, or a key service,
+* not answering is the app's outage too, not a bug: 503. One only its
+* words say (pg's "Connection terminated") goes as Postgres's code for a
+* connection that failed, 08006.
+*/
+function failureOf(error) {
+	const message = error instanceof Error ? error.message : "the vault failed";
+	let code;
+	for (let cause = error; typeof cause === "object" && cause !== null && code === void 0; cause = cause.cause) {
+		const found = cause.code;
+		if (typeof found === "string") code = found;
+	}
+	if (!isUnavailable(error)) return {
+		status: 500,
+		body: code === void 0 ? { error: message } : {
+			error: message,
+			code
+		}
+	};
+	return {
+		status: 503,
+		body: {
+			error: message,
+			code: code !== void 0 && isUnavailable({ code }) ? code : "08006"
+		}
+	};
+}
+//#endregion
 //#region src/local.ts
 /** Every call the vault answers, in the order of the `Vault` interface. */
 const METHODS = [
@@ -89,7 +122,8 @@ async function serveVault(config) {
 			reply(200, result === void 0 ? {} : { result });
 		} catch (error) {
 			console.error(`vault ${name} failed`, error);
-			reply(500, { error: error instanceof Error ? error.message : "the vault failed" });
+			const { status, body } = failureOf(error);
+			reply(status, body);
 		}
 	});
 	server.keepAliveTimeout = 0;
@@ -127,11 +161,12 @@ function connectVault(socket) {
 		}, (res) => {
 			readBody(res).then((text) => {
 				const payload = JSON.parse(text);
-				if (res.statusCode === 200) resolve(payload.result);
-				else reject(/* @__PURE__ */ new Error(`vault ${name}: ${payload.error ?? `status ${res.statusCode}`}`));
+				if (res.statusCode === 200) return resolve(payload.result);
+				const failed = /* @__PURE__ */ new Error(`vault ${name}: ${payload.error ?? `status ${res.statusCode}`}`);
+				reject(payload.code === void 0 ? failed : Object.assign(failed, { code: payload.code }));
 			}, reject);
 		});
-		req.on("error", (error) => reject(/* @__PURE__ */ new Error(`the vault at ${socket} is unreachable: ${error.message}`)));
+		req.on("error", (error) => reject(new Error(`the vault at ${socket} is unreachable: ${error.message}`, { cause: error.code === "ENOENT" ? Object.assign(error, { code: "ECONNREFUSED" }) : error })));
 		req.end(body);
 	});
 	return Object.fromEntries(METHODS.map((name) => [name, call(name)]));

package/dist/{vault-DEjPmLNt.js → vault-C5n9wSvj.js}

@@ -6,7 +6,7 @@ import { DEFAULT_POLICY, EVERYWHERE, EVERY_ENVIRONMENT, FIXED_ROLES, INSTANCE_RO
 import { GENESIS_HASH, deriveLogKey, verifyEntries } from "@coffre/core/audit";
 import { checkContext, ownerKey } from "@coffre/core/envelope";
 import { TOMBSTONE, shownMember } from "@coffre/core/schemas";
-import { SNAPSHOT, clockMillis, engineOf, forUpdate, isUniqueViolation, isUnreachable, rowsOf, tombstone, truth } from "@coffre/db/dialect";
+import { SNAPSHOT, clockMillis, engineOf, forUpdate, isUnavailable, isUniqueViolation, rowsOf, tombstone, truth } from "@coffre/db/dialect";
 import { accessEntriesAbout, everyProjectConversion, insertGrant, liveProjects, newestAccess, readGrants, reportStands, roleColumns, storedRole } from "@coffre/db/grants";
 import { LogHeadMismatch, appendEntries, entryColumns, lockLogHead, missingEntry, newestAuthentic, newestVaultEntries, withinBytes } from "@coffre/db/log";
 import { and, asc, desc, eq, gt, gte, inArray, isNotNull, isNull, lt, lte, or, sql } from "drizzle-orm";
@@ -4019,7 +4019,7 @@ var VaultService = class {
 		if (walked.ok) try {
 			scrub = await this.#db.transaction((tx) => this.#scrub(tx, walked.from), SNAPSHOT);
 		} catch (error) {
-			if (!isUnreachable(error) && !timedOut(error)) throw error;
+			if (!isUnavailable(error)) throw error;
 			stalled = `the rehash of the past did not run, and goes on where it was next time: ${error.message}`;
 		}
 		return this.#decide([], async (d) => {
@@ -4438,11 +4438,6 @@ var VaultService = class {
 		return null;
 	}
 };
-/** Whether a statement was cancelled for taking too long: Postgres's `query_canceled`, a statement timeout among them. */
-function timedOut(error) {
-	for (let cause = error; typeof cause === "object" && cause !== null; cause = cause.cause) if (cause.code === "57014") return true;
-	return false;
-}
 const FIRST_ENTRY = {
 	ok: true,
 	entry: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffre/vault",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "coffre's vault: keys, grants and members, in the database the app uses, as a Cloudflare Worker or on Node.",
   "license": "MIT",
   "repository": {
@@ -36,8 +36,8 @@
   },
   "dependencies": {
     "drizzle-orm": "0.45.2",
-    "@coffre/core": "0.12.1",
-    "@coffre/db": "0.12.1"
+    "@coffre/core": "0.14.0",
+    "@coffre/db": "0.14.0"
   },
   "devDependencies": {
     "@types/node": "26.1.1",

package/src/failure.ts

@@ -0,0 +1,20 @@
+import { isUnavailable } from '@coffre/db/dialect';
+
+/**
+ * A vault call's failure, as `serveVault` answers it: its message, and the
+ * code its causes carry, which `connectVault` puts back on its error, so
+ * the app reads it as it would in process. Its database, or a key service,
+ * not answering is the app's outage too, not a bug: 503. One only its
+ * words say (pg's "Connection terminated") goes as Postgres's code for a
+ * connection that failed, 08006.
+ */
+export function failureOf(error: unknown): { status: number; body: { error: string; code?: string } } {
+  const message = error instanceof Error ? error.message : 'the vault failed';
+  let code: string | undefined;
+  for (let cause = error; typeof cause === 'object' && cause !== null && code === undefined; cause = (cause as { cause?: unknown }).cause) {
+    const found = (cause as { code?: unknown }).code;
+    if (typeof found === 'string') code = found;
+  }
+  if (!isUnavailable(error)) return { status: 500, body: code === undefined ? { error: message } : { error: message, code } };
+  return { status: 503, body: { error: message, code: code !== undefined && isUnavailable({ code }) ? code : '08006' } };
+}

package/src/node.ts

@@ -22,6 +22,7 @@ import type { Database } from '@coffre/db';
 import { openDatabase } from '@coffre/db/connect';
 
 import { resolveVaultConfig, type VaultConfig } from './config.ts';
+import { failureOf } from './failure.ts';
 import { METHODS, openLocalVault, type LocalVault } from './local.ts';
 import type { VaultOptions } from './vault.ts';
 
@@ -75,7 +76,8 @@ export async function serveVault(config: NodeVaultConfig & { socket: string }):
       reply(200, result === undefined ? {} : { result });
     } catch (error) {
       console.error(`vault ${name} failed`, error);
-      reply(500, { error: error instanceof Error ? error.message : 'the vault failed' });
+      const { status, body } = failureOf(error);
+      reply(status, body);
     }
   });
 
@@ -123,13 +125,16 @@ export function connectVault(socket: string): Vault {
         },
         (res) => {
           readBody(res).then((text) => {
-            const payload = JSON.parse(text) as { result?: unknown; error?: string };
-            if (res.statusCode === 200) resolve(payload.result);
-            else reject(new Error(`vault ${name}: ${payload.error ?? `status ${res.statusCode}`}`));
+            const payload = JSON.parse(text) as { result?: unknown; error?: string; code?: string };
+            if (res.statusCode === 200) return resolve(payload.result);
+            const failed = new Error(`vault ${name}: ${payload.error ?? `status ${res.statusCode}`}`);
+            reject(payload.code === undefined ? failed : Object.assign(failed, { code: payload.code }));
           }, reject);
         },
       );
-      req.on('error', (error) => reject(new Error(`the vault at ${socket} is unreachable: ${error.message}`)));
+      // No socket file is a vault that stopped cleanly, as a refused connection is one that did not: the same outage.
+      req.on('error', (error: NodeJS.ErrnoException) =>
+        reject(new Error(`the vault at ${socket} is unreachable: ${error.message}`, { cause: error.code === 'ENOENT' ? Object.assign(error, { code: 'ECONNREFUSED' }) : error })));
       req.end(body);
     });
   return Object.fromEntries(METHODS.map((name) => [name, call(name)])) as unknown as Vault;

package/src/vault.ts

@@ -98,7 +98,7 @@ import {
   type WrappedKey,
 } from '@coffre/core/vault';
 import type { Database, Queryable, Transaction } from '@coffre/db';
-import { isUniqueViolation, isUnreachable, SNAPSHOT } from '@coffre/db/dialect';
+import { isUnavailable, isUniqueViolation, SNAPSHOT } from '@coffre/db/dialect';
 import { everyProjectConversion, newestAccess, reportStands } from '@coffre/db/grants';
 import { appendEntries, lockLogHead, missingEntry, newestAuthentic, type Appended, type Authenticity, type Newest, type NewEntry } from '@coffre/db/log';
 
@@ -2550,7 +2550,7 @@ class VaultService implements Vault {
         scrub = await this.#db.transaction((tx) => this.#scrub(tx, walked.from), SNAPSHOT);
       } catch (error) {
         // Only the database not answering, or a statement it gave up on: anything else is coffre's to fix.
-        if (!isUnreachable(error) && !timedOut(error)) throw error;
+        if (!isUnavailable(error)) throw error;
         stalled = `the rehash of the past did not run, and goes on where it was next time: ${(error as Error).message}`;
       }
     }
@@ -2913,14 +2913,6 @@ type Resumed = {
 /** A lap of the rehash of the past: the last entry rehashed, and the prefix it rehashes to, signed when it began. */
 type Lap = { at: Position; end: Position };
 
-/** Whether a statement was cancelled for taking too long: Postgres's `query_canceled`, a statement timeout among them. */
-function timedOut(error: unknown): boolean {
-  for (let cause = error; typeof cause === 'object' && cause !== null; cause = (cause as { cause?: unknown }).cause) {
-    if ((cause as { code?: unknown }).code === '57014') return true;
-  }
-  return false;
-}
-
 /** Where the next rehash of the past goes on from, null for the first entry; or what it found. */
 type Scrubbed = { ok: true; next: Lap | null } | Broken;