@dcl/pg-component 0.1.0

package/README.md

@@ -0,0 +1,173 @@
+# @dcl/pg-component
+
+A PostgreSQL database component that provides connection pooling, transaction management, query streaming, and migration support.
+
+## Installation
+
+```bash
+npm install @dcl/pg-component
+```
+
+## Usage
+
+```typescript
+import { createPgComponent } from '@dcl/pg-component'
+import SQL from 'sql-template-strings'
+
+// Create the component with required dependencies
+const pg = await createPgComponent({ config, logs, metrics })
+
+// Start the component (runs migrations if configured)
+await pg.start()
+
+// Execute queries using sql-template-strings for safe parameterization
+const result = await pg.query<{ id: number; name: string }>(SQL`SELECT * FROM users WHERE id = ${userId}`)
+
+// Stop the component (gracefully drains connections)
+await pg.stop()
+```
+
+## Features
+
+- **Connection pooling**: Efficient connection management using `pg` Pool
+- **SQL injection protection**: Use `sql-template-strings` for safe parameterized queries
+- **Transaction support**: Two transaction APIs for different use cases
+- **Query streaming**: Memory-efficient streaming for large result sets
+- **Migration support**: Built-in support for `node-pg-migrate`
+- **Metrics integration**: Optional query duration metrics
+- **Graceful shutdown**: Drains connections before closing the pool
+
+## Transactions
+
+### Using `withTransaction`
+
+Provides direct access to the transaction client:
+
+```typescript
+await pg.withTransaction(async (client) => {
+  await client.query('INSERT INTO users (name) VALUES ($1)', ['Alice'])
+  await client.query('INSERT INTO audit (action) VALUES ($1)', ['user_created'])
+  // Automatically commits on success, rolls back on error
+})
+```
+
+### Using `withAsyncContextTransaction`
+
+Uses AsyncLocalStorage so nested `query()` calls automatically use the transaction client:
+
+```typescript
+await pg.withAsyncContextTransaction(async () => {
+  // All pg.query() calls within this callback use the same transaction
+  await pg.query(SQL`INSERT INTO users (name) VALUES ('Alice')`)
+  await pg.query(SQL`INSERT INTO audit (action) VALUES ('user_created')`)
+  // Automatically commits on success, rolls back on error
+})
+```
+
+### Important Warnings
+
+#### Do not use transaction control statements with `withAsyncContextTransaction`
+
+When using `withAsyncContextTransaction`, do **not** execute `BEGIN`, `COMMIT`, or `ROLLBACK` via `query()`. The transaction lifecycle is managed automatically:
+
+```typescript
+// ❌ WRONG - Don't do this
+await pg.withAsyncContextTransaction(async () => {
+  await pg.query(SQL`BEGIN`) // Don't do this!
+  await pg.query(SQL`INSERT INTO users (name) VALUES ('Alice')`)
+  await pg.query(SQL`COMMIT`) // Don't do this!
+})
+
+// ✅ CORRECT
+await pg.withAsyncContextTransaction(async () => {
+  await pg.query(SQL`INSERT INTO users (name) VALUES ('Alice')`)
+  // BEGIN/COMMIT/ROLLBACK are handled automatically
+})
+```
+
+#### Nesting transactions creates independent transactions
+
+Calling `withTransaction` or `withAsyncContextTransaction` inside another transaction method will create **independent transactions**, not nested transactions. Each call acquires a new connection from the pool:
+
+```typescript
+// ⚠️ WARNING: This creates TWO independent transactions
+await pg.withAsyncContextTransaction(async () => {
+  await pg.query(SQL`INSERT INTO table1 (name) VALUES ('outer')`)
+
+  // This is a SEPARATE transaction with its own connection!
+  await pg.withTransaction(async (client) => {
+    await client.query(`INSERT INTO table2 (name) VALUES ('inner')`)
+  })
+})
+```
+
+If the inner transaction fails and rolls back, the outer transaction is **not** affected and will still commit. This is because PostgreSQL does not support true nested transactions, and each transaction method acquires its own connection.
+
+## Query Streaming
+
+For large result sets, use `streamQuery` to avoid loading all rows into memory:
+
+```typescript
+for await (const row of pg.streamQuery<User>(SQL`SELECT * FROM large_table`)) {
+  await processRow(row)
+}
+```
+
+## Migrations
+
+Configure migrations when creating the component:
+
+```typescript
+const pg = await createPgComponent(
+  { config, logs },
+  {
+    migration: {
+      migrationsTable: 'pgmigrations',
+      dir: path.join(__dirname, 'migrations'),
+      direction: 'up',
+      count: Infinity
+    }
+  }
+)
+```
+
+## Configuration
+
+Environment variables read by the component:
+
+| Variable                              | Type     | Description                              |
+| ------------------------------------- | -------- | ---------------------------------------- |
+| `PG_COMPONENT_PSQL_CONNECTION_STRING` | `string` | PostgreSQL connection string             |
+| `PG_COMPONENT_PSQL_HOST`              | `string` | Database host                            |
+| `PG_COMPONENT_PSQL_PORT`              | `number` | Database port                            |
+| `PG_COMPONENT_PSQL_DATABASE`          | `string` | Database name                            |
+| `PG_COMPONENT_PSQL_USER`              | `string` | Database user                            |
+| `PG_COMPONENT_PSQL_PASSWORD`          | `string` | Database password                        |
+| `PG_COMPONENT_IDLE_TIMEOUT`           | `number` | Idle connection timeout (ms)             |
+| `PG_COMPONENT_QUERY_TIMEOUT`          | `number` | Query timeout (ms)                       |
+| `PG_COMPONENT_STREAM_QUERY_TIMEOUT`   | `number` | Stream query timeout (ms)                |
+| `PG_COMPONENT_GRACE_PERIODS`          | `number` | Grace periods for shutdown (default: 10) |
+
+## Metrics
+
+When a metrics component is provided, query durations are tracked:
+
+```typescript
+// Pass a label to track query duration
+const result = await pg.query(SQL`SELECT * FROM users`, 'get_users')
+```
+
+Metric: `dcl_db_query_duration_seconds` with labels `query` and `status` (success/error)
+
+## Testing
+
+Tests use [Testcontainers](https://testcontainers.com/) to run against a real PostgreSQL instance:
+
+```bash
+# Requires Docker to be running
+pnpm test
+```
+
+## License
+
+Apache-2.0

package/dist/src/component.d.ts

@@ -0,0 +1,18 @@
+import { IBaseComponent, IConfigComponent, ILoggerComponent } from '@well-known-components/interfaces';
+import { Options, IPgComponent, IMetricsComponent } from './types';
+export * from './types';
+export * from './metrics';
+export declare function runReportingQueryDurationMetric<T>(components: {
+    metrics: IMetricsComponent;
+}, queryNameLabel: string, functionToRun: () => Promise<T>): Promise<T>;
+/**
+ * Query a Postgres (https://www.postgresql.org) database with ease.
+ * It uses a pool behind the scenes and will try to gracefully close it after finishing the connection.
+ * @public
+ */
+export declare function createPgComponent(components: {
+    logs: ILoggerComponent;
+    config: IConfigComponent;
+    metrics?: IMetricsComponent;
+}, options?: Options): Promise<IPgComponent & IBaseComponent>;
+//# sourceMappingURL=component.d.ts.map

package/dist/src/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/component.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AAOtG,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAwC,MAAM,SAAS,CAAA;AAExG,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AAEzB,wBAAsB,+BAA+B,CAAC,CAAC,EACrD,UAAU,EAAE;IAAE,OAAO,EAAE,iBAAiB,CAAA;CAAE,EAC1C,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,CAAC,CAAC,CAcZ;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,OAAO,CAAC,EAAE,iBAAiB,CAAA;CAAE,EAC7F,OAAO,GAAE,OAAY,GACpB,OAAO,CAAC,YAAY,GAAG,cAAc,CAAC,CA0OxC"}

package/dist/src/component.js

@@ -0,0 +1,248 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReportingQueryDurationMetric = runReportingQueryDurationMetric;
+exports.createPgComponent = createPgComponent;
+const async_hooks_1 = require("async_hooks");
+const pg_1 = require("pg");
+const pg_query_stream_1 = __importDefault(require("pg-query-stream"));
+const node_pg_migrate_1 = __importDefault(require("node-pg-migrate"));
+const promises_1 = require("timers/promises");
+__exportStar(require("./types"), exports);
+__exportStar(require("./metrics"), exports);
+async function runReportingQueryDurationMetric(components, queryNameLabel, functionToRun) {
+    const { metrics } = components;
+    const { end: endTimer } = metrics.startTimer('dcl_db_query_duration_seconds', {
+        query: queryNameLabel
+    });
+    try {
+        const res = await functionToRun();
+        endTimer({ status: 'success' });
+        return res;
+    }
+    catch (err) {
+        endTimer({ status: 'error' });
+        throw err;
+    }
+}
+/**
+ * Query a Postgres (https://www.postgresql.org) database with ease.
+ * It uses a pool behind the scenes and will try to gracefully close it after finishing the connection.
+ * @public
+ */
+async function createPgComponent(components, options = {}) {
+    const { config, logs } = components;
+    const logger = logs.getLogger('pg-component');
+    // Environment
+    const [connectionString, port, host, database, user, password, idleTimeoutMillis, query_timeout] = await Promise.all([
+        config.getString('PG_COMPONENT_PSQL_CONNECTION_STRING'),
+        config.getNumber('PG_COMPONENT_PSQL_PORT'),
+        config.getString('PG_COMPONENT_PSQL_HOST'),
+        config.getString('PG_COMPONENT_PSQL_DATABASE'),
+        config.getString('PG_COMPONENT_PSQL_USER'),
+        config.getString('PG_COMPONENT_PSQL_PASSWORD'),
+        config.getNumber('PG_COMPONENT_IDLE_TIMEOUT'),
+        config.getNumber('PG_COMPONENT_QUERY_TIMEOUT')
+    ]);
+    const defaultOptions = {
+        connectionString,
+        port,
+        host,
+        database,
+        user,
+        password,
+        idleTimeoutMillis,
+        query_timeout
+    };
+    const STREAM_QUERY_TIMEOUT = await config.getNumber('PG_COMPONENT_STREAM_QUERY_TIMEOUT');
+    const GRACE_PERIODS = (await config.getNumber('PG_COMPONENT_GRACE_PERIODS')) || 10;
+    const finalOptions = { ...defaultOptions, ...options.pool };
+    if (!finalOptions.log) {
+        finalOptions.log = logger.debug.bind(logger);
+    }
+    // Config
+    const pool = new pg_1.Pool(finalOptions);
+    // Async context for transaction client
+    const transactionContext = new async_hooks_1.AsyncLocalStorage();
+    // Methods
+    async function start() {
+        try {
+            const db = await pool.connect();
+            try {
+                if (options.migration) {
+                    logger.debug('Running migrations:');
+                    const opt = {
+                        ...options.migration,
+                        dbClient: db
+                    };
+                    if (!opt.logger) {
+                        opt.logger = logger;
+                    }
+                    await (0, node_pg_migrate_1.default)(opt);
+                }
+            }
+            catch (err) {
+                logger.error(err);
+                throw err;
+            }
+            finally {
+                db.release();
+            }
+        }
+        catch (error) {
+            logger.warn('Error starting pg-component:');
+            logger.error(error);
+            throw error;
+        }
+    }
+    async function withTransaction(callback) {
+        const client = await pool.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await callback(client);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async function withAsyncContextTransaction(callback) {
+        const client = await pool.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await transactionContext.run(client, callback);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async function defaultQuery(sql) {
+        const notices = [];
+        // Get the transaction's context client or connect a new one
+        const transactionClient = transactionContext.getStore();
+        const client = transactionClient ?? (await pool.connect());
+        function listenNotice(notice) {
+            notices.push(notice);
+        }
+        try {
+            client.on('notice', listenNotice);
+            const result = await client.query(sql);
+            return { ...result, rowCount: result.rowCount ?? 0, notices };
+        }
+        finally {
+            client.off('notice', listenNotice);
+            // Only release if we created a new connection (not from transaction context)
+            if (!transactionClient) {
+                client.release();
+            }
+        }
+    }
+    async function measuredQuery(sql, durationQueryNameLabel) {
+        const result = durationQueryNameLabel
+            ? await runReportingQueryDurationMetric({ metrics: components.metrics }, durationQueryNameLabel, () => defaultQuery(sql))
+            : await defaultQuery(sql);
+        return result;
+    }
+    async function* streamQuery(sql, config) {
+        const client = new pg_1.Client({
+            ...finalOptions,
+            query_timeout: STREAM_QUERY_TIMEOUT
+        });
+        await client.connect();
+        // https://github.com/brianc/node-postgres/issues/1860
+        // Uncaught TypeError: queryCallback is not a function
+        // finish - OK, this call is necessary to finish the query when we configure query_timeout due to a bug in pg
+        // finish - with error, this call is necessary to finish the query when we configure query_timeout due to a bug in pg
+        const stream = new pg_query_stream_1.default(sql.text, sql.values, config);
+        stream.callback = function () {
+            // noop
+        };
+        try {
+            client.query(stream);
+            for await (const row of stream) {
+                yield row;
+            }
+            stream.callback(undefined, undefined);
+        }
+        catch (err) {
+            stream.callback(err, undefined);
+            throw err;
+        }
+        finally {
+            stream.destroy();
+            await client.end();
+        }
+    }
+    let didStop = false;
+    async function stop() {
+        if (didStop) {
+            logger.error('Stop called more than once');
+            return;
+        }
+        didStop = true;
+        let gracePeriods = GRACE_PERIODS;
+        while (gracePeriods > 0 && pool.waitingCount > 0) {
+            logger.debug('Draining connections', {
+                waitingCount: pool.waitingCount,
+                gracePeriods
+            });
+            await (0, promises_1.setTimeout)(200);
+            gracePeriods -= 1;
+        }
+        const promise = pool.end();
+        let finished = false;
+        promise.finally(() => {
+            finished = true;
+        });
+        while (!finished && (pool.totalCount > 0 || pool.idleCount > 0 || pool.waitingCount > 0)) {
+            if (pool.totalCount) {
+                logger.log('Draining connections', {
+                    totalCount: pool.totalCount,
+                    idleCount: pool.idleCount,
+                    waitingCount: pool.waitingCount
+                });
+                await (0, promises_1.setTimeout)(1000);
+            }
+        }
+        await promise;
+    }
+    function getPool() {
+        return pool;
+    }
+    return {
+        query: components.metrics ? measuredQuery : defaultQuery,
+        withTransaction,
+        withAsyncContextTransaction,
+        streamQuery,
+        getPool,
+        start,
+        stop
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './component';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./component"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/metrics.d.ts

@@ -0,0 +1,7 @@
+import { IMetricsComponent } from "@well-known-components/interfaces";
+/**
+ * Metrics declarations, needed for your IMetricsComponent
+ * @public
+ */
+export declare const metricDeclarations: IMetricsComponent.MetricsRecordDefinition<string>;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/src/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAErE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,uBAAuB,CAAC,MAAM,CAMhF,CAAA"}

package/dist/src/metrics.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metricDeclarations = void 0;
+const interfaces_1 = require("@well-known-components/interfaces");
+/**
+ * Metrics declarations, needed for your IMetricsComponent
+ * @public
+ */
+exports.metricDeclarations = {
+    dcl_db_query_duration_seconds: {
+        help: "Histogram of query duration to the database in seconds per query",
+        type: interfaces_1.IMetricsComponent.HistogramType,
+        labelNames: ["query", "status"], // status=(success|error)
+    },
+};

package/dist/src/types.d.ts

@@ -0,0 +1,84 @@
+import { IDatabase, IMetricsComponent as IBaseMetricsComponent } from '@well-known-components/interfaces';
+import { Pool, PoolClient, PoolConfig } from 'pg';
+import { NoticeMessage } from 'pg-protocol/dist/messages';
+import { RunnerOption } from 'node-pg-migrate';
+import { SQLStatement } from 'sql-template-strings';
+import QueryStream from 'pg-query-stream';
+import { metricDeclarations } from './metrics';
+/**
+ * @internal
+ */
+export type QueryStreamWithCallback = QueryStream & {
+    callback: Function;
+};
+/**
+ * @public
+ *
+ * Query result with notices.
+ */
+export type QueryResult<T extends Record<string, any>> = IDatabase.IQueryResult<T> & {
+    notices: NoticeMessage[];
+};
+/**
+ * @public
+ */
+export type Options = Partial<{
+    pool: PoolConfig;
+    migration: Omit<RunnerOption, 'databaseUrl' | 'dbClient'>;
+}>;
+/**
+ * @public
+ */
+export interface IPgComponent extends IDatabase {
+    start(): Promise<void>;
+    query<T extends Record<string, any>>(sql: string): Promise<QueryResult<T>>;
+    query<T extends Record<string, any>>(sql: SQLStatement, durationQueryNameLabel?: string): Promise<QueryResult<T>>;
+    streamQuery<T = any>(sql: SQLStatement, config?: {
+        batchSize?: number;
+    }): AsyncGenerator<T>;
+    /**
+     * Executes a callback within a transaction using a client.
+     * The client is acquired from the pool and released after the callback is executed.
+     * If an error occurs, the transaction is rolled back and the client is released.
+     *
+     * @warning Nesting transaction methods (calling `withTransaction` or `withAsyncContextTransaction`
+     * inside this callback) will create independent transactions, not nested transactions.
+     * Each call acquires a new connection from the pool.
+     */
+    withTransaction<T>(callback: (client: PoolClient) => Promise<T>): Promise<T>;
+    /**
+     * Executes a callback within a transaction using async context.
+     * The client is acquired from the pool and released after the callback is executed.
+     * If an error occurs, the transaction is rolled back and the client is released.
+     * All calls to query() within the callback will automatically use the transaction's client.
+     *
+     * @warning Do not execute transaction control statements (BEGIN, COMMIT, ROLLBACK) via `query()`
+     * within this callback, as the transaction lifecycle is managed automatically.
+     *
+     * @warning Nesting transaction methods (calling `withTransaction` or `withAsyncContextTransaction`
+     * inside this callback) will create independent transactions, not nested transactions.
+     * Each call acquires a new connection from the pool.
+     */
+    withAsyncContextTransaction<T>(callback: () => Promise<T>): Promise<T>;
+    /**
+     * @internal
+     */
+    getPool(): Pool;
+    stop(): Promise<void>;
+}
+/**
+ * @public
+ */
+export declare namespace IPgComponent {
+    /**
+     * @public
+     */
+    type Composable = {
+        pg: IPgComponent;
+    };
+}
+/**
+ * @public
+ */
+export type IMetricsComponent = IBaseMetricsComponent<keyof typeof metricDeclarations>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,IAAI,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AACzG,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,IAAI,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,WAAW,MAAM,iBAAiB,CAAA;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAE9C;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE1E;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG;IACnF,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,GAAG,UAAU,CAAC,CAAA;CAAE,CAAC,CAAA;AAE9G;;GAEG;AACH,MAAM,WAAW,YAAa,SAAQ,SAAS;IAC7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAEtB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;IAC1E,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,sBAAsB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;IACjH,WAAW,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,cAAc,CAAC,CAAC,CAAC,CAAA;IAC3F;;;;;;;;OAQG;IACH,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAC5E;;;;;;;;;;;;OAYG;IACH,2BAA2B,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAEtE;;OAEG;IACH,OAAO,IAAI,IAAI,CAAA;IAEf,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACtB;AAED;;GAEG;AACH,yBAAiB,YAAY,CAAC;IAC5B;;OAEG;IACH,KAAY,UAAU,GAAG;QACvB,EAAE,EAAE,YAAY,CAAA;KACjB,CAAA;CACF;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dcl/pg-component",
+  "version": "0.1.0",
+  "description": "PG component for core components library",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@well-known-components/interfaces": "^1.5.2",
+    "node-pg-migrate": "^7.9.1",
+    "pg": "8.17.2",
+    "pg-protocol": "^1.11.0",
+    "pg-query-stream": "4.11.2",
+    "sql-template-strings": "2.2.2"
+  },
+  "peerDependencies": {
+    "@well-known-components/interfaces": "^1.5.2"
+  },
+  "devDependencies": {
+    "@testcontainers/postgresql": "^10.18.0",
+    "@types/pg": "^8.16.0",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "jest --forceExit",
+    "lint": "echo \"No linting configured\""
+  }
+}