Preferred way to share database connection pool

[ravinggenius]

I have a single file where I instantiate a connection:

// src/library/_/datastore.ts

import { createPool, sql } from "slonik";
import { z } from "zod";

import * as config from "./config.mjs";

export const pool = createPool(config.databaseUrl);

export { sql };

export const BOOLEAN_NAMED = (name: string) =>
	z.object({
		[name]: z.boolean()
	});

export const VOID = z.object({}).strict();

Then in my data access layer, I have functions that look like this:

// src/library/session/model.ts

import { pool, sql, VOID } from "../_/datastore";

import { ACCOUNT } from "../account/schema";

import { Session } from "./schema";

// others omitted for brevity

export const verify = async (sessionId: Session["id"]) =>
	(await pool).maybeOne(
		sql.type(ACCOUNT.pick({ profileId: true }))`
			SELECT a.profile_id AS "profileId"
			FROM accounts AS a
			INNER JOIN sessions AS s ON a.id = s.account_id
			WHERE s.id = ${sessionId}
			AND s.expires_at > NOW()
			LIMIT 1
		`
	);

export const destroy = async (sessionId: Session["id"]) => {
	await (
		await pool
	).query(sql.type(VOID)`
		DELETE FROM sessions
		WHERE id = ${sessionId}
	`);
};

export const clearExpired = async () => {
	await (
		await pool
	).query(sql.type(VOID)`
		DELETE FROM sessions
		WHERE expires_at <= NOW()
	`);
};

Normally I wouldn't need the await keyword in front of pool, but because createPool() is async, it's required. This seems uncomfortable, but maybe not as bad as calling const pool = await createPool(config.databaseUrl); in every function that needs to use the database. I also tried using top-level await in src/library/_/datastore.ts when defining pool, but that was more trouble. This is a Next app by the way.

It seems my options are as follows:

• create/export pool in central datastore.ts, then import and await it to use (as shown above)
• call createPool() in every model function as needed. this seems weird, because generally each function is independent of the others. most only run a single query, but some have a couple in a single transaction.
• create/export custom async getter function in datastore.ts, then import and call it everywhere. this getter would in turn call createPool(). this is functionally the same as the second option, but it gives me a chance to simplify it a bit.

What is the preferred approach? Is there something I might have missed that would be better?