node-server-engine 1.1.4 → 1.1.6

package/src/utils/dbMigration/migrateMetadataTable/migrateMetadataTable.ts

@@ -1,102 +1,102 @@
-import { Sequelize, QueryTypes } from 'sequelize';
-import { SequelizeMeta } from 'db/models';
-import { reportDebug } from 'utils/report';
-
-const namespace = 'engine:utils:dbMigration';
-
-/**
- * Run migrations on the metadata table
- * The table containing the migrations metadata cannot be handled through migrations
- * Therefore, we use a more classic approach with this function and pure SQL queries
- */
-export async function migrateMetadataTable(
-  sequelize: Sequelize
-): Promise<void> {
-  reportDebug({ namespace, message: 'Executing metadata migration routine' });
-
-  const query = `SELECT table_name FROM information_schema.tables`;
-
-  // We check if we have a custom sequelize_meta table yet
-  const tables = await sequelize.query<Array<string>>(query, {
-    type: QueryTypes.SELECT
-  });
-
-  const hasCustomSequelizeMeta =
-    process.env.SQL_TYPE === 'postgres'
-      ? tables.some((table) => table[0] === 'sequelize_meta')
-      : tables.some((table) => Object.values(table)[0] === 'sequelize_meta');
-  const hasLegacySequelizeMeta =
-    process.env.SQL_TYPE === 'postgres'
-      ? tables.some((table) => table[0] === 'SequelizeMeta')
-      : tables.some((table) => Object.values(table)[0] === 'SequelizeMeta');
-  if (!hasCustomSequelizeMeta) {
-    reportDebug({
-      namespace,
-      message: 'No metadata table found, creating new one'
-    });
-
-    // Define SQL for creating the table based on the database type
-    let createTableQuery = '';
-
-    switch (process.env.SQL_TYPE) {
-      case 'mysql':
-      case 'postgres':
-        createTableQuery = `
-          CREATE TABLE sequelize_meta (
-            name      VARCHAR(100) PRIMARY KEY,
-            version   VARCHAR(25),
-            createdAt TIMESTAMP NOT NULL,
-            updatedAt TIMESTAMP NOT NULL
-          )`;
-        break;
-      case 'mssql':
-        createTableQuery = `
-          CREATE TABLE sequelize_meta (
-            name      VARCHAR(100) PRIMARY KEY,
-            version   VARCHAR(25),
-            createdAt DATETIME NOT NULL,
-            updatedAt DATETIME NOT NULL
-          )`;
-        break;
-      default:
-        throw new Error('Unsupported SQL type');
-    }
-
-    // Create the new sequelize_meta table if it does not exist
-    await sequelize.query(createTableQuery, { type: QueryTypes.RAW });
-
-    // Migrate the data from the old table to the new one if needed
-    if (hasLegacySequelizeMeta) {
-      reportDebug({
-        namespace,
-        message: 'Legacy metadata table found, migrating data'
-      });
-
-      const migrations = await sequelize.query<SequelizeMeta>(
-        'SELECT name FROM SequelizeMeta ORDER BY name',
-        {
-          type: QueryTypes.SELECT
-        }
-      );
-
-      const insertQuery = `
-      INSERT INTO sequelize_meta (name, version, createdAt, updatedAt) VALUES
-        ${migrations
-          .map((migration) => {
-            switch (process.env.SQL_TYPE) {
-              case 'mysql':
-              case 'postgres':
-                return `('${migration.name}', NULL, NOW(), NOW())`;
-              case 'mssql':
-                return `('${migration.name}', NULL, GETDATE(), GETDATE())`;
-              default:
-                throw new Error('Unsupported SQL type');
-            }
-          })
-          .join(',')}
-    `;
-
-      await sequelize.query(insertQuery, { type: QueryTypes.INSERT });
-    }
-  }
-}
+import { Sequelize, QueryTypes } from 'sequelize';
+import { SequelizeMeta } from 'db/models';
+import { reportDebug } from 'utils/report';
+
+const namespace = 'engine:utils:dbMigration';
+
+/**
+ * Run migrations on the metadata table
+ * The table containing the migrations metadata cannot be handled through migrations
+ * Therefore, we use a more classic approach with this function and pure SQL queries
+ */
+export async function migrateMetadataTable(
+  sequelize: Sequelize
+): Promise<void> {
+  reportDebug({ namespace, message: 'Executing metadata migration routine' });
+
+  const query = `SELECT table_name FROM information_schema.tables`;
+
+  // We check if we have a custom sequelize_meta table yet
+  const tables = await sequelize.query<Array<string>>(query, {
+    type: QueryTypes.SELECT
+  });
+
+  const hasCustomSequelizeMeta =
+    process.env.SQL_TYPE === 'postgres'
+      ? tables.some((table) => table[0] === 'sequelize_meta')
+      : tables.some((table) => Object.values(table)[0] === 'sequelize_meta');
+  const hasLegacySequelizeMeta =
+    process.env.SQL_TYPE === 'postgres'
+      ? tables.some((table) => table[0] === 'SequelizeMeta')
+      : tables.some((table) => Object.values(table)[0] === 'SequelizeMeta');
+  if (!hasCustomSequelizeMeta) {
+    reportDebug({
+      namespace,
+      message: 'No metadata table found, creating new one'
+    });
+
+    // Define SQL for creating the table based on the database type
+    let createTableQuery = '';
+
+    switch (process.env.SQL_TYPE) {
+      case 'mysql':
+      case 'postgres':
+        createTableQuery = `
+          CREATE TABLE sequelize_meta (
+            name      VARCHAR(100) PRIMARY KEY,
+            version   VARCHAR(25),
+            createdAt TIMESTAMP NOT NULL,
+            updatedAt TIMESTAMP NOT NULL
+          )`;
+        break;
+      case 'mssql':
+        createTableQuery = `
+          CREATE TABLE sequelize_meta (
+            name      VARCHAR(100) PRIMARY KEY,
+            version   VARCHAR(25),
+            createdAt DATETIME NOT NULL,
+            updatedAt DATETIME NOT NULL
+          )`;
+        break;
+      default:
+        throw new Error('Unsupported SQL type');
+    }
+
+    // Create the new sequelize_meta table if it does not exist
+    await sequelize.query(createTableQuery, { type: QueryTypes.RAW });
+
+    // Migrate the data from the old table to the new one if needed
+    if (hasLegacySequelizeMeta) {
+      reportDebug({
+        namespace,
+        message: 'Legacy metadata table found, migrating data'
+      });
+
+      const migrations = await sequelize.query<SequelizeMeta>(
+        'SELECT name FROM SequelizeMeta ORDER BY name',
+        {
+          type: QueryTypes.SELECT
+        }
+      );
+
+      const insertQuery = `
+      INSERT INTO sequelize_meta (name, version, createdAt, updatedAt) VALUES
+        ${migrations
+          .map((migration) => {
+            switch (process.env.SQL_TYPE) {
+              case 'mysql':
+              case 'postgres':
+                return `('${migration.name}', NULL, NOW(), NOW())`;
+              case 'mssql':
+                return `('${migration.name}', NULL, GETDATE(), GETDATE())`;
+              default:
+                throw new Error('Unsupported SQL type');
+            }
+          })
+          .join(',')}
+    `;
+
+      await sequelize.query(insertQuery, { type: QueryTypes.INSERT });
+    }
+  }
+}

package/src/utils/envAssert/envAssert.ts

@@ -1,31 +1,31 @@
-import { bool, num, host, email, port, url, json } from 'envalid';
-
-import {
-  envIsIpList,
-  envIsPath,
-  envIsHostList,
-  envIsStringList,
-  envIsString
-} from './validators';
-
-/**
- * envalid validators to use with checkEnvironment made with evalid.makeValidator and validator.js
- *  is* functions. + Also Added isString, isHost, and isIPList.
- *
- *
- * envalid docs: https://github.com/af/envalid
- */
-export const envAssert = {
-  isString: envIsString,
-  isBoolean: bool,
-  isNumber: num,
-  isEmail: email,
-  isHost: host,
-  isPort: port,
-  isURL: url,
-  isJSON: json,
-  isIPList: envIsIpList,
-  isPath: envIsPath,
-  isHostList: envIsHostList,
-  isStringList: envIsStringList
-};
+import { bool, num, host, email, port, url, json } from 'envalid';
+
+import {
+  envIsIpList,
+  envIsPath,
+  envIsHostList,
+  envIsStringList,
+  envIsString
+} from './validators';
+
+/**
+ * envalid validators to use with checkEnvironment made with evalid.makeValidator and validator.js
+ *  is* functions. + Also Added isString, isHost, and isIPList.
+ *
+ *
+ * envalid docs: https://github.com/af/envalid
+ */
+export const envAssert = {
+  isString: envIsString,
+  isBoolean: bool,
+  isNumber: num,
+  isEmail: email,
+  isHost: host,
+  isPort: port,
+  isURL: url,
+  isJSON: json,
+  isIPList: envIsIpList,
+  isPath: envIsPath,
+  isHostList: envIsHostList,
+  isStringList: envIsStringList
+};

package/src/utils/envAssert/index.ts

@@ -1 +1 @@
-export * from './envAssert';
+export * from './envAssert';

package/src/utils/envAssert/validators/hostList.ts

@@ -1,17 +1,17 @@
-import { makeValidator } from 'envalid';
-import validator from 'validator';
-
-/**
- * Validate that a string is a list of comma separated host names
- */
-export const envIsHostList = makeValidator((value): boolean => {
-  if (!value) throw new Error('expected a host name');
-  const hosts = value.split(',');
-  const valid = hosts.every(
-    (host) =>
-      validator.isIP(host.trim()) ||
-      validator.isFQDN(host.trim(), { require_tld: false })
-  );
-  if (!valid) throw new Error('expected a host name');
-  return valid;
-});
+import { makeValidator } from 'envalid';
+import validator from 'validator';
+
+/**
+ * Validate that a string is a list of comma separated host names
+ */
+export const envIsHostList = makeValidator((value): boolean => {
+  if (!value) throw new Error('expected a host name');
+  const hosts = value.split(',');
+  const valid = hosts.every(
+    (host) =>
+      validator.isIP(host.trim()) ||
+      validator.isFQDN(host.trim(), { require_tld: false })
+  );
+  if (!valid) throw new Error('expected a host name');
+  return valid;
+});

package/src/utils/envAssert/validators/index.ts

@@ -1,5 +1,5 @@
-export * from './ipList';
-export * from './path';
-export * from './hostList';
-export * from './stringList';
-export * from './string';
+export * from './ipList';
+export * from './path';
+export * from './hostList';
+export * from './stringList';
+export * from './string';

package/src/utils/envAssert/validators/ipList.ts

@@ -1,13 +1,13 @@
-import { makeValidator } from 'envalid';
-import validator from 'validator';
-
-/**
- * Validate that a string is a list of comma separated ip (V4/V6) addresses
- */
-export const envIsIpList = makeValidator((value): boolean => {
-  if (!value) throw new Error('expected an ip address');
-  const ips = value.split(',');
-  const valid = ips.every((v) => validator.isIP(v));
-  if (!valid) throw new Error('expected an ip address');
-  return valid;
-});
+import { makeValidator } from 'envalid';
+import validator from 'validator';
+
+/**
+ * Validate that a string is a list of comma separated ip (V4/V6) addresses
+ */
+export const envIsIpList = makeValidator((value): boolean => {
+  if (!value) throw new Error('expected an ip address');
+  const ips = value.split(',');
+  const valid = ips.every((v) => validator.isIP(v));
+  if (!valid) throw new Error('expected an ip address');
+  return valid;
+});

package/src/utils/envAssert/validators/path.ts

@@ -1,13 +1,13 @@
-import { makeValidator } from 'envalid';
-
-const pathRegex = /^(\.\.\/(?:\.\.\/)*)?(?!.*?\/\/)(?!(?:.*\/)?\.+(?:\/|$)).+$/;
-
-/**
- * Validate that a string is a system path (linux only)
- */
-export const envIsPath = makeValidator((value): boolean => {
-  if (!value) throw new Error('expected a path');
-  const valid = pathRegex.test(value);
-  if (!valid) throw new Error('expected a path');
-  return valid;
-});
+import { makeValidator } from 'envalid';
+
+const pathRegex = /^(\.\.\/(?:\.\.\/)*)?(?!.*?\/\/)(?!(?:.*\/)?\.+(?:\/|$)).+$/;
+
+/**
+ * Validate that a string is a system path (linux only)
+ */
+export const envIsPath = makeValidator((value): boolean => {
+  if (!value) throw new Error('expected a path');
+  const valid = pathRegex.test(value);
+  if (!valid) throw new Error('expected a path');
+  return valid;
+});

package/src/utils/envAssert/validators/string.ts

@@ -1,9 +1,9 @@
-import { makeValidator } from 'envalid';
-
-/**
- * Validate that aa value is a string
- */
-export const envIsString = makeValidator((value): boolean => {
-  if (!value || typeof value !== 'string') throw new Error('expected a string');
-  return value.length > 0;
-});
+import { makeValidator } from 'envalid';
+
+/**
+ * Validate that aa value is a string
+ */
+export const envIsString = makeValidator((value): boolean => {
+  if (!value || typeof value !== 'string') throw new Error('expected a string');
+  return value.length > 0;
+});

package/src/utils/envAssert/validators/stringList.ts

@@ -1,13 +1,13 @@
-import { makeValidator } from 'envalid';
-
-/**
- * Validate that a string is a list of comma separated strings
-
- */
-export const envIsStringList = makeValidator((value): boolean => {
-  if (!value) throw new Error('expected a string');
-  const strings = value.split(',');
-  const valid = strings.every((v) => typeof v === 'string');
-  if (!valid) throw new Error('expected a string');
-  return valid;
-});
+import { makeValidator } from 'envalid';
+
+/**
+ * Validate that a string is a list of comma separated strings
+
+ */
+export const envIsStringList = makeValidator((value): boolean => {
+  if (!value) throw new Error('expected a string');
+  const strings = value.split(',');
+  const valid = strings.every((v) => typeof v === 'string');
+  if (!valid) throw new Error('expected a string');
+  return valid;
+});

package/src/utils/filter/filter.ts

@@ -1,17 +1,17 @@
-/**
- * Filters an object, returns a copy of that object with only the keys specified in the whitelist
- * @param object - The object to filter
- * @param whitelist - A list of keys to keep
- */
-export function filter<T extends Record<string, unknown>>(
-  object: T,
-  whitelist: Array<string>
-): T {
-  const copy: Record<string, unknown> = {};
-  for (const key of Object.keys(object)) {
-    if (whitelist.includes(key)) {
-      copy[key] = object[key];
-    }
-  }
-  return copy as T;
-}
+/**
+ * Filters an object, returns a copy of that object with only the keys specified in the whitelist
+ * @param object - The object to filter
+ * @param whitelist - A list of keys to keep
+ */
+export function filter<T extends Record<string, unknown>>(
+  object: T,
+  whitelist: Array<string>
+): T {
+  const copy: Record<string, unknown> = {};
+  for (const key of Object.keys(object)) {
+    if (whitelist.includes(key)) {
+      copy[key] = object[key];
+    }
+  }
+  return copy as T;
+}

package/src/utils/filter/index.ts

@@ -1 +1 @@
-export * from './filter';
+export * from './filter';

package/src/utils/getDynamicLink/getDynamicLink.test.ts

@@ -1,51 +1,51 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import chai, { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { stub, SinonStub, match } from 'sinon';
-import sinonChai from 'sinon-chai';
-import { getDynamicLink } from './getDynamicLink';
-import { DynamicLinkResponseBody } from './getDynamicLink.types';
-import * as tlsRequest from 'utils/tlsRequest/tlsRequest';
-
-chai.use(sinonChai);
-
-describe('Utils - Get Dynamic Link', () => {
-  let expectedPayload: AxiosRequestConfig;
-  let path: string;
-  let requestStub: SinonStub;
-  let link: string;
-
-  beforeEach(() => {
-    link = faker.internet.url();
-    requestStub = stub(tlsRequest, 'tlsRequest').resolves({
-      data: { link }
-    } as AxiosResponse<DynamicLinkResponseBody>);
-    path = faker.system.directoryPath();
-    expectedPayload = {
-      method: 'get',
-      url: '/link',
-      baseURL: process.env.LINKS_SERVICE_URL,
-      params: {
-        path
-      }
-    };
-  });
-
-  it('should get a dynamic link', async () => {
-    // should return a link from the res
-    const dynamicLink = await getDynamicLink(path);
-    expect(dynamicLink).to.equal(link);
-    expect(requestStub).to.have.been.calledOnceWithExactly(
-      match(expectedPayload)
-    );
-  });
-
-  it('should get a dynamic link with custom settings', async () => {
-    // should return a link from the res
-    const dynamicLink = await getDynamicLink(path, { short: false });
-    expect(dynamicLink).to.equal(link);
-    expect(requestStub).to.have.been.calledOnceWithExactly(
-      match({ ...expectedPayload, params: { path, short: false } })
-    );
-  });
-});
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import chai, { expect } from 'chai';
+import { faker } from '@faker-js/faker';
+import { stub, SinonStub, match } from 'sinon';
+import sinonChai from 'sinon-chai';
+import { getDynamicLink } from './getDynamicLink';
+import { DynamicLinkResponseBody } from './getDynamicLink.types';
+import * as tlsRequest from 'utils/tlsRequest/tlsRequest';
+
+chai.use(sinonChai);
+
+describe('Utils - Get Dynamic Link', () => {
+  let expectedPayload: AxiosRequestConfig;
+  let path: string;
+  let requestStub: SinonStub;
+  let link: string;
+
+  beforeEach(() => {
+    link = faker.internet.url();
+    requestStub = stub(tlsRequest, 'tlsRequest').resolves({
+      data: { link }
+    } as AxiosResponse<DynamicLinkResponseBody>);
+    path = faker.system.directoryPath();
+    expectedPayload = {
+      method: 'get',
+      url: '/link',
+      baseURL: process.env.LINKS_SERVICE_URL,
+      params: {
+        path
+      }
+    };
+  });
+
+  it('should get a dynamic link', async () => {
+    // should return a link from the res
+    const dynamicLink = await getDynamicLink(path);
+    expect(dynamicLink).to.equal(link);
+    expect(requestStub).to.have.been.calledOnceWithExactly(
+      match(expectedPayload)
+    );
+  });
+
+  it('should get a dynamic link with custom settings', async () => {
+    // should return a link from the res
+    const dynamicLink = await getDynamicLink(path, { short: false });
+    expect(dynamicLink).to.equal(link);
+    expect(requestStub).to.have.been.calledOnceWithExactly(
+      match({ ...expectedPayload, params: { path, short: false } })
+    );
+  });
+});

package/src/utils/getDynamicLink/getDynamicLink.ts

@@ -1,28 +1,28 @@
-import { AxiosRequestConfig } from 'axios';
-import {
-  getDynamicLinksOptions,
-  DynamicLinkResponseBody
-} from './getDynamicLink.types';
-import { validateDynamicLinkEnvironment } from './getDynamicLink.validate';
-import { tlsRequest } from 'utils/tlsRequest';
-
-/** Fetch a dynamic link from the links service */
-export async function getDynamicLink(
-  path: string,
-  options: getDynamicLinksOptions = {}
-): Promise<string> {
-  validateDynamicLinkEnvironment();
-  const option: AxiosRequestConfig = {
-    method: 'get',
-    url: '/link',
-    baseURL: process.env.LINKS_SERVICE_URL,
-    params: {
-      path,
-      short: options.short ?? true
-    }
-  };
-  const {
-    data: { link }
-  } = await tlsRequest<DynamicLinkResponseBody>(option);
-  return link;
-}
+import { AxiosRequestConfig } from 'axios';
+import {
+  getDynamicLinksOptions,
+  DynamicLinkResponseBody
+} from './getDynamicLink.types';
+import { validateDynamicLinkEnvironment } from './getDynamicLink.validate';
+import { tlsRequest } from 'utils/tlsRequest';
+
+/** Fetch a dynamic link from the links service */
+export async function getDynamicLink(
+  path: string,
+  options: getDynamicLinksOptions = {}
+): Promise<string> {
+  validateDynamicLinkEnvironment();
+  const option: AxiosRequestConfig = {
+    method: 'get',
+    url: '/link',
+    baseURL: process.env.LINKS_SERVICE_URL,
+    params: {
+      path,
+      short: options.short ?? true
+    }
+  };
+  const {
+    data: { link }
+  } = await tlsRequest<DynamicLinkResponseBody>(option);
+  return link;
+}

package/src/utils/getDynamicLink/getDynamicLink.types.ts

@@ -1,11 +1,11 @@
-/** Options to fetch dynamic links */
-export interface getDynamicLinksOptions {
-  /** Make a shortened link */
-  short?: boolean;
-}
-
-/** Dynamic link query server response */
-export interface DynamicLinkResponseBody {
-  /** The generated dynamic link */
-  link: string;
-}
+/** Options to fetch dynamic links */
+export interface getDynamicLinksOptions {
+  /** Make a shortened link */
+  short?: boolean;
+}
+
+/** Dynamic link query server response */
+export interface DynamicLinkResponseBody {
+  /** The generated dynamic link */
+  link: string;
+}

package/src/utils/getDynamicLink/getDynamicLink.validate.ts

@@ -1,6 +1,6 @@
-import { assertEnvironment, envAssert } from 'utils';
-
-/** Environment variable validator for get dynamic link from LinkService */
-export function validateDynamicLinkEnvironment(): void {
-  assertEnvironment({ LINKS_SERVICE_URL: envAssert.isURL() });
-}
+import { assertEnvironment, envAssert } from 'utils';
+
+/** Environment variable validator for get dynamic link from LinkService */
+export function validateDynamicLinkEnvironment(): void {
+  assertEnvironment({ LINKS_SERVICE_URL: envAssert.isURL() });
+}