@hazeljs/data 0.2.4 → 0.3.1

package/dist/connectors/postgres.connector.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresSink = exports.PostgresSource = void 0;
+class PostgresSource {
+    constructor(options) {
+        this.pool = null;
+        this.name = options.name ?? `postgres:${options.database}.${options.table}`;
+        this.options = { batchSize: 1000, ...options };
+    }
+    async ensurePool() {
+        if (this.pool)
+            return;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { Pool } = require('pg');
+            this.pool = new Pool({
+                host: this.options.host,
+                port: this.options.port,
+                database: this.options.database,
+                user: this.options.user,
+                password: this.options.password,
+                max: 10,
+                idleTimeoutMillis: 30000,
+                connectionTimeoutMillis: 5000,
+            });
+        }
+        catch (error) {
+            throw new Error(`PostgresSource requires 'pg' package. Install with: npm install pg\nError: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async open() {
+        await this.ensurePool();
+        if (!this.pool)
+            throw new Error('Failed to initialize pool');
+        // Test connection
+        const client = await this.pool.connect();
+        try {
+            await client.query('SELECT 1');
+        }
+        finally {
+            client.release();
+        }
+    }
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    async readAll() {
+        const records = [];
+        for await (const record of this.read()) {
+            records.push(record);
+        }
+        return records;
+    }
+    async *read() {
+        await this.ensurePool();
+        if (!this.pool)
+            throw new Error('Failed to initialize pool');
+        const columns = this.options.columns ? this.options.columns.join(', ') : '*';
+        let query = `SELECT ${columns} FROM ${this.options.table}`;
+        if (this.options.where) {
+            query += ` WHERE ${this.options.where}`;
+        }
+        if (this.options.orderBy) {
+            query += ` ORDER BY ${this.options.orderBy}`;
+        }
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(query);
+            for (const row of result.rows) {
+                yield row;
+            }
+        }
+        finally {
+            client.release();
+        }
+    }
+    /**
+     * Execute a custom SQL query
+     */
+    async query(sql, params) {
+        await this.ensurePool();
+        if (!this.pool)
+            throw new Error('Failed to initialize pool');
+        const client = await this.pool.connect();
+        try {
+            const result = await client.query(sql, params);
+            return result.rows;
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+exports.PostgresSource = PostgresSource;
+/**
+ * PostgreSQL data sink — writes records to a Postgres table.
+ * Supports batch inserts and upserts.
+ *
+ * @example
+ * const sink = new PostgresSink({
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'mydb',
+ *   user: 'user',
+ *   password: 'pass',
+ *   table: 'users',
+ *   columns: ['id', 'name', 'email'],
+ *   conflictColumn: 'id', // for upserts
+ * });
+ * await sink.open();
+ * await sink.writeBatch(records);
+ * await sink.close();
+ */
+class PostgresSink {
+    constructor(options) {
+        this.pool = null;
+        this.buffer = [];
+        this.name = options.name ?? `postgres:${options.database}.${options.table}`;
+        this.options = { batchSize: 100, ...options };
+    }
+    async ensurePool() {
+        if (this.pool)
+            return;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { Pool } = require('pg');
+            this.pool = new Pool({
+                host: this.options.host,
+                port: this.options.port,
+                database: this.options.database,
+                user: this.options.user,
+                password: this.options.password,
+                max: 10,
+                idleTimeoutMillis: 30000,
+                connectionTimeoutMillis: 5000,
+            });
+        }
+        catch (error) {
+            throw new Error(`PostgresSink requires 'pg' package. Install with: npm install pg\nError: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async open() {
+        await this.ensurePool();
+    }
+    async close() {
+        if (this.buffer.length > 0) {
+            await this.flush();
+        }
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    async write(record) {
+        this.buffer.push(record);
+        if (this.buffer.length >= (this.options.batchSize ?? 100)) {
+            await this.flush();
+        }
+    }
+    async writeBatch(records) {
+        this.buffer.push(...records);
+        await this.flush();
+    }
+    async flush() {
+        if (this.buffer.length === 0)
+            return;
+        if (!this.pool)
+            throw new Error('Pool not initialized');
+        const client = await this.pool.connect();
+        try {
+            const columns = this.options.columns;
+            const columnList = columns.join(', ');
+            const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
+            if (this.options.conflictColumn) {
+                // Upsert (INSERT ... ON CONFLICT DO UPDATE)
+                const updates = columns
+                    .filter((c) => c !== this.options.conflictColumn)
+                    .map((c) => `${c} = EXCLUDED.${c}`)
+                    .join(', ');
+                const query = `
+          INSERT INTO ${this.options.table} (${columnList})
+          VALUES (${placeholders})
+          ON CONFLICT (${this.options.conflictColumn})
+          DO UPDATE SET ${updates}
+        `;
+                for (const record of this.buffer) {
+                    const values = columns.map((col) => record[col] ?? null);
+                    await client.query(query, values);
+                }
+            }
+            else {
+                // Plain insert
+                const query = `INSERT INTO ${this.options.table} (${columnList}) VALUES (${placeholders})`;
+                for (const record of this.buffer) {
+                    const values = columns.map((col) => record[col] ?? null);
+                    await client.query(query, values);
+                }
+            }
+        }
+        finally {
+            client.release();
+        }
+        this.buffer = [];
+    }
+    /**
+     * Execute a custom SQL command
+     */
+    async execute(sql, params) {
+        await this.ensurePool();
+        if (!this.pool)
+            throw new Error('Failed to initialize pool');
+        const client = await this.pool.connect();
+        try {
+            await client.query(sql, params);
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+exports.PostgresSink = PostgresSink;

package/dist/contracts/__tests__/contract-registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contract-registry.test.d.ts.map

package/dist/contracts/__tests__/contract-registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-registry.test.d.ts","sourceRoot":"","sources":["../../../src/contracts/__tests__/contract-registry.test.ts"],"names":[],"mappings":""}