chore: cleanup node14 unneeded code (#407)

Remove no longer needed workaround node14 code paths.

Node14 support was removed in #403

Author: jackwotherspoon

.npmrc

@@ -60,7 +60,6 @@
     "@sequelize/core": "^7.0.0-alpha.29",
     "@types/node": "^22.0.0",
     "@types/pg": "^8.10.1",
-    "@types/semver": "^7.5.0",
     "@types/tap": "^18.0.0",
     "@types/tedious": "^4.0.9",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
@@ -71,7 +70,6 @@
     "mysql2": "^3.2.0",
     "nock": "^13.3.0",
     "pg": "^8.10.0",
-    "semver": "^7.5.1",
     "tap": "^21.0.0",
     "tedious": "^16.1.0",
     "typeorm": "^0.3.19",

package.json

@@ -18,54 +18,6 @@ import {SslCert} from './ssl-cert';
 import {cryptoModule} from './node-crypto';
 import {CloudSQLConnectorError} from './errors';
 
-// The following is a fallback certificate parser for node14 to work around
-// its lack of support to the X509Certificate class parser, this block of code
-// can be safely removed once node14 is no longer supported, along with any
-// `node14ParseCert` call and its unit tests.
-// --- node@14 cert parse fallback start
-import net from 'node:net';
-import tls from 'node:tls';
-
-const node14ParseCert = (cert: string): SslCert => {
-  const isPeerCertificate = (
-    obj: object | tls.PeerCertificate
-  ): obj is tls.PeerCertificate =>
-    (obj as tls.PeerCertificate).valid_to !== undefined;
-
-  let socket;
-  let parsed;
-  try {
-    socket = new tls.TLSSocket(new net.Socket(), {
-      secureContext: tls.createSecureContext({cert}),
-    });
-    parsed = socket.getCertificate();
-  } catch (err: unknown) {
-    throw new CloudSQLConnectorError({
-      message: 'Failed to parse as X.509 certificate.',
-      code: 'EPARSESQLADMINEPH',
-      errors: [err as Error],
-    });
-  }
-
-  if (parsed && isPeerCertificate(parsed)) {
-    const expirationTime = parsed.valid_to;
-    socket.destroy();
-    socket = undefined;
-    parsed = undefined;
-
-    return {
-      cert,
-      expirationTime,
-    };
-  }
-  /* c8 ignore next 5 */
-  throw new CloudSQLConnectorError({
-    message: 'Could not read ephemeral certificate.',
-    code: 'EPARSESQLADMINEPH',
-  });
-};
-// --- node@14 cert parse fallback end
-
 export async function generateKeys(): Promise<RSAKeys> {
   const crypto = await cryptoModule();
   const keygen = promisify(crypto.generateKeyPair);
@@ -90,27 +42,24 @@ export async function generateKeys(): Promise<RSAKeys> {
 
 export async function parseCert(cert: string): Promise<SslCert> {
   const {X509Certificate} = await cryptoModule();
-  if (X509Certificate) {
-    try {
-      const parsed = new X509Certificate(cert);
-      if (parsed && parsed.validTo) {
-        return {
-          cert,
-          expirationTime: parsed.validTo,
-        };
-      }
-
-      throw new CloudSQLConnectorError({
-        message: 'Could not read ephemeral certificate.',
-        code: 'EPARSESQLADMINEPH',
-      });
-    } catch (err: unknown) {
-      throw new CloudSQLConnectorError({
-        message: 'Failed to parse as X.509 certificate.',
-        code: 'EPARSESQLADMINEPH',
-        errors: [err as Error],
-      });
+  try {
+    const parsed = new X509Certificate(cert);
+    if (parsed && parsed.validTo) {
+      return {
+        cert,
+        expirationTime: parsed.validTo,
+      };
     }
+
+    throw new CloudSQLConnectorError({
+      message: 'Could not read ephemeral certificate.',
+      code: 'EPARSESQLADMINEPH',
+    });
+  } catch (err: unknown) {
+    throw new CloudSQLConnectorError({
+      message: 'Failed to parse as X.509 certificate.',
+      code: 'EPARSESQLADMINEPH',
+      errors: [err as Error],
+    });
   }
-  return node14ParseCert(cert);
 }

scripts/tap16-adapter.js

@@ -13,69 +13,62 @@
 // limitations under the License.
 
 const t = require('tap');
-const semver = require('semver');
 const {Connector} = require('@google-cloud/cloud-sql-connector');
+const {Connection, Request} = require('tedious');
 
-t.test(
-  'open connection and run basic sqlserver commands',
-  // the connector-supported versions of tedious do not support node14
-  {skip: semver.lt(process.versions.node, '16.0.0')},
-  async t => {
-    // lazy-load tedious here in order to allow for skipping node14
-    const {Connection, Request} = require('tedious');
-    const connector = new Connector();
-    const clientOpts = await connector.getTediousOptions({
-      instanceConnectionName: process.env.SQLSERVER_CONNECTION_NAME,
-      ipType: 'PUBLIC',
-    });
-    const connection = new Connection({
-      server: '0.0.0.0',
-      authentication: {
-        type: 'default',
-        options: {
-          userName: process.env.SQLSERVER_USER,
-          password: process.env.SQLSERVER_PASS,
-        },
-      },
+t.test('open connection and run basic sqlserver commands', async t => {
+  const connector = new Connector();
+  const clientOpts = await connector.getTediousOptions({
+    instanceConnectionName: process.env.SQLSERVER_CONNECTION_NAME,
+    ipType: 'PUBLIC',
+  });
+  const connection = new Connection({
+    server: '0.0.0.0',
+    authentication: {
+      type: 'default',
       options: {
-        ...clientOpts,
-        port: 9999,
-        database: process.env.SQLSERVER_DB,
+        userName: process.env.SQLSERVER_USER,
+        password: process.env.SQLSERVER_PASS,
       },
-    });
+    },
+    options: {
+      ...clientOpts,
+      port: 9999,
+      database: process.env.SQLSERVER_DB,
+    },
+  });
 
-    await new Promise((res, rej) => {
-      connection.connect(err => {
-        if (err) {
-          return rej(err);
-        }
-        res();
-      });
+  await new Promise((res, rej) => {
+    connection.connect(err => {
+      if (err) {
+        return rej(err);
+      }
+      res();
     });
+  });
 
-    const res = await new Promise((res, rej) => {
-      let result;
-      const req = new Request('SELECT GETUTCDATE()', err => {
-        if (err) {
-          throw err;
-        }
-      });
-      req.on('error', err => {
-        rej(err);
-      });
-      req.on('row', columns => {
-        result = columns;
-      });
-      req.on('requestCompleted', () => {
-        res(result);
-      });
-      connection.execSql(req);
+  const res = await new Promise((res, rej) => {
+    let result;
+    const req = new Request('SELECT GETUTCDATE()', err => {
+      if (err) {
+        throw err;
+      }
+    });
+    req.on('error', err => {
+      rej(err);
+    });
+    req.on('row', columns => {
+      result = columns;
+    });
+    req.on('requestCompleted', () => {
+      res(result);
     });
+    connection.execSql(req);
+  });
 
-    const [{value: utcDateResult}] = res;
-    t.ok(utcDateResult.getTime(), 'should have valid returned date object');
+  const [{value: utcDateResult}] = res;
+  t.ok(utcDateResult.getTime(), 'should have valid returned date object');
 
-    connection.close();
-    connector.close();
-  }
-);
+  connection.close();
+  connector.close();
+});

src/crypto.ts

@@ -13,20 +13,14 @@
 // limitations under the License.
 
 import t from 'tap';
-import semver from 'semver';
 import {Connector} from '@google-cloud/cloud-sql-connector';
+import {Connection, Request} from 'tedious';
 
-t.test(
-  'open connection and run basic sqlserver commands',
-  // the connector-supported versions of tedious do not support node14
-  {skip: semver.lt(process.versions.node, '16.0.0')},
-  async t => {
-  // dynamically load tedious in order to allow for skipping node14
-  const {Connection, Request} = await import('tedious');
+t.test('open connection and run basic sqlserver commands', async t => {
   const connector = new Connector();
   const clientOpts = await connector.getTediousOptions({
     instanceConnectionName: process.env.SQLSERVER_CONNECTION_NAME,
-    ipType: 'PUBLIC'
+    ipType: 'PUBLIC',
   });
   const connection = new Connection({
     server: '0.0.0.0',
@@ -42,29 +36,35 @@ t.test(
       port: 9999,
       database: process.env.SQLSERVER_DB,
     },
-  })
+  });
 
   await new Promise((res, rej) => {
     connection.connect(err => {
       if (err) {
-        return rej(err)
+        return rej(err);
       }
-      res()
-    })
-  })
+      res();
+    });
+  });
 
   const res = await new Promise((res, rej) => {
     let result;
-    const req = new Request('SELECT GETUTCDATE()', (err) => {
+    const req = new Request('SELECT GETUTCDATE()', err => {
       if (err) {
         throw err;
       }
-    })
-    req.on('error', (err) => { rej(err); });
-    req.on('row', (columns) => { result = columns; });
-    req.on('requestCompleted', () => { res(result); });
+    });
+    req.on('error', err => {
+      rej(err);
+    });
+    req.on('row', columns => {
+      result = columns;
+    });
+    req.on('requestCompleted', () => {
+      res(result);
+    });
     connection.execSql(req);
-  })
+  });
 
   const [{value: utcDateResult}] = res;
   t.ok(utcDateResult.getTime(), 'should have valid returned date object');