@product7/product7-js 0.1.0

package/src/core/Product7.js

@@ -0,0 +1,812 @@
+import { ConfigError, SDKError } from '../utils/errors.js';
+import { deepMerge, generateId } from '../utils/helpers.js';
+import { WidgetFactory } from '../widgets/WidgetFactory.js';
+import { APIService } from './APIService.js';
+import { EventBus } from './EventBus.js';
+
+export class Product7 {
+	constructor(config = {}) {
+		this.config = this._validateAndMergeConfig(config);
+		this.initialized = false;
+		this.widgets = new Map();
+		this.eventBus = new EventBus();
+
+		this.apiService = new APIService({
+			apiUrl: this.config.apiUrl,
+			workspace: this.config.workspace,
+			siteId: this.config.siteId,
+			sessionToken: this.config.sessionToken,
+			metadata: this.config.metadata,
+			mock: this.config.mock,
+			debug: this.config.debug,
+			env: this.config.env,
+		});
+
+		this._bindMethods();
+	}
+
+	async init() {
+		if (this.initialized) {
+			return { alreadyInitialized: true };
+		}
+
+		try {
+			const initData = await this.apiService.init(this.config.metadata);
+
+			if (initData.config) {
+				this.config = deepMerge(initData.config, this.config);
+			}
+
+			this.initialized = true;
+			this.eventBus.emit('sdk:initialized', {
+				config: this.config,
+				sessionToken: initData.sessionToken,
+			});
+
+			return {
+				initialized: true,
+				config: initData.config || {},
+				sessionToken: initData.sessionToken,
+				expiresIn: initData.expiresIn,
+			};
+		} catch (error) {
+			this.eventBus.emit('sdk:error', { error });
+			throw new SDKError(`Failed to initialize SDK: ${error.message}`, error);
+		}
+	}
+
+	createWidget(type = 'button', options = {}) {
+		if (!this.initialized) {
+			throw new SDKError(
+				'SDK must be initialized before creating widgets. Call init() first.'
+			);
+		}
+
+		const widgetId = generateId('widget');
+		const widgetConfig = this._getWidgetTypeConfig(type);
+		const explicitOptions = this._omitUndefined(options);
+		const widgetEnabled = this._isWidgetEnabled(type, {
+			...widgetConfig,
+			...explicitOptions,
+		});
+		const widgetOptions = {
+			id: widgetId,
+			sdk: this,
+			apiService: this.apiService,
+			...this.config,
+			...widgetConfig,
+			...explicitOptions,
+			enabled: widgetEnabled,
+		};
+
+		try {
+			const widget = WidgetFactory.create(type, widgetOptions);
+			this.widgets.set(widgetId, widget);
+			this.eventBus.emit('widget:created', { widget, type });
+			return widget;
+		} catch (error) {
+			throw new SDKError(`Failed to create widget: ${error.message}`, error);
+		}
+	}
+
+	getWidget(id) {
+		return this.widgets.get(id);
+	}
+
+	async getActiveSurveys(context = {}) {
+		if (!this.initialized) {
+			throw new SDKError(
+				'SDK must be initialized before fetching surveys. Call init() first.'
+			);
+		}
+
+		try {
+			const result = await this.apiService.getActiveSurveys(context);
+			const surveys = (result.data || []).map((survey) =>
+				this._normalizeSurveyConfig(survey)
+			);
+			if (context.includeIneligible) {
+				return surveys;
+			}
+			return surveys.filter((survey) => this._isSurveyEligible(survey));
+		} catch (error) {
+			this.eventBus.emit('sdk:error', { error });
+			throw new SDKError(
+				`Failed to fetch active surveys: ${error.message}`,
+				error
+			);
+		}
+	}
+
+	async showSurveyById(surveyId, options = {}) {
+		if (!this.initialized) {
+			throw new SDKError(
+				'SDK must be initialized before showing surveys. Call init() first.'
+			);
+		}
+
+		const { context = {}, ...displayOptions } = options;
+		const surveys = await this.getActiveSurveys({
+			...context,
+			includeEligibility: true,
+			includeIneligible: true,
+		});
+		const surveyConfig = surveys.find((s) => s.id === surveyId);
+
+		if (!surveyConfig) {
+			throw new SDKError(
+				`Survey with ID '${surveyId}' not found or not active`
+			);
+		}
+
+		if (!this._isSurveyEligible(surveyConfig)) {
+			this.eventBus.emit('survey:suppressed', {
+				surveyId,
+				reason: this._getSurveyIneligibilityReason(surveyConfig),
+				survey: surveyConfig,
+			});
+			return null;
+		}
+
+		return this.showSurvey({
+			surveyId: surveyConfig.id,
+			surveyType: surveyConfig.surveyType || surveyConfig.type,
+			title: surveyConfig.title,
+			description: surveyConfig.description,
+			lowLabel: surveyConfig.lowLabel || surveyConfig.low_label,
+			highLabel: surveyConfig.highLabel || surveyConfig.high_label,
+			ratingScale: surveyConfig.ratingScale ?? surveyConfig.rating_scale,
+			showFeedbackInput:
+				surveyConfig.showFeedbackInput ?? surveyConfig.show_feedback_input,
+			showSubmitButton:
+				surveyConfig.showSubmitButton ?? surveyConfig.show_submit_button,
+			autoSubmitOnSelect:
+				surveyConfig.autoSubmitOnSelect ?? surveyConfig.auto_submit_on_select,
+			showTitle: surveyConfig.showTitle ?? surveyConfig.show_title,
+			showDescription:
+				surveyConfig.showDescription ?? surveyConfig.show_description,
+			customQuestions: surveyConfig.customQuestions || surveyConfig.questions,
+			pages: surveyConfig.pages,
+			enabled: surveyConfig.enabled,
+			...displayOptions,
+		});
+	}
+
+	showSurvey(options = {}) {
+		if (!this.initialized) {
+			throw new SDKError(
+				'SDK must be initialized before showing surveys. Call init() first.'
+			);
+		}
+
+		if (!this._isSurveyEligible(options)) {
+			this.eventBus.emit('survey:suppressed', {
+				surveyId: options.surveyId || options.id || null,
+				reason: this._getSurveyIneligibilityReason(options),
+				survey: options,
+			});
+			return null;
+		}
+
+		const normalizedOptions = this._normalizeSurveyConfig(options);
+		const surveyConfigDefaults = this._getWidgetTypeConfig('survey');
+		const surveyEnabled = this._isWidgetEnabled('survey', normalizedOptions);
+
+		if (!surveyEnabled) {
+			this.eventBus.emit('survey:suppressed', {
+				surveyId:
+					normalizedOptions.surveyId ||
+					normalizedOptions.id ||
+					options.id ||
+					null,
+				reason: 'disabled',
+				survey: normalizedOptions,
+			});
+			return null;
+		}
+
+		const surveyWidget = this.createWidget('survey', {
+			surveyId: normalizedOptions.surveyId,
+			surveyType:
+				normalizedOptions.surveyType || normalizedOptions.type || 'nps',
+			position:
+				normalizedOptions.position ??
+				surveyConfigDefaults.position ??
+				this.config.position ??
+				'right',
+			theme:
+				normalizedOptions.theme ??
+				surveyConfigDefaults.theme ??
+				this.config.theme ??
+				'light',
+			title: normalizedOptions.title,
+			description: normalizedOptions.description,
+			lowLabel: normalizedOptions.lowLabel,
+			highLabel: normalizedOptions.highLabel,
+			ratingScale: normalizedOptions.ratingScale ?? normalizedOptions.scale,
+			showFeedbackInput: normalizedOptions.showFeedbackInput,
+			showSubmitButton: normalizedOptions.showSubmitButton,
+			autoSubmitOnSelect: normalizedOptions.autoSubmitOnSelect,
+			showTitle: normalizedOptions.showTitle,
+			showDescription: normalizedOptions.showDescription,
+			customQuestions: normalizedOptions.customQuestions,
+			pages: normalizedOptions.pages,
+			respondentId: normalizedOptions.respondentId,
+			email: normalizedOptions.email,
+			onSubmit: normalizedOptions.onSubmit,
+			onDismiss: normalizedOptions.onDismiss,
+			enabled: surveyEnabled,
+		});
+
+		surveyWidget.mount();
+		surveyWidget.show();
+
+		return surveyWidget;
+	}
+
+	_isSurveyEligible(survey = {}) {
+		const shouldShow = this._getSurveyField(survey, [
+			'shouldShow',
+			'should_show',
+		]);
+		if (typeof shouldShow === 'boolean') {
+			return shouldShow;
+		}
+
+		const eligibilityShouldShow = this._getSurveyField(
+			survey.eligibility || {},
+			['shouldShow', 'should_show']
+		);
+		if (typeof eligibilityShouldShow === 'boolean') {
+			return eligibilityShouldShow;
+		}
+
+		const eligible = this._getSurveyField(survey, [
+			'eligible',
+			'isEligible',
+			'is_eligible',
+		]);
+		if (typeof eligible === 'boolean') {
+			return eligible;
+		}
+
+		const isAnswered = this._getSurveyField(survey, [
+			'isAnswered',
+			'is_answered',
+		]);
+		if (typeof isAnswered === 'boolean') {
+			return !isAnswered;
+		}
+
+		const eligibilityAnswered = this._getSurveyField(survey.eligibility || {}, [
+			'isAnswered',
+			'is_answered',
+		]);
+		if (typeof eligibilityAnswered === 'boolean') {
+			return !eligibilityAnswered;
+		}
+
+		return true;
+	}
+
+	_getSurveyIneligibilityReason(survey = {}) {
+		const explicitReason = this._getSurveyField(survey, [
+			'reason',
+			'suppressionReason',
+			'suppression_reason',
+		]);
+		if (explicitReason) {
+			return explicitReason;
+		}
+
+		const eligibilityReason = this._getSurveyField(survey.eligibility || {}, [
+			'reason',
+			'suppressionReason',
+			'suppression_reason',
+		]);
+		if (eligibilityReason) {
+			return eligibilityReason;
+		}
+
+		const isAnswered = this._getSurveyField(survey, [
+			'isAnswered',
+			'is_answered',
+		]);
+		if (isAnswered === true) {
+			return 'already_answered';
+		}
+
+		return 'ineligible';
+	}
+
+	_normalizeSurveyConfig(survey = {}) {
+		const firstPage =
+			Array.isArray(survey.pages) && survey.pages.length > 0
+				? survey.pages[0]
+				: null;
+		const ratingConfig = firstPage
+			? firstPage.rating_config || firstPage.ratingConfig || {}
+			: {};
+
+		const inferredType =
+			survey.surveyType ||
+			survey.survey_type ||
+			survey.type ||
+			this._inferSurveyTypeFromPage(firstPage) ||
+			'nps';
+
+		return {
+			...survey,
+			surveyId: survey.surveyId || survey.survey_id || survey.id || null,
+			surveyType: survey.surveyType || survey.survey_type || inferredType,
+			type: survey.type || survey.survey_type || inferredType,
+			enabled: typeof survey.enabled === 'boolean' ? survey.enabled : undefined,
+			should_show:
+				survey.should_show ??
+				(survey.eligibility ? survey.eligibility.should_show : undefined),
+			reason:
+				survey.reason ||
+				(survey.eligibility ? survey.eligibility.reason : undefined),
+			title:
+				survey.title || survey.name || (firstPage ? firstPage.title : null),
+			description:
+				survey.description || (firstPage ? firstPage.description : null),
+			lowLabel:
+				survey.lowLabel || survey.low_label || ratingConfig.low_label || null,
+			highLabel:
+				survey.highLabel ||
+				survey.high_label ||
+				ratingConfig.high_label ||
+				null,
+			ratingScale:
+				survey.ratingScale ?? survey.rating_scale ?? ratingConfig.scale ?? null,
+			showFeedbackInput:
+				survey.showFeedbackInput ?? survey.show_feedback_input ?? null,
+			showSubmitButton:
+				survey.showSubmitButton ?? survey.show_submit_button ?? null,
+			autoSubmitOnSelect:
+				survey.autoSubmitOnSelect ?? survey.auto_submit_on_select ?? null,
+			showTitle: survey.showTitle ?? survey.show_title ?? null,
+			showDescription:
+				survey.showDescription ?? survey.show_description ?? null,
+			customQuestions:
+				survey.customQuestions ||
+				survey.custom_questions ||
+				survey.questions ||
+				[],
+			pages: this._normalizeSurveyPages(survey.pages || []),
+		};
+	}
+
+	_normalizeSurveyPages(pages = []) {
+		if (!Array.isArray(pages)) {
+			return [];
+		}
+
+		return pages
+			.map((page, index) => ({
+				id: page.id || `page_${index}`,
+				type: page.type || 'rating',
+				title: page.title || '',
+				description: page.description || '',
+				placeholder: page.placeholder || '',
+				required: page.required !== false,
+				position: page.position ?? index,
+				ratingConfig: page.ratingConfig || page.rating_config || null,
+				multipleChoiceConfig:
+					page.multipleChoiceConfig || page.multiple_choice_config || null,
+				linkConfig: page.linkConfig || page.link_config || null,
+				afterThisPage: page.afterThisPage || page.after_this_page || null,
+			}))
+			.sort((a, b) => a.position - b.position);
+	}
+
+	_inferSurveyTypeFromPage(page) {
+		if (!page) return null;
+		const ratingConfig = page.rating_config || page.ratingConfig || {};
+		const scale = ratingConfig.scale;
+		const surveyType = ratingConfig.survey_type;
+		const title = (page.title || '').toLowerCase();
+
+		if (scale === 11 || surveyType === 'nps') {
+			return 'nps';
+		}
+
+		const lowLabel = (ratingConfig.low_label || '').toLowerCase();
+		if (
+			surveyType === 'ces' ||
+			title.includes('effort') ||
+			title.includes('easy') ||
+			lowLabel.includes('difficult')
+		) {
+			return 'ces';
+		}
+
+		return 'csat';
+	}
+
+	_getSurveyField(survey, fields) {
+		for (const field of fields) {
+			if (survey[field] !== undefined && survey[field] !== null) {
+				return survey[field];
+			}
+		}
+		return null;
+	}
+
+	_getWidgetTypeConfig(type) {
+		const widgetsConfig = this._isPlainObject(this.config?.widgets)
+			? this.config.widgets
+			: {};
+
+		const legacyTypeConfig = this._isPlainObject(this.config?.[type])
+			? this.config[type]
+			: {};
+
+		const namespacedTypeConfig = this._isPlainObject(widgetsConfig?.[type])
+			? widgetsConfig[type]
+			: {};
+
+		const mergedTypeConfig = deepMerge(legacyTypeConfig, namespacedTypeConfig);
+		return this._toCamelCaseObject(mergedTypeConfig);
+	}
+
+	_isWidgetEnabled(type, options = {}) {
+		const typeConfig = this._getWidgetTypeConfig(type);
+		if (typeConfig.enabled === false) {
+			return false;
+		}
+
+		if (typeof options.enabled === 'boolean') {
+			return options.enabled;
+		}
+
+		if (typeof typeConfig.enabled === 'boolean') {
+			return typeConfig.enabled;
+		}
+
+		return true;
+	}
+
+	_isPlainObject(value) {
+		return Object.prototype.toString.call(value) === '[object Object]';
+	}
+
+	_toCamelCaseKey(key) {
+		return key.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+	}
+
+	_toCamelCaseObject(value) {
+		if (Array.isArray(value)) {
+			return value.map((item) => this._toCamelCaseObject(item));
+		}
+
+		if (!this._isPlainObject(value)) {
+			return value;
+		}
+
+		const normalized = {};
+		for (const [key, nestedValue] of Object.entries(value)) {
+			normalized[this._toCamelCaseKey(key)] =
+				this._toCamelCaseObject(nestedValue);
+		}
+		return normalized;
+	}
+
+	_omitUndefined(value) {
+		if (!this._isPlainObject(value)) {
+			return value;
+		}
+
+		return Object.fromEntries(
+			Object.entries(value).filter(
+				([, nestedValue]) => nestedValue !== undefined
+			)
+		);
+	}
+
+	showChangelog(options = {}) {
+		if (!this.initialized) {
+			throw new SDKError(
+				'SDK must be initialized before showing changelog. Call init() first.'
+			);
+		}
+
+		const defaults = {
+			position: this.config.position || 'right',
+			theme: this.config.theme || 'light',
+			title: "What's New",
+			triggerText: "What's New",
+			showBadge: true,
+			viewButtonText: 'View Update',
+			showBackdrop: true,
+		};
+
+		const configDefaults = this._getWidgetTypeConfig('changelog');
+		const explicitOptions = this._omitUndefined(options);
+		const changelogEnabled = this._isWidgetEnabled(
+			'changelog',
+			explicitOptions
+		);
+
+		if (!changelogEnabled) {
+			this.eventBus.emit('widget:suppressed', {
+				type: 'changelog',
+				reason: 'disabled',
+			});
+			return null;
+		}
+
+		const changelogWidget = this.createWidget('changelog', {
+			...defaults,
+			...configDefaults,
+			...explicitOptions,
+			enabled: changelogEnabled,
+		});
+
+		changelogWidget.mount();
+		changelogWidget.show();
+
+		return changelogWidget;
+	}
+
+	async getChangelogs(options = {}) {
+		if (!this.initialized) {
+			throw new SDKError(
+				'SDK must be initialized before fetching changelogs. Call init() first.'
+			);
+		}
+
+		try {
+			const result = await this.apiService.getChangelogs(options);
+			return result.data || [];
+		} catch (error) {
+			this.eventBus.emit('sdk:error', { error });
+			throw new SDKError(`Failed to fetch changelogs: ${error.message}`, error);
+		}
+	}
+
+	getAllWidgets() {
+		return Array.from(this.widgets.values());
+	}
+
+	destroyWidget(id) {
+		const widget = this.widgets.get(id);
+		if (widget) {
+			widget.destroy();
+			this.widgets.delete(id);
+			this.eventBus.emit('widget:removed', { widgetId: id });
+			return true;
+		}
+		return false;
+	}
+
+	destroyAllWidgets() {
+		for (const widget of this.widgets.values()) {
+			widget.destroy();
+		}
+		this.widgets.clear();
+		this.eventBus.emit('widgets:cleared');
+	}
+
+	updateConfig(newConfig) {
+		const oldConfig = { ...this.config };
+		this.config = this._validateAndMergeConfig(newConfig, this.config);
+
+		for (const widget of this.widgets.values()) {
+			widget.handleConfigUpdate(this.config);
+		}
+
+		this.eventBus.emit('config:updated', {
+			oldConfig,
+			newConfig: this.config,
+		});
+	}
+
+	setMetadata(metadata) {
+		this.config.metadata = metadata;
+		if (this.apiService) {
+			this.apiService.setMetadata(metadata);
+		}
+		this.eventBus.emit('metadata:updated', { metadata });
+	}
+
+	getMetadata() {
+		return (
+			this.config.metadata ||
+			(this.apiService ? this.apiService.getMetadata() : null)
+		);
+	}
+
+	async reinitialize(newMetadata = null) {
+		this.apiService.clearSession();
+		this.initialized = false;
+
+		if (newMetadata) {
+			this.setMetadata(newMetadata);
+		}
+
+		return this.init();
+	}
+
+	on(event, callback) {
+		this.eventBus.on(event, callback);
+		return this;
+	}
+
+	off(event, callback) {
+		this.eventBus.off(event, callback);
+		return this;
+	}
+
+	once(event, callback) {
+		this.eventBus.once(event, callback);
+		return this;
+	}
+
+	emit(event, data) {
+		this.eventBus.emit(event, data);
+		return this;
+	}
+
+	destroy() {
+		this.destroyAllWidgets();
+		this.eventBus.removeAllListeners();
+		this.apiService.clearSession();
+		this.initialized = false;
+		this.eventBus.emit('sdk:destroyed');
+	}
+
+	hasFeedbackBeenSubmitted(cooldownDays = 30) {
+		const cooldownMs = cooldownDays * 24 * 60 * 60 * 1000;
+		const now = Date.now();
+
+		if (this.config.last_feedback_at) {
+			try {
+				const backendTimestamp = new Date(
+					this.config.last_feedback_at
+				).getTime();
+				if (now - backendTimestamp < cooldownMs) {
+					return true;
+				}
+			} catch (e) {
+				// Invalid date format, continue to localStorage check
+			}
+		}
+
+		try {
+			const storageKey = `feedback_submitted_${this.config.workspace}`;
+			const stored = localStorage.getItem(storageKey);
+			if (!stored) return false;
+
+			const data = JSON.parse(stored);
+			return now - data.submittedAt < cooldownMs;
+		} catch (e) {
+			return false;
+		}
+	}
+
+	clearFeedbackSubmissionTracking() {
+		try {
+			const storageKey = `feedback_submitted_${this.config.workspace}`;
+			localStorage.removeItem(storageKey);
+			this.eventBus.emit('feedback:trackingCleared');
+		} catch (e) {
+			console.warn('Failed to clear feedback tracking:', e);
+		}
+	}
+
+	_detectEnvironment() {
+		if (typeof window === 'undefined') {
+			return 'production';
+		}
+
+		const hostname = window.location.hostname.toLowerCase();
+
+		if (
+			hostname.includes('staging') ||
+			hostname.includes('localhost') ||
+			hostname.includes('127.0.0.1') ||
+			hostname.includes('.local')
+		) {
+			return 'staging';
+		}
+
+		return 'production';
+	}
+
+	_validateAndMergeConfig(newConfig, existingConfig = {}) {
+		const defaultConfig = {
+			apiUrl: null,
+			workspace: null,
+			metadata: null,
+			position: 'right',
+			theme: 'light',
+			boardName: 'general',
+			autoShow: true,
+			debug: false,
+			mock: false,
+			env: this._detectEnvironment(),
+		};
+
+		const mergedConfig = deepMerge(
+			deepMerge(defaultConfig, existingConfig),
+			newConfig
+		);
+
+		if (!newConfig.env && !existingConfig.env) {
+			mergedConfig.env = this._detectEnvironment();
+		}
+
+		if (!mergedConfig.workspace) {
+			throw new ConfigError('Missing required configuration: workspace');
+		}
+
+		if (mergedConfig.metadata) {
+			this._validateMetadata(mergedConfig.metadata);
+		}
+
+		return mergedConfig;
+	}
+
+	_validateMetadata(metadata) {
+		if (!metadata.user_id && !metadata.email) {
+			throw new ConfigError('Metadata must include at least user_id or email');
+		}
+
+		const validStructure = {
+			user_id: 'string',
+			email: 'string',
+			name: 'string',
+			custom_fields: 'object',
+			company: 'object',
+		};
+
+		for (const [key, expectedType] of Object.entries(validStructure)) {
+			if (metadata[key] && typeof metadata[key] !== expectedType) {
+				throw new ConfigError(
+					`Metadata field '${key}' must be of type '${expectedType}'`
+				);
+			}
+		}
+	}
+
+	_bindMethods() {
+		this.createWidget = this.createWidget.bind(this);
+		this.destroyWidget = this.destroyWidget.bind(this);
+		this.updateConfig = this.updateConfig.bind(this);
+	}
+
+	static create(config) {
+		return new Product7(config);
+	}
+
+	static async createAndInit(config) {
+		const sdk = new Product7(config);
+		await sdk.init();
+		return sdk;
+	}
+
+	static extractMetadataFromAuth(authData) {
+		if (!authData) return null;
+
+		return {
+			user_id: authData.sub || authData.id || authData.user_id,
+			email: authData.email,
+			name: authData.name || authData.display_name || authData.full_name,
+			custom_fields: {
+				role: authData.role,
+				plan: authData.plan || authData.subscription?.plan,
+				...(authData.custom_fields || {}),
+			},
+			company:
+				authData.company || authData.organization
+					? {
+							id: authData.company?.id || authData.organization?.id,
+							name: authData.company?.name || authData.organization?.name,
+							monthly_spend: authData.company?.monthly_spend,
+						}
+					: undefined,
+		};
+	}
+}