backend-manager 5.0.91 → 5.0.93

package/test/helpers/infer-contact.js

@@ -0,0 +1,299 @@
+/**
+ * Test: libraries/infer-contact.js
+ * Unit tests for contact inference from email addresses
+ *
+ * Tests capitalize, inferContactFromEmail (regex), and inferContact (AI fallback).
+ * AI tests only run when TEST_EXTENDED_MODE is set.
+ */
+const { inferContact, inferContactFromEmail, capitalize } = require('../../src/manager/libraries/infer-contact.js');
+
+module.exports = {
+  description: 'Infer contact from email',
+  type: 'group',
+
+  tests: [
+    // ─── capitalize ───
+
+    {
+      name: 'capitalize-single-word',
+      async run({ assert }) {
+        assert.equal(capitalize('john'), 'John', 'Should capitalize first letter');
+      },
+    },
+
+    {
+      name: 'capitalize-multiple-words',
+      async run({ assert }) {
+        assert.equal(capitalize('john doe'), 'John Doe', 'Should capitalize each word');
+      },
+    },
+
+    {
+      name: 'capitalize-all-uppercase',
+      async run({ assert }) {
+        assert.equal(capitalize('JOHN'), 'John', 'Should lowercase after first letter');
+      },
+    },
+
+    {
+      name: 'capitalize-mixed-case',
+      async run({ assert }) {
+        assert.equal(capitalize('jOHN dOE'), 'John Doe', 'Should normalize mixed case');
+      },
+    },
+
+    {
+      name: 'capitalize-empty-string',
+      async run({ assert }) {
+        assert.equal(capitalize(''), '', 'Empty string should return empty');
+      },
+    },
+
+    {
+      name: 'capitalize-null',
+      async run({ assert }) {
+        assert.equal(capitalize(null), '', 'Null should return empty');
+      },
+    },
+
+    {
+      name: 'capitalize-undefined',
+      async run({ assert }) {
+        assert.equal(capitalize(undefined), '', 'Undefined should return empty');
+      },
+    },
+
+    // ─── inferContactFromEmail: name parsing ───
+
+    {
+      name: 'regex-first-dot-last',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john.doe@gmail.com');
+
+        assert.equal(result.firstName, 'John', 'First name from local part before dot');
+        assert.equal(result.lastName, 'Doe', 'Last name from local part after dot');
+        assert.equal(result.method, 'regex', 'Method should be regex');
+        assert.equal(result.confidence, 0.5, 'Two-part name should have 0.5 confidence');
+      },
+    },
+
+    {
+      name: 'regex-first-underscore-last',
+      async run({ assert }) {
+        const result = inferContactFromEmail('jane_smith@yahoo.com');
+
+        assert.equal(result.firstName, 'Jane', 'First name from local part before underscore');
+        assert.equal(result.lastName, 'Smith', 'Last name from local part after underscore');
+      },
+    },
+
+    {
+      name: 'regex-first-hyphen-last',
+      async run({ assert }) {
+        const result = inferContactFromEmail('bob-jones@hotmail.com');
+
+        assert.equal(result.firstName, 'Bob', 'First name from local part before hyphen');
+        assert.equal(result.lastName, 'Jones', 'Last name from local part after hyphen');
+      },
+    },
+
+    {
+      name: 'regex-three-part-name',
+      async run({ assert }) {
+        const result = inferContactFromEmail('mary.jane.watson@example.com');
+
+        assert.equal(result.firstName, 'Mary', 'First name is first part');
+        assert.equal(result.lastName, 'Jane Watson', 'Last name joins remaining parts');
+      },
+    },
+
+    {
+      name: 'regex-single-word-local-part',
+      async run({ assert }) {
+        const result = inferContactFromEmail('admin@example.com');
+
+        assert.equal(result.firstName, 'Admin', 'Single word becomes first name');
+        assert.equal(result.lastName, '', 'No last name for single word');
+        assert.equal(result.confidence, 0.25, 'Single-part name should have 0.25 confidence');
+      },
+    },
+
+    {
+      name: 'regex-strips-trailing-numbers',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john.doe42@gmail.com');
+
+        assert.equal(result.firstName, 'John', 'Trailing numbers stripped before parsing');
+        assert.equal(result.lastName, 'Doe', 'Name parsed correctly after stripping');
+      },
+    },
+
+    {
+      name: 'regex-only-numbers-after-name',
+      async run({ assert }) {
+        const result = inferContactFromEmail('user123@gmail.com');
+
+        assert.equal(result.firstName, 'User', 'Numbers stripped, name capitalized');
+        assert.equal(result.lastName, '', 'No last name');
+      },
+    },
+
+    // ─── inferContactFromEmail: company inference ───
+
+    {
+      name: 'regex-company-from-custom-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@acme.com');
+
+        assert.equal(result.company, 'Acme', 'Company from custom domain');
+      },
+    },
+
+    {
+      name: 'regex-company-from-hyphenated-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@my-company.com');
+
+        assert.equal(result.company, 'My Company', 'Hyphens replaced with spaces');
+      },
+    },
+
+    {
+      name: 'regex-company-from-underscored-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@my_company.com');
+
+        assert.equal(result.company, 'My Company', 'Underscores replaced with spaces');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-gmail',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@gmail.com');
+
+        assert.equal(result.company, '', 'Gmail is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-yahoo',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@yahoo.com');
+
+        assert.equal(result.company, '', 'Yahoo is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-outlook',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@outlook.com');
+
+        assert.equal(result.company, '', 'Outlook is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-protonmail',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@protonmail.com');
+
+        assert.equal(result.company, '', 'Protonmail is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-icloud',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@icloud.com');
+
+        assert.equal(result.company, '', 'iCloud is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-generic-domain-case-insensitive',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@GMAIL.COM');
+
+        assert.equal(result.company, '', 'Generic domain check should be case-insensitive');
+      },
+    },
+
+    // ─── inferContactFromEmail: combined name + company ───
+
+    {
+      name: 'regex-full-result-custom-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('sarah.connor@skynet.io');
+
+        assert.equal(result.firstName, 'Sarah', 'First name parsed');
+        assert.equal(result.lastName, 'Connor', 'Last name parsed');
+        assert.equal(result.company, 'Skynet', 'Company from domain');
+        assert.equal(result.method, 'regex', 'Method is regex');
+        assert.equal(result.confidence, 0.5, 'Confidence 0.5 for two-part name');
+      },
+    },
+
+    {
+      name: 'regex-single-name-custom-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('info@acme.com');
+
+        assert.equal(result.firstName, 'Info', 'Single word capitalized');
+        assert.equal(result.lastName, '', 'No last name');
+        assert.equal(result.company, 'Acme', 'Company inferred');
+        assert.equal(result.confidence, 0.25, 'Lower confidence for single name');
+      },
+    },
+
+    // ─── inferContact: regex fallback (no OPENAI_API_KEY) ───
+
+    {
+      name: 'infer-contact-regex-fallback',
+      async run({ assert }) {
+        // Temporarily clear OPENAI_API_KEY to force regex path
+        const originalKey = process.env.OPENAI_API_KEY;
+        delete process.env.OPENAI_API_KEY;
+
+        try {
+          const result = await inferContact('alice.wonderland@example.com');
+
+          assert.equal(result.firstName, 'Alice', 'Regex fallback first name');
+          assert.equal(result.lastName, 'Wonderland', 'Regex fallback last name');
+          assert.equal(result.company, 'Example', 'Regex fallback company');
+          assert.equal(result.method, 'regex', 'Should use regex when no API key');
+        } finally {
+          // Restore
+          if (originalKey) {
+            process.env.OPENAI_API_KEY = originalKey;
+          }
+        }
+      },
+    },
+
+    // ─── inferContact: AI path (requires TEST_EXTENDED_MODE) ───
+
+    {
+      name: 'infer-contact-ai',
+      skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE not set (skipping AI inference test)' : false,
+      timeout: 30000,
+
+      async run({ assert, Manager }) {
+        // This test requires a real OPENAI_API_KEY and running Manager
+        if (!process.env.OPENAI_API_KEY) {
+          return assert.fail('OPENAI_API_KEY not set');
+        }
+
+        const assistant = Manager.Assistant();
+        const result = await inferContact('john.smith@microsoft.com', assistant);
+
+        assert.ok(result, 'Should return a result');
+        assert.ok(result.firstName, 'Should infer a first name');
+        assert.equal(result.method, 'ai', 'Should use AI method');
+        assert.ok(typeof result.confidence === 'number', 'Confidence should be a number');
+      },
+    },
+  ],
+};

package/test/routes/admin/email.js

@@ -1,14 +1,48 @@
 /**
  * Test: POST /admin/email
- * Tests the admin send email endpoint
- * Requires admin authentication and SendGrid API key configured
+ * Route-level tests: auth, permissions, HTTP status codes, basic send/queue
+ *
+ * Library-level tests (validation, dedup, recipients, features) are in test/helpers/email.js
  */
 module.exports = {
-  description: 'Admin send email',
+  description: 'Admin send email (route)',
   type: 'group',
   skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE env var not set (skipping email tests)' : false,
   tests: [
-    // Test 1: Missing subject returns 400 error
+    // --- Auth / Permissions ---
+
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'Test Email',
+          to: [{ email: `_test-receiver@${config.domain}` }],
+        });
+
+        assert.isError(response, 401, 'Send email should fail without authentication');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'Test Email',
+          to: [{ email: `_test-receiver@${config.domain}` }],
+        });
+
+        assert.isError(response, 403, 'Send email should fail for non-admin user');
+      },
+    },
+
+    // --- Basic Validation ---
+
     {
       name: 'missing-subject-rejected',
       auth: 'admin',
@@ -18,14 +52,14 @@ module.exports = {
         const response = await http.post('admin/email', {
           to: [{ email: `_test-receiver@${config.domain}` }],
           copy: false,
-          ensureUnique: false,
         });
 
         assert.isError(response, 400, 'Missing subject should return 400');
       },
     },
 
-    // Test 2: Status 'sent' - Email sent successfully via SendGrid
+    // --- Happy Path ---
+
     {
       name: 'status-sent',
       auth: 'admin',
@@ -36,7 +70,6 @@ module.exports = {
           subject: 'BEM Test Email - Status Sent',
           to: [{ email: `_test-receiver@${config.domain}`, name: 'Test Receiver' }],
           copy: false,
-          ensureUnique: false,
           data: {
             email: {
               subject: 'BEM Test Email - Status Sent',
@@ -47,11 +80,10 @@ module.exports = {
 
         assert.isSuccess(response, 'Admin should be able to send email');
         assert.hasProperty(response, 'data.status', 'Response should have status');
-        assert.equal(response.data.status, 'sent', 'Status should be sent when ensureUnique is false');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
       },
     },
 
-    // Test 3: Status 'queued' - Email scheduled beyond 71 hours
     {
       name: 'status-queued',
       auth: 'admin',
@@ -64,7 +96,6 @@ module.exports = {
           subject: 'BEM Test Email - Status Queued',
           to: [{ email: `_test-receiver@${config.domain}`, name: 'Test Receiver' }],
           copy: false,
-          ensureUnique: false,
           sendAt: sendAt,
           data: {
             email: {
@@ -79,85 +110,5 @@ module.exports = {
         assert.equal(response.data.status, 'queued', 'Status should be queued when sendAt is beyond 71 hours');
       },
     },
-
-    // Test 4: Status 'non-unique' - Duplicate email detected
-    {
-      name: 'status-non-unique',
-      auth: 'admin',
-      timeout: 120000,
-
-      async run({ http, assert, config }) {
-        const uniqueSubject = `BEM Test Email - Unique Check ${Date.now()}`;
-
-        const response1Promise = http.post('admin/email', {
-          subject: uniqueSubject,
-          to: [{ email: `_test-receiver@${config.domain}` }],
-          copy: false,
-          ensureUnique: true,
-          categories: ['bem-test-unique'],
-          data: {
-            email: {
-              subject: uniqueSubject,
-              body: 'Testing ensureUnique feature.',
-            },
-          },
-        });
-
-        const response2Promise = http.post('admin/email', {
-          subject: uniqueSubject,
-          to: [{ email: `_test-receiver@${config.domain}` }],
-          copy: false,
-          ensureUnique: true,
-          categories: ['bem-test-unique'],
-          data: {
-            email: {
-              subject: uniqueSubject,
-              body: 'Testing ensureUnique feature.',
-            },
-          },
-        });
-
-        const [response1, response2] = await Promise.all([response1Promise, response2Promise]);
-
-        assert.isSuccess(response1, 'First email should succeed');
-        assert.isSuccess(response2, 'Second email should succeed');
-
-        const statuses = [response1.data.status, response2.data.status].sort();
-        assert.equal(statuses[0], 'non-unique', 'One email should have status non-unique');
-        assert.equal(statuses[1], 'sent', 'One email should have status sent');
-      },
-    },
-
-    // Test 5: Unauthenticated request fails
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert, config }) {
-        const response = await http.post('admin/email', {
-          subject: 'Test Email',
-          to: [{ email: `_test-receiver@${config.domain}` }],
-        });
-
-        assert.isError(response, 401, 'Send email should fail without authentication');
-      },
-    },
-
-    // Test 6: Non-admin user fails
-    {
-      name: 'non-admin-rejected',
-      auth: 'basic',
-      timeout: 15000,
-
-      async run({ http, assert, config }) {
-        const response = await http.post('admin/email', {
-          subject: 'Test Email',
-          to: [{ email: `_test-receiver@${config.domain}` }],
-        });
-
-        assert.isError(response, 403, 'Send email should fail for non-admin user');
-      },
-    },
   ],
 };

package/REFACTOR-BEM-API.md

@@ -1,76 +0,0 @@
-We need to do a pretty significatn refactor of our BEM API now.
-
-Since that was orignally implemented, I built a much better process for hading incoming http requests. That is, the route/schema system found here:
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/helpers/assistant.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/helpers/middleware.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/helpers/settings.js
-
-You can see an example of it in our consuming project:
-/Users/ian/Developer/Repositories/ITW-Creative-Works/ultimate-jekyll-backend/functions/index.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/ultimate-jekyll-backend/functions/routes/example/index.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/ultimate-jekyll-backend/functions/schemas/example/index.js
-
-We built a single unified bem_api function that handles all http requests in a single place, and then routes them, see here:
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/index.js
-.https.onRequest(async (req, res) => self._process((new (require(`${core}/actions/api.js`))()).init(self, { req: req, res: res, })));
-
-We should refactor this system to USE THE NEW ROUTE/SCHEMA SYSTEM rather than the old way of doing things. This will make it much easier to maintain and extend in the future.
-
-We can start with a simple one like:
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/api/general/generate-uuid.js
-
-and once we perfect that we can move on to the others.
-
-For each BEM refactor, we should create a route and a schema for the expected input. As you can see, BEM APIs epect a command and payload in the body, requiring it to be a POST operation. I would like to rebuild this system to be more proper, so that each BEM api can be GET, POST, etc as appropriate.
-
-Previously:
-request('/backend-manager', {
-  method: 'POST',
-  body: {
-    command: 'generate-uuid',
-    payload: { ... }
-  }
-})
-
-but i think it owud be more intuitive if going forward we just had endpoints like:
-request('/backend-manager/general:uuid', {
-  method: 'POST',
-  body: { ... }
-})
-OR
-request('/backend-manager/general/uuid', {
-  method: 'POST',
-  body: { ... }
-})
-
-Im not sure how we can do this to be backwards compatible with existing BEM API consumers, but it does need to be backwards compatible.
-
-If you look at the firebase.json in the consuming project we can see that
-/Users/ian/Developer/Repositories/ITW-Creative-Works/ultimate-jekyll-backend/firebase.json
-{
-  "source": "/backend-manager",
-  "function": "bm_api"
-},
-
-So maybe we could make it:
-{
-  "source": "/backend-manager/**",
-  "function": "bm_api"
-},
-and then parse the route inside the bem_api function to determine which route/schema to use, falling back to the old system if the route is just /backend-manager with a "command" in the body, and then use the new route/schema system if the path is /backend-manager/something?
-
-Either way, i think we need a minimal intermediary step where we determine which one to use based on the incoming request and then either just route to the old one or route to the new "middleware", "settings", route/schema system
-
-I would like each new route to have a great name clearly indicating its purpose, the method should be appropriate for the action (GET for fetches, POST for creates, etc) and the schema should be well defined for each route.
-
-Since we can build this new API system however we want, i also expect you to rewrite and refactor the BEM api endppints to be kickass, modern, and well designed.
-
-Also, certain VERBS should be removed from the actual file/function names since they are implied by the HTTP method. For example, instead of having a generate-uuid.js file, we could just have uuid.js since the POST method implies that we are generating/creating a new one, or insetad of add-marketing-contact we could just have marketing-contact.js since the POST method implies adding a new one and GET would imply fetching them.
-
-Next, some fucntions have a lot crammed isnide them that could use some separation. For example, in add-marketing-contact.js we have code for handling multiple email providers (SendGrid, Beehiiv) all jammed into a single file. I think we should refactor this to have a separate file for each provider in subfolder that handles the specifics of that provider, and then the main route file just calls those provider-specific files as needed. This will make it much easier to maintain and extend in the future as we add more providers.
-
-Also, sometimes there are two endpoints that should be combined,for example
-* /Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/api/general/add-marketing-contact.js
-* /Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/api/general/remove-marketing-contact.js
-These could be combined into a single marketing-contact.js file that handles both adding and removing based on the HTTP method (POST for add, DELETE for remove). This will make the API more RESTful and easier to understand.
-

package/REFACTOR-MIDDLEWARE.md

@@ -1,62 +0,0 @@
-MIDDLEWARE REFACTOR
-We have a system where we handle incoming requests using a route/schema system found here:
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/helpers/assistant.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/helpers/middleware.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/helpers/settings.js
-
-You can see an example of it in our consuming project:
-/Users/ian/Developer/Repositories/ITW-Creative-Works/ultimate-jekyll-backend/functions/index.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/ultimate-jekyll-backend/functions/routes/example/index.js
-/Users/ian/Developer/Repositories/ITW-Creative-Works/ultimate-jekyll-backend/functions/schemas/example/index.js
-
-I have some ideas iw as thinking about and id like to know your thoughts:
-* new design so that each route is modern JS that does a single export instead of exportting a class with an init() and a main() method.
-* schema system currently uses the user's plan when designing the schma like
-module.exports = function (assistant) {
-  return {
-    // DEFAULTS
-    ['defaults']: {
-      key: {
-        types: ['string'],
-        value: undefined,
-        default: '',
-        required: false,
-        min: 0,
-        max: 2048,
-      },
-    },
-
-    // Premium plan
-    ['premium']: {
-      key: {
-        types: ['string'],
-        value: undefined,
-        default: 'premium-default',
-        required: false,
-        min: 0,
-        max: 4096,
-      },
-    }
-  };
-}
-
-however it hink we should instead eliminate the toplevel plan/default system and code each plan changes into the individual keys like:
-  const schema = {
-    id: {
-      types: ['string'],
-      value: () => assistant.Manager.Utilities().randomId(),
-      required: false,
-    },
-    feature: {
-      types: ['string'],
-      default: '',
-      required: true,
-      min: 1,
-      max: 4,
-    },
-  };
-
-  // Adjust schema based on plan
-  if (assistant.user.plan === 'premium') {
-    schema.feature.max = 8;
-  }