@geins/core 0.3.0-canary

package/src/logic/channel.ts

@@ -0,0 +1,102 @@
+import type { GeinsSettings, GeinsChannelTypeType } from '@geins/types';
+import { SimpleCache } from '../utils/simpleCache';
+import { MerchantApiClient, FetchPolicyOptions } from '../api-client';
+import { buildEndpoints } from '../utils';
+import { ChannelStore } from '../stores';
+import { ChannelService } from '../services';
+
+let instance: Channel | null = null;
+
+export class Channel {
+  private channelId: string;
+  private channelService: ChannelService | undefined;
+  private cache: SimpleCache<GeinsChannelTypeType>;
+  private store: ChannelStore | undefined;
+  private _apiClient!: () => MerchantApiClient;
+
+  constructor(private geinsSettings: GeinsSettings) {
+    if (!geinsSettings.channel) {
+      throw new Error('Channel is required');
+    }
+
+    if (!geinsSettings.apiKey) {
+      throw new Error('API Key is required');
+    }
+
+    this.store = new ChannelStore();
+    this.channelId = `${geinsSettings.channel}|${geinsSettings.tld}`;
+    this.cache = new SimpleCache<GeinsChannelTypeType>(60 * 60 * 1000);
+    this.initApiClient();
+  }
+
+  private initApiClient() {
+    if (this.geinsSettings.apiKey && this.geinsSettings.accountName) {
+      const endpointsUrls = buildEndpoints(
+        this.geinsSettings.apiKey,
+        this.geinsSettings.accountName,
+        this.geinsSettings.environment,
+      );
+      const options = {
+        apiUrl: endpointsUrls.main,
+        apiKey: this.geinsSettings.apiKey,
+        requestOptions: { fetchPolicy: FetchPolicyOptions.CACHE_FIRST },
+      };
+
+      this._apiClient = () => new MerchantApiClient(options);
+    } else {
+      throw new Error('API Key and Account Name are required');
+    }
+  }
+
+  private initChannelService() {
+    this.channelService = new ChannelService(
+      () => this._apiClient(),
+      this.geinsSettings,
+    );
+  }
+
+  public static getInstance(geinsSettings: GeinsSettings) {
+    if (!instance) {
+      instance = new Channel(geinsSettings);
+    }
+    return instance;
+  }
+
+  setKey(key: string, value: string): void {
+    if (!this.store) {
+      throw new Error('Store is not initialized');
+    }
+    this.store.setKey(key, value);
+  }
+
+  getKey(key: string): Promise<string> {
+    if (!this.store) {
+      throw new Error('Store is not initialized');
+    }
+    return this.store.getKey(key);
+  }
+
+  private async setChannel() {
+    if (!this.channelService) {
+      if (!this._apiClient) {
+        this.initApiClient();
+      }
+      this.initChannelService();
+    }
+    const channel = await this.channelService?.get(this.channelId);
+    if (channel) {
+      this.cache.set(this.channelId, channel);
+    }
+    return channel;
+  }
+
+  public async get(): Promise<GeinsChannelTypeType | undefined> {
+    const cachedChannel = this.cache.get(this.channelId);
+    if (cachedChannel) {
+      return cachedChannel;
+    }
+
+    const channel = await this.setChannel();
+    return channel ?? undefined;
+  }
+}

package/src/logic/index.ts

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

package/src/parsers/channelParser.ts

@@ -0,0 +1,91 @@
+import type {
+  GeinsChannelTypeType,
+  GeinsMarketTypeType,
+  GeinsCountryTypeType,
+  GeinsLanguageTypeType,
+  GeinsCurrencyTypeType,
+} from '@geins/types';
+
+export function parseChannelsResult(
+  result: any,
+): GeinsChannelTypeType[] | undefined {
+  if (!result || !result.data) {
+    throw new Error('Invalid result structure for channels');
+  }
+  const channels = result.data.channels;
+  if (!channels || channels.length === 0) {
+    console.warn('No channel found');
+    return undefined;
+  }
+  return channels.map((channel: any) => parseChannel(channel));
+}
+
+export function parseChannelResult(
+  result: any,
+): GeinsChannelTypeType | undefined {
+  if (!result || !result.data) {
+    throw new Error('Invalid result structure for channel');
+  }
+  const channel = result.data.channel;
+  if (!channel) {
+    console.warn('No channel found');
+    return undefined;
+  }
+  return parseChannel(channel);
+}
+export function parseChannel(channel: any): GeinsChannelTypeType | undefined {
+  if (!channel || !channel.id) {
+    throw new Error('Invalid result structure for channel');
+  }
+
+  return {
+    id: channel.id,
+    name: channel.name,
+    type: channel.type,
+    url: channel.url,
+    defaultMarketId: channel.defaultMarketId,
+    defaultLanguageId: channel.defaultLanguageId,
+    markets: channel.markets.map((item: any) => parseMarket(item)),
+    languages: channel.languages.map((item: any) => parseLanguage(item)),
+  };
+}
+
+export function parseMarket(market: any): GeinsMarketTypeType {
+  return {
+    id: market.id,
+    alias: market.alias,
+    allowedLanguages: market.allowedLanguages.map((item: any) =>
+      parseLanguage(item),
+    ),
+    country: parseCountry(market.country),
+    currency: parseCurrency(market.currency),
+    onlyDisplayInCheckout: market.onlyDisplayInCheckout,
+    virtual: market.virtual,
+    groupKey: market.groupKey,
+    defaultLanguageId: market.defaultLanguageId,
+  };
+}
+
+export function parseCountry(country: any): GeinsCountryTypeType {
+  return {
+    name: country.name,
+    code: country.code,
+  };
+}
+
+export function parseLanguage(language: any): GeinsLanguageTypeType {
+  return {
+    id: language.id,
+    name: language.name,
+    code: language.code,
+  };
+}
+
+export function parseCurrency(currency: any): GeinsCurrencyTypeType {
+  return {
+    code: currency.code,
+    symbol: currency.symbol,
+    name: currency.name,
+    rate: currency.rate,
+  };
+}

package/src/services/channelService.ts

@@ -0,0 +1,33 @@
+import type { GeinsChannelTypeType, GeinsSettings } from '@geins/types';
+import { SimpleCache } from '../utils/simpleCache';
+import { BaseApiService } from '../base/baseApiService';
+import { queries } from '../graphql';
+import { parseChannelResult } from '../parsers/channelParser';
+
+export class ChannelService extends BaseApiService {
+  private cache: SimpleCache<GeinsChannelTypeType>;
+  constructor(client: any, geinsSettings: GeinsSettings) {
+    super(client, geinsSettings);
+    this.cache = new SimpleCache<GeinsChannelTypeType>(15 * 60 * 1000); // 15 minutes cache
+  }
+  async get(channelId: string): Promise<GeinsChannelTypeType | undefined> {
+    const cacheKey = `channel_${channelId}`;
+    const cachedChannel = this.cache.get(cacheKey);
+    if (cachedChannel) {
+      return cachedChannel;
+    }
+    const options: any = {
+      query: queries.channel,
+      variables: { channelId },
+    };
+    const channel = await this.runQueryParsed<GeinsChannelTypeType>(options);
+    if (channel) {
+      this.cache.set(cacheKey, channel);
+    }
+    return channel;
+  }
+
+  protected parseResult(result: any): GeinsChannelTypeType | undefined {
+    return parseChannelResult(result);
+  }
+}

package/src/services/channelsService.ts

@@ -0,0 +1,35 @@
+import type { GeinsChannelTypeType, GeinsSettings } from '@geins/types';
+import { SimpleCache } from '../utils/simpleCache';
+import { BaseApiService } from '../base/baseApiService';
+import { queries } from '../graphql';
+import { parseChannelsResult } from '../parsers/channelParser';
+
+export class ChannelsService extends BaseApiService {
+  private cache: SimpleCache<GeinsChannelTypeType[]>;
+
+  constructor(client: any, geinsSettings: GeinsSettings) {
+    super(client, geinsSettings);
+    this.cache = new SimpleCache<GeinsChannelTypeType[]>(30 * 60 * 1000); // 30 minutes cache
+  }
+
+  async get(): Promise<GeinsChannelTypeType[] | undefined> {
+    const cacheKey = 'all_channels';
+    const cachedChannels = this.cache.get(cacheKey);
+
+    if (cachedChannels) {
+      return cachedChannels;
+    }
+    const options: any = {
+      query: queries.channels,
+      variables: {},
+    };
+    const channels = await this.runQueryParsed<GeinsChannelTypeType[]>(options);
+    if (channels) {
+      this.cache.set(cacheKey, channels);
+    }
+    return channels;
+  }
+  protected parseResult(result: any): GeinsChannelTypeType[] | undefined {
+    return parseChannelsResult(result);
+  }
+}

package/src/services/cookieService.ts

@@ -0,0 +1,168 @@
+import Cookie from 'cookie-universal';
+import { parse, type CookieSerializeOptions } from 'cookie';
+
+/**
+ * Configuration options for setting cookies.
+ */
+export interface CookieServiceConfig {
+  /**
+   * Indicates if the cookie is HTTP only.
+   * If `true`, the cookie is inaccessible to client-side scripts.
+   */
+  httpOnly?: boolean;
+
+  /**
+   * Specifies the domain for which the cookie is valid.
+   * If not specified, defaults to the host portion of the current document URL.
+   */
+  domain?: string;
+
+  /**
+   * Specifies the URL path that must exist in the requested URL for the browser to send the Cookie header.
+   * Defaults to `'/'`.
+   */
+  path?: string;
+
+  /**
+   * Indicates if the cookie should only be transmitted over secure protocols like HTTPS.
+   * If `true`, the cookie will only be sent over secure connections.
+   */
+  secure?: boolean;
+
+  /**
+   * Sets the maximum age of the cookie in seconds.
+   * Can be a number or a string representation of a number.
+   */
+  maxAge?: number | string; // maxAge can be a number or string here
+}
+
+/**
+ * Represents a cookie with a name and payload, extending the cookie configuration options.
+ */
+export interface CookieType extends CookieServiceConfig {
+  /**
+   * The name of the cookie.
+   */
+  name: string;
+
+  /**
+   * The value or data stored in the cookie.
+   */
+  payload: string;
+}
+
+/**
+ * Service for managing cookies.
+ */
+export class CookieService {
+  private path = '/';
+  private domain = '';
+  private secure = true;
+  private httpOnly = false;
+  private maxAge: number;
+  private cookie = Cookie();
+
+  /**
+   * Creates an instance of CookieService.
+   * @param {CookieServiceConfig} [config] - Optional configuration for the cookie service.
+   */
+  constructor(config?: CookieServiceConfig) {
+    this.maxAge = 0;
+    if (config) {
+      if (config.path) {
+        this.path = config.path;
+      }
+
+      if (config.domain) {
+        this.domain = config.domain;
+      }
+
+      if (config.secure !== undefined) {
+        this.secure = config.secure;
+      }
+
+      if (config.httpOnly !== undefined) {
+        this.httpOnly = config.httpOnly;
+      }
+
+      if (config.maxAge !== undefined) {
+        this.maxAge = this.parseMaxAge(config.maxAge);
+      }
+    }
+  }
+
+  /**
+   * Retrieves the current cookie configuration.
+   * @returns {CookieServiceConfig} - The current configuration settings.
+   */
+  protected getConfig(): CookieServiceConfig {
+    return {
+      path: this.path,
+      domain: this.domain,
+      secure: this.secure,
+      httpOnly: this.httpOnly,
+      maxAge: this.maxAge,
+    };
+  }
+
+  private parseMaxAge(maxAge: string | number): number {
+    if (typeof maxAge === 'string') {
+      const parsed = parseInt(maxAge, 10);
+      return isNaN(parsed) ? 0 : parsed;
+    }
+    return maxAge;
+  }
+
+  private configToCookieOptions(
+    config: CookieServiceConfig,
+  ): CookieSerializeOptions {
+    return {
+      path: config.path,
+      domain: config.domain,
+      secure: config.secure,
+      httpOnly: config.httpOnly,
+      maxAge:
+        config.maxAge !== undefined
+          ? this.parseMaxAge(config.maxAge)
+          : undefined,
+    };
+  }
+
+  /**
+   * Retrieves all cookies.
+   * @returns {Record<string, string>} - An object containing all cookies.
+   */
+  public getAll(): Record<string, string> {
+    return this.cookie.getAll() as Record<string, string>;
+  }
+
+  /**
+   * Retrieves the value of a specific cookie.
+   * @param {string} cookieName - The name of the cookie to retrieve.
+   * @returns {string} - The value of the cookie, or an empty string if not found.
+   */
+  public get(cookieName: string): string {
+    return this.cookie.get(cookieName) || '';
+  }
+
+  /**
+   * Removes a specific cookie.
+   * @param {string} cookieName - The name of the cookie to remove.
+   */
+  public remove(cookieName: string): void {
+    this.cookie.remove(cookieName);
+  }
+
+  /**
+   * Sets a cookie with the specified options.
+   * @param {CookieType} cookie - The cookie to set, including name and payload.
+   * @param {CookieServiceConfig} [config] - Optional configuration for setting the cookie.
+   */
+  public set(cookie: CookieType, config?: CookieServiceConfig): void {
+    const baseConfig = this.getConfig();
+    const mergedConfig = { ...baseConfig, ...config, ...cookie };
+    const options = this.configToCookieOptions(mergedConfig);
+
+    this.cookie.set(cookie.name, cookie.payload, options);
+  }
+}

package/src/services/eventService.ts

@@ -0,0 +1,89 @@
+import { EventEmitter } from 'events';
+import { BroadcastChannel } from 'broadcast-channel';
+import { isServerContext } from '../utils';
+import type { GeinsEventMessage } from '@geins/types';
+import { logWrite } from './logService';
+
+/**
+ * Event service
+ * Responsible for handling events and broadcasting them to other windows and tabs.
+ *
+ * @class
+ * @name EventService
+ *
+ */
+export class EventService {
+  private eventName: string = 'geins-event';
+  private emitter: any;
+  private broadcast: BroadcastChannel | undefined;
+  private broadcastChannelId: string = 'geins-channel';
+  constructor() {
+    this.emitter = new EventEmitter();
+    if (!isServerContext()) {
+      this.broadcast = new BroadcastChannel(this.broadcastChannelId);
+      this.addBroadcastListener();
+    }
+  }
+
+  private addBroadcastListener() {
+    if (this.broadcast) {
+      this.broadcast.onmessage = (data: any) => {
+        this.emitter.emit(data.eventName, data.eventMessage);
+      };
+    }
+  }
+
+  /**
+   * Adds a presistent event listener to the event emitter.
+   * @param handler A callback function that handles the event data.
+   * @param eventName (optional): The name of the event to listen for. If omitted, it defaults to 'geins-event'.
+   */
+  listnerAdd(handler: any, eventName: string = this.eventName): void {
+    this.emitter.on(eventName, handler);
+  }
+
+  /**
+   * Adds a one-time event listener for the specified event. This listener will be invoked only the first time the event is emitted and then automatically removed.
+   * @param handler A callback function that handles the event data.
+   * @param eventName (optional): The name of the event to listen for. If omitted, it defaults to 'geins-event'.
+   */
+  listnerOnce(handler: any, eventName: string = this.eventName): void {
+    this.emitter.once(eventName, handler);
+  }
+  /**
+   * Removes the specified event listener from the event emitter.   *
+   * @param eventName (optional): The name of the event to listen for. If omitted, it defaults to 'geins-event'.
+   */
+  listnerRemove(eventName: string = this.eventName): void {
+    this.emitter.removeAllListeners(eventName);
+  }
+  /**
+   * Returns the number of listeners for the specified event.
+   * @param eventName (optional): The name of the event to listen for. If omitted, it defaults to 'geins-event'.
+   */
+  listnerCount(eventName: string = this.eventName): number {
+    return this.emitter.listenerCount(eventName);
+  }
+  /**
+   * Lists the listeners for the specified event.
+   * @param eventName
+   * @returns An array of listeners for the specified event.
+   */
+  listnersGet(eventName: string = this.eventName): any[] {
+    return this.emitter.listeners(eventName);
+  }
+  /**
+   * Pushes an event message to the event emitter.
+   * @param eventMessage - The event message to push.
+   * @param eventName - The name of the event to push the message to. If omitted, it defaults to 'geins-event'.
+   */
+  push(
+    eventMessage: GeinsEventMessage,
+    eventName: string = this.eventName,
+  ): void {
+    this.emitter.emit(eventName, eventMessage);
+    if ((eventMessage.broadcast ?? true) && this.broadcast) {
+      this.broadcast?.postMessage({ eventMessage, eventName });
+    }
+  }
+}

package/src/services/graphQLService.ts

@@ -0,0 +1,55 @@
+import type { GeinsSettings } from '@geins/types';
+import { BaseApiService } from '../base/baseApiService';
+import { GraphQLQueryOptions } from '../api-client/merchantApiClient';
+
+export class GraphQLService extends BaseApiService {
+  constructor(client: any, geinsSettings: GeinsSettings) {
+    super(client, geinsSettings);
+  }
+
+  /**
+   * Generic method to run any GraphQL query
+   * @param query - The GraphQL query DocumentNode or gql query object
+   * @param variables - Variables to pass to the query
+   * @param options - Optional options like fetchPolicy, pollInterval, etc.
+   * @returns The result data of the query or null
+   */
+  async query<T = any>(options: GraphQLQueryOptions): Promise<T | null> {
+    try {
+      const result = this.cleanObject(await this.runQuery(options));
+      const parsedResult = this.parseResult(result);
+      return parsedResult as T;
+    } catch (error) {
+      console.error('Query error:', error);
+      return null;
+    }
+    return null;
+  }
+
+  /**
+   * Generic method to run any GraphQL mutation
+   * @param mutation - The GraphQL mutation DocumentNode or gql mutation object
+   * @param variables - Variables to pass to the mutation
+   * @param options - Optional options like fetchPolicy, etc.
+   * @returns The result data of the mutation or null
+   */
+  async mutation<T = any>(options: GraphQLQueryOptions): Promise<T | null> {
+    try {
+      const result = await this.runMutation(options);
+      const parsedResult = this.parseResult(result);
+      return parsedResult as T;
+    } catch (error) {
+      console.error('Mutation error:', error);
+      return null;
+    }
+  }
+  protected parseResult(result: any): any {
+    if (result.data) {
+      return result.data;
+    }
+    if (result.errors) {
+      console.error('GraphQL errors:', result.errors);
+    }
+    return null;
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,7 @@
+export * from './cookieService';
+export * from './eventService';
+export * from './logService';
+export * from './routingService';
+export * from './channelsService';
+export * from './channelService';
+export * from './graphQLService';