better-supabase 0.13.0 → 0.15.0

package/dist/plugins/soft-delete/index.js

@@ -1,90 +0,0 @@
-import { t as and } from "../../types-R6syp1el.js";
-import { a as ok, t as AsyncResult } from "../../result-DIT_qp4G.js";
-import { r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { n as scopeOperation } from "../../scope-DgWjuXUw.js";
-import { a as insertsOnly, c as withDefault, i as guardManaged, o as isNotNull, s as isNull, t as dbName } from "../../shared-C80IHf4B.js";
-//#region src/plugins/soft-delete/index.ts
-function deletedColumn(table) {
-	return dbName(table, table.flags.softDelete);
-}
-function scopeFor(table) {
-	const column = deletedColumn(table);
-	return column ? isNull(column) : void 0;
-}
-/**
-* Soft delete for tables generated with `Flags.softDelete`:
-*
-* - Reads, updates and deletes skip deleted rows, including inside includes and
-*   relation filters (`withDeleted` / `onlyDeleted` change the root table);
-* - `delete` sets the column instead (`{ hard: true }` really deletes);
-* - `restore(key)` clears it.
-*
-* Deletes become updates without `RETURNING`, so a SELECT policy that hides
-* deleted rows does not make them fail. `deleteMany({ returning: true })` keeps
-* `RETURNING`, which needs a SELECT policy that still shows the row.
-*/
-function softDelete() {
-	return definePlugin({
-		name: "softDelete",
-		enforce: "pre",
-		scopes: ["softDelete"],
-		describe(api) {
-			for (const { table } of api.resources) {
-				const flag = table.flags.softDelete;
-				if (!flag) continue;
-				api.markReadOnly(table.key, flag, "Set when the row is deleted. Deleted rows are not returned, and delete sets this column instead of removing the row.");
-			}
-		},
-		transformQuery(op, { options }) {
-			const hardDelete = op.kind === "delete" && options["hard"] === true;
-			const withDeleted = options["withDeleted"] === true || hardDelete;
-			const onlyDeleted = options["onlyDeleted"] === true;
-			const scoped = scopeOperation(op, scopeFor, !withDeleted && !onlyDeleted);
-			const column = deletedColumn(op.table);
-			if (!onlyDeleted || !column || scoped.kind === "insert") return scoped;
-			return {
-				...scoped,
-				where: and(scoped.where, isNotNull(column))
-			};
-		},
-		beforeMutation(op, { table, options, now }) {
-			const column = deletedColumn(table);
-			if (!column) return op;
-			guardManaged(op, [column], "softDelete", options);
-			if (op.kind === "insert") {
-				if (insertsOnly(op)) return op;
-				return {
-					...op,
-					rows: op.rows.map((row) => withDefault(row, column, null))
-				};
-			}
-			if (op.kind !== "delete" || options["hard"] === true) return op;
-			return {
-				kind: "update",
-				intent: "softDelete",
-				table,
-				set: { [column]: now().toString() },
-				where: op.where,
-				returning: options["returning"] === true ? op.returning : void 0,
-				...op.maxAffected === void 0 ? {} : { maxAffected: op.maxAffected },
-				...op.count === void 0 ? {} : { count: op.count }
-			};
-		},
-		repository({ table, base }) {
-			const flag = table.flags.softDelete;
-			if (!flag) return;
-			const update = base["update"];
-			return { restore: (key, args) => AsyncResult.from(async () => {
-				const result = await update(key, { [flag]: null }, {
-					...args,
-					withDeleted: true,
-					returning: false,
-					override: true
-				});
-				return result.ok ? ok(void 0) : result;
-			}) };
-		}
-	});
-}
-//#endregion
-export { softDelete };

package/dist/plugins/tenant/index.d.ts

@@ -1,60 +0,0 @@
-import { F as SchemaMeta } from "../../types-DmshMaXz.js";
-import { d as Plugin, m as RequestContext, o as HasFlag, p as RepositoryExtension } from "../../plugin-DouW0Kvg.js";
-//#region src/plugins/tenant/index.d.ts
-/**
- * Dotted paths to the string claims of `C` (up to three levels), e.g.
- * `'tenant_id' | 'app_metadata.tenant_id'`. Any string without a claims type.
- */
-export type ClaimPath<C> = unknown extends C ? string : StringPaths<C, [1, 2, 3]>;
-type StringPaths<T, Depth extends readonly unknown[]> = T extends object ? T extends readonly unknown[] ? never : { [K in keyof T & string]-?: (NonNullable<T[K]> extends string ? K : never) | (Depth extends readonly [unknown, ...infer Rest] ? `${K}.${StringPaths<NonNullable<T[K]>, Rest>}` : never); }[keyof T & string] : never;
-/**
- * `C` is the claims type (`betterSupabase.claims(schema)`'s output); it types
- * `claim`.
- */
-export interface TenantOptions<C = unknown> {
-  /**
-   * JWT claim path(s) holding the tenant id when `context.tenant` is not set.
-   * Dots walk into objects. Defaults to `config.claims.tenant` (`tenant_id`),
-   * then the same key in `app_metadata`. `user_metadata` is never a source:
-   * users can write it.
-   */
-  readonly claim?: ClaimPath<C> | readonly ClaimPath<C>[];
-  /** Custom resolution, e.g. from a header validated against memberships. */
-  readonly resolve?: (context: RequestContext) => string | undefined;
-  /**
-   * What happens on a tenant table without a tenant in the context: `error`
-   * (default) fails with `forbidden`; `skip` leaves it to RLS.
-   */
-  readonly onMissing?: "error" | "skip";
-  /**
-   * The request header `resolve` reads the tenant from. The plugin does not
-   * read it; `defineApi` documents it as a parameter of tenant tables.
-   */
-  readonly header?: string;
-}
-export interface TenantFindArgs {
-  /**
-   * Skip the tenant filter for this call (admin tooling, jobs). RLS still
-   * applies.
-   */
-  readonly allTenants?: boolean;
-}
-export interface TenantExtension extends RepositoryExtension {
-  readonly findArgs: HasFlag<this["M"], this["T"], "tenant"> extends true ? TenantFindArgs : unknown;
-  readonly methods: unknown;
-  readonly deleteArgs: HasFlag<this["M"], this["T"], "tenant"> extends true ? TenantFindArgs : unknown;
-}
-/**
- * The tenant for a request: `context.tenant`, then the configured claim.
- * `schema` supplies the default claim (`config.claims.tenant`).
- */
-export declare function resolveTenant<C = unknown>(context: RequestContext, options?: TenantOptions<C>, schema?: Pick<SchemaMeta, "claims">): string | undefined;
-/**
- * Multi-tenancy for tables generated with `Flags.tenant`. Scopes reads, updates
- * and deletes to the request's tenant (nested includes and relation filters
- * too), fills the tenant column on insert and rejects writes that would move
- * rows to another tenant. It complements RLS; it does not replace it.
- */
-export declare function tenant<C = unknown>(options?: TenantOptions<C>): Plugin<"tenant", TenantExtension>;
-//#endregion
-export {};

package/dist/plugins/tenant/index.js

@@ -1,119 +0,0 @@
-import { t as DbException } from "../../db-exception-CnWcYPxL.js";
-import { n as dbError } from "../../errors-D7u24ZJH.js";
-import { a as spansAllTenants, r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { n as scopeOperation } from "../../scope-DgWjuXUw.js";
-import { o as tenantFrom, s as tenantPathsFor } from "../../claims-Bp9My7XP.js";
-import { a as insertsOnly, n as equals, r as forbidden, t as dbName } from "../../shared-C80IHf4B.js";
-//#region src/plugins/tenant/index.ts
-/**
-* The tenant for a request: `context.tenant`, then the configured claim.
-* `schema` supplies the default claim (`config.claims.tenant`).
-*/
-function resolveTenant(context, options = {}, schema) {
-	if (options.resolve) return options.resolve(context);
-	const claim = options.claim;
-	return tenantFrom(context, tenantPathsFor(claim, schema));
-}
-/** Tenant columns may be numeric; the resolved tenant is always a string. */
-function sameTenant(value, id) {
-	if (value === id) return true;
-	return (typeof value === "number" || typeof value === "bigint") && String(value) === id;
-}
-function tenantColumn(table) {
-	return dbName(table, table.flags.tenant);
-}
-/**
-* Multi-tenancy for tables generated with `Flags.tenant`. Scopes reads, updates
-* and deletes to the request's tenant (nested includes and relation filters
-* too), fills the tenant column on insert and rejects writes that would move
-* rows to another tenant. It complements RLS; it does not replace it.
-*/
-function tenant(options = {}) {
-	const onMissing = options.onMissing ?? "error";
-	/** A context is fixed for a connection, so its tenant is resolved once. */
-	const resolved = /* @__PURE__ */ new WeakMap();
-	const resolvedFor = (context, schema) => {
-		let id = resolved.get(context);
-		if (id === void 0 && !resolved.has(context)) {
-			id = resolveTenant(context, options, schema);
-			resolved.set(context, id);
-		}
-		return id;
-	};
-	const missing = (table) => {
-		throw new DbException(dbError("forbidden", `No tenant in the request context for "${table.key}"`));
-	};
-	const current = (table, context, schema) => {
-		const id = resolvedFor(context, schema);
-		if (id === void 0 && onMissing === "error" && tenantColumn(table)) missing(table);
-		return id;
-	};
-	return definePlugin({
-		name: "tenant",
-		scopes: ["tenant"],
-		describe(api) {
-			for (const { table } of api.resources) {
-				const flag = table.flags.tenant;
-				if (!flag) continue;
-				api.markReadOnly(table.key, flag, "Set from the request's tenant.");
-				if (options.header) api.addParameter(table.key, {
-					name: options.header,
-					in: "header",
-					required: onMissing === "error",
-					description: "The tenant the request acts for.",
-					schema: { type: "string" }
-				});
-			}
-		},
-		context(context, { schema }) {
-			if (spansAllTenants(context)) return context;
-			const id = resolvedFor(context, schema);
-			if (id === void 0 || id === context.tenant) return context;
-			const derived = {
-				...context,
-				tenant: id
-			};
-			resolved.set(derived, id);
-			return derived;
-		},
-		transformQuery(op, { context, schema, options: call }) {
-			if (call["allTenants"] === true || spansAllTenants(context)) return op;
-			const id = resolvedFor(context, schema);
-			if (id === void 0) {
-				if (onMissing === "error") scopeOperation(op, (table) => tenantColumn(table) ? missing(table) : void 0);
-				return op;
-			}
-			return scopeOperation(op, (table) => {
-				const column = tenantColumn(table);
-				return column ? equals(column, id) : void 0;
-			});
-		},
-		beforeMutation(op, { table, context, schema, options: call }) {
-			const column = tenantColumn(table);
-			if (!column || call["allTenants"] === true || spansAllTenants(context)) return op;
-			const id = current(table, context, schema);
-			if (id === void 0) return op;
-			switch (op.kind) {
-				case "insert":
-					if (!insertsOnly(op) && !op.onConflict?.columns.includes(column)) forbidden(`An upsert on ${table.key} that updates on conflict needs the tenant column "${column}" in its conflict target`);
-					return {
-						...op,
-						rows: op.rows.map((row) => {
-							if (column in row && !sameTenant(row[column], id)) forbidden(`Cannot write a ${table.key} row for another tenant`);
-							return {
-								...row,
-								[column]: id
-							};
-						})
-					};
-				case "update":
-					if (column in op.set && !sameTenant(op.set[column], id)) forbidden(`Cannot move a ${table.key} row to another tenant`);
-					return op;
-				case "delete": return op;
-				default: return op;
-			}
-		}
-	});
-}
-//#endregion
-export { resolveTenant, tenant };

package/dist/plugins/timestamps/index.d.ts

@@ -1,11 +0,0 @@
-import { d as Plugin } from "../../plugin-DouW0Kvg.js";
-//#region src/plugins/timestamps/index.d.ts
-/**
- * Stamps the columns generated as `Flags.timestamps`: `createdAt` on insert,
- * `updatedAt` on insert and update. A call that sets either column fails with
- * `invalid_request` unless it passes `{ override: true }`, which keeps the
- * caller's values. Pair it with the `updated-at` SQL module trigger to cover
- * writes that bypass the app.
- */
-export declare function timestamps(): Plugin<"timestamps">;
-//#endregion

package/dist/plugins/timestamps/index.js

@@ -1,47 +0,0 @@
-import { r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { a as insertsOnly, c as withDefault, i as guardManaged, t as dbName } from "../../shared-C80IHf4B.js";
-//#region src/plugins/timestamps/index.ts
-/**
-* Stamps the columns generated as `Flags.timestamps`: `createdAt` on insert,
-* `updatedAt` on insert and update. A call that sets either column fails with
-* `invalid_request` unless it passes `{ override: true }`, which keeps the
-* caller's values. Pair it with the `updated-at` SQL module trigger to cover
-* writes that bypass the app.
-*/
-function timestamps() {
-	return definePlugin({
-		name: "timestamps",
-		describe(api) {
-			for (const { table } of api.resources) {
-				const flags = table.flags.timestamps;
-				if (flags?.createdAt) api.markReadOnly(table.key, flags.createdAt, "Set by the server when the row is created.");
-				if (flags?.updatedAt) api.markReadOnly(table.key, flags.updatedAt, "Set by the server on every write.");
-			}
-		},
-		beforeMutation(op, { table, now, options }) {
-			const flags = table.flags.timestamps;
-			if (!flags) return op;
-			const created = dbName(table, flags.createdAt);
-			const updated = dbName(table, flags.updatedAt);
-			guardManaged(op, [created, updated], "timestamps", options);
-			const stamp = now().toString();
-			switch (op.kind) {
-				case "insert": {
-					const stampCreated = insertsOnly(op);
-					return {
-						...op,
-						rows: op.rows.map((row) => withDefault(stampCreated ? withDefault(row, created, stamp) : row, updated, stamp))
-					};
-				}
-				case "update": return {
-					...op,
-					set: withDefault(op.set, updated, stamp)
-				};
-				case "delete": return op;
-				default: return op;
-			}
-		}
-	});
-}
-//#endregion
-export { timestamps };

package/dist/plugins/validation/index.d.ts

@@ -1,24 +0,0 @@
-import { t as StandardSchemaV1 } from "../../standard-16AIDny5.js";
-import { d as Plugin } from "../../plugin-DouW0Kvg.js";
-//#region src/plugins/validation/index.d.ts
-export interface TableValidators {
-  /** Validates inserts and upserts, with app-cased keys. */
-  readonly insert?: StandardSchemaV1;
-  /** Validates update patches, with app-cased keys. */
-  readonly update?: StandardSchemaV1;
-}
-export interface ValidationOptions {
-  /**
-   * Validators per table key. The `validators` export of a generated `zod()` or
-   * `valibot()` module fits as is.
-   */
-  readonly schemas: Readonly<Record<string, TableValidators>>;
-}
-/**
- * Validates writes with Standard Schema validators (zod, valibot, arktype,
- * ...). Runs after other plugins (`enforce: 'post'`), so it sees the tenant,
- * timestamp and actor columns they fill. Failures become `validation` errors
- * (422) with issue paths; bulk writes prefix the row index.
- */
-export declare function validation(options: ValidationOptions): Plugin<"validation">;
-//#endregion

package/dist/plugins/validation/index.js

@@ -1,83 +0,0 @@
-import { t as DbException } from "../../db-exception-CnWcYPxL.js";
-import { n as dbError } from "../../errors-D7u24ZJH.js";
-import { i as encodeValue, r as decodeValue } from "../../wire-BJhepFbv.js";
-import { r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { n as validate } from "../../standard-l10kE0yS.js";
-import { n as toDb, t as toApp } from "../../casing-DdFWEtqr.js";
-//#region src/plugins/validation/index.ts
-/**
-* Rows reach plugins in wire form (ISO text, decimal text), while generated
-* validators expect the column codecs' app values (Temporal, `bigint`).
-*/
-function decoded(table, row) {
-	const app = toApp(table, row);
-	for (const [name, value] of Object.entries(app)) {
-		const codec = table.columns[name]?.codec;
-		if (codec === void 0 || typeof value !== "string") continue;
-		try {
-			app[name] = decodeValue(codec, value);
-		} catch {}
-	}
-	return app;
-}
-function encoded(row) {
-	for (const [name, value] of Object.entries(row)) row[name] = encodeValue(value);
-	return row;
-}
-async function check(schema, table, row, label, index) {
-	const result = await validate(schema, decoded(table, row), label);
-	if (result.ok) {
-		const output = result.data;
-		return typeof output === "object" && output !== null ? {
-			...row,
-			...encoded(toDb(table, output))
-		} : { ...row };
-	}
-	const error = result.error;
-	if (index === void 0 || error.kind !== "validation") throw new DbException(error);
-	const issues = error.issues.map((issue) => ({
-		message: issue.message,
-		path: [index, ...issue.path ?? []]
-	}));
-	throw new DbException(dbError("validation", error.message, { issues }));
-}
-/**
-* Validates writes with Standard Schema validators (zod, valibot, arktype,
-* ...). Runs after other plugins (`enforce: 'post'`), so it sees the tenant,
-* timestamp and actor columns they fill. Failures become `validation` errors
-* (422) with issue paths; bulk writes prefix the row index.
-*/
-function validation(options) {
-	return definePlugin({
-		name: "validation",
-		enforce: "post",
-		async beforeMutation(op, { table }) {
-			const validators = options.schemas[table.key];
-			if (!validators) return op;
-			switch (op.kind) {
-				case "insert": {
-					const schema = validators.insert;
-					if (!schema) return op;
-					const many = op.rows.length > 1;
-					const rows = await Promise.all(op.rows.map((row, index) => check(schema, table, row, `${table.key} insert`, many ? index : void 0)));
-					return {
-						...op,
-						rows
-					};
-				}
-				case "update": {
-					const schema = validators.update;
-					if (!schema) return op;
-					return {
-						...op,
-						set: await check(schema, table, op.set, `${table.key} update`, void 0)
-					};
-				}
-				case "delete": return op;
-				default: return op;
-			}
-		}
-	});
-}
-//#endregion
-export { validation };

package/dist/pool-Bu8zXGzI.d.ts

@@ -1,123 +0,0 @@
-import { r as Executor } from "./executor-C29668fO.js";
-import { o as EventHub } from "./events-DhGgwqQA.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { n as SqlClient } from "./executor-DXfgDsKd.js";
-//#region src/postgres/pool.d.ts
-/** The part of a `pg` pool client `createPostgres` uses. */
-interface PgPoolClient {
-  query(text: string, values?: unknown[]): Promise<{
-    rows: unknown[];
-  }>;
-  release(): void;
-}
-/** The part of a `pg.Pool` `createPostgres` uses. */
-interface PgPool {
-  connect(): Promise<PgPoolClient>;
-  end(): Promise<void>;
-  /** `pg.Pool` reports errors of idle connections here. */
-  on?(event: "error", listener: (error: Error) => void): unknown;
-}
-/** Statement timeouts in milliseconds by the role a transaction runs as. */
-interface PostgresTimeouts {
-  /**
-   * The connection-string role (`admin` and `transaction` without claims).
-   * Unset by default.
-   */
-  readonly admin?: number;
-  /** Defaults to 8000, Supabase's setting for the role. */
-  readonly authenticated?: number;
-  /** Defaults to 3000, Supabase's setting for the role. */
-  readonly anon?: number;
-}
-interface PostgresOptions {
-  /**
-   * Defaults to `$SUPABASE_DB_URL`, `$DATABASE_URL`, `$POSTGRES_URL`, then
-   * `$POSTGRES_URL_NON_POOLING`, the first one set.
-   */
-  readonly connectionString?: string;
-  /** An existing pool to run on instead of opening one. `end()` ends it. */
-  readonly pool?: PgPool;
-  readonly max?: number;
-  /**
-   * Statement timeout in milliseconds, applied per transaction: one value for
-   * every role, or one per role. `set role` doesn't apply the role's own
-   * `statement_timeout`, so `authenticated` and `anon` get Supabase's 8 s and 3
-   * s unless you set them.
-   */
-  readonly statementTimeout?: number | PostgresTimeouts;
-  /**
-   * Ends a session that stays idle inside a transaction this long, in
-   * milliseconds, so `transaction(fn)` can't hold a connection while `fn` waits
-   * on something else. Defaults to 15000; `0` turns it off. Statements outside
-   * a transaction don't set it.
-   */
-  readonly idleInTransactionTimeout?: number;
-  /** How long `connect` waits for a connection, in milliseconds. Defaults to 10000. */
-  readonly connectionTimeout?: number;
-  /** How long an unused connection stays open, in milliseconds. Defaults to 10000. */
-  readonly idleTimeout?: number;
-  /**
-   * `betterSupabase.events`: an error on an idle pooled connection arrives as
-   * an `error` event instead of crashing the process.
-   */
-  readonly events?: EventHub;
-  /**
-   * Where idle-connection errors go without `error` handlers. Defaults to the
-   * console.
-   */
-  readonly logger?: Logger;
-}
-/** JWT claims to run as. `role` must be `authenticated` or `anon`. */
-interface SqlClaims {
-  readonly sub?: string;
-  readonly role?: string;
-  readonly [claim: string]: unknown;
-}
-/** What every transaction of a user session sets besides the claims and role. */
-interface SessionOptions {
-  /**
-   * Transaction-local settings, e.g. `{ 'better_supabase.tenant': id }`. Names
-   * need a dot (custom settings); `role` and `request.jwt.claims` are set from
-   * the claims.
-   */
-  readonly settings?: Readonly<Record<string, string>>;
-  /** Runs every transaction with `begin read only`: writes fail with 25006. */
-  readonly readOnly?: boolean;
-  /**
-   * Statement timeout in milliseconds for this session's transactions, instead
-   * of the role's `statementTimeout` from `createPostgres`.
-   */
-  readonly statementTimeout?: number;
-}
-interface BetterPostgres {
-  /** Connects as the connection-string role. On Supabase that bypasses RLS. */
-  readonly admin: SqlClient;
-  /** Runs every query as the given user, with RLS, like PostgREST does. */
-  asUser(claims: SqlClaims, options?: SessionOptions): SqlClient;
-  /** Runs every query as `anon`. */
-  readonly anon: SqlClient;
-  /**
-   * Repositories' executor as the given user
-   * (`postgresExecutor(asUser(claims))`). `createServer` calls it for
-   * `ctx.sql`, so only apps that pass `postgres` bundle the SQL compiler.
-   */
-  executorFor(claims: SqlClaims, options?: SessionOptions): Executor;
-  /**
-   * Runs `fn` in one transaction. Pass claims to run it as a user; the session
-   * options apply with or without them.
-   */
-  transaction<T>(fn: (client: SqlClient) => Promise<T>, options?: {
-    readonly claims?: SqlClaims;
-  } & SessionOptions): Promise<T>;
-  end(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
-}
-/**
- * A pooled Postgres connection for jobs, scripts and tests. Each query (or
- * transaction) runs in its own transaction; claims and role are
- * transaction-local, so nothing leaks back into the pool. An `admin` query with
- * no timeout to set runs on its own, without `begin` and `commit`.
- */
-declare function createPostgres(options?: PostgresOptions): BetterPostgres;
-//#endregion
-export { PostgresTimeouts as a, createPostgres as c, PostgresOptions as i, PgPool as n, SessionOptions as o, PgPoolClient as r, SqlClaims as s, BetterPostgres as t };

package/dist/pool-errors-DOZ3oDeS.js

@@ -1,27 +0,0 @@
-import { c as mapDbError } from "./errors-D7u24ZJH.js";
-import { s as toDbError } from "./result-DIT_qp4G.js";
-import { t as consoleLogger } from "./logger-glM28NVN.js";
-import { n as errorEvent } from "./events-D6IZ5CE8.js";
-import { t as fromPgError } from "./pg-error-B5QLDcbG.js";
-//#region src/postgres/pool-errors.ts
-/**
-* Listens for errors on idle pooled connections, such as a server restart or an
-* ended session. `pg.Pool` emits them as an `error` event, and Node exits on an
-* `error` event nobody listens to. The listener reports the error and never
-* throws.
-*/
-function watchPoolErrors(pool, options) {
-	pool.on?.("error", (cause) => {
-		try {
-			const raw = fromPgError(cause);
-			const error = raw ? mapDbError(raw, []) : toDbError(cause);
-			if (options.events?.has("error")) {
-				options.events.emit("error", errorEvent(error));
-				return;
-			}
-			(options.logger ?? options.events?.logger ?? consoleLogger).error("an idle Postgres connection failed", { error });
-		} catch {}
-	});
-}
-//#endregion
-export { watchPoolErrors as t };