node-firebird-driver 3.2.2 → 3.4.0

package/dist/test/tests.js

@@ -4,6 +4,7 @@ exports.runCommonTests = runCommonTests;
 const lib_1 = require("../lib");
 const fs = require("fs-extra-promise");
 const tmp = require("temp-fs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 require('dotenv').config({ path: '../../.env' });
 function runCommonTests(client) {
     function dateToString(d) {
@@ -13,20 +14,22 @@ function runCommonTests(client) {
         return d && `${d.getHours()}:${d.getMinutes()}:${d.getSeconds()}.${d.getMilliseconds()}`;
     }
     function timeTzToString(zd) {
-        if (!zd)
+        if (!zd) {
             return null;
-        const d = new Date(zd.date.getTime() + (zd.offset * 60 * 1000));
+        }
+        const d = new Date(zd.date.getTime() + zd.offset * 60 * 1000);
         return `time '${d.getUTCHours()}:${d.getUTCMinutes()}:${d.getUTCSeconds()}.${d.getUTCMilliseconds()} ${zd.timeZone}'`;
     }
     function dateTimeToString(d) {
         return d && `${dateToString(d)} ${timeToString(d)}`;
     }
     function dateTimeTzToString(zd) {
-        if (!zd)
+        if (!zd) {
             return null;
-        const d = new Date(zd.date.getTime() + (zd.offset * 60 * 1000));
-        return `timestamp '${(d.getUTCFullYear() + '').padStart(4, '0')}-${d.getUTCMonth() + 1}-${d.getUTCDate()} ` +
-            `${d.getUTCHours()}:${d.getUTCMinutes()}:${d.getUTCSeconds()}.${d.getUTCMilliseconds()} ${zd.timeZone}'`;
+        }
+        const d = new Date(zd.date.getTime() + zd.offset * 60 * 1000);
+        return (`timestamp '${(d.getUTCFullYear() + '').padStart(4, '0')}-${d.getUTCMonth() + 1}-${d.getUTCDate()} ` +
+            `${d.getUTCHours()}:${d.getUTCMinutes()}:${d.getUTCSeconds()}.${d.getUTCMilliseconds()} ${zd.timeZone}'`);
     }
     describe('node-firebird-driver', () => {
         const testConfig = {
@@ -34,19 +37,17 @@ function runCommonTests(client) {
             password: process.env.ISC_PASSWORD,
             host: process.env.NODE_FB_TEST_HOST,
             port: process.env.NODE_FB_TEST_PORT,
-            tmpDir: process.env.NODE_FB_TEST_TMP_DIR
+            tmpDir: process.env.NODE_FB_TEST_TMP_DIR,
         };
         function isLocal() {
-            return testConfig.host == undefined ||
-                testConfig.host == 'localhost' ||
-                testConfig.host == '127.0.0.1';
+            return testConfig.host == undefined || testConfig.host == 'localhost' || testConfig.host == '127.0.0.1';
         }
         function getTempFile(name) {
             const database = `${testConfig.tmpDir}/${name}`;
-            return (testConfig.host ?? '') +
+            return ((testConfig.host ?? '') +
                 (testConfig.host && testConfig.port ? `/${testConfig.port}` : '') +
                 (testConfig.host ? ':' : '') +
-                database;
+                database);
         }
         jest.setTimeout(10000);
         beforeAll(() => {
@@ -58,21 +59,22 @@ function runCommonTests(client) {
             }
             const defaultOptions = {
                 password: testConfig.password,
-                username: testConfig.username
+                username: testConfig.username,
             };
             client.defaultCreateDatabaseOptions = {
                 forcedWrite: false,
-                ...defaultOptions
+                ...defaultOptions,
             };
             client.defaultConnectOptions = {
-                ...defaultOptions
+                ...defaultOptions,
             };
         });
         afterAll(async () => {
             await client.dispose();
             expect(client.isValid).toBeFalsy();
-            if (isLocal())
+            if (isLocal()) {
                 fs.rmdirSync(testConfig.tmpDir);
+            }
         });
         describe('Client', () => {
             test('#createDatabase()', async () => {
@@ -90,22 +92,55 @@ function runCommonTests(client) {
                 expect(attachment1.isValid).toBeFalsy();
                 expect(attachment2.isValid).toBeFalsy();
             });
+            test('setDatabaseReadWriteMode', async () => {
+                const filename = getTempFile('setDatabaseReadWriteMode.fdb');
+                const attachment1 = await client.createDatabase(filename);
+                await attachment1.disconnect();
+                const attachment2 = await client.connect(filename, {
+                    setDatabaseReadWriteMode: lib_1.DatabaseReadWriteMode.READ_ONLY,
+                });
+                try {
+                    const transaction = await attachment2.startTransaction();
+                    await expect(attachment2.execute(transaction, 'create table t1 (id integer)')).rejects.toThrow();
+                    await transaction.rollback();
+                }
+                finally {
+                    await attachment2.disconnect();
+                }
+                const attachment3 = await client.connect(filename, {
+                    setDatabaseReadWriteMode: lib_1.DatabaseReadWriteMode.READ_WRITE,
+                });
+                try {
+                    const transaction = await attachment3.startTransaction();
+                    await attachment3.execute(transaction, 'create table t1 (id integer)');
+                    await transaction.commit();
+                }
+                finally {
+                    await attachment3.disconnect();
+                }
+                const attachment4 = await client.connect(filename);
+                await attachment4.dropDatabase();
+            });
         });
         describe('Attachment', () => {
             test('#startTransaction()', async () => {
                 const attachment = await client.createDatabase(getTempFile('Attachment-startTransaction.fdb'));
-                const isolationQuery = 'select rdb$get_context(\'SYSTEM\', \'ISOLATION_LEVEL\') from rdb$database';
+                const isolationQuery = "select rdb$get_context('SYSTEM', 'ISOLATION_LEVEL') from rdb$database";
                 const transaction1 = await attachment.startTransaction();
                 expect(transaction1.isValid).toBeTruthy();
                 expect((await attachment.executeSingleton(transaction1, isolationQuery))[0]).toBe('SNAPSHOT');
                 await transaction1.commit();
                 expect(transaction1.isValid).toBeFalsy();
-                const transaction2 = await attachment.startTransaction({ isolation: lib_1.TransactionIsolation.READ_COMMITTED });
+                const transaction2 = await attachment.startTransaction({
+                    isolation: lib_1.TransactionIsolation.READ_COMMITTED,
+                });
                 expect(transaction2.isValid).toBeTruthy();
                 expect((await attachment.executeSingleton(transaction2, isolationQuery))[0]).toBe('READ COMMITTED');
                 await transaction2.commit();
                 expect(transaction2.isValid).toBeFalsy();
-                const transaction3 = await attachment.startTransaction({ isolation: lib_1.TransactionIsolation.CONSISTENCY });
+                const transaction3 = await attachment.startTransaction({
+                    isolation: lib_1.TransactionIsolation.CONSISTENCY,
+                });
                 expect(transaction3.isValid).toBeTruthy();
                 expect((await attachment.executeSingleton(transaction3, isolationQuery))[0]).toBe('CONSISTENCY');
                 await transaction3.commit();
@@ -125,15 +160,33 @@ function runCommonTests(client) {
                 }
                 catch (e) {
                     error = e;
-                    expect(error.message).toBe('Dynamic SQL Error\n' +
-                        '-SQL error code = -104\n' +
-                        '-Token unknown - line 1, column 8\n' +
-                        '-select');
+                    expect(error.message).toBe('Dynamic SQL Error\n' + '-SQL error code = -104\n' + '-Token unknown - line 1, column 8\n' + '-select');
                 }
                 expect(error).toBeTruthy();
                 await transaction.commit();
                 await attachment.dropDatabase();
             });
+            test('statement.type', async () => {
+                const attachment = await client.createDatabase(getTempFile('Statement-type.fdb'));
+                const transaction = await attachment.startTransaction();
+                const s1 = await attachment.prepare(transaction, 'select * from rdb$database');
+                expect(await s1.type).toBe(lib_1.StatementType.SELECT);
+                await s1.dispose();
+                const s2 = await attachment.prepare(transaction, "insert into rdb$types (rdb$type_name, rdb$type, rdb$field_name) values ('A', 1, 'B')");
+                expect(await s2.type).toBe(lib_1.StatementType.INSERT);
+                await s2.dispose();
+                const s3 = await attachment.prepare(transaction, 'update rdb$database set rdb$description = null');
+                expect(await s3.type).toBe(lib_1.StatementType.UPDATE);
+                await s3.dispose();
+                const s4 = await attachment.prepare(transaction, 'delete from rdb$types where 1 = 0');
+                expect(await s4.type).toBe(lib_1.StatementType.DELETE);
+                await s4.dispose();
+                const s5 = await attachment.prepare(transaction, 'create table t_stmt_type (n integer)');
+                expect(await s5.type).toBe(lib_1.StatementType.DDL);
+                await s5.dispose();
+                await transaction.commit();
+                await attachment.dropDatabase();
+            });
             //// TODO: #executeTransaction
             test('#execute()', async () => {
                 const attachment = await client.createDatabase(getTempFile('Attachment-execute.fdb'));
@@ -202,7 +255,7 @@ function runCommonTests(client) {
                 const attachment = await client.createDatabase(getTempFile('Attachment-queueEvents.fdb'));
                 const eventNames = [
                     ['EVENT1', 16],
-                    ['EVENT2', 8]
+                    ['EVENT2', 8],
                 ];
                 const eventsObj = eventNames.map(([name, expected]) => {
                     let resolver = undefined;
@@ -210,20 +263,21 @@ function runCommonTests(client) {
                         name,
                         expected,
                         count: 0,
-                        promise: new Promise(resolve => resolver = resolve)
+                        promise: new Promise((resolve) => (resolver = resolve)),
                     };
                     return { ...obj, resolver };
                 });
-                const eventsMap = new Map(eventsObj.map(ev => [ev.name, ev]));
+                const eventsMap = new Map(eventsObj.map((ev) => [ev.name, ev]));
                 const eventHandler = async (counters) => {
                     counters.forEach(([name, count]) => {
                         const obj = eventsMap.get(name);
                         const newCount = obj.count + count;
                         obj.count = newCount;
-                        if (newCount >= obj.expected)
+                        if (newCount >= obj.expected) {
                             obj.resolver();
+                        }
                     });
-                    if (Array.from(eventsMap.values()).every(obj => obj.count >= obj.expected)) {
+                    if (Array.from(eventsMap.values()).every((obj) => obj.count >= obj.expected)) {
                         if (events) {
                             await events.cancel();
                             expect(events.isValid).toBeFalsy();
@@ -256,10 +310,11 @@ function runCommonTests(client) {
                     await transaction.commit();
                     expect(transaction.isValid).toBeFalsy();
                 }
-                await Promise.all(eventsObj.map(ev => ev.promise));
-                if (events)
+                await Promise.all(eventsObj.map((ev) => ev.promise));
+                if (events) {
                     await events.cancel();
-                eventsObj.forEach(ev => expect(ev.count).toBeGreaterThanOrEqual(ev.expected));
+                }
+                eventsObj.forEach((ev) => expect(ev.count).toBeGreaterThanOrEqual(ev.expected));
                 await attachment.dropDatabase();
             });
             test('#cancelOperation()', async () => {
@@ -272,9 +327,10 @@ function runCommonTests(client) {
                 await attachment.execute(transaction1, 'update t1 set n1 = n1 + 1');
                 await attachment.enableCancellation(true);
                 const transaction2 = await attachment.startTransaction();
-                const promise = attachment.execute(transaction2, 'update t1 set n1 = n1 - 1')
-                    .catch(e => `Error: ${e.message}`);
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                const promise = attachment
+                    .execute(transaction2, 'update t1 set n1 = n1 - 1')
+                    .catch((e) => `Error: ${e.message}`);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
                 await attachment.cancelOperation();
                 await expect(promise).resolves.toEqual('Error: operation was cancelled');
                 await transaction2.commit();
@@ -432,55 +488,116 @@ function runCommonTests(client) {
                 const fields = [
                     { name: 'x_short', type: 'numeric(2)', valToStr: (v) => v },
                     { name: 'x_int', type: 'integer', valToStr: (v) => v },
-                    { name: 'x_int_scale', type: 'numeric(5, 2)', valToStr: (v) => v },
+                    {
+                        name: 'x_int_scale',
+                        type: 'numeric(5, 2)',
+                        valToStr: (v) => v,
+                    },
                     { name: 'x_bigint', type: 'bigint', valToStr: (v) => v },
-                    { name: 'x_bigint_scale', type: 'numeric(15, 2)', valToStr: (v) => v },
+                    {
+                        name: 'x_bigint_scale',
+                        type: 'numeric(15, 2)',
+                        valToStr: (v) => v,
+                    },
                     { name: 'x_int128', type: 'int128', valToStr: (v) => v },
-                    { name: 'x_int128_scale', type: 'numeric(20, 2)', valToStr: (v) => v },
+                    {
+                        name: 'x_int128_scale',
+                        type: 'numeric(20, 2)',
+                        valToStr: (v) => v,
+                    },
                     { name: 'x_dec16', type: 'decfloat(16)', valToStr: (v) => v },
                     { name: 'x_dec34', type: 'decfloat(34)', valToStr: (v) => v },
-                    { name: 'x_double', type: 'double precision', valToStr: (v) => v },
-                    { name: 'x_date1', type: 'date', valToStr: (v) => `date '${dateToString(v)}'` },
-                    { name: 'x_date2', type: 'date', valToStr: (v) => `date '${dateToString(v)}'` },
-                    { name: 'x_date3', type: 'date', valToStr: (v) => `date '${dateToString(v)}'` },
-                    { name: 'x_time', type: 'time', valToStr: (v) => `time '${timeToString(v)}'` },
+                    {
+                        name: 'x_double',
+                        type: 'double precision',
+                        valToStr: (v) => v,
+                    },
+                    {
+                        name: 'x_date1',
+                        type: 'date',
+                        valToStr: (v) => `date '${dateToString(v)}'`,
+                    },
+                    {
+                        name: 'x_date2',
+                        type: 'date',
+                        valToStr: (v) => `date '${dateToString(v)}'`,
+                    },
+                    {
+                        name: 'x_date3',
+                        type: 'date',
+                        valToStr: (v) => `date '${dateToString(v)}'`,
+                    },
+                    {
+                        name: 'x_time',
+                        type: 'time',
+                        valToStr: (v) => `time '${timeToString(v)}'`,
+                    },
                     {
                         name: 'x_time_tz1',
                         type: 'time with time zone',
-                        valToStr: (v) => `${timeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                        valToStr: (v) => `${timeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`,
                     },
                     {
                         name: 'x_time_tz2',
                         type: 'time with time zone',
-                        valToStr: (v) => `${timeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                        valToStr: (v) => `${timeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`,
+                    },
+                    {
+                        name: 'x_timestamp1',
+                        type: 'timestamp',
+                        valToStr: (v) => `timestamp '${dateTimeToString(v)}'`,
+                    },
+                    {
+                        name: 'x_timestamp2',
+                        type: 'timestamp',
+                        valToStr: (v) => `timestamp '${dateTimeToString(v)}'`,
+                    },
+                    {
+                        name: 'x_timestamp3',
+                        type: 'timestamp',
+                        valToStr: (v) => `timestamp '${dateTimeToString(v)}'`,
                     },
-                    { name: 'x_timestamp1', type: 'timestamp', valToStr: (v) => `timestamp '${dateTimeToString(v)}'` },
-                    { name: 'x_timestamp2', type: 'timestamp', valToStr: (v) => `timestamp '${dateTimeToString(v)}'` },
-                    { name: 'x_timestamp3', type: 'timestamp', valToStr: (v) => `timestamp '${dateTimeToString(v)}'` },
                     {
                         name: 'x_timestamp_tz1',
                         type: 'timestamp with time zone',
-                        valToStr: (v) => `${dateTimeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                        valToStr: (v) => `${dateTimeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`,
                     },
                     {
                         name: 'x_timestamp_tz2',
                         type: 'timestamp with time zone',
-                        valToStr: (v) => `${dateTimeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`
+                        valToStr: (v) => `${dateTimeTzToString({ date: v.date, timeZone: 'GMT', offset: 0 })} at time zone '${v.timeZone}'`,
                     },
                     { name: 'x_boolean', type: 'boolean', valToStr: (v) => v },
-                    { name: 'x_varchar', type: 'varchar(10) character set utf8', valToStr: (v) => `'${v}'` },
-                    { name: 'x_char', type: 'char(10) character set utf8', valToStr: (v) => `'${v}'` },
-                    { name: 'x_blob1', type: 'blob', valToStr: (v) => `'${v.toString()}'` },
-                    { name: 'x_blob2', type: 'blob', valToStr: () => `'${blobBuffer.toString()}'` }
+                    {
+                        name: 'x_varchar',
+                        type: 'varchar(10) character set utf8',
+                        valToStr: (v) => `'${v}'`,
+                    },
+                    {
+                        name: 'x_char',
+                        type: 'char(10) character set utf8',
+                        valToStr: (v) => `'${v}'`,
+                    },
+                    {
+                        name: 'x_blob1',
+                        type: 'blob',
+                        valToStr: (v) => `'${v.toString()}'`,
+                    },
+                    {
+                        name: 'x_blob2',
+                        type: 'blob',
+                        valToStr: () => `'${blobBuffer.toString()}'`,
+                    },
                 ];
-                const statement1 = await attachment.prepare(transaction, `create table t1 (${fields.map(f => `${f.name} ${f.type}`).join(', ')})`);
+                const statement1 = await attachment.prepare(transaction, `create table t1 (${fields.map((f) => `${f.name} ${f.type}`).join(', ')})`);
                 await statement1.execute(transaction);
                 await statement1.dispose();
                 await transaction.commitRetaining();
                 const recordCount = 5;
                 let parameters;
-                { // scope
-                    const statement2a = await attachment.prepare(transaction, `insert into t1 (${fields.map(f => f.name).join(', ')}) values (${fields.map(() => '?').join(', ')})`);
+                {
+                    // scope
+                    const statement2a = await attachment.prepare(transaction, `insert into t1 (${fields.map((f) => f.name).join(', ')}) values (${fields.map(() => '?').join(', ')})`);
                     // Test execution in a new transaction, after the one used in prepare was committed.
                     await transaction.commit();
                     transaction = await attachment.startTransaction();
@@ -507,32 +624,41 @@ function runCommonTests(client) {
                         new Date(2020, 1 - 1, 1, 11, 56, 32, 123),
                         {
                             date: new Date(Date.UTC(2020, 1 - 1, 1, 11, 56, 32, 123)),
-                            timeZone: 'America/New_York'
+                            timeZone: 'America/New_York',
                         },
                         {
                             date: new Date(Date.UTC(2020, 1 - 1, 1, 11, 56, 32, 123)),
-                            timeZone: 'America/Sao_Paulo'
+                            timeZone: 'America/Sao_Paulo',
                         },
                         new Date(2017, 3 - 1, 26, 11, 56, 32, 123),
                         new Date(new Date(2000, 3 - 1, 26, 11, 56, 32, 123).setFullYear(50)),
                         new Date(9999, 3 - 1, 26, 11, 56, 32, 123),
-                        { date: new Date(Date.UTC(2021, 6 - 1, 7, 11, 56, 32, 123)), timeZone: 'America/New_York' },
-                        { date: new Date(Date.UTC(2021, 6 - 1, 7, 11, 56, 32, 123)), timeZone: 'America/Sao_Paulo' },
+                        {
+                            date: new Date(Date.UTC(2021, 6 - 1, 7, 11, 56, 32, 123)),
+                            timeZone: 'America/New_York',
+                        },
+                        {
+                            date: new Date(Date.UTC(2021, 6 - 1, 7, 11, 56, 32, 123)),
+                            timeZone: 'America/Sao_Paulo',
+                        },
                         true,
                         '123áé4567',
                         '123áé4567',
                         blobBuffer,
-                        blob
+                        blob,
                     ];
-                    for (let i = 0; i < recordCount; ++i)
+                    for (let i = 0; i < recordCount; ++i) {
                         await statement2a.execute(transaction, parameters);
+                    }
                     await statement2a.dispose();
                 }
-                { // scope
-                    const statement2b = await attachment.prepare(transaction, `insert into t1 (${fields.map(f => f.name).join(', ')}) ` +
+                {
+                    // scope
+                    const statement2b = await attachment.prepare(transaction, `insert into t1 (${fields.map((f) => f.name).join(', ')}) ` +
                         `values (${parameters.map((val, index) => fields[index].valToStr(val)).join(', ')})`);
-                    for (let i = 0; i < recordCount; ++i)
+                    for (let i = 0; i < recordCount; ++i) {
                         await statement2b.execute(transaction);
+                    }
                     await statement2b.dispose();
                 }
                 await transaction.commitRetaining();
@@ -666,7 +792,7 @@ function runCommonTests(client) {
             test('#fetch() with fetchSize and exception', async () => {
                 const attachment = await client.createDatabase(getTempFile('ResultSet-fetch-with-fetchSize.fdb'));
                 const transaction = await attachment.startTransaction();
-                await attachment.execute(transaction, 'create exception e1 \'e1\'');
+                await attachment.execute(transaction, "create exception e1 'e1'");
                 await transaction.commitRetaining();
                 const rs = await attachment.executeQuery(transaction, `
 					execute block returns (n integer)
@@ -705,8 +831,9 @@ function runCommonTests(client) {
                 const resultBuffer = Buffer.alloc(blobLength);
                 let size = 0;
                 let n;
-                while (size < blobLength && (n = await readStream.read(resultBuffer.slice(size))) > 0)
+                while (size < blobLength && (n = await readStream.read(resultBuffer.slice(size))) > 0) {
                     size += n;
+                }
                 await readStream.close();
                 expect(resultBuffer.toString().length).toEqual(buffer.toString().length);
                 expect(resultBuffer.toString()).toEqual(buffer.toString());
@@ -721,7 +848,9 @@ function runCommonTests(client) {
                 const transaction = await attachment.startTransaction();
                 await attachment.execute(transaction, 'create table t1 (b blob)');
                 await transaction.commitRetaining();
-                const blobStream = await attachment.createBlob(transaction, { type: 'STREAM' });
+                const blobStream = await attachment.createBlob(transaction, {
+                    type: 'STREAM',
+                });
                 await blobStream.write(Buffer.alloc(10, '1234567890'));
                 await blobStream.close();
                 await attachment.execute(transaction, 'insert into t1 (b) values (?)', [blobStream.blob]);