@tellescope/sdk 2.0.0-beta.1 → 2.0.0-beta.2

package/lib/esm/tests/api_tests/public_form_case_insensitive_match.test.js

@@ -0,0 +1,728 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+require('source-map-support').install();
+import { EnduserSession } from "../../sdk";
+import { assert_checks, setup_isolated_tenant, } from "../setup_isolated";
+var host = process.env.API_URL || 'http://localhost:8080';
+var RAND = function () { return Math.random().toString(36).slice(2, 10); };
+/**
+ * Coverage for `settings.endusers.caseInsensitiveMatching` — the per-org opt-in that makes public
+ * form intake match an existing contact when only the CAPITALIZATION of fname/lname differs.
+ *
+ * Two matchers are gated by the setting and both are exercised here:
+ *   - `session_for_public_form` (api/v1/api.ts), the intake screen
+ *   - `resolveAutoMergeBeforeSubmission` (api/modules/auto_merge.ts), for autoMergeOnSubmission forms
+ *
+ * Fixture warning: `nameValidator` applies `first_letter_capitalized`, so "john" is already stored and
+ * submitted as "John" and a "john"/"John" fixture would pass with the setting OFF, proving nothing.
+ * Every case here differs AFTER the first letter ("MCDONALD" vs "Mcdonald").
+ *
+ * `setup_isolated` rather than `setup_tests` because these checks flip an ORGANIZATION setting, which
+ * on the shared fixture org would change behavior under every concurrently running suite. It also
+ * asserts on "how many contacts match this name", which needs a tenant nobody else writes to.
+ *
+ * Runs standalone or as part of the main suite:
+ *   npm run test:modular -- api_tests/public_form_case_insensitive_match
+ */
+/** Builds a public form with the intake questions the matchers read.
+ *  `intakePhone: 'optional'` so `session_for_public_form` does not reject a submission with no phone
+ *  — the endpoint requires a phone number unless the form configures one. */
+var createPublicForm = function (sdk, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.autoMergeOnSubmission, autoMergeOnSubmission = _c === void 0 ? false : _c;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var form, fnameField, lnameField, dobField, emailField, phoneField;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, sdk.api.forms.createOne({
+                        title: "Case Insensitive Match ".concat(RAND()),
+                        allowPublicURL: true,
+                        intakePhone: 'optional',
+                        autoMergeOnSubmission: autoMergeOnSubmission,
+                    })
+                    // sequential: each field's previousFields references the one before it
+                ];
+                case 1:
+                    form = _d.sent();
+                    return [4 /*yield*/, sdk.api.form_fields.createOne({
+                            formId: form.id, title: 'First Name', type: 'string', intakeField: 'fname',
+                            previousFields: [{ type: 'root', info: {} }],
+                        })];
+                case 2:
+                    fnameField = _d.sent();
+                    return [4 /*yield*/, sdk.api.form_fields.createOne({
+                            formId: form.id, title: 'Last Name', type: 'string', intakeField: 'lname',
+                            previousFields: [{ type: 'after', info: { fieldId: fnameField.id } }],
+                        })];
+                case 3:
+                    lnameField = _d.sent();
+                    return [4 /*yield*/, sdk.api.form_fields.createOne({
+                            formId: form.id, title: 'Date of Birth', type: 'dateString', intakeField: 'dateOfBirth',
+                            previousFields: [{ type: 'after', info: { fieldId: lnameField.id } }],
+                        })];
+                case 4:
+                    dobField = _d.sent();
+                    return [4 /*yield*/, sdk.api.form_fields.createOne({
+                            formId: form.id, title: 'Email', type: 'email', intakeField: 'email',
+                            previousFields: [{ type: 'after', info: { fieldId: dobField.id } }],
+                        })];
+                case 5:
+                    emailField = _d.sent();
+                    return [4 /*yield*/, sdk.api.form_fields.createOne({
+                            formId: form.id, title: 'Phone', type: 'phone', intakeField: 'phone',
+                            previousFields: [{ type: 'after', info: { fieldId: emailField.id } }],
+                        })];
+                case 6:
+                    phoneField = _d.sent();
+                    return [2 /*return*/, { form: form, fields: [fnameField, lnameField, dobField, emailField, phoneField] }];
+            }
+        });
+    });
+};
+/** Drives the intake screen exactly as a public visitor would, returning the enduser the session was
+ *  minted for. This is the `session_for_public_form` matcher under test. */
+var intakeSession = function (form, values) { return __awaiter(void 0, void 0, void 0, function () {
+    var enduserSDK, _a, enduserId, accessCode, authToken;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                enduserSDK = new EnduserSession({ host: host, businessId: form.businessId });
+                return [4 /*yield*/, enduserSDK.api.form_responses.session_for_public_form(__assign({ formId: form.id, businessId: form.businessId }, values))];
+            case 1:
+                _a = _b.sent(), enduserId = _a.enduserId, accessCode = _a.accessCode, authToken = _a.authToken;
+                return [2 /*return*/, { enduserId: enduserId, accessCode: accessCode, authedSDK: new EnduserSession({ host: host, businessId: form.businessId, authToken: authToken }) }];
+        }
+    });
+}); };
+/** The intake screen alone, which is the matcher under test. */
+var intake = function (form, values) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, intakeSession(form, values)];
+        case 1: return [2 /*return*/, (_a.sent()).enduserId
+            /** Intake followed by a real submission, so the intake-field write onto the matched contact runs. */
+        ];
+    }
+}); }); };
+/** Intake followed by a real submission, so the intake-field write onto the matched contact runs. */
+var intakeAndSubmit = function (form, fields, values) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, enduserId, accessCode, authedSDK, byIntake;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, intakeSession(form, values)];
+            case 1:
+                _a = _b.sent(), enduserId = _a.enduserId, accessCode = _a.accessCode, authedSDK = _a.authedSDK;
+                byIntake = function (intakeField) { return fields.find(function (f) { return f.intakeField === intakeField; }); };
+                return [4 /*yield*/, authedSDK.api.form_responses.submit_form_response({
+                        accessCode: accessCode,
+                        responses: [
+                            { fieldId: byIntake('fname').id, fieldTitle: 'First Name', answer: { type: 'string', value: values.fname } },
+                            { fieldId: byIntake('lname').id, fieldTitle: 'Last Name', answer: { type: 'string', value: values.lname } },
+                            { fieldId: byIntake('dateOfBirth').id, fieldTitle: 'Date of Birth', answer: { type: 'dateString', value: values.dateOfBirth } },
+                        ],
+                    })];
+            case 2:
+                _b.sent();
+                return [2 /*return*/, enduserId];
+        }
+    });
+}); };
+/** Drives an auto-merge submission: a `skipMatch` session (which always inserts a fresh contact),
+ *  then a submission whose intake answers are what `resolveAutoMergeBeforeSubmission` matches on. */
+var submitWithSkipMatch = function (form, fields, values) { return __awaiter(void 0, void 0, void 0, function () {
+    var enduserSDK, _a, authToken, accessCode, enduserId, authedSDK, byIntake;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                enduserSDK = new EnduserSession({ host: host, businessId: form.businessId });
+                return [4 /*yield*/, enduserSDK.api.form_responses.session_for_public_form({
+                        formId: form.id,
+                        businessId: form.businessId,
+                        skipMatch: true,
+                    })];
+            case 1:
+                _a = _b.sent(), authToken = _a.authToken, accessCode = _a.accessCode, enduserId = _a.enduserId;
+                authedSDK = new EnduserSession({ host: host, businessId: form.businessId, authToken: authToken });
+                byIntake = function (intakeField) { return fields.find(function (f) { return f.intakeField === intakeField; }); };
+                return [4 /*yield*/, authedSDK.api.form_responses.submit_form_response({
+                        accessCode: accessCode,
+                        responses: [
+                            { fieldId: byIntake('fname').id, fieldTitle: 'First Name', answer: { type: 'string', value: values.fname } },
+                            { fieldId: byIntake('lname').id, fieldTitle: 'Last Name', answer: { type: 'string', value: values.lname } },
+                            { fieldId: byIntake('dateOfBirth').id, fieldTitle: 'Date of Birth', answer: { type: 'dateString', value: values.dateOfBirth } },
+                        ],
+                    })];
+            case 2:
+                _b.sent();
+                return [2 /*return*/, enduserId];
+        }
+    });
+}); };
+var enduserExists = function (sdk, enduserId) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, sdk.api.endusers.getOne(enduserId)];
+            case 1:
+                _b.sent();
+                return [2 /*return*/, true];
+            case 2:
+                _a = _b.sent();
+                return [2 /*return*/, false];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+export var public_form_case_insensitive_match_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, tenant, sdk_1, businessId_1, caseInsensitiveState_1, setCaseInsensitive, _a, form, fields_1, DOB, stored, matchedId, exactId, OFF_EMAIL, offContact, offSession, offField, offAfter, _b, form_1, fields_2, DOB, stored, matchedId, afterIntake, submittedId, afterSubmit, storedResponses, LOCK_DOB, LOCK_EMAIL, lockContact, lockSession, lockField, lockAfter, RENAME_EMAIL, renameTarget, renameSession, byIntake, renamed, EMAIL, byEmail, emailMatchedId, nameless, namelessMatchId, form, DOB, a, b, _c, lowest_1, highest, resolved, i, _d, _e, form, DOB, target, matchedId, WILDCARD_DOB, decoy, decoyProbeId, HYPHEN_DOB, hyphenated, hyphenMatchedId, DOB, offForm, offDestination, offSourceId, _f, _g, onForm, ON_DOB, onDestination, onSourceId, onSourceGone, mergedDestination, AMBIGUOUS_DOB, ambiguousForm, candidateA, candidateB, ambiguousSourceId, _h, a, b, _j, _k, _l, _m, DOB, stored, first, second_1, group, enduserSDK, _o, authToken, enduserId, authedSDK, secondResponse, attempt, responses, submitted, f, after, form, DOB, dobContact, wrongDobId, EMAIL, emailContact, matchedId, DOB, stored, template, bookingSDK, bookingMatched, sameName, err_1;
+    var _p, _q, _r;
+    return __generator(this, function (_s) {
+        switch (_s.label) {
+            case 0:
+                checks = [];
+                record = function (label, pass, detail) { return checks.push({ label: label, pass: pass, detail: detail }); };
+                _s.label = 1;
+            case 1:
+                _s.trys.push([1, , 99, 101]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "PublicFormCaseInsensitive ".concat(RAND()),
+                        users: [{ isAdmin: true }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _s.sent();
+                sdk_1 = tenant.sdk, businessId_1 = tenant.businessId;
+                setCaseInsensitive = function (on) { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (caseInsensitiveState_1 === on)
+                                    return [2 /*return*/];
+                                return [4 /*yield*/, sdk_1.api.organizations.updateOne(businessId_1, {
+                                        settings: { endusers: { caseInsensitiveMatching: on } },
+                                    })];
+                            case 1:
+                                _a.sent();
+                                caseInsensitiveState_1 = on;
+                                return [2 /*return*/];
+                        }
+                    });
+                }); };
+                return [4 /*yield*/, setCaseInsensitive(false)];
+            case 3:
+                _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1)];
+            case 4:
+                _a = _s.sent(), form = _a.form, fields_1 = _a.fields;
+                DOB = '1990-01-02';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'John', lname: 'MCDONALD', dateOfBirth: DOB })];
+            case 5:
+                stored = _s.sent();
+                record('fixture: a non-first-letter capitalization variant is stored verbatim', stored.lname === 'MCDONALD', "stored lname=".concat(JSON.stringify(stored.lname), " (if this is not MCDONALD every other check is vacuous)"));
+                return [4 /*yield*/, intake(form, { fname: 'John', lname: 'Mcdonald', dateOfBirth: DOB })];
+            case 6:
+                matchedId = _s.sent();
+                record('setting OFF: "Mcdonald" does NOT match stored "MCDONALD" (unchanged behavior)', matchedId !== stored.id, "intake resolved to ".concat(matchedId, ", stored contact is ").concat(stored.id));
+                return [4 /*yield*/, intake(form, { fname: 'John', lname: 'MCDONALD', dateOfBirth: DOB })];
+            case 7:
+                exactId = _s.sent();
+                record('setting OFF: an exactly-matching name still matches (control)', exactId === stored.id, "intake resolved to ".concat(exactId, ", expected ").concat(stored.id));
+                OFF_EMAIL = "dontsend-off-".concat(RAND(), "@tellescope.com");
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Off', lname: 'MCDONALD', email: OFF_EMAIL })];
+            case 8:
+                offContact = _s.sent();
+                return [4 /*yield*/, intakeSession(form, { email: OFF_EMAIL })];
+            case 9:
+                offSession = _s.sent();
+                offField = function (intakeField) { return fields_1.find(function (f) { return f.intakeField === intakeField; }); };
+                return [4 /*yield*/, offSession.authedSDK.api.form_responses.submit_form_response({
+                        accessCode: offSession.accessCode,
+                        responses: [
+                            { fieldId: offField('fname').id, fieldTitle: 'First Name', answer: { type: 'string', value: 'Off' } },
+                            { fieldId: offField('lname').id, fieldTitle: 'Last Name', answer: { type: 'string', value: 'Mcdonald' } },
+                        ],
+                    })];
+            case 10:
+                _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.getOne(offContact.id)];
+            case 11:
+                offAfter = _s.sent();
+                record('setting OFF: a case-only name change from intake still writes through (guard is inert)', offSession.enduserId === offContact.id && offAfter.lname === 'Mcdonald', "intake resolved to ".concat(offSession.enduserId, " (expected ").concat(offContact.id, "); stored lname is ").concat(JSON.stringify(offAfter.lname), ", expected \"Mcdonald\""));
+                return [4 /*yield*/, setCaseInsensitive(true)];
+            case 12:
+                _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1)];
+            case 13:
+                _b = _s.sent(), form_1 = _b.form, fields_2 = _b.fields;
+                DOB = '1991-02-03';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Jane', lname: 'MCDONALD', dateOfBirth: DOB })];
+            case 14:
+                stored = _s.sent();
+                return [4 /*yield*/, intake(form_1, { fname: 'Jane', lname: 'Mcdonald', dateOfBirth: DOB })];
+            case 15:
+                matchedId = _s.sent();
+                record('setting ON: "Mcdonald" matches stored "MCDONALD"', matchedId === stored.id, "intake resolved to ".concat(matchedId, ", expected ").concat(stored.id));
+                return [4 /*yield*/, sdk_1.api.endusers.getOne(stored.id)];
+            case 16:
+                afterIntake = _s.sent();
+                record('setting ON: the intake screen does not rewrite a matched contact\'s capitalization', afterIntake.lname === 'MCDONALD', "stored lname is now ".concat(JSON.stringify(afterIntake.lname), ", must still be \"MCDONALD\""));
+                return [4 /*yield*/, intakeAndSubmit(form_1, fields_2, { fname: 'Jane', lname: 'Mcdonald', dateOfBirth: DOB })];
+            case 17:
+                submittedId = _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.getOne(stored.id)];
+            case 18:
+                afterSubmit = _s.sent();
+                record('setting ON: SUBMITTING the form does not rewrite a matched contact\'s capitalization', submittedId === stored.id && afterSubmit.lname === 'MCDONALD', "submission resolved to ".concat(submittedId, " (expected ").concat(stored.id, "); stored lname is now ").concat(JSON.stringify(afterSubmit.lname), ", must still be \"MCDONALD\""));
+                return [4 /*yield*/, sdk_1.api.form_responses.getSome({ filter: { enduserId: stored.id } })];
+            case 19:
+                storedResponses = _s.sent();
+                record('setting ON: the submitted response is attached to the matched contact', storedResponses.some(function (r) { return r.formId === form_1.id && !!r.submittedAt; }), "form_responses on ".concat(stored.id, ": ").concat(JSON.stringify(storedResponses.map(function (r) { return ({ formId: r.formId, submitted: !!r.submittedAt }); }))));
+                LOCK_DOB = '1991-02-04';
+                LOCK_EMAIL = "dontsend-lock-".concat(RAND(), "@tellescope.com");
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'Lock', lname: 'MCDONALD', dateOfBirth: LOCK_DOB, email: LOCK_EMAIL, phone: '+15555550123',
+                    })];
+            case 20:
+                lockContact = _s.sent();
+                return [4 /*yield*/, intakeSession(form_1, { fname: 'Lock', lname: 'Mcdonald', dateOfBirth: LOCK_DOB })];
+            case 21:
+                lockSession = _s.sent();
+                lockField = function (intakeField) { return fields_2.find(function (f) { return f.intakeField === intakeField; }); };
+                return [4 /*yield*/, lockSession.authedSDK.api.form_responses.submit_form_response({
+                        accessCode: lockSession.accessCode,
+                        responses: [
+                            { fieldId: lockField('fname').id, fieldTitle: 'First Name', answer: { type: 'string', value: 'Lock' } },
+                            { fieldId: lockField('lname').id, fieldTitle: 'Last Name', answer: { type: 'string', value: 'Mcdonald' } },
+                            { fieldId: lockField('email').id, fieldTitle: 'Email', answer: { type: 'email', value: "attacker-".concat(RAND(), "@example.com") } },
+                            { fieldId: lockField('phone').id, fieldTitle: 'Phone', answer: { type: 'phone', value: '+15555559999' } },
+                        ],
+                    })];
+            case 22:
+                _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.getOne(lockContact.id)];
+            case 23:
+                lockAfter = _s.sent();
+                record('setting ON: a case-insensitively matched contact keeps its email and phone (auth-field lock holds)', lockSession.enduserId === lockContact.id
+                    && lockAfter.email === LOCK_EMAIL
+                    && lockAfter.phone === '+15555550123', "intake resolved to ".concat(lockSession.enduserId, " (expected ").concat(lockContact.id, ");")
+                    + " email=".concat(JSON.stringify(lockAfter.email), " (expected ").concat(JSON.stringify(LOCK_EMAIL), "),")
+                    + " phone=".concat(JSON.stringify(lockAfter.phone), " (expected \"+15555550123\")"));
+                RENAME_EMAIL = "dontsend-rename-".concat(RAND(), "@tellescope.com");
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Rename', lname: 'Smith', email: RENAME_EMAIL })];
+            case 24:
+                renameTarget = _s.sent();
+                return [4 /*yield*/, intakeSession(form_1, { email: RENAME_EMAIL })];
+            case 25:
+                renameSession = _s.sent();
+                byIntake = function (intakeField) { return fields_2.find(function (f) { return f.intakeField === intakeField; }); };
+                return [4 /*yield*/, renameSession.authedSDK.api.form_responses.submit_form_response({
+                        accessCode: renameSession.accessCode,
+                        responses: [
+                            { fieldId: byIntake('fname').id, fieldTitle: 'First Name', answer: { type: 'string', value: 'Rename' } },
+                            { fieldId: byIntake('lname').id, fieldTitle: 'Last Name', answer: { type: 'string', value: 'Smyth' } },
+                        ],
+                    })];
+            case 26:
+                _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.getOne(renameTarget.id)];
+            case 27:
+                renamed = _s.sent();
+                record('setting ON: a GENUINE name change from intake is still written through (control)', renameSession.enduserId === renameTarget.id && renamed.lname === 'Smyth', "intake resolved to ".concat(renameSession.enduserId, " (expected ").concat(renameTarget.id, "); stored lname is ").concat(JSON.stringify(renamed.lname), ", expected \"Smyth\""));
+                EMAIL = "dontsend-ci-".concat(RAND(), "@tellescope.com");
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Email', lname: 'Only', email: EMAIL })];
+            case 28:
+                byEmail = _s.sent();
+                return [4 /*yield*/, intake(form_1, { email: EMAIL })];
+            case 29:
+                emailMatchedId = _s.sent();
+                record('setting ON: matching by email alone is unchanged', emailMatchedId === byEmail.id, "intake resolved to ".concat(emailMatchedId, ", expected ").concat(byEmail.id));
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ dateOfBirth: '1960-06-06' })];
+            case 30:
+                nameless = _s.sent();
+                return [4 /*yield*/, intake(form_1, { fname: 'Nobody', dateOfBirth: '1960-06-06' })];
+            case 31:
+                namelessMatchId = _s.sent();
+                record('setting ON: a blank name does not match a nameless contact (sentinel survives)', namelessMatchId !== nameless.id, "intake resolved to ".concat(namelessMatchId, ", nameless contact is ").concat(nameless.id));
+                return [4 /*yield*/, setCaseInsensitive(true)];
+            case 32:
+                _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1)];
+            case 33:
+                form = (_s.sent()).form;
+                DOB = '1992-03-04';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Olive', lname: 'Mcdonald', dateOfBirth: DOB })];
+            case 34:
+                a = _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Olive', lname: 'MCDONALD', dateOfBirth: DOB })];
+            case 35:
+                b = _s.sent();
+                _c = a.id < b.id ? [a, b] : [b, a], lowest_1 = _c[0], highest = _c[1];
+                resolved = [];
+                i = 0;
+                _s.label = 36;
+            case 36:
+                if (!(i < 3)) return [3 /*break*/, 39];
+                _e = (_d = resolved).push;
+                return [4 /*yield*/, intake(form, { fname: 'Olive', lname: 'McDonald', dateOfBirth: DOB })];
+            case 37:
+                _e.apply(_d, [_s.sent()]);
+                _s.label = 38;
+            case 38:
+                i++;
+                return [3 /*break*/, 36];
+            case 39:
+                record('setting ON: with two case variants, the lowest-_id (oldest) contact wins on every submission', resolved.every(function (id) { return id === lowest_1.id; }), "resolved ".concat(JSON.stringify(resolved), ", lowest _id=").concat(lowest_1.id, ", other=").concat(highest.id));
+                return [4 /*yield*/, setCaseInsensitive(true)];
+            case 40:
+                _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1)];
+            case 41:
+                form = (_s.sent()).form;
+                DOB = '1993-04-05';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Mary', lname: 'O.Brien', dateOfBirth: DOB })];
+            case 42:
+                target = _s.sent();
+                return [4 /*yield*/, intake(form, { fname: 'Mary', lname: 'o.BRIEN', dateOfBirth: DOB })];
+            case 43:
+                matchedId = _s.sent();
+                record('setting ON: "." in a name is matched literally (matches the contact that has it)', matchedId === target.id, "intake resolved to ".concat(matchedId, ", expected O.Brien ").concat(target.id));
+                WILDCARD_DOB = '1993-04-06';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Mary', lname: 'OXBrien', dateOfBirth: WILDCARD_DOB })];
+            case 44:
+                decoy = _s.sent();
+                return [4 /*yield*/, intake(form, { fname: 'Mary', lname: 'O.Brien', dateOfBirth: WILDCARD_DOB })];
+            case 45:
+                decoyProbeId = _s.sent();
+                record('setting ON: "." is NOT a wildcard (does not match a contact with another character there)', decoyProbeId !== decoy.id, "intake resolved to ".concat(decoyProbeId, ", must NOT be the OXBrien contact ").concat(decoy.id));
+                HYPHEN_DOB = '1994-05-06';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Ann', lname: 'Smith-Jones', dateOfBirth: HYPHEN_DOB })];
+            case 46:
+                hyphenated = _s.sent();
+                return [4 /*yield*/, intake(form, { fname: 'Ann', lname: 'SMITH-JONES', dateOfBirth: HYPHEN_DOB })];
+            case 47:
+                hyphenMatchedId = _s.sent();
+                record('setting ON: a hyphenated name matches case-insensitively', hyphenMatchedId === hyphenated.id, "intake resolved to ".concat(hyphenMatchedId, ", expected ").concat(hyphenated.id));
+                DOB = '1995-06-07';
+                // 5a. setting OFF: a capitalization variant is not a merge candidate
+                return [4 /*yield*/, setCaseInsensitive(false)];
+            case 48:
+                // 5a. setting OFF: a capitalization variant is not a merge candidate
+                _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1, { autoMergeOnSubmission: true })];
+            case 49:
+                offForm = _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Merge', lname: 'MCDONALD', dateOfBirth: DOB })];
+            case 50:
+                offDestination = _s.sent();
+                return [4 /*yield*/, submitWithSkipMatch(offForm.form, offForm.fields, {
+                        fname: 'Merge', lname: 'Mcdonald', dateOfBirth: DOB,
+                    })];
+            case 51:
+                offSourceId = _s.sent();
+                _f = record;
+                _g = ['auto-merge, setting OFF: a capitalization variant does NOT merge (unchanged behavior)'];
+                return [4 /*yield*/, enduserExists(sdk_1, offSourceId)];
+            case 52:
+                _f.apply(void 0, _g.concat([_s.sent(), "source ".concat(offSourceId, " should still exist alongside destination ").concat(offDestination.id)]));
+                // 5b. setting ON: the same submission merges
+                return [4 /*yield*/, setCaseInsensitive(true)];
+            case 53:
+                // 5b. setting ON: the same submission merges
+                _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1, { autoMergeOnSubmission: true })];
+            case 54:
+                onForm = _s.sent();
+                ON_DOB = '1996-07-08';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Merge', lname: 'MCDONNELL', dateOfBirth: ON_DOB })];
+            case 55:
+                onDestination = _s.sent();
+                return [4 /*yield*/, submitWithSkipMatch(onForm.form, onForm.fields, {
+                        fname: 'Merge', lname: 'Mcdonnell', dateOfBirth: ON_DOB,
+                    })];
+            case 56:
+                onSourceId = _s.sent();
+                return [4 /*yield*/, enduserExists(sdk_1, onSourceId)];
+            case 57:
+                onSourceGone = !(_s.sent());
+                return [4 /*yield*/, sdk_1.api.endusers.getOne(onDestination.id)];
+            case 58:
+                mergedDestination = _s.sent();
+                record('auto-merge, setting ON: a capitalization variant merges into the existing contact', onSourceGone && !!((_p = mergedDestination.mergedIds) === null || _p === void 0 ? void 0 : _p.includes(onSourceId)), "source deleted=".concat(onSourceGone, ", destination mergedIds=").concat(JSON.stringify(mergedDestination.mergedIds)));
+                record('auto-merge, setting ON: the merged-into contact keeps its stored capitalization', mergedDestination.lname === 'MCDONNELL', "destination lname is ".concat(JSON.stringify(mergedDestination.lname), ", must still be \"MCDONNELL\""));
+                AMBIGUOUS_DOB = '1997-08-09';
+                return [4 /*yield*/, createPublicForm(sdk_1, { autoMergeOnSubmission: true })];
+            case 59:
+                ambiguousForm = _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Ambi', lname: 'Mcguire', dateOfBirth: AMBIGUOUS_DOB })];
+            case 60:
+                candidateA = _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Ambi', lname: 'MCGUIRE', dateOfBirth: AMBIGUOUS_DOB })];
+            case 61:
+                candidateB = _s.sent();
+                return [4 /*yield*/, submitWithSkipMatch(ambiguousForm.form, ambiguousForm.fields, {
+                        fname: 'Ambi', lname: 'McGuire', dateOfBirth: AMBIGUOUS_DOB,
+                    })];
+            case 62:
+                ambiguousSourceId = _s.sent();
+                return [4 /*yield*/, Promise.all([
+                        sdk_1.api.endusers.getOne(candidateA.id),
+                        sdk_1.api.endusers.getOne(candidateB.id),
+                    ])];
+            case 63:
+                _h = _s.sent(), a = _h[0], b = _h[1];
+                _j = record;
+                _k = ['auto-merge, setting ON: two case variants are ambiguous, so NOTHING is merged'];
+                return [4 /*yield*/, enduserExists(sdk_1, ambiguousSourceId)];
+            case 64:
+                _k = _k.concat([(_s.sent())
+                        && !((_q = a.mergedIds) === null || _q === void 0 ? void 0 : _q.includes(ambiguousSourceId))
+                        && !((_r = b.mergedIds) === null || _r === void 0 ? void 0 : _r.includes(ambiguousSourceId))]);
+                _m = (_l = "source ".concat(ambiguousSourceId, " exists=")).concat;
+                return [4 /*yield*/, enduserExists(sdk_1, ambiguousSourceId)];
+            case 65:
+                _j.apply(void 0, _k.concat([_m.apply(_l, [_s.sent(), ","])
+                        + " A.mergedIds=".concat(JSON.stringify(a.mergedIds), ", B.mergedIds=").concat(JSON.stringify(b.mergedIds))]));
+                return [4 /*yield*/, setCaseInsensitive(true)];
+            case 66:
+                _s.sent();
+                DOB = '1986-06-16';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Group', lname: 'MCDONALD', dateOfBirth: DOB })
+                    // Form 1 carries the intake screen that does the matching; form 2 ALSO carries name intake
+                    // questions, which is the case that escapes a publicSubmit-only guard — the follow-on group
+                    // responses are inserted by session_for_public_form without publicSubmit.
+                ];
+            case 67:
+                stored = _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1)];
+            case 68:
+                first = _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1)];
+            case 69:
+                second_1 = _s.sent();
+                return [4 /*yield*/, sdk_1.api.form_groups.createOne({
+                        title: "Case Insensitive Group ".concat(RAND()),
+                        formIds: [first.form.id, second_1.form.id],
+                    })];
+            case 70:
+                group = _s.sent();
+                enduserSDK = new EnduserSession({ host: host, businessId: businessId_1 });
+                return [4 /*yield*/, enduserSDK.api.form_responses.session_for_public_form({
+                        formId: first.form.id,
+                        businessId: businessId_1,
+                        groupId: group.id,
+                        fname: 'Group',
+                        lname: 'Mcdonald',
+                        dateOfBirth: DOB,
+                    })];
+            case 71:
+                _o = _s.sent(), authToken = _o.authToken, enduserId = _o.enduserId;
+                authedSDK = new EnduserSession({ host: host, businessId: businessId_1, authToken: authToken });
+                secondResponse = void 0;
+                attempt = 0;
+                _s.label = 72;
+            case 72:
+                if (!(attempt < 20 && !secondResponse)) return [3 /*break*/, 76];
+                return [4 /*yield*/, sdk_1.api.form_responses.getSome({ filter: { enduserId: stored.id } })];
+            case 73:
+                responses = _s.sent();
+                secondResponse = responses.find(function (r) { return r.formId === second_1.form.id; });
+                if (!!secondResponse) return [3 /*break*/, 75];
+                return [4 /*yield*/, new Promise(function (res) { return setTimeout(res, 100); })];
+            case 74:
+                _s.sent();
+                _s.label = 75;
+            case 75:
+                attempt++;
+                return [3 /*break*/, 72];
+            case 76:
+                submitted = false;
+                if (!(secondResponse === null || secondResponse === void 0 ? void 0 : secondResponse.accessCode)) return [3 /*break*/, 78];
+                f = function (intakeField) { return second_1.fields.find(function (x) { return x.intakeField === intakeField; }); };
+                return [4 /*yield*/, authedSDK.api.form_responses.submit_form_response({
+                        accessCode: secondResponse.accessCode,
+                        responses: [
+                            { fieldId: f('fname').id, fieldTitle: 'First Name', answer: { type: 'string', value: 'Group' } },
+                            { fieldId: f('lname').id, fieldTitle: 'Last Name', answer: { type: 'string', value: 'Mcdonald' } },
+                        ],
+                    })];
+            case 77:
+                _s.sent();
+                submitted = true;
+                _s.label = 78;
+            case 78: return [4 /*yield*/, sdk_1.api.endusers.getOne(stored.id)];
+            case 79:
+                after = _s.sent();
+                record('setting ON: form 2 of a public GROUP does not rewrite the matched contact\'s capitalization', enduserId === stored.id && submitted && after.lname === 'MCDONALD', "intake resolved to ".concat(enduserId, " (expected ").concat(stored.id, "); submitted form 2 = ").concat(submitted)
+                    + " (accessCode present = ".concat(!!(secondResponse === null || secondResponse === void 0 ? void 0 : secondResponse.accessCode), "); stored lname is ").concat(JSON.stringify(after.lname), ", must still be \"MCDONALD\""));
+                return [4 /*yield*/, setCaseInsensitive(true)];
+            case 80:
+                _s.sent();
+                return [4 /*yield*/, createPublicForm(sdk_1)
+                    // dateOfBirth is an identifier and stays an exact match: the same name with a different DOB
+                    // must not match, with the setting on
+                ];
+            case 81:
+                form = (_s.sent()).form;
+                DOB = '1999-10-11';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Dob', lname: 'MCDONALD', dateOfBirth: DOB })];
+            case 82:
+                dobContact = _s.sent();
+                return [4 /*yield*/, intake(form, { fname: 'Dob', lname: 'Mcdonald', dateOfBirth: '1999-10-12' })];
+            case 83:
+                wrongDobId = _s.sent();
+                record('setting ON: dateOfBirth is still an exact match (a different DOB does not match)', wrongDobId !== dobContact.id, "intake resolved to ".concat(wrongDobId, ", contact with DOB ").concat(DOB, " is ").concat(dobContact.id));
+                // with matchEmailAndNames on, the email branch of the $or additionally requires fname + lname;
+                // those two must be case-insensitive as well, or the opt-in silently excludes email matching
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(businessId_1, {
+                        settings: { endusers: { matchEmailAndNames: true } },
+                    })];
+            case 84:
+                // with matchEmailAndNames on, the email branch of the $or additionally requires fname + lname;
+                // those two must be case-insensitive as well, or the opt-in silently excludes email matching
+                _s.sent();
+                _s.label = 85;
+            case 85:
+                _s.trys.push([85, , 88, 90]);
+                EMAIL = "dontsend-mean-".concat(RAND(), "@tellescope.com");
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Mean', lname: 'MCDONALD', email: EMAIL })];
+            case 86:
+                emailContact = _s.sent();
+                return [4 /*yield*/, intake(form, { email: EMAIL, fname: 'Mean', lname: 'Mcdonald' })];
+            case 87:
+                matchedId = _s.sent();
+                record('setting ON + matchEmailAndNames: the email+fname+lname clause is case-insensitive too', matchedId === emailContact.id, "intake resolved to ".concat(matchedId, ", expected ").concat(emailContact.id));
+                return [3 /*break*/, 90];
+            case 88: return [4 /*yield*/, sdk_1.api.organizations.updateOne(businessId_1, {
+                    settings: { endusers: { matchEmailAndNames: false } },
+                })];
+            case 89:
+                _s.sent();
+                return [7 /*endfinally*/];
+            case 90: return [4 /*yield*/, setCaseInsensitive(true)];
+            case 91:
+                _s.sent();
+                DOB = '1998-09-10';
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Booking', lname: 'MCDONALD', dateOfBirth: DOB })];
+            case 92:
+                stored = _s.sent();
+                return [4 /*yield*/, sdk_1.api.calendar_event_templates.createOne({
+                        title: "Case Insensitive Booking ".concat(RAND()),
+                        durationInMinutes: 30,
+                    })];
+            case 93:
+                template = _s.sent();
+                bookingSDK = new EnduserSession({ host: host, businessId: businessId_1 });
+                bookingMatched = void 0;
+                _s.label = 94;
+            case 94:
+                _s.trys.push([94, 97, , 98]);
+                return [4 /*yield*/, bookingSDK.api.calendar_events.session_for_public_appointment_booking({
+                        calendarEventTemplateId: template.id,
+                        businessId: businessId_1,
+                        fname: 'Booking',
+                        lname: 'Mcdonald',
+                        dateOfBirth: DOB,
+                    })
+                    // the booking endpoint returns only an authToken, so "did it match?" is read off the contact
+                    // list: a non-match inserts a SECOND contact with the submitted capitalization
+                ];
+            case 95:
+                _s.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.getSome({ filter: { dateOfBirth: DOB } })];
+            case 96:
+                sameName = _s.sent();
+                bookingMatched = sameName.length === 1;
+                return [3 /*break*/, 98];
+            case 97:
+                err_1 = _s.sent();
+                bookingMatched = undefined;
+                return [3 /*break*/, 98];
+            case 98:
+                record('appointment booking stays byte-exact even with the setting ON (deliberately out of scope)', bookingMatched === false, bookingMatched === undefined
+                    ? 'the booking endpoint errored, so this check could not be evaluated'
+                    : "contacts with dateOfBirth ".concat(DOB, ": ").concat(bookingMatched ? 1 : 2, "; expected 2 (a separate contact), stored=").concat(stored.id));
+                return [2 /*return*/, checks];
+            case 99: return [4 /*yield*/, (tenant === null || tenant === void 0 ? void 0 : tenant.teardown())];
+            case 100:
+                _s.sent();
+                return [7 /*endfinally*/];
+            case 101: return [2 /*return*/];
+        }
+    });
+}); };
+/** Asserting wrapper, for standalone runs. */
+export var public_form_case_insensitive_match_tests = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = assert_checks;
+                _b = ['Public form case-insensitive matching'];
+                return [4 /*yield*/, public_form_case_insensitive_match_checks()];
+            case 1:
+                _a.apply(void 0, _b.concat([_c.sent()]));
+                return [2 /*return*/];
+        }
+    });
+}); };
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export var ISOLATED_SUITE = { name: 'Public form case-insensitive matching', run: public_form_case_insensitive_match_checks };
+// Allow running this test file independently
+if (require.main === module) {
+    console.log("Using API URL: ".concat(host));
+    public_form_case_insensitive_match_tests()
+        .then(function () {
+        console.log("Public form case-insensitive match test suite completed successfully");
+        process.exit(0);
+    })
+        .catch(function (error) {
+        console.error("Public form case-insensitive match test suite failed:", error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=public_form_case_insensitive_match.test.js.map