@geins/core 0.3.0-canary

package/dist/logic/channel.d.ts

@@ -0,0 +1,17 @@
+import type { GeinsSettings, GeinsChannelTypeType } from '@geins/types';
+export declare class Channel {
+    private geinsSettings;
+    private channelId;
+    private channelService;
+    private cache;
+    private store;
+    private _apiClient;
+    constructor(geinsSettings: GeinsSettings);
+    private initApiClient;
+    private initChannelService;
+    static getInstance(geinsSettings: GeinsSettings): Channel;
+    setKey(key: string, value: string): void;
+    getKey(key: string): Promise<string>;
+    private setChannel;
+    get(): Promise<GeinsChannelTypeType | undefined>;
+}

package/dist/logic/index.d.ts

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

package/dist/parsers/channelParser.d.ts

@@ -0,0 +1,8 @@
+import type { GeinsChannelTypeType, GeinsMarketTypeType, GeinsCountryTypeType, GeinsLanguageTypeType, GeinsCurrencyTypeType } from '@geins/types';
+export declare function parseChannelsResult(result: any): GeinsChannelTypeType[] | undefined;
+export declare function parseChannelResult(result: any): GeinsChannelTypeType | undefined;
+export declare function parseChannel(channel: any): GeinsChannelTypeType | undefined;
+export declare function parseMarket(market: any): GeinsMarketTypeType;
+export declare function parseCountry(country: any): GeinsCountryTypeType;
+export declare function parseLanguage(language: any): GeinsLanguageTypeType;
+export declare function parseCurrency(currency: any): GeinsCurrencyTypeType;

package/dist/services/channelService.d.ts

@@ -0,0 +1,8 @@
+import type { GeinsChannelTypeType, GeinsSettings } from '@geins/types';
+import { BaseApiService } from '../base/baseApiService';
+export declare class ChannelService extends BaseApiService {
+    private cache;
+    constructor(client: any, geinsSettings: GeinsSettings);
+    get(channelId: string): Promise<GeinsChannelTypeType | undefined>;
+    protected parseResult(result: any): GeinsChannelTypeType | undefined;
+}

package/dist/services/channelsService.d.ts

@@ -0,0 +1,8 @@
+import type { GeinsChannelTypeType, GeinsSettings } from '@geins/types';
+import { BaseApiService } from '../base/baseApiService';
+export declare class ChannelsService extends BaseApiService {
+    private cache;
+    constructor(client: any, geinsSettings: GeinsSettings);
+    get(): Promise<GeinsChannelTypeType[] | undefined>;
+    protected parseResult(result: any): GeinsChannelTypeType[] | undefined;
+}

package/dist/services/cookieService.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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;
+}
+/**
+ * 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 declare class CookieService {
+    private path;
+    private domain;
+    private secure;
+    private httpOnly;
+    private maxAge;
+    private cookie;
+    /**
+     * Creates an instance of CookieService.
+     * @param {CookieServiceConfig} [config] - Optional configuration for the cookie service.
+     */
+    constructor(config?: CookieServiceConfig);
+    /**
+     * Retrieves the current cookie configuration.
+     * @returns {CookieServiceConfig} - The current configuration settings.
+     */
+    protected getConfig(): CookieServiceConfig;
+    private parseMaxAge;
+    private configToCookieOptions;
+    /**
+     * Retrieves all cookies.
+     * @returns {Record<string, string>} - An object containing all cookies.
+     */
+    getAll(): 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.
+     */
+    get(cookieName: string): string;
+    /**
+     * Removes a specific cookie.
+     * @param {string} cookieName - The name of the cookie to remove.
+     */
+    remove(cookieName: string): void;
+    /**
+     * 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.
+     */
+    set(cookie: CookieType, config?: CookieServiceConfig): void;
+}

package/dist/services/eventService.d.ts

@@ -0,0 +1,51 @@
+import type { GeinsEventMessage } from '@geins/types';
+/**
+ * Event service
+ * Responsible for handling events and broadcasting them to other windows and tabs.
+ *
+ * @class
+ * @name EventService
+ *
+ */
+export declare class EventService {
+    private eventName;
+    private emitter;
+    private broadcast;
+    private broadcastChannelId;
+    constructor();
+    private addBroadcastListener;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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): void;
+    /**
+     * 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): number;
+    /**
+     * Lists the listeners for the specified event.
+     * @param eventName
+     * @returns An array of listeners for the specified event.
+     */
+    listnersGet(eventName?: string): any[];
+    /**
+     * 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): void;
+}

package/dist/services/graphQLService.d.ts

@@ -0,0 +1,23 @@
+import type { GeinsSettings } from '@geins/types';
+import { BaseApiService } from '../base/baseApiService';
+import { GraphQLQueryOptions } from '../api-client/merchantApiClient';
+export declare class GraphQLService extends BaseApiService {
+    constructor(client: any, geinsSettings: 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
+     */
+    query<T = any>(options: GraphQLQueryOptions): Promise<T | 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
+     */
+    mutation<T = any>(options: GraphQLQueryOptions): Promise<T | null>;
+    protected parseResult(result: any): any;
+}

package/dist/services/index.d.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';

package/dist/services/logService.d.ts

@@ -0,0 +1,19 @@
+export declare class LogService {
+    private static configIsEnabled;
+    private static configLogLevel;
+    static configure({ isEnabled, logLevel, }?: {
+        isEnabled?: boolean;
+        logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    }): void;
+    static isServer(): boolean;
+    static trace(...args: any[]): void;
+    static debug(...args: any[]): void;
+    static info(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static error(...args: any[]): void;
+    private static log;
+    private static output;
+    private static getCallerInfoExtended;
+    private static getFileTypeFromExtension;
+}
+export declare const logWrite: typeof LogService.debug;

package/dist/services/routingService.d.ts

@@ -0,0 +1,74 @@
+import { IStore } from '../base/baseStore';
+export declare enum RoutingServiceState {
+    INIT = 0,
+    FETCHING = 1,
+    READY = 2,
+    ERROR = 3
+}
+export interface RoutingRule extends RoutingItem {
+    httpStatusCode?: number;
+    isCanonical?: boolean;
+}
+export interface RoutingItem {
+    fromUrl: string;
+    toUrl: string;
+}
+export declare class RoutingService {
+    private static instance;
+    private store;
+    private apiKey;
+    private apiClient;
+    private state;
+    private constructor();
+    /**
+     * Retrieves the singleton instance of the RoutingService.
+     * @param apiKey - The API key used for authentication.
+     * @param store - The storage interface for caching routes.
+     * @returns The singleton instance of RoutingService.
+     */
+    static getInstance(apiKey: string, store: IStore): RoutingService;
+    private setKey;
+    private getKey;
+    /**
+     * Retrieves all routing rules from the store.
+     * @returns A promise that resolves to an array of RoutingRule objects.
+     */
+    getRoutingRules(): Promise<RoutingRule[]>;
+    /**
+     * Retrieves all route keys from the store.
+     * @returns A promise that resolves to an array of route keys.
+     */
+    getAllRoutes(): Promise<string[]>;
+    private shouldFetchNewData;
+    private fetchAndProcessUrlHistory;
+    /**
+     * Fetches the URL history from the API and updates the store.
+     * If the history was fetched less than an hour ago, it uses the cached data.
+     * @returns A promise that resolves to an array of route keys.
+     * @throws An error if the URL history could not be fetched.
+     */
+    fillUrlHistory(): Promise<string[]>;
+    /**
+     * Retrieves the route for the given path from the store.
+     * @param path - The path for which to get the route.
+     * @returns A promise that resolves to the route or null if not found.
+     */
+    getRoute(path: string): Promise<string | null>;
+    /**
+     * Refreshes the URL history if more than an hour has passed since the last fetch.
+     * @returns A promise that resolves to an array of route keys.
+     */
+    refreshUrlHistoryIfNeeded(): Promise<string[]>;
+    /**
+     * Retrieves the last time the URL history was fetched.
+     * @returns A promise that resolves to the last fetch time as a string or null if not set.
+     */
+    getLastFetchTime(): Promise<string | null>;
+    /**
+     * Fills the routes by fetching the URL history and returns the updated routes.
+     * @returns A promise that resolves to an object containing the urlHistory array.
+     */
+    fillRoutes(): Promise<{
+        urlHistory: string[];
+    }>;
+}

package/dist/stores/channelStore.d.ts

@@ -0,0 +1,11 @@
+import NodeCache from 'node-cache';
+import { BaseStore } from '../base';
+export declare class ChannelStore extends BaseStore {
+    store: NodeCache;
+    constructor();
+    initStore(): NodeCache;
+    getKey(from: string): Promise<any>;
+    setKey(from: string, to: string): Promise<boolean>;
+    deleteKey(from: string): Promise<number>;
+    getKeys(): Promise<string[]>;
+}

package/dist/stores/index.d.ts

@@ -0,0 +1,2 @@
+export * from './routingStore';
+export * from './channelStore';

package/dist/stores/routingStore.d.ts

@@ -0,0 +1,32 @@
+import { IStore } from '../base';
+/**
+ * RoutingStore implements the IStore interface using NodeCache for in-memory caching.
+ */
+export declare class RoutingStore implements IStore {
+    private store;
+    constructor();
+    /**
+     * Sets a key-value pair in the cache.
+     * @param key - The key under which the value is stored.
+     * @param value - The value to store.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    setKey(key: string, value: string): Promise<void>;
+    /**
+     * Retrieves a value from the cache by its key.
+     * @param key - The key of the value to retrieve.
+     * @returns A promise that resolves to the value or null if not found.
+     */
+    getKey(key: string): Promise<string | null>;
+    /**
+     * Retrieves all keys from the cache.
+     * @returns A promise that resolves to an array of all keys.
+     */
+    getKeys(): Promise<string[]>;
+    /**
+     * Deletes a key-value pair from the cache.
+     * @param key - The key of the value to delete.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    deleteKey(key: string): Promise<void>;
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,21 @@
+import type { Environment, GeinsEndpoints } from '@geins/types';
+/**
+ * Get context of the runtime.
+ * @returns If the context is server.
+ */
+export declare function isServerContext(): boolean;
+/**
+ * Builds the endpoints for the Geins API.
+ * @param apiKey - The API key.
+ * @param accountName - The account name.
+ * @param environment - The environment.
+ * @returns The endpoints.
+ * @example
+ * ```ts
+ * const apiKey
+ * const accountName
+ * const environment
+ * const endpoints = buildEndpoints(apiKey, accountName, environment);
+ * ```
+ */
+export declare function buildEndpoints(apiKey: string, accountName: string, environment?: Environment): GeinsEndpoints;

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './helpers';
+export * from './simpleCache';

package/dist/utils/simpleCache.d.ts

@@ -0,0 +1,9 @@
+export declare class SimpleCache<T> {
+    private defaultTTL;
+    private cache;
+    constructor(defaultTTL?: number);
+    set(key: string, value: T, ttl?: number): void;
+    get(key: string): T | undefined;
+    delete(key: string): void;
+    clear(): void;
+}

package/eslint.config.js

@@ -0,0 +1,3 @@
+import { geinsSharedConfig } from '@geins/eslint-config/eslint-config.js';
+
+export default [...geinsSharedConfig];

package/jest.config.js

@@ -0,0 +1,8 @@
+// /packages/sdk/cms/jest.config.js
+import baseConfig from '../../../jest.config.js';
+
+export default {
+  ...baseConfig,
+  displayName: '@geins/cms',
+  roots: ['<rootDir>'],
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@geins/core",
+  "version": "0.3.0-canary",
+  "main": "dist/index.cjs",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "build": "rollup -c",
+    "prepublishOnly": "yarn build",
+    "lint": "eslint --fix .",
+    "link": "yarn link"
+  },
+  "dependencies": {
+    "@apollo/client": "^3.11.8",
+    "cookie-universal": "^2.2.2",
+    "graphql": "^16.9.0",
+    "node-cache": "^5.1.2",
+    "broadcast-channel": "^7.0.0"
+  },
+  "devDependencies": {
+    "@geins/types": "0.3.0-canary",
+    "@geins/eslint-config": "*",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-graphql": "^2.0.5",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-typescript": "^12.1.0",
+    "typescript": "^5.6.2",
+    "eslint": "^9.11.1"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,26 @@
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import typescript from '@rollup/plugin-typescript';
+import graphql from '@rollup/plugin-graphql';
+
+export default {
+  input: 'src/index.ts',
+  output: [
+    {
+      file: 'dist/index.cjs',
+      format: 'cjs',
+    },
+    {
+      file: 'dist/index.esm.js',
+      format: 'esm',
+    },
+  ],
+  plugins: [
+    resolve({
+      preferBuiltins: true,
+    }),
+    commonjs(),
+    typescript(),
+    graphql(),
+  ],
+};

package/src/api-client/endpointClient.ts

@@ -0,0 +1,52 @@
+import {
+  API_ENDPOINT_URL_HISTORY,
+  API_ENDPOINT_SLUG_HISTORY,
+} from '../constants';
+export class EndpointApiClient {
+  private apiKey: string;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  private getEndpointUrl(endpointUrl: string) {
+    return `${endpointUrl}/${this.apiKey}`;
+  }
+
+  private async request(endpointUrl: string) {
+    try {
+      const options = {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+        },
+      };
+      const response = await fetch(endpointUrl, options);
+
+      if (!response.ok) {
+        throw new Error(
+          `Request failed with status ${response.status}: ${response.statusText}`,
+        );
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error(`Error fetching data from ${endpointUrl}:`, error);
+      throw error;
+    }
+  }
+
+  async getUrlHistory(lastFetchTime?: string) {
+    const endpoint =
+      this.getEndpointUrl(API_ENDPOINT_URL_HISTORY) +
+      (lastFetchTime ? `?offset=${lastFetchTime}` : '');
+    return this.request(endpoint);
+  }
+
+  async getSlugHistory(lastFetchTime?: string) {
+    const endpoint =
+      this.getEndpointUrl(API_ENDPOINT_SLUG_HISTORY) +
+      (lastFetchTime ? `?offset=${lastFetchTime}` : '');
+    return this.request(endpoint);
+  }
+}

package/src/api-client/index.ts

@@ -0,0 +1,4 @@
+export * from './merchantApiClient';
+export * from './managementApiClient';
+export * from './endpointClient';
+export * from '../constants/endpoints';

package/src/api-client/managementApiClient.ts

@@ -0,0 +1,41 @@
+import { MANAGEMENT_API_URL } from '../constants/endpoints';
+import type { ManagementApiCredentials } from '@geins/types';
+
+export class ManagementApiClient {
+  private baseUrl: string;
+  private apiKey: string;
+  private authToken: string;
+
+  constructor(credentials: ManagementApiCredentials) {
+    this.baseUrl = MANAGEMENT_API_URL;
+    this.apiKey = credentials.apiKey;
+    this.authToken = this.createAuthToken(credentials);
+  }
+
+  createAuthToken(credentials: ManagementApiCredentials) {
+    return btoa(`${credentials.username}:${credentials.password}`);
+  }
+
+  getEndpointUrl(path: string) {
+    return `${this.baseUrl}/${path}`;
+  }
+
+  async request(method: string, path: string, data: any = {}) {
+    const endpointUrl = this.getEndpointUrl(path);
+    const options = {
+      method,
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'x-apikey': this.apiKey,
+        Authorization: `Bearer ${this.authToken}`,
+      },
+      body: JSON.stringify(data),
+    };
+
+    const reponse = await fetch(endpointUrl, options).then((response) => {
+      return response.json();
+    });
+    return reponse;
+  }
+}