@hexaijs/postgres 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Sangwoo Hyun
+
+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/README.md

@@ -0,0 +1,318 @@
+# @hexaijs/postgres
+
+> PostgreSQL infrastructure for transaction management, event storage, and migrations
+
+## Overview
+
+`@hexaijs/postgres` provides PostgreSQL implementations of the core infrastructure interfaces defined in `@hexaijs/core`. It bridges your domain layer to PostgreSQL with production-ready transaction management.
+
+The package centers around `PostgresUnitOfWork`, which manages database transactions across your command handlers. It uses `AsyncLocalStorage` to maintain transaction context throughout async operations, ensuring all database operations within a handler share the same transaction. If your handler succeeds, the transaction commits automatically. If it throws, the transaction rolls back.
+
+Beyond transactions, the package includes `PostgresEventStore` for storing domain events, a migration runner that integrates with `node-pg-migrate`, and configuration utilities for managing connection settings through environment variables.
+
+## Installation
+
+```bash
+npm install @hexaijs/postgres
+```
+
+**Peer dependencies:**
+
+```bash
+npm install @hexaijs/core @hexaijs/utils pg
+```
+
+## Core Concepts
+
+### PostgresUnitOfWork
+
+The `PostgresUnitOfWork` implements `UnitOfWork` from `@hexaijs/core`. It manages transaction lifecycle and provides access to the database client.
+
+```typescript
+import * as pg from "pg";
+import { PostgresUnitOfWork } from "@hexaijs/postgres";
+
+// Create with a client factory
+const pool = new pg.Pool({ connectionString: "postgres://..." });
+const unitOfWork = new PostgresUnitOfWork(
+    () => new pg.Client({ connectionString: "postgres://..." }),
+    (client) => client.end()  // cleanup function
+);
+
+// Or use a connection pool
+const pooledUnitOfWork = new PostgresUnitOfWork(
+    async () => await pool.connect(),
+    (client) => (client as pg.PoolClient).release()
+);
+```
+
+The client factory creates a new client for each transaction. The optional cleanup function runs after the transaction completes (commit or rollback).
+
+### Transaction Execution
+
+Use `wrap()` to execute operations within a transaction:
+
+```typescript
+import { Propagation } from "@hexaijs/core";
+
+// Execute within a transaction
+const result = await unitOfWork.wrap(async (client) => {
+    await client.query("INSERT INTO orders (id, status) VALUES ($1, $2)", [orderId, "pending"]);
+    await client.query("INSERT INTO order_items (order_id, product_id) VALUES ($1, $2)", [orderId, productId]);
+    return { orderId };
+});
+```
+
+Within a command handler, access the client through `getClient()`:
+
+```typescript
+// Inside a command handler
+const client = ctx.getUnitOfWork().getClient();
+await client.query("UPDATE orders SET status = $1 WHERE id = $2", ["confirmed", orderId]);
+```
+
+### Transaction Propagation
+
+Control how nested operations participate in transactions using `Propagation`:
+
+```typescript
+import { Propagation } from "@hexaijs/core";
+
+// EXISTING (default): Join current transaction, or create new if none exists
+await unitOfWork.wrap(async () => {
+    // This joins the outer transaction
+    await unitOfWork.wrap(async (client) => {
+        // Same transaction as outer
+    }, { propagation: Propagation.EXISTING });
+});
+
+// NEW: Always start a new transaction
+await unitOfWork.wrap(async () => {
+    // This runs in a separate transaction
+    await unitOfWork.wrap(async (client) => {
+        // Independent transaction
+    }, { propagation: Propagation.NEW });
+});
+
+// NESTED: Create a savepoint within the current transaction
+await unitOfWork.wrap(async () => {
+    try {
+        await unitOfWork.wrap(async (client) => {
+            // Runs in a savepoint
+            throw new Error("Rollback this part only");
+        }, { propagation: Propagation.NESTED });
+    } catch {
+        // Savepoint rolled back, outer transaction continues
+    }
+});
+```
+
+### Isolation Levels
+
+Configure transaction isolation levels when stricter guarantees are needed:
+
+```typescript
+import { IsolationLevel } from "@hexaijs/postgres";
+
+await unitOfWork.wrap(async (client) => {
+    // Serializable isolation prevents phantom reads
+    const result = await client.query("SELECT * FROM inventory WHERE product_id = $1", [productId]);
+    // ...
+}, { isolationLevel: IsolationLevel.SERIALIZABLE });
+```
+
+Available levels:
+- `IsolationLevel.READ_UNCOMMITTED`
+- `IsolationLevel.READ_COMMITTED` (PostgreSQL default)
+- `IsolationLevel.REPEATABLE_READ`
+- `IsolationLevel.SERIALIZABLE`
+
+### PostgresEventStore
+
+The `PostgresEventStore` implements `EventStore` from `@hexaijs/core` for storing and retrieving domain events.
+
+```typescript
+import { PostgresEventStore } from "@hexaijs/postgres";
+import { DomainEvent } from "@hexaijs/core";
+
+class OrderPlaced extends DomainEvent<{ orderId: string; customerId: string }> {
+    static readonly type = "order.order-placed";
+}
+
+// Create event store with the transaction client
+const client = unitOfWork.getClient();
+const eventStore = new PostgresEventStore(client);
+
+// Store events
+const stored = await eventStore.store(new OrderPlaced({
+    orderId: "order-123",
+    customerId: "customer-456"
+}));
+console.log(stored.position);  // Event position in the store
+
+// Store multiple events atomically
+const storedEvents = await eventStore.storeAll([event1, event2, event3]);
+
+// Fetch events for replay or projections
+const { events, lastPosition } = await eventStore.fetch(0, 100);
+// events: StoredEvent[] - events after position 0, up to 100
+// lastPosition: number - highest position in store (for catchup detection)
+```
+
+Custom table name:
+
+```typescript
+const eventStore = new PostgresEventStore(client, {
+    tableName: "my_bounded_context_events"
+});
+```
+
+## Usage
+
+### Running Migrations
+
+The package provides a migration runner that supports both SQL and JavaScript migration formats.
+
+```typescript
+import { runMigrations } from "@hexaijs/postgres";
+
+// Run JavaScript migrations (node-pg-migrate format)
+await runMigrations({
+    url: "postgres://user:pass@localhost:5432/mydb",
+    dir: "./migrations",
+});
+
+// With namespace (creates separate migrations table)
+await runMigrations({
+    url: "postgres://user:pass@localhost:5432/mydb",
+    dir: "./migrations/orders",
+    namespace: "orders",  // Table: hexai__migrations_orders
+});
+
+// SQL-based migrations (directories with migration.sql files)
+// migrations/
+//   001_create_orders/
+//     migration.sql
+//   002_add_status/
+//     migration.sql
+await runMigrations({
+    url: dbConfig,
+    dir: "./migrations",
+});
+```
+
+Run built-in hexai migrations (creates the event store table):
+
+```typescript
+import { runHexaiMigrations } from "@hexaijs/postgres";
+
+await runHexaiMigrations("postgres://user:pass@localhost:5432/mydb");
+```
+
+### Configuration
+
+`PostgresConfig` provides immutable configuration management:
+
+```typescript
+import { PostgresConfig } from "@hexaijs/postgres";
+
+// From connection URL
+const config = PostgresConfig.fromUrl("postgres://user:pass@localhost:5432/mydb");
+
+// From environment variables
+// URL mode: reads MY_DB_URL
+const config = PostgresConfig.fromEnv("MY_DB");
+
+// Fields mode: reads MY_DB_HOST, MY_DB_PORT, MY_DB_DATABASE, MY_DB_USER, MY_DB_PASSWORD
+const config = PostgresConfig.fromEnv("MY_DB", { mode: "fields" });
+
+// Builder pattern for modifications (returns new instance)
+const testConfig = config
+    .withDatabase("mydb_test")
+    .withPoolSize(5);
+
+// Use as connection string
+new pg.Client({ connectionString: config.toString() });
+```
+
+With `defineConfig` from `@hexaijs/utils`:
+
+```typescript
+import { defineConfig } from "@hexaijs/utils/config";
+import { postgresConfig } from "@hexaijs/postgres";
+
+const getConfig = defineConfig({
+    db: postgresConfig("ORDER_DB"),           // reads ORDER_DB_URL
+    readReplica: postgresConfig("REPLICA_DB", "fields"),  // reads individual fields
+});
+
+const config = getConfig();
+config.db.host;        // "localhost"
+config.db.toString();  // "postgres://..."
+```
+
+### Database Utilities
+
+Helper classes for database management and testing:
+
+```typescript
+import { DatabaseManager, TableManager, ensureConnection } from "@hexaijs/postgres";
+
+// Create/drop databases
+const dbManager = new DatabaseManager("postgres://user:pass@localhost:5432/postgres");
+await dbManager.createDatabase("my_new_db");
+await dbManager.dropDatabase("my_old_db");
+await dbManager.close();
+
+// Table operations
+const tableManager = new TableManager(client);
+await tableManager.tableExists("orders");
+await tableManager.truncateTable("orders");
+await tableManager.dropAllTables();
+
+// Ensure client is connected
+await ensureConnection(client);  // Safe to call multiple times
+```
+
+### Test Fixtures
+
+The package exports test utilities from `@hexaijs/postgres/test`:
+
+```typescript
+import { useDatabase, useClient, useTableManager } from "@hexaijs/postgres/test";
+
+describe("OrderRepository", () => {
+    // Creates database before tests, drops after
+    const dbUrl = useDatabase("order_test_db");
+
+    // Provides connected client
+    const client = useClient("order_test_db");
+
+    it("should persist orders", async () => {
+        // Use client for assertions
+        const result = await client.query("SELECT * FROM orders");
+        expect(result.rows).toHaveLength(1);
+    });
+});
+```
+
+## API Highlights
+
+| Export | Description |
+|--------|-------------|
+| `PostgresUnitOfWork` | Transaction management with `AsyncLocalStorage` context |
+| `PostgresEventStore` | Event store implementation with batch insert support |
+| `PostgresConfig` | Immutable configuration with builder pattern |
+| `postgresConfig` | Config spec for `defineConfig` integration |
+| `runMigrations` | Migration runner for SQL and JS migrations |
+| `runHexaiMigrations` | Runs built-in hexai migrations |
+| `DatabaseManager` | Create/drop databases |
+| `TableManager` | Table operations (truncate, drop, schema info) |
+| `IsolationLevel` | Transaction isolation level enum |
+| `ensureConnection` | Safe connection helper |
+
+## See Also
+
+- [@hexaijs/core](../core/README.md) - Core interfaces (`UnitOfWork`, `EventStore`, `Propagation`)
+- [@hexaijs/sqlite](../sqlite/README.md) - SQLite implementation for testing
+- [@hexaijs/application](../application/README.md) - Application context that provides `getUnitOfWork()`

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./postgres-config";
+export * from "./postgres-config-spec";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC"}

package/dist/config/index.js

@@ -0,0 +1,19 @@
+"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("./postgres-config"), exports);
+__exportStar(require("./postgres-config-spec"), exports);
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,yDAAuC"}

package/dist/config/postgres-config-spec.d.ts

@@ -0,0 +1,32 @@
+import type { ConfigSpec } from "@hexaijs/utils/config";
+import { PostgresConfig, type FromEnvOptions } from "./postgres-config";
+export declare class PostgresConfigSpec implements ConfigSpec<PostgresConfig> {
+    private readonly prefix;
+    private readonly mode;
+    readonly _type = "postgres";
+    constructor(prefix: string, mode?: FromEnvOptions["mode"]);
+    resolve(errors: string[]): PostgresConfig | undefined;
+}
+/**
+ * PostgreSQL database configuration from environment variables.
+ * Returns a PostgresConfig instance.
+ *
+ * @param prefix - Environment variable prefix
+ * @param mode - "url" reads {PREFIX}_URL, "fields" reads individual fields
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig, env } from "@hexaijs/core";
+ * import { postgresConfig } from "@hexaijs/postgres";
+ *
+ * const getConfig = defineConfig({
+ *     db: postgresConfig("ORDER_DB"),           // reads ORDER_DB_URL
+ *     db2: postgresConfig("PG", "fields"),      // reads PG_HOST, PG_PORT, etc.
+ * });
+ *
+ * getConfig().db.host;        // "localhost"
+ * getConfig().db.toString();  // "postgres://..."
+ * ```
+ */
+export declare function postgresConfig(prefix: string, mode?: FromEnvOptions["mode"]): PostgresConfigSpec;
+//# sourceMappingURL=postgres-config-spec.d.ts.map

package/dist/config/postgres-config-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-config-spec.d.ts","sourceRoot":"","sources":["../../src/config/postgres-config-spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExE,qBAAa,kBAAmB,YAAW,UAAU,CAAC,cAAc,CAAC;IAI7D,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJzB,QAAQ,CAAC,KAAK,cAAc;gBAGP,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,cAAc,CAAC,MAAM,CAAS;IAGzD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,cAAc,GAAG,SAAS;CAQxD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAC1B,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,cAAc,CAAC,MAAM,CAAS,GACrC,kBAAkB,CAEpB"}

package/dist/config/postgres-config-spec.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresConfigSpec = void 0;
+exports.postgresConfig = postgresConfig;
+const postgres_config_1 = require("./postgres-config");
+class PostgresConfigSpec {
+    prefix;
+    mode;
+    _type = "postgres";
+    constructor(prefix, mode = "url") {
+        this.prefix = prefix;
+        this.mode = mode;
+    }
+    resolve(errors) {
+        try {
+            return postgres_config_1.PostgresConfig.fromEnv(this.prefix, { mode: this.mode });
+        }
+        catch (e) {
+            errors.push(e.message);
+            return undefined;
+        }
+    }
+}
+exports.PostgresConfigSpec = PostgresConfigSpec;
+/**
+ * PostgreSQL database configuration from environment variables.
+ * Returns a PostgresConfig instance.
+ *
+ * @param prefix - Environment variable prefix
+ * @param mode - "url" reads {PREFIX}_URL, "fields" reads individual fields
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig, env } from "@hexaijs/core";
+ * import { postgresConfig } from "@hexaijs/postgres";
+ *
+ * const getConfig = defineConfig({
+ *     db: postgresConfig("ORDER_DB"),           // reads ORDER_DB_URL
+ *     db2: postgresConfig("PG", "fields"),      // reads PG_HOST, PG_PORT, etc.
+ * });
+ *
+ * getConfig().db.host;        // "localhost"
+ * getConfig().db.toString();  // "postgres://..."
+ * ```
+ */
+function postgresConfig(prefix, mode = "url") {
+    return new PostgresConfigSpec(prefix, mode);
+}
+//# sourceMappingURL=postgres-config-spec.js.map

package/dist/config/postgres-config-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-config-spec.js","sourceRoot":"","sources":["../../src/config/postgres-config-spec.ts"],"names":[],"mappings":";;;AA0CA,wCAKC;AA9CD,uDAAwE;AAExE,MAAa,kBAAkB;IAIN;IACA;IAJZ,KAAK,GAAG,UAAU,CAAC;IAE5B,YACqB,MAAc,EACd,OAA+B,KAAK;QADpC,WAAM,GAAN,MAAM,CAAQ;QACd,SAAI,GAAJ,IAAI,CAAgC;IACtD,CAAC;IAEJ,OAAO,CAAC,MAAgB;QACpB,IAAI,CAAC;YACD,OAAO,gCAAc,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACpE,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,MAAM,CAAC,IAAI,CAAE,CAAW,CAAC,OAAO,CAAC,CAAC;YAClC,OAAO,SAAS,CAAC;QACrB,CAAC;IACL,CAAC;CACJ;AAhBD,gDAgBC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,cAAc,CAC1B,MAAc,EACd,OAA+B,KAAK;IAEpC,OAAO,IAAI,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAChD,CAAC"}

package/dist/config/postgres-config.d.ts

@@ -0,0 +1,59 @@
+import type { DatabaseConfig } from "@hexaijs/utils/config";
+export interface PoolOptions {
+    size?: number;
+    connectionTimeout?: number;
+    idleTimeout?: number;
+}
+export interface FromEnvOptions {
+    /**
+     * Environment variable loading mode.
+     * - "url": Load from {PREFIX}_URL (default)
+     * - "fields": Load from {PREFIX}_HOST, {PREFIX}_PORT, {PREFIX}_DATABASE, {PREFIX}_USER, {PREFIX}_PASSWORD
+     */
+    mode?: "url" | "fields";
+}
+export declare class PostgresConfig implements DatabaseConfig {
+    readonly host: string;
+    readonly database: string;
+    readonly user: string;
+    readonly port: number;
+    readonly password?: string;
+    readonly pool?: PoolOptions;
+    constructor(config: {
+        database: string;
+        user?: string;
+        host?: string;
+        port?: number;
+        password?: string;
+        pool?: PoolOptions;
+    });
+    static fromUrl(value: string): PostgresConfig;
+    /**
+     * Creates a PostgresConfig from environment variables.
+     *
+     * @param prefix - Environment variable prefix
+     * @param options - Loading options (mode: "url" | "fields")
+     * @throws Error if required environment variables are not set
+     *
+     * @example
+     * ```typescript
+     * // URL mode (default): reads ASSIGNMENT_DB_URL
+     * const config = PostgresConfig.fromEnv("ASSIGNMENT_DB");
+     *
+     * // Fields mode: reads POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DATABASE, POSTGRES_USER, POSTGRES_PASSWORD
+     * const config = PostgresConfig.fromEnv("POSTGRES", { mode: "fields" });
+     * ```
+     */
+    static fromEnv(prefix: string, options?: FromEnvOptions): PostgresConfig;
+    private static parseUrl;
+    withDatabase(database: string): PostgresConfig;
+    withUser(user: string): PostgresConfig;
+    withPassword(password: string): PostgresConfig;
+    withHost(host: string): PostgresConfig;
+    withPort(port: number): PostgresConfig;
+    withPoolSize(size: number): PostgresConfig;
+    withConnectionTimeout(connectionTimeout: number): PostgresConfig;
+    withIdleTimeout(idleTimeout: number): PostgresConfig;
+    toString(): string;
+}
+//# sourceMappingURL=postgres-config.d.ts.map

package/dist/config/postgres-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-config.d.ts","sourceRoot":"","sources":["../../src/config/postgres-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,WAAW;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC3B;;;;OAIG;IACH,IAAI,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC;CAC3B;AAED,qBAAa,cAAe,YAAW,cAAc;IACjD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClC,SAAgB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEvB,MAAM,EAAE;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,WAAW,CAAC;KACtB;WASa,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc;IAIpD;;;;;;;;;;;;;;;OAeG;WACW,OAAO,CACjB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,cAAc,GACzB,cAAc;IAiCjB,OAAO,CAAC,MAAM,CAAC,QAAQ;IAqBhB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc;IAW9C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;IAWtC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc;IAW9C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;IAWtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;IAWtC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;IAW1C,qBAAqB,CAAC,iBAAiB,EAAE,MAAM,GAAG,cAAc;IAWhE,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc;IAWpD,QAAQ,IAAI,MAAM;CA2B5B"}