API/src/models/feedback/integrations/salesforce.service.ts

import {NachklangFeedbackDB} from '../Feedback.db.js';
import logger from '../../../middleware/logger.js';
import {salesforceApexRestPost} from '../../../common/salesforce.client.js';

// Newsletter opt-ins sync to Salesforce, which already runs a full
// double-opt-in subscription flow (Person Account for existing constituents,
// Lead for everyone else - see the Salesforce repo's
// feature/newsletter-signup-integration branch for the full design notes).
// This is the one file that knows that contract exists; submissions.service.ts
// only ever calls syncNewsletterSignup(signupId) after its own transaction
// commits, fire-and-forget, so a Salesforce outage can never delay or fail a
// visitor's feedback submission. The OAuth token cache and retry-once-on-401
// live in common/salesforce.client.ts, shared with the transactional-email relay.

interface SalesforceSuccessResponse {
	status: 'PENDING_CONFIRMATION' | 'ALREADY_SUBSCRIBED';
	salesforceObject: 'Lead' | 'Account';
	salesforceRecordId: string;
	created: boolean;
}

interface NewsletterSignupRow {
	signup_id: number;
	first_name: string;
	last_name: string;
	email: string;
	event_name: string;
}

const postSignup = (payload: {firstName: string; lastName: string; email: string; eventName: string}): Promise<SalesforceSuccessResponse> =>
	salesforceApexRestPost<SalesforceSuccessResponse>('/services/apexrest/newsletter/signup', payload);

const markSynced = async (signupId: number, externalId: string): Promise<void> => {
	let conn = await NachklangFeedbackDB.getConnection();
	try {
		await conn.query(
			`UPDATE newsletter_signups SET sync_status = 'SENT', synced_at = NOW(), external_id = ?, sync_attempts = sync_attempts + 1, last_error = NULL WHERE signup_id = ?`,
			[externalId, signupId]
		);
	} finally {
		await conn.end();
	}
};

const markFailed = async (signupId: number, errorMessage: string): Promise<void> => {
	let conn = await NachklangFeedbackDB.getConnection();
	try {
		await conn.query(
			`UPDATE newsletter_signups SET sync_status = 'FAILED', last_error = ?, sync_attempts = sync_attempts + 1 WHERE signup_id = ?`,
			[errorMessage.slice(0, 2000), signupId]
		);
	} finally {
		await conn.end();
	}
};

/**
 * Reads one newsletter_signups row and syncs it to Salesforce. Always
 * called after the owning submission's transaction has committed, never
 * awaited by the request handler. When SALESFORCE_ENABLED is false, this
 * only logs the payload it would have sent - the row's sync_status is
 * already 'SKIPPED' from the insert in submissions.service.ts, so there's
 * nothing to update.
 */
export const syncNewsletterSignup = async (signupId: number): Promise<void> => {
	let conn = await NachklangFeedbackDB.getConnection();
	let row: NewsletterSignupRow | undefined;
	try {
		const rows = await conn.query(
			`SELECT ns.signup_id, ns.first_name, ns.last_name, ns.email, e.name AS event_name
			 FROM newsletter_signups ns JOIN events e ON e.event_id = ns.event_id
			 WHERE ns.signup_id = ?`,
			[signupId]
		);
		row = rows[0];
	} finally {
		await conn.end();
	}

	if (!row) {
		logger.error('syncNewsletterSignup: signup not found', {signupId});
		return;
	}

	const payload = {firstName: row.first_name, lastName: row.last_name, email: row.email, eventName: row.event_name};

	if (process.env.SALESFORCE_ENABLED !== 'true') {
		logger.info('syncNewsletterSignup: SALESFORCE_ENABLED is false, would have sent', {signupId, payload});
		return;
	}

	try {
		const result = await postSignup(payload);
		await markSynced(signupId, result.salesforceRecordId);
	} catch (err: any) {
		const message = err?.response?.data?.message || err?.message || 'Unknown error';
		logger.error('syncNewsletterSignup failed', {signupId, message});
		await markFailed(signupId, message);
	}
};