@geins/core 0.3.0-canary

package/src/api-client/merchantApiClient.ts

@@ -0,0 +1,153 @@
+import { CookieService } from '../services/cookieService';
+import { AUTH_COOKIES } from '../constants';
+import {
+  ApolloClient,
+  InMemoryCache,
+  NormalizedCacheObject,
+  DocumentNode,
+  FetchPolicy,
+  ApolloQueryResult,
+  FetchResult,
+  OperationVariables,
+} from '@apollo/client/core';
+
+export enum FetchPolicyOptions {
+  CACHE_FIRST = 'cache-first',
+  NETWORK_ONLY = 'network-only',
+  CACHE_ONLY = 'cache-only',
+  NO_CACHE = 'no-cache',
+  STANDBY = 'standby',
+}
+
+export enum OperationType {
+  QUERY = 'query',
+  MUTATION = 'mutation',
+}
+
+export interface RequestOptions {
+  fetchPolicy?: FetchPolicy;
+  pollInterval?: number;
+  context?: any;
+  [key: string]: any;
+}
+
+export interface MerchantApiClientOptions {
+  apiUrl: string;
+  apiKey: string;
+  fetchPolicy?: FetchPolicy;
+  userToken?: string;
+}
+
+export interface GraphQLQueryOptions {
+  query?: any;
+  variables?: any;
+  requestOptions?: RequestOptions;
+}
+
+export class MerchantApiClient {
+  private _cookieService: CookieService | undefined;
+  private _apolloClient: ApolloClient<NormalizedCacheObject>;
+  private _userToken?: string;
+  fetchPolicy: FetchPolicy = FetchPolicyOptions.CACHE_FIRST;
+  pollInterval: number = 0;
+
+  constructor(options: MerchantApiClientOptions) {
+    const { apiUrl, apiKey, userToken, fetchPolicy } = options;
+    this._apolloClient = this.createClient(apiUrl, apiKey);
+    this._cookieService = new CookieService();
+    if (userToken) {
+      this._userToken = userToken;
+    }
+    if (fetchPolicy) {
+      this.fetchPolicy = fetchPolicy;
+    }
+  }
+
+  public updateToken(newToken?: string) {
+    this._userToken = newToken;
+  }
+  public get userToken() {
+    return this._userToken;
+  }
+
+  createClient(apiUrl: string, apiKey: string) {
+    return new ApolloClient({
+      uri: apiUrl,
+      cache: new InMemoryCache(),
+      headers: {
+        Accept: 'application/json',
+        'x-apikey': apiKey,
+      },
+    });
+  }
+
+  getClient(): ApolloClient<NormalizedCacheObject> | undefined {
+    return this._apolloClient;
+  }
+
+  public clearCacheAndRefetchQueries() {
+    this._apolloClient.resetStore();
+  }
+
+  private getFetchPolicy(operationType: OperationType, selectedFetchPolicy: FetchPolicy | undefined) {
+    if (operationType === OperationType.QUERY) {
+      if (selectedFetchPolicy) {
+        return selectedFetchPolicy;
+      } else {
+        return this.fetchPolicy;
+      }
+    }
+
+    if (
+      selectedFetchPolicy === FetchPolicyOptions.NO_CACHE ||
+      selectedFetchPolicy === FetchPolicyOptions.NETWORK_ONLY
+    ) {
+      return selectedFetchPolicy;
+    }
+
+    return FetchPolicyOptions.NETWORK_ONLY;
+  }
+
+  private getOperationObject(
+    operationType: OperationType,
+    document: DocumentNode,
+    variables: OperationVariables = {},
+    options: RequestOptions = {},
+  ) {
+    const token = this._userToken || this._cookieService?.get(AUTH_COOKIES.USER_AUTH);
+    // remove typename from variables
+
+    const operationObj: any = {
+      [operationType]: document,
+      variables,
+      fetchPolicy: this.getFetchPolicy(operationType, options.fetchPolicy),
+      pollInterval: options.pollInterval || this.pollInterval,
+    };
+
+    if (token) {
+      operationObj.context = {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      };
+    }
+
+    return operationObj;
+  }
+
+  async runQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(
+    options: GraphQLQueryOptions,
+  ): Promise<ApolloQueryResult<TData>> {
+    const { query, variables, requestOptions } = options;
+    const q = this.getOperationObject(OperationType.QUERY, query, variables, requestOptions);
+    return this._apolloClient.query<TData, TVariables>(q);
+  }
+
+  async runMutation<TData = any, TVariables extends OperationVariables = OperationVariables>(
+    options: GraphQLQueryOptions,
+  ): Promise<FetchResult<TData>> {
+    const { query, variables, requestOptions } = options;
+    const q = this.getOperationObject(OperationType.MUTATION, query, variables, requestOptions);
+    return this._apolloClient.mutate<TData, TVariables>(q);
+  }
+}

package/src/base/baseApiService.ts

@@ -0,0 +1,96 @@
+import type { GeinsSettings } from '@geins/types';
+import { GraphQLQueryOptions } from '../api-client/merchantApiClient';
+
+export abstract class BaseApiService {
+  protected _apiClient: any;
+  protected _geinsSettings: GeinsSettings;
+  protected _channelId: string;
+
+  constructor(apiClient: any, geinsSettings: GeinsSettings) {
+    this._apiClient = apiClient;
+
+    if (!geinsSettings.channel) {
+      throw new Error('Channel is required');
+    }
+
+    this._geinsSettings = geinsSettings;
+    this._channelId = `${geinsSettings.channel}|${geinsSettings.tld}`;
+  }
+
+  protected createVariables(vars: any) {
+    const variables = { ...vars };
+
+    if (!variables.languageId) {
+      if (!this._geinsSettings.locale) {
+        throw new Error('Language is required');
+      }
+      variables.languageId = this._geinsSettings.locale;
+    }
+
+    if (!variables.marketId) {
+      if (!this._geinsSettings.market) {
+        throw new Error('Market is required');
+      }
+      variables.marketId = this._geinsSettings.market;
+    }
+
+    if (!variables.channelId) {
+      variables.channelId = this._channelId;
+    }
+
+    return variables;
+  }
+
+  protected async runQuery(options: GraphQLQueryOptions) {
+    if (!this._apiClient) {
+      throw new Error('Merchant API Client is not set');
+    }
+    return this._apiClient().runQuery(options);
+  }
+
+  protected async runQueryParsed<T>(options: GraphQLQueryOptions): Promise<T> {
+    const result = this.cleanObject(await this.runQuery(options));
+    const parsedResult = this.parseResult(result);
+    return parsedResult as T;
+  }
+
+  protected async runMutation(options: GraphQLQueryOptions) {
+    if (!this._apiClient) {
+      throw new Error('Merchant API Client is not set');
+    }
+    return this._apiClient().runMutation(options);
+  }
+
+  protected parseResult(result: any): any {
+    return result;
+  }
+
+  protected cleanObject<T extends Record<string, any>>(obj: T): Partial<T> {
+    const cleanedObj = Object.entries(obj).reduce(
+      (acc, [key, value]) => {
+        // Skip __typename properties
+        if (key.startsWith('__typename')) {
+          return acc;
+        }
+
+        // Check if the value is an array, and clean each object inside it
+        if (Array.isArray(value)) {
+          acc[key] = value.map(item => (item && typeof item === 'object' ? this.cleanObject(item) : item));
+        }
+        // Recursively clean if the value is a non-null object
+        else if (value && typeof value === 'object') {
+          acc[key] = this.cleanObject(value);
+        }
+        // Otherwise, keep the value as-is
+        else {
+          acc[key] = value;
+        }
+
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+
+    return cleanedObj as Partial<T>;
+  }
+}

package/src/base/basePackage.ts

@@ -0,0 +1,39 @@
+import { GeinsCore } from '../geinsCore';
+import { MerchantApiClient } from '../api-client/merchantApiClient';
+import type { GeinsEventMessage, GeinsSettings } from '@geins/types';
+import { GeinsEventType } from '@geins/types';
+export abstract class BasePackage {
+  protected _geinsSettings: GeinsSettings;
+  protected _apiClient: () => MerchantApiClient;
+
+  constructor(protected core: GeinsCore) {
+    if (!core) {
+      throw new Error('Core is required');
+    }
+    if (!core.client) {
+      throw new Error('Merchant API Client is not set');
+    }
+    if (!core.geinsSettings) {
+      throw new Error('Settings are required');
+    }
+    const { client, geinsSettings } = core;
+    this._geinsSettings = geinsSettings;
+    this._apiClient = () => client ?? undefined;
+  }
+
+  protected pushEvent(
+    eventMessage: GeinsEventMessage,
+    eventName?: GeinsEventType,
+  ) {
+    const eventNameStr = eventName ? GeinsEventType[eventName] : undefined;
+    if (eventNameStr && eventNameStr.includes('_')) {
+      const parentEvent = eventNameStr.split('_')[0];
+      this.core.events.push(eventMessage, parentEvent);
+    }
+    this.core.events.push(eventMessage, eventNameStr);
+  }
+
+  public getCore() {
+    return this.core;
+  }
+}

package/src/base/baseStore.ts

@@ -0,0 +1,21 @@
+export abstract class BaseStore {
+  store: any;
+  constructor() {
+    this.store = this.initStore();
+  }
+  abstract initStore(): any;
+
+  abstract getKey(key: string): Promise<any>;
+
+  abstract setKey(key: string, value: string): Promise<any>;
+
+  protected abstract deleteKey(key: string): Promise<any>;
+
+  protected abstract getKeys(): Promise<string[]>;
+}
+
+export interface IStore {
+  setKey(key: string, value: string): Promise<void>;
+  getKey(key: string): Promise<string | null>;
+  getKeys(): Promise<string[]>;
+}

package/src/base/index.ts

@@ -0,0 +1,3 @@
+export * from './baseApiService';
+export * from './basePackage';
+export * from './baseStore';

package/src/constants/cookies.ts

@@ -0,0 +1,12 @@
+export const AUTH_COOKIES = {
+  USER: 'geins-user',
+  USER_AUTH: 'geins-auth',
+  USER_TYPE: 'geins-user-type',
+  USER_MAX_AGE: 'geins-user-maxage',
+  REFRESH_TOKEN: 'geins-auth-refresh-token',
+};
+
+export const AUTH_COOKIES_MAX_AGE = {
+  DEFAULT: 1800,
+  REMEMBER_USER: 604800,
+};

package/src/constants/endpoints.ts

@@ -0,0 +1,27 @@
+const API_URL = 'https://merchantapi.geins.io/graphql';
+const SIGN_URL = 'https://merchantapi.geins.io/auth/sign/{API-KEY}?identity=';
+const AUTH_URL = 'https://auth-service.geins.io/api/{ACCOUNT}_{ENV}';
+const IMAGE_URL = 'https://{ACCOUNT}.commerce.services';
+const MANAGEMENT_API_URL = 'https://mgmtapi.geins.io';
+const API_ENDPOINT_URL_HISTORY =
+  'https://merchantapi.geins.io/redirect/urlhistory';
+const API_ENDPOINT_SLUG_HISTORY =
+  'https://merchantapi.geins.io/redirect/aliashistory';
+
+const ENDPOINTS = {
+  main: API_URL,
+  auth: AUTH_URL,
+  auth_sign: SIGN_URL,
+  image: IMAGE_URL,
+};
+
+export {
+  ENDPOINTS,
+  MANAGEMENT_API_URL,
+  API_URL,
+  SIGN_URL,
+  AUTH_URL,
+  IMAGE_URL,
+  API_ENDPOINT_URL_HISTORY,
+  API_ENDPOINT_SLUG_HISTORY,
+};

package/src/constants/headerNames.ts

@@ -0,0 +1,3 @@
+export const AUTH_HEADERS = {
+  REFRESH_TOKEN: 'x-auth-refresh-token',
+};

package/src/constants/index.ts

@@ -0,0 +1,3 @@
+export * from './endpoints';
+export * from './cookies';
+export * from './headerNames';

package/src/geinsCore.ts

@@ -0,0 +1,214 @@
+import type { GeinsSettings, GeinsChannelTypeType, GeinsEndpoints, Environment } from '@geins/types';
+import { GeinsChannelInterface } from '@geins/types';
+import { MerchantApiClient } from './api-client';
+import { ChannelsService } from './services/channelsService';
+import { CookieService } from './services/cookieService';
+import { EventService } from './services/eventService';
+import { Channel } from './logic';
+import { isServerContext, buildEndpoints } from './utils';
+import { GraphQLService } from './services';
+
+export class GeinsCore {
+  // api client
+  private _endpointsUrls: any;
+  private _apiClient!: MerchantApiClient;
+  private _geinsSettings: GeinsSettings;
+  private _userToken?: string | undefined;
+
+  // exposed graphql service
+  private _graphQLService!: GraphQLService;
+
+  // cookie service
+  private _cookieService!: CookieService;
+
+  // events
+  private _eventService: EventService;
+
+  // channel
+  private _currentChannel!: Channel;
+  private _accountChannels!: ChannelsService;
+
+  constructor(geinsSettings: GeinsSettings) {
+    if (!geinsSettings.channel) {
+      throw new Error('Channel is required');
+    }
+
+    if (!geinsSettings.apiKey) {
+      throw new Error('API Key is required');
+    }
+
+    if (!geinsSettings.accountName) {
+      throw new Error('Account name is required');
+    }
+
+    // Set default environment if not provided
+    const defaultSettings: Partial<GeinsSettings> = {
+      environment: 'prod',
+    };
+
+    // Merge provided settings with defaults
+    this._geinsSettings = { ...defaultSettings, ...geinsSettings };
+
+    // Initialize API Client
+    if (this._geinsSettings.apiKey && this._geinsSettings.accountName) {
+      this._endpointsUrls = buildEndpoints(
+        this._geinsSettings.apiKey,
+        this._geinsSettings.accountName,
+        this._geinsSettings.environment,
+      );
+    }
+
+    // Initialize BroadcastChannel
+    if (!isServerContext()) {
+      this._cookieService = new CookieService();
+    }
+    this._currentChannel = new Channel(this._geinsSettings);
+
+    this._eventService = new EventService();
+  }
+
+  // Initialize API Client
+  private initApiClient() {
+    if (this._geinsSettings.apiKey && this._geinsSettings.accountName) {
+      const options = {
+        apiUrl: this._endpointsUrls.main,
+        apiKey: this._geinsSettings.apiKey,
+        userToken: this._userToken,
+      };
+      this._apiClient = new MerchantApiClient(options);
+    } else {
+      throw new Error('Failed to initialize API Client');
+    }
+  }
+
+  private initGraphQLService(): void {
+    this._graphQLService = new GraphQLService(() => this.client, this._geinsSettings);
+  }
+
+  /**
+   * Channels
+   * Methods:
+   * - current() gets the current channel for application set from the settings;
+   * - all() get all channels for the account;
+   */
+  get channel(): GeinsChannelInterface {
+    return {
+      current: this.channelGet.bind(this),
+      all: this.channelsGet.bind(this),
+    };
+  }
+
+  private async channelGet(): Promise<GeinsChannelTypeType | undefined> {
+    if (!this._currentChannel) {
+      this._currentChannel = new Channel(this._geinsSettings);
+    }
+    if (!this._currentChannel) {
+      throw new Error('Failed to initialize channel');
+    }
+    return this._currentChannel?.get() ?? undefined;
+  }
+
+  private async channelsGet(): Promise<GeinsChannelTypeType[] | undefined> {
+    if (!this._accountChannels) {
+      this._accountChannels = new ChannelsService(() => this.client, this._geinsSettings);
+    }
+    return this._accountChannels.get() ?? undefined;
+  }
+
+  /**
+   * Set the user token.
+   * @param userToken
+   */
+  public setUserToken(userToken?: string): void {
+    this._userToken = userToken;
+    if (this._apiClient) {
+      this._apiClient.updateToken(userToken);
+    }
+  }
+
+  /**
+   * Get the user token. Returns a token if user is authenticated.
+   * @returns string | undefined
+   */
+  public getUserToken(): string | undefined {
+    return this._userToken;
+  }
+
+  /**
+   * Endpoints for the current environment.
+   * - main: The main api endpoint used to query Geins.
+   * - auth: The auth endpoint.
+   * - authSign: The auth sign endpoint.
+   * - image: The base image url
+   */
+  get endpoints(): GeinsEndpoints {
+    return this._endpointsUrls;
+  }
+
+  /**
+   * Returns the API Client instance.
+   */
+  get client(): MerchantApiClient {
+    if (!this._endpointsUrls) {
+      throw new Error('Endpoints are not set');
+    }
+    if (!this._apiClient) {
+      this.initApiClient();
+    }
+    return this._apiClient;
+  }
+  /**
+   * Returns the GraphQL Client instance.
+   * @returns GraphQLClient
+   * Use to query Geins using GraphQL.
+   */
+  get graphql(): GraphQLService {
+    if (!this._graphQLService) {
+      this.initGraphQLService();
+    }
+    return this._graphQLService;
+  }
+
+  /**
+   * Returns the GeinsSettings that was used to to instance the class.
+   */
+  get geinsSettings(): GeinsSettings {
+    return this._geinsSettings;
+  }
+
+  /**
+   * Returns the EventService instance.
+   * @returns EventService
+   * @example
+   * const eventService = core.events;
+   * eventService.listnerAdd((data) => {
+   *  console.log(data);
+   * });
+   * eventService.push({
+   * subject: 'USER_LOGIN',
+   * payload: {
+   * user: 'luke.skywalker@tatooine.com',
+   * },
+   * broadcast: true,
+   * });
+   */
+  get events(): EventService {
+    return this._eventService;
+  }
+
+  /**
+   * Returns the CookieService instance.
+   * @returns CookieService
+   * @example
+   * const cookieService = core.cookies;
+   * cookieService.set('cookieName', 'cookieValue');
+   * const cookieValue = cookieService.get('cookieName');
+   *
+   */
+  get cookies(): CookieService {
+    if (!this._cookieService) {
+      this._cookieService = new CookieService();
+    }
+    return this._cookieService;
+  }
+}

package/src/graphql/channel.gql

@@ -0,0 +1,16 @@
+#import './fragments/channelFields.gql'
+#import './fragments/languageFields.gql'
+#import './fragments/marketFields.gql'
+#import './fragments/currencyFields.gql'
+
+query getChannel($channelId: String = null) {
+  channel(channelId: $channelId) {
+    ...ChannelFields
+    markets {
+      ...MarketFields
+    }
+    languages {
+      ...LanguageFields
+    }
+  }
+}

package/src/graphql/channels.gql

@@ -0,0 +1,16 @@
+#import './fragments/channelFields.gql'
+#import './fragments/languageFields.gql'
+#import './fragments/marketFields.gql'
+#import './fragments/currencyFields.gql'
+
+query getChannels {
+  channels {
+    ...ChannelFields
+    markets {
+      ...MarketFields
+    }
+    languages {
+      ...LanguageFields
+    }
+  }
+}

package/src/graphql/fragments/channelFields.gql

@@ -0,0 +1,8 @@
+fragment ChannelFields on ChannelType {
+  id
+  name
+  type
+  url
+  defaultLanguageId
+  defaultMarketId
+}

package/src/graphql/fragments/countryFields.gql

@@ -0,0 +1,4 @@
+fragment CountryFields on CountryType {
+  name
+  code
+}

package/src/graphql/fragments/currencyFields.gql

@@ -0,0 +1,4 @@
+fragment CurrencyFields on CurrencyType {
+  code
+  symbol
+}

package/src/graphql/fragments/languageFields.gql

@@ -0,0 +1,5 @@
+fragment LanguageFields on LanguageType {
+  id
+  name
+  code
+}

package/src/graphql/fragments/marketFields.gql

@@ -0,0 +1,19 @@
+#import './currencyFields.gql'
+#import './countryFields.gql'
+#import './languageFields.gql'
+fragment MarketFields on MarketType {
+  id
+  alias
+  allowedLanguages {
+    ...LanguageFields
+  }
+  country {
+    ...CountryFields
+  }
+  currency {
+    ...CurrencyFields
+  }
+  onlyDisplayInCheckout
+  virtual
+  groupKey
+}

package/src/graphql/graphql.d.ts

@@ -0,0 +1,4 @@
+declare module '*.gql' {
+  const value: string;
+  export default value;
+}

package/src/graphql/index.ts

@@ -0,0 +1 @@
+export * from './queries';

package/src/graphql/queries.ts

@@ -0,0 +1,9 @@
+import channels from './channels.gql';
+import channel from './channel.gql';
+
+const queries = {
+  channels,
+  channel,
+};
+
+export { queries };

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from '@geins/types';
+export * from './api-client';
+export * from './base';
+export * from './constants';
+export * from './geinsCore';
+export * from './services';
+export * from './stores';
+export * from './utils';
+export * from './logic';
+export { gql } from '@apollo/client/core';