@constructor-io/constructorio-node 4.2.1 → 4.3.1

package/src/types/index.d.ts

@@ -0,0 +1,277 @@
+export * from './autocomplete';
+export * from './browse';
+export * from './catalog';
+export * from './quizzes';
+export * from './recommendations';
+export * from './search';
+export * from './tasks';
+export * from './tracker';
+
+export interface NetworkParameters extends Record<string, any> {
+  timeout?: number;
+}
+
+export interface ConstructorClientOptions {
+  apiKey: string;
+  apiToken?: string;
+  securityToken?: string;
+  version?: string;
+  serviceUrl?: string;
+  fetch?: () => any;
+  networkParameters?: NetworkParameters;
+}
+
+export interface UserParameters {
+  sessionId?: Number;
+  clientId?: Number;
+  userId?: string;
+  segments?: string;
+  testCells?: Record<string, any>;
+  userIp?: string;
+  userAgent?: string;
+}
+
+export interface FmtOptions extends Record<string, any> {
+  show_hidden_facets: boolean;
+  show_protected_facets: boolean;
+}
+
+export interface RequestFeature extends Record<string, any> {
+  query_items: boolean;
+  auto_generated_refined_query_rules: boolean;
+  manual_searchandizing: boolean;
+  personalization: boolean;
+  filter_items: boolean;
+}
+
+export interface RequestFeatureVariant extends Record<string, any> {
+  query_items: string;
+  auto_generated_refined_query_rules: string;
+  manual_searchandizing: string | null;
+  personalization: string;
+  filter_items: string;
+}
+
+export type ErrorData = {
+  message: string;
+  [key: string]: any;
+};
+
+export interface ResultSources extends Record<string, any> {
+  token_match: { count: number; [key: string]: any };
+  embeddings_match: { count: number; [key: string]: any };
+}
+
+export interface SortOption extends Record<string, any> {
+  sort_by: string;
+  display_name: string;
+  sort_order: string;
+  status: string;
+}
+
+export interface Feature extends Record<string, any> {
+  feature_name: string;
+  display_name: string;
+  enabled: boolean;
+  variant: {
+    name: string;
+    display_name: string;
+    [key: string]: any;
+  };
+}
+
+export interface FmtOption extends Record<string, any> {
+  groups_start: string;
+  groups_max_depth: number;
+}
+
+export type Facet = RangeFacet | OptionFacet;
+
+export interface BaseFacet extends Record<string, any> {
+  data: Record<string, any>;
+  status: Record<string, any>;
+  display_name: string;
+  name: string;
+  hidden: boolean;
+}
+
+export interface RangeFacet extends BaseFacet, Record<string, any> {
+  max: number;
+  min: number;
+  type: 'range';
+}
+
+export interface OptionFacet extends BaseFacet, Record<string, any> {
+  options: FacetOption[];
+  type: 'multiple' | 'single' | 'hierarchical';
+}
+
+export interface FacetOption extends Record<string, any> {
+  count: number;
+  display_name: string;
+  value: string;
+  options?: FacetOption[];
+  range?: ['-inf' | number, 'inf' | number];
+  status: string;
+}
+
+export interface Group extends BaseGroup, Record<string, any> {
+  count: number;
+  data: Record<string, any>;
+  parents: BaseGroup[];
+  children: Group[];
+}
+
+export interface Collection extends Record<string, any> {
+  collection_id: string;
+  display_name: string;
+  data: Record<string, any>;
+}
+
+export interface BaseGroup extends Record<string, any> {
+  display_name: string;
+  group_id: string;
+}
+
+export type Nullable<T> = T | null;
+
+export interface Item extends Record<string, any> {
+  id: string;
+  name?: string;
+  suggested_score?: number;
+  data?: ItemData;
+}
+
+export interface Variation extends Record<string, any> {
+  id: string;
+  item_id: string;
+  name?: string;
+  suggested_score?: number;
+  data?: ItemData;
+}
+
+export interface ItemData extends Record<string, any> {
+  keywords?: string[];
+  url?: string;
+  image_url?: string;
+  facets?: Record<string, any>;
+  group_ids?: string[];
+  description?: string;
+  active?: boolean;
+  deactivated?: boolean;
+}
+
+export interface ItemGroup extends Record<string, any> {
+  id: string;
+  name?: string;
+  data?: Nullable<Record<string, any>>;
+  children?: ItemGroup[];
+}
+
+export interface RedirectRuleMatchObject {
+  match_type: string;
+  pattern: string;
+}
+
+export interface RedirectRuleResponse extends Record<string, any> {
+  id: number;
+  end_time?: Nullable<string>;
+  last_updated?: Nullable<string>;
+  start_time?: Nullable<string>;
+  metadata?: Nullable<Record<string, any>>;
+  url?: string;
+  user_segments?: Nullable<string[]>;
+  matches: {
+    id: number;
+    match_type: 'EXACT' | 'UNORDERED' | 'PHRASE';
+    pattern: string;
+    [key: string]: any;
+  }[];
+}
+
+/* 4 types of facets
+    - MultipleFacetConfiguration
+    - RangeSlidersFacetConfiguration
+    - RangeOptionsStaticFacetConfiguration
+    - RangeOptionsDynamicFacetConfiguration
+*/
+
+export interface MultipleFacetConfiguration extends BaseFacetConfiguration {
+  type: 'multiple';
+}
+
+export interface RangeSlidersFacetConfiguration
+  extends RangeFacetConfiguration {
+  range_format: 'boundaries';
+}
+
+export interface RangeOptionsStaticFacetConfiguration
+  extends RangeOptionsFacetConfiguration {
+  range_type: 'static';
+  bucket_size?: number;
+  range_limits?: number[];
+}
+
+export interface RangeOptionsDynamicFacetConfiguration
+  extends RangeOptionsFacetConfiguration {
+  range_type: 'dynamic';
+}
+
+export interface RangeOptionsFacetConfiguration
+  extends RangeFacetConfiguration {
+  range_format: 'options';
+}
+
+export interface RangeFacetConfiguration extends BaseFacetConfiguration {
+  type: 'range';
+}
+
+export interface BaseFacetConfiguration {
+  name: string;
+  display_name?: string;
+  sort_order?: 'relevance' | 'value' | 'num_matches';
+  sort_descending?: boolean;
+  range_inclusive?: Nullable<string>;
+  match_type?: 'any' | 'all' | 'none';
+  position?: Nullable<number>;
+  hidden?: boolean;
+  protected?: boolean;
+  data?: object;
+  section?: string;
+  options?: Record<string, any>[];
+  range_format: 'options' | 'boundaries' | null;
+  range_type: 'static' | 'dynamic' | null;
+  bucket_size?: number | null;
+  range_limits?: number[] | null;
+}
+
+export type FacetConfiguration =
+  | MultipleFacetConfiguration
+  | RangeSlidersFacetConfiguration
+  | RangeOptionsStaticFacetConfiguration
+  | RangeOptionsDynamicFacetConfiguration;
+
+export interface FacetOptionConfiguration {
+  value: string;
+  value_alias?: Nullable<string>;
+  display_name?: string;
+  position?: Nullable<number>;
+  hidden?: boolean;
+  data?: Nullable<Record<string, any>>;
+}
+
+export interface OneWaySynonymRelation extends Record<string, any> {
+  parent_phrase: string;
+  child_phrases: {
+    automatically_generated: boolean;
+    phrase: string;
+    created_at: string;
+    updated_at: string;
+    [key: string]: any;
+  }[];
+}
+
+export interface SynonymGroup extends Record<string, any> {
+  synonym_group_id: number;
+  synonyms: string[];
+}

package/src/types/quizzes.d.ts

@@ -0,0 +1,73 @@
+import { ConstructorClientOptions, NetworkParameters, UserParameters } from '.';
+
+export default Quizzes;
+
+export interface QuizzesParameters {
+  section?: string;
+  answers?: any[];
+  versionId?: string;
+}
+
+declare class Quizzes {
+  constructor(options: ConstructorClientOptions);
+
+  options: ConstructorClientOptions;
+
+  getQuizNextQuestion(
+    id: string,
+    parameters?: QuizzesParameters,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<NextQuestionResponse>;
+
+  getQuizResults(
+    id: string,
+    parameters?: QuizzesParameters,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<QuizResultsResponse>;
+}
+
+/* quizzes results returned from server */
+export interface NextQuestionResponse extends Record<string, any> {
+  next_question: Partial<NextQuestion>;
+  is_last_question?: boolean;
+  version_id?: string;
+}
+export interface QuizResultsResponse extends Record<string, any> {
+  result: Partial<QuizResult>;
+  version_id?: string;
+}
+
+export interface NextQuestion extends Record<string, any> {
+  id: number;
+  title: string;
+  description: string;
+  type: 'single' | 'multiple' | 'open' | 'cover';
+  cta_text: string;
+  images: Partial<QuestionImages>;
+  options: Partial<QuestionOption>[];
+  input_placeholder: string;
+}
+
+export interface QuizResult extends Record<string, any> {
+  filter_expression: Record<string, any>;
+  results_url: string;
+}
+
+export interface QuestionOption extends Record<string, any> {
+  id: number;
+  value: string;
+  attribute: {
+    name: string;
+    value: string;
+  };
+  images: Partial<QuestionImages>;
+}
+
+export interface QuestionImages extends Record<string, any> {
+  primary_url: string;
+  primary_alt: string;
+  secondary_url: string;
+  secondary_alt: string;
+}

package/src/types/recommendations.d.ts

@@ -0,0 +1,64 @@
+import { ConstructorClientOptions, NetworkParameters, UserParameters } from '.';
+
+export default Recommendations;
+
+interface RecommendationsParameters {
+  itemIds?: string | string[];
+  numResults?: number;
+  section?: string;
+  term?: string;
+  filters?: Record<string, any>;
+  variationsMap?: Record<string, any>;
+}
+
+declare class Recommendations {
+  constructor(options: ConstructorClientOptions);
+
+  options: ConstructorClientOptions;
+
+  getRecommendations(
+    podId: string,
+    parameters?: RecommendationsParameters,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<RecommendationsResponse>;
+}
+
+/* Recommendations results returned from server */
+export interface RecommendationsResponse extends Record<string, any> {
+  request: Partial<RecommendationsRequestType>;
+  response: Partial<RecommendationsResponseType>;
+  result_id: string;
+}
+
+export interface RecommendationsRequestType extends Record<string, any> {
+  num_results: number;
+  item_id: string;
+  filters: {
+    group_id: string;
+    [key: string]: any;
+  };
+  pod_id: string;
+}
+
+export interface RecommendationsResponseType extends Record<string, any> {
+  results: Partial<RecommendationsResultType>;
+  total_num_results: number;
+  pod: {
+    id: string;
+    display_name: string;
+    [key: string]: any;
+  };
+}
+
+export interface RecommendationsResultType extends Record<string, any> {
+  matched_terms: string[];
+  data: Record<string, any>;
+  value: string;
+  is_slotted: boolean;
+  labels: Record<string, any>;
+  strategy: {
+    id: string;
+    [key: string]: any;
+  };
+}

package/src/types/search.d.ts

@@ -0,0 +1,98 @@
+import {
+  ConstructorClientOptions,
+  Facet,
+  Feature,
+  FmtOption,
+  Group,
+  NetworkParameters,
+  RequestFeature,
+  RequestFeatureVariant,
+  ResultSources,
+  SortOption,
+  UserParameters,
+} from '.';
+
+export default Search;
+
+export interface SearchParameters {
+  page?: number;
+  resultsPerPage?: number;
+  filters?: Record<string, any>;
+  sortBy?: string;
+  sortOrder?: string;
+  section?: string;
+  fmtOptions?: Record<string, any>;
+  hiddenFields?: string[];
+  hiddenFacets?: string[];
+  variationsMap?: Record<string, any>;
+}
+
+declare class Search {
+  constructor(options: ConstructorClientOptions);
+
+  options: ConstructorClientOptions;
+
+  getSearchResults(
+    query: string,
+    parameters?: SearchParameters,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<SearchResponse>;
+}
+
+/* search results returned from server */
+export interface SearchResponse {
+  request: Partial<SearchRequestType>;
+  response: Partial<Response | Redirect>;
+  result_id: string;
+}
+
+export interface Response extends Record<string, any> {
+  result_sources: Partial<ResultSources>;
+  facets: Partial<Facet>[];
+  groups: Partial<Group>[];
+  results: Partial<SearchResultType>[];
+  sort_options: Partial<SortOption>[];
+  refined_content: Record<string, any>[];
+  total_num_results: number;
+  features: Partial<Feature>[];
+}
+
+export interface SearchRequestType extends Record<string, any> {
+  page: number;
+  num_results_per_page: number;
+  section: string;
+  blacklist_rules: boolean;
+  term: string;
+  fmt_options: Partial<FmtOption>;
+  sort_by: string;
+  sort_order: string;
+  features: Partial<RequestFeature>;
+  feature_variants: Partial<RequestFeatureVariant>;
+  searchandized_items: Record<string, any>;
+}
+
+export interface SearchResultType extends Record<string, any> {
+  matched_terms: string[];
+  data: {
+    id: string;
+    [key: string]: any;
+  };
+  value: string;
+  is_slotted: false;
+  labels: Record<string, any>;
+  variations: Record<string, any>[];
+}
+
+export interface Redirect extends Record<string, any> {
+  redirect: {
+    data: {
+      match_id: number;
+      rule_id: number;
+      url: string;
+      [key: string]: any;
+    };
+    matched_terms: string[];
+    matched_user_segments: string[];
+  };
+}

package/src/types/tasks.d.ts

@@ -0,0 +1,70 @@
+import { ConstructorClientOptions, NetworkParameters } from '.';
+
+export default Tasks;
+
+export interface TasksParameters {
+  numResultsPerPage?: number;
+  page?: number;
+  startDate?: string;
+  endDate?: string;
+  status?: string;
+  type?: string;
+}
+
+declare class Tasks {
+  constructor(options: ConstructorClientOptions);
+
+  options: ConstructorClientOptions;
+
+  getAllTasks(
+    parameters?: TasksParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<TasksResponseType>;
+
+  getTask(
+    parameters?: {
+      id: string;
+    },
+    networkParameters?: NetworkParameters
+  ): Promise<Task>;
+}
+
+/* tasks results returned from server */
+export interface TasksResponseType {
+  total_count: number;
+  tasks: Partial<Task>[];
+  status_counts: {
+    QUEUED: number;
+    DONE: number;
+    IN_PROGRESS: number;
+    FAILED: number;
+    CANCELED: number;
+  };
+}
+
+export type TaskStatus = 'QUEUED' | 'DONE' | 'FAILED' | 'IN_PROGRESS';
+
+export interface Task extends Record<string, any> {
+  id: number;
+  type: 'ingestion' | 'user_data_request';
+  status: TaskStatus;
+  submission_time: string;
+  last_update: string;
+  filename: string;
+  protocol: 'ftp' | 'http' | null;
+  result?: {
+    changelog?: Partial<ChangeLog>;
+  };
+}
+
+export interface ChangeLog extends Record<string, any> {
+  sections?: {
+    [key: string]: {
+      items_updated: number;
+      items_deleted: number;
+      variations_updated: number;
+      variations_deleted: number;
+    };
+  };
+  index_built: boolean;
+}

package/src/types/tests/autocomplete.test-d.ts

@@ -0,0 +1,59 @@
+import { expectAssignable } from 'tsd';
+import { AutocompleteResponse } from '../autocomplete';
+
+expectAssignable<AutocompleteResponse>({
+  sections: {
+    Products: [
+      {
+        matched_terms: ['red'],
+        data: {
+          id: 'ABC',
+          url: 'https://example',
+        },
+        value: 'ABC',
+        is_slotted: false,
+        labels: {},
+        variations: [
+          {
+            data: {
+              url: 'https://example',
+              name: 'Orange, One Size / Fitment 6',
+            },
+            value: 'ABC',
+          },
+        ],
+      },
+    ],
+    'Search Suggestions': [
+      {
+        matched_terms: ['red'],
+        data: {
+          id: 'ABC',
+        },
+        value: 'ABC',
+        is_slotted: false,
+        labels: {},
+      },
+    ],
+  },
+  result_id: '5a7e6a84-5ded-4315-83b5-71f08c175a4a',
+  request: {
+    query: 'red',
+    term: 'red',
+    features: {
+      query_items: true,
+      auto_generated_refined_query_rules: true,
+      manual_searchandizing: true,
+      personalization: true,
+      filter_items: true,
+    },
+    feature_variants: {
+      query_items: 'query_items',
+      auto_generated_refined_query_rules: 'default_rules',
+      manual_searchandizing: null,
+      personalization: 'default_personalization',
+      filter_items: 'filter_items_w_and_purchases',
+    },
+    searchandized_items: {},
+  },
+});