tlc-claude-code 0.7.5 → 0.7.7

package/server/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/server/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/server/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/server/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/server/node_modules/embedded-postgres/dist/index.js

@@ -0,0 +1,354 @@
+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 = 'en_US.UTF-8';
+// 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,
+};
+/**
+ * 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');
+            // Greedily make the file executable, in case it is not
+            yield fs.chmod(postgres, '755');
+            yield fs.chmod(initdb, '755');
+            // 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: { 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.');
+            });
+            // Greedily make the file executable, in case it is not
+            yield fs.chmod(postgres, '755');
+            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: { 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;