@snowtop/ent 0.2.8 → 0.2.10

package/action/index.d.ts

@@ -1,6 +1,9 @@
-export { WriteOperation, Builder, Changeset, Trigger, Observer, Validator, Action, saveBuilder, saveBuilderX, setEdgeTypeInGroup, TriggerReturn, ChangesetOptions, } from "./action";
-export { OrchestratorOptions, Orchestrator, EntChangeset, EdgeInputData, } from "./orchestrator";
+export { WriteOperation, saveBuilder, saveBuilderX, setEdgeTypeInGroup, } from "./action";
+export { Orchestrator, EntChangeset } from "./orchestrator";
+export type { Action, Builder, Changeset, ChangesetOptions, Observer, Trigger, TriggerReturn, Validator, } from "./action";
+export type { OrchestratorOptions, EdgeInputData } from "./orchestrator";
 export { DenyIfBuilder, AllowIfBuilder } from "./privacy";
-export { RelativeFieldValue, RelativeNumberValue, NumberOps, convertRelativeInput, maybeConvertRelativeInputPlusExpressions, } from "./relative_value";
+export { NumberOps, convertRelativeInput, maybeConvertRelativeInputPlusExpressions, } from "./relative_value";
+export type { RelativeFieldValue, RelativeNumberValue, } from "./relative_value";
 export { Transaction } from "./transaction";
-export { AssocEdgeOptions } from "./operations";
+export type { AssocEdgeOptions } from "./operations";

package/action/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transaction = exports.maybeConvertRelativeInputPlusExpressions = exports.convertRelativeInput = exports.NumberOps = exports.AllowIfBuilder = exports.DenyIfBuilder = exports.EntChangeset = exports.Orchestrator = exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
 var action_1 = require("./action");
 Object.defineProperty(exports, "WriteOperation", { enumerable: true, get: function () { return action_1.WriteOperation; } });
+// make sure not to expose Executor...
 Object.defineProperty(exports, "saveBuilder", { enumerable: true, get: function () { return action_1.saveBuilder; } });
 Object.defineProperty(exports, "saveBuilderX", { enumerable: true, get: function () { return action_1.saveBuilderX; } });
 Object.defineProperty(exports, "setEdgeTypeInGroup", { enumerable: true, get: function () { return action_1.setEdgeTypeInGroup; } });

package/auth/index.d.ts

@@ -1 +1,2 @@
-export { AuthHandler, AuthViewer, registerAuthHandler, clearAuthHandlers, getLoggedInViewer, buildContext, } from "./auth";
+export { registerAuthHandler, clearAuthHandlers, getLoggedInViewer, buildContext, } from "./auth";
+export type { AuthHandler, AuthViewer } from "./auth";

package/core/base.d.ts

@@ -53,7 +53,7 @@ export interface Ent<TViewer extends Viewer = Viewer> {
     viewer: TViewer;
     getPrivacyPolicy(): PrivacyPolicy<this, TViewer>;
     nodeType: string;
-    __setRawDBData<T extends Data = Data>(data: T): any;
+    __setRawDBData<T extends Data = Data>(data: T): void;
 }
 export declare type Data = {
     [key: string]: any;

package/core/config.d.ts

@@ -12,6 +12,8 @@ declare enum fieldPrivacyEvaluated {
     AT_ENT_LOAD = "at_ent_load",
     ON_DEMAND = "on_demand"
 }
+export type RuntimeMode = "node" | "bun";
+export type PostgresDriver = "pg" | "bun";
 export interface RuntimeDBExtension {
     name: string;
     provisionedBy?: "ent" | "external";
@@ -21,6 +23,8 @@ export interface RuntimeDBExtension {
     dropCascade?: boolean;
 }
 export interface Config {
+    runtime?: RuntimeMode;
+    postgresDriver?: PostgresDriver;
     dbConnectionString?: string;
     dbFile?: string;
     db?: Database | DBDict;

package/core/config.js

@@ -70,8 +70,12 @@ function setConfig(cfg) {
         cfg.dbFile ||
         cfg.db ||
         cfg.devSchema ||
-        cfg.extensions) {
+        cfg.extensions ||
+        cfg.runtime ||
+        cfg.postgresDriver) {
         db_1.default.initDB({
+            runtime: cfg.runtime,
+            postgresDriver: cfg.postgresDriver,
             connectionString: cfg.dbConnectionString,
             dbFile: cfg.dbFile,
             db: cfg.db,

package/core/convert.d.ts

@@ -1,3 +1,7 @@
+export declare function convertDBDate(val: any): string;
+export declare function convertNullableDBDate(val: any): string | null;
+export declare function convertDBDateList(val: any): string[];
+export declare function convertNullableDBDateList(val: any): string[] | null;
 export declare function convertDate(val: any): Date;
 export declare function convertNullableDate(val: any): Date | null;
 export declare function convertBool(val: any): boolean;

package/core/convert.js

@@ -1,5 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDBDate = convertDBDate;
+exports.convertNullableDBDate = convertNullableDBDate;
+exports.convertDBDateList = convertDBDateList;
+exports.convertNullableDBDateList = convertNullableDBDateList;
 exports.convertDate = convertDate;
 exports.convertNullableDate = convertNullableDate;
 exports.convertBool = convertBool;
@@ -16,7 +23,49 @@ exports.convertJSONList = convertJSONList;
 exports.convertNullableJSONList = convertNullableJSONList;
 exports.convertTextToBuffer = convertTextToBuffer;
 exports.convertNullableTextToBuffer = convertNullableTextToBuffer;
+const pg_1 = __importDefault(require("pg"));
 const luxon_1 = require("luxon");
+const TEXT_ARRAY_OID = 1009;
+const parseTextArray = pg_1.default.types.getTypeParser(TEXT_ARRAY_OID);
+function normalizeArrayLikeObject(val) {
+    // This only runs for list-typed fields. Bun's native Postgres client can return
+    // some arrays as `{0: ..., 1: ...}` objects instead of real JS arrays.
+    const keys = Object.keys(val);
+    if (!keys.length) {
+        return [];
+    }
+    if (keys.every((key) => /^\d+$/.test(key))) {
+        return keys
+            .sort((a, b) => parseInt(a, 10) - parseInt(b, 10))
+            .map((key) => val[key]);
+    }
+    throw new Error(`got a non-array from the db: ${JSON.stringify(val)}`);
+}
+function convertDBDate(val) {
+    if (typeof val === "string") {
+        return val.slice(0, 10);
+    }
+    const dt = luxon_1.DateTime.fromJSDate(new Date(val), { zone: "utc" });
+    if (dt.isValid) {
+        const date = dt.toISODate();
+        if (date) {
+            return date;
+        }
+    }
+    return new Date(val).toISOString().slice(0, 10);
+}
+function convertNullableDBDate(val) {
+    if (val === null || val === undefined) {
+        return null;
+    }
+    return convertDBDate(val);
+}
+function convertDBDateList(val) {
+    return convertList(val, convertDBDate);
+}
+function convertNullableDBDateList(val) {
+    return convertNullableList(val, convertDBDate);
+}
 // these are needed to deal with SQLite having different types stored in the db vs the representation
 // gotten back from the db/needed in ent land
 // see Sqlite.execSync
@@ -53,10 +102,29 @@ function convertNullableBool(val) {
     return convertBool(val);
 }
 function convertList(val, conv) {
+    let res;
     if (Array.isArray(val)) {
-        return val;
+        res = [...val];
+    }
+    else if (val && typeof val === "object") {
+        res = normalizeArrayLikeObject(val);
+    }
+    else {
+        try {
+            res = JSON.parse(val);
+        }
+        catch (err) {
+            if (typeof val === "string" && val.startsWith("{") && val.endsWith("}")) {
+                res = parseTextArray(val);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    if (res && typeof res === "object" && !Array.isArray(res)) {
+        res = normalizeArrayLikeObject(res);
     }
-    let res = JSON.parse(val);
     if (!conv) {
         return res;
     }

package/core/date.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDate = parseDate;
 const luxon_1 = require("luxon");
+function isDateLike(val) {
+    return !!val && typeof val === "object" && typeof val.getTime === "function";
+}
 function parseDate(val, throwErr) {
     let dt;
     if (typeof val === "number") {
@@ -13,8 +16,8 @@ function parseDate(val, throwErr) {
             dt = luxon_1.DateTime.fromMillis(Date.parse(val));
         }
     }
-    else if (val instanceof Date) {
-        dt = luxon_1.DateTime.fromJSDate(val);
+    else if (val instanceof Date || isDateLike(val)) {
+        dt = luxon_1.DateTime.fromJSDate(val instanceof Date ? val : new Date(val.getTime()));
     }
     else if (val instanceof luxon_1.DateTime) {
         dt = val;

package/core/db.d.ts

@@ -1,5 +1,5 @@
 import { Pool, PoolClient, PoolConfig } from "pg";
-import type { RuntimeDBExtension, RuntimeDevSchemaConfig } from "./config";
+import type { PostgresDriver, RuntimeDBExtension, RuntimeDevSchemaConfig, RuntimeMode } from "./config";
 export interface Database extends PoolConfig {
     database?: string;
     user?: string;
@@ -10,6 +10,22 @@ export interface Database extends PoolConfig {
 }
 export type env = "production" | "test" | "development";
 export declare type DBDict = Partial<Record<env, Database>>;
+interface BunSQLResult extends Array<QueryResultRow> {
+    count?: number;
+    affectedRows?: number;
+}
+interface BunSQLClientLike {
+    unsafe(query: string, values?: any[]): Promise<BunSQLResult>;
+}
+interface BunSQLReservedClient extends BunSQLClientLike {
+    release(): void | Promise<void>;
+}
+interface BunSQLPool extends BunSQLClientLike {
+    reserve(): Promise<BunSQLReservedClient>;
+    close(options?: {
+        timeout?: number;
+    }): Promise<void>;
+}
 export declare enum Dialect {
     Postgres = "postgres",
     SQLite = "sqlite"
@@ -17,11 +33,15 @@ export declare enum Dialect {
 interface DatabaseInfo {
     dialect: Dialect;
     config: PoolConfig;
+    runtime?: RuntimeMode;
+    postgresDriver?: PostgresDriver;
     filePath?: string;
     devSchema?: RuntimeDevSchemaConfig;
     extensions?: RuntimeDBExtension[];
 }
 interface clientConfigArgs {
+    runtime?: RuntimeMode;
+    postgresDriver?: PostgresDriver;
     connectionString?: string;
     dbFile?: string;
     db?: Database | DBDict;
@@ -33,7 +53,6 @@ export default class DB {
     db: DatabaseInfo;
     static instance: DB;
     static dialect: Dialect;
-    private pool;
     private q;
     private constructor();
     getConnection(): Connection;
@@ -61,7 +80,7 @@ export interface Connection extends Queryer {
     self(): Queryer;
     newClient(): Promise<Client>;
     close(): Promise<void>;
-    runInTransaction?(cb: () => void | Promise<void>): any;
+    runInTransaction?(cb: () => void | Promise<void>): void | Promise<void>;
 }
 export interface QueryResultRow {
     [column: string]: any;
@@ -138,4 +157,27 @@ export declare class PostgresClient implements Client {
     exec(query: string, values?: any[]): Promise<ExecResult>;
     release(err?: Error | boolean): Promise<void>;
 }
+export declare class BunPostgres implements Connection {
+    private sql;
+    private ready?;
+    private closePromise?;
+    constructor(sql: BunSQLPool, ready?: Promise<void> | undefined);
+    private ensureReady;
+    self(): this;
+    newClient(): Promise<BunPostgresClient>;
+    query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
+    queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
+    exec(query: string, values?: any[]): Promise<ExecResult>;
+    close(): Promise<void>;
+}
+export declare class BunPostgresClient implements Client {
+    private client;
+    private ready?;
+    constructor(client: BunSQLReservedClient, ready?: Promise<void> | undefined);
+    private ensureReady;
+    query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
+    queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
+    exec(query: string, values?: any[]): Promise<ExecResult>;
+    release(err?: Error | boolean): Promise<void>;
+}
 export {};

package/core/db.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresClient = exports.Postgres = exports.Sqlite = exports.defaultTimestampParser = exports.Dialect = void 0;
+exports.BunPostgresClient = exports.BunPostgres = exports.PostgresClient = exports.Postgres = exports.Sqlite = exports.defaultTimestampParser = exports.Dialect = void 0;
 const fs = __importStar(require("fs"));
 const js_yaml_1 = require("js-yaml");
 const luxon_1 = require("luxon");
@@ -41,16 +41,42 @@ const pg_1 = __importStar(require("pg"));
 const logger_1 = require("./logger");
 const dev_schema_1 = require("./dev_schema");
 const extensions_1 = require("./extensions");
+const knownEnvs = ["production", "development", "test"];
+function isEnv(value) {
+    return knownEnvs.includes(value);
+}
 function isDbDict(v) {
-    return (v["production"] !== undefined ||
-        v["development"] !== undefined ||
-        v["test"] !== undefined);
+    return knownEnvs.some((key) => key in v);
 }
 var Dialect;
 (function (Dialect) {
     Dialect["Postgres"] = "postgres";
     Dialect["SQLite"] = "sqlite";
 })(Dialect || (exports.Dialect = Dialect = {}));
+function normalizeRuntimeMode(runtime) {
+    switch (runtime) {
+        case undefined:
+        case "":
+        case "node":
+            return "node";
+        case "bun":
+            return "bun";
+        default:
+            throw new Error(`invalid runtime "${runtime}". valid values: node, bun`);
+    }
+}
+function normalizePostgresDriver(driver) {
+    switch (driver) {
+        case undefined:
+        case "":
+        case "pg":
+            return "pg";
+        case "bun":
+            return "bun";
+        default:
+            throw new Error(`invalid postgresDriver "${driver}". valid values: pg, bun`);
+    }
+}
 function parseConnectionString(str, args) {
     if (str.startsWith("sqlite:///")) {
         let filePath = str.substr(10);
@@ -79,10 +105,15 @@ function parseConnectionString(str, args) {
 // database/config.yml
 function getClientConfig(args) {
     const extensions = (0, extensions_1.resolveExtensions)(args?.extensions);
+    const runtime = normalizeRuntimeMode(args?.runtime ?? process.env.ENT_RUNTIME);
+    const postgresDriver = normalizePostgresDriver(args?.postgresDriver ??
+        process.env.ENT_POSTGRES_DRIVER);
     // if there's a db connection string, use that first
     const str = process.env.DB_CONNECTION_STRING;
     if (str) {
         const info = parseConnectionString(str, args);
+        info.runtime = runtime;
+        info.postgresDriver = postgresDriver;
         info.devSchema = args?.devSchema;
         info.extensions = extensions;
         return info;
@@ -91,6 +122,8 @@ function getClientConfig(args) {
     if (args) {
         if (args.connectionString) {
             const info = parseConnectionString(args.connectionString, args);
+            info.runtime = runtime;
+            info.postgresDriver = postgresDriver;
             info.devSchema = args?.devSchema;
             info.extensions = extensions;
             return info;
@@ -98,10 +131,18 @@ function getClientConfig(args) {
         if (args.db) {
             let db;
             if (isDbDict(args.db)) {
-                if (!process.env.NODE_ENV) {
+                const nodeEnv = process.env.NODE_ENV;
+                if (!nodeEnv) {
                     throw new Error(`process.env.NODE_ENV is undefined`);
                 }
-                db = args.db[process.env.NODE_ENV];
+                if (!isEnv(nodeEnv)) {
+                    throw new Error(`unsupported process.env.NODE_ENV value: ${nodeEnv}`);
+                }
+                const envDB = args.db[nodeEnv];
+                if (!envDB) {
+                    throw new Error(`database config missing for environment ${nodeEnv}`);
+                }
+                db = envDB;
             }
             else {
                 db = args.db;
@@ -109,6 +150,8 @@ function getClientConfig(args) {
             return {
                 dialect: Dialect.Postgres,
                 config: db,
+                runtime,
+                postgresDriver,
                 devSchema: args?.devSchema,
                 extensions,
             };
@@ -139,6 +182,8 @@ function getClientConfig(args) {
                     // max, min, etc
                     ...cfg,
                 },
+                runtime,
+                postgresDriver,
                 devSchema: args?.devSchema,
                 extensions,
             };
@@ -146,10 +191,115 @@ function getClientConfig(args) {
         throw new Error(`invalid yaml configuration in file`);
     }
     catch (e) {
-        console.error("error reading file" + e.message);
+        const message = e instanceof Error ? e.message : String(e);
+        console.error("error reading file" + message);
         return null;
     }
 }
+function getBunSQLConstructor() {
+    const BunRuntime = globalThis.Bun;
+    const SQL = BunRuntime?.SQL;
+    if (!SQL) {
+        throw new Error(`postgresDriver "bun" requires running under Bun`);
+    }
+    return SQL;
+}
+function createBunSQLConfig(config, searchPath) {
+    const cfg = config;
+    const bunConfig = {};
+    if (config.connectionString) {
+        bunConfig.url = config.connectionString;
+    }
+    else {
+        if (cfg.host) {
+            bunConfig.hostname = cfg.host;
+        }
+        if (cfg.port) {
+            bunConfig.port = cfg.port;
+        }
+        if (cfg.database) {
+            bunConfig.database = cfg.database;
+        }
+        if (cfg.user) {
+            bunConfig.username = cfg.user;
+        }
+        if (cfg.password) {
+            bunConfig.password = cfg.password;
+        }
+    }
+    if (typeof config.max === "number") {
+        bunConfig.max = config.max;
+    }
+    if (cfg.sslmode) {
+        bunConfig.tls = cfg.sslmode !== "disable";
+    }
+    else if (config.ssl !== undefined) {
+        bunConfig.tls = config.ssl;
+    }
+    if (searchPath) {
+        bunConfig.onconnect = async (client) => {
+            await client.unsafe("SELECT set_config('search_path', $1, false)", [
+                searchPath,
+            ]);
+        };
+    }
+    return bunConfig;
+}
+function normalizeBunResult(result) {
+    const rows = Array.isArray(result) ? [...result] : [];
+    const rowCount = typeof result?.count === "number"
+        ? result.count
+        : typeof result?.affectedRows === "number"
+            ? result.affectedRows
+            : rows.length;
+    return {
+        rows,
+        rowCount,
+    };
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function serializePostgresArray(values) {
+    return `{${values.map((entry) => serializePostgresArrayElement(entry)).join(",")}}`;
+}
+function serializePostgresArrayElement(value) {
+    if (value === null || value === undefined) {
+        return "NULL";
+    }
+    if (Array.isArray(value)) {
+        return serializePostgresArray(value);
+    }
+    const str = value instanceof Date
+        ? value.toISOString()
+        : isPlainObject(value)
+            ? JSON.stringify(value)
+            : String(value);
+    return `"${str.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function serializeBunValue(value) {
+    if (Array.isArray(value)) {
+        return serializePostgresArray(value);
+    }
+    if (isPlainObject(value)) {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+function serializeBunValues(values) {
+    return values?.map((value) => serializeBunValue(value));
+}
+function createBunQueryable(sql) {
+    return {
+        async query(query, values) {
+            return normalizeBunResult(await sql.unsafe(query, serializeBunValues(values)));
+        },
+    };
+}
 class DB {
     constructor(db) {
         this.db = db;
@@ -163,7 +313,10 @@ class DB {
         const extensions = db.extensions || [];
         if (db.dialect === Dialect.Postgres) {
             const searchPath = (0, extensions_1.buildExtensionSearchPath)(resolvedDevSchema, extensions);
-            if (searchPath) {
+            const postgresDriver = normalizePostgresDriver(db.postgresDriver);
+            db.runtime = normalizeRuntimeMode(db.runtime);
+            db.postgresDriver = postgresDriver;
+            if (postgresDriver === "pg" && searchPath) {
                 const option = `-c search_path=${searchPath}`;
                 db.config = {
                     ...db.config,
@@ -172,23 +325,42 @@ class DB {
                         : option,
                 };
             }
-            this.pool = new pg_1.Pool(db.config);
             const schemaName = resolvedDevSchema.schemaName;
-            const readyTasks = [];
-            if (resolvedDevSchema.enabled && schemaName) {
-                readyTasks.push(validateDevSchema(this.pool, schemaName).then(() => touchDevSchemaRegistry(this.pool, schemaName, resolvedDevSchema.branchName).catch(() => { })));
+            if (postgresDriver === "bun") {
+                const SQL = getBunSQLConstructor();
+                const sql = new SQL(createBunSQLConfig(db.config, searchPath));
+                const queryable = createBunQueryable(sql);
+                const readyTasks = [];
+                if (resolvedDevSchema.enabled && schemaName) {
+                    readyTasks.push(validateDevSchema(queryable, schemaName).then(() => touchDevSchemaRegistry(queryable, schemaName, resolvedDevSchema.branchName).catch(() => { })));
+                }
+                readyTasks.push((0, extensions_1.initializeExtensions)(queryable, extensions, postgresDriver));
+                const ready = readyTasks.length > 0
+                    ? Promise.all(readyTasks).then(() => undefined)
+                    : undefined;
+                if (ready) {
+                    ready.catch(() => { });
+                }
+                this.q = new BunPostgres(sql, ready);
             }
-            readyTasks.push((0, extensions_1.initializeExtensions)(this.pool, extensions));
-            const ready = readyTasks.length > 0
-                ? Promise.all(readyTasks).then(() => undefined)
-                : undefined;
-            if (ready) {
-                ready.catch(() => { });
+            else {
+                const pool = new pg_1.Pool(db.config);
+                const readyTasks = [];
+                if (resolvedDevSchema.enabled && schemaName) {
+                    readyTasks.push(validateDevSchema(pool, schemaName).then(() => touchDevSchemaRegistry(pool, schemaName, resolvedDevSchema.branchName).catch(() => { })));
+                }
+                readyTasks.push((0, extensions_1.initializeExtensions)(pool, extensions, postgresDriver));
+                const ready = readyTasks.length > 0
+                    ? Promise.all(readyTasks).then(() => undefined)
+                    : undefined;
+                if (ready) {
+                    ready.catch(() => { });
+                }
+                this.q = new Postgres(pool, ready);
+                pool.on("error", (err) => {
+                    (0, logger_1.log)("error", err);
+                });
             }
-            this.q = new Postgres(this.pool, ready);
-            this.pool.on("error", (err, client) => {
-                (0, logger_1.log)("error", err);
-            });
         }
         else {
             let sqlite = require("better-sqlite3");
@@ -447,6 +619,71 @@ class PostgresClient {
     }
 }
 exports.PostgresClient = PostgresClient;
+class BunPostgres {
+    constructor(sql, ready) {
+        this.sql = sql;
+        this.ready = ready;
+    }
+    async ensureReady() {
+        if (this.ready) {
+            await this.ready;
+        }
+    }
+    self() {
+        return this;
+    }
+    async newClient() {
+        await this.ensureReady();
+        const client = await this.sql.reserve();
+        return new BunPostgresClient(client, this.ready);
+    }
+    async query(query, values) {
+        await this.ensureReady();
+        return normalizeBunResult(await this.sql.unsafe(query, serializeBunValues(values)));
+    }
+    async queryAll(query, values) {
+        await this.ensureReady();
+        return normalizeBunResult(await this.sql.unsafe(query, serializeBunValues(values)));
+    }
+    async exec(query, values) {
+        await this.ensureReady();
+        return normalizeBunResult(await this.sql.unsafe(query, serializeBunValues(values)));
+    }
+    async close() {
+        if (!this.closePromise) {
+            this.closePromise = this.sql.close();
+        }
+        return this.closePromise;
+    }
+}
+exports.BunPostgres = BunPostgres;
+class BunPostgresClient {
+    constructor(client, ready) {
+        this.client = client;
+        this.ready = ready;
+    }
+    async ensureReady() {
+        if (this.ready) {
+            await this.ready;
+        }
+    }
+    async query(query, values) {
+        await this.ensureReady();
+        return normalizeBunResult(await this.client.unsafe(query, serializeBunValues(values)));
+    }
+    async queryAll(query, values) {
+        await this.ensureReady();
+        return normalizeBunResult(await this.client.unsafe(query, serializeBunValues(values)));
+    }
+    async exec(query, values) {
+        await this.ensureReady();
+        return normalizeBunResult(await this.client.unsafe(query, serializeBunValues(values)));
+    }
+    async release(err) {
+        await this.client.release();
+    }
+}
+exports.BunPostgresClient = BunPostgresClient;
 async function validateDevSchema(pool, schemaName) {
     const res = await pool.query("SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = $1) AS ok", [schemaName]);
     if (!res.rows?.[0]?.ok) {
@@ -465,8 +702,7 @@ async function touchDevSchemaRegistry(pool, schemaName, branchName) {
       `, [schemaName, branch]);
     }
     catch (err) {
-        if (err &&
-            typeof err.message === "string" &&
+        if (err instanceof Error &&
             err.message.includes("ent_dev_schema_registry")) {
             return;
         }