@product7/product7-js 0.1.0

package/src/core/APIService.js

@@ -0,0 +1,303 @@
+import { ChangelogService } from '../api/services/ChangelogService.js';
+import { FeedbackService } from '../api/services/FeedbackService.js';
+import { HelpService } from '../api/services/HelpService.js';
+import { MessengerService } from '../api/services/MessengerService.js';
+import { SurveyService } from '../api/services/SurveyService.js';
+import { BaseAPIService } from './BaseAPIService.js';
+
+export class APIService extends BaseAPIService {
+	constructor(config = {}) {
+		super(config);
+
+		this.feedback = new FeedbackService(this);
+		this.survey = new SurveyService(this);
+		this.messenger = new MessengerService(this);
+		this.help = new HelpService(this);
+		this.changelog = new ChangelogService(this);
+	}
+
+	async submitFeedback(data) {
+		return this.feedback.submitFeedback(data);
+	}
+
+	async getActiveSurveys(context) {
+		return this.survey.getActiveSurveys(context);
+	}
+
+	async submitSurveyResponse(surveyId, responseData) {
+		return this.survey.submitSurveyResponse(surveyId, responseData);
+	}
+
+	async dismissSurvey(surveyId) {
+		return this.survey.dismissSurvey(surveyId);
+	}
+
+	async getMessengerSettings() {
+		return this.messenger.getMessengerSettings();
+	}
+
+	async checkAgentsOnline() {
+		if (!this.isSessionValid()) {
+			await this.init();
+		}
+
+		if (this.mock) {
+			return {
+				status: true,
+				data: {
+					agents_online: true,
+					online_count: 2,
+					response_time: 'Usually replies within a few minutes',
+					available_agents: [
+						{ full_name: 'Sarah', picture: '' },
+						{ full_name: 'Tom', picture: '' },
+					],
+				},
+			};
+		}
+
+		return this._makeRequest('/widget/messenger/agents/online', {
+			method: 'GET',
+			headers: { Authorization: `Bearer ${this.sessionToken}` },
+		});
+	}
+
+	async getConversations(options) {
+		return this.messenger.getConversations(options);
+	}
+
+	async getConversation(conversationId) {
+		return this.messenger.getConversation(conversationId);
+	}
+
+	async getMessages(conversationId, options) {
+		return this.messenger.getMessages(conversationId, options);
+	}
+
+	async startConversation(data) {
+		if (!this.isSessionValid()) {
+			console.log(
+				'[APIService] startConversation: session invalid, calling init...'
+			);
+			try {
+				await this.init();
+				console.log(
+					'[APIService] startConversation: init result, token:',
+					this.sessionToken ? 'set' : 'null'
+				);
+			} catch (initError) {
+				console.error(
+					'[APIService] startConversation: init failed:',
+					initError.message
+				);
+				throw initError;
+			}
+		}
+
+		if (!this.sessionToken) {
+			console.error(
+				'[APIService] startConversation: no session token after init'
+			);
+			throw new APIError(401, 'No valid session token available');
+		}
+
+		console.log(
+			'[APIService] startConversation: sending to',
+			`${this.baseURL}/widget/messenger/conversations`,
+			'mock:',
+			this.mock
+		);
+
+		if (this.mock) {
+			await new Promise((resolve) => setTimeout(resolve, 300));
+			const newConv = {
+				id: 'conv_' + Date.now(),
+				subject: data.subject || 'New conversation',
+				status: 'open',
+				last_message_at: new Date().toISOString(),
+				created_at: new Date().toISOString(),
+				messages: [
+					{
+						id: 'msg_' + Date.now(),
+						content: data.message,
+						sender_type: 'customer',
+						created_at: new Date().toISOString(),
+					},
+				],
+			};
+			MOCK_CONVERSATIONS.unshift(newConv);
+			MOCK_MESSAGES[newConv.id] = newConv.messages;
+			return { status: true, data: newConv };
+		}
+
+		return this._makeRequest('/widget/messenger/conversations', {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${this.sessionToken}`,
+			},
+			body: JSON.stringify({
+				message: data.message,
+				subject: data.subject || '',
+			}),
+		});
+	}
+
+	async sendMessage(conversationId, data) {
+		if (!this.isSessionValid()) {
+			await this.init();
+		}
+
+		if (this.mock) {
+			await new Promise((resolve) => setTimeout(resolve, 200));
+			const newMessage = {
+				id: 'msg_' + Date.now(),
+				content: data.content,
+				attachments: data.attachments || [],
+				sender_type: 'customer',
+				created_at: new Date().toISOString(),
+			};
+			if (!MOCK_MESSAGES[conversationId]) {
+				MOCK_MESSAGES[conversationId] = [];
+			}
+			MOCK_MESSAGES[conversationId].push(newMessage);
+			return { status: true, data: newMessage };
+		}
+
+		const payload = { content: data.content };
+		if (data.attachments && data.attachments.length > 0) {
+			payload.attachments = data.attachments;
+		}
+
+		return this._makeRequest(
+			`/widget/messenger/conversations/${conversationId}/messages`,
+			{
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${this.sessionToken}`,
+				},
+				body: JSON.stringify(payload),
+			}
+		);
+	}
+
+	/**
+	 * Upload a file to CDN via widget endpoint
+	 * @param {string} base64Data - Base64 encoded file data (with or without data URI prefix)
+	 * @param {string} filename - Original filename
+	 * @returns {Promise<Object>} Response with url
+	 */
+	async uploadFile(base64Data, filename) {
+		if (!this.isSessionValid()) {
+			await this.init();
+		}
+
+		if (this.mock) {
+			await new Promise((resolve) => setTimeout(resolve, 300));
+			return { status: true, url: `https://mock-cdn.example.com/${filename}` };
+		}
+
+		return this._makeRequest('/widget/messenger/upload', {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				Authorization: `Bearer ${this.sessionToken}`,
+			},
+			body: JSON.stringify({ file: base64Data, filename }),
+		});
+	}
+
+	async sendTypingIndicator(conversationId, isTyping) {
+		return this.messenger.sendTypingIndicator(conversationId, isTyping);
+	}
+
+	async markConversationAsRead(conversationId) {
+		return this.messenger.markConversationAsRead(conversationId);
+	}
+
+	async getUnreadCount() {
+		return this.messenger.getUnreadCount();
+	}
+
+	async submitRating(conversationId, data) {
+		return this.messenger.submitRating(conversationId, data);
+	}
+
+	async identifyContact(data) {
+		return this.messenger.identifyContact(data);
+	}
+
+	async getHelpCollections(options) {
+		return this.help.getHelpCollections(options);
+	}
+
+	async searchHelpArticles(query, options) {
+		return this.help.searchHelpArticles(query, options);
+	}
+
+	async getChangelogs(options) {
+		return this.changelog.getChangelogs(options);
+	}
+
+	_loadStoredSession() {
+		if (typeof localStorage === 'undefined') return false;
+
+		try {
+			const stored = localStorage.getItem('product7_session');
+			if (!stored) return false;
+
+			const sessionData = JSON.parse(stored);
+
+			// Invalidate mock tokens when not in mock mode (and vice versa)
+			const isMockToken =
+				sessionData.token && sessionData.token.startsWith('mock_');
+			if (isMockToken !== this.mock) {
+				localStorage.removeItem('product7_session');
+				return false;
+			}
+
+			this.sessionToken = sessionData.token;
+			this.sessionExpiry = new Date(sessionData.expiry);
+
+			return this.isSessionValid();
+		} catch (error) {
+			return false;
+		}
+	}
+
+	async _makeRequest(endpoint, options = {}) {
+		const url = `${this.baseURL}${endpoint}`;
+
+		try {
+			const response = await fetch(url, options);
+
+			if (!response.ok) {
+				let errorMessage = `HTTP ${response.status}`;
+				let responseData = null;
+
+				try {
+					responseData = await response.json();
+					errorMessage =
+						responseData.message || responseData.error || errorMessage;
+				} catch (e) {
+					errorMessage = (await response.text()) || errorMessage;
+				}
+
+				throw new APIError(response.status, errorMessage, responseData);
+			}
+
+			const contentType = response.headers.get('content-type');
+			if (contentType && contentType.includes('application/json')) {
+				return await response.json();
+			}
+
+			return await response.text();
+		} catch (error) {
+			if (error instanceof APIError) {
+				throw error;
+			}
+			throw new APIError(0, error.message, null);
+		}
+	}
+}

package/src/core/BaseAPIService.js

@@ -0,0 +1,298 @@
+import { APIError } from '../utils/errors.js';
+
+export class BaseAPIService {
+	constructor(config = {}) {
+		this.workspace = config.workspace;
+		this.sessionToken = null;
+		this.sessionExpiry = null;
+		this.metadata = config.metadata || null;
+		this.mock = config.mock || false;
+		this.env = config.env || 'production';
+		this.baseURL = this._getBaseURL(config);
+
+		this._loadStoredSession();
+	}
+
+	_getBaseURL(config) {
+		if (config.apiUrl) return config.apiUrl;
+
+		const ENV_URLS = {
+			production: {
+				base: 'https://api.product7.io/api/v1',
+				withWorkspace: (ws) => `https://${ws}.api.product7.io/api/v1`,
+			},
+			staging: {
+				base: 'https://staging.api.product7.io/api/v1',
+				withWorkspace: (ws) => `https://${ws}.staging.api.product7.io/api/v1`,
+			},
+			localstack: {
+				base: 'http://localhost:1323/api/v1',
+				withWorkspace: (ws) => `http://${ws}.localhost:1323/api/v1`,
+			},
+		};
+
+		let env = this.env;
+		if (!env || env === 'production') {
+			const hostname =
+				(typeof window !== 'undefined' && window.location?.hostname) || '';
+			const isLocal =
+				hostname === 'localhost' ||
+				hostname === '127.0.0.1' ||
+				/^192\.168\./.test(hostname) ||
+				/^10\./.test(hostname) ||
+				/^172\.(1[6-9]|2\d|3[01])\./.test(hostname);
+			if (hostname.includes('staging') || isLocal) {
+				env = 'staging';
+			}
+		}
+
+		const envConfig = ENV_URLS[env] || ENV_URLS.production;
+		return this.workspace
+			? envConfig.withWorkspace(this.workspace)
+			: envConfig.base;
+	}
+
+	async init(metadata = null) {
+		if (metadata) {
+			this.metadata = metadata;
+		}
+
+		if (this.isSessionValid()) {
+			return { sessionToken: this.sessionToken };
+		}
+
+		if (!this.workspace || !this.metadata) {
+			throw new APIError(
+				400,
+				`Missing ${!this.workspace ? 'workspace' : 'user context'} for initialization`
+			);
+		}
+
+		if (this.mock) {
+			return this._initMockSession();
+		}
+
+		return this._initRealSession();
+	}
+
+	async _initMockSession() {
+		this.sessionToken = 'mock_session_' + Date.now();
+		this.sessionExpiry = new Date(Date.now() + 3600 * 1000);
+		this._storeSession();
+		return {
+			sessionToken: this.sessionToken,
+			config: {
+				primaryColor: '#21244A',
+				backgroundColor: '#ffffff',
+				textColor: '#1F2937',
+				boardName: 'feature-requests',
+				size: 'medium',
+				displayMode: 'modal',
+			},
+			expiresIn: 3600,
+		};
+	}
+
+	async _initRealSession() {
+		const payload = {
+			workspace: this.workspace,
+			user: this.metadata,
+		};
+
+		try {
+			const response = await this._makeRequest('/widget/init', {
+				method: 'POST',
+				body: JSON.stringify(payload),
+				headers: { 'Content-Type': 'application/json' },
+			});
+			const initData = this._extractInitResponseData(response);
+
+			this.sessionToken = initData.sessionToken;
+			this.sessionExpiry = new Date(Date.now() + initData.expiresIn * 1000);
+			this._storeSession();
+
+			return {
+				sessionToken: this.sessionToken,
+				config: initData.config,
+				expiresIn: initData.expiresIn,
+				status: initData.status,
+				message: initData.message,
+				configVersion: initData.configVersion,
+			};
+		} catch (error) {
+			throw new APIError(
+				error.status || 500,
+				`Failed to initialize widget: ${error.message}`,
+				error.response
+			);
+		}
+	}
+
+	_extractInitResponseData(response) {
+		const payload =
+			response && typeof response.data === 'object'
+				? response.data
+				: response || {};
+
+		const sessionToken = payload.session_token || payload.sessionToken;
+		const expiresIn = Number(payload.expires_in ?? payload.expiresIn);
+
+		if (!sessionToken) {
+			throw new APIError(500, 'Invalid init response: missing session_token');
+		}
+
+		if (!Number.isFinite(expiresIn) || expiresIn <= 0) {
+			throw new APIError(500, 'Invalid init response: missing expires_in');
+		}
+
+		return {
+			sessionToken,
+			expiresIn,
+			config:
+				payload.config && typeof payload.config === 'object'
+					? payload.config
+					: {},
+			configVersion: payload.config_version ?? payload.configVersion ?? null,
+			status: response?.status ?? payload?.status ?? true,
+			message: response?.message ?? payload?.message ?? null,
+		};
+	}
+
+	async _ensureSession() {
+		if (!this.isSessionValid()) {
+			await this.init();
+		}
+		if (!this.sessionToken) {
+			throw new APIError(401, 'No valid session token available');
+		}
+	}
+
+	async _handleAuthRetry(method, ...args) {
+		try {
+			return await method.apply(this, args);
+		} catch (error) {
+			if (error.status === 401) {
+				this.sessionToken = null;
+				this.sessionExpiry = null;
+				await this.init();
+				return await method.apply(this, args);
+			}
+			throw error;
+		}
+	}
+
+	isSessionValid() {
+		return (
+			this.sessionToken && this.sessionExpiry && new Date() < this.sessionExpiry
+		);
+	}
+
+	setMetadata(metadata) {
+		this.metadata = metadata;
+		this._storeData('product7_metadata', metadata);
+	}
+
+	getMetadata() {
+		return this.metadata;
+	}
+
+	clearSession() {
+		this.sessionToken = null;
+		this.sessionExpiry = null;
+		this._removeData('product7_session');
+		this._removeData('product7_metadata');
+	}
+
+	_storeSession() {
+		if (typeof localStorage === 'undefined') return;
+		try {
+			const sessionData = {
+				token: this.sessionToken,
+				expiry: this.sessionExpiry.toISOString(),
+				workspace: this.workspace,
+			};
+			this._storeData('product7_session', sessionData);
+		} catch (error) {
+			// Silent fail
+		}
+	}
+
+	_loadStoredSession() {
+		if (typeof localStorage === 'undefined') return false;
+		try {
+			const stored = localStorage.getItem('product7_session');
+			if (!stored) return false;
+
+			const sessionData = JSON.parse(stored);
+			this.sessionToken = sessionData.token;
+			this.sessionExpiry = new Date(sessionData.expiry);
+
+			return this.isSessionValid();
+		} catch (error) {
+			return false;
+		}
+	}
+
+	_storeData(key, value) {
+		if (typeof localStorage !== 'undefined') {
+			localStorage.setItem(key, JSON.stringify(value));
+		}
+	}
+
+	_removeData(key) {
+		if (typeof localStorage !== 'undefined') {
+			localStorage.removeItem(key);
+		}
+	}
+
+	async _makeRequest(endpoint, options = {}) {
+		const url = `${this.baseURL}${endpoint}`;
+
+		try {
+			const response = await fetch(url, options);
+
+			if (!response.ok) {
+				let errorMessage = `HTTP ${response.status}`;
+				let responseData = null;
+
+				try {
+					responseData = await response.json();
+					errorMessage =
+						responseData.message || responseData.error || errorMessage;
+				} catch (e) {
+					errorMessage = (await response.text()) || errorMessage;
+				}
+
+				throw new APIError(response.status, errorMessage, responseData);
+			}
+
+			const contentType = response.headers.get('content-type');
+			if (contentType && contentType.includes('application/json')) {
+				return await response.json();
+			}
+
+			return await response.text();
+		} catch (error) {
+			if (error instanceof APIError) throw error;
+			throw new APIError(0, error.message, null);
+		}
+	}
+
+	_buildQueryParams(params) {
+		const queryParams = new URLSearchParams();
+		Object.entries(params).forEach(([key, value]) => {
+			if (value !== undefined && value !== null) {
+				queryParams.append(
+					key,
+					typeof value === 'object' ? JSON.stringify(value) : value
+				);
+			}
+		});
+		return queryParams.toString();
+	}
+
+	_getEndpointWithParams(endpoint, params) {
+		const queryString = this._buildQueryParams(params);
+		return `${endpoint}${queryString ? '?' + queryString : ''}`;
+	}
+}

package/src/core/EventBus.js

@@ -0,0 +1,54 @@
+export class EventBus {
+	constructor() {
+		this.events = new Map();
+	}
+
+	on(event, callback) {
+		if (!this.events.has(event)) {
+			this.events.set(event, []);
+		}
+		this.events.get(event).push(callback);
+
+		return () => this.off(event, callback);
+	}
+
+	off(event, callback) {
+		const callbacks = this.events.get(event);
+		if (callbacks) {
+			const index = callbacks.indexOf(callback);
+			if (index > -1) {
+				callbacks.splice(index, 1);
+			}
+		}
+	}
+
+	emit(event, data) {
+		const callbacks = this.events.get(event);
+		if (callbacks) {
+			callbacks.forEach((callback) => {
+				try {
+					callback(data);
+				} catch (error) {
+					console.error('[Product7] Event callback error:', error);
+				}
+			});
+		}
+	}
+
+	once(event, callback) {
+		const unsubscribe = this.on(event, (data) => {
+			callback(data);
+			unsubscribe();
+		});
+		return unsubscribe;
+	}
+
+	clear() {
+		this.events.clear();
+	}
+
+	getListenerCount(event) {
+		const callbacks = this.events.get(event);
+		return callbacks ? callbacks.length : 0;
+	}
+}