@vida-global/core 1.4.5 → 2.0.0

package/test/activeRecord/db/schema.test.js

@@ -0,0 +1,217 @@
+jest.mock('../../../lib/activeRecord/db/importSchema', () => jest.fn());
+
+jest.mock('../../../lib/activeRecord/db/connection', () => {
+    const clearConnectionsCache = jest.fn();
+    const allTables             = jest.fn();
+    function Connection() {
+        this.queryInterface = { allTables };
+    }
+    Connection.clearConnectionsCache = clearConnectionsCache;
+    Connection.__allTables           = allTables;
+    return { Connection };
+});
+
+jest.mock('../../../lib/activeRecord/db/connectionConfiguration', () => ({
+    ConnectionConfiguration: { configuredDatabaseIds: jest.fn() }
+}));
+
+jest.mock('../../../lib/activeRecord/utils', () => {
+    const actual = jest.requireActual('../../../lib/activeRecord/utils');
+    return { ...actual, ensureSchemasDirectory: jest.fn() };
+});
+
+const   fs                                                   = require('node:fs');
+const   importSchema                                         = require('../../../lib/activeRecord/db/importSchema');
+const { Connection }                                         = require('../../../lib/activeRecord/db/connection');
+const { ConnectionConfiguration }                            = require('../../../lib/activeRecord/db/connectionConfiguration');
+const   utils                                                = require('../../../lib/activeRecord/utils');
+const { generateActiveRecordSchemaFiles, getActiveRecordSchema } = require('../../../lib/activeRecord/db/schema');
+const { Sequelize }                                          = require('sequelize');
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('activeRecord/db/schema', () => {
+    describe('.getActiveRecordSchema', () => {
+        it ('throws when no schema is found for the table', () => {
+            importSchema.mockImplementation(() => undefined);
+            expect(() => getActiveRecordSchema('users', 'main', 'postgres'))
+                .toThrow('No schema found for table main.users');
+        });
+
+
+        describe('type mapping (cleanSchema → dataTypeForColumn)', () => {
+            it ('maps INTEGER columns to Sequelize.DataTypes.INTEGER', () => {
+                importSchema.mockImplementation(() => ({
+                    id: { type: 'INTEGER', primaryKey: true }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.id.type).toBe(Sequelize.DataTypes.INTEGER);
+            });
+
+            it ('maps BOOLEAN columns to Sequelize.DataTypes.BOOLEAN', () => {
+                importSchema.mockImplementation(() => ({
+                    flag: { type: 'BOOLEAN' }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.flag.type).toBe(Sequelize.DataTypes.BOOLEAN);
+            });
+
+            it ('strips parameterized type modifiers before lookup', () => {
+                importSchema.mockImplementation(() => ({
+                    name: { type: 'INTEGER(10)' }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.name.type).toBe(Sequelize.DataTypes.INTEGER);
+            });
+
+            it ('falls back to STRING when type contains CHAR but is not otherwise matched', () => {
+                importSchema.mockImplementation(() => ({
+                    code: { type: 'NCHARFOO' }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.code.type).toBe(Sequelize.DataTypes.STRING);
+            });
+
+            it ('leaves the original type when no match is found', () => {
+                importSchema.mockImplementation(() => ({
+                    weird: { type: 'COMPLETELY_UNKNOWN_TYPE' }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.weird.type).toBe('COMPLETELY_UNKNOWN_TYPE');
+            });
+        });
+
+
+        describe('autoIncrement resolution', () => {
+            it ('sets autoIncrement and removes defaultValue + allowNull when default is a PG sequence', () => {
+                importSchema.mockImplementation(() => ({
+                    id: {
+                        type:         'INTEGER',
+                        primaryKey:   true,
+                        defaultValue: 'nextval(users_id_seq::regclass)',
+                        allowNull:    false
+                    }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.id.autoIncrement).toBe(true);
+                expect(schema.id).not.toHaveProperty('defaultValue');
+                expect(schema.id).not.toHaveProperty('allowNull');
+            });
+
+            it ('does not modify columns whose defaultValue is not a sequence', () => {
+                importSchema.mockImplementation(() => ({
+                    name: {
+                        type:         'INTEGER',
+                        defaultValue: 'literal',
+                        allowNull:    true
+                    }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.name.autoIncrement).toBeUndefined();
+                expect(schema.name.defaultValue).toBe('literal');
+                expect(schema.name.allowNull).toBe(true);
+            });
+
+            it ('does nothing when there is no defaultValue', () => {
+                importSchema.mockImplementation(() => ({
+                    name: { type: 'INTEGER' }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.name.autoIncrement).toBeUndefined();
+            });
+        });
+
+
+        describe('UUID resolution', () => {
+            it ('sets UUIDV4 default on UUID primary keys whose type stays as the string "UUID"', () => {
+                importSchema.mockImplementation(() => ({
+                    id: { type: 'UUID', primaryKey: true }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                // Whether dataTypeForColumn rewrote the type or not, behavior is observable:
+                // if it stayed as 'UUID', resolveUUIDColumns sets the default.
+                if (schema.id.type === 'UUID') {
+                    expect(schema.id.defaultValue).toBe(Sequelize.UUIDV4);
+                }
+            });
+
+            it ('does not set a UUIDV4 default on UUID columns that are not primary keys', () => {
+                importSchema.mockImplementation(() => ({
+                    ref: { type: 'UUID' }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.ref.defaultValue).toBeUndefined();
+            });
+
+            it ('does not set a UUIDV4 default on non-UUID primary keys', () => {
+                importSchema.mockImplementation(() => ({
+                    id: { type: 'INTEGER', primaryKey: true }
+                }));
+                const schema = getActiveRecordSchema('t', 'main', 'postgres');
+                expect(schema.id.defaultValue).toBeUndefined();
+            });
+        });
+    });
+
+
+    describe('.generateActiveRecordSchemaFiles', () => {
+        let writeFileSpy;
+
+        beforeEach(() => {
+            writeFileSpy = jest.spyOn(fs, 'writeFile').mockImplementation((p, c, cb) => cb && cb(null));
+        });
+
+        afterEach(() => {
+            writeFileSpy.mockRestore();
+        });
+
+        it ('ensures the schemas directory exists before writing', async () => {
+            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue([]);
+            await generateActiveRecordSchemaFiles();
+            expect(utils.ensureSchemasDirectory).toHaveBeenCalledTimes(1);
+        });
+
+        it ('writes one schema file per configured database id', async () => {
+            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue(['main', 'analytics']);
+            Connection.__allTables.mockResolvedValue({ users: { id: { type: 'INTEGER' } } });
+
+            await generateActiveRecordSchemaFiles();
+            expect(Connection.clearConnectionsCache).toHaveBeenCalledTimes(2);
+            expect(writeFileSpy).toHaveBeenCalledTimes(2);
+
+            const writtenPaths = writeFileSpy.mock.calls.map(c => c[0]);
+            expect(writtenPaths[0]).toEqual(`${utils.schemasDirectory}/main.js`);
+            expect(writtenPaths[1]).toEqual(`${utils.schemasDirectory}/analytics.js`);
+
+            const writtenBody = writeFileSpy.mock.calls[0][1];
+            expect(writtenBody).toContain('module.exports = ');
+            expect(writtenBody).toContain('"users"');
+        });
+
+        it ('logs an error when fs.writeFile fails (does not reject)', async () => {
+            const { logger } = require('../../../lib/logger');
+            const errSpy     = jest.spyOn(logger, 'error').mockImplementation(() => {});
+            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue(['main']);
+            Connection.__allTables.mockResolvedValue({});
+            writeFileSpy.mockImplementation((p, c, cb) => cb(new Error('disk full')));
+
+            await generateActiveRecordSchemaFiles();
+            expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Unable to write new schema file'));
+            errSpy.mockRestore();
+        });
+
+        it ('logs success when fs.writeFile succeeds', async () => {
+            const { logger } = require('../../../lib/logger');
+            const infoSpy    = jest.spyOn(logger, 'info').mockImplementation(() => {});
+            ConnectionConfiguration.configuredDatabaseIds.mockReturnValue(['main']);
+            Connection.__allTables.mockResolvedValue({});
+
+            await generateActiveRecordSchemaFiles();
+            expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('New schemas file written'));
+            infoSpy.mockRestore();
+        });
+    });
+});

package/test/activeRecord/helpers/baseRecordMocks.js

@@ -35,15 +35,17 @@ class MockSequelize {
     static DataTypes = {
         [dataTypeKey1]: {types: {postgres: [dataTypeValue1]}, key: dataTypeKey1},
         [dataTypeKey2]: {types: {postgres: [dataTypeValue2]}, key: dataTypeKey2},
-        postgres:       {}
+        postgres:       {},
+        VIRTUAL:        {key: 'VIRTUAL'},
     }
 }
 
 
 const redisClient = {
-    del:  jest.fn(),
-    mGet: jest.fn(),
-    mSet: jest.fn(),
+    del:     jest.fn(),
+    mGet:    jest.fn(),
+    mSet:    jest.fn(),
+    connect: jest.fn(),
 }
 const mockRedisClientFactory = () => redisClient;
 

package/test/activeRecord/helpers/connection.js

@@ -6,8 +6,6 @@ const secondaryConfig = Fixtures.buildPostgresConfig();
 const sslConfig       = Fixtures.buildPostgresConfig({ ssl: true });
 const sqliteConfig    = { dialect: 'sqlite' };
 
-const originalNodeEnv = process.env.NODE_ENV;
-
 
 function buildConfigs() {
     return {
@@ -23,6 +21,5 @@ module.exports = {
     ...Fixtures,
     buildConfigs,
     defaultConfig,
-    originalNodeEnv,
     secondaryConfig,
 };

package/test/activeRecord/helpers/connectionConfiguration.js

@@ -7,13 +7,6 @@ const productionConfig = Fixtures.buildPostgresConfig();
 const sqliteConfig     = { dialect: 'sqlite' };
 
 
-const originalEnv = {
-    dbPoolMin: process.env.DB_POOL_MIN,
-    dbPoolMax: process.env.DB_POOL_MAX,
-    nodeEnv: process.env.NODE_ENV,
-};
-
-
 const fetchConfigsSpy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
 function mockConfigs(configs) {
     fetchConfigsSpy.mockImplementation(() => configs);
@@ -24,7 +17,6 @@ module.exports = {
     fetchConfigsSpy,
     ...Fixtures,
     mockConfigs,
-    originalEnv,
     productionConfig,
     sqliteConfig,
     testConfig,

package/test/activeRecord/utils.test.js

@@ -0,0 +1,72 @@
+const fs    = require('node:fs');
+const utils = require('../../lib/activeRecord/utils');
+
+
+describe('activeRecord/utils', () => {
+    describe('.toCamelCase', () => {
+        it ('converts kebab-case to camelCase', () => {
+            expect(utils.toCamelCase('foo-bar-baz')).toEqual('fooBarBaz');
+        });
+
+        it ('converts snake_case to camelCase', () => {
+            expect(utils.toCamelCase('foo_bar_baz')).toEqual('fooBarBaz');
+        });
+
+        it ('converts space-separated words to camelCase', () => {
+            expect(utils.toCamelCase('foo bar baz')).toEqual('fooBarBaz');
+        });
+
+        it ('handles mixed separators', () => {
+            expect(utils.toCamelCase('foo-bar_baz qux')).toEqual('fooBarBazQux');
+        });
+
+        it ('lowercases the first token even when capitalized', () => {
+            expect(utils.toCamelCase('Foo-Bar')).toEqual('fooBar');
+        });
+
+        it ('returns a single token lowercased', () => {
+            expect(utils.toCamelCase('FOO')).toEqual('foo');
+        });
+
+        it ('returns an empty string when given an empty string', () => {
+            expect(utils.toCamelCase('')).toEqual('');
+        });
+    });
+
+
+    describe('directory ensurers', () => {
+        let mkdirSpy;
+
+        beforeEach(() => {
+            mkdirSpy = jest.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
+        });
+
+        afterEach(() => {
+            mkdirSpy.mockRestore();
+        });
+
+        describe('.ensureConfigDirectory', () => {
+            it ('creates the config directory recursively', () => {
+                utils.ensureConfigDirectory();
+                expect(mkdirSpy).toHaveBeenCalledTimes(1);
+                expect(mkdirSpy).toHaveBeenCalledWith(utils.configDirectory, { recursive: true });
+            });
+        });
+
+        describe('.ensureMigrationsDirectory', () => {
+            it ('creates the migrations directory recursively', () => {
+                utils.ensureMigrationsDirectory();
+                expect(mkdirSpy).toHaveBeenCalledTimes(1);
+                expect(mkdirSpy).toHaveBeenCalledWith(utils.migrationsDirectory, { recursive: true });
+            });
+        });
+
+        describe('.ensureSchemasDirectory', () => {
+            it ('creates the schemas directory recursively', () => {
+                utils.ensureSchemasDirectory();
+                expect(mkdirSpy).toHaveBeenCalledTimes(1);
+                expect(mkdirSpy).toHaveBeenCalledWith(utils.schemasDirectory, { recursive: true });
+            });
+        });
+    });
+});

package/test/apm/agent.test.js

@@ -0,0 +1,56 @@
+const ORIGINAL_ENV = process.env;
+
+
+beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...ORIGINAL_ENV, NODE_ENV: 'test' };
+    delete process.env.NEW_RELIC_LICENSE_KEY;
+});
+
+
+afterEach(() => {
+    process.env = ORIGINAL_ENV;
+});
+
+
+describe('apm/agent', () => {
+    describe('stub client (NEW_RELIC_LICENSE_KEY unset)', () => {
+        it ('reports enabled=false', () => {
+            const { enabled } = require('../../lib/apm/agent');
+
+            expect(enabled).toEqual(false);
+        });
+
+        it ('exposes no-op stubs that accept any arguments', () => {
+            const { client } = require('../../lib/apm/agent');
+
+            expect(() => client.addCustomAttribute('k', 'v')).not.toThrow();
+            expect(() => client.noticeError(new Error('x'), {})).not.toThrow();
+            expect(() => client.recordCustomEvent('Type', { a: 1 })).not.toThrow();
+            expect(() => client.recordMetric('name', 1)).not.toThrow();
+            expect(() => client.setControllerName('C', 'a')).not.toThrow();
+            expect(() => client.setUserID(1)).not.toThrow();
+            expect(() => client.instrumentLoadedModule('pkg', {})).not.toThrow();
+        });
+
+        it ('startBackgroundTransaction invokes the handler and returns its result', () => {
+            const { client } = require('../../lib/apm/agent');
+            const handler    = jest.fn(() => 'bg-result');
+
+            const result = client.startBackgroundTransaction('Job', 'queue', handler);
+
+            expect(handler).toHaveBeenCalledTimes(1);
+            expect(result).toEqual('bg-result');
+        });
+
+        it ('startSegment invokes the handler and returns its result', () => {
+            const { client } = require('../../lib/apm/agent');
+            const handler    = jest.fn(() => 'seg-result');
+
+            const result = client.startSegment('seg', true, handler);
+
+            expect(handler).toHaveBeenCalledTimes(1);
+            expect(result).toEqual('seg-result');
+        });
+    });
+});

package/test/apm/utils.test.js

@@ -0,0 +1,121 @@
+jest.mock('../../lib/apm/agent', () => ({
+    enabled: false,
+    client:  {
+        addCustomAttribute:         jest.fn(),
+        noticeError:                jest.fn(),
+        recordCustomEvent:          jest.fn(),
+        recordMetric:               jest.fn(),
+        setControllerName:          jest.fn(),
+        setUserID:                  jest.fn(),
+        startBackgroundTransaction: jest.fn((name, group, handler) => handler()),
+        startSegment:               jest.fn((name, record, handler) => handler()),
+    },
+}));
+
+
+let utils;
+let agent;
+
+beforeEach(() => {
+    jest.resetModules();
+    utils = require('../../lib/apm/utils');
+    agent = require('../../lib/apm/agent');
+});
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('apm/utils', () => {
+    describe('addCustomAttribute', () => {
+        it ('forwards key and value to the client', () => {
+            utils.addCustomAttribute('foo', 'bar');
+
+            expect(agent.client.addCustomAttribute).toHaveBeenCalledWith('foo', 'bar');
+        });
+    });
+
+
+    describe('reportError', () => {
+        it ('forwards the error and details to noticeError', () => {
+            const err     = new Error('boom');
+            const details = { a: 1 };
+
+            utils.reportError(err, details);
+
+            expect(agent.client.noticeError).toHaveBeenCalledWith(err, details);
+        });
+
+        it ('defaults details to an empty object', () => {
+            const err = new Error('boom');
+
+            utils.reportError(err);
+
+            expect(agent.client.noticeError).toHaveBeenCalledWith(err, {});
+        });
+    });
+
+
+    describe('recordCustomEvent', () => {
+        it ('forwards eventType and attributes to the client', () => {
+            const attrs = { jobName: 'X' };
+
+            utils.recordCustomEvent('JobCompleted', attrs);
+
+            expect(agent.client.recordCustomEvent).toHaveBeenCalledWith('JobCompleted', attrs);
+        });
+    });
+
+
+    describe('recordMetric', () => {
+        it ('forwards name and value to the client', () => {
+            utils.recordMetric('Custom/Worker/foo', 42);
+
+            expect(agent.client.recordMetric).toHaveBeenCalledWith('Custom/Worker/foo', 42);
+        });
+    });
+
+
+    describe('setControllerName', () => {
+        it ('forwards controller and action to the client', () => {
+            utils.setControllerName('Users', 'getIndex');
+
+            expect(agent.client.setControllerName).toHaveBeenCalledWith('Users', 'getIndex');
+        });
+    });
+
+
+    describe('setUserId', () => {
+        it ('forwards id to the client (note the casing difference)', () => {
+            utils.setUserId(123);
+
+            expect(agent.client.setUserID).toHaveBeenCalledWith(123);
+        });
+    });
+
+
+    describe('startBackgroundTransaction', () => {
+        it ('forwards name, group, and handler to the client and returns its result', () => {
+            const handler = jest.fn(() => 'result');
+
+            const result = utils.startBackgroundTransaction('Job', 'queue', handler);
+
+            expect(agent.client.startBackgroundTransaction).toHaveBeenCalledWith('Job', 'queue', handler);
+            expect(result).toEqual('result');
+        });
+    });
+
+
+    describe('startSegment', () => {
+        it ('forwards name, record flag, and handler to the client and returns its result', () => {
+            const handler = jest.fn(() => 'segment-result');
+
+            const result = utils.startSegment('seg', true, handler);
+
+            expect(agent.client.startSegment).toHaveBeenCalledWith('seg', true, handler);
+            expect(result).toEqual('segment-result');
+        });
+    });
+});

package/test/helpers/env.js

@@ -0,0 +1,33 @@
+/***************************************************************************************************
+* ENV SNAPSHOT
+*
+* Captures the current value of the given process.env keys and returns a restore() function that
+* puts them back to their original state. Use in beforeEach/afterEach pairs whenever a test needs
+* to mutate environment variables without leaking changes to other tests.
+*
+*   const restoreEnv = snapshotEnv(['NODE_ENV', 'REDIS_BULL_HOST']);
+*   process.env.NODE_ENV = 'production';
+*   // ...test body...
+*   restoreEnv();
+***************************************************************************************************/
+function snapshotEnv(keys) {
+    const original = {};
+    for (const key of keys) {
+        original[key] = process.env[key];
+    }
+
+    return function restore() {
+        for (const key of keys) {
+            if (original[key] === undefined) {
+                delete process.env[key];
+            } else {
+                process.env[key] = original[key];
+            }
+        }
+    }
+}
+
+
+module.exports = {
+    snapshotEnv,
+}

package/test/http/client.test.js

@@ -10,7 +10,7 @@ afterEach(() => {
 
 beforeEach(() => {
     Helpers.mockFetchSuccess();
-    logger.info = jest.fn();
+    logger.http.debug = jest.fn();
 });
 
 
@@ -60,8 +60,8 @@ describe('HttpClient', () => {
         it ('logs API requests', async () => {
             await client[methodName](Helpers.apiUrl);
 
-            expect(logger.info).toHaveBeenCalledTimes(1);
-            expect(logger.info).toHaveBeenCalledWith(`API CALL: ${httpMethod} ${Helpers.apiUrl}`);
+            expect(logger.http.debug).toHaveBeenCalledTimes(1);
+            expect(logger.http.debug).toHaveBeenCalledWith(`API CALL: ${httpMethod} ${Helpers.apiUrl}`);
         });
 
         if (behavior.supportsBody) {