@envive-ai/react-hooks 0.1.0

package/src/application/models/guards/api/isApiOrgConfigResults.ts

@@ -0,0 +1,277 @@
+import Logger from 'src/application/logging/logger';
+import {
+  StatsigExperiment as ApiOrgConfigExperiment,
+  StatsigFeatureGate as ApiOrgConfigFeatureGate,
+  OrganizationSettings as ApiOrgConfigOrganizationSettings,
+  Organization as ApiOrganization,
+  OrganizationStatusEnum,
+} from '@spiffy-ai/commerce-api-client';
+import { ApiOrganizationConfig, isApiOrganizationConfig } from './isApiOrganizationConfig';
+
+interface ApiOrgConfigResults {
+  configs: ApiOrganizationConfig[];
+  experiments: ApiOrgConfigExperiment[];
+  gates: ApiOrgConfigFeatureGate[];
+  org: ApiOrgConfigOrganizationSettings;
+}
+
+const isApiOrgConfigExperiment = (data: unknown): data is ApiOrgConfigExperiment => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: data is not an object', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if ('group' in data && typeof data.group !== 'string' && data.group !== undefined) {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgConfigExperiment: group is not a string or undefined',
+      undefined,
+      {
+        data,
+      },
+    );
+    return false;
+  }
+
+  if (
+    'group_name' in data &&
+    typeof data.group_name !== 'string' &&
+    data.group_name !== undefined
+  ) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: group_name is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if ('name' in data && typeof data.name !== 'string' && data.name !== undefined) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: name is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if ('rule_id' in data && typeof data.rule_id !== 'string' && data.rule_id !== undefined) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: rule_id is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if ('value' in data && typeof data.value !== 'object' && data.value !== undefined) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: value is not an object', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  return true;
+};
+
+const isApiOrgConfigFeatureGate = (data: unknown): data is ApiOrgConfigFeatureGate => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: data is not an object', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if ('name' in data && typeof data.name !== 'string' && data.name !== undefined) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: name is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if ('rule_id' in data && typeof data.rule_id !== 'string' && data.rule_id !== undefined) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: rule_id is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if ('value' in data && typeof data.value !== 'boolean' && data.value !== undefined) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: value is not a boolean', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  return true;
+};
+
+const isApiOrganization = (data: unknown): data is ApiOrganization => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug('[spiffy-ai] isApiOrganization: data is not an object', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (!('id' in data) || typeof data.id !== 'string') {
+    Logger.logDebug('[spiffy-ai] isApiOrganization: id is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (!('display_name' in data) || typeof data.display_name !== 'string') {
+    Logger.logDebug('[spiffy-ai] isApiOrganization: display_name is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (!('domain' in data) || typeof data.domain !== 'string') {
+    Logger.logDebug('[spiffy-ai] isApiOrganization: domain is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (!('short_name' in data) || typeof data.short_name !== 'string') {
+    Logger.logDebug('[spiffy-ai] isApiOrganization: short_name is not a string', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (
+    !('status' in data) ||
+    !Object.values(OrganizationStatusEnum).includes(data.status as OrganizationStatusEnum)
+  ) {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrganization: status is not a valid OrganizationStatusEnum value',
+      undefined,
+      {
+        data,
+      },
+    );
+    return false;
+  }
+
+  if (
+    'created_at' in data &&
+    !(data.created_at instanceof Date) &&
+    typeof data.created_at !== 'string' &&
+    data.created_at !== undefined
+  ) {
+    Logger.logDebug('[spiffy-ai] isApiOrganization: created_at is not a Date', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (
+    'updated_at' in data &&
+    !(data.updated_at instanceof Date) &&
+    typeof data.updated_at !== 'string' &&
+    data.updated_at !== undefined
+  ) {
+    Logger.logDebug('[spiffy-ai] isApiOrganization: updated_at is not a Date', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  return true;
+};
+
+const isApiOrgConfigOrganizationSettings = (
+  data: unknown,
+): data is ApiOrgConfigOrganizationSettings => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgConfigOrganizationSettings: data is not an object',
+      undefined,
+      {
+        data,
+      },
+    );
+    return false;
+  }
+
+  if (!('org' in data) || !isApiOrganization(data.org)) {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgConfigOrganizationSettings: org is not an object',
+      undefined,
+      {
+        data,
+      },
+    );
+    return false;
+  }
+
+  // skip validation for 'settings' for now
+
+  return true;
+};
+
+/**
+ *
+ * @param data
+ * @returns
+ */
+export const isApiOrgConfigResults = (data: unknown): data is Required<ApiOrgConfigResults> => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigResults: data is not an object', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (
+    !('configs' in data) ||
+    !Array.isArray(data.configs) ||
+    !data.configs.every((config) => isApiOrganizationConfig(config))
+  ) {
+    Logger.logDebug('[spiffy-ai] isApiOrgConfigResults: configs is not an array', undefined, {
+      data,
+    });
+    return false;
+  }
+
+  if (
+    'experiments' in data &&
+    data.experiments !== undefined &&
+    (!Array.isArray(data.experiments) ||
+      !data.experiments.every((exp) => isApiOrgConfigExperiment(exp)))
+  ) {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgConfigResults: experiments is not an array or contains invalid items',
+      undefined,
+      {
+        data,
+      },
+    );
+    return false;
+  }
+
+  if (
+    !('gates' in data) ||
+    !Array.isArray(data.gates) ||
+    !data.gates.every((gate) => isApiOrgConfigFeatureGate(gate))
+  ) {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgConfigResults: gates is not an array or contains invalid items',
+      undefined,
+      {
+        data,
+      },
+    );
+    return false;
+  }
+
+  if (!('org' in data) || !isApiOrgConfigOrganizationSettings(data.org)) {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgConfigResults: org is not an object or has invalid fields',
+      undefined,
+      { data },
+    );
+
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiOrganizationConfig.ts

@@ -0,0 +1,207 @@
+import Logger from 'src/application/logging/logger';
+import { OrganizationConfig } from '@spiffy-ai/commerce-api-client';
+
+// the "config" property is a generic object in the commerce api spec, these interfaces
+// are used to validate the structure of that object and to transform the api response
+// into a typed object for the frontend. Do not use these interfaces for anything else.
+interface ApiOrgAnalyticsConfigAmplitude {
+  session_replay_enabled: boolean;
+  session_replay_sample_rate: number;
+  tracking_enabled: boolean;
+}
+
+interface ApiOrgAnalyticsConfigCustomerService {
+  provider: string;
+}
+
+interface ApiOrgAnalyticsConfigGoogleAnalytics {
+  measurement_id: string;
+}
+
+interface ApiOrgAnalyticsConfig {
+  amplitude?: ApiOrgAnalyticsConfigAmplitude;
+  customer_service?: ApiOrgAnalyticsConfigCustomerService;
+  google_analytics?: ApiOrgAnalyticsConfigGoogleAnalytics;
+}
+
+export interface ApiOrganizationConfig extends OrganizationConfig {
+  config: ApiOrgAnalyticsConfig;
+}
+
+const isApiOrgAnalyticsConfigAmplitude = (
+  data: unknown,
+): data is ApiOrgAnalyticsConfigAmplitude => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug('[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: data is not an object', data);
+    return false;
+  }
+
+  if (!('session_replay_enabled' in data) || typeof data.session_replay_enabled !== 'boolean') {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_enabled is not a boolean',
+      data,
+    );
+    return false;
+  }
+
+  if (
+    !('session_replay_sample_rate' in data) ||
+    typeof data.session_replay_sample_rate !== 'number'
+  ) {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_sample_rate is not a number',
+      data,
+    );
+    return false;
+  }
+
+  if (!('tracking_enabled' in data) || typeof data.tracking_enabled !== 'boolean') {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: tracking_enabled is not a boolean',
+      data,
+    );
+    return false;
+  }
+
+  return true;
+};
+
+const isApiOrgAnalyticsConfigCustomerService = (
+  data: unknown,
+): data is ApiOrgAnalyticsConfigCustomerService => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: data is not an object',
+      data,
+    );
+    return false;
+  }
+
+  if (!('provider' in data) || typeof data.provider !== 'string') {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: provider is not a string',
+      data,
+    );
+    return false;
+  }
+
+  return true;
+};
+
+const isApiOrgAnalyticsConfigGoogleAnalytics = (
+  data: unknown,
+): data is ApiOrgAnalyticsConfigGoogleAnalytics => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: data is not an object',
+      data,
+    );
+    return false;
+  }
+
+  if (!('measurement_id' in data) || typeof data.measurement_id !== 'string') {
+    Logger.logDebug(
+      '[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: measurement_id is not a string',
+      data,
+    );
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ *
+ * @param data
+ * @returns
+ */
+const isApiOrgAnalyticsConfig = (data: unknown): data is ApiOrgAnalyticsConfig => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: data is not an object', data);
+    return false;
+  }
+
+  if (
+    'amplitude' in data &&
+    !isApiOrgAnalyticsConfigAmplitude(data.amplitude)
+  ) {
+    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: amplitude is not an object', data);
+    return false;
+  }
+
+  if (
+    'customer_service' in data &&
+    !isApiOrgAnalyticsConfigCustomerService(data.customer_service)
+  ) {
+    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: customer_service is not an object', data);
+    return false;
+  }
+
+  if (
+    'google_analytics' in data &&
+    !isApiOrgAnalyticsConfigGoogleAnalytics(data.google_analytics)
+  ) {
+    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: google_analytics is not an object', data);
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ *
+ * @param data
+ * @returns
+ */
+export const isApiOrganizationConfig = (data: unknown): data is ApiOrganizationConfig => {
+  if (data == null || typeof data !== 'object') {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: data is not an object', data);
+    return false;
+  }
+
+  if (!('created_at' in data)) {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: created_at is not defined', data);
+    return false;
+  }
+
+  if (!('namespace' in data) || typeof data.namespace !== 'string') {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: namespace is not a string', data);
+    return false;
+  }
+
+  if (!('is_latest' in data) || typeof data.is_latest !== 'boolean') {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: is_latest is not a boolean', data);
+    return false;
+  }
+
+  if (!('version' in data) || typeof data.version !== 'string') {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: version is not a string', data);
+    return false;
+  }
+
+  if (!('updated_at' in data)) {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: updated_at is not defined', data);
+    return false;
+  }
+
+  if (
+    !('config' in data) ||
+    typeof data.config !== 'object' ||
+    !isApiOrgAnalyticsConfig(data.config)
+  ) {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: config is not an object', data);
+    return false;
+  }
+
+  if ('organization_id' in data && typeof data.organization_id !== 'string') {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: organization_id is not a string', data);
+    return false;
+  }
+
+  if ('id' in data && typeof data.id !== 'string') {
+    Logger.logDebug('[spiffy-ai] isOrgConfig: id is not a string', data);
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiPDPEventAttributes.ts

@@ -0,0 +1,21 @@
+import { PDPAttributes } from '@spiffy-ai/commerce-api-client';
+
+export const isApiPDPAttributes = (data: unknown): data is PDPAttributes => {
+  if (data == null || typeof data !== 'object') {
+    return false;
+  }
+
+  if (!('product_id' in data) || typeof data.product_id !== 'string') {
+    return false;
+  }
+
+  if ('parent_product_id' in data && typeof data.parent_product_id !== 'string') {
+    return false;
+  }
+
+  if ('url' in data && data.url != null && typeof data.url !== 'string') {
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiPLPEventAttributes.ts

@@ -0,0 +1,41 @@
+import {
+  PLPAttributeCategory,
+  PLPAttributes,
+  PLPIdAttributes,
+} from '@spiffy-ai/commerce-api-client';
+
+export const isApiPLPIdAttribute = (data: unknown): data is PLPIdAttributes => {
+  if (data == null || typeof data !== 'object') {
+    return false;
+  }
+
+  if (!('id' in data) || typeof data.id !== 'string') {
+    return false;
+  }
+
+  return true;
+};
+
+export const isApiPLPEventAttributes = (data: unknown): data is PLPAttributes => {
+  if (data == null || typeof data !== 'object') {
+    return false;
+  }
+
+  if (
+    !('category' in data) ||
+    typeof data.category !== 'string' ||
+    !Object.values(PLPAttributeCategory).includes(data.category as PLPAttributeCategory)
+  ) {
+    return false;
+  }
+
+  if (
+    !('attributes' in data) ||
+    typeof data.attributes !== 'object' ||
+    !isApiPLPIdAttribute(data.attributes)
+  ) {
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiPageResponseAttributes.ts

@@ -0,0 +1,21 @@
+import { ApiPageResponseAttributes } from 'src/application/models/api/responseGenerics';
+
+export const isApiPageResponseAttributes = (obj: unknown): obj is ApiPageResponseAttributes => {
+  if (obj == null || typeof obj !== 'object') {
+    return false;
+  }
+
+  if ('title' in obj && obj.title != null && typeof obj.title !== 'string') {
+    return false;
+  }
+
+  if ('description' in obj && typeof obj.description !== 'string') {
+    return false;
+  }
+
+  if ('url' in obj && typeof obj.url !== 'string') {
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiProductResponseAttributes.ts

@@ -0,0 +1,85 @@
+import Logger from 'src/application/logging/logger';
+import { ResponseProductAttributes } from '@spiffy-ai/commerce-api-client';
+import { hasPropertyOfType } from '../utils';
+
+export const isApiProductResponseAttributes = (
+  attributes: unknown,
+): attributes is ResponseProductAttributes => {
+  if (attributes == null || typeof attributes !== 'object') {
+    Logger.logError(
+      'isApiProductResponseAttributes: attributes is null or not an object',
+      undefined,
+      {
+        attributes,
+      },
+    );
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'description', 'string', true)) {
+    Logger.logError('isApiProductResponseAttributes: description is not a string', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (
+    !hasPropertyOfType(attributes, 'image_url', 'string', true)
+  ) {
+    Logger.logError('isApiProductResponseAttributes: image_url is not a string', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'title', 'string')) {
+    Logger.logError('isApiProductResponseAttributes: title is not a string', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'url', 'string')) {
+    Logger.logError('isApiProductResponseAttributes: url is not a string', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'original_price', 'number', true)) {
+    Logger.logError('isApiProductResponseAttributes: original_price is not a number', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'sale_price', 'number', true)) {
+    Logger.logError('isApiProductResponseAttributes: sale_price is not a number', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'average_rating', 'number', true)) {
+    Logger.logError('isApiProductResponseAttributes: average_rating is not a number', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'number_reviews', 'number', true)) {
+    Logger.logError('isApiProductResponseAttributes: number_reviews is not a number', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  if (!hasPropertyOfType(attributes, 'metadata', 'array', true)) {
+    Logger.logError('isApiProductResponseAttributes: metadata is not an array', undefined, {
+      attributes,
+    });
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiProductSearchAttributes.ts

@@ -0,0 +1,23 @@
+import { ProductSearchResponseAttributes } from '@spiffy-ai/commerce-api-client';
+
+export const isApiProductSearchResponseAttributes = (
+  attributes: unknown,
+): attributes is ProductSearchResponseAttributes => {
+  if (attributes == null || typeof attributes !== 'object') {
+    return false;
+  }
+
+  if ('generated_query' in attributes && typeof attributes.generated_query !== 'string') {
+    return false;
+  }
+
+  if (
+    'product_count' in attributes &&
+    attributes.product_count != null &&
+    typeof attributes.product_count !== 'number'
+  ) {
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiProductSearchFilterAttributes.ts

@@ -0,0 +1,15 @@
+import { ProductSearchFilterResponseAttributes } from '@spiffy-ai/commerce-api-client';
+
+export const isApiProductSearchFilterResponseAttributes = (
+  attributes: unknown,
+): attributes is ProductSearchFilterResponseAttributes => {
+  if (attributes == null || typeof attributes !== 'object') {
+    return false;
+  }
+
+  if ('filter_name' in attributes && typeof attributes.filter_name !== 'string') {
+    return false;
+  }
+
+  return true;
+};

package/src/application/models/guards/api/isApiQueryTypedEventAttributes.ts

@@ -0,0 +1,4 @@
+import { QueryTypedAttributes } from '@spiffy-ai/commerce-api-client';
+
+export const isApiQueryTypedAttributes = (data: unknown): data is QueryTypedAttributes =>
+  data != null && typeof data === 'object' && 'query' in data && typeof data.query === 'string';