@tickernelz/paperclip-pro-db 2026.925.0

package/node_modules/embedded-postgres/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2022 Lei Nelissen
+
+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/embedded-postgres/README.md

@@ -0,0 +1,191 @@
+![Embedded
+Postgres](https://github.com/leinelissen/embedded-postgres/raw/main/docs/images/embedded-postgres-header.svg)
+
+<div align="center">
+
+![npm](https://img.shields.io/npm/v/embedded-postgres)
+![npm type definitions](https://img.shields.io/npm/types/embedded-postgres)
+![npm](https://img.shields.io/npm/dy/embedded-postgres)
+![NPM](https://img.shields.io/npm/l/embedded-postgres)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/leinelissen/embedded-postgres/test.yml)
+
+
+</div>
+
+<h3 align="center">
+    🐘 A Node package that spawns PostgresQL clusters programatically.
+</h3>
+
+## Installation
+`embedded-postgres` is available from NPM:
+
+```sh
+npm i embedded-postgres
+```
+
+<br />
+
+## Usage
+This package contains a simple API that allows you to create clusters, start
+them, create / delete database and stop any existing processes.
+
+```ts
+import EmbeddedPostgres from 'embedded-postgres';
+
+async function main() {
+    // Create the object
+    const pg = new EmbeddedPostgres({
+        databaseDir: './data/db',
+        user: 'postgres',
+        password: 'password',
+        port: 5432,
+        persistent: true,
+    });
+
+    // Create the cluster config files
+    await pg.initialise();
+
+    // Start the server
+    await pg.start();
+
+    // Create and/or drop database
+    await pg.createDatabase('TEST');
+    await pg.dropDatabase('TEST');
+
+    // Initialize a node-postgres client
+    const client = pg.getPgClient();
+    await client.connect();
+    const result = await client.query('SELECT datname FROM pg_database');
+
+    // Stop the server
+    await pg.stop();
+}
+
+main();
+```
+
+<br />
+
+## PostgresQL Versions
+This package aims to track the [PostgresQL support
+policy](https://www.postgresql.org/support/versioning/) for supported versions.
+Additionally, we track the binaries that are created upstream in [zonky's
+embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres). This
+leads to the following current support matrix:
+
+| Platform / Architecture   | 12.20.0 | 13.16.0 | 14.13.0 | 15.8.0 | 16.4.0 | 17.0.0 |
+|---------------------------|---------|---------|---------|--------|--------|--------|
+| 🍎 Darwin / x64           | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 🍎 Darwin / arm64[[1]](https://github.com/zonkyio/embedded-postgres/issues/86#issuecomment-1120425822) | 🚫 | 🚫 | 🚫 | ✅ | ✅ | ✅ |
+| 🪟 Windows / x64          | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 🐧 Linux / x64            | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 🐧 Linux / arm            | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 🐧 Linux / arm64          | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 🐧 Linux / ia32           | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 🐧 Linux / ppc64          | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+
+In order to install a particular version, look for the latest tag in
+[NPM](https://www.npmjs.com/package/embedded-postgres). For example, if you
+would like to install `v10.20.0`, you can currently use the following tag:
+```sh
+npm i embedded-postgres@10.20.0-beta.6
+```
+
+Installing particular versions of PostgresQL (i.e. versions not released on NPM)
+is currently not possible. If you would have a need for doing so, please create
+an issue.
+
+<br />
+
+## API
+Options in the constructor can be used to modify the behaviour of the
+application. The parameters that are available as part of the options can be
+seen here:
+
+| Property | Type | Description |
+|---|---|---|
+| databaseDir | string | The location where the data should be persisted to. Defaults to `./data/db` |
+| port | number | The port where the Postgres database should be listening. Defaults to:  `5432` |
+| user | string | The username for logging into the Postgres database. Defaults to `postgres` |
+| password | string | The password for logging into the Postgres database. Defaults to `password` |
+| authMethod | 'scram-sha-256' \| 'password' \| 'md5' | The authentication method to use when authenticating against Postgres. Defaults to `password`  |
+| persistent | boolean | Whether all data should be left in place when the database is shut down. Defaults to `true`. |
+| initdbFlags | string[] | 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 `[]` 
+| postgresFlags | 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 `[]`.  |
+| createPostgresUser | boolean | 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. <br />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`. |
+| onLog | (message \| string) => void | 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` |
+| onError | (messageOrError \| string \| Error \| unknown) => 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` |
+
+<br />
+
+## Contributing
+This package is open to issues, feedback, ideas and pull requests. Create an
+issue on this repository to get started! In order to get started with
+development, you might need some extra pointers
+
+### Development
+In order to get yourself situated for development, you will need to the
+repository up and running. In order to make this work, start with a relatively
+recent install of NodeJS (at least v18, v20+ recommended). You can then run this
+command to install all packages:
+```
+npm install --force
+```
+
+> [!NOTE]
+> You must include `--force` or else NPM will refuse to install the
+> dependencies for all packages, including those not for the current architecture.
+
+Then, you must pre-compile all Typescript using the following command:
+```
+npm run build
+```
+
+As soon as that is complete, we'll download the requisite PostgresQL binaries
+for your particular architecture using:
+```
+npm run download
+```
+
+Lastly, you can hop over to `packages/embedded-postgres` and do some development
+there:
+```
+cd packages/embedded-postgres
+```
+
+You can force automatic recompliation of the Typescript files by running:
+```
+npm start
+```
+
+Don't forget to add and run tests when you are developing new functionality. Add
+them to `tests/index.test.ts`, and run the tests by running:
+```
+npm test
+```
+
+<br />
+
+## Troubleshotting
+
+### Running in Docker containers
+Running in Docker containers might fail, because many are setup to run with the
+root user as default. Either you resolve to setting up a container with a
+specific user yourself, or you set the `createPostgresUser` option to true,
+after which embedded-postgres will automatically set up a postgres user on the
+system for usage by your script.
+
+<br />
+
+## Credits and Licensing
+Embedded Postgres was created by Lei Nelissen for [BMD
+Studio](https://bmd.studio). It is based on [zonky's
+embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres). The
+binaries are made available under the Apache License 2.0, whereas the specific
+code in this package is made available under the MIT license.
+
+<a href="https://bmd.studio">
+    <img src="https://github.com/leinelissen/embedded-postgres/raw/main/docs/images/logo-bmd.svg" alt="BMD Studio" width="150" height="150" />
+</a>
+
+<br />

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

@@ -0,0 +1,7 @@
+export declare type PostgresBinaries = {
+    postgres: string;
+    pg_ctl: string;
+    initdb: string;
+};
+declare function getBinaries(): Promise<PostgresBinaries>;
+export default getBinaries;

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

@@ -0,0 +1,41 @@
+import os from 'os';
+function getBinaries() {
+    const arch = os.arch();
+    const platform = os.platform();
+    switch (platform) {
+        case 'darwin':
+            switch (arch) {
+                case 'arm64':
+                    return import('@embedded-postgres/darwin-arm64');
+                case 'x64':
+                    return import('@embedded-postgres/darwin-x64');
+                default:
+                    throw new Error(`Unsupported arch "${arch}" for platform "${platform}"`);
+            }
+        case 'linux':
+            switch (arch) {
+                case 'arm64':
+                    return import('@embedded-postgres/linux-arm64');
+                case 'arm':
+                    return import('@embedded-postgres/linux-arm');
+                case 'ia32':
+                    return import('@embedded-postgres/linux-ia32');
+                case 'ppc64':
+                    return import('@embedded-postgres/linux-ppc64');
+                case 'x64':
+                    return import('@embedded-postgres/linux-x64');
+                default:
+                    throw new Error(`Unsupported arch "${arch}" for platform "${platform}"`);
+            }
+        case 'win32':
+            switch (arch) {
+                case 'x64':
+                    return import('@embedded-postgres/windows-x64');
+                default:
+                    throw new Error(`Unsupported arch "${arch}" for platform "${platform}"`);
+            }
+        default:
+            throw new Error(`Unsupported platform "${platform}"`);
+    }
+}
+export default getBinaries;

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

@@ -0,0 +1,58 @@
+import pg from 'pg';
+import { PostgresOptions } from './types.js';
+/**
+ * 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.
+ */
+declare class EmbeddedPostgres {
+    protected options: PostgresOptions;
+    private process?;
+    private isRootUser;
+    constructor(options?: Partial<PostgresOptions>);
+    /**
+     * 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(): Promise<void>;
+    /**
+     * 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(): Promise<void>;
+    /**
+     * 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(): Promise<void>;
+    /**
+     * 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?: string, host?: string): pg.Client;
+    /**
+     * Create a database with a given name on the cluster
+     */
+    createDatabase(name: string): Promise<void>;
+    /**
+     * Drop a database with a given name on the cluster
+     */
+    dropDatabase(name: string): Promise<void>;
+    /**
+     * Warn the user in case they're trying to run this library as a root user
+     */
+    private checkForRootUser;
+    /**
+     * Retrieve the uid and gid for a particular user
+     */
+    private getUidAndGid;
+}
+export default EmbeddedPostgres;

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;