@tickernelz/wardmote-db 0.0.0 → 2026.1108.1

package/node_modules/embedded-postgres/dist/index.js

@@ -0,0 +1,366 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import { platform, tmpdir, userInfo } from 'os';
+import { spawn, exec } from 'child_process';
+import pg from 'pg';
+import AsyncExitHook from 'async-exit-hook';
+import getBinaries from './binary.js';
+const bin = getBinaries();
+const { Client } = pg;
+/**
+ * We have to specify the LC_MESSAGES locale because we rely on inspecting the
+ * output of the `initdb` command to see if Postgres is ready. As we're looking
+ * for a particular string, we need to force that string into the right locale.
+ * @see https://github.com/leinelissen/embedded-postgres/issues/15
+ */
+const LC_MESSAGES_LOCALE = 'C';
+// The default configuration options for the class
+const defaults = {
+    databaseDir: path.join(process.cwd(), 'data', 'db'),
+    port: 5432,
+    user: 'postgres',
+    password: 'password',
+    authMethod: 'password',
+    persistent: true,
+    initdbFlags: [],
+    postgresFlags: [],
+    createPostgresUser: false,
+    onLog: console.log,
+    onError: console.error,
+};
+// Fixes the mode of files that are supposed to be executable
+//                        r-xr-xr-x
+const BIN_PERMISSIONS = 0b101101101;
+const ensureBinIsExecutable = (filePath) => __awaiter(void 0, void 0, void 0, function* () {
+    // Only fix the file's mode if it's missing a permission. This is useful
+    // when the binaries are in a read-only file system, as a call to chmod
+    // (even unnecessary) would cause a crash.
+    const stat = yield fs.stat(filePath);
+    if ((stat.mode & BIN_PERMISSIONS) !== BIN_PERMISSIONS) {
+        yield fs.chmod(filePath, stat.mode | BIN_PERMISSIONS);
+    }
+});
+/**
+ * This will track instances of all current initialised clusters. We need this
+ * because we want to be able to shutdown any clusters when the script is exited.
+ */
+const instances = new Set();
+/**
+ * This class creates an instance from which a single Postgres cluster is
+ * managed. Note that many clusters may be created, but they will need seperate
+ * data directories in order to be properly lifecycle managed.
+ */
+class EmbeddedPostgres {
+    constructor(options = {}) {
+        // Options were previously specified in snake_case rather than
+        // camelCase. We still want to accept the old style of options.
+        const legacyOptions = {};
+        if (options.database_dir) {
+            legacyOptions.databaseDir = options.database_dir;
+        }
+        if (options.auth_method) {
+            legacyOptions.authMethod = options.auth_method;
+        }
+        // Assign default options to options object
+        this.options = Object.assign({}, defaults, legacyOptions, options);
+        instances.add(this);
+        this.isRootUser = userInfo().uid === 0;
+    }
+    /**
+     * This function needs to be called whenever a Postgres cluster first needs
+     * to be created. It will populate the data directory with the right
+     * settings. If your Postgres cluster is already initialised, you don't need
+     * to call this function again.
+     */
+    initialise() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { postgres, initdb } = yield bin;
+            // GUARD: Check that a postgres user is available 
+            yield this.checkForRootUser();
+            // Optionally retrieve the uid and gid
+            let permissionIds = yield this.getUidAndGid()
+                .catch(() => ({}));
+            // GUARD: Check if we need to create users
+            if (this.options.createPostgresUser
+                && !('uid' in permissionIds)
+                && !('gid' in permissionIds)) {
+                try {
+                    // Create the group and user
+                    yield execAsync('groupadd postgres');
+                    yield execAsync('useradd -g postgres postgres');
+                    // Re-treieve the permission ids now the user exists
+                    permissionIds = yield this.getUidAndGid();
+                }
+                catch (err) {
+                    this.options.onError(err);
+                    throw new Error('Failed to create and initialize a new user on this system.');
+                }
+            }
+            // GUARD: Ensure that the data directory is owned by the created user
+            if (this.options.createPostgresUser) {
+                if (!('uid' in permissionIds)) {
+                    throw new Error('Failed to retrieve the uid for the newly created user.');
+                }
+                // Create the data directory and have the user own it, so we
+                // don't get any permission errors
+                yield fs.mkdir(this.options.databaseDir, { recursive: true });
+                yield fs.chown(this.options.databaseDir, permissionIds.uid, permissionIds.gid);
+            }
+            // Create a file on disk that contains the password in plaintext
+            const randomId = crypto.randomBytes(6).readUIntLE(0, 6).toString(36);
+            const passwordFile = path.resolve(tmpdir(), `pg-password-${randomId}`);
+            yield fs.writeFile(passwordFile, this.options.password + '\n');
+            // Make the files executable, in case they are not
+            ensureBinIsExecutable(postgres);
+            ensureBinIsExecutable(initdb);
+            // Initialize the database
+            yield new Promise((resolve, reject) => {
+                var _a;
+                const process = spawn(initdb, [
+                    `--pgdata=${this.options.databaseDir}`,
+                    `--auth=${this.options.authMethod}`,
+                    `--username=${this.options.user}`,
+                    `--pwfile=${passwordFile}`,
+                    `--lc-messages=${LC_MESSAGES_LOCALE}`,
+                    ...this.options.initdbFlags,
+                ], Object.assign(Object.assign({}, permissionIds), { env: Object.assign(Object.assign({}, globalThis.process.env), { LC_MESSAGES: LC_MESSAGES_LOCALE }) }));
+                // Connect to stderr, as that is where the messages get sent
+                (_a = process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+                    // Parse the data as a string and log it
+                    const message = chunk.toString('utf-8');
+                    this.options.onLog(message);
+                });
+                process.on('exit', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(`Postgres init script exited with code ${code}. Please check the logs for extra info. The data directory might already exist.`);
+                    }
+                });
+            });
+            // Clean up the file
+            yield fs.unlink(passwordFile);
+        });
+    }
+    /**
+     * Start the Postgres cluster with the given configuration. The cluster is
+     * started as a seperate process, unmanaged by NodeJS. It is automatically
+     * shut down when the script exits.
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { postgres } = yield bin;
+            // Optionally retrieve the uid and gid
+            const permissionIds = yield this.getUidAndGid()
+                .catch(() => {
+                throw new Error('Postgres cannot run as a root user. embedded-postgres could not find a postgres user to run as instead. Consider using the `createPostgresUser` option.');
+            });
+            // Make the file executable, in case it is not
+            ensureBinIsExecutable(postgres);
+            yield new Promise((resolve, reject) => {
+                var _a;
+                // Spawn a postgres server
+                this.process = spawn(postgres, [
+                    '-D',
+                    this.options.databaseDir,
+                    '-p',
+                    this.options.port.toString(),
+                    ...this.options.postgresFlags,
+                ], Object.assign(Object.assign({}, permissionIds), { env: Object.assign(Object.assign({}, globalThis.process.env), { LC_MESSAGES: LC_MESSAGES_LOCALE }) }));
+                // Connect to stderr, as that is where the messages get sent
+                (_a = this.process.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+                    // Parse the data as a string and log it
+                    const message = chunk.toString('utf-8');
+                    this.options.onLog(message);
+                    // GUARD: Check for the right message to determine server start
+                    if (message.includes('database system is ready to accept connections')) {
+                        resolve();
+                    }
+                });
+                // In case the process exits early, the promise is rejected.
+                this.process.on('close', () => {
+                    reject();
+                });
+            });
+        });
+    }
+    /**
+     * Stop an already started cluster with the given configuration.
+     * NOTE: If you have `persisent` set to false, this method WILL DELETE your
+     * database files. You will need to call `.initialise()` again after executing
+     * this method.
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // GUARD: If no database is running, immdiately return the function.
+            if (!this.process) {
+                return;
+            }
+            // Kill the existing postgres process
+            yield new Promise((resolve) => {
+                var _a, _b, _c;
+                // Register a handler for when the process finally exists
+                (_a = this.process) === null || _a === void 0 ? void 0 : _a.on('exit', resolve);
+                // GUARD: Check if we're on Windows, since Windows doesn't support SIGINT
+                if (platform() === 'win32') {
+                    // GUARD: Double check the pid is there to keep TypeScript happy
+                    if (!((_b = this.process) === null || _b === void 0 ? void 0 : _b.pid)) {
+                        throw new Error('Could not find process PID');
+                    }
+                    // Actually kill the process using the Windows taskkill command
+                    spawn('taskkill', ['/pid', this.process.pid.toString(), '/f', '/t']);
+                }
+                else {
+                    // If on a sane OS, simply kill using SIGINT
+                    (_c = this.process) === null || _c === void 0 ? void 0 : _c.kill('SIGINT');
+                }
+            });
+            // Clean up process
+            this.process = undefined;
+            // GUARD: Additional work if database is not persistent
+            if (this.options.persistent === false) {
+                // Delete the data directory
+                yield fs.rm(this.options.databaseDir, { recursive: true, force: true });
+            }
+        });
+    }
+    /**
+     * Create a node-postgres client using the existing cluster configuration.
+     *
+     * @param database The database that the postgres client should connect to
+     * @param host The host that should be pre-filled in the connection options
+     * @returns Client
+     */
+    getPgClient(database = 'postgres', host = 'localhost') {
+        // Create client
+        const client = new Client({
+            user: this.options.user,
+            password: this.options.password,
+            port: this.options.port,
+            host,
+            database,
+        });
+        // Log errors rather than throwing them so that embedded-postgres has
+        // enough time to actually shutdown.
+        client.on('error', this.options.onError);
+        return client;
+    }
+    /**
+     * Create a database with a given name on the cluster
+     */
+    createDatabase(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // GUARD: Cluster must be running for performing database operations
+            if (!this.process) {
+                throw new Error('Your cluster must be running before you can create a database');
+            }
+            // Get client and execute CREATE DATABASE query
+            const client = this.getPgClient();
+            yield client.connect();
+            yield client.query(`CREATE DATABASE ${client.escapeIdentifier(name)}`);
+            // Clean up client
+            yield client.end();
+        });
+    }
+    /**
+     * Drop a database with a given name on the cluster
+     */
+    dropDatabase(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // GUARD: Cluster must be running for performing database operations
+            if (!this.process) {
+                throw new Error('Your cluster must be running before you can create a database');
+            }
+            // Get client and execute DROP DATABASE query
+            const client = this.getPgClient();
+            yield client.connect();
+            yield client.query(`DROP DATABASE ${client.escapeIdentifier(name)}`);
+            // Clean up client
+            yield client.end();
+        });
+    }
+    /**
+     * Warn the user in case they're trying to run this library as a root user
+     */
+    checkForRootUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // GUARD: Ensure that the user isn't root
+            if (!this.isRootUser) {
+                return;
+            }
+            // Attempt to retrieve the uid and gid for the postgres user. This check
+            // will throw and error when the postgres user doesn't exist
+            try {
+                yield this.getUidAndGid();
+            }
+            catch (err) {
+                // GUARD: No user exists, but check that a postgres user should be created
+                if (!this.options.createPostgresUser) {
+                    throw new Error('You are running this script as root. Postgres does not support running as root. If you wish to continue, configure embedded-postgres to create a Postgres user by setting the `createPostgresUser` option to true.');
+                }
+            }
+        });
+    }
+    /**
+     * Retrieve the uid and gid for a particular user
+     */
+    getUidAndGid(name = 'postgres') {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isRootUser) {
+                return {};
+            }
+            const [uid, gid] = yield Promise.all([
+                execAsync(`id -u ${name}`).then(Number.parseInt),
+                execAsync(`id -g ${name}`).then(Number.parseInt),
+            ]);
+            return { uid, gid };
+        });
+    }
+}
+/**
+ * A promisified version of the exec API that either throws on errors or returns
+ * the string results from the executed command.
+ */
+function execAsync(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            exec(command, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout);
+                }
+            });
+        });
+    });
+}
+/**
+ * This script should be called when a Node script is exited, so that we can
+ * nicely shutdown all potentially started clusters, and we don't end up with
+ * zombie processes.
+ */
+function gracefulShutdown(done) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Loop through all instances, stop them, and await the response
+        yield Promise.all([...instances].map((instance) => {
+            return instance.stop();
+        }));
+        // Let NodeJS know we're done
+        done();
+    });
+}
+// Register graceful shutdown function
+AsyncExitHook(gracefulShutdown);
+export default EmbeddedPostgres;

package/node_modules/embedded-postgres/dist/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The options that are optionally specified for launching the Postgres database.
+ */
+export interface PostgresOptions {
+    /** The location where the data should be persisted to. Defaults to: `./data/db` */
+    databaseDir: string;
+    /** The port where the Postgres database should be listening. Defaults to:
+     *  `5432` */
+    port: number;
+    /** The username for logging into the Postgres database. Defaults to `postgres` */
+    user: string;
+    /** The password for logging into the Postgres database. Defaults to `password` */
+    password: string;
+    /** The authentication method to use when authenticating against Postgres.
+     * Defaults to `password`  */
+    authMethod: 'scram-sha-256' | 'password' | 'md5';
+    /** Whether all data should be left in place when the database is shut down.
+     * Defaults to `true`. */
+    persistent: boolean;
+    /** Pass any additional flags to the initdb process. You can find all
+     * available flags here:
+     * https://www.postgresql.org/docs/current/app-initdb.html. Flags should be
+     * passed as a string array, e.g. `["--debug"]` or `["--locale=en-GB"]`
+     *
+     * Defaults to `[]`
+     */
+    initdbFlags: string[];
+    /** Pass any additional flags to the postgres process. You can find all
+     * available flags here:
+     * https://www.postgresql.org/docs/current/app-postgres.html. Flags should
+     * be passed as a string array, e.g. `["--debug"]` or `["--locale=en-GB"]`.
+     *
+     * Defaults to `[]`.  */
+    postgresFlags: string[];
+    /**
+     * Postgres does not allow binaries to be run by root. In case you're
+     * running in root-only enviroments, such as Docker containers, you may need
+     * to create an extra user on your system in order to be able to call the binaries.
+     *
+     * NOTE: This WILL irreversibly modify your host system. The effects are
+     * somewhat minor, but it's still recommend to only use this in Docker containers.
+     *
+     * Defaults to `false`.
+     */
+    createPostgresUser: boolean;
+    /** Pass in a custom logging handler. This will relay and console messages
+     * that are generated by the postgres and initdb processes. Defaults to
+     * `console.log` */
+    onLog: (message: string) => void;
+    /** Pass in a custom error logging handler. This will catch and stderr
+     * results coming in from the postgres and initdb processes. Defaults to
+     * `console.error` */
+    onError: (messageOrError: string | Error | unknown) => void;
+}

package/node_modules/embedded-postgres/dist/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/embedded-postgres/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "embedded-postgres",
+  "version": "18.1.0-beta.16",
+  "description": "A package to run an embedded Postgresql database right from NodeJS",
+  "exports": "./dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leinelissen/embedded-postgres"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "tsc -w",
+    "build": "tsc",
+    "lint": "eslint ./src --ext ts",
+    "docs": "typedoc --plugin typedoc-plugin-markdown ./src/types.ts --theme markdown --excludePrivate",
+    "test": "vitest"
+  },
+  "keywords": [
+    "postgres",
+    "postgresql",
+    "database",
+    "embedded"
+  ],
+  "author": "Lei Nelissen",
+  "license": "MIT",
+  "devDependencies": {
+    "@embedded-postgres/symlink-reader": "^18.1.0-beta.16",
+    "@types/async-exit-hook": "^2.0.0",
+    "@types/pg": "^8.6.5",
+    "eslint": "^8.56.0",
+    "typescript": "^4.7.3",
+    "vitest": "^1.1.0"
+  },
+  "optionalDependencies": {
+    "@embedded-postgres/darwin-arm64": "^18.1.0-beta.16",
+    "@embedded-postgres/darwin-x64": "^18.1.0-beta.16",
+    "@embedded-postgres/linux-arm": "^18.1.0-beta.16",
+    "@embedded-postgres/linux-arm64": "^18.1.0-beta.16",
+    "@embedded-postgres/linux-ia32": "^18.1.0-beta.16",
+    "@embedded-postgres/linux-ppc64": "^18.1.0-beta.16",
+    "@embedded-postgres/linux-x64": "^18.1.0-beta.16",
+    "@embedded-postgres/windows-x64": "^18.1.0-beta.16"
+  },
+  "dependencies": {
+    "async-exit-hook": "^2.0.1",
+    "pg": "^8.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "/dist/**/*",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "gitHead": "9a1e52f4ac4d92bf24976f635020374342fd0838"
+}

package/node_modules/pg/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010 - 2021 Brian Carlson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/pg/README.md

@@ -0,0 +1,96 @@
+# node-postgres
+
+[![Build Status](https://secure.travis-ci.org/brianc/node-postgres.svg?branch=master)](http://travis-ci.org/brianc/node-postgres)
+<span class="badge-npmversion"><a href="https://npmjs.org/package/pg" title="View this project on NPM"><img src="https://img.shields.io/npm/v/pg.svg" alt="NPM version" /></a></span>
+<span class="badge-npmdownloads"><a href="https://npmjs.org/package/pg" title="View this project on NPM"><img src="https://img.shields.io/npm/dm/pg.svg" alt="NPM downloads" /></a></span>
+
+Non-blocking PostgreSQL client for Node.js. Pure JavaScript and optional native libpq bindings.
+
+## Install
+
+```sh
+$ npm install pg
+```
+
+---
+
+## :star: [Documentation](https://node-postgres.com) :star:
+
+### Features
+
+- [Fastest PostgreSQL client for Node.js](https://github.com/nigrosimone/postgres-benchmarks)
+- Pure JavaScript client and native libpq bindings share _the same API_
+- Connection pooling
+- Extensible JS ↔ PostgreSQL data-type coercion
+- Supported PostgreSQL features
+  - Parameterized queries
+  - Named statements with query plan caching
+  - Async notifications with `LISTEN/NOTIFY`
+  - Bulk import & export with `COPY TO/COPY FROM`
+
+### Extras
+
+node-postgres is by design pretty light on abstractions. These are some handy modules we've been using over the years to complete the picture.
+The entire list can be found on our [wiki](https://github.com/brianc/node-postgres/wiki/Extras).
+
+## Support
+
+node-postgres is free software. If you encounter a bug with the library please open an issue on the [GitHub repo](https://github.com/brianc/node-postgres). If you have questions unanswered by the documentation please open an issue pointing out how the documentation was unclear & I will do my best to make it better!
+
+When you open an issue please provide:
+
+- version of Node
+- version of Postgres
+- smallest possible snippet of code to reproduce the problem
+
+You can also follow me [@brianc](https://bsky.app/profile/brianc.bsky.social) on bluesky if that's your thing for updates on node-postgres with nearly zero non node-postgres content. My old twitter/x account is no longer used.
+
+## Sponsorship :two_hearts:
+
+node-postgres's continued development has been made possible in part by generous financial support from [the community](https://github.com/brianc/node-postgres/blob/master/SPONSORS.md).
+
+If you or your company are benefiting from node-postgres and would like to help keep the project financially sustainable [please consider supporting](https://github.com/sponsors/brianc) its development.
+
+### Featured sponsor
+
+Special thanks to [medplum](https://medplum.com) for their generous and thoughtful support of node-postgres!
+
+![medplum](https://raw.githubusercontent.com/medplum/medplum-logo/refs/heads/main/medplum-logo.png)
+
+## Contributing
+
+**:heart: contributions!**
+
+I will **happily** accept your pull request if it:
+
+- **has tests**
+- looks reasonable
+- does not break backwards compatibility
+
+If your change involves breaking backwards compatibility please please point that out in the pull request & we can discuss & plan when and how to release it and what type of documentation or communicate it will require.
+
+## Troubleshooting and FAQ
+
+The causes and solutions to common errors can be found among the [Frequently Asked Questions (FAQ)](https://github.com/brianc/node-postgres/wiki/FAQ)
+
+## License
+
+Copyright (c) 2010-2020 Brian Carlson (brian.m.carlson@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/pg/esm/index.mjs

@@ -0,0 +1,20 @@
+// ESM wrapper for pg
+import pg from '../lib/index.js'
+
+// Re-export all the properties
+export const Client = pg.Client
+export const Pool = pg.Pool
+export const Connection = pg.Connection
+export const types = pg.types
+export const Query = pg.Query
+export const DatabaseError = pg.DatabaseError
+export const escapeIdentifier = pg.escapeIdentifier
+export const escapeLiteral = pg.escapeLiteral
+export const Result = pg.Result
+export const TypeOverrides = pg.TypeOverrides
+
+// Also export the defaults
+export const defaults = pg.defaults
+
+// Re-export the default
+export default pg