@geins/crm 0.1.1-canary

package/src/geinsCRM.ts

@@ -0,0 +1,306 @@
+import { GeinsCore, BasePackage, buildEndpoints } from '@geins/core';
+import {
+  AuthSettings,
+  AuthClientConnectionModes,
+  AuthCredentials,
+  AuthResponse,
+  AuthTokens,
+  GeinsUserInputTypeType,
+  GeinsUserOrdersType,
+  GeinsCustomerType,
+  GeinsEventType,
+  GeinsUserType,
+} from '@geins/types';
+import { AuthClientDirect, AuthClientProxy, AuthService } from './auth';
+import type { AuthInterface, UserInterface } from './types';
+import { UserService, UserOrdersService, PasswordResetService } from './services';
+
+class GeinsCRM extends BasePackage {
+  private _authClient: AuthClientDirect | AuthClientProxy;
+  private _userService!: UserService;
+  private _passwordResetService!: PasswordResetService;
+  private _userOrdersService!: UserOrdersService;
+
+  constructor(core: GeinsCore, authSettings: AuthSettings) {
+    super(core);
+    const { geinsSettings } = core;
+
+    if (authSettings.clientConnectionMode === AuthClientConnectionModes.Proxy) {
+      const proxyUrl = authSettings.proxyUrl || '/api/auth';
+      this._authClient = new AuthClientProxy(proxyUrl);
+    } else if (authSettings.clientConnectionMode === AuthClientConnectionModes.Direct) {
+      const endpoints = buildEndpoints(
+        geinsSettings.apiKey,
+        geinsSettings.accountName,
+        geinsSettings.environment,
+      );
+      this._authClient = new AuthClientDirect(endpoints.authSign, endpoints.auth);
+    } else {
+      throw new Error('Invalid client connection mode');
+    }
+  }
+
+  private async initUserService(): Promise<void> {
+    this._userService = new UserService(() => this._apiClient(), this._geinsSettings);
+
+    if (!this._userService) {
+      throw new Error('Failed to initialize user service');
+    }
+  }
+
+  private async initPasswordService(): Promise<void> {
+    this._passwordResetService = new PasswordResetService(() => this._apiClient(), this._geinsSettings);
+    if (!this._passwordResetService) {
+      throw new Error('Failed to initialize password reset service');
+    }
+  }
+
+  private async initUserOrderService(): Promise<void> {
+    this._userOrdersService = new UserOrdersService(() => this._apiClient(), this._geinsSettings);
+    if (!this._userOrdersService) {
+      throw new Error('Failed to initialize user order service');
+    }
+  }
+
+  public setAuthTokens(tokens: AuthTokens): void {
+    if (tokens?.token) {
+      this.core.setUserToken(tokens?.token);
+    }
+    if (tokens?.refreshToken) {
+      this._authClient.setRefreshToken(tokens.refreshToken);
+    }
+  }
+
+  public clearAuthAndUser(): void {
+    this.core?.setUserToken(undefined);
+    this._authClient?.clearAuth();
+    this._apiClient()?.clearCacheAndRefetchQueries();
+  }
+
+  public spoofUser(token: string): string {
+    this._authClient.logout();
+    return this._authClient.spoofPreviewUser(token);
+  }
+
+  get auth(): AuthInterface {
+    if (!this._authClient) {
+      throw new Error('AuthClient is not initialized');
+    }
+    return {
+      get: this.authGetUser.bind(this),
+      login: this.authLogin.bind(this),
+      logout: this.authLogout.bind(this),
+      refresh: this.authRefresh.bind(this),
+      authorized: this.authAuthorized.bind(this),
+    };
+  }
+
+  private handleAuthResponse(authResponse: AuthResponse | undefined, clearAuthOnFail: boolean = true): void {
+    if (authResponse?.succeeded && authResponse.tokens?.token) {
+      this.setAuthTokens(authResponse.tokens);
+    } else if (clearAuthOnFail) {
+      this.clearAuthAndUser();
+    }
+  }
+
+  private async authAuthorized(refreshToken?: string): Promise<boolean> {
+    // check if refreshToken is argument
+    if (refreshToken) {
+      this._authClient.setRefreshToken(refreshToken);
+    }
+
+    // try to to get user with refreshToken
+    const authResponse = await this._authClient.getUser(refreshToken);
+    this.handleAuthResponse(authResponse);
+
+    return authResponse?.succeeded ?? false;
+  }
+
+  private async authLogin(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    const authResponse = await this._authClient.login(credentials);
+    this.handleAuthResponse(authResponse);
+
+    if (authResponse?.succeeded) {
+      this._apiClient()?.clearCacheAndRefetchQueries();
+    }
+
+    try {
+      this.pushEvent(
+        {
+          subject: GeinsEventType.USER_LOGIN,
+          payload: {
+            success: authResponse?.succeeded,
+            user: credentials.username,
+          },
+        },
+        GeinsEventType.USER_LOGIN,
+      );
+    } catch (error) {
+      console.warn('Failed to push USER_LOGIN event:', error);
+    }
+
+    return authResponse;
+  }
+
+  private async authLogout(): Promise<AuthResponse | undefined> {
+    this.clearAuthAndUser();
+    try {
+      this.pushEvent({ subject: GeinsEventType.USER_LOGOUT, payload: {} }, GeinsEventType.USER_LOGOUT);
+    } catch (error) {
+      console.warn('Failed to push USER_LOGOUT event:', error);
+    }
+
+    return this._authClient.logout();
+  }
+
+  private async authRefresh(refreshToken?: string): Promise<AuthResponse | undefined> {
+    const authResponse = await this._authClient.refresh(refreshToken);
+    this.handleAuthResponse(authResponse);
+
+    return authResponse;
+  }
+
+  private async authGetUser(refreshToken?: string, userToken?: string): Promise<AuthResponse | undefined> {
+    const authResponse = await this._authClient.getUser(refreshToken, userToken);
+    this.handleAuthResponse(authResponse);
+
+    return authResponse;
+  }
+
+  get user(): UserInterface {
+    if (!this._authClient) {
+      throw new Error('AuthClient is not initialized');
+    }
+    return {
+      get: this.userGet.bind(this),
+      update: this.userUpdate.bind(this),
+      create: this.userRegisterAndCreate.bind(this),
+      remove: this.userRemove.bind(this),
+      password: {
+        change: this.userChangePassword.bind(this),
+        requestReset: this.userPasswordResetRequest.bind(this),
+        commitReset: this.userPasswordResetCommit.bind(this),
+      },
+      orders: {
+        get: this.userOrders.bind(this),
+      },
+    };
+  }
+
+  private async userGet(): Promise<GeinsUserType | undefined> {
+    if (!this._userService) {
+      await this.initUserService();
+    }
+
+    // check if core has token
+    const userTokenFromCore = this.getCore().getUserToken();
+    if (!userTokenFromCore) {
+      return undefined;
+    }
+    return this._userService?.get();
+  }
+
+  private async userUpdate(user: GeinsUserInputTypeType): Promise<any> {
+    if (!this._userService) {
+      await this.initUserService();
+    }
+
+    // Unwrap the Proxy
+    const unwrappedUser: GeinsUserInputTypeType = JSON.parse(JSON.stringify(user));
+
+    try {
+      this.pushEvent(
+        { subject: GeinsEventType.USER_UPDATE, payload: unwrappedUser },
+        GeinsEventType.USER_UPDATE,
+      );
+    } catch (error) {
+      console.warn('Failed to push USER_UPDATE event:', error);
+    }
+
+    return this._userService?.update(user);
+  }
+
+  private async userRegisterAndCreate(
+    credentials: AuthCredentials,
+    user?: GeinsUserInputTypeType,
+  ): Promise<AuthResponse | undefined> {
+    // logout user if already logged in
+    await this.authLogout();
+
+    // user will be registered and logged in
+    const authResponse = await this._authClient.register(credentials);
+    this.handleAuthResponse(authResponse);
+
+    if (!authResponse?.succeeded) {
+      return authResponse;
+    }
+
+    if (user) {
+      const userResult = await this.userUpdate(user);
+      if (!userResult) {
+        throw new Error('Failed to update user with information');
+      }
+    } else {
+      const registerUserAs: GeinsUserInputTypeType = {
+        newsletter: false,
+        customerType: GeinsCustomerType.PersonType,
+      };
+
+      const userResult = await this.userCreate(registerUserAs);
+
+      if (!userResult) {
+        throw new Error('Failed to create user in MC');
+      }
+    }
+
+    const { refreshToken, token } = authResponse?.tokens || {};
+    return this._authClient.getUser(refreshToken, token);
+  }
+
+  private async userCreate(user: GeinsUserInputTypeType): Promise<any> {
+    if (!this._userService) {
+      await this.initUserService();
+    }
+
+    return this._userService?.create(user);
+  }
+
+  private async userRemove(): Promise<any> {
+    this.pushEvent({ subject: GeinsEventType.USER_DELETE, payload: {} }, GeinsEventType.USER_DELETE);
+    if (!this._userService) {
+      await this.initUserService();
+    }
+
+    return this._userService?.delete();
+  }
+
+  private async userOrders(): Promise<GeinsUserOrdersType | undefined> {
+    if (!this._userOrdersService) {
+      await this.initUserOrderService();
+    }
+    return this._userOrdersService?.get();
+  }
+
+  private async userChangePassword(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    const authResponse = await this._authClient.changePassword(credentials);
+    this.handleAuthResponse(authResponse, false);
+
+    return authResponse;
+  }
+
+  private async userPasswordResetRequest(email: string): Promise<any> {
+    if (!this._passwordResetService) {
+      await this.initPasswordService();
+    }
+    return this._passwordResetService?.request(email);
+  }
+
+  private async userPasswordResetCommit(resetKey: string, password: string): Promise<any> {
+    if (!this._passwordResetService) {
+      await this.initPasswordService();
+    }
+    return this._passwordResetService?.commit(resetKey, password);
+  }
+}
+
+export { GeinsCRM };

package/src/graphql/auth/pw-reset-commit.gql

@@ -0,0 +1,15 @@
+mutation UserPasswordResetCommit(
+  $resetKey: String!
+  $password: String!
+  $channelId: String
+  $languageId: String
+  $marketId: String
+) {
+  commitReset(
+    resetKey: $resetKey
+    password: $password
+    channelId: $channelId
+    languageId: $languageId
+    marketId: $marketId
+  )
+}

package/src/graphql/auth/pw-reset-request.gql

@@ -0,0 +1,13 @@
+mutation UserRequestPasswordReset(
+  $email: String!
+  $channelId: String
+  $languageId: String
+  $marketId: String
+) {
+  requestPasswordReset(
+    email: $email
+    channelId: $channelId
+    languageId: $languageId
+    marketId: $marketId
+  )
+}

package/src/graphql/fragments/address.gql

@@ -0,0 +1,16 @@
+fragment Address on AddressType {
+  firstName
+  lastName
+  company
+  mobile
+  phone
+  careOf
+  entryCode
+  addressLine1
+  addressLine2
+  addressLine3
+  zip
+  city
+  state
+  country
+}

package/src/graphql/fragments/balances.gql

@@ -0,0 +1,5 @@
+fragment UserBalance on UserBalanceType {
+  currency
+  amount
+  #amountFormatted
+}

package/src/graphql/fragments/campaign.gql

@@ -0,0 +1,4 @@
+fragment Campaign on CampaignRuleType {
+  name
+  hideTitle
+}

package/src/graphql/fragments/cart.gql

@@ -0,0 +1,101 @@
+#import "./price.gql"
+#import "./stock.gql"
+
+fragment Cart on CartType {
+  id
+  promoCode
+  appliedCampaigns {
+    name
+    hideTitle
+  }
+  items {
+    campaign {
+      appliedCampaigns {
+        name
+        hideTitle
+      }
+      prices {
+        price {
+          ...Price
+        }
+        quantity
+      }
+    }
+    unitPrice {
+      ...Price
+    }
+    product {
+      productId
+      articleNumber
+      brand {
+        name
+      }
+      name
+      productImages {
+        fileName
+      }
+      alias
+      canonicalUrl
+      primaryCategory {
+        name
+      }
+      skus {
+        skuId
+        name
+        stock {
+          ...Stock
+        }
+      }
+      unitPrice {
+        ...Price
+      }
+    }
+    quantity
+    skuId
+    totalPrice {
+      ...Price
+    }
+  }
+  summary {
+    fixedAmountDiscountIncVat
+    fixedAmountDiscountExVat
+    balance {
+      pending
+      pendingFormatted
+      totalSellingPriceExBalanceExVat
+      totalSellingPriceExBalanceIncVat
+      totalSellingPriceExBalanceIncVatFormatted
+    }
+    subTotal {
+      regularPriceIncVatFormatted
+      regularPriceExVatFormatted
+      sellingPriceIncVatFormatted
+      sellingPriceExVatFormatted
+      sellingPriceExVat
+      sellingPriceIncVat
+      vat
+    }
+    shipping {
+      amountLeftToFreeShipping
+      amountLeftToFreeShippingFormatted
+      feeExVatFormatted
+      feeIncVatFormatted
+      feeIncVat
+      feeExVat
+      isDefault
+    }
+    total {
+      isDiscounted
+      sellingPriceIncVatFormatted
+      sellingPriceExVatFormatted
+      sellingPriceIncVat
+      sellingPriceExVat
+      discountIncVatFormatted
+      discountExVatFormatted
+      discountExVat
+      discountIncVat
+      vatFormatted
+      vat
+    }
+  }
+}

package/src/graphql/fragments/price.gql

@@ -0,0 +1,13 @@
+fragment Price on PriceType {
+  isDiscounted
+  sellingPriceIncVat
+  sellingPriceExVat
+  regularPriceIncVat
+  regularPriceExVat
+  vat
+  discountPercentage
+  regularPriceIncVatFormatted
+  sellingPriceIncVatFormatted
+  regularPriceExVatFormatted
+  sellingPriceExVatFormatted
+}

package/src/graphql/fragments/stock.gql

@@ -0,0 +1,7 @@
+fragment Stock on StockType {
+  inStock
+  oversellable
+  totalStock
+  static
+  incoming
+}

package/src/graphql/fragments/user.gql

@@ -0,0 +1,16 @@
+#import "./address.gql"
+#import "./balances.gql"
+fragment User on UserType {
+  id
+  email
+  personalId
+  customerType
+  gender
+  address {
+    ...Address
+  }
+  balances {
+    ...UserBalance
+  }
+  metaData
+}

package/src/graphql/graphql.d.ts

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

package/src/graphql/index.ts

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

package/src/graphql/order/orders.gql

@@ -0,0 +1,39 @@
+#import "../fragments/price.gql"
+#import "../fragments/address.gql"
+#import "../fragments/cart.gql"
+
+query UserOrders($channelId: String, $languageId: String, $marketId: String) {
+  getOrders(
+    channelId: $channelId
+    languageId: $languageId
+    marketId: $marketId
+  ) {
+    cart {
+      ...Cart
+    }
+    billingAddress {
+      ...Address
+    }
+    shippingAddress {
+      ...Address
+    }
+    createdAt
+    id
+    status
+    shippingDetails {
+      name
+      trackingLink
+    }
+    paymentDetails {
+      displayName
+    }
+    refunds {
+      id
+      itemId
+      createdAt
+      reason
+      total
+      vat
+    }
+  }
+}

package/src/graphql/queries.ts

@@ -0,0 +1,21 @@
+import userGet from './user/get.gql';
+import userOrders from './order/orders.gql';
+import userRegister from './user/register.gql';
+import userUpdate from './user/update.gql';
+import userDelete from './user/delete.gql';
+import pwResetRequest from './auth/pw-reset-request.gql';
+import pwResetCommit from './auth/pw-reset-commit.gql';
+
+const queries = {
+  userGet,
+  userOrders,
+};
+const mutations = {
+  userRegister,
+  userUpdate,
+  userDelete,
+  pwResetRequest,
+  pwResetCommit,
+};
+
+export { queries, mutations };

package/src/graphql/user/delete.gql

@@ -0,0 +1,3 @@
+mutation UserDelete {
+  deleteUser
+}

package/src/graphql/user/get.gql

@@ -0,0 +1,6 @@
+#import "../fragments/user.gql"
+query UserGet {
+  getUser {
+    ...User
+  }
+}

package/src/graphql/user/register.gql

@@ -0,0 +1,15 @@
+mutation UserCreate(
+  $user: UserInputType!
+  $channelId: String
+  $languageId: String
+  $marketId: String
+) {
+  updateUser(
+    user: $user
+    channelId: $channelId
+    languageId: $languageId
+    marketId: $marketId
+  ) {
+    email
+  }
+}

package/src/graphql/user/update.gql

@@ -0,0 +1,16 @@
+#import "../fragments/user.gql"
+mutation UserUpdate(
+  $user: UserInputType!
+  $channelId: String
+  $languageId: String
+  $marketId: String
+) {
+  updateUser(
+    user: $user
+    channelId: $channelId
+    languageId: $languageId
+    marketId: $marketId
+  ) {
+    ...User
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './auth';
+export * from './geinsCRM';

package/src/parsers/shared.ts

@@ -0,0 +1,23 @@
+import { GeinsAddressTypeType } from '@geins/types';
+
+export function parseAddress(data: any): GeinsAddressTypeType | undefined {
+  if (!data) {
+    return undefined;
+  }
+  return {
+    firstName: data.firstName,
+    lastName: data.lastName,
+    addressLine1: data.addressLine1,
+    addressLine2: data.addressLine2,
+    addressLine3: data.addressLine3,
+    entryCode: data.entryCode,
+    careOf: data.careOf,
+    city: data.city,
+    state: data.state,
+    country: data.country,
+    zip: data.zip,
+    company: data.company,
+    mobile: data.mobile,
+    phone: data.phone,
+  };
+}

package/src/services/index.ts

@@ -0,0 +1,3 @@
+export * from './userService';
+export * from './userOrdersService';
+export * from './pwResetService';

package/src/services/pwResetService.ts

@@ -0,0 +1,30 @@
+//import type { GeinsUserRequestPasswordResetType } from '@geins/types';
+import { BaseApiService, logWrite, GeinsUserInputTypeType } from '@geins/core';
+import { mutations } from '../graphql';
+import { digest } from '../auth/authHelpers';
+export class PasswordResetService extends BaseApiService {
+  private async generateVars(variables: any) {
+    return this.createVariables(variables);
+  }
+  async request(email: string): Promise<any> {
+    const variables = {
+      email,
+    };
+    const options = {
+      query: mutations.pwResetRequest,
+      variables: await this.generateVars(variables),
+    };
+    return this.runMutation(options);
+  }
+
+  async commit(resetKey: string, password: string): Promise<any> {
+    const pwd = await digest(password);
+    const variables = { resetKey, password: pwd };
+    const vars = await this.generateVars(variables);
+    const options = {
+      query: mutations.pwResetCommit,
+      variables: vars,
+    };
+    return this.runMutation(options);
+  }
+}