node-server-engine 1.4.9 → 1.5.1

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

@@ -1,59 +0,0 @@
-// import {expect} from 'chai';
-// import { faker } from '@faker-js/faker';
-// import {QueryTypes} from 'sequelize';
-// import {testRecreateDB} from '../dbMigration';
-// import {migrateMetadataTable} from './migrateMetadataTable';
-// import {sequelize} from 'entities/Sequelize';
-
-// describe('Utils - DB Migration - Migrate Metadata Table', function () {
-//   before(async () => {
-//     sequelize.init();
-//     await testRecreateDB({clean: true});
-//   });
-
-//   afterEach(async () => {
-//     await testRecreateDB({clean: true});
-//   });
-
-//   // it('should create the metadata table if it does not exist', async () => {
-//   //   await migrateMetadataTable(sequelize);
-
-//   //   const tables = await sequelize.query<[string]>(
-//   //     "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'",
-//   //     {type: QueryTypes.SELECT},
-//   //   );
-//   //   const hasTable = tables.some((table) => table[0] === 'sequelize_meta');
-//   //   expect(hasTable).to.be.true;
-//   // });
-
-//   it('should copy legacy table data to the new table', async () => {
-//     await sequelize.query('CREATE TABLE SequelizeMeta (name varchar(100) PRIMARY KEY)', {
-//       type: QueryTypes.RAW,
-//     });
-
-//     const migrations = [faker.lorem.word(), faker.lorem.word(), faker.lorem.word()];
-//     await sequelize.query(
-//       `INSERT INTO "SequelizeMeta" ("name") VALUES ('${migrations[0]}'), ('${migrations[1]}'), ('${migrations[2]}')`,
-//       {
-//         type: QueryTypes.RAW,
-//       },
-//     );
-
-//     await migrateMetadataTable(sequelize);
-
-//     const results = await sequelize.query<{
-//       /** Name of the migration */
-//       name: string;
-//       /** Version at which the migration was executed */
-//       version: string;
-//     }>('SELECT * FROM sequelize_meta', {
-//       type: QueryTypes.SELECT,
-//     });
-
-//     expect(results).to.have.length(3);
-//     results.forEach((result) => {
-//       expect(migrations).to.include(result.name);
-//       expect(result.version).to.be.null;
-//     });
-//   });
-// });

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

@@ -1,102 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-export * from './envAssert';

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

@@ -1,17 +0,0 @@
-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 +0,0 @@
-export * from './ipList';
-export * from './path';
-export * from './hostList';
-export * from './stringList';
-export * from './string';

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

@@ -1,13 +0,0 @@
-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 +0,0 @@
-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 +0,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 +0,0 @@
-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 +0,0 @@
-/**
- * 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 +0,0 @@
-export * from './filter';

package/src/utils/geminiFileUpload/geminiFileUpload.ts

@@ -1,93 +0,0 @@
-import { GoogleAIFileManager } from '@google/generative-ai/server';
-import fs from 'fs';
-import path from 'path';
-import tmp from 'tmp';
-import { reportError, reportDebug } from 'utils/report';
-
-const namespace = 'engine:utils:geminiFileUpload';
-
-const fileManager = new GoogleAIFileManager(process.env.GOOGLE_AI_KEY || '');
-
-export async function geminiFileUpload(
-  buffer: Buffer,
-  mimeType: string,
-  originalName: string
-): Promise<
-  | { success: true; originalname: string; fileUri: string; mimeType: string }
-  | { success: false; error: unknown }
-> {
-  let tempFile;
-  try {
-    // 1. Create Temp File
-    tempFile = tmp.fileSync({ postfix: path.extname(originalName) });
-    fs.writeFileSync(tempFile.name, buffer);
-
-    // 2. Upload File
-    const uploadResult = await fileManager.uploadFile(tempFile.name, {
-      mimeType,
-      displayName: originalName
-    });
-
-    if (!uploadResult || !uploadResult.file) {
-      throw new Error('Upload failed: No file returned');
-    }
-
-    const file = uploadResult.file;
-    reportDebug({
-      namespace,
-      message: 'Uploaded file successfully',
-      data: { displayName: file.displayName, name: file.name }
-    });
-
-    reportDebug({
-      namespace,
-      message: 'Waiting for file processing...'
-    });
-
-    // 3. Poll Until File is Processed
-    let geminiFile = await fileManager.getFile(file.name);
-    while (geminiFile?.state === 'PROCESSING') {
-      process.stdout.write('.');
-      await new Promise((resolve) => setTimeout(resolve, 10000));
-      geminiFile = await fileManager.getFile(file.name);
-    }
-
-    if (!geminiFile || geminiFile.state !== 'ACTIVE') {
-      const errorMessage = `File processing failed for ${file.name}`;
-      reportError(errorMessage);
-      return { success: false, error: new Error(errorMessage) };
-    }
-
-    reportDebug({
-      namespace,
-      message: 'File is ready'
-    });
-
-    return {
-      success: true,
-      originalname: file.name,
-      fileUri: file.uri,
-      mimeType: file.mimeType
-    };
-  } catch (error) {
-    reportError({
-      namespace,
-      message: 'Error during Gemini file upload and processing',
-      error
-    });
-    return { success: false, error };
-  } finally {
-    // Ensure cleanup of temp file
-    if (tempFile) {
-      try {
-        tempFile.removeCallback();
-      } catch (cleanupError) {
-        reportError({
-          namespace,
-          message: 'Error cleaning up temp file',
-          error: cleanupError
-        });
-      }
-    }
-  }
-}

package/src/utils/geminiFileUpload/index.ts

@@ -1 +0,0 @@
-export * from './geminiFileUpload';

package/src/utils/hmac/checkEnv/checkEnv.test.ts

@@ -1,18 +0,0 @@
-import { expect } from 'chai';
-import { assertPayloadSignatureSecret } from './checkEnv';
-
-describe('Utils - HMAC - Check environment', () => {
-  it('should pass if environment variables are set', () => {
-    process.env.PAYLOAD_SIGNATURE_SECRET = 'secret';
-    expect(() => {
-      assertPayloadSignatureSecret();
-    }).to.not.throw();
-  });
-
-  it('should throw an error if the environment vairable is not set', () => {
-    delete process.env.PAYLOAD_SIGNATURE_SECRET;
-    expect(() => {
-      assertPayloadSignatureSecret();
-    }).to.throw();
-  });
-});

package/src/utils/hmac/checkEnv/checkEnv.ts

@@ -1,9 +0,0 @@
-import { assertEnvironment } from 'utils/checkEnvironment';
-import { envAssert } from 'utils/envAssert';
-
-/**
- * Check that secret used to sign payloads is properly set in the environment
- */
-export function assertPayloadSignatureSecret(): void {
-  assertEnvironment({ PAYLOAD_SIGNATURE_SECRET: envAssert.isString() });
-}

package/src/utils/hmac/checkEnv/index.ts

@@ -1 +0,0 @@
-export * from './checkEnv';

package/src/utils/hmac/createHmac/createHmac.ts

@@ -1,33 +0,0 @@
-import crypto from 'crypto';
-import { assertPayloadSignatureSecret } from '../checkEnv';
-import { HmacOptions } from '../index.types';
-import { createSortedObject } from 'utils/createSortedObject';
-
-/** Calculates the HMAC signature for a given payload */
-export function createHmac(
-  payload: unknown,
-  options: HmacOptions = {}
-): Buffer | string {
-  // Check env if no secret is specified
-  if (!options.secret) {
-    assertPayloadSignatureSecret();
-  }
-  // Set default values
-  const settings = {
-    algorithm: options.algorithm ?? 'sha512',
-    sort: options.sort ?? true,
-    encode: options.encode,
-    secret: options.secret ?? (process.env.PAYLOAD_SIGNATURE_SECRET as string)
-  };
-
-  // Stringify the payload
-  const sortedPayload = settings.sort ? createSortedObject(payload) : payload;
-  const stringifiedPayload = JSON.stringify(sortedPayload);
-
-  // Calculate the hash
-  const hmac = crypto
-    .createHmac(settings.algorithm, settings.secret)
-    .update(stringifiedPayload);
-
-  return settings.encode ? hmac.digest(settings.encode) : hmac.digest();
-}

package/src/utils/hmac/createHmac/index.ts

@@ -1 +0,0 @@
-export * from './createHmac';

package/src/utils/hmac/index.ts

@@ -1,4 +0,0 @@
-export * from './signPayload';
-export * from './verifySignature';
-export * from './createHmac';
-export * from './index.types';

package/src/utils/hmac/index.types.ts

@@ -1,13 +0,0 @@
-import { BinaryToTextEncoding } from 'crypto';
-
-/** HMAC calculation options  */
-export interface HmacOptions {
-  /** Secret used to sign the payload */
-  secret?: string;
-  /** Hashing algorithm to use (default: SHA-512) */
-  algorithm?: string;
-  /** Should the object keys be sorted alphabetically (default: true) */
-  sort?: boolean;
-  /** The encoding of the signature (default: base64) */
-  encode?: BinaryToTextEncoding;
-}

package/src/utils/hmac/signPayload/index.ts

@@ -1 +0,0 @@
-export * from './signPayload';

package/src/utils/hmac/signPayload/signPayload.ts

@@ -1,16 +0,0 @@
-import { createHmac } from '../createHmac';
-import { HmacOptions } from '../index.types';
-
-/** Add signature to a payload */
-export function signPayload<T>(
-  payload: T,
-  options: HmacOptions = {}
-): T & {
-  /** HMAC signature of the payload */
-  signature: string;
-} {
-  return {
-    ...payload,
-    signature: createHmac(payload, { ...options, encode: 'base64' }) as string
-  };
-}

package/src/utils/hmac/verifySignature/index.ts

@@ -1 +0,0 @@
-export * from './verifySignature';

package/src/utils/hmac/verifySignature/verifySignature.ts

@@ -1,24 +0,0 @@
-import crypto from 'crypto';
-import { createHmac } from '../createHmac';
-import { HmacOptions } from '../index.types';
-
-/** Checks the signature of a payload */
-export function verifySignature(
-  payload: Record<string, unknown>,
-  signature: string,
-  options: HmacOptions = {}
-): boolean {
-  if (!payload || !signature) return false;
-  // Obtain a buffer digest
-  const digest = createHmac(payload, {
-    ...options,
-    encode: undefined
-  }) as Buffer;
-  // Transform the signature to buffer
-  const checksum = Buffer.from(signature, options.encode ?? 'base64');
-  // Compare signature with the calculated digest
-  return (
-    checksum.length === digest.length &&
-    crypto.timingSafeEqual(digest, checksum)
-  );
-}

package/src/utils/index.ts

@@ -1,29 +0,0 @@
-// general
-export * from './report';
-export * from './filter';
-export * from './semverCompare';
-export * from './dbMigration';
-
-// env
-export * from './checkEnvironment';
-export * from './envAssert';
-
-// auth
-export * from './createSortedObject';
-export * from './jwt';
-export * from './hmac';
-
-// Networking
-export * from './createHttpServer';
-export * from './request';
-export * from './tlsConfig';
-export * from './sendPush';
-export * from './sendEmail';
-
-// String manipulation
-export * from './trimPathSlash';
-
-export * from './secretManager';
-
-// File Upload
-export * from './geminiFileUpload';

package/src/utils/jwt/index.ts

@@ -1,2 +0,0 @@
-export * from './jwt';
-export * from './jwt.types';

package/src/utils/jwt/jwt.test.ts

@@ -1,28 +0,0 @@
-import { randomUUID } from 'crypto';
-import { generateAccessToken } from 'backend-test-tools';
-import { expect } from 'chai';
-import { faker } from '@faker-js/faker';
-import { jwtVerify } from './jwt';
-import { TokenIssuer } from 'const';
-
-describe('Utils - JWT', () => {
-  it('should pass a default token', async () => {
-    const id = randomUUID();
-    const token = generateAccessToken(id);
-    const result = await jwtVerify(token);
-    expect(result.sub).to.equal(id);
-  });
-
-  it('should pass a token with one correct audience [Auth-service]', async () => {
-    const id = randomUUID();
-    const token = generateAccessToken(id, {
-      audience: [
-        process.env.ACCESS_TOKEN_AUDIENCE as string,
-        faker.lorem.word()
-      ],
-      issuer: process.env.ACCESS_TOKEN_ISSUER
-    });
-    const result = await jwtVerify(token, TokenIssuer.AUTH_SERVICE);
-    expect(result.sub).to.equal(id);
-  });
-});