@geins/crm 0.1.1-canary

package/dist/parsers/shared.d.ts

@@ -0,0 +1,2 @@
+import { GeinsAddressTypeType } from '@geins/types';
+export declare function parseAddress(data: any): GeinsAddressTypeType | undefined;

package/dist/services/index.d.ts

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

package/dist/services/pwResetService.d.ts

@@ -0,0 +1,6 @@
+import { BaseApiService } from '@geins/core';
+export declare class PasswordResetService extends BaseApiService {
+    private generateVars;
+    request(email: string): Promise<any>;
+    commit(resetKey: string, password: string): Promise<any>;
+}

package/dist/services/userOrdersService.d.ts

@@ -0,0 +1,9 @@
+import type { GeinsSettings, GeinsUserOrdersType } from '@geins/types';
+import { BaseApiService } from '@geins/core';
+export declare class UserOrdersService extends BaseApiService {
+    constructor(apiClient: any, geinsSettings: GeinsSettings);
+    private generateVars;
+    getRaw(variables: any): Promise<any>;
+    get(): Promise<GeinsUserOrdersType | undefined>;
+    protected parseResult(result: any): GeinsUserOrdersType | undefined;
+}

package/dist/services/userService.d.ts

@@ -0,0 +1,13 @@
+import type { GeinsUserType, GeinsSettings } from '@geins/types';
+import { BaseApiService, GeinsUserInputTypeType } from '@geins/core';
+export declare class UserService extends BaseApiService {
+    constructor(apiClient: any, geinsSettings: GeinsSettings);
+    private generateVars;
+    private generateMutationVars;
+    getRaw(): Promise<any>;
+    get(): Promise<GeinsUserType | undefined>;
+    create(user: GeinsUserInputTypeType): Promise<any>;
+    update(user: GeinsUserInputTypeType): Promise<GeinsUserType>;
+    delete(): Promise<any>;
+    protected parseResult(data: any): GeinsUserType | undefined;
+}

package/dist/types/crmTypes.d.ts

@@ -0,0 +1,36 @@
+import { AuthCredentials, AuthResponse, GeinsUserInputTypeType, GeinsUserType, GeinsUserOrdersType } from '@geins/types';
+export interface AuthInterface {
+    get(refreshToken?: string, userToken?: string): Promise<AuthResponse | undefined>;
+    login(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+    logout(): Promise<AuthResponse | undefined>;
+    refresh(refreshToken?: string): Promise<AuthResponse | undefined>;
+    authorized(refreshToken?: string): Promise<boolean>;
+}
+/**
+ * User interface
+ * This interface is used to define the user service
+ */
+export interface UserInterface {
+    get(): Promise<GeinsUserType | undefined>;
+    update(user: GeinsUserInputTypeType): Promise<any>;
+    create(credentials: AuthCredentials, user?: GeinsUserInputTypeType): Promise<AuthResponse | undefined>;
+    remove(): Promise<any>;
+    password: UserPasswordInterface;
+    orders: UserOrdersInterface;
+}
+/**
+ * User password interface
+ * This interface is used to define the user password service
+ */
+export interface UserPasswordInterface {
+    change(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+    requestReset(email: string): Promise<any>;
+    commitReset(resetKey: string, password: string): Promise<any>;
+}
+/**
+ * User orders interface
+ * This interface is used to define the user orders service
+ */
+export interface UserOrdersInterface {
+    get(): Promise<GeinsUserOrdersType | undefined>;
+}

package/dist/types/index.d.ts

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

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/crm/jest.config.js
+import baseConfig from '../../../jest.config.js';
+
+export default {
+  ...baseConfig,
+  displayName: '@geins/crm',
+  roots: ['<rootDir>'],
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@geins/crm",
+  "version": "0.1.1-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",
+    "@geins/core": "0.1.1-canary",
+    "crypto-js": "^4.2.0",
+    "graphql": "^16.9.0"
+  },
+  "devDependencies": {
+    "@geins/eslint-config": "*",
+    "@geins/types": "0.1.1-canary",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-typescript": "^12.1.0",
+    "eslint": "^9.11.1",
+    "typescript": "^5.6.2"
+  }
+}

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/auth/authClient.ts

@@ -0,0 +1,318 @@
+import { CookieService, AUTH_COOKIES, AUTH_COOKIES_MAX_AGE } from '@geins/core';
+import type { AuthResponse, AuthCredentials, AuthTokens, AuthUser } from '@geins/types';
+import { authClaimsTokenSerializeToObject } from './authHelpers';
+import { AuthService } from './authService';
+
+export abstract class AuthClient {
+  protected _cookieService: CookieService;
+  protected _refreshToken: string | undefined;
+
+  constructor() {
+    this._cookieService = new CookieService();
+  }
+
+  // abstract methods
+  protected abstract handleLogin(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+  protected abstract handleRefresh(refreshToken?: string): Promise<AuthResponse | undefined>;
+  protected abstract handleGetUser(
+    refreshToken?: string,
+    userToken?: string,
+  ): Promise<AuthResponse | undefined>;
+  protected abstract handleChangePassword(
+    credentials: AuthCredentials,
+    refreshToken: string,
+  ): Promise<AuthResponse | undefined>;
+  protected abstract handleRegister(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+
+  // base methods
+  async login(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    const authResponse = await this.handleLogin(credentials);
+
+    if (authResponse?.succeeded) {
+      this.setCookiesLogin(authResponse, credentials.rememberUser || false);
+    }
+
+    return authResponse;
+  }
+
+  async refresh(refreshToken?: string): Promise<AuthResponse | undefined> {
+    this._refreshToken = refreshToken || this.getCookieRefreshToken();
+
+    if (!this._refreshToken) {
+      return undefined;
+    }
+
+    const authResponse = await this.handleRefresh(this._refreshToken);
+
+    if (authResponse?.succeeded && authResponse.tokens) {
+      this.refreshLoginCookies(authResponse);
+    }
+
+    return authResponse;
+  }
+
+  async getUser(refreshToken?: string, userToken?: string): Promise<AuthResponse | undefined> {
+    const tokens = this.getCurrentTokens(refreshToken, userToken);
+    this._refreshToken = tokens.refreshToken;
+
+    if (!tokens.refreshToken) {
+      return undefined;
+    }
+
+    if (tokens.userToken && tokens.refreshToken) {
+      return this.handleUserTokenScenario({
+        userToken: tokens.userToken,
+        refreshToken: tokens.refreshToken,
+      });
+    }
+
+    return this.handleRefreshTokenOnlyScenario(tokens.refreshToken);
+  }
+
+  async changePassword(
+    credentials: AuthCredentials,
+    refreshToken?: string,
+  ): Promise<AuthResponse | undefined> {
+    this._refreshToken = refreshToken || this.getCookieRefreshToken();
+
+    if (!this._refreshToken) {
+      return undefined;
+    }
+
+    const authResponse = await this.handleChangePassword(credentials, this._refreshToken);
+
+    if (authResponse?.succeeded) {
+      this.setCookiesLogin(authResponse, credentials.rememberUser || false);
+    }
+    return authResponse;
+  }
+
+  async register(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    const authResponse = await this.handleRegister(credentials);
+
+    if (authResponse?.succeeded) {
+      this.setCookiesLogin(authResponse, credentials.rememberUser || false);
+    }
+
+    return authResponse;
+  }
+
+  private async handleUserTokenScenario(tokens: {
+    refreshToken: string;
+    userToken: string;
+  }): Promise<AuthResponse | undefined> {
+    let authResponse = AuthService.getUserObjectFromToken(tokens.userToken, tokens.refreshToken);
+
+    if (authResponse?.succeeded && authResponse.tokens?.expiresSoon) {
+      return this.refreshUserTokens(tokens);
+    }
+
+    return authResponse;
+  }
+
+  private async refreshUserTokens(tokens: {
+    refreshToken: string;
+    userToken: string;
+  }): Promise<AuthResponse | undefined> {
+    const authResponse = await this.handleGetUser(tokens.refreshToken, tokens.userToken);
+
+    if (authResponse?.succeeded && authResponse.tokens) {
+      this._refreshToken = tokens.refreshToken;
+      this.refreshLoginCookies(authResponse);
+    }
+
+    return authResponse;
+  }
+
+  private async handleRefreshTokenOnlyScenario(refreshToken: string): Promise<AuthResponse | undefined> {
+    const authResponse = await this.handleGetUser(refreshToken);
+
+    if (authResponse?.succeeded && authResponse.tokens) {
+      this._refreshToken = refreshToken;
+      this.refreshLoginCookies(authResponse);
+    }
+
+    return authResponse;
+  }
+
+  // cookie methods
+  public async logout(): Promise<AuthResponse | undefined> {
+    return { succeeded: true };
+  }
+
+  public getUserFromCookie(token?: string, refreshToken?: string): AuthResponse | undefined {
+    token = token || this.getCookieUserToken();
+    refreshToken = refreshToken || this.getCookieRefreshToken();
+
+    if (!token || !refreshToken) {
+      return undefined;
+    }
+
+    return AuthService.getUserObjectFromToken(token, refreshToken);
+  }
+
+  public getCookieTokens(): AuthTokens {
+    return {
+      token: this.getCookieUserToken(),
+      refreshToken: this.getCookieRefreshToken(),
+    };
+  }
+
+  public setRefreshToken(token: string): void {
+    this._refreshToken = token;
+  }
+
+  protected getCookieUser(): string {
+    return this._cookieService.get(AUTH_COOKIES.USER);
+  }
+
+  protected getCookieRefreshToken(): string {
+    return this._cookieService.get(AUTH_COOKIES.REFRESH_TOKEN);
+  }
+
+  protected getCookieUserToken(): string {
+    return this._cookieService.get(AUTH_COOKIES.USER_AUTH);
+  }
+
+  protected getCookieMaxAge(): number {
+    const maxAge = this._cookieService.get(AUTH_COOKIES.USER_MAX_AGE);
+    if (!maxAge) {
+      return AUTH_COOKIES_MAX_AGE.DEFAULT;
+    }
+    return parseInt(maxAge, 10);
+  }
+
+  protected getCurrentTokens(
+    refreshToken?: string,
+    userToken?: string,
+  ): { refreshToken: string | undefined; userToken: string | undefined } {
+    const cookieRefreshToken = this.getCookieRefreshToken();
+    const cookieUserToken = this.getCookieUserToken();
+    return {
+      refreshToken: refreshToken || cookieRefreshToken,
+      userToken: userToken || cookieUserToken,
+    };
+  }
+
+  protected setCookieRefreshToken(token: string, maxAge?: number): void {
+    const setMaxAge = maxAge || this.getCookieMaxAge() || AUTH_COOKIES_MAX_AGE.DEFAULT;
+    this._cookieService.set({
+      name: AUTH_COOKIES.REFRESH_TOKEN,
+      payload: token,
+      maxAge: setMaxAge,
+    });
+  }
+
+  protected setCookieUserToken(token: string, maxAge: number): void {
+    const setMaxAge = maxAge || this.getCookieMaxAge() || AUTH_COOKIES_MAX_AGE.DEFAULT;
+    this._cookieService.set({
+      name: AUTH_COOKIES.USER_AUTH,
+      payload: token,
+      maxAge: setMaxAge,
+    });
+  }
+
+  protected setCookiesTokens(tokens?: AuthTokens, maxAge?: number): void {
+    if (!tokens) {
+      return;
+    }
+    const setMaxAge = maxAge || this.getCookieMaxAge() || AUTH_COOKIES_MAX_AGE.DEFAULT;
+    if (tokens?.refreshToken) {
+      this.setCookieRefreshToken(tokens.refreshToken, setMaxAge);
+    }
+    if (tokens?.token) {
+      this.setCookieUserToken(tokens.token, tokens.expiresIn || 900);
+    }
+  }
+
+  protected setCookiesUser(authUser?: AuthUser, maxAge?: number): void {
+    if (!authUser) {
+      return;
+    }
+    const setMaxAge = maxAge || this.getCookieMaxAge() || AUTH_COOKIES_MAX_AGE.DEFAULT;
+
+    this._cookieService.set({
+      name: AUTH_COOKIES.USER_MAX_AGE,
+      payload: setMaxAge.toString(),
+      maxAge: setMaxAge,
+    });
+
+    if (authUser?.username) {
+      this._cookieService.set({
+        name: AUTH_COOKIES.USER,
+        payload: authUser.username,
+        maxAge: setMaxAge,
+      });
+    }
+
+    if (authUser?.customerType) {
+      this._cookieService.set({
+        name: AUTH_COOKIES.USER_TYPE,
+        payload: authUser.customerType,
+        maxAge: setMaxAge,
+      });
+    }
+  }
+
+  protected setCookiesLogin(authResponse: AuthResponse, rememberUser: boolean): void {
+    const maxAge = rememberUser ? AUTH_COOKIES_MAX_AGE.REMEMBER_USER : AUTH_COOKIES_MAX_AGE.DEFAULT;
+    const { tokens, user } = authResponse;
+
+    this.setCookiesUser(user, maxAge);
+    this.setCookiesTokens(tokens, maxAge);
+  }
+
+  protected refreshLoginCookies(authResponse: AuthResponse): void {
+    const { tokens, user } = authResponse;
+    this.setCookiesUser(user);
+    this.setCookiesTokens(tokens);
+  }
+
+  public clearAuth(): void {
+    this.clearAuthCookies();
+    this._refreshToken = undefined;
+  }
+
+  public clearAuthCookies(): void {
+    Object.values(AUTH_COOKIES).forEach(cookieName => {
+      this._cookieService.remove(cookieName);
+    });
+  }
+
+  public spoofPreviewUser(token: string): string {
+    this.clearAuthCookies();
+
+    const maxAge = AUTH_COOKIES_MAX_AGE.DEFAULT;
+    const spoofedUser = authClaimsTokenSerializeToObject(token);
+
+    const username = spoofedUser?.spoofedBy || 'preview@geins.io';
+    const spoofDate = spoofedUser?.spoofDate;
+    const customerType = spoofedUser?.customerType || 'preview';
+
+    this._cookieService.set({
+      name: AUTH_COOKIES.USER,
+      payload: username,
+      maxAge,
+    });
+
+    this._cookieService.set({
+      name: AUTH_COOKIES.USER_AUTH,
+      payload: token,
+      maxAge,
+    });
+
+    this._cookieService.set({
+      name: AUTH_COOKIES.USER_TYPE,
+      payload: customerType,
+      maxAge,
+    });
+
+    this._cookieService.set({
+      name: AUTH_COOKIES.USER_MAX_AGE,
+      payload: maxAge.toString(),
+      maxAge,
+    });
+
+    return JSON.stringify(spoofedUser);
+  }
+}

package/src/auth/authClientDirect.ts

@@ -0,0 +1,31 @@
+import type { AuthResponse, AuthCredentials } from '@geins/types';
+import { AuthClient } from './authClient';
+import { AuthService } from './authService';
+
+export class AuthClientDirect extends AuthClient {
+  private _authService: AuthService;
+
+  constructor(signEndpoint: string, authEndpoint: string) {
+    super();
+    this._authService = new AuthService(signEndpoint, authEndpoint);
+  }
+
+  protected async handleLogin(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    return this._authService.login(credentials);
+  }
+  protected async handleRefresh(refreshToken: string): Promise<AuthResponse | undefined> {
+    return this._authService.refresh(refreshToken);
+  }
+  protected async handleGetUser(refreshToken: string, userToken?: string): Promise<AuthResponse | undefined> {
+    return this._authService.getUser(refreshToken, userToken);
+  }
+  protected async handleChangePassword(
+    credentials: AuthCredentials,
+    refreshToken: string,
+  ): Promise<AuthResponse | undefined> {
+    return this._authService.changePassword(credentials, refreshToken);
+  }
+  protected async handleRegister(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    return this._authService.register(credentials);
+  }
+}

package/src/auth/authClientProxy.ts

@@ -0,0 +1,82 @@
+import { AUTH_HEADERS } from '@geins/core';
+import type { AuthResponse, AuthCredentials } from '@geins/types';
+import { AuthClient } from './authClient';
+import { AuthService } from './authService';
+
+export class AuthClientProxy extends AuthClient {
+  private _authEndpointApp: string;
+
+  constructor(authEndpointApp: string) {
+    super();
+    this._authEndpointApp = authEndpointApp;
+  }
+
+  private async request<T>(path: string, options: RequestInit): Promise<T> {
+    const refreshToken = this._refreshToken || this.getCookieRefreshToken();
+
+    if (!options.headers) {
+      options.headers = { 'Content-Type': 'application/json' };
+    }
+    if (refreshToken) {
+      options.headers = {
+        ...options.headers,
+        [`${AUTH_HEADERS.REFRESH_TOKEN}`]: refreshToken,
+      };
+    }
+
+    if (options.method === 'GET' || options.method === 'HEAD') {
+      delete options.body;
+    }
+
+    const response = await fetch(`${this._authEndpointApp}${path}`, {
+      ...options,
+    });
+
+    const result = await response.json();
+    if (!response.ok) {
+      console.error(result.message || 'API request failed');
+      throw new Error('API request failed');
+    }
+
+    return result.body?.data as T;
+  }
+
+  protected async handleLogin(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    return this.request('/login', {
+      method: 'POST',
+      body: JSON.stringify(credentials),
+    });
+  }
+
+  protected async handleRefresh(refreshToken: string): Promise<AuthResponse | undefined> {
+    this._refreshToken = refreshToken;
+    return this.request('/refresh', {
+      method: 'POST',
+    });
+  }
+
+  protected async handleGetUser(refreshToken: string, userToken?: string): Promise<AuthResponse | undefined> {
+    this._refreshToken = refreshToken;
+    return this.request('/user', {
+      method: 'GET',
+    });
+  }
+
+  protected async handleChangePassword(
+    credentials: AuthCredentials,
+    refreshToken: string,
+  ): Promise<AuthResponse | undefined> {
+    this._refreshToken = refreshToken;
+    return this.request('/change-password', {
+      method: 'POST',
+      body: JSON.stringify(credentials),
+    });
+  }
+
+  protected async handleRegister(credentials: AuthCredentials): Promise<AuthResponse | undefined> {
+    return this.request('/register', {
+      method: 'POST',
+      body: JSON.stringify(credentials),
+    });
+  }
+}

package/src/auth/authHelpers.ts

@@ -0,0 +1,65 @@
+export function authClaimTokenParse(token: string): any {
+  try {
+    const base64Url = token.split('.')[1];
+    if (!base64Url) {
+      return null;
+    }
+
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const decodedString = atob(base64);
+    return JSON.parse(decodedString);
+  } catch (error) {
+    return null;
+  }
+}
+
+export function authClaimsTokenSerialize(token: string): string | null {
+  const claims = authClaimTokenParse(token);
+  if (!claims) {
+    return null;
+  }
+
+  return Object.entries(claims)
+    .map(([key, value]) =>
+      Array.isArray(value) ? value.map(v => `${key}=${v}`).join(';') : `${key}=${value}`,
+    )
+    .join(';');
+}
+
+export function authClaimsTokenSerializeToObject(token: string): Record<string, string> | null {
+  try {
+    const serializedClaims = authClaimsTokenSerialize(token);
+    if (!serializedClaims) {
+      return null;
+    }
+
+    const obj = serializedClaims.split(';').reduce(
+      (acc, pair) => {
+        let [key, value] = pair.split('=');
+        if (key.includes('/')) {
+          key = key.split('/').pop() || key;
+        }
+        key = key.charAt(0).toLowerCase() + key.slice(1);
+        acc[key] = value;
+        return acc;
+      },
+      {} as Record<string, string>,
+    );
+
+    return obj;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function arrayBufferToBase64(buffer: ArrayBuffer): string {
+  const byteArray = new Uint8Array(buffer);
+  const binaryString = byteArray.reduce((acc, byte) => acc + String.fromCharCode(byte), '');
+  return btoa(binaryString);
+}
+
+export async function digest(password: string): Promise<string> {
+  const salt = 'Dd1dfLonNy6Am2fXQl2AcoI+IbhLhXvaibnDNn8uEa6vbJ05eyJajSuGFm9uQSmD';
+  const buffer = await crypto.subtle.digest('SHA-384', new TextEncoder().encode(password + salt));
+  return arrayBufferToBase64(buffer);
+}