oak-db 3.3.11 → 3.3.12

package/lib/MySQL/connector.d.ts

@@ -1,15 +1,15 @@
-import mysql, { Pool } from 'mysql2/promise';
-import { TxnOption } from 'oak-domain/lib/types';
-import { MySQLConfiguration } from './types/Configuration';
-export declare class MySqlConnector {
-    pool: Pool;
-    configuration: MySQLConfiguration;
-    txnDict: Record<string, mysql.PoolConnection>;
-    constructor(configuration: MySQLConfiguration);
-    connect(): void;
-    disconnect(): Promise<void>;
-    startTransaction(option?: TxnOption): Promise<string>;
-    exec(sql: string, txn?: string): Promise<[mysql.RowDataPacket[] | mysql.RowDataPacket[][] | mysql.OkPacket | mysql.OkPacket[] | mysql.ResultSetHeader, mysql.FieldPacket[]]>;
-    commitTransaction(txn: string): Promise<void>;
-    rollbackTransaction(txn: string): Promise<void>;
-}
+import mysql, { Pool } from 'mysql2/promise';
+import { TxnOption } from 'oak-domain/lib/types';
+import { MySQLConfiguration } from './types/Configuration';
+export declare class MySqlConnector {
+    pool: Pool;
+    configuration: MySQLConfiguration;
+    txnDict: Record<string, mysql.PoolConnection>;
+    constructor(configuration: MySQLConfiguration);
+    connect(): void;
+    disconnect(): Promise<void>;
+    startTransaction(option?: TxnOption): Promise<string>;
+    exec(sql: string, txn?: string): Promise<[mysql.RowDataPacket[] | mysql.RowDataPacket[][] | mysql.OkPacket | mysql.OkPacket[] | mysql.ResultSetHeader, mysql.FieldPacket[]]>;
+    commitTransaction(txn: string): Promise<void>;
+    rollbackTransaction(txn: string): Promise<void>;
+}

package/lib/MySQL/connector.js

@@ -1,77 +1,77 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySqlConnector = void 0;
-const tslib_1 = require("tslib");
-const promise_1 = tslib_1.__importDefault(require("mysql2/promise"));
-const uuid_1 = require("uuid");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-class MySqlConnector {
-    pool;
-    configuration;
-    txnDict;
-    constructor(configuration) {
-        this.configuration = configuration;
-        this.txnDict = {};
-        this.pool = promise_1.default.createPool(this.configuration);
-    }
-    connect() {
-    }
-    disconnect() {
-        return this.pool.end();
-    }
-    async startTransaction(option) {
-        // 防止用户配置connection可复用
-        const startInner = async () => {
-            const connection = await this.pool.getConnection();
-            // 分配出来的connection不能被别的事务占据
-            for (const txn2 in this.txnDict) {
-                if (this.txnDict[txn2] === connection) {
-                    return new Promise((resolve) => {
-                        this.pool.on('release', () => resolve(startInner()));
-                    });
-                }
-            }
-            await connection.beginTransaction();
-            const id = (0, uuid_1.v4)();
-            // console.log('start_txn', id, connection.threadId);
-            this.txnDict[id] = connection;
-            if (option?.isolationLevel) {
-                await connection.query(`SET TRANSACTION ISOLATION LEVEL ${option.isolationLevel};`);
-            }
-            return id;
-        };
-        return startInner();
-    }
-    async exec(sql, txn) {
-        if (process.env.NODE_ENV === 'development') {
-            // console.log(sql);
-        }
-        if (txn) {
-            const connection = this.txnDict[txn];
-            (0, assert_1.default)(connection);
-            const result = await connection.query(sql);
-            return result;
-        }
-        else {
-            const result = await this.pool.query(sql);
-            return result;
-        }
-    }
-    async commitTransaction(txn) {
-        const connection = this.txnDict[txn];
-        (0, assert_1.default)(connection);
-        delete this.txnDict[txn];
-        // console.log('commit_txn', txn, connection.threadId);
-        await connection.commit();
-        connection.release();
-    }
-    async rollbackTransaction(txn) {
-        const connection = this.txnDict[txn];
-        (0, assert_1.default)(connection);
-        // console.log('rollback_txn', txn, connection.threadId);
-        await connection.rollback();
-        delete this.txnDict[txn];
-        connection.release();
-    }
-}
-exports.MySqlConnector = MySqlConnector;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySqlConnector = void 0;
+const tslib_1 = require("tslib");
+const promise_1 = tslib_1.__importDefault(require("mysql2/promise"));
+const uuid_1 = require("uuid");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+class MySqlConnector {
+    pool;
+    configuration;
+    txnDict;
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.txnDict = {};
+        this.pool = promise_1.default.createPool(this.configuration);
+    }
+    connect() {
+    }
+    disconnect() {
+        return this.pool.end();
+    }
+    async startTransaction(option) {
+        // 防止用户配置connection可复用
+        const startInner = async () => {
+            const connection = await this.pool.getConnection();
+            // 分配出来的connection不能被别的事务占据
+            for (const txn2 in this.txnDict) {
+                if (this.txnDict[txn2] === connection) {
+                    return new Promise((resolve) => {
+                        this.pool.on('release', () => resolve(startInner()));
+                    });
+                }
+            }
+            await connection.beginTransaction();
+            const id = (0, uuid_1.v4)();
+            // console.log('start_txn', id, connection.threadId);
+            this.txnDict[id] = connection;
+            if (option?.isolationLevel) {
+                await connection.query(`SET TRANSACTION ISOLATION LEVEL ${option.isolationLevel};`);
+            }
+            return id;
+        };
+        return startInner();
+    }
+    async exec(sql, txn) {
+        if (process.env.NODE_ENV === 'development') {
+            // console.log(`${sql}; \n`);
+        }
+        if (txn) {
+            const connection = this.txnDict[txn];
+            (0, assert_1.default)(connection);
+            const result = await connection.query(sql);
+            return result;
+        }
+        else {
+            const result = await this.pool.query(sql);
+            return result;
+        }
+    }
+    async commitTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection);
+        delete this.txnDict[txn];
+        // console.log('commit_txn', txn, connection.threadId);
+        await connection.commit();
+        connection.release();
+    }
+    async rollbackTransaction(txn) {
+        const connection = this.txnDict[txn];
+        (0, assert_1.default)(connection);
+        // console.log('rollback_txn', txn, connection.threadId);
+        await connection.rollback();
+        delete this.txnDict[txn];
+        connection.release();
+    }
+}
+exports.MySqlConnector = MySqlConnector;

package/lib/MySQL/store.d.ts

@@ -1,37 +1,63 @@
-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 { MySQLConfiguration } from './types/Configuration';
-import { MySqlConnector } from './connector';
-import { MySqlTranslator, MySqlSelectOption, MysqlOperateOption } from './translator';
-import { AsyncContext, AsyncRowStore } from 'oak-domain/lib/store/AsyncRowStore';
-import { SyncContext } from 'oak-domain/lib/store/SyncRowStore';
-import { CreateEntityOption } from '../types/Translator';
-export declare class MysqlStore<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends CascadeStore<ED> implements AsyncRowStore<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: MySqlConnector;
-    translator: MySqlTranslator<ED>;
-    constructor(storageSchema: StorageSchema<ED>, configuration: MySQLConfiguration);
-    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?: MySqlSelectOption): Promise<Partial<ED[T]['Schema']>[]>;
-    protected updateAbjointRowAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, option?: MysqlOperateOption): 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(): void;
-    disconnect(): Promise<void>;
-    initialize(option: CreateEntityOption): Promise<void>;
-}
+import { EntityDict, OperateOption, OperationResult, TxnOption, StorageSchema, SelectOption, AggregationResult, Attribute, Index } 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 { MySQLConfiguration } from './types/Configuration';
+import { MySqlConnector } from './connector';
+import { MySqlTranslator, MySqlSelectOption, MysqlOperateOption } 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 } from '../types/dbStore';
+export declare class MysqlStore<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: MySqlConnector;
+    translator: MySqlTranslator<ED>;
+    constructor(storageSchema: StorageSchema<ED>, configuration: MySQLConfiguration);
+    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?: MySqlSelectOption): Promise<Partial<ED[T]['Schema']>[]>;
+    protected updateAbjointRowAsync<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: AsyncContext<ED>, option?: MysqlOperateOption): 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;
+}
+type Plan = {
+    newTables: Record<string, {
+        attributes: Record<string, Attribute>;
+    }>;
+    newIndexes: Record<string, Index<any>[]>;
+    updatedTables: Record<string, {
+        attributes: Record<string, Attribute & {
+            isNew: boolean;
+        }>;
+    }>;
+    updatedIndexes: Record<string, Index<any>[]>;
+};
+export {};