@geins/core 0.3.0-canary

package/.turbo/turbo-build.log

@@ -0,0 +1,7 @@
+
+yarn run v1.22.22
+$ rollup -c
+
+src/index.ts → dist/index.cjs, dist/index.esm.js...
+created dist/index.cjs, dist/index.esm.js in 2.4s
+✨  Done in 2.89s.

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @geins/core
+
+## 0.3.0-canary
+
+### Patch Changes
+
+- first
+
+## 0.1.1-canary
+
+### Patch Changes
+
+- first

package/README.md

@@ -0,0 +1 @@
+# CORE

package/__tests__/Channel.test.ts

@@ -0,0 +1,34 @@
+// packages/sdk/core/__tests__/GeinsCore.test.ts
+
+import { Channel } from '../src/logic/channel';
+import { validSettings } from '../../../../test/globalSettings';
+
+describe('Channel', () => {
+  let channel: Channel;
+  beforeEach(() => {
+    channel = Channel.getInstance(validSettings);
+  });
+
+  it('should initialize channel correctly', () => {
+    expect(channel).toBeDefined();
+  });
+
+  it('should get current channel correctly', async () => {
+    const currentChannel = await channel.get();
+    expect(currentChannel).toBeDefined();
+    expect(currentChannel).toHaveProperty('id');
+    expect(currentChannel).toHaveProperty('name');
+    expect(currentChannel).toHaveProperty('type');
+    expect(currentChannel).toHaveProperty('url');
+    expect(currentChannel).toHaveProperty('defaultMarketId');
+    expect(currentChannel).toHaveProperty('defaultLanguageId');
+    if (currentChannel) {
+      expect(currentChannel.id).toEqual(`${validSettings.channel}|${validSettings.tld}`);
+    }
+  });
+
+  afterEach(() => {
+    // Clean up mocks after each test
+    jest.clearAllMocks();
+  });
+});

package/__tests__/EventService.test.ts

@@ -0,0 +1,32 @@
+import { EventService } from '../src/services/eventService';
+import { BroadcastChannel } from 'broadcast-channel';
+import { EventEmitter } from 'events';
+import { isServerContext } from '../src/utils';
+import type { GeinsEventMessage } from '@geins/types';
+
+// Mock dependencies
+jest.mock('broadcast-channel');
+jest.mock('events');
+jest.mock('../src/utils', () => ({
+  isServerContext: jest.fn(),
+}));
+
+describe('EventService', () => {
+  let eventService: EventService;
+
+  beforeEach(() => {
+    // Set isServerContext to return false to simulate a browser environment
+    (isServerContext as jest.Mock).mockReturnValue(false);
+
+    // Create a new instance of EventService before each test
+    eventService = new EventService();
+  });
+
+  it('should be defined', () => {
+    expect(eventService).toBeDefined();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks(); // Clear all mocks after each test
+  });
+});

package/__tests__/GeinsCore.test.ts

@@ -0,0 +1,69 @@
+// packages/sdk/core/__tests__/GeinsCore.test.ts
+
+import { GeinsCore } from '../src/geinsCore';
+import { GeinsSettings } from '@geins/types';
+import { validSettings } from '../../../../test/globalSettings';
+
+describe('GeinsCore', () => {
+  describe('Real API Calls', () => {
+    let geinsCore: GeinsCore;
+    beforeEach(() => {
+      geinsCore = new GeinsCore(validSettings);
+      // Reset mocks before each test
+      jest.clearAllMocks();
+    });
+    it('should list channels', async () => {
+      const channels = await geinsCore.channel.all();
+      expect(channels).toBeDefined();
+      expect(channels!.length).toBeGreaterThan(0);
+    });
+  });
+
+  it('should initialize with valid settings', () => {
+    expect(() => new GeinsCore(validSettings)).not.toThrow();
+    const geinsCore = new GeinsCore(validSettings);
+    expect(geinsCore).toBeInstanceOf(GeinsCore);
+    expect(geinsCore.geinsSettings).toEqual(validSettings);
+  });
+
+  it('should throw an error when channel is missing', () => {
+    const invalidSettings: Partial<GeinsSettings> = {
+      ...validSettings,
+      channel: undefined as any,
+    };
+    expect(() => new GeinsCore(invalidSettings as GeinsSettings)).toThrow('Channel is required');
+  });
+
+  it('should throw an error when API key is missing', () => {
+    const invalidSettings: Partial<GeinsSettings> = {
+      ...validSettings,
+      apiKey: undefined as any,
+    };
+    expect(() => new GeinsCore(invalidSettings as GeinsSettings)).toThrow('API Key is required');
+  });
+
+  it('should throw an error when Account name is missing', () => {
+    const invalidSettings: Partial<GeinsSettings> = {
+      ...validSettings,
+      accountName: undefined as any,
+    };
+    expect(() => new GeinsCore(invalidSettings as GeinsSettings)).toThrow('Account name is required');
+  });
+
+  it('should use default environment when not specified', () => {
+    const settingsWithoutEnvironment: Omit<GeinsSettings, 'environment'> = {
+      ...validSettings,
+    };
+    delete (settingsWithoutEnvironment as any).environment;
+    const geinsCore = new GeinsCore(settingsWithoutEnvironment);
+    expect(geinsCore.geinsSettings.environment).toBe('prod');
+  });
+
+  it('should correctly set up endpoints', () => {
+    const geinsCore = new GeinsCore(validSettings);
+    expect(geinsCore.endpoints).toHaveProperty('main');
+    expect(geinsCore.endpoints).toHaveProperty('auth');
+    expect(geinsCore.endpoints).toHaveProperty('authSign');
+    expect(geinsCore.endpoints).toHaveProperty('image');
+  });
+});

package/__tests__/Graphql.test.ts

@@ -0,0 +1,43 @@
+import { GeinsCore, GraphQLService, gql } from '../src';
+import { validSettings } from '../../../../test/globalSettings';
+
+describe('GeinsCMS', () => {
+  let graphqlClient: GraphQLService;
+
+  beforeEach(() => {
+    const geinsCore = new GeinsCore(validSettings);
+    graphqlClient = geinsCore.graphql;
+
+    // Reset mocks before each test
+    jest.clearAllMocks();
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should get result from custom query', async () => {
+    const MY_QUERY = gql`
+      query getChannels {
+        channels {
+          name
+          url
+        }
+      }
+    `;
+
+    interface Channels {
+      channels: {
+        name: string;
+        url: string;
+      }[];
+    }
+
+    const result = await graphqlClient.query<Channels>({
+      query: MY_QUERY,
+    });
+
+    expect(result).toBeDefined();
+    expect(result!.channels).toBeDefined();
+    expect(result!.channels.length).toBeGreaterThan(0);
+  });
+});

package/dist/api-client/endpointClient.d.ts

@@ -0,0 +1,8 @@
+export declare class EndpointApiClient {
+    private apiKey;
+    constructor(apiKey: string);
+    private getEndpointUrl;
+    private request;
+    getUrlHistory(lastFetchTime?: string): Promise<any>;
+    getSlugHistory(lastFetchTime?: string): Promise<any>;
+}

package/dist/api-client/index.d.ts

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

package/dist/api-client/managementApiClient.d.ts

@@ -0,0 +1,10 @@
+import type { ManagementApiCredentials } from '@geins/types';
+export declare class ManagementApiClient {
+    private baseUrl;
+    private apiKey;
+    private authToken;
+    constructor(credentials: ManagementApiCredentials);
+    createAuthToken(credentials: ManagementApiCredentials): string;
+    getEndpointUrl(path: string): string;
+    request(method: string, path: string, data?: any): Promise<any>;
+}

package/dist/api-client/merchantApiClient.d.ts

@@ -0,0 +1,46 @@
+import { ApolloClient, NormalizedCacheObject, FetchPolicy, ApolloQueryResult, FetchResult, OperationVariables } from '@apollo/client/core';
+export declare enum FetchPolicyOptions {
+    CACHE_FIRST = "cache-first",
+    NETWORK_ONLY = "network-only",
+    CACHE_ONLY = "cache-only",
+    NO_CACHE = "no-cache",
+    STANDBY = "standby"
+}
+export declare 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 declare class MerchantApiClient {
+    private _cookieService;
+    private _apolloClient;
+    private _userToken?;
+    fetchPolicy: FetchPolicy;
+    pollInterval: number;
+    constructor(options: MerchantApiClientOptions);
+    updateToken(newToken?: string): void;
+    get userToken(): string | undefined;
+    createClient(apiUrl: string, apiKey: string): ApolloClient<NormalizedCacheObject>;
+    getClient(): ApolloClient<NormalizedCacheObject> | undefined;
+    clearCacheAndRefetchQueries(): void;
+    private getFetchPolicy;
+    private getOperationObject;
+    runQuery<TData = any, TVariables extends OperationVariables = OperationVariables>(options: GraphQLQueryOptions): Promise<ApolloQueryResult<TData>>;
+    runMutation<TData = any, TVariables extends OperationVariables = OperationVariables>(options: GraphQLQueryOptions): Promise<FetchResult<TData>>;
+}

package/dist/base/baseApiService.d.ts

@@ -0,0 +1,14 @@
+import type { GeinsSettings } from '@geins/types';
+import { GraphQLQueryOptions } from '../api-client/merchantApiClient';
+export declare abstract class BaseApiService {
+    protected _apiClient: any;
+    protected _geinsSettings: GeinsSettings;
+    protected _channelId: string;
+    constructor(apiClient: any, geinsSettings: GeinsSettings);
+    protected createVariables(vars: any): any;
+    protected runQuery(options: GraphQLQueryOptions): Promise<any>;
+    protected runQueryParsed<T>(options: GraphQLQueryOptions): Promise<T>;
+    protected runMutation(options: GraphQLQueryOptions): Promise<any>;
+    protected parseResult(result: any): any;
+    protected cleanObject<T extends Record<string, any>>(obj: T): Partial<T>;
+}

package/dist/base/basePackage.d.ts

@@ -0,0 +1,12 @@
+import { GeinsCore } from '../geinsCore';
+import { MerchantApiClient } from '../api-client/merchantApiClient';
+import type { GeinsEventMessage, GeinsSettings } from '@geins/types';
+import { GeinsEventType } from '@geins/types';
+export declare abstract class BasePackage {
+    protected core: GeinsCore;
+    protected _geinsSettings: GeinsSettings;
+    protected _apiClient: () => MerchantApiClient;
+    constructor(core: GeinsCore);
+    protected pushEvent(eventMessage: GeinsEventMessage, eventName?: GeinsEventType): void;
+    getCore(): GeinsCore;
+}

package/dist/base/baseStore.d.ts

@@ -0,0 +1,14 @@
+export declare abstract class BaseStore {
+    store: any;
+    constructor();
+    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/dist/base/index.d.ts

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

package/dist/constants/cookies.d.ts

@@ -0,0 +1,11 @@
+export declare const AUTH_COOKIES: {
+    USER: string;
+    USER_AUTH: string;
+    USER_TYPE: string;
+    USER_MAX_AGE: string;
+    REFRESH_TOKEN: string;
+};
+export declare const AUTH_COOKIES_MAX_AGE: {
+    DEFAULT: number;
+    REMEMBER_USER: number;
+};

package/dist/constants/endpoints.d.ts

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

package/dist/constants/headerNames.d.ts

@@ -0,0 +1,3 @@
+export declare const AUTH_HEADERS: {
+    REFRESH_TOKEN: string;
+};

package/dist/constants/index.d.ts

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

package/dist/geinsCore.d.ts

@@ -0,0 +1,88 @@
+import type { GeinsSettings, GeinsEndpoints } from '@geins/types';
+import { GeinsChannelInterface } from '@geins/types';
+import { MerchantApiClient } from './api-client';
+import { CookieService } from './services/cookieService';
+import { EventService } from './services/eventService';
+import { GraphQLService } from './services';
+export declare class GeinsCore {
+    private _endpointsUrls;
+    private _apiClient;
+    private _geinsSettings;
+    private _userToken?;
+    private _graphQLService;
+    private _cookieService;
+    private _eventService;
+    private _currentChannel;
+    private _accountChannels;
+    constructor(geinsSettings: GeinsSettings);
+    private initApiClient;
+    private initGraphQLService;
+    /**
+     * Channels
+     * Methods:
+     * - current() gets the current channel for application set from the settings;
+     * - all() get all channels for the account;
+     */
+    get channel(): GeinsChannelInterface;
+    private channelGet;
+    private channelsGet;
+    /**
+     * Set the user token.
+     * @param userToken
+     */
+    setUserToken(userToken?: string): void;
+    /**
+     * Get the user token. Returns a token if user is authenticated.
+     * @returns string | undefined
+     */
+    getUserToken(): string | undefined;
+    /**
+     * 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;
+    /**
+     * Returns the API Client instance.
+     */
+    get client(): MerchantApiClient;
+    /**
+     * Returns the GraphQL Client instance.
+     * @returns GraphQLClient
+     * Use to query Geins using GraphQL.
+     */
+    get graphql(): GraphQLService;
+    /**
+     * Returns the GeinsSettings that was used to to instance the class.
+     */
+    get geinsSettings(): 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;
+    /**
+     * Returns the CookieService instance.
+     * @returns CookieService
+     * @example
+     * const cookieService = core.cookies;
+     * cookieService.set('cookieName', 'cookieValue');
+     * const cookieValue = cookieService.get('cookieName');
+     *
+     */
+    get cookies(): CookieService;
+}

package/dist/graphql/index.d.ts

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

package/dist/graphql/queries.d.ts

@@ -0,0 +1,5 @@
+declare const queries: {
+    channels: string;
+    channel: string;
+};
+export { queries };