chadstart 1.0.0

package/test/error-reporter.test.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const assert = require('assert');
+
+describe('error-reporter', () => {
+  const reporter = require('../core/error-reporter');
+
+  afterEach(() => {
+    // Reset module state and env between tests
+    reporter._reset();
+    delete process.env.SENTRY_DSN;
+  });
+
+  it('does nothing when SENTRY_DSN is not set', () => {
+    reporter.initErrorReporter({});
+    assert.strictEqual(reporter.getSentry(), null);
+  });
+
+  it('getRequestHandler returns null when not initialised', () => {
+    assert.strictEqual(reporter.getRequestHandler(), null);
+  });
+
+  it('getErrorHandler returns null when not initialised', () => {
+    assert.strictEqual(reporter.getErrorHandler(), null);
+  });
+
+  it('attachErrorHandler is a no-op when not initialised', () => {
+    let called = false;
+    reporter.attachErrorHandler({ use: () => { called = true; } });
+    assert.strictEqual(called, false, 'app.use should not have been called');
+  });
+
+  it('getSentry returns null when not initialised', () => {
+    assert.strictEqual(reporter.getSentry(), null);
+  });
+
+  it('initialises Sentry when SENTRY_DSN is set', () => {
+    process.env.SENTRY_DSN = 'https://test@sentry.io/1';
+
+    const calls = [];
+    // Stub @sentry/node by temporarily overriding require cache
+    const sentryStub = {
+      init: (opts) => calls.push(opts),
+      setupExpressErrorHandler: () => {},
+    };
+    const Module = require('module');
+    const origLoad = Module._load;
+    Module._load = function (request, parent, isMain) {
+      if (request === '@sentry/node') return sentryStub;
+      return origLoad.call(this, request, parent, isMain);
+    };
+
+    try {
+      reporter.initErrorReporter({ sentry: { environment: 'test', tracesSampleRate: 0.5 } });
+      assert.strictEqual(calls.length, 1);
+      assert.strictEqual(calls[0].dsn, 'https://test@sentry.io/1');
+      assert.strictEqual(calls[0].environment, 'test');
+      assert.strictEqual(calls[0].tracesSampleRate, 0.5);
+      assert.strictEqual(reporter.getSentry(), sentryStub);
+    } finally {
+      Module._load = origLoad;
+      reporter._reset();
+    }
+  });
+
+  it('uses NODE_ENV as environment when sentry.environment is not set', () => {
+    process.env.SENTRY_DSN = 'https://test@sentry.io/2';
+    const prevNodeEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'staging';
+
+    const calls = [];
+    const sentryStub = {
+      init: (opts) => calls.push(opts),
+      setupExpressErrorHandler: () => {},
+    };
+    const Module = require('module');
+    const origLoad = Module._load;
+    Module._load = function (request, parent, isMain) {
+      if (request === '@sentry/node') return sentryStub;
+      return origLoad.call(this, request, parent, isMain);
+    };
+
+    try {
+      reporter.initErrorReporter({});
+      assert.strictEqual(calls[0].environment, 'staging');
+    } finally {
+      Module._load = origLoad;
+      process.env.NODE_ENV = prevNodeEnv;
+      reporter._reset();
+    }
+  });
+
+  it('defaults tracesSampleRate to 1.0 when not configured', () => {
+    process.env.SENTRY_DSN = 'https://test@sentry.io/3';
+
+    const calls = [];
+    const sentryStub = {
+      init: (opts) => calls.push(opts),
+      setupExpressErrorHandler: () => {},
+    };
+    const Module = require('module');
+    const origLoad = Module._load;
+    Module._load = function (request, parent, isMain) {
+      if (request === '@sentry/node') return sentryStub;
+      return origLoad.call(this, request, parent, isMain);
+    };
+
+    try {
+      reporter.initErrorReporter({});
+      assert.strictEqual(calls[0].tracesSampleRate, 1.0);
+    } finally {
+      Module._load = origLoad;
+      reporter._reset();
+    }
+  });
+
+  it('attachErrorHandler calls setupExpressErrorHandler on the app', () => {
+    process.env.SENTRY_DSN = 'https://test@sentry.io/4';
+    let attached = false;
+    const sentryStub = {
+      init: () => {},
+      setupExpressErrorHandler: () => { attached = true; },
+    };
+    const Module = require('module');
+    const origLoad = Module._load;
+    Module._load = function (request, parent, isMain) {
+      if (request === '@sentry/node') return sentryStub;
+      return origLoad.call(this, request, parent, isMain);
+    };
+
+    try {
+      reporter.initErrorReporter({});
+      reporter.attachErrorHandler({});
+      assert.ok(attached, 'setupExpressErrorHandler should have been called');
+    } finally {
+      Module._load = origLoad;
+      reporter._reset();
+    }
+  });
+});

package/test/functions-engine.test.js

@@ -0,0 +1,240 @@
+'use strict';
+
+const assert = require('assert');
+const path   = require('path');
+const fs     = require('fs');
+const os     = require('os');
+const http   = require('http');
+const express = require('express');
+
+const { resolveSchedule, setupFunctions, cleanup, eventBus } = require('../core/functions-engine');
+
+// ── resolveSchedule ────────────────────────────────────────────────────────────
+
+describe('functions-engine – resolveSchedule', () => {
+  it('maps @yearly  → 0 0 1 1 *', () => assert.strictEqual(resolveSchedule('@yearly'),  '0 0 1 1 *'));
+  it('maps @annually → 0 0 1 1 *', () => assert.strictEqual(resolveSchedule('@annually'),'0 0 1 1 *'));
+  it('maps @monthly → 0 0 1 * *',  () => assert.strictEqual(resolveSchedule('@monthly'), '0 0 1 * *'));
+  it('maps @weekly  → 0 0 * * 0',  () => assert.strictEqual(resolveSchedule('@weekly'),  '0 0 * * 0'));
+  it('maps @daily   → 0 0 * * *',  () => assert.strictEqual(resolveSchedule('@daily'),   '0 0 * * *'));
+  it('maps @midnight → 0 0 * * *', () => assert.strictEqual(resolveSchedule('@midnight'),'0 0 * * *'));
+  it('maps @hourly  → 0 * * * *',  () => assert.strictEqual(resolveSchedule('@hourly'),  '0 * * * *'));
+  it('passes through standard cron expressions unchanged', () => {
+    assert.strictEqual(resolveSchedule('*/10 * * * *'), '*/10 * * * *');
+  });
+});
+
+// ── HTTP trigger ───────────────────────────────────────────────────────────────
+
+describe('functions-engine – HTTP trigger', () => {
+  let server, port, fnDir;
+
+  before(async () => {
+    cleanup();
+    fnDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cs-fn-'));
+    fs.writeFileSync(path.join(fnDir, 'greet.js'), `module.exports = async function(event, ctx) { return { msg: 'hi', trigger: ctx.trigger }; };`);
+
+    process.env.CHADSTART_FUNCTIONS_FOLDER = fnDir;
+
+    const app = express();
+    app.use(express.json());
+    setupFunctions(app, {
+      greet: {
+        runtime: 'js',
+        function: 'greet.js',
+        triggers: [{ type: 'http', method: 'GET', path: '/greet' }],
+      },
+    });
+
+    server = http.createServer(app);
+    await new Promise((r) => server.listen(0, '127.0.0.1', r));
+    port = server.address().port;
+  });
+
+  after(async () => {
+    cleanup();
+    await new Promise((r) => server.close(r));
+    delete process.env.CHADSTART_FUNCTIONS_FOLDER;
+    fs.rmSync(fnDir, { recursive: true, force: true });
+  });
+
+  it('GET /greet returns function result', async () => {
+    const res  = await fetch(`http://127.0.0.1:${port}/greet`);
+    const body = await res.json();
+    assert.strictEqual(res.status, 200);
+    assert.strictEqual(body.msg, 'hi');
+    assert.strictEqual(body.trigger, 'http');
+  });
+});
+
+// ── Event trigger ──────────────────────────────────────────────────────────────
+
+describe('functions-engine – event trigger', () => {
+  let fnDir;
+
+  before(() => {
+    cleanup();
+    fnDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cs-fn-'));
+    fs.writeFileSync(path.join(fnDir, 'onMyEvent.js'), `
+      module.exports = async function(event, ctx) { global.__csTestPayload = event; };
+    `);
+    process.env.CHADSTART_FUNCTIONS_FOLDER = fnDir;
+
+    setupFunctions(null, {
+      myEventFn: {
+        runtime: 'js',
+        function: 'onMyEvent.js',
+        triggers: [{ type: 'event', name: 'test-event' }],
+      },
+    });
+  });
+
+  after(() => {
+    cleanup();
+    delete process.env.CHADSTART_FUNCTIONS_FOLDER;
+    delete global.__csTestPayload;
+    fs.rmSync(fnDir, { recursive: true, force: true });
+  });
+
+  it('emitting an event invokes the registered function', async () => {
+    global.__csTestPayload = null;
+    eventBus.emit('test-event', { value: 42 });
+    await new Promise((r) => setTimeout(r, 100));
+    assert.deepStrictEqual(global.__csTestPayload, { value: 42 });
+  });
+});
+
+// ── HTTP trigger with policies ─────────────────────────────────────────────────
+
+describe('functions-engine – HTTP trigger policies', () => {
+  let server, port, fnDir;
+  const jwt = require('jsonwebtoken');
+  const JWT_SECRET = process.env.JWT_SECRET || process.env.TOKEN_SECRET_KEY || 'chadstart-dev-secret-change-in-production';
+
+  before(async () => {
+    cleanup();
+    fnDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cs-fn-'));
+    fs.writeFileSync(path.join(fnDir, 'ok.js'), `module.exports = async function() { return { ok: true }; };`);
+
+    process.env.CHADSTART_FUNCTIONS_FOLDER = fnDir;
+
+    const app = express();
+    app.use(express.json());
+    setupFunctions(app, {
+      publicFn:     { function: 'ok.js', triggers: [{ type: 'http', method: 'GET', path: '/pub',       policies: [{ access: 'public'     }] }] },
+      defaultFn:    { function: 'ok.js', triggers: [{ type: 'http', method: 'GET', path: '/default'                                         }] },
+      adminFn:      { function: 'ok.js', triggers: [{ type: 'http', method: 'GET', path: '/admin',     policies: [{ access: 'admin'      }] }] },
+      forbiddenFn:  { function: 'ok.js', triggers: [{ type: 'http', method: 'GET', path: '/forbidden', policies: [{ access: 'forbidden'  }] }] },
+      restrictedFn: { function: 'ok.js', triggers: [{ type: 'http', method: 'GET', path: '/restricted', policies: [{ access: 'restricted', allow: 'Customer' }] }] },
+    });
+
+    server = http.createServer(app);
+    await new Promise((r) => server.listen(0, '127.0.0.1', r));
+    port = server.address().port;
+  });
+
+  after(async () => {
+    cleanup();
+    await new Promise((r) => server.close(r));
+    delete process.env.CHADSTART_FUNCTIONS_FOLDER;
+    fs.rmSync(fnDir, { recursive: true, force: true });
+  });
+
+  function makeToken(entity) {
+    return jwt.sign({ id: 'test-id', entity }, JWT_SECRET, { expiresIn: '1h' });
+  }
+
+  it('public policy: allows unauthenticated requests', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/pub`);
+    assert.strictEqual(res.status, 200);
+    const body = await res.json();
+    assert.strictEqual(body.ok, true);
+  });
+
+  it('no policy (default): allows unauthenticated requests', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/default`);
+    assert.strictEqual(res.status, 200);
+  });
+
+  it('admin policy: rejects unauthenticated request with 401', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/admin`);
+    assert.strictEqual(res.status, 401);
+  });
+
+  it('admin policy: allows any valid JWT', async () => {
+    const token = makeToken('Admin');
+    const res = await fetch(`http://127.0.0.1:${port}/admin`, { headers: { Authorization: `Bearer ${token}` } });
+    assert.strictEqual(res.status, 200);
+  });
+
+  it('forbidden policy: always returns 403', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/forbidden`);
+    assert.strictEqual(res.status, 403);
+  });
+
+  it('restricted policy: rejects unauthenticated request with 401', async () => {
+    const res = await fetch(`http://127.0.0.1:${port}/restricted`);
+    assert.strictEqual(res.status, 401);
+  });
+
+  it('restricted policy: rejects token from wrong entity with 403', async () => {
+    const token = makeToken('Admin');
+    const res = await fetch(`http://127.0.0.1:${port}/restricted`, { headers: { Authorization: `Bearer ${token}` } });
+    assert.strictEqual(res.status, 403);
+  });
+
+  it('restricted policy: allows token from correct entity', async () => {
+    const token = makeToken('Customer');
+    const res = await fetch(`http://127.0.0.1:${port}/restricted`, { headers: { Authorization: `Bearer ${token}` } });
+    assert.strictEqual(res.status, 200);
+    const body = await res.json();
+    assert.strictEqual(body.ok, true);
+  });
+});
+
+
+describe('functions-engine – JS format auto-detection', () => {
+  let server, port, fnDir;
+
+  before(async () => {
+    cleanup();
+    fnDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cs-fn-'));
+    fs.writeFileSync(path.join(fnDir, 'universal.js'), `
+      module.exports = async function(event, ctx) {
+        if (ctx.trigger === 'http') return { format: 'universal' };
+      };
+    `);
+    fs.writeFileSync(path.join(fnDir, 'lambda.js'), `
+      exports.handler = async (event, context) => ({ statusCode: 200, body: JSON.stringify({ format: 'lambda' }) });
+    `);
+
+    process.env.CHADSTART_FUNCTIONS_FOLDER = fnDir;
+    const app = express();
+    app.use(express.json());
+    setupFunctions(app, {
+      universal: { function: 'universal.js', triggers: [{ type: 'http', method: 'GET', path: '/universal' }] },
+      lambda:    { function: 'lambda.js',    triggers: [{ type: 'http', method: 'GET', path: '/lambda'    }] },
+    });
+    server = http.createServer(app);
+    await new Promise((r) => server.listen(0, '127.0.0.1', r));
+    port = server.address().port;
+  });
+
+  after(async () => {
+    cleanup();
+    await new Promise((r) => server.close(r));
+    delete process.env.CHADSTART_FUNCTIONS_FOLDER;
+    fs.rmSync(fnDir, { recursive: true, force: true });
+  });
+
+  it('universal format function responds correctly', async () => {
+    const body = await fetch(`http://127.0.0.1:${port}/universal`).then((r) => r.json());
+    assert.strictEqual(body.format, 'universal');
+  });
+
+  it('AWS Lambda format function is auto-detected and responds correctly', async () => {
+    const body = await fetch(`http://127.0.0.1:${port}/lambda`).then((r) => r.json());
+    assert.strictEqual(body.format, 'lambda');
+  });
+});
+

package/test/groups.test.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { buildCore } = require('../core/entity-engine');
+const dbModule = require('../core/db');
+const { validateBody, deserializeGroupProps } = require('../core/api-generator');
+
+describe('groups – serialization / deserialization', () => {
+  const groupEntity = {
+    properties: [
+      { name: 'testimonials', type: 'group', options: { group: 'Testimonial' } },
+      { name: 'callToAction', type: 'group', options: { group: 'CallToAction', multiple: false } },
+      { name: 'title', type: 'string' },
+    ],
+    belongsTo: [],
+  };
+
+  it('deserializeGroupProps: parses JSON string to array for multiple group', () => {
+    const items = [{ author: 'Alice', rating: 5 }, { author: 'Bob', rating: 4 }];
+    const row = { id: '1', testimonials: JSON.stringify(items), title: 'hi' };
+    const result = deserializeGroupProps(row, groupEntity);
+    assert.deepStrictEqual(result.testimonials, items);
+    assert.strictEqual(result.title, 'hi');
+  });
+
+  it('deserializeGroupProps: parses JSON string to object for single group', () => {
+    const cta = { title: 'Buy now', buttonText: 'Go' };
+    const row = { id: '1', callToAction: JSON.stringify(cta) };
+    const result = deserializeGroupProps(row, groupEntity);
+    assert.deepStrictEqual(result.callToAction, cta);
+  });
+
+  it('deserializeGroupProps: leaves non-string group values unchanged', () => {
+    const items = [{ author: 'Alice' }];
+    const row = { id: '1', testimonials: items };
+    const result = deserializeGroupProps(row, groupEntity);
+    assert.deepStrictEqual(result.testimonials, items);
+  });
+
+  it('deserializeGroupProps: handles invalid JSON gracefully (leaves as string)', () => {
+    const row = { id: '1', testimonials: 'not-json' };
+    const result = deserializeGroupProps(row, groupEntity);
+    assert.strictEqual(result.testimonials, 'not-json');
+  });
+
+  it('deserializeGroupProps: is a no-op when no group properties exist', () => {
+    const simpleEntity = { properties: [{ name: 'title', type: 'string' }] };
+    const row = { id: '1', title: 'hello' };
+    const result = deserializeGroupProps(row, simpleEntity);
+    assert.deepStrictEqual(result, row);
+  });
+
+  it('deserializeGroupProps: returns row unchanged when row is null', () => {
+    assert.strictEqual(deserializeGroupProps(null, groupEntity), null);
+  });
+});
+
+describe('groups – validateBody with group validation', () => {
+  const groups = {
+    Testimonial: {
+      properties: [
+        { name: 'author', type: 'text' },
+        { name: 'rating', type: 'number' },
+      ],
+      validation: { rating: { isNotEmpty: true } },
+    },
+    CallToAction: {
+      properties: [
+        { name: 'title', type: 'string' },
+        { name: 'description', type: 'text' },
+      ],
+      validation: {
+        title: { isNotEmpty: true },
+        description: { isNotEmpty: true },
+      },
+    },
+  };
+
+  const entityWithGroup = {
+    properties: [
+      { name: 'name', type: 'string' },
+      { name: 'testimonials', type: 'group', options: { group: 'Testimonial' } },
+    ],
+    validation: {},
+  };
+
+  it('validateBody: passes when group items satisfy validation', () => {
+    const body = { name: 'Service A', testimonials: [{ author: 'Alice', rating: 5 }, { author: 'Bob', rating: 4 }] };
+    assert.strictEqual(validateBody(body, entityWithGroup, groups).errors, null);
+  });
+
+  it('validateBody: fails when a group item violates validation', () => {
+    const body = { name: 'Service A', testimonials: [{ author: 'Alice', rating: 5 }, { author: 'Bob', rating: '' }] };
+    const result = validateBody(body, entityWithGroup, groups);
+    assert.ok(result.errors, 'should have errors');
+    assert.ok(result.errors.some((e) => e.property.startsWith('testimonials[1]')));
+  });
+
+  it('validateBody: skips group validation when group value is absent', () => {
+    const body = { name: 'Service A' };
+    assert.strictEqual(validateBody(body, entityWithGroup, groups).errors, null);
+  });
+
+  it('validateBody: skips group validation when no groups map provided', () => {
+    const body = { name: 'Service A', testimonials: [{ author: 'Alice', rating: '' }] };
+    assert.strictEqual(validateBody(body, entityWithGroup).errors, null);
+  });
+
+  it('validateBody: single (non-multiple) group validates the object directly', () => {
+    const ctaEntity = {
+      properties: [
+        { name: 'callToAction', type: 'group', options: { group: 'CallToAction', multiple: false } },
+      ],
+      validation: {},
+    };
+    const badBody = { callToAction: { title: '', description: 'desc' } };
+    const result = validateBody(badBody, ctaEntity, groups);
+    assert.ok(result.errors, 'should have errors for empty title');
+    assert.ok(result.errors.some((e) => e.property === 'callToAction.title'),
+      `expected callToAction.title, got: ${JSON.stringify(result.errors.map((e) => e.property))}`);
+
+    const goodBody = { callToAction: { title: 'Act now', description: 'Do it' } };
+    assert.strictEqual(validateBody(goodBody, ctaEntity, groups).errors, null);
+  });
+});
+
+describe('groups – seeder generates group values', () => {
+  let tmp;
+  const groupSeedCore = buildCore({
+    name: 'GroupSeedTest',
+    entities: {
+      Service: {
+        properties: [
+          { name: 'name', type: 'string' },
+          { name: 'testimonials', type: 'group', options: { group: 'Testimonial' } },
+          { name: 'callToAction', type: 'group', options: { group: 'CallToAction', multiple: false } },
+        ],
+        seedCount: 3,
+      },
+    },
+    groups: {
+      Testimonial: {
+        properties: [
+          { name: 'author', type: 'text' },
+          { name: 'content', type: 'text' },
+          { name: 'rating', type: 'number' },
+        ],
+      },
+      CallToAction: {
+        properties: [
+          { name: 'title', type: 'string' },
+          { name: 'buttonText', type: 'string' },
+        ],
+      },
+    },
+  });
+
+  before(() => {
+    tmp = path.join(os.tmpdir(), `chadstart-group-seed-${Date.now()}.db`);
+    dbModule.initDb(groupSeedCore, tmp);
+  });
+
+  after(() => { fs.unlinkSync(tmp); });
+
+  it('seeder: group property stores valid JSON array for multiple group', async () => {
+    const { seedAll } = require('../core/seeder');
+    const result = await seedAll(groupSeedCore);
+    assert.strictEqual(result.summary.Service, 3);
+
+    const rows = dbModule.findAll('service', {}, { perPage: 100 });
+    assert.strictEqual(rows.total, 3);
+
+    for (const row of rows.data) {
+      assert.ok(typeof row.testimonials === 'string', 'testimonials should be stored as string');
+      const items = JSON.parse(row.testimonials);
+      assert.ok(Array.isArray(items), 'testimonials should parse to array');
+      assert.ok(items.length >= 1, 'testimonials should have at least one item');
+      assert.ok('author' in items[0], 'each item should have author');
+      assert.ok('rating' in items[0], 'each item should have rating');
+
+      assert.ok(typeof row.callToAction === 'string', 'callToAction should be stored as string');
+      const cta = JSON.parse(row.callToAction);
+      assert.ok(cta && typeof cta === 'object' && !Array.isArray(cta), 'callToAction should parse to object');
+      assert.ok('title' in cta, 'callToAction should have title');
+    }
+  });
+
+  it('seeder: group with no matching group definition stores empty JSON array', async () => {
+    const { seedAll } = require('../core/seeder');
+    const coreNoGroupDef = buildCore({
+      name: 'NoGroupDef',
+      entities: {
+        Item: {
+          properties: [{ name: 'stuff', type: 'group', options: { group: 'Missing' } }],
+          seedCount: 1,
+        },
+      },
+      groups: {},
+    });
+    const tmpNoGroup = path.join(os.tmpdir(), `chadstart-nogrp-${Date.now()}.db`);
+    dbModule.initDb(coreNoGroupDef, tmpNoGroup);
+    const result = await seedAll(coreNoGroupDef);
+    assert.strictEqual(result.summary.Item, 1);
+    const rows = dbModule.findAll('item', {}, { perPage: 10 });
+    assert.ok(typeof rows.data[0].stuff === 'string');
+    assert.deepStrictEqual(JSON.parse(rows.data[0].stuff), []);
+    fs.unlinkSync(tmpNoGroup);
+  });
+});