node-firebird-driver 3.2.0 → 3.3.0

package/src/lib/impl/blob.ts

@@ -2,41 +2,43 @@ import { AbstractAttachment } from './attachment';
 
 import { Blob, BlobSeekWhence, BlobStream } from '..';
 
-
 /** AbstractBlobStream implementation. */
 export abstract class AbstractBlobStream extends BlobStream {
-	protected constructor(blob: Blob, public attachment: AbstractAttachment) {
-		super(blob);
-	}
-
-	get length(): Promise<number> {
-		return this.internalGetLength();
-	}
-
-	async close(): Promise<void> {
-		return await this.internalClose();
-	}
-
-	async cancel(): Promise<void> {
-		return await this.internalCancel();
-	}
-
-	async seek(offset: number, whence?: BlobSeekWhence): Promise<number> {
-		return await this.internalSeek(offset, whence);
-	}
-
-	async read(buffer: Buffer): Promise<number> {
-		return await this.internalRead(buffer);
-	}
-
-	async write(buffer: Buffer): Promise<void> {
-		return await this.internalWrite(buffer);
-	}
-
-	protected abstract internalGetLength(): Promise<number>;
-	protected abstract internalClose(): Promise<void>;
-	protected abstract internalCancel(): Promise<void>;
-	protected abstract internalSeek(offset: number, whence?: BlobSeekWhence): Promise<number>;
-	protected abstract internalRead(buffer: Buffer): Promise<number>;
-	protected abstract internalWrite(buffer: Buffer): Promise<void>;
+  protected constructor(
+    blob: Blob,
+    public attachment: AbstractAttachment,
+  ) {
+    super(blob);
+  }
+
+  get length(): Promise<number> {
+    return this.internalGetLength();
+  }
+
+  async close(): Promise<void> {
+    return await this.internalClose();
+  }
+
+  async cancel(): Promise<void> {
+    return await this.internalCancel();
+  }
+
+  async seek(offset: number, whence?: BlobSeekWhence): Promise<number> {
+    return await this.internalSeek(offset, whence);
+  }
+
+  async read(buffer: Buffer): Promise<number> {
+    return await this.internalRead(buffer);
+  }
+
+  async write(buffer: Buffer): Promise<void> {
+    return await this.internalWrite(buffer);
+  }
+
+  protected abstract internalGetLength(): Promise<number>;
+  protected abstract internalClose(): Promise<void>;
+  protected abstract internalCancel(): Promise<void>;
+  protected abstract internalSeek(offset: number, whence?: BlobSeekWhence): Promise<number>;
+  protected abstract internalRead(buffer: Buffer): Promise<number>;
+  protected abstract internalWrite(buffer: Buffer): Promise<void>;
 }

package/src/lib/impl/client.ts

@@ -1,87 +1,86 @@
 import { AbstractAttachment } from './attachment';
 
 import {
-	Client,
-	ConnectOptions,
-	CreateDatabaseOptions,
-	ExecuteOptions,
-	ExecuteQueryOptions,
-	FetchOptions,
-	PrepareOptions,
-	TransactionOptions
+  Client,
+  ConnectOptions,
+  CreateDatabaseOptions,
+  ExecuteOptions,
+  ExecuteQueryOptions,
+  FetchOptions,
+  PrepareOptions,
+  TransactionOptions,
 } from '..';
 
-
 /** AbstractClient implementation. */
 export abstract class AbstractClient implements Client {
-	connected = true;
-	attachments = new Set<AbstractAttachment>();
+  connected = true;
+  attachments = new Set<AbstractAttachment>();
 
-	/** Default connect options. */
-	defaultConnectOptions: ConnectOptions;
+  /** Default connect options. */
+  defaultConnectOptions: ConnectOptions;
 
-	/** Set default create database options. */
-	defaultCreateDatabaseOptions: CreateDatabaseOptions;
+  /** Set default create database options. */
+  defaultCreateDatabaseOptions: CreateDatabaseOptions;
 
-	/** Default transaction options. */
-	defaultTransactionOptions: TransactionOptions;
+  /** Default transaction options. */
+  defaultTransactionOptions: TransactionOptions;
 
-	/** Default query's prepare options. */
-	defaultPrepareOptions: PrepareOptions;
+  /** Default query's prepare options. */
+  defaultPrepareOptions: PrepareOptions;
 
-	/** Default query's execute options. */
-	defaultExecuteOptions: ExecuteOptions;
+  /** Default query's execute options. */
+  defaultExecuteOptions: ExecuteOptions;
 
-	/** Default query's executeQuery options. */
-	defaultExecuteQueryOptions: ExecuteQueryOptions;
+  /** Default query's executeQuery options. */
+  defaultExecuteQueryOptions: ExecuteQueryOptions;
 
-	/** Default result set's fetch options. */
-	defaultFetchOptions: FetchOptions;
+  /** Default result set's fetch options. */
+  defaultFetchOptions: FetchOptions;
 
-	/** Disposes this client's resources. */
-	async dispose(): Promise<void> {
-		this.check();
+  /** Disposes this client's resources. */
+  async dispose(): Promise<void> {
+    this.check();
 
-		try {
-			await Promise.all(Array.from(this.attachments).map(attachment => attachment.disconnect()));
-		}
-		finally {
-			this.attachments.clear();
-		}
+    try {
+      await Promise.all(Array.from(this.attachments).map((attachment) => attachment.disconnect()));
+    } finally {
+      this.attachments.clear();
+    }
 
-		await this.internalDispose();
+    await this.internalDispose();
 
-		this.connected = false;
-	}
+    this.connected = false;
+  }
 
-	/** Connects to a database. */
-	async connect(uri: string, options?: ConnectOptions): Promise<AbstractAttachment> {
-		this.check();
+  /** Connects to a database. */
+  async connect(uri: string, options?: ConnectOptions): Promise<AbstractAttachment> {
+    this.check();
 
-		const attachment = await this.internalConnect(uri, options || this.defaultConnectOptions);
-		this.attachments.add(attachment);
-		return attachment;
-	}
+    const attachment = await this.internalConnect(uri, options || this.defaultConnectOptions);
+    this.attachments.add(attachment);
+    return attachment;
+  }
 
-	/** Creates a database. */
-	async createDatabase(uri: string, options?: CreateDatabaseOptions): Promise<AbstractAttachment> {
-		this.check();
+  /** Creates a database. */
+  async createDatabase(uri: string, options?: CreateDatabaseOptions): Promise<AbstractAttachment> {
+    this.check();
 
-		const attachment = await this.internalCreateDatabase(uri, options || this.defaultCreateDatabaseOptions);
-		this.attachments.add(attachment);
-		return attachment;
-	}
+    const attachment = await this.internalCreateDatabase(uri, options || this.defaultCreateDatabaseOptions);
+    this.attachments.add(attachment);
+    return attachment;
+  }
 
-	get isValid(): boolean {
-		return !!this.connected;
-	}
+  get isValid(): boolean {
+    return !!this.connected;
+  }
 
-	private check() {
-		if (!this.isValid)
-			throw new Error('Client is already disposed.');
-	}
+  private check() {
+    if (!this.isValid) {
+      throw new Error('Client is already disposed.');
+    }
+  }
 
-	protected abstract internalDispose(): Promise<void>;
-	protected abstract internalConnect(uri: string, options?: ConnectOptions): Promise<AbstractAttachment>;
-	protected abstract internalCreateDatabase(uri: string, options?: CreateDatabaseOptions): Promise<AbstractAttachment>;
+  protected abstract internalDispose(): Promise<void>;
+  protected abstract internalConnect(uri: string, options?: ConnectOptions): Promise<AbstractAttachment>;
+  protected abstract internalCreateDatabase(uri: string, options?: CreateDatabaseOptions): Promise<AbstractAttachment>;
 }

package/src/lib/impl/date-time.ts

@@ -25,55 +25,55 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 /** Decode a date. */
 export function decodeDate(date: number) {
-	let nday = date + 678882;
-	const century = Math.trunc((4 * nday - 1) / 146097);
-	nday = 4 * nday - 1 - 146097 * century;
-	let day = Math.trunc(nday / 4);
+  let nday = date + 678882;
+  const century = Math.trunc((4 * nday - 1) / 146097);
+  nday = 4 * nday - 1 - 146097 * century;
+  let day = Math.trunc(nday / 4);
 
-	nday = Math.trunc((4 * day + 3) / 1461);
-	day = 4 * day + 3 - 1461 * nday;
-	day = Math.trunc((day + 4) / 4);
+  nday = Math.trunc((4 * day + 3) / 1461);
+  day = 4 * day + 3 - 1461 * nday;
+  day = Math.trunc((day + 4) / 4);
 
-	let month = Math.trunc((5 * day - 3) / 153);
-	day = 5 * day - 3 - 153 * month;
-	day = Math.trunc((day + 5) / 5);
-	let year = 100 * century + nday;
+  let month = Math.trunc((5 * day - 3) / 153);
+  day = 5 * day - 3 - 153 * month;
+  day = Math.trunc((day + 5) / 5);
+  let year = 100 * century + nday;
 
-	if (month < 10)
-		month += 3;
-	else {
-		month -= 9;
-		year += 1;
-	}
+  if (month < 10) {
+    month += 3;
+  } else {
+    month -= 9;
+    year += 1;
+  }
 
-	return { year, month, day };
+  return { year, month, day };
 }
 
 /** Encode a date. */
 export function encodeDate(year: number, month: number, day: number): number {
-	const i = month + 9;
-	let jy = year + Math.trunc(i / 12) - 1;
-	const jm = i % 12;
-	const c = Math.trunc(jy / 100);
-	jy -= 100 * c;
-	const j = Math.trunc((146097 * c) / 4) + Math.trunc((1461 * jy) / 4) + Math.trunc((153 * jm + 2) / 5) + day - 678882;
+  const i = month + 9;
+  let jy = year + Math.trunc(i / 12) - 1;
+  const jm = i % 12;
+  const c = Math.trunc(jy / 100);
+  jy -= 100 * c;
+  const j = Math.trunc((146097 * c) / 4) + Math.trunc((1461 * jy) / 4) + Math.trunc((153 * jm + 2) / 5) + day - 678882;
 
-	return j;
+  return j;
 }
 
 /** Descode a time. */
 export function decodeTime(time: number) {
-	let seconds = Math.trunc(time / 10000);
-	let minutes = Math.trunc(seconds / 60);
-	const hours = Math.trunc(minutes / 60);
-	minutes = minutes % 60;
-	seconds = seconds % 60;
-	const fractions = time % 10000;
+  let seconds = Math.trunc(time / 10000);
+  let minutes = Math.trunc(seconds / 60);
+  const hours = Math.trunc(minutes / 60);
+  minutes = minutes % 60;
+  seconds = seconds % 60;
+  const fractions = time % 10000;
 
-	return { hours, minutes, seconds, fractions };
+  return { hours, minutes, seconds, fractions };
 }
 
 /** Encode a time. */
 export function encodeTime(hours: number, minutes: number, seconds: number, fractions: number): number {
-	return (hours * 3600 + minutes * 60 + seconds) * 10000 + fractions;
+  return (hours * 3600 + minutes * 60 + seconds) * 10000 + fractions;
 }

package/src/lib/impl/events.ts

@@ -2,30 +2,29 @@ import { AbstractAttachment } from './attachment';
 
 import { Events } from '..';
 
-
 /** AbstractStatement implementation. */
 export abstract class AbstractEvents implements Events {
-	protected constructor(public attachment?: AbstractAttachment) {
-	}
+  protected constructor(public attachment?: AbstractAttachment) {}
 
-	/** Cancel this events' resources. */
-	async cancel(): Promise<void> {
-		this.check();
+  /** Cancel this events' resources. */
+  async cancel(): Promise<void> {
+    this.check();
 
-		await this.internalCancel();
+    await this.internalCancel();
 
-		this.attachment?.events.delete(this);
-		this.attachment = undefined;
-	}
+    this.attachment?.events.delete(this);
+    this.attachment = undefined;
+  }
 
-	get isValid(): boolean {
-		return !!this.attachment;
-	}
+  get isValid(): boolean {
+    return !!this.attachment;
+  }
 
-	private check() {
-		if (!this.isValid)
-			throw new Error('Events are already cancelled.');
-	}
+  private check() {
+    if (!this.isValid) {
+      throw new Error('Events are already cancelled.');
+    }
+  }
 
-	protected abstract internalCancel(): Promise<void>;
+  protected abstract internalCancel(): Promise<void>;
 }