@vercel/board 0.0.0-stage → 0.15.0

package/dist/backend-a2/store-postgres.d.mts

@@ -0,0 +1,38 @@
+import { t as BoardStore } from "../types-BHCjTZdB.mjs";
+//#region src/store/postgres-db.d.ts
+/** What the tables need of a `pg` Pool, or of anything shaped like one. */
+type PgQueryable = {
+  query(text: string, values?: unknown[]): Promise<{
+    rows: Record<string, unknown>[];
+    rowCount: number | null;
+  }>;
+};
+type PgPool = PgQueryable & {
+  connect(): Promise<PgQueryable & {
+    release(): void;
+  }>;
+  end(): Promise<void>;
+};
+//#endregion
+//#region src/store/postgres.d.ts
+export type PostgresOptions = {
+  /** A direct connection to the same database, for live updates by notification. */
+  listenConnectionString?: string;
+} & ({
+  /** The database: A2's log and board's tables, which `schema.sql` creates. */
+  connectionString: string;
+  /** Connections board's own pool may open; A2 keeps a pool of its own. Default 5. */
+  max?: number;
+} | {
+  /**
+   * A `pg` Pool you made, shared by A2's log and board's tables: for a password
+   * that comes from a callback, say. Closing the store ends it.
+   */
+  client: PgPool;
+});
+/**
+ * A board on Postgres (`npm i pg`). Apply `node_modules/@vercel/board/sql/postgres/schema.sql`
+ * before the first deploy: neither A2 nor board creates tables in Postgres.
+ */
+export declare function postgres(options: PostgresOptions): BoardStore;
+//#endregion

package/dist/backend-a2/store-postgres.mjs

@@ -0,0 +1,110 @@
+import { r as sqlTables } from "../sql-DbiEnqM0.mjs";
+import { postgres as postgres$1 } from "experimental-a2/store-postgres";
+//#region src/store/postgres-db.ts
+const SCHEMA_FILE = "node_modules/@vercel/board/sql/postgres/schema.sql";
+/** The board's own error for tables that aren't there: the fix is a file to apply. */
+var TablesNotConfiguredError = class extends Error {
+	code = "STORE_NOT_CONFIGURED";
+};
+/** Missing tables or columns (42P01, 42703), or missing grants (42501), say what to apply. */
+function explain(error) {
+	const code = error?.code;
+	if (code === "42P01" || code === "42703") return new TablesNotConfiguredError(`board's tables aren't in this database: apply ${SCHEMA_FILE}`, { cause: error });
+	if (code === "42501") return new TablesNotConfiguredError(`this database role can't use board's tables: grant it select, insert, update, and delete on them`, { cause: error });
+	return error;
+}
+/**
+* The tables on Postgres, through a pool that `pool()` makes the first time it's
+* needed. `owned`: closing the tables ends the pool.
+*/
+function postgresDb(pool, options = { owned: true }) {
+	const run = async (queryable, query) => {
+		try {
+			return await queryable.query(query.text, query.values);
+		} catch (error) {
+			throw explain(error);
+		}
+	};
+	/** Runs `body` in a transaction, which commits when it returns true and rolls back otherwise. */
+	async function transaction(begin, body) {
+		const client = await (await pool()).connect();
+		try {
+			await client.query(begin);
+			const keep = await body(client);
+			await client.query(keep ? "commit" : "rollback");
+			return keep;
+		} catch (error) {
+			await client.query("rollback").catch(() => {});
+			throw error;
+		} finally {
+			client.release();
+		}
+	}
+	return {
+		dialect: "postgres",
+		all: async (query) => (await run(await pool(), query)).rows,
+		async read(queries) {
+			const rows = [];
+			await transaction("begin isolation level repeatable read read only", async (client) => {
+				for (const query of queries) rows.push((await run(client, query)).rows);
+				return true;
+			});
+			return rows;
+		},
+		commit: (claim, writes) => transaction("begin", async (client) => {
+			if ((await run(client, claim)).rows.length === 0) return false;
+			for (const write of writes) await run(client, write);
+			return true;
+		}),
+		async close() {
+			if (options.owned) await (await pool()).end();
+		}
+	};
+}
+//#endregion
+//#region src/store/postgres.ts
+/** `pg` is an optional peer, installed by the apps that use Postgres. */
+const PG = "pg";
+/**
+* A board on Postgres (`npm i pg`). Apply `node_modules/@vercel/board/sql/postgres/schema.sql`
+* before the first deploy: neither A2 nor board creates tables in Postgres.
+*/
+function postgres(options) {
+	const listen = options.listenConnectionString ? { listenConnectionString: options.listenConnectionString } : {};
+	if ("client" in options) {
+		if (typeof options.client.connect !== "function") throw new TypeError("postgres({ client }) takes a pg Pool, which has connect()");
+		const log = postgres$1({
+			client: options.client,
+			...listen
+		});
+		return {
+			log,
+			tables: sqlTables(postgresDb(async () => options.client, { owned: false })),
+			close: () => log.close()
+		};
+	}
+	const log = postgres$1({
+		connectionString: options.connectionString,
+		...listen
+	});
+	let pool = null;
+	const open = () => pool ??= import(PG).then(({ default: pg }) => {
+		const opened = new pg.Pool({
+			connectionString: options.connectionString,
+			max: options.max ?? 5
+		});
+		opened.on("error", () => {});
+		return opened;
+	});
+	const tables = sqlTables(postgresDb(open));
+	return {
+		log,
+		tables,
+		async close() {
+			if (pool) await tables.close();
+			await log.close();
+		}
+	};
+}
+//#endregion
+export { postgres };

package/dist/backend-a2/store-redis-http.d.mts

@@ -0,0 +1,17 @@
+import { t as BoardStore } from "../types-BHCjTZdB.mjs";
+//#region src/store/redis-http.d.ts
+export type RedisHttpOptions = {
+  /** The REST endpoint, e.g. `process.env.UPSTASH_REDIS_REST_URL`. */
+  url: string;
+  /** Its bearer token, e.g. `process.env.UPSTASH_REDIS_REST_TOKEN`. */
+  token: string;
+  /**
+   * Isolates boards on one Redis: A2's log and board's tables both live under it. Default `'a2'`.
+   * It can't contain braces. board 0.14 (A2 0.22) names every key differently, so a board moves
+   * to a new prefix and starts with an empty log: on one board 0.13 wrote, every request answers 503.
+   */
+  keyPrefix?: string;
+};
+/** A board on Redis over Upstash's REST API: no connection to keep, so it suits functions. */
+export declare function redisHttp(options: RedisHttpOptions): BoardStore;
+//#endregion

package/dist/backend-a2/store-redis-http.mjs

@@ -0,0 +1,32 @@
+import { t as redisTables } from "../redis-tables-B35vv4CZ.mjs";
+import { redisHttp as redisHttp$1 } from "experimental-a2/store-redis-http";
+//#region src/store/redis-http.ts
+/** A board on Redis over Upstash's REST API: no connection to keep, so it suits functions. */
+function redisHttp(options) {
+	const keyPrefix = options.keyPrefix ?? "a2";
+	const log = redisHttp$1({
+		url: options.url,
+		token: options.token,
+		keyPrefix
+	});
+	const call = async (command, ...args) => {
+		const response = await fetch(options.url, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${options.token}`,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify([command, ...args.map(String)])
+		});
+		const body = await response.json().catch(() => null);
+		if (body === null || !response.ok || body.error !== void 0) throw new Error(`redis rest command failed: ${body?.error ?? `status ${response.status}`}`);
+		return body.result;
+	};
+	return {
+		log,
+		tables: redisTables(call, keyPrefix),
+		close: () => log.close()
+	};
+}
+//#endregion
+export { redisHttp };

package/dist/backend-a2/store-redis.d.mts

@@ -0,0 +1,23 @@
+import { t as BoardStore } from "../types-BHCjTZdB.mjs";
+import { RedisConnection } from "experimental-a2/store-redis";
+//#region src/store/redis.d.ts
+export type RedisOptions = {
+  /**
+   * Isolates boards on one Redis: A2's log and board's tables both live under it. Default `'a2'`.
+   * It can't contain braces. board 0.14 (A2 0.22) names every key differently, so a board moves
+   * to a new prefix and starts with an empty log: on one board 0.13 wrote, every request answers 503.
+   */
+  keyPrefix?: string;
+} & ({
+  /** The Redis server, as `ioredis` takes it: `redis://…` or `rediss://…`. */
+  url: string;
+} | {
+  /** A client you made, shared by A2's log and board's tables. Closing the store ends it. */
+  client: RedisConnection;
+});
+/**
+ * A board on Redis over TCP (`npm i ioredis`): a single server or a provider
+ * without cluster mode, since each write is one script across many keys.
+ */
+export declare function redis(options: RedisOptions): BoardStore;
+//#endregion

package/dist/backend-a2/store-redis.mjs

@@ -0,0 +1,39 @@
+import { t as redisTables } from "../redis-tables-B35vv4CZ.mjs";
+import { redis as redis$1 } from "experimental-a2/store-redis";
+//#region src/store/redis.ts
+/** `ioredis` is an optional peer, installed by the apps that use Redis over TCP. */
+const IOREDIS = "ioredis";
+/**
+* A board on Redis over TCP (`npm i ioredis`): a single server or a provider
+* without cluster mode, since each write is one script across many keys.
+*/
+function redis(options) {
+	const keyPrefix = options.keyPrefix ?? "a2";
+	if ("client" in options) {
+		const log = redis$1({
+			client: options.client,
+			keyPrefix
+		});
+		return {
+			log,
+			tables: redisTables((command, ...args) => options.client.call(command, ...args), keyPrefix),
+			close: () => log.close()
+		};
+	}
+	const log = redis$1({
+		url: options.url,
+		keyPrefix
+	});
+	let client = null;
+	const open = () => client ??= import(IOREDIS).then(({ default: Redis }) => new Redis(options.url));
+	return {
+		log,
+		tables: redisTables(async (command, ...args) => (await open()).call(command, ...args), keyPrefix),
+		async close() {
+			if (client) (await client).disconnect();
+			await log.close();
+		}
+	};
+}
+//#endregion
+export { redis };

package/dist/backend-a2/store-sqlite.d.mts

@@ -0,0 +1,12 @@
+import { t as BoardStore } from "../types-BHCjTZdB.mjs";
+//#region src/store/sqlite.d.ts
+/**
+ * A board in one SQLite file, A2's log and board's tables side by side: `a2()`'s
+ * store when it's given none, for development, `vb serve`, and a single
+ * long-running server. It creates its tables when it opens, and a serverless
+ * function, whose files are read-only, can't open it.
+ */
+export declare function sqlite(options?: {
+  path?: string;
+}): BoardStore;
+//#endregion

package/dist/backend-a2/store-sqlite.mjs

@@ -0,0 +1,31 @@
+import { r as sqlTables } from "../sql-DbiEnqM0.mjs";
+import { t as sqliteDb } from "../sqlite-db-Cbj03vmp.mjs";
+import { sqlite as sqlite$1 } from "experimental-a2/store-sqlite";
+//#region src/store/sqlite.ts
+/**
+* A board in one SQLite file, A2's log and board's tables side by side: `a2()`'s
+* store when it's given none, for development, `vb serve`, and a single
+* long-running server. It creates its tables when it opens, and a serverless
+* function, whose files are read-only, can't open it.
+*/
+function sqlite(options = {}) {
+	const path = options.path ?? ".a2/dev.db";
+	const log = sqlite$1({ path });
+	let tables;
+	try {
+		tables = sqlTables(sqliteDb(path));
+	} catch (error) {
+		log.close();
+		throw error;
+	}
+	return {
+		log,
+		tables,
+		async close() {
+			await tables.close();
+			log.close();
+		}
+	};
+}
+//#endregion
+export { sqlite };

package/dist/backend-a2.d.mts

@@ -0,0 +1,4 @@
+import { n as A2Options, r as a2, t as A2Backend } from "./a2-5EG8FkZ8.mjs";
+import { t as BoardStore } from "./types-BHCjTZdB.mjs";
+import { n as fsBlob, r as memoryBlob, t as BlobStore } from "./blob-C0J3wbGv.mjs";
+export { type A2Backend, type A2Options, type BlobStore, type BoardStore, a2, fsBlob, memoryBlob };

package/dist/backend-a2.mjs

@@ -0,0 +1,2 @@
+import { n as fsBlob, r as memoryBlob, t as a2 } from "./a2-DYGYankn.mjs";
+export { a2, fsBlob, memoryBlob };