better-zap 0.0.4 → 0.2.0

package/dist/index.cjs

@@ -132,8 +132,8 @@ function delay(ms) {
 }
 //#endregion
 //#region src/services/whatsapp.service.ts
-const META_API_VERSION = "v25.0";
-const META_BASE_URL = "https://graph.facebook.com";
+const META_API_VERSION$1 = "v25.0";
+const META_BASE_URL$1 = "https://graph.facebook.com";
 const CONTEXT_WINDOW_CLOSED_ERROR = "Free-form message window is closed.";
 var WhatsAppService = class {
 	baseUrl;
@@ -142,7 +142,7 @@ var WhatsAppService = class {
 	logger;
 	log;
 	constructor(config, logger, log) {
-		this.baseUrl = `${META_BASE_URL}/${META_API_VERSION}/${config.phoneId}/messages`;
+		this.baseUrl = `${META_BASE_URL$1}/${META_API_VERSION$1}/${config.phoneId}/messages`;
 		this.token = config.token;
 		this.isDev = config.environment === "development";
 		this.logger = logger;
@@ -457,6 +457,366 @@ var WhatsAppService = class {
 	}
 };
 //#endregion
+//#region src/services/coexistence.service.ts
+const META_API_VERSION = "v25.0";
+const META_BASE_URL = "https://graph.facebook.com";
+var CoexistenceService = class {
+	accessToken;
+	appId;
+	appSecret;
+	graphApiVersion;
+	graphBaseUrl;
+	fetchImpl;
+	tokenProvider;
+	credentialProvider;
+	constructor(config) {
+		this.accessToken = config.accessToken;
+		this.appId = config.appId;
+		this.appSecret = config.appSecret;
+		this.graphApiVersion = config.graphApiVersion ?? META_API_VERSION;
+		this.graphBaseUrl = config.graphBaseUrl ?? META_BASE_URL;
+		this.fetchImpl = config.fetch ?? fetch;
+		this.tokenProvider = config.tokenProvider ?? config.credentialProvider;
+		this.credentialProvider = config.credentialProvider;
+	}
+	async exchangeEmbeddedSignupCode(input) {
+		if (this.credentialProvider) try {
+			return {
+				success: true,
+				data: await this.credentialProvider.exchangeEmbeddedSignupCode(input)
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Token exchange failed"
+			};
+		}
+		if (!this.appId || !this.appSecret) return {
+			success: false,
+			error: "appId and appSecret are required when no credentialProvider is configured"
+		};
+		const params = new URLSearchParams({
+			client_id: this.appId,
+			client_secret: this.appSecret,
+			code: input.code
+		});
+		if (input.redirectUri) params.set("redirect_uri", input.redirectUri);
+		const result = await this.request({
+			path: "/oauth/access_token",
+			method: "GET",
+			query: params,
+			token: null
+		});
+		if (!result.success || !result.data) return {
+			success: false,
+			error: result.error,
+			errorCode: result.errorCode,
+			httpStatus: result.httpStatus,
+			details: result.details
+		};
+		return {
+			success: true,
+			data: {
+				accessToken: result.data.access_token,
+				tokenType: result.data.token_type,
+				expiresIn: result.data.expires_in,
+				raw: result.data
+			}
+		};
+	}
+	async subscribeWaba(input) {
+		return this.request({
+			path: `/${input.wabaId}/subscribed_apps`,
+			method: "POST",
+			token: input.accessToken ?? await this.resolveAccessToken({ wabaId: input.wabaId })
+		});
+	}
+	async getPhoneStatus(input) {
+		return this.request({
+			path: `/${input.phoneNumberId}`,
+			method: "GET",
+			query: new URLSearchParams({ fields: "is_on_biz_app,platform_type" }),
+			token: input.accessToken ?? await this.resolveAccessToken({ phoneNumberId: input.phoneNumberId })
+		});
+	}
+	async startContactsSync(input) {
+		return this.startSmbAppDataSync({
+			phoneNumberId: input.phoneNumberId,
+			accessToken: input.accessToken,
+			syncType: "smb_app_state_sync"
+		});
+	}
+	async startHistorySync(input) {
+		return this.startSmbAppDataSync({
+			phoneNumberId: input.phoneNumberId,
+			accessToken: input.accessToken,
+			syncType: "history"
+		});
+	}
+	async startSmbAppDataSync(input) {
+		return this.request({
+			path: `/${input.phoneNumberId}/smb_app_data`,
+			method: "POST",
+			body: { sync_type: input.syncType },
+			token: input.accessToken ?? await this.resolveAccessToken({ phoneNumberId: input.phoneNumberId })
+		});
+	}
+	async resolveAccessToken(input) {
+		if (this.tokenProvider) return this.tokenProvider.getAccessToken(input);
+		return this.accessToken;
+	}
+	async request(input) {
+		if (input.token === void 0) return {
+			success: false,
+			error: "Missing Meta access token"
+		};
+		const url = new URL(`${this.graphBaseUrl}/${this.graphApiVersion}${input.path}`);
+		if (input.query) input.query.forEach((value, key) => url.searchParams.set(key, value));
+		try {
+			const response = await this.fetchImpl(url.toString(), {
+				method: input.method,
+				headers: {
+					"Content-Type": "application/json",
+					...input.token ? { Authorization: `Bearer ${input.token}` } : {}
+				},
+				...input.body ? { body: JSON.stringify(input.body) } : {}
+			});
+			let data = null;
+			try {
+				data = await response.json();
+			} catch {
+				data = null;
+			}
+			if (!response.ok) {
+				const errorData = data;
+				return {
+					success: false,
+					error: errorData?.error?.message ?? `HTTP ${response.status}`,
+					errorCode: errorData?.error?.code,
+					httpStatus: response.status,
+					details: data
+				};
+			}
+			return {
+				success: true,
+				data
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Network error"
+			};
+		}
+	}
+};
+//#endregion
+//#region src/coexistence/config.ts
+function createCoexistenceEmbeddedSignupConfig(input) {
+	return {
+		config_id: input.configId,
+		response_type: "code",
+		override_default_response_type: true,
+		extras: {
+			...input.setup ? { setup: input.setup } : {},
+			featureType: "whatsapp_business_app_onboarding",
+			sessionInfoVersion: "3"
+		}
+	};
+}
+//#endregion
+//#region src/coexistence/events.ts
+const LEGACY_EVENT_BY_GENERIC = {
+	FINISH: "FINISH_WHATSAPP_BUSINESS_APP_ONBOARDING",
+	CANCEL: "CANCEL_WHATSAPP_BUSINESS_APP_ONBOARDING",
+	ERROR: "ERROR_WHATSAPP_BUSINESS_APP_ONBOARDING"
+};
+const GENERIC_EVENT_BY_LEGACY = {
+	FINISH_WHATSAPP_BUSINESS_APP_ONBOARDING: "FINISH",
+	CANCEL_WHATSAPP_BUSINESS_APP_ONBOARDING: "CANCEL",
+	ERROR_WHATSAPP_BUSINESS_APP_ONBOARDING: "ERROR"
+};
+function isKnownGenericEvent(event) {
+	return event === "FINISH" || event === "CANCEL" || event === "ERROR";
+}
+function normalizeCoexistenceSessionEvent(event) {
+	if (isKnownGenericEvent(event)) return event;
+	if (event in GENERIC_EVENT_BY_LEGACY) return GENERIC_EVENT_BY_LEGACY[event];
+	return "PROGRESS";
+}
+function toLegacyCoexistenceSessionEvent(event) {
+	return isKnownGenericEvent(event) ? LEGACY_EVENT_BY_GENERIC[event] : event;
+}
+function normalizeCoexistenceSessionPayload(payload) {
+	return {
+		...payload,
+		normalizedEvent: normalizeCoexistenceSessionEvent(payload.event)
+	};
+}
+//#endregion
+//#region src/coexistence/embedded-signup.ts
+const DEFAULT_ALLOWED_ORIGINS = ["https://www.facebook.com", "https://web.facebook.com"];
+function parseEmbeddedSignupMessage(data) {
+	const payload = typeof data === "string" ? parseJson(data) : data;
+	if (typeof payload !== "object" || payload === null) return null;
+	const candidate = payload;
+	if (candidate.type !== "WA_EMBEDDED_SIGNUP" || candidate.version !== 3 || typeof candidate.event !== "string") return null;
+	return {
+		event: candidate.event,
+		data: typeof candidate.data === "object" && candidate.data !== null ? candidate.data : void 0
+	};
+}
+function parseJson(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+function launchCoexistenceEmbeddedSignup(input) {
+	const allowedOrigins = new Set([
+		...DEFAULT_ALLOWED_ORIGINS,
+		...input.origin ? [input.origin] : [],
+		...input.allowedOrigins ?? []
+	]);
+	let latestSession = null;
+	let latestCode = null;
+	const listener = (event) => {
+		if (!allowedOrigins.has(event.origin)) return;
+		const session = parseEmbeddedSignupMessage(event.data);
+		if (!session) return;
+		latestSession = session;
+		const normalizedEvent = normalizeCoexistenceSessionEvent(session.event);
+		if (normalizedEvent === "FINISH") {
+			input.onFinish?.({
+				code: latestCode,
+				session
+			});
+			return;
+		}
+		if (normalizedEvent === "CANCEL") {
+			input.onCancel?.({ session });
+			return;
+		}
+		if (normalizedEvent === "ERROR") {
+			input.onError?.({ session });
+			return;
+		}
+		input.onProgress?.({ session });
+	};
+	input.target.addEventListener("message", listener);
+	input.fb.init?.(input.fbInit ?? {});
+	return {
+		result: new Promise((resolve) => {
+			input.fb.login((response) => {
+				latestCode = typeof response.authResponse?.code === "string" ? response.authResponse.code : null;
+				if (latestSession && normalizeCoexistenceSessionEvent(latestSession.event) === "FINISH") input.onFinish?.({
+					code: latestCode,
+					session: latestSession
+				});
+				resolve({
+					code: latestCode,
+					session: latestSession,
+					loginResponse: response
+				});
+			}, createCoexistenceEmbeddedSignupConfig(input));
+		}),
+		teardown() {
+			input.target.removeEventListener("message", listener);
+		}
+	};
+}
+//#endregion
+//#region src/coexistence/memory-store.ts
+const IN_FLIGHT_SYNC_STATUSES = new Set(["requested", "processing"]);
+function timeValue(value) {
+	if (!value) return;
+	return value instanceof Date ? value.getTime() : new Date(value).getTime();
+}
+function cloneRecord(record) {
+	return structuredClone(record);
+}
+function isInFlight(job, now) {
+	if (!IN_FLIGHT_SYNC_STATUSES.has(job.status)) return false;
+	const deadline = timeValue(job.deadlineAt);
+	if (deadline !== void 0 && deadline <= now.getTime()) return false;
+	return true;
+}
+var InMemoryCoexistenceStore = class {
+	connectedAccounts = /* @__PURE__ */ new Map();
+	onboardingSessions = /* @__PURE__ */ new Map();
+	syncJobs = /* @__PURE__ */ new Map();
+	contacts = /* @__PURE__ */ new Map();
+	lifecycleEvents = [];
+	rawEventStatuses = /* @__PURE__ */ new Map();
+	preflightStates = /* @__PURE__ */ new Map();
+	async upsertConnectedAccount(account) {
+		const record = cloneRecord(account);
+		this.connectedAccounts.set(account.wabaId, record);
+		this.connectedAccounts.set(account.phoneNumberId, record);
+		if (account.preflight) await this.upsertPreflightState(account.preflight);
+	}
+	async getConnectedAccountByWabaId(wabaId) {
+		return cloneRecord(this.connectedAccounts.get(wabaId) ?? null);
+	}
+	async getConnectedAccountByPhoneNumberId(phoneNumberId) {
+		return cloneRecord(this.connectedAccounts.get(phoneNumberId) ?? null);
+	}
+	async recordOnboardingSession(session) {
+		this.onboardingSessions.set(session.id, cloneRecord(session));
+		if (session.preflight) await this.upsertPreflightState(session.preflight);
+	}
+	async upsertPreflightState(state) {
+		const record = cloneRecord(state);
+		if (state.phoneNumberId) this.preflightStates.set(state.phoneNumberId, record);
+		if (state.wabaId) this.preflightStates.set(state.wabaId, record);
+	}
+	async getPreflightStateByPhoneNumberId(phoneNumberId) {
+		return cloneRecord(this.preflightStates.get(phoneNumberId) ?? null);
+	}
+	async createSyncJob(job) {
+		if (await this.getInFlightSyncJob({
+			phoneNumberId: job.phoneNumberId,
+			syncType: job.syncType,
+			now: job.requestedAt ?? job.createdAt
+		})) throw new Error(`Coexistence sync already in flight for ${job.phoneNumberId}:${job.syncType}`);
+		this.syncJobs.set(job.requestId, cloneRecord(job));
+	}
+	async getInFlightSyncJob(input) {
+		const now = input.now instanceof Date ? input.now : new Date(input.now ?? Date.now());
+		for (const job of this.syncJobs.values()) {
+			if (job.phoneNumberId !== input.phoneNumberId || job.syncType !== input.syncType) continue;
+			if (isInFlight(job, now)) return cloneRecord(job);
+			if (IN_FLIGHT_SYNC_STATUSES.has(job.status) && job.deadlineAt) await this.updateSyncJobByRequestId(job.requestId, {
+				status: "deadline_exceeded",
+				failedAt: now,
+				failureReason: "sync_deadline_exceeded"
+			});
+		}
+		return null;
+	}
+	async updateSyncJobByRequestId(requestId, patch) {
+		const current = this.syncJobs.get(requestId);
+		if (!current) return;
+		this.syncJobs.set(requestId, cloneRecord({
+			...current,
+			...patch
+		}));
+	}
+	async upsertContact(contact) {
+		const key = `${contact.phoneNumberId ?? ""}:${contact.waId}`;
+		this.contacts.set(key, cloneRecord(contact));
+	}
+	async removeContact(input) {
+		this.contacts.delete(`${input.phoneNumberId ?? ""}:${input.waId}`);
+	}
+	async recordLifecycleEvent(event) {
+		this.lifecycleEvents.push(cloneRecord(event));
+	}
+	async updateRawEventStatus(status) {
+		this.rawEventStatuses.set(status.id, cloneRecord(status));
+	}
+};
+//#endregion
 //#region src/services/message-logger.service.ts
 const WHATSAPP_MESSAGE_TYPES = [
 	"queue_position",
@@ -511,7 +871,7 @@ var MessageLoggerService = class {
 	* Log outgoing message for LGPD compliance
 	*/
 	async logOutgoing(params) {
-		const inserted = await this.store.createWhatsAppLog({
+		const { record: inserted } = await this.store.createWhatsAppLog({
 			phone: params.phone,
 			userId: params.userId,
 			direction: "outgoing",
@@ -567,7 +927,7 @@ var MessageLoggerService = class {
 	* Log incoming message (for audit trail)
 	*/
 	async logIncoming(params) {
-		const inserted = await this.store.createWhatsAppLog({
+		const { record: inserted, created } = await this.store.createWhatsAppLog({
 			phone: params.phone,
 			contactName: params.senderName,
 			waMessageId: params.waMessageId,
@@ -578,12 +938,40 @@ var MessageLoggerService = class {
 			metadata: params.metadata,
 			sentAt: params.sentAt
 		});
+		if (!created) return false;
+		const conversation = await this.getConversationById(inserted.conversationId);
+		if (conversation) await this.notify({
+			type: "NEW_MESSAGE",
+			message: inserted,
+			conversation
+		});
+		return true;
+	}
+	/**
+	* Log an imported WhatsApp message with an explicit direction and timestamp.
+	* Used by coexistence history imports and app echo webhooks where the message
+	* did not originate from the local send API call.
+	*/
+	async logImportedMessage(params) {
+		const { record: inserted, created } = await this.store.createWhatsAppLog({
+			phone: params.phone,
+			contactName: params.senderName,
+			waMessageId: params.waMessageId,
+			direction: params.direction,
+			messageType: params.messageType ?? (params.direction === "incoming" ? "incoming" : "bot_reply"),
+			content: params.content,
+			status: params.direction === "incoming" ? "delivered" : "sent",
+			metadata: params.metadata,
+			sentAt: params.sentAt
+		});
+		if (!created) return false;
 		const conversation = await this.getConversationById(inserted.conversationId);
 		if (conversation) await this.notify({
 			type: "NEW_MESSAGE",
 			message: inserted,
 			conversation
 		});
+		return true;
 	}
 };
 //#endregion
@@ -669,11 +1057,14 @@ function serializeTemplateParameter(parameter, value) {
 }
 //#endregion
 exports.BetterZapClientError = require_client.BetterZapClientError;
+exports.CoexistenceService = CoexistenceService;
 exports.EMPTY_TEMPLATE_REGISTRY = EMPTY_TEMPLATE_REGISTRY;
 exports.FREEFORM_MESSAGE_WINDOW_MS = FREEFORM_MESSAGE_WINDOW_MS;
+exports.InMemoryCoexistenceStore = InMemoryCoexistenceStore;
 exports.MessageLoggerService = MessageLoggerService;
 exports.WHATSAPP_MESSAGE_TYPES = WHATSAPP_MESSAGE_TYPES;
 exports.WhatsAppService = WhatsAppService;
+exports.createCoexistenceEmbeddedSignupConfig = createCoexistenceEmbeddedSignupConfig;
 exports.createFreeformMessageWindow = createFreeformMessageWindow;
 exports.createLogger = createLogger;
 exports.createZapClient = require_client.createZapClient;
@@ -683,9 +1074,13 @@ exports.formatPhone = formatPhone;
 exports.getLatestIncomingMessageAt = getLatestIncomingMessageAt;
 exports.getTemplateNames = getTemplateNames;
 exports.hasConfiguredTemplates = hasConfiguredTemplates;
+exports.launchCoexistenceEmbeddedSignup = launchCoexistenceEmbeddedSignup;
 exports.noopLogger = noopLogger;
+exports.normalizeCoexistenceSessionEvent = normalizeCoexistenceSessionEvent;
+exports.normalizeCoexistenceSessionPayload = normalizeCoexistenceSessionPayload;
 exports.normalizeConversationRecord = normalizeConversationRecord;
 exports.normalizeConversationRecords = normalizeConversationRecords;
 exports.resolveConversationFreeformMessageWindow = resolveConversationFreeformMessageWindow;
 exports.serializeError = serializeError;
 exports.serializeTemplateFromRegistry = serializeTemplateFromRegistry;
+exports.toLegacyCoexistenceSessionEvent = toLegacyCoexistenceSessionEvent;