@vida-global/core 1.4.5 → 1.4.6

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/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/logger/serverMiddleware.test.js

@@ -0,0 +1,73 @@
+jest.mock('express-winston', () => {
+    return {
+        logger: jest.fn(() => jest.fn()) // returns a noop middleware
+    };
+});
+
+const expressWinston = require('express-winston');
+
+// Loading the module triggers expressWinston.logger(options) — capturing options gives us
+// access to the otherwise-unexported msgFormatter
+require('../../lib/logger/serverMiddleware');
+
+const options       = expressWinston.logger.mock.calls[0][0];
+const msgFormatter  = options.msg;
+
+
+describe('logger/serverMiddleware', () => {
+    describe('msgFormatter', () => {
+        const baseRes = (overrides = {}) => ({
+            statusCode: 200,
+            _header:    'HTTP/1.1 200 OK\nX-Response-Time: 12ms\nContent-Type: application/json',
+            ...overrides
+        });
+
+        const baseReq = (overrides = {}) => ({
+            method: 'GET',
+            url:    '/api/things',
+            ip:     '127.0.0.1',
+            ...overrides
+        });
+
+        it ('uses Controller#action when req.controller is set', () => {
+            class FooController {}
+            const req = baseReq({ controller: new FooController(), action: 'getIndex' });
+            const res = baseRes();
+            const msg = msgFormatter(req, res);
+            expect(msg).toContain('FooController#getIndex');
+            expect(msg).toContain('req: GET /api/things for 127.0.0.1');
+            // The header parser splits on /:(.*)/, preserving the space after the colon —
+            // hence "responseTime= 12ms" rather than "responseTime=12ms".
+            expect(msg).toContain('res: statusCode=200 responseTime= 12ms');
+        });
+
+        it ('uses "request completed" when no controller and statusCode < 500', () => {
+            const msg = msgFormatter(baseReq(), baseRes({ statusCode: 200 }));
+            expect(msg).toContain('request completed');
+        });
+
+        it ('uses "request errored" when no controller and statusCode >= 500', () => {
+            const msg = msgFormatter(baseReq(), baseRes({ statusCode: 503 }));
+            expect(msg).toContain('request errored');
+        });
+
+        it ('strips the query string from the request URL', () => {
+            const req = baseReq({ url: '/api/things?limit=10&q=foo' });
+            const msg = msgFormatter(req, baseRes());
+            expect(msg).toContain('req: GET /api/things for 127.0.0.1');
+            expect(msg).not.toContain('limit=10');
+        });
+
+        it ('appends the error stack when res.error is present', () => {
+            const err = new Error('boom');
+            err.stack = 'Error: boom\n    at somewhere';
+            const msg = msgFormatter(baseReq(), baseRes({ error: err }));
+            expect(msg).toContain('Error: boom\n    at somewhere');
+        });
+
+        it ('does not append a stack when there is no res.error', () => {
+            const msg = msgFormatter(baseReq(), baseRes());
+            expect(msg).not.toContain('Error:');
+        });
+    });
+});

package/test/server/apiDocsGenerator.test.js

@@ -0,0 +1,38 @@
+const { ApiDocsGenerator } = require('../../lib/server/apiDocsGenerator');
+
+
+describe('ApiDocsGenerator', () => {
+    let generator;
+
+    beforeEach(() => {
+        generator = new ApiDocsGenerator({ controllerDirectories: [] });
+    });
+
+
+    describe('#formatEndpoint', () => {
+        it ('replaces a single :param with {param}', () => {
+            expect(generator.formatEndpoint({ path: '/users/:id' })).toEqual('/users/{id}');
+        });
+
+        it ('replaces multiple :params with {params}', () => {
+            expect(generator.formatEndpoint({ path: '/users/:userId/posts/:postId' }))
+                .toEqual('/users/{userId}/posts/{postId}');
+        });
+
+        it ('returns the path unchanged when there are no params', () => {
+            expect(generator.formatEndpoint({ path: '/users' })).toEqual('/users');
+        });
+
+        it ('handles a trailing :param', () => {
+            expect(generator.formatEndpoint({ path: '/foo/bar/:baz' })).toEqual('/foo/bar/{baz}');
+        });
+
+        it ('handles an empty path', () => {
+            expect(generator.formatEndpoint({ path: '' })).toEqual('');
+        });
+
+        it ('only replaces up to the next slash', () => {
+            expect(generator.formatEndpoint({ path: '/a/:x/b/:y' })).toEqual('/a/{x}/b/{y}');
+        });
+    });
+});

package/test/server/server.test.js

@@ -5,17 +5,39 @@ const { Request }       = require('jest-express/lib/request');
 const { Response }      = require('jest-express/lib/response');
 const { TestServer }    = require('./helpers/server');
 const { VidaServer }    = require('../../lib/server');
+const   express         = require('express');
+const   IoServer        = require('socket.io');
+const { Server: HttpServer } = require('http');
+
+
+const lastApp = () => express.__instances[express.__instances.length - 1];
 
 
 jest.mock('express', () => {
-    const   express    = require('jest-express');
-    const { Response } = require('jest-express/lib/response');
+    const   jestExpress = require('jest-express');
+    const { Response }  = require('jest-express/lib/response');
 
     // missing functions in mock express
     Response.prototype.on = jest.fn();
-    express.raw           = jest.fn();
 
-    return express;
+    // Wrap the factory so tests can inspect the most recently created Express app.
+    const instances = [];
+    const wrapped   = (...args) => {
+        const app = jestExpress(...args);
+        instances.push(app);
+        return app;
+    };
+    Object.assign(wrapped, jestExpress);
+    wrapped.raw         = jest.fn();
+    wrapped.__instances = instances;
+
+    return wrapped;
+});
+
+jest.mock('socket.io', () => jest.fn());
+jest.mock('http', () => {
+    const actual = jest.requireActual('http');
+    return { ...actual, Server: jest.fn() };
 });
 
 
@@ -187,4 +209,164 @@ describe('VidaServer', () => {
             expect(afterSpy5).toHaveBeenCalledTimes(0);
         });
     });
+
+
+    describe('VidaServer#listen', () => {
+        it ('starts the http server on the configured host/port and invokes the callback', async () => {
+            const fakeHttpServer = { listen: jest.fn((port, host, cb) => cb()) };
+            HttpServer.mockReturnValueOnce(fakeHttpServer);
+
+            const server   = new TestServer({ port: 4321, host: '0.0.0.0' });
+            const callback = jest.fn();
+            jest.spyOn(server, 'registerControllers').mockResolvedValue();
+
+            await server.listen(callback);
+            expect(fakeHttpServer.listen).toHaveBeenCalledWith(4321, '0.0.0.0', expect.any(Function));
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does not require a callback', async () => {
+            const fakeHttpServer = { listen: jest.fn((port, host, cb) => cb()) };
+            HttpServer.mockReturnValueOnce(fakeHttpServer);
+
+            const server = new TestServer({ port: 5000, host: 'localhost' });
+            jest.spyOn(server, 'registerControllers').mockResolvedValue();
+
+            await expect(server.listen()).resolves.toBeUndefined();
+            expect(fakeHttpServer.listen).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
+    describe('VidaServer#corsOrigins', () => {
+        it ('defaults to an empty array', () => {
+            expect(new TestServer().corsOrigins).toEqual([]);
+        });
+    });
+
+
+    describe('VidaServer#viewsDirectory / staticFilesDirectory', () => {
+        it ('returns absolute paths under cwd', () => {
+            const server = new TestServer();
+            expect(server.viewsDirectory).toEqual(`${process.cwd()}/views`);
+            expect(server.staticFilesDirectory).toEqual(`${process.cwd()}/static`);
+        });
+    });
+
+
+    describe('VidaServer#controllerDirectories (default)', () => {
+        it ('returns cwd/controllers when not overridden', () => {
+            const server = new VidaServer();
+            expect(server.controllerDirectories).toEqual([`${process.cwd()}/controllers`]);
+        });
+    });
+
+
+    describe('VidaServer#connectionAbortedMiddleware', () => {
+        it ('short-circuits with a 400 when err.code === ECONNABORTED', async () => {
+            const server     = new TestServer();
+            const middleware = server.connectionAbortedMiddleware;
+            const status     = jest.fn().mockReturnValue({ end: jest.fn() });
+            const res        = { status };
+            const next       = jest.fn();
+
+            await middleware({ code: 'ECONNABORTED' }, {}, res, next);
+            expect(status).toHaveBeenCalledWith(400);
+            expect(next).not.toHaveBeenCalled();
+        });
+
+        it ('calls next() for other errors', async () => {
+            const server     = new TestServer();
+            const middleware = server.connectionAbortedMiddleware;
+            const next       = jest.fn();
+
+            await middleware(new Error('something else'), {}, {}, next);
+            expect(next).toHaveBeenCalledTimes(1);
+        });
+
+        it ('calls next() when there is no error', async () => {
+            const server     = new TestServer();
+            const middleware = server.connectionAbortedMiddleware;
+            const next       = jest.fn();
+
+            await middleware(null, {}, {}, next);
+            expect(next).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
+    describe('VidaServer HTTP verb wrappers', () => {
+        const verbs = ['get', 'post', 'put', 'delete', 'patch', 'head'];
+
+        it.each(verbs)('_%s delegates to express app.%s', (verb) => {
+            const server  = new TestServer();
+            const handler = jest.fn();
+            const app     = lastApp();
+            app[verb].mockClear();
+
+            server[`_${verb}`]('/path', handler);
+            expect(app[verb]).toHaveBeenCalledWith('/path', handler);
+        });
+    });
+
+
+    describe('VidaServer deprecated routing methods', () => {
+        const verbs = ['get', 'post', 'put', 'patch', 'head', 'delete'];
+
+        it.each(verbs)('%s emits a DeprecationWarning and delegates to express app.%s', (verb) => {
+            const emitSpy = jest.spyOn(process, 'emitWarning').mockImplementation(() => {});
+            try {
+                const server  = new TestServer();
+                const handler = jest.fn();
+                const app     = lastApp();
+                app[verb].mockClear();
+
+                server[verb]('/path', handler);
+                expect(emitSpy).toHaveBeenCalledWith(expect.stringContaining(`\`${verb}\` is deprecated`), 'DeprecationWarning');
+                expect(app[verb]).toHaveBeenCalledWith('/path', handler);
+            } finally {
+                emitSpy.mockRestore();
+            }
+        });
+
+        it ('only emits the warning once per method name', () => {
+            const emitSpy = jest.spyOn(process, 'emitWarning').mockImplementation(() => {});
+            try {
+                const server = new TestServer();
+                server.post('/a', jest.fn());
+                server.post('/b', jest.fn());
+                server.post('/c', jest.fn());
+
+                const postWarnings = emitSpy.mock.calls.filter(c => c[0].includes('`post`'));
+                expect(postWarnings).toHaveLength(1);
+            } finally {
+                emitSpy.mockRestore();
+            }
+        });
+    });
+
+
+    describe('VidaServer web socket helpers', () => {
+        let fakeIo;
+        let server;
+
+        beforeEach(() => {
+            fakeIo = { to: jest.fn(() => fakeIo), emit: jest.fn(), on: jest.fn() };
+            IoServer.mockReturnValueOnce(fakeIo);
+            HttpServer.mockReturnValueOnce({ listen: jest.fn() });
+            server = new TestServer();
+        });
+
+        it ('emitWebSocketEvent forwards channel/event/data to the io server', () => {
+            server.emitWebSocketEvent('chan', 'evt', { hello: 'world' });
+            expect(fakeIo.to).toHaveBeenCalledWith('chan');
+            expect(fakeIo.emit).toHaveBeenCalledWith('evt', { hello: 'world' });
+        });
+
+        it ('addWebSocketEventHandler registers the handler on the io server', () => {
+            const handler = jest.fn();
+            server.addWebSocketEventHandler('connection', handler);
+            expect(fakeIo.on).toHaveBeenCalledWith('connection', handler);
+        });
+    });
 });