node-firebird-driver-native 3.2.0 → 3.3.0

package/src/lib/attachment.ts

@@ -6,91 +6,104 @@ import { EventsImpl } from './events';
 import { createDpb } from './fb-util';
 
 import {
-	Blob,
-	ConnectOptions,
-	CreateBlobOptions,
-	CreateDatabaseOptions,
-	PrepareOptions,
-	TransactionOptions
+  Blob,
+  ConnectOptions,
+  CreateBlobOptions,
+  CreateDatabaseOptions,
+  PrepareOptions,
+  TransactionOptions,
 } from 'node-firebird-driver';
 
 import { AbstractAttachment, cancelType } from 'node-firebird-driver/dist/lib/impl';
 
 import * as fb from 'node-firebird-native-api';
 
-
 /** Attachment implementation. */
 export class AttachmentImpl extends AbstractAttachment {
-	// Override declarations.
-	override client: ClientImpl;
-
-	attachmentHandle?: fb.Attachment;
-
-	static async connect(client: ClientImpl, uri: string, options?: ConnectOptions): Promise<AttachmentImpl> {
-		const attachment = new AttachmentImpl(client);
-
-		return await client.statusAction(async status => {
-			const dpb = createDpb(options);
-			attachment.attachmentHandle = await client!.dispatcher!.attachDatabaseAsync(status, uri, dpb.length, dpb);
-			return attachment;
-		});
-	}
-
-	static async createDatabase(client: ClientImpl, uri: string, options?: CreateDatabaseOptions): Promise<AttachmentImpl> {
-		const attachment = new AttachmentImpl(client);
-
-		return await client.statusAction(async status => {
-			const dpb = createDpb(options);
-			attachment.attachmentHandle = await client!.dispatcher!.createDatabaseAsync(status, uri, dpb.length, dpb);
-			return attachment;
-		});
-	}
-
-	/** Disconnects this attachment. */
-	protected async internalDisconnect(): Promise<void> {
-		await this.client.statusAction(status => this.attachmentHandle!.detachAsync(status));
-		this.attachmentHandle = undefined;
-	}
-
-	/** Drops the database and release this attachment. */
-	protected async internalDropDatabase(): Promise<void> {
-		await this.client.statusAction(status => this.attachmentHandle!.dropDatabaseAsync(status));
-		this.attachmentHandle = undefined;
-	}
-
-	/** Enable/disable cancellation of operations in this attachment. */
-	protected async internalEnableCancellation(enable: boolean): Promise<void> {
-		await this.client.statusAction(status =>
-			this.attachmentHandle!.cancelOperationAsync(status, (enable ? cancelType.enable : cancelType.disable)));
-	}
-
-	/** Cancel a running operation in this attachment. */
-	protected async internalCancelOperation(forcibleAbort: boolean): Promise<void> {
-		await this.client.statusAction(status =>
-			this.attachmentHandle!.cancelOperationAsync(status, (forcibleAbort ? cancelType.abort : cancelType.raise)));
-	}
-
-	/** Starts a new transaction. */
-	protected async internalStartTransaction(options?: TransactionOptions): Promise<TransactionImpl> {
-		return await TransactionImpl.start(this, options);
-	}
-
-	protected async internalCreateBlob(transaction: TransactionImpl, options?: CreateBlobOptions): Promise<BlobStreamImpl> {
-		return await BlobStreamImpl.create(this, transaction, options);
-	}
-
-	protected async internalOpenBlob(transaction: TransactionImpl, blob: Blob): Promise<BlobStreamImpl> {
-		return await BlobStreamImpl.open(this, transaction, blob);
-	}
-
-	/** Prepares a query. */
-	protected async internalPrepare(transaction: TransactionImpl, sqlStmt: string, options?: PrepareOptions): Promise<StatementImpl> {
-		return await StatementImpl.prepare(this, transaction, sqlStmt, options);
-	}
-
-	protected async internalQueueEvents(
-		names: string[], callBack: (counters: [string, number][]) => Promise<void>): Promise<EventsImpl>
-	{
-		return await EventsImpl.queue(this, names, callBack);
-	}
+  // Override declarations.
+  override client: ClientImpl;
+
+  attachmentHandle?: fb.Attachment;
+
+  static async connect(client: ClientImpl, uri: string, options?: ConnectOptions): Promise<AttachmentImpl> {
+    const attachment = new AttachmentImpl(client);
+
+    return await client.statusAction(async (status) => {
+      const dpb = createDpb(options);
+      attachment.attachmentHandle = await client!.dispatcher!.attachDatabaseAsync(status, uri, dpb.length, dpb);
+      return attachment;
+    });
+  }
+
+  static async createDatabase(
+    client: ClientImpl,
+    uri: string,
+    options?: CreateDatabaseOptions,
+  ): Promise<AttachmentImpl> {
+    const attachment = new AttachmentImpl(client);
+
+    return await client.statusAction(async (status) => {
+      const dpb = createDpb(options);
+      attachment.attachmentHandle = await client!.dispatcher!.createDatabaseAsync(status, uri, dpb.length, dpb);
+      return attachment;
+    });
+  }
+
+  /** Disconnects this attachment. */
+  protected async internalDisconnect(): Promise<void> {
+    await this.client.statusAction((status) => this.attachmentHandle!.detachAsync(status));
+    this.attachmentHandle = undefined;
+  }
+
+  /** Drops the database and release this attachment. */
+  protected async internalDropDatabase(): Promise<void> {
+    await this.client.statusAction((status) => this.attachmentHandle!.dropDatabaseAsync(status));
+    this.attachmentHandle = undefined;
+  }
+
+  /** Enable/disable cancellation of operations in this attachment. */
+  protected async internalEnableCancellation(enable: boolean): Promise<void> {
+    await this.client.statusAction((status) =>
+      this.attachmentHandle!.cancelOperationAsync(status, enable ? cancelType.enable : cancelType.disable),
+    );
+  }
+
+  /** Cancel a running operation in this attachment. */
+  protected async internalCancelOperation(forcibleAbort: boolean): Promise<void> {
+    await this.client.statusAction((status) =>
+      this.attachmentHandle!.cancelOperationAsync(status, forcibleAbort ? cancelType.abort : cancelType.raise),
+    );
+  }
+
+  /** Starts a new transaction. */
+  protected async internalStartTransaction(options?: TransactionOptions): Promise<TransactionImpl> {
+    return await TransactionImpl.start(this, options);
+  }
+
+  protected async internalCreateBlob(
+    transaction: TransactionImpl,
+    options?: CreateBlobOptions,
+  ): Promise<BlobStreamImpl> {
+    return await BlobStreamImpl.create(this, transaction, options);
+  }
+
+  protected async internalOpenBlob(transaction: TransactionImpl, blob: Blob): Promise<BlobStreamImpl> {
+    return await BlobStreamImpl.open(this, transaction, blob);
+  }
+
+  /** Prepares a query. */
+  protected async internalPrepare(
+    transaction: TransactionImpl,
+    sqlStmt: string,
+    options?: PrepareOptions,
+  ): Promise<StatementImpl> {
+    return await StatementImpl.prepare(this, transaction, sqlStmt, options);
+  }
+
+  protected async internalQueueEvents(
+    names: string[],
+    callBack: (counters: [string, number][]) => Promise<void>,
+  ): Promise<EventsImpl> {
+    return await EventsImpl.queue(this, names, callBack);
+  }
 }

package/src/lib/blob.ts

@@ -6,97 +6,111 @@ import { AbstractBlobStream, blobInfo, createBpb, getPortableInteger } from 'nod
 import * as fb from 'node-firebird-native-api';
 import { TransactionImpl } from './transaction';
 
-
 const MAX_SEGMENT_SIZE = 65535;
 
-
 /** BlobStream implementation. */
 export class BlobStreamImpl extends AbstractBlobStream {
-	// Override declarations.
-	override attachment: AttachmentImpl;
-
-	blobHandle?: fb.Blob;
-
-	static async create(attachment: AttachmentImpl, transaction: TransactionImpl, options?: CreateBlobOptions): Promise<BlobStreamImpl> {
-		return await attachment.client.statusAction(async status => {
-			const blobId = new Uint8Array(8);
-			const bpb = createBpb(options);
-
-			const blobHandle = await attachment.attachmentHandle!.createBlobAsync(
-				status, transaction.transactionHandle, blobId, bpb.length, bpb);
-
-			const blob = new Blob(attachment, blobId);
-
-			const blobStream = new BlobStreamImpl(blob, attachment);
-			blobStream.blobHandle = blobHandle;
-			return blobStream;
-		});
-	}
-
-	static async open(attachment: AttachmentImpl, transaction: TransactionImpl, blob: Blob): Promise<BlobStreamImpl> {
-		return await attachment.client.statusAction(async status => {
-			const blobStream = new BlobStreamImpl(blob, attachment);
-			blobStream.blobHandle = await attachment.attachmentHandle!.openBlobAsync(
-				status, transaction.transactionHandle, blob.id, 0, undefined);
-			return blobStream;
-		});
-	}
-
-	protected async internalGetLength(): Promise<number> {
-		return await this.attachment.client.statusAction(async status => {
-			const infoReq = new Uint8Array([blobInfo.totalLength]);
-			const infoRet = new Uint8Array(20);
-			await this.blobHandle!.getInfoAsync(status, infoReq.byteLength, infoReq, infoRet.byteLength, infoRet);
-
-			if (infoRet[0] != blobInfo.totalLength)
-				throw new Error('Unrecognized response from Blob::getInfo.');
-
-			const size = getPortableInteger(infoRet.subarray(1), 2);
-
-			return getPortableInteger(infoRet.subarray(3), size);
-		});
-	}
-
-	protected async internalClose(): Promise<void> {
-		await this.attachment.client.statusAction(status => this.blobHandle!.closeAsync(status));
-		this.blobHandle = undefined;
-	}
-
-	protected async internalCancel(): Promise<void> {
-		await this.attachment.client.statusAction(status => this.blobHandle!.cancelAsync(status));
-		this.blobHandle = undefined;
-	}
-
-	protected async internalSeek(offset: number, whence?: BlobSeekWhence): Promise<number> {
-		return await this.attachment.client.statusAction(async status => {
-			return await this.blobHandle!.seekAsync(status, whence ?? BlobSeekWhence.START, offset);
-		});
-	}
-
-	protected async internalRead(buffer: Buffer): Promise<number> {
-		return await this.attachment.client.statusAction(async status => {
-			const readingBytes = Math.min(buffer.length, MAX_SEGMENT_SIZE);
-			const segLength = new Uint32Array(1);
-			const result = await this.blobHandle!.getSegmentAsync(status, readingBytes, buffer, segLength);
-
-			if (result == fb.Status.RESULT_NO_DATA)
-				return -1;
-
-			return segLength[0];
-		});
-	}
-
-	protected async internalWrite(buffer: Buffer): Promise<void> {
-		await this.attachment.client.statusAction(async status => {
-			while (buffer.length > 0) {
-				const writingBytes = Math.min(buffer.length, MAX_SEGMENT_SIZE);
-				await this.blobHandle!.putSegmentAsync(status, writingBytes, buffer);
-				buffer = buffer.slice(writingBytes);
-			}
-		});
-	}
-
-	get isValid(): boolean {
-		return !!this.blobHandle && this.attachment.isValid;
-	}
+  // Override declarations.
+  override attachment: AttachmentImpl;
+
+  blobHandle?: fb.Blob;
+
+  static async create(
+    attachment: AttachmentImpl,
+    transaction: TransactionImpl,
+    options?: CreateBlobOptions,
+  ): Promise<BlobStreamImpl> {
+    return await attachment.client.statusAction(async (status) => {
+      const blobId = new Uint8Array(8);
+      const bpb = createBpb(options);
+
+      const blobHandle = await attachment.attachmentHandle!.createBlobAsync(
+        status,
+        transaction.transactionHandle,
+        blobId,
+        bpb.length,
+        bpb,
+      );
+
+      const blob = new Blob(attachment, blobId);
+
+      const blobStream = new BlobStreamImpl(blob, attachment);
+      blobStream.blobHandle = blobHandle;
+      return blobStream;
+    });
+  }
+
+  static async open(attachment: AttachmentImpl, transaction: TransactionImpl, blob: Blob): Promise<BlobStreamImpl> {
+    return await attachment.client.statusAction(async (status) => {
+      const blobStream = new BlobStreamImpl(blob, attachment);
+      blobStream.blobHandle = await attachment.attachmentHandle!.openBlobAsync(
+        status,
+        transaction.transactionHandle,
+        blob.id,
+        0,
+        undefined,
+      );
+      return blobStream;
+    });
+  }
+
+  protected async internalGetLength(): Promise<number> {
+    return await this.attachment.client.statusAction(async (status) => {
+      const infoReq = new Uint8Array([blobInfo.totalLength]);
+      const infoRet = new Uint8Array(20);
+      await this.blobHandle!.getInfoAsync(status, infoReq.byteLength, infoReq, infoRet.byteLength, infoRet);
+
+      if (infoRet[0] != blobInfo.totalLength) {
+        throw new Error('Unrecognized response from Blob::getInfo.');
+      }
+
+      const size = getPortableInteger(infoRet.subarray(1), 2);
+
+      return getPortableInteger(infoRet.subarray(3), size);
+    });
+  }
+
+  protected async internalClose(): Promise<void> {
+    await this.attachment.client.statusAction((status) => this.blobHandle!.closeAsync(status));
+    this.blobHandle = undefined;
+  }
+
+  protected async internalCancel(): Promise<void> {
+    await this.attachment.client.statusAction((status) => this.blobHandle!.cancelAsync(status));
+    this.blobHandle = undefined;
+  }
+
+  protected async internalSeek(offset: number, whence?: BlobSeekWhence): Promise<number> {
+    return await this.attachment.client.statusAction(async (status) => {
+      return await this.blobHandle!.seekAsync(status, whence ?? BlobSeekWhence.START, offset);
+    });
+  }
+
+  protected async internalRead(buffer: Buffer): Promise<number> {
+    return await this.attachment.client.statusAction(async (status) => {
+      const readingBytes = Math.min(buffer.length, MAX_SEGMENT_SIZE);
+      const segLength = new Uint32Array(1);
+      const result = await this.blobHandle!.getSegmentAsync(status, readingBytes, buffer, segLength);
+
+      if (result == fb.Status.RESULT_NO_DATA) {
+        return -1;
+      }
+
+      return segLength[0];
+    });
+  }
+
+  protected async internalWrite(buffer: Buffer): Promise<void> {
+    await this.attachment.client.statusAction(async (status) => {
+      while (buffer.length > 0) {
+        const writingBytes = Math.min(buffer.length, MAX_SEGMENT_SIZE);
+        await this.blobHandle!.putSegmentAsync(status, writingBytes, buffer);
+        buffer = buffer.slice(writingBytes);
+      }
+    });
+  }
+
+  get isValid(): boolean {
+    return !!this.blobHandle && this.attachment.isValid;
+  }
 }

package/src/lib/client.ts

@@ -1,65 +1,58 @@
 import { AttachmentImpl } from './attachment';
 
-import {
-	Client,
-	ConnectOptions,
-	CreateDatabaseOptions
-} from 'node-firebird-driver';
+import { Client, ConnectOptions, CreateDatabaseOptions } from 'node-firebird-driver';
 
 import { AbstractClient } from 'node-firebird-driver/dist/lib/impl';
 
 import * as fb from 'node-firebird-native-api';
 
-
 /** Gets the default platform Firebird client library filename. */
 export { getDefaultLibraryFilename } from 'node-firebird-native-api';
 
 /** Creates a client for a given library filename. */
 export function createNativeClient(library: string): Client {
-	return new ClientImpl(library);
+  return new ClientImpl(library);
 }
 
-
 /** Client implementation. */
 export class ClientImpl extends AbstractClient {
-	master?: fb.Master;
-	dispatcher?: fb.Provider;
-	util?: fb.Util;
-
-	constructor(library: string) {
-		super();
-		this.master = fb.getMaster(library);
-		this.dispatcher = this.master.getDispatcherSync();
-		this.util = this.master.getUtilInterfaceSync();
-	}
-
-	async statusAction<T>(action: (status: fb.Status) => Promise<T>): Promise<T> {
-		const status = this.master!.getStatusSync()!;
-		try {
-			return await action(status);
-		}
-		finally {
-			status.disposeSync();
-		}
-	}
-
-	/** Connects to a database. */
-	protected async internalConnect(uri: string, options?: ConnectOptions): Promise<AttachmentImpl> {
-		return await AttachmentImpl.connect(this, uri, options);
-	}
-
-	/** Creates a database. */
-	protected async internalCreateDatabase(uri: string, options?: CreateDatabaseOptions): Promise<AttachmentImpl> {
-		return await AttachmentImpl.createDatabase(this, uri, options);
-	}
-
-	/** Disposes this client's resources. */
-	protected async internalDispose(): Promise<void> {
-		this.dispatcher!.releaseSync();
-		fb.disposeMaster(this.master!);
-
-		this.util = undefined;
-		this.dispatcher = undefined;
-		this.master = undefined;
-	}
+  master?: fb.Master;
+  dispatcher?: fb.Provider;
+  util?: fb.Util;
+
+  constructor(library: string) {
+    super();
+    this.master = fb.getMaster(library);
+    this.dispatcher = this.master.getDispatcherSync();
+    this.util = this.master.getUtilInterfaceSync();
+  }
+
+  async statusAction<T>(action: (status: fb.Status) => Promise<T>): Promise<T> {
+    const status = this.master!.getStatusSync()!;
+    try {
+      return await action(status);
+    } finally {
+      status.disposeSync();
+    }
+  }
+
+  /** Connects to a database. */
+  protected async internalConnect(uri: string, options?: ConnectOptions): Promise<AttachmentImpl> {
+    return await AttachmentImpl.connect(this, uri, options);
+  }
+
+  /** Creates a database. */
+  protected async internalCreateDatabase(uri: string, options?: CreateDatabaseOptions): Promise<AttachmentImpl> {
+    return await AttachmentImpl.createDatabase(this, uri, options);
+  }
+
+  /** Disposes this client's resources. */
+  protected async internalDispose(): Promise<void> {
+    this.dispatcher!.releaseSync();
+    fb.disposeMaster(this.master!);
+
+    this.util = undefined;
+    this.dispatcher = undefined;
+    this.master = undefined;
+  }
 }

package/src/lib/events.ts

@@ -4,30 +4,32 @@ import { AbstractEvents } from 'node-firebird-driver/dist/lib/impl';
 
 import * as fb from 'node-firebird-native-api';
 
-
 /** Events implementation. */
 export class EventsImpl extends AbstractEvents {
-	// Override declarations.
-	override attachment: AttachmentImpl;
-
-	eventCallback: fb.EventCallback;
-
-	static async queue(attachment: AttachmentImpl, names: string[], callBack: (counters: [string, number][]) => Promise<void>):
-			Promise<EventsImpl> {
-		const events = new EventsImpl(attachment);
-		const { client } = attachment;
-
-		events.eventCallback = await fb.queueEvent(client.master!, attachment.attachmentHandle!, names, callBack);
-
-		return events;
-	}
-
-	/** Disposes this events' resources. */
-	protected async internalCancel(): Promise<void> {
-		if (this.eventCallback) {
-			const { eventCallback } = this;
-			this.eventCallback = undefined!;
-			await fb.cancelEvent(eventCallback);
-		}
-	}
+  // Override declarations.
+  override attachment: AttachmentImpl;
+
+  eventCallback: fb.EventCallback;
+
+  static async queue(
+    attachment: AttachmentImpl,
+    names: string[],
+    callBack: (counters: [string, number][]) => Promise<void>,
+  ): Promise<EventsImpl> {
+    const events = new EventsImpl(attachment);
+    const { client } = attachment;
+
+    events.eventCallback = await fb.queueEvent(client.master!, attachment.attachmentHandle!, names, callBack);
+
+    return events;
+  }
+
+  /** Disposes this events' resources. */
+  protected async internalCancel(): Promise<void> {
+    if (this.eventCallback) {
+      const { eventCallback } = this;
+      this.eventCallback = undefined!;
+      await fb.cancelEvent(eventCallback);
+    }
+  }
 }