node-firebird-driver 3.2.2 → 3.3.0

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "node-firebird-driver",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "description": "Firebird Driver Interfaces for Node.js",
   "main": "dist/lib/index.js",
   "scripts": {
-    "build": "yarn run clean && yarn run lint && tsc --build",
+    "build": "yarn run clean && yarn run lint:check && tsc --build",
     "build:w": "tsc --build -w",
     "clean": "tsc --build --clean && rimraf dist",
-    "lint": "tslint --project .",
+    "lint:check": "eslint",
+    "lint:fix": "eslint --fix",
     "prepublishOnly": "yarn run build"
   },
   "repository": {
@@ -29,7 +30,7 @@
   "homepage": "https://github.com/asfernandes/node-firebird-drivers#readme",
   "typings": "./dist/lib/index.d.ts",
   "dependencies": {
-    "@types/node": "^22.7.5"
+    "@types/node": "^22.13.10"
   },
-  "gitHead": "20e22c67b13e0d5ddf6667aa005d65949f5961db"
+  "gitHead": "b5e16b7a239c6a8eee91de6576ee8edb4815ab53"
 }

package/src/lib/impl/attachment.ts

@@ -6,261 +6,298 @@ import { AbstractTransaction } from './transaction';
 import { AbstractEvents } from './events';
 
 import {
-	Attachment,
-	Blob,
-	CreateBlobOptions,
-	ExecuteOptions,
-	ExecuteQueryOptions,
-	Events,
-	FetchOptions,
-	PrepareOptions,
-	TransactionOptions
+  Attachment,
+  Blob,
+  CreateBlobOptions,
+  ExecuteOptions,
+  ExecuteQueryOptions,
+  Events,
+  FetchOptions,
+  PrepareOptions,
+  TransactionOptions,
 } from '..';
 
-
 /** AbstractAttachment implementation. */
 export abstract class AbstractAttachment implements Attachment {
-	events = new Set<Events>();
-	statements = new Set<AbstractStatement>();
-	transactions = new Set<AbstractTransaction>();
-
-	/** Default transaction options. */
-	defaultTransactionOptions: TransactionOptions;
-
-	/** Default query's prepare options. */
-	defaultPrepareOptions: PrepareOptions;
-
-	/** Default query's execute options. */
-	defaultExecuteOptions: ExecuteOptions;
-
-	/** Default query's executeQuery options. */
-	defaultExecuteQueryOptions: ExecuteQueryOptions;
-
-	/** Default result set's fetch options. */
-	defaultFetchOptions: FetchOptions;
-
-	protected constructor(public client?: AbstractClient) {
-	}
-
-	/** Disconnects this attachment. */
-	async disconnect(): Promise<void> {
-		this.check();
-
-		await this.preDispose();
-		await this.internalDisconnect();
-		await this.postDispose();
-	}
-
-	/** Drops the database and release this attachment. */
-	async dropDatabase(): Promise<void> {
-		this.check();
-
-		await this.preDispose();
-		await this.internalDropDatabase();
-		await this.postDispose();
-	}
-
-	/** Enable/disable cancellation of operations in this attachment. */
-	async enableCancellation(enable: boolean): Promise<void> {
-		this.check();
-		await this.internalEnableCancellation(enable);
-	}
-
-	/** Cancel a running operation in this attachment. */
-	async cancelOperation(forcibleAbort?: boolean): Promise<void> {
-		this.check();
-		await this.internalCancelOperation(forcibleAbort ?? false);
-	}
-
-	/** Executes a statement that uses the SET TRANSACTION command. Returns the new transaction. */
-	async executeTransaction(transaction: AbstractTransaction, sqlStmt: string,
-			options?: {
-				prepareOptions?: PrepareOptions
-			}): Promise<AbstractTransaction> {
-		this.check();
-
-		const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
-		try {
-			const newTransaction = await statement.executeTransaction(transaction);
-			this.transactions.add(newTransaction);
-			return newTransaction;
-		}
-		finally {
-			await statement.dispose();
-		}
-	}
-
-	/** Executes a statement that has no result set. */
-	async execute(transaction: AbstractTransaction, sqlStmt: string, parameters?: any[],
-			options?: {
-				prepareOptions?: PrepareOptions,
-				executeOptions?: ExecuteOptions
-			}): Promise<void> {
-		this.check();
-
-		const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
-		try {
-			return await statement.execute(transaction, parameters, options && options.executeOptions);
-		}
-		finally {
-			await statement.dispose();
-		}
-	}
-
-	/** Executes a statement that returns a single record. */
-	async executeSingleton(transaction: AbstractTransaction, sqlStmt: string, parameters?: Array<any>,
-			options?: {
-				prepareOptions?: PrepareOptions,
-				executeOptions?: ExecuteOptions
-			}): Promise<Array<any>> {
-		this.check();
-
-		const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
-		try {
-			return await statement.executeSingleton(transaction, parameters, options && options.executeOptions);
-		}
-		finally {
-			await statement.dispose();
-		}
-	}
-
-	/** Executes a statement that returns a single record in object form. */
-	async executeSingletonAsObject<T extends object>(transaction: AbstractTransaction, sqlStmt: string, parameters?: any[],
-			options?: {
-				prepareOptions?: PrepareOptions,
-				executeOptions?: ExecuteOptions
-			}): Promise<T> {
-		this.check();
-
-		const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
-		try {
-			return await statement.executeSingletonAsObject(transaction, parameters, options && options.executeOptions);
-		}
-		finally {
-			await statement.dispose();
-		}
-	}
-
-	/** Executes a statement that returns a single record. */
-	async executeReturning(transaction: AbstractTransaction, sqlStmt: string, parameters?: Array<any>,
-			options?: {
-				prepareOptions?: PrepareOptions,
-				executeOptions?: ExecuteOptions
-			}): Promise<Array<any>> {
-		return await this.executeSingleton(transaction, sqlStmt, parameters, options);
-	}
-
-	/** Executes a statement that returns a single record in object form. */
-	async executeReturningAsObject<T extends object>(transaction: AbstractTransaction, sqlStmt: string, parameters?: any[],
-			options?: {
-				prepareOptions?: PrepareOptions,
-				executeOptions?: ExecuteOptions
-			}): Promise<T> {
-		return await this.executeSingletonAsObject<T>(transaction, sqlStmt, parameters, options);
-	}
-
-	/** Executes a statement that has result set. */
-	async executeQuery(transaction: AbstractTransaction, sqlStmt: string, parameters?: any[],
-			options?: {
-				prepareOptions?: PrepareOptions,
-				executeOptions?: ExecuteQueryOptions
-			}): Promise<AbstractResultSet> {
-		this.check();
-
-		const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
-		try {
-			const resultSet = await statement.executeQuery(transaction, parameters, options && options.executeOptions);
-			resultSet.diposeStatementOnClose = true;
-			return resultSet;
-		}
-		catch (e) {
-			await statement.dispose();
-			throw e;
-		}
-	}
-
-	async queueEvents(names: string[], callBack: (counters: [string, number][]) => Promise<void>): Promise<Events> {
-		this.check();
-
-		const trimmedNames = names.map(name => {
-			const trimmedName = name.trimRight();
-
-			if (Buffer.from(trimmedName).byteLength > 255)
-				throw new Error(`Invalid event name: ${name}.`);
-
-			return trimmedName;
-		});
-
-		const events = await this.internalQueueEvents(trimmedNames, callBack);
-		this.events.add(events);
-
-		return events;
-	}
-
-	async createBlob(transaction: AbstractTransaction, options?: CreateBlobOptions): Promise<AbstractBlobStream> {
-		return await this.internalCreateBlob(transaction, options);
-	}
-
-	async openBlob(transaction: AbstractTransaction, blob: Blob): Promise<AbstractBlobStream> {
-		return await this.internalOpenBlob(transaction, blob);
-	}
-
-	/** Starts a new transaction. */
-	async startTransaction(options?: TransactionOptions): Promise<AbstractTransaction> {
-		this.check();
-
-		const transaction = await this.internalStartTransaction(
-			options || this.defaultTransactionOptions || this.client!.defaultTransactionOptions);
-		this.transactions.add(transaction);
-		return transaction;
-	}
-
-	/** Prepares a query. */
-	async prepare(transaction: AbstractTransaction, sqlStmt: string, options?: PrepareOptions): Promise<AbstractStatement> {
-		this.check();
-
-		const statement = await this.internalPrepare(transaction, sqlStmt,
-			options || this.defaultPrepareOptions || this.client!.defaultPrepareOptions);
-		this.statements.add(statement);
-		return statement;
-	}
-
-	get isValid(): boolean {
-		return !!this.client;
-	}
-
-	private check() {
-		if (!this.isValid)
-			throw new Error('Attachment is already disconnected.');
-	}
-
-	private async preDispose() {
-		try {
-			await Promise.all(Array.from(this.events).map(events => events.cancel()));
-			await Promise.all(Array.from(this.statements).map(statement => statement.dispose()));
-			await Promise.all(Array.from(this.transactions).map(transaction => transaction.rollback()));
-		}
-		finally {
-			this.events.clear();
-			this.statements.clear();
-			this.transactions.clear();
-		}
-	}
-
-	private async postDispose() {
-		this.client!.attachments.delete(this);
-		this.client = undefined;
-	}
-
-	protected abstract internalDisconnect(): Promise<void>;
-	protected abstract internalDropDatabase(): Promise<void>;
-	protected abstract internalEnableCancellation(enable: boolean): Promise<void>;
-	protected abstract internalCancelOperation(forcibleAbort: boolean): Promise<void>;
-	protected abstract internalCreateBlob(transaction: AbstractTransaction, options?: CreateBlobOptions): Promise<AbstractBlobStream>;
-	protected abstract internalOpenBlob(transaction: AbstractTransaction, blob: Blob): Promise<AbstractBlobStream>;
-	protected abstract internalPrepare(transaction: AbstractTransaction, sqlStmt: string, options?: PrepareOptions):
-		Promise<AbstractStatement>;
-	protected abstract internalStartTransaction(options?: TransactionOptions): Promise<AbstractTransaction>;
-	protected abstract internalQueueEvents(names: string[], callBack: (counters: [string, number][]) => Promise<void>):
-		Promise<AbstractEvents>;
+  events = new Set<Events>();
+  statements = new Set<AbstractStatement>();
+  transactions = new Set<AbstractTransaction>();
+
+  /** Default transaction options. */
+  defaultTransactionOptions: TransactionOptions;
+
+  /** Default query's prepare options. */
+  defaultPrepareOptions: PrepareOptions;
+
+  /** Default query's execute options. */
+  defaultExecuteOptions: ExecuteOptions;
+
+  /** Default query's executeQuery options. */
+  defaultExecuteQueryOptions: ExecuteQueryOptions;
+
+  /** Default result set's fetch options. */
+  defaultFetchOptions: FetchOptions;
+
+  protected constructor(public client?: AbstractClient) {}
+
+  /** Disconnects this attachment. */
+  async disconnect(): Promise<void> {
+    this.check();
+
+    await this.preDispose();
+    await this.internalDisconnect();
+    await this.postDispose();
+  }
+
+  /** Drops the database and release this attachment. */
+  async dropDatabase(): Promise<void> {
+    this.check();
+
+    await this.preDispose();
+    await this.internalDropDatabase();
+    await this.postDispose();
+  }
+
+  /** Enable/disable cancellation of operations in this attachment. */
+  async enableCancellation(enable: boolean): Promise<void> {
+    this.check();
+    await this.internalEnableCancellation(enable);
+  }
+
+  /** Cancel a running operation in this attachment. */
+  async cancelOperation(forcibleAbort?: boolean): Promise<void> {
+    this.check();
+    await this.internalCancelOperation(forcibleAbort ?? false);
+  }
+
+  /** Executes a statement that uses the SET TRANSACTION command. Returns the new transaction. */
+  async executeTransaction(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    options?: {
+      prepareOptions?: PrepareOptions;
+    },
+  ): Promise<AbstractTransaction> {
+    this.check();
+
+    const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
+    try {
+      const newTransaction = await statement.executeTransaction(transaction);
+      this.transactions.add(newTransaction);
+      return newTransaction;
+    } finally {
+      await statement.dispose();
+    }
+  }
+
+  /** Executes a statement that has no result set. */
+  async execute(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    parameters?: any[],
+    options?: {
+      prepareOptions?: PrepareOptions;
+      executeOptions?: ExecuteOptions;
+    },
+  ): Promise<void> {
+    this.check();
+
+    const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
+    try {
+      return await statement.execute(transaction, parameters, options && options.executeOptions);
+    } finally {
+      await statement.dispose();
+    }
+  }
+
+  /** Executes a statement that returns a single record. */
+  async executeSingleton(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    parameters?: any[],
+    options?: {
+      prepareOptions?: PrepareOptions;
+      executeOptions?: ExecuteOptions;
+    },
+  ): Promise<any[]> {
+    this.check();
+
+    const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
+    try {
+      return await statement.executeSingleton(transaction, parameters, options && options.executeOptions);
+    } finally {
+      await statement.dispose();
+    }
+  }
+
+  /** Executes a statement that returns a single record in object form. */
+  async executeSingletonAsObject<T extends object>(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    parameters?: any[],
+    options?: {
+      prepareOptions?: PrepareOptions;
+      executeOptions?: ExecuteOptions;
+    },
+  ): Promise<T> {
+    this.check();
+
+    const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
+    try {
+      return await statement.executeSingletonAsObject(transaction, parameters, options && options.executeOptions);
+    } finally {
+      await statement.dispose();
+    }
+  }
+
+  /** Executes a statement that returns a single record. */
+  async executeReturning(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    parameters?: any[],
+    options?: {
+      prepareOptions?: PrepareOptions;
+      executeOptions?: ExecuteOptions;
+    },
+  ): Promise<any[]> {
+    return await this.executeSingleton(transaction, sqlStmt, parameters, options);
+  }
+
+  /** Executes a statement that returns a single record in object form. */
+  async executeReturningAsObject<T extends object>(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    parameters?: any[],
+    options?: {
+      prepareOptions?: PrepareOptions;
+      executeOptions?: ExecuteOptions;
+    },
+  ): Promise<T> {
+    return await this.executeSingletonAsObject<T>(transaction, sqlStmt, parameters, options);
+  }
+
+  /** Executes a statement that has result set. */
+  async executeQuery(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    parameters?: any[],
+    options?: {
+      prepareOptions?: PrepareOptions;
+      executeOptions?: ExecuteQueryOptions;
+    },
+  ): Promise<AbstractResultSet> {
+    this.check();
+
+    const statement = await this.prepare(transaction, sqlStmt, options && options.prepareOptions);
+    try {
+      const resultSet = await statement.executeQuery(transaction, parameters, options && options.executeOptions);
+      resultSet.diposeStatementOnClose = true;
+      return resultSet;
+    } catch (e) {
+      await statement.dispose();
+      throw e;
+    }
+  }
+
+  async queueEvents(names: string[], callBack: (counters: [string, number][]) => Promise<void>): Promise<Events> {
+    this.check();
+
+    const trimmedNames = names.map((name) => {
+      const trimmedName = name.trimRight();
+
+      if (Buffer.from(trimmedName).byteLength > 255) {
+        throw new Error(`Invalid event name: ${name}.`);
+      }
+
+      return trimmedName;
+    });
+
+    const events = await this.internalQueueEvents(trimmedNames, callBack);
+    this.events.add(events);
+
+    return events;
+  }
+
+  async createBlob(transaction: AbstractTransaction, options?: CreateBlobOptions): Promise<AbstractBlobStream> {
+    return await this.internalCreateBlob(transaction, options);
+  }
+
+  async openBlob(transaction: AbstractTransaction, blob: Blob): Promise<AbstractBlobStream> {
+    return await this.internalOpenBlob(transaction, blob);
+  }
+
+  /** Starts a new transaction. */
+  async startTransaction(options?: TransactionOptions): Promise<AbstractTransaction> {
+    this.check();
+
+    const transaction = await this.internalStartTransaction(
+      options || this.defaultTransactionOptions || this.client!.defaultTransactionOptions,
+    );
+    this.transactions.add(transaction);
+    return transaction;
+  }
+
+  /** Prepares a query. */
+  async prepare(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    options?: PrepareOptions,
+  ): Promise<AbstractStatement> {
+    this.check();
+
+    const statement = await this.internalPrepare(
+      transaction,
+      sqlStmt,
+      options || this.defaultPrepareOptions || this.client!.defaultPrepareOptions,
+    );
+    this.statements.add(statement);
+    return statement;
+  }
+
+  get isValid(): boolean {
+    return !!this.client;
+  }
+
+  private check() {
+    if (!this.isValid) {
+      throw new Error('Attachment is already disconnected.');
+    }
+  }
+
+  private async preDispose() {
+    try {
+      await Promise.all(Array.from(this.events).map((events) => events.cancel()));
+      await Promise.all(Array.from(this.statements).map((statement) => statement.dispose()));
+      await Promise.all(Array.from(this.transactions).map((transaction) => transaction.rollback()));
+    } finally {
+      this.events.clear();
+      this.statements.clear();
+      this.transactions.clear();
+    }
+  }
+
+  private async postDispose() {
+    this.client!.attachments.delete(this);
+    this.client = undefined;
+  }
+
+  protected abstract internalDisconnect(): Promise<void>;
+  protected abstract internalDropDatabase(): Promise<void>;
+  protected abstract internalEnableCancellation(enable: boolean): Promise<void>;
+  protected abstract internalCancelOperation(forcibleAbort: boolean): Promise<void>;
+  protected abstract internalCreateBlob(
+    transaction: AbstractTransaction,
+    options?: CreateBlobOptions,
+  ): Promise<AbstractBlobStream>;
+  protected abstract internalOpenBlob(transaction: AbstractTransaction, blob: Blob): Promise<AbstractBlobStream>;
+  protected abstract internalPrepare(
+    transaction: AbstractTransaction,
+    sqlStmt: string,
+    options?: PrepareOptions,
+  ): Promise<AbstractStatement>;
+  protected abstract internalStartTransaction(options?: TransactionOptions): Promise<AbstractTransaction>;
+  protected abstract internalQueueEvents(
+    names: string[],
+    callBack: (counters: [string, number][]) => Promise<void>,
+  ): Promise<AbstractEvents>;
 }