@omega.js/backend 0.1.0

package/test/routes/admin/infer-contact.test.js

@@ -0,0 +1,220 @@
+/**
+ * Test: POST /admin/infer-contact
+ * Tests the admin infer-contact endpoint for inferring names from email addresses
+ *
+ * AI inference tests only run when TEST_EXTENDED_MODE is set (requires OPENAI_API_KEY)
+ */
+
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+module.exports = defineCases({
+  description: 'Admin infer contact',
+  type: 'group',
+  tests: [
+    // ─── Auth rejection ───
+
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 401, 'Should reject unauthenticated requests');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'user',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 403, 'Should reject non-admin users');
+      },
+    },
+
+    // ─── Single email ───
+
+    {
+      name: 'single-email-returns-result',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isSuccess(response, 'Should succeed for admin');
+        assert.hasProperty(response, 'data.results', 'Should have results array');
+        assert.equal(response.data.results.length, 1, 'Should have 1 result');
+
+        const result = response.data.results[0];
+        assert.equal(result.email, 'john.smith@gmail.com', 'Should include email');
+        assert.hasProperty(result, 'firstName', 'Should have firstName field');
+        assert.hasProperty(result, 'lastName', 'Should have lastName field');
+        assert.hasProperty(result, 'method', 'Should include method');
+        assert.hasProperty(result, 'confidence', 'Should include confidence');
+        assert.equal(result.method, 'ai', 'Should use AI method');
+      },
+    },
+
+    // ─── Batch emails ───
+
+    {
+      name: 'batch-emails-returns-all-results',
+      auth: 'admin',
+      timeout: 60000,
+
+      async run({ http, assert }) {
+        const emails = [
+          'sarah.connor@skynet.io',
+          'bob-jones@hotmail.com',
+          'admin@acme.com',
+        ];
+
+        const response = await http.post('backend-manager/admin/infer-contact', { emails });
+
+        assert.isSuccess(response, 'Should succeed for batch');
+        assert.equal(response.data.results.length, 3, 'Should have 3 results');
+
+        // Verify each email is in results
+        for (let i = 0; i < emails.length; i++) {
+          assert.equal(response.data.results[i].email, emails[i], `Result ${i} should match input email`);
+        }
+      },
+    },
+
+    // ─── Name parsing (requires AI) ───
+
+    {
+      name: 'regex-parses-dot-separated-names',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        // Use a name unlikely to trigger the "fictional/brand" rejection in the AI prompt.
+        // The infer-contact prompt rejects placeholder + fictional names (e.g. alice.wonderland,
+        // john.doe). Use a generic-but-realistic name to exercise dot-separated parsing.
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'sarah.martinez@example.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+
+        assert.equal(result.firstName, 'Sarah', 'Should parse first name');
+        assert.equal(result.lastName, 'Martinez', 'Should parse last name');
+      },
+    },
+
+    {
+      name: 'infers-company-from-custom-domain',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'ceo@my-startup.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.ok(result.company, 'Should infer company from custom domain');
+      },
+    },
+
+    {
+      name: 'no-company-from-generic-domain',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'someone@gmail.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.equal(result.company, '', 'Should not infer company from gmail');
+      },
+    },
+
+    // ─── AI inference (requires TEST_EXTENDED_MODE) ───
+
+    {
+      name: 'ai-inference',
+      auth: 'admin',
+      timeout: 60000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping AI inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          emails: [
+            'john.smith@microsoft.com',
+            'xkcd42@gmail.com',
+            'bobs.burgers@example.com',
+          ],
+        });
+
+        assert.isSuccess(response, 'AI inference should succeed');
+
+        const results = response.data.results;
+        assert.equal(results.length, 3, 'Should have 3 results');
+
+        // Verify structure — AI may return empty names but shape must be correct
+        for (const r of results) {
+          assert.hasProperty(r, 'firstName', `${r.email}: should have firstName`);
+          assert.hasProperty(r, 'lastName', `${r.email}: should have lastName`);
+          assert.hasProperty(r, 'method', `${r.email}: should have method`);
+          assert.hasProperty(r, 'confidence', `${r.email}: should have confidence`);
+        }
+
+        // john.smith@microsoft.com — AI should parse this but may flake
+        const john = results.find(r => r.email === 'john.smith@microsoft.com');
+        assert.equal(john.method, 'ai', 'Should use AI method');
+        if (!john.firstName) {
+          console.warn('AI flake: john.smith@microsoft.com returned empty firstName (non-fatal)');
+        }
+      },
+    },
+
+    // ─── Edge cases ───
+
+    {
+      name: 'empty-emails-array-returns-empty',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          emails: [],
+        });
+
+        assert.isSuccess(response);
+        assert.equal(response.data.results.length, 0, 'Empty input should return empty results');
+      },
+    },
+  ],
+});

package/test/routes/admin/notification.test.js

@@ -0,0 +1,199 @@
+/**
+ * Test: POST /admin/notification
+ * Tests the admin send notification (FCM) endpoint
+ * Requires admin authentication
+ */
+const { TEST_DATA } = require('../../../dist/test/test-accounts.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  description: 'Admin send notification (FCM)',
+  type: 'group',
+  tests: [
+    // Test 1: Admin can call send-notification with no subscribers
+    {
+      name: 'admin-succeeds-empty-collection',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: '@omega.js/backend Test Notification',
+            body: 'Testing from @omega.js/backend test suite',
+            clickAction: 'https://example.com/test',
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification should succeed for admin');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+        assert.hasProperty(response, 'data.deleted', 'Response should have deleted count');
+      },
+    },
+
+    // Test 2: Notification with owner filter
+    {
+      name: 'with-owner-filter',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: 'Filtered Notification',
+            body: 'Testing owner filter',
+          },
+          filters: {
+            owner: TEST_DATA.filterUid,
+            limit: 10,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with filters should succeed');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+      },
+    },
+
+    // Test 3: Notification with tags filter
+    {
+      name: 'with-tags-filter',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: 'Tagged Notification',
+            body: 'Testing tags filter',
+          },
+          filters: {
+            tags: ['test-tag', 'another-tag'],
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with tags filter should succeed');
+      },
+    },
+
+    // Test 4: Notification with limit filter
+    {
+      name: 'with-limit-filter',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: 'Limited Notification',
+            body: 'Testing limit filter',
+          },
+          filters: {
+            limit: 5,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with limit should succeed');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+      },
+    },
+
+    // Test 5: Default notification values applied when notification is omitted
+    {
+      name: 'default-values-applied',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        // Omit notification entirely to test schema defaults are applied
+        const response = await http.post('backend-manager/admin/notification', {
+          filters: {
+            limit: 1,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with defaults should succeed');
+      },
+    },
+
+    // Test 6: Send to real FCM token (requires TEST_FCM_TOKEN env var)
+    {
+      name: 'send-to-real-token',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_FCM_TOKEN ? 'TEST_FCM_TOKEN env var not set' : false,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: '@omega.js/backend Test Notification',
+            body: `Test sent at ${new Date().toISOString()}`,
+            clickAction: `https://${config.domain}/?test-notification=true`,
+          },
+          filters: {
+            token: process.env.TEST_FCM_TOKEN,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification to real token should succeed');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+      },
+    },
+
+    // Test 7: Send to fake token (API succeeds, FCM fails silently)
+    {
+      name: 'fake-token-api-succeeds',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: 'Fake Token Test',
+            body: 'Testing with invalid token',
+          },
+          filters: {
+            token: 'fake-invalid-token-for-testing',
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification to fake token should succeed API-wise');
+      },
+    },
+
+    // Test 8: Unauthenticated request fails
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: 'Test Notification',
+            body: 'This is a test',
+          },
+        });
+
+        assert.isError(response, 401, 'Send notification should fail without authentication');
+      },
+    },
+
+    // Test 9: Non-admin user fails
+    {
+      name: 'non-admin-rejected',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/notification', {
+          notification: {
+            title: 'Test Notification',
+            body: 'This is a test',
+          },
+        });
+
+        assert.isError(response, 403, 'Send notification should fail for non-admin user');
+      },
+    },
+  ],
+});

package/test/routes/admin/post-convert-image.test.js

@@ -0,0 +1,159 @@
+/**
+ * Test: routes/admin/post/post.convertToJpeg + applyImageCDNParams
+ * Unit tests for non-JPG ingest conversion and CDN pre-scale params used by
+ * the admin/post route.
+ *
+ * Run (from the framework repo): npm test routes/admin/post-convert-image
+ *
+ * Contract:
+ *   - png/webp downloads are converted in place to progressive JPEG at
+ *     IMAGE_JPEG_QUALITY; the result's path/filename/ext all become .jpg and
+ *     the original file is removed.
+ *   - Alpha channels are flattened onto white (JPEG has no transparency).
+ *   - applyImageCDNParams adds w/q params for Unsplash and w/auto params for
+ *     Pexels (without clobbering params already present), and leaves other
+ *     hosts untouched.
+ */
+const os = require('os');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const sharp = require('sharp');
+
+const post = require('../../../dist/manager/routes/admin/post/post');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const { convertToJpeg, applyImageCDNParams, IMAGE_MAX_DIMENSION } = post;
+
+// Generate a synthetic image of the given format and write it to a tmp path.
+async function makeImage(format, options) {
+  const filepath = path.join(os.tmpdir(), `backend-test-convert-${Date.now()}-${Math.random().toString(36).slice(2)}.${format}`);
+  const buffer = await sharp({
+    create: {
+      width: 640,
+      height: 480,
+      channels: options?.alpha ? 4 : 3,
+      background: options?.alpha
+        ? { r: 200, g: 50, b: 50, alpha: 0.5 }
+        : { r: 200, g: 50, b: 50 },
+    },
+  })[format]()
+    .toBuffer();
+
+  jetpack.write(filepath, buffer);
+  return filepath;
+}
+
+// Minimal ctx stub — convertToJpeg only uses Manager.require + log.
+function makeAssistant() {
+  return {
+    log: () => {},
+    Manager: {
+      require: (mod) => require(mod),
+    },
+  };
+}
+
+module.exports = defineCases({
+  description: 'routes/admin/post/post.convertToJpeg + applyImageCDNParams',
+  type: 'group',
+
+  tests: [
+    // ─── convertToJpeg ───
+
+    {
+      name: 'png-converts-to-jpg',
+      async run({ assert }) {
+        const filepath = await makeImage('png');
+        const result = { path: filepath, filename: path.basename(filepath), ext: '.png' };
+
+        await convertToJpeg(makeAssistant(), result);
+
+        assert.equal(result.ext, '.jpg', 'ext should become .jpg');
+        assert.ok(result.path.endsWith('.jpg'), 'path should end with .jpg');
+        assert.ok(result.filename.endsWith('.jpg'), 'filename should end with .jpg');
+        assert.ok(jetpack.exists(result.path), 'converted file should exist');
+        assert.equal(jetpack.exists(filepath), false, 'original .png should be removed');
+
+        const meta = await sharp(result.path).metadata();
+        assert.equal(meta.format, 'jpeg', 'on-disk format should be JPEG');
+        assert.equal(meta.width, 640, 'dimensions should be preserved');
+
+        jetpack.remove(result.path);
+      },
+    },
+
+    {
+      name: 'webp-converts-to-jpg',
+      async run({ assert }) {
+        const filepath = await makeImage('webp');
+        const result = { path: filepath, filename: path.basename(filepath), ext: '.webp' };
+
+        await convertToJpeg(makeAssistant(), result);
+
+        assert.equal(result.ext, '.jpg', 'ext should become .jpg');
+        const meta = await sharp(result.path).metadata();
+        assert.equal(meta.format, 'jpeg', 'on-disk format should be JPEG');
+        assert.equal(jetpack.exists(filepath), false, 'original .webp should be removed');
+
+        jetpack.remove(result.path);
+      },
+    },
+
+    {
+      name: 'alpha-png-flattens-onto-white',
+      async run({ assert }) {
+        const filepath = await makeImage('png', { alpha: true });
+        const result = { path: filepath, filename: path.basename(filepath), ext: '.png' };
+
+        await convertToJpeg(makeAssistant(), result);
+
+        const meta = await sharp(result.path).metadata();
+        assert.equal(meta.format, 'jpeg', 'on-disk format should be JPEG');
+        assert.equal(meta.channels, 3, 'alpha channel should be gone');
+
+        // 50%-alpha red over white ≈ light red — the green/blue channels must be
+        // well above 0 (a black flatten would leave them near 25).
+        const { channels } = await sharp(result.path).stats();
+        assert.ok(channels[1].mean > 100, `green mean should reflect a white flatten (got ${Math.round(channels[1].mean)})`);
+
+        jetpack.remove(result.path);
+      },
+    },
+
+    // ─── applyImageCDNParams ───
+
+    {
+      name: 'unsplash-gets-w-and-q-params',
+      async run({ assert }) {
+        const out = new URL(applyImageCDNParams('https://images.unsplash.com/photo-123'));
+        assert.equal(out.searchParams.get('w'), String(IMAGE_MAX_DIMENSION), 'w param should be the max dimension');
+        assert.ok(out.searchParams.get('q'), 'q param should be set');
+      },
+    },
+
+    {
+      name: 'pexels-gets-w-and-auto-params',
+      async run({ assert }) {
+        const out = new URL(applyImageCDNParams('https://images.pexels.com/photos/416405/pexels-photo-416405.jpeg'));
+        assert.equal(out.searchParams.get('w'), String(IMAGE_MAX_DIMENSION), 'w param should be the max dimension');
+        assert.equal(out.searchParams.get('auto'), 'compress', 'auto=compress should be set');
+      },
+    },
+
+    {
+      name: 'existing-params-are-not-clobbered',
+      async run({ assert }) {
+        const out = new URL(applyImageCDNParams('https://images.pexels.com/photos/1/a.jpeg?w=800'));
+        assert.equal(out.searchParams.get('w'), '800', 'an existing w param should be preserved');
+      },
+    },
+
+    {
+      name: 'other-hosts-untouched',
+      async run({ assert }) {
+        const src = 'https://cdn.pixabay.com/photo/2024/01/01/example.jpg';
+        assert.equal(applyImageCDNParams(src), src, 'hosts without CDN param support should pass through unchanged');
+      },
+    },
+  ],
+});

package/test/routes/admin/post-deploy-flag.test.js

@@ -0,0 +1,81 @@
+/**
+ * Test: admin/post schemas carry the D13 deploy flag
+ *
+ * Regression: the schemas didn't declare `deploy`, and unknown keys are
+ * stripped at validation (middleware's includeNonSchemaSettings defaults
+ * false) — so `deploy: false` could NEVER reach dispatch-deploy and the
+ * documented opt-out was dead on arrival. These resolve the REAL schema
+ * modules through Settings.resolve (same direct-schema seam as
+ * test/helpers/schema-zod.js) and pin the contract: absent → true,
+ * explicit false → false.
+ *
+ * Run: npx omega test backend:routes/admin/post-deploy-flag
+ */
+const Settings = require('../../../dist/manager/helpers/settings.js');
+const createSchema = require('../../../dist/manager/schemas/admin/post/post.js');
+const editSchema = require('../../../dist/manager/schemas/admin/post/put.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+// Settings.resolve only touches these surfaces when the schema is passed
+// directly (no file loading) — the seam test/helpers/schema-zod.js documents
+const makeAssistant = () => ({
+  log() {},
+  warn() {},
+  report: (msg, opts) => Object.assign(new Error(msg), { code: (opts || {}).code }),
+  request: { method: 'POST', user: { auth: { uid: 'u1', email: 'u1@test.com' } } },
+});
+const Manager = { cwd: '/tmp' };
+
+const resolve = (schema, input) => new Settings(Manager).resolve(makeAssistant(), schema, input, {});
+
+const CREATE_INPUT = {
+  title: 'Post',
+  url: 'post',
+  description: 'A post',
+  headerImageURL: 'https://example.com/image.jpg',
+  body: 'Body',
+};
+
+const EDIT_INPUT = {
+  url: 'https://example.com/blog/post',
+  body: 'Body',
+};
+
+module.exports = defineCases({
+  description: 'admin/post schemas: D13 deploy flag survives validation',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'create: deploy defaults true when absent',
+      async run({ assert }) {
+        const settings = resolve(createSchema(), { ...CREATE_INPUT });
+        assert.equal(settings.deploy, true, `deploy should default true, got ${settings.deploy}`);
+      },
+    },
+
+    {
+      name: 'create: deploy false survives to the route',
+      async run({ assert }) {
+        const settings = resolve(createSchema(), { ...CREATE_INPUT, deploy: false });
+        assert.equal(settings.deploy, false, `deploy: false should survive validation, got ${settings.deploy}`);
+      },
+    },
+
+    {
+      name: 'edit: deploy defaults true when absent',
+      async run({ assert }) {
+        const settings = resolve(editSchema(), { ...EDIT_INPUT });
+        assert.equal(settings.deploy, true, `deploy should default true, got ${settings.deploy}`);
+      },
+    },
+
+    {
+      name: 'edit: deploy false survives to the route',
+      async run({ assert }) {
+        const settings = resolve(editSchema(), { ...EDIT_INPUT, deploy: false });
+        assert.equal(settings.deploy, false, `deploy: false should survive validation, got ${settings.deploy}`);
+      },
+    },
+  ],
+});