oak-db 3.3.11 → 3.3.13

package/lib/PostgreSQL/connector.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLConnector = void 0;
+const tslib_1 = require("tslib");
+const pg_1 = require("pg");
+const uuid_1 = require("uuid");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+class PostgreSQLConnector {
+    pool;
+    configuration;
+    txnDict;
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.txnDict = {};
+        this.pool = new pg_1.Pool(configuration);
+        // 错误处理
+        this.pool.on('error', (err) => {
+            console.error('PostgreSQL pool error:', err);
+        });
+    }
+    connect() {
+        // pg Pool 是惰性连接，不需要显式连接
+        // 但可以在这里进行连接测试
+    }
+    async disconnect() {
+        // 先获取所有事务ID的快照
+        const txnIds = Object.keys(this.txnDict);
+        for (const txnId of txnIds) {
+            try {
+                await this.rollbackTransaction(txnId);
+            }
+            catch (e) {
+                console.error(`Failed to rollback transaction ${txnId}:`, e);
+            }
+        }
+        await this.pool.end();
+    }
+    async startTransaction(option) {
+        const startInner = async () => {
+            const connection = await this.pool.connect();
+            // 添加：检测连接是否已被其他事务占用
+            for (const txn2 in this.txnDict) {
+                if (this.txnDict[txn2] === connection) {
+                    return new Promise((resolve) => {
+                        this.pool.on('release', () => resolve(startInner()));
+                    });
+                }
+            }
+            try {
+                let beginStmt = 'BEGIN';
+                if (option?.isolationLevel) {
+                    // PostgreSQL 隔离级别: 
+                    // READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE
+                    // 注意: PostgreSQL 的 READ UNCOMMITTED 行为等同于 READ COMMITTED
+                    const level = this.mapIsolationLevel(option.isolationLevel);
+                    beginStmt = `BEGIN ISOLATION LEVEL ${level}`;
+                }
+                await connection.query(beginStmt);
+                const id = (0, uuid_1.v4)();
+                this.txnDict[id] = connection;
+                return id;
+            }
+            catch (error) {
+                // 如果启动事务失败，释放连接
+                connection.release();
+                throw error;
+            }
+        };
+        return startInner();
+    }
+    /**
+     * 映射隔离级别到 PostgreSQL 语法
+     */
+    mapIsolationLevel(level) {
+        const levelUpper = level.toUpperCase().replace(/[-_]/g, ' '); // 同时处理 - 和 _
+        const validLevels = [
+            'READ UNCOMMITTED',
+            'READ COMMITTED',
+            'REPEATABLE READ',
+            'SERIALIZABLE'
+        ];
+        if (validLevels.includes(levelUpper)) {
+            return levelUpper;
+        }
+        // 默认使用 READ COMMITTED
+        console.warn(`Unknown isolation level "${level}", using READ COMMITTED`);
+        return 'READ COMMITTED';
+    }
+    async exec(sql, txn) {
+        if (process.env.NODE_ENV === 'development') {
+            // console.log(`SQL: ${sql}; \n`);
+        }
+        try {
+            let result;
+            if (txn) {
+                const connection = this.txnDict[txn];
+                (0, assert_1.default)(connection, `Transaction ${txn} not found`);
+                result = await connection.query(sql);
+            }
+            else {
+                result = await this.pool.query(sql);
+            }
+            // 返回格式与 mysql2 兼容: [rows, fields/result]
+            return [result.rows, result];
+        }
+        catch (error) {
+            // 增强错误信息
+            const enhancedError = new Error(`PostgreSQL query failed: ${error.message}\nSQL: ${sql.slice(0, 500)}${sql.length > 500 ? '...' : ''}`);
+            enhancedError.originalError = error;
+            enhancedError.sql = sql;
+            throw enhancedError;
+        }
+    }
+    async commitTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection, `Transaction ${txn} not found`);
+        try {
+            await connection.query('COMMIT');
+        }
+        finally {
+            delete this.txnDict[txn];
+            connection.release();
+        }
+    }
+    async rollbackTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection, `Transaction ${txn} not found`);
+        try {
+            await connection.query('ROLLBACK');
+        }
+        finally {
+            delete this.txnDict[txn];
+            connection.release();
+        }
+    }
+    /**
+     * 获取连接池状态
+     */
+    getPoolStatus() {
+        return {
+            total: this.pool.totalCount,
+            idle: this.pool.idleCount,
+            waiting: this.pool.waitingCount
+        };
+    }
+}
+exports.PostgreSQLConnector = PostgreSQLConnector;

package/lib/PostgreSQL/store.d.ts

@@ -0,0 +1,50 @@
+import { EntityDict, OperateOption, OperationResult, TxnOption, StorageSchema, SelectOption, AggregationResult } from 'oak-domain/lib/types';
+import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
+import { CascadeStore } from 'oak-domain/lib/store/CascadeStore';
+import { PostgreSQLConfiguration } from './types/Configuration';
+import { PostgreSQLConnector } from './connector';
+import { PostgreSQLTranslator, PostgreSQLSelectOption, PostgreSQLOperateOption } from './translator';
+import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
+import { SyncContext } from 'oak-domain/lib/store/SyncRowStore';
+import { CreateEntityOption } from '../types/Translator';
+import { DbStore, Plan } from '../types/dbStore';
+export declare class PostgreSQLStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends CascadeStore<ED> implements DbStore<ED, Cxt> {
+    protected countAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
+    protected aggregateAbjointRowSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
+    protected selectAbjointRow<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: SyncContext<ED>, option: OP): Partial<ED[T]['Schema']>[];
+    protected updateAbjointRow<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: SyncContext<ED>, option: OP): number;
+    exec(script: string, txnId?: string): Promise<void>;
+    connector: PostgreSQLConnector;
+    translator: PostgreSQLTranslator<ED>;
+    constructor(storageSchema: StorageSchema<ED>, configuration: PostgreSQLConfiguration);
+    checkRelationAsync<T extends keyof ED, Cxt extends AsyncContext<ED>>(entity: T, operation: Omit<ED[T]['Operation'] | ED[T]['Selection'], 'id'>, context: Cxt): Promise<void>;
+    protected aggregateAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    protected supportManyToOneJoin(): boolean;
+    protected supportMultipleCreate(): boolean;
+    private formResult;
+    protected selectAbjointRowAsync<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: AsyncContext<ED>, option?: PostgreSQLSelectOption): Promise<Partial<ED[T]['Schema']>[]>;
+    protected updateAbjointRowAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, option?: PostgreSQLOperateOption): Promise<number>;
+    operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OperateOption): Promise<OperationResult<ED>>;
+    select<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: SelectOption): Promise<Partial<ED[T]['Schema']>[]>;
+    protected countAbjointRowAsync<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: AsyncContext<ED>, option: SelectOption): Promise<number>;
+    count<T extends keyof ED>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: SelectOption): Promise<number>;
+    begin(option?: TxnOption): Promise<string>;
+    commit(txnId: string): Promise<void>;
+    rollback(txnId: string): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    initialize(option: CreateEntityOption): Promise<void>;
+    readSchema(): Promise<StorageSchema<ED>>;
+    /**
+     * 根据载入的dataSchema，和数据库中原来的schema，决定如何来upgrade
+     * 制订出来的plan分为两阶段：增加阶段和削减阶段，在两个阶段之间，由用户来修正数据
+     */
+    makeUpgradePlan(): Promise<Plan>;
+    /**
+     * 比较两个schema的不同，这里计算的是new对old的增量
+     * @param schemaOld
+     * @param schemaNew
+     */
+    diffSchema(schemaOld: StorageSchema<any>, schemaNew: StorageSchema<any>): Plan;
+}