@geins/crm 0.1.1-canary

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @geins/crm
+
+## 0.1.1-canary
+
+### Patch Changes
+
+- Updated dependencies
+  - @geins/core@0.1.1-canary

package/README.md

@@ -0,0 +1 @@
+# CRM

package/__tests__/GeinsCRM.auth.test.ts

@@ -0,0 +1,284 @@
+// /packages/sdk/crm/__tests__/GeinsCRM.auth.test.ts
+
+import { GeinsCore, CookieService, AUTH_COOKIES } from '@geins/core';
+import { AuthSettings, AuthCredentials } from '@geins/types';
+import { GeinsCRM } from '../src/geinsCRM';
+import { validSettings, validUserCredentials, expectedCookiesAuthAll } from '../../../../test/globalSettings';
+import { setupMockFetchForInternalApi } from '../../../../test/setupAuthMockFetch';
+import { randomString, randomUserData, cleanObject } from '../../../../test/dataMock';
+import { AuthService } from '../src/auth/authService';
+
+// Define type for test setup options
+type TestSetupOptions = {
+  authSettings: AuthSettings;
+  useMockFetch?: boolean; // Flag to indicate if mock fetch should be used
+};
+
+/**
+ * Shared function to test GeinsCRM with different AuthSettings configurations.
+ * @param {TestSetupOptions} options - Contains the AuthSettings and other configuration flags.
+ */
+function testGeinsCRM(options: TestSetupOptions) {
+  const { authSettings, useMockFetch } = options;
+
+  describe(`GeinsCRM Tests with AuthSettings - ${authSettings.clientConnectionMode}`, () => {
+    let setCookieSpy: jest.SpyInstance;
+    let removeCookieSpy: jest.SpyInstance;
+    let expectedMaxAge: number;
+
+    let geinsCRM: GeinsCRM;
+
+    beforeEach(() => {
+      setCookieSpy = jest.spyOn(CookieService.prototype, 'set');
+      removeCookieSpy = jest.spyOn(CookieService.prototype, 'remove');
+
+      validUserCredentials.rememberUser = true;
+      expectedMaxAge = validUserCredentials.rememberUser ? 604800 : 1800;
+
+      // Initialize GeinsCore and GeinsCRM instance before each test
+      const geinsCore = new GeinsCore(validSettings);
+      geinsCRM = new GeinsCRM(geinsCore, authSettings);
+
+      // If useMockFetch is true, set up mock fetch for internal API calls
+      if (useMockFetch) {
+        const authService = new AuthService(geinsCore.endpoints.authSign, geinsCore.endpoints.auth);
+        setupMockFetchForInternalApi(authService);
+      }
+      setCookieSpy.mockClear();
+    });
+
+    afterEach(() => {
+      // Clean up mocks after each test
+      jest.clearAllMocks();
+      setCookieSpy.mockClear();
+    });
+
+    it('should initialize GeinsCRM correctly', () => {
+      expect(geinsCRM).toBeDefined();
+    });
+
+    it('should login a user with valid credentials', async () => {
+      const credentials: AuthCredentials = {
+        username: validUserCredentials.username,
+        password: validUserCredentials.password,
+        rememberUser: validUserCredentials.rememberUser,
+      };
+
+      const loginResult = await geinsCRM.auth.login(credentials);
+
+      expect(loginResult).toBeDefined();
+      expect(loginResult).toHaveProperty('succeeded');
+      expect(loginResult).toHaveProperty('tokens');
+      expect(loginResult).toHaveProperty('user');
+      expect(loginResult!.succeeded).toBe(true);
+      expect(loginResult!.tokens).toBeDefined();
+      expect(loginResult!.user).toBeDefined();
+      expect(loginResult!.tokens).toHaveProperty('token');
+      expect(loginResult!.tokens).toHaveProperty('refreshToken');
+
+      // check cookie set calls
+      const setCalls = setCookieSpy.mock.calls.map(call => call[0]);
+      expectedCookiesAuthAll.forEach(expectedName => {
+        expect(setCalls).toContainEqual(expect.objectContaining({ name: expectedName }));
+      });
+      expect(setCookieSpy).toHaveBeenCalledTimes(expectedCookiesAuthAll.length);
+      // check remove calls
+      const removeCalls = removeCookieSpy.mock.calls.map(call => call[0]);
+      expect(removeCalls).toHaveLength(0);
+    });
+
+    it('should not login a user with invalid credentials', async () => {
+      const credentials: AuthCredentials = {
+        username: validUserCredentials.username,
+        password: validUserCredentials.password + '1',
+      };
+
+      const loginResult = await geinsCRM.auth.login(credentials);
+
+      expect(loginResult).toBeDefined();
+      expect(loginResult).toHaveProperty('succeeded');
+      expect(loginResult!.succeeded).toBe(false);
+
+      // check cookies
+      const setCalls = setCookieSpy.mock.calls.map(call => call[0]);
+      expect(setCalls).toHaveLength(0);
+      const removeCalls = removeCookieSpy.mock.calls.map(call => call[0]);
+      expect(removeCalls).toHaveLength(expectedCookiesAuthAll.length);
+    });
+
+    it('should register a user with credentials', async () => {
+      const randomUsername = `${randomString(10).toLowerCase()}@test-user.com`;
+      const randomPassword = randomString(10);
+
+      const result = await geinsCRM.user.create({
+        username: randomUsername,
+        password: randomPassword,
+      });
+
+      expect(result).toBeDefined();
+      expect(result).toHaveProperty('succeeded');
+      expect(result!.succeeded).toBe(true);
+      expect(result).toHaveProperty('tokens');
+      expect(result).toHaveProperty('user');
+      expect(result!.user).toBeDefined();
+      expect(result!.tokens).toBeDefined();
+      expect(result!.user).toHaveProperty('username');
+      expect(result!.user?.username).toBe(randomUsername);
+
+      // check cookies
+      const setCalls = setCookieSpy.mock.calls.map(call => call[0]);
+      expect(setCalls).toHaveLength(expectedCookiesAuthAll.length);
+    });
+
+    it('should login a user and update information', async () => {
+      const credentials: AuthCredentials = {
+        username: validUserCredentials.username,
+        password: validUserCredentials.password,
+      };
+
+      // create random user data
+      const changedUserInfo = randomUserData();
+
+      const loginResult = await geinsCRM.auth.login(credentials);
+      expect(loginResult).toBeDefined();
+      expect(loginResult!.succeeded).toBe(true);
+
+      // get user information
+      const user = await geinsCRM.user.get();
+      expect(user).toBeDefined();
+      expect(user).toHaveProperty('email');
+      expect(user).toHaveProperty('customerType');
+      expect(user).toHaveProperty('address');
+
+      // update user information
+      const updateResult = await geinsCRM.user.update(changedUserInfo);
+      expect(updateResult).toBeDefined();
+      expect(updateResult).toHaveProperty('email');
+      expect(updateResult).toHaveProperty('personalId');
+      expect(updateResult).toHaveProperty('gender');
+      expect(updateResult).toHaveProperty('customerType');
+      expect(updateResult).toHaveProperty('address');
+
+      // check so that the user information has been updated
+      expect(updateResult!.personalId).toBe(changedUserInfo.personalId);
+      expect(updateResult!.gender).toBe(changedUserInfo.gender);
+      expect(updateResult!.customerType).toBe(changedUserInfo.customerType);
+
+      // clean address object and compare
+      const cleanUpdateResult = cleanObject(updateResult);
+      expect(cleanUpdateResult!.address).toEqual(changedUserInfo.address);
+    });
+
+    it('should not return user with invalid user-token', async () => {
+      const invalidToken = 'invalidToken';
+
+      const isolatedCore = new GeinsCore(validSettings);
+      const isolatedCRM = new GeinsCRM(isolatedCore, authSettings);
+
+      const user = await isolatedCRM.auth.get(invalidToken);
+      expect(user).toBeDefined();
+      expect(user).toHaveProperty('succeeded');
+      expect(user!.succeeded).toBe(false);
+
+      const setCalls = setCookieSpy.mock.calls.map(call => call[0]);
+      expect(setCalls).toHaveLength(0);
+    });
+
+    it('should return user when use refresh-token to auth.get', async () => {
+      const credentials: AuthCredentials = {
+        username: validUserCredentials.username,
+        password: validUserCredentials.password,
+      };
+
+      const loginResult = await geinsCRM.auth.login(credentials);
+      expect(loginResult).toBeDefined();
+      expect(loginResult!.succeeded).toBe(true);
+      expect(loginResult!.tokens).toBeDefined();
+      expect(loginResult!.tokens?.token).toBeDefined();
+
+      const refreshToken = loginResult!.tokens?.refreshToken;
+      const validToken = loginResult!.tokens?.token;
+
+      const isolatedCore = new GeinsCore(validSettings);
+      const isolatedCRM = new GeinsCRM(isolatedCore, authSettings);
+
+      const authUser = await isolatedCRM.auth.get(refreshToken);
+      const latestRefreshToken = authUser?.tokens?.refreshToken;
+      expect(authUser).toBeDefined();
+
+      const setCalls = setCookieSpy.mock.calls.map(call => call[0]);
+      const lastAuthRefreshTokenCookie = setCalls
+        .reverse()
+        .find(item => item.name === AUTH_COOKIES.REFRESH_TOKEN);
+      const lastAuthRefreshToken = lastAuthRefreshTokenCookie?.payload;
+
+      expect(latestRefreshToken).toBe(lastAuthRefreshToken);
+
+      // no remove calls
+      const removeCalls = removeCookieSpy.mock.calls.map(call => call[0]);
+      expect(removeCalls).toHaveLength(0);
+    });
+
+    it('should return true for authorized when using valid refresh-token', async () => {
+      const credentials: AuthCredentials = {
+        username: validUserCredentials.username,
+        password: validUserCredentials.password,
+      };
+
+      const loginResult = await geinsCRM.auth.login(credentials);
+      expect(loginResult).toBeDefined();
+      expect(loginResult!.succeeded).toBe(true);
+
+      const refreshToken = loginResult!.tokens?.refreshToken;
+
+      const isolatedCore = new GeinsCore(validSettings);
+      const isolatedCRM = new GeinsCRM(isolatedCore, authSettings);
+
+      const authorized = await isolatedCRM.auth.authorized(refreshToken);
+      expect(authorized).toBe(true);
+
+      const setCalls = setCookieSpy.mock.calls.map(call => call[0]);
+      expectedCookiesAuthAll.forEach(expectedName => {
+        expect(setCalls).toContainEqual(expect.objectContaining({ name: expectedName }));
+      });
+    });
+
+    it('should return false and remove cookies for authorized when using invalid refresh-token', async () => {
+      const refreshToken = 'invalidtoken';
+
+      const isolatedCore = new GeinsCore(validSettings);
+      const isolatedCRM = new GeinsCRM(isolatedCore, authSettings);
+
+      const authorized = await isolatedCRM.auth.authorized(refreshToken);
+      expect(authorized).toBe(false);
+
+      const setCalls = setCookieSpy.mock.calls.map(call => call[0]);
+      expect(setCalls).toHaveLength(0);
+      const removeCalls = removeCookieSpy.mock.calls.map(call => call[0]);
+      expectedCookiesAuthAll.forEach(expectedName => {
+        expect(removeCalls).toContainEqual(expect.stringContaining(expectedName));
+      });
+    });
+  });
+}
+
+// Define different AuthSettings configurations to test with
+const authSettingsVariations: TestSetupOptions[] = [
+  {
+    authSettings: {
+      clientConnectionMode: 'Direct',
+    },
+  },
+  {
+    authSettings: {
+      clientConnectionMode: 'Proxy',
+      proxyUrl: '/api/auth',
+    },
+    useMockFetch: true,
+  },
+];
+
+// Use describe.each to run the test suite with different configurations
+describe.each(authSettingsVariations)('GeinsCRM Auth', options => {
+  testGeinsCRM(options);
+});

package/__tests__/GeinsCRM.user.test.ts

@@ -0,0 +1,109 @@
+// /packages/sdk/crm/__tests__/GeinsCRM.auth.test.ts
+
+import { GeinsCore, CookieService, AUTH_COOKIES } from '@geins/core';
+import { AuthSettings, AuthCredentials } from '@geins/types';
+import { GeinsCRM } from '../src/geinsCRM';
+import { validSettings, validUserCredentials, expectedCookiesAuthAll } from '../../../../test/globalSettings';
+import { setupMockFetchForInternalApi } from '../../../../test/setupAuthMockFetch';
+import { randomString, randomUserData, cleanObject } from '../../../../test/dataMock';
+import { AuthService } from '../src/auth/authService';
+
+// Define type for test setup options
+type TestSetupOptions = {
+  authSettings: AuthSettings;
+  useMockFetch?: boolean; // Flag to indicate if mock fetch should be used
+};
+
+/**
+ * Shared function to test GeinsCRM with different AuthSettings configurations.
+ * @param {TestSetupOptions} options - Contains the AuthSettings and other configuration flags.
+ */
+function testGeinsCRM(options: TestSetupOptions) {
+  const { authSettings, useMockFetch } = options;
+
+  describe(`GeinsCRM User Tests with AuthSettings - ${authSettings.clientConnectionMode}`, () => {
+    let setCookieSpy: jest.SpyInstance;
+    let removeCookieSpy: jest.SpyInstance;
+    let expectedMaxAge: number;
+
+    let geinsCRM: GeinsCRM;
+
+    beforeEach(() => {
+      setCookieSpy = jest.spyOn(CookieService.prototype, 'set');
+      removeCookieSpy = jest.spyOn(CookieService.prototype, 'remove');
+
+      validUserCredentials.rememberUser = true;
+      expectedMaxAge = validUserCredentials.rememberUser ? 604800 : 1800;
+
+      // Initialize GeinsCore and GeinsCRM instance before each test
+      const geinsCore = new GeinsCore(validSettings);
+      geinsCRM = new GeinsCRM(geinsCore, authSettings);
+
+      // If useMockFetch is true, set up mock fetch for internal API calls
+      if (useMockFetch) {
+        const authService = new AuthService(geinsCore.endpoints.authSign, geinsCore.endpoints.auth);
+        setupMockFetchForInternalApi(authService);
+      }
+      setCookieSpy.mockClear();
+    });
+
+    afterEach(() => {
+      // Clean up mocks after each test
+      jest.clearAllMocks();
+      setCookieSpy.mockClear();
+    });
+
+    it('should login a user and update information', async () => {
+      const credentials: AuthCredentials = {
+        username: validUserCredentials.username,
+        password: validUserCredentials.password,
+      };
+
+      // create random user data
+      const changedUserInfo = randomUserData();
+
+      const loginResult = await geinsCRM.auth.login(credentials);
+      expect(loginResult).toBeDefined();
+      expect(loginResult!.succeeded).toBe(true);
+
+      // get user information
+      const user = await geinsCRM.user.get();
+      expect(user).toBeDefined();
+      expect(user).toHaveProperty('email');
+      expect(user).toHaveProperty('customerType');
+      expect(user).toHaveProperty('address');
+
+      // update user information
+      const updateResult = await geinsCRM.user.update(changedUserInfo);
+      expect(updateResult).toBeDefined();
+      expect(updateResult).toHaveProperty('email');
+      expect(updateResult).toHaveProperty('personalId');
+      expect(updateResult).toHaveProperty('gender');
+      expect(updateResult).toHaveProperty('customerType');
+      expect(updateResult).toHaveProperty('address');
+
+      // check so that the user information has been updated
+      expect(updateResult!.personalId).toBe(changedUserInfo.personalId);
+      expect(updateResult!.gender).toBe(changedUserInfo.gender);
+      expect(updateResult!.customerType).toBe(changedUserInfo.customerType);
+
+      // clean address object and compare
+      const cleanUpdateResult = cleanObject(updateResult);
+      expect(cleanUpdateResult!.address).toEqual(changedUserInfo.address);
+    });
+  });
+}
+
+// Define different AuthSettings configurations to test with
+const authSettingsVariations: TestSetupOptions[] = [
+  {
+    authSettings: {
+      clientConnectionMode: 'Direct',
+    },
+  },
+];
+
+// Use describe.each to run the test suite with different configurations
+describe.each(authSettingsVariations)('GeinsCRM User', options => {
+  testGeinsCRM(options);
+});

package/dist/auth/authClient.d.ts

@@ -0,0 +1,41 @@
+import { CookieService } from '@geins/core';
+import type { AuthResponse, AuthCredentials, AuthTokens, AuthUser } from '@geins/types';
+export declare abstract class AuthClient {
+    protected _cookieService: CookieService;
+    protected _refreshToken: string | undefined;
+    constructor();
+    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>;
+    login(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+    refresh(refreshToken?: string): Promise<AuthResponse | undefined>;
+    getUser(refreshToken?: string, userToken?: string): Promise<AuthResponse | undefined>;
+    changePassword(credentials: AuthCredentials, refreshToken?: string): Promise<AuthResponse | undefined>;
+    register(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+    private handleUserTokenScenario;
+    private refreshUserTokens;
+    private handleRefreshTokenOnlyScenario;
+    logout(): Promise<AuthResponse | undefined>;
+    getUserFromCookie(token?: string, refreshToken?: string): AuthResponse | undefined;
+    getCookieTokens(): AuthTokens;
+    setRefreshToken(token: string): void;
+    protected getCookieUser(): string;
+    protected getCookieRefreshToken(): string;
+    protected getCookieUserToken(): string;
+    protected getCookieMaxAge(): number;
+    protected getCurrentTokens(refreshToken?: string, userToken?: string): {
+        refreshToken: string | undefined;
+        userToken: string | undefined;
+    };
+    protected setCookieRefreshToken(token: string, maxAge?: number): void;
+    protected setCookieUserToken(token: string, maxAge: number): void;
+    protected setCookiesTokens(tokens?: AuthTokens, maxAge?: number): void;
+    protected setCookiesUser(authUser?: AuthUser, maxAge?: number): void;
+    protected setCookiesLogin(authResponse: AuthResponse, rememberUser: boolean): void;
+    protected refreshLoginCookies(authResponse: AuthResponse): void;
+    clearAuth(): void;
+    clearAuthCookies(): void;
+    spoofPreviewUser(token: string): string;
+}

package/dist/auth/authClientDirect.d.ts

@@ -0,0 +1,11 @@
+import type { AuthResponse, AuthCredentials } from '@geins/types';
+import { AuthClient } from './authClient';
+export declare class AuthClientDirect extends AuthClient {
+    private _authService;
+    constructor(signEndpoint: string, authEndpoint: string);
+    protected handleLogin(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+    protected handleRefresh(refreshToken: string): Promise<AuthResponse | undefined>;
+    protected handleGetUser(refreshToken: string, userToken?: string): Promise<AuthResponse | undefined>;
+    protected handleChangePassword(credentials: AuthCredentials, refreshToken: string): Promise<AuthResponse | undefined>;
+    protected handleRegister(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+}

package/dist/auth/authClientProxy.d.ts

@@ -0,0 +1,12 @@
+import type { AuthResponse, AuthCredentials } from '@geins/types';
+import { AuthClient } from './authClient';
+export declare class AuthClientProxy extends AuthClient {
+    private _authEndpointApp;
+    constructor(authEndpointApp: string);
+    private request;
+    protected handleLogin(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+    protected handleRefresh(refreshToken: string): Promise<AuthResponse | undefined>;
+    protected handleGetUser(refreshToken: string, userToken?: string): Promise<AuthResponse | undefined>;
+    protected handleChangePassword(credentials: AuthCredentials, refreshToken: string): Promise<AuthResponse | undefined>;
+    protected handleRegister(credentials: AuthCredentials): Promise<AuthResponse | undefined>;
+}

package/dist/auth/authHelpers.d.ts

@@ -0,0 +1,5 @@
+export declare function authClaimTokenParse(token: string): any;
+export declare function authClaimsTokenSerialize(token: string): string | null;
+export declare function authClaimsTokenSerializeToObject(token: string): Record<string, string> | null;
+export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
+export declare function digest(password: string): Promise<string>;

package/dist/auth/authService.d.ts

@@ -0,0 +1,17 @@
+import type { AuthResponse, AuthCredentials } from '@geins/types';
+export declare class AuthService {
+    private signEndpoint;
+    private authEndpoint;
+    private client;
+    private cookieService;
+    constructor(signEndpoint: string, authEndpoint: string);
+    private initClient;
+    private ensureClientInitialized;
+    login(credentials: AuthCredentials): Promise<AuthResponse>;
+    getUser(refreshToken: string, userToken?: string): Promise<AuthResponse>;
+    changePassword(credentials: AuthCredentials, refreshToken: string): Promise<AuthResponse>;
+    refresh(refreshToken: string): Promise<AuthResponse>;
+    register(credentials: AuthCredentials): Promise<AuthResponse>;
+    static getUserObjectFromToken(userToken: string, refreshToken?: string): AuthResponse;
+    private handleError;
+}

package/dist/auth/authServiceClient.d.ts

@@ -0,0 +1,20 @@
+import { type AuthCredentials, type AuthUserToken } from '@geins/core';
+export declare class AuthServiceClient {
+    private authEndpoint;
+    private signEndpoint;
+    constructor(authEndpoint: string, signEndpoint: string);
+    private getAuthEndpointUrl;
+    private getSignEndpointUrl;
+    private extractRefreshTokenFromResponse;
+    private requestAuthChallenge;
+    private verifyAuthChallenge;
+    private fetchUserToken;
+    private fetchRefreshToken;
+    private performChangePassword;
+    private performUserRegister;
+    register(username: string, password: string): Promise<AuthUserToken>;
+    login(username: string, password: string, rememberUser?: boolean): Promise<AuthUserToken>;
+    renewRefreshtoken(refreshToken: string): Promise<AuthUserToken>;
+    changePassword(credentials: AuthCredentials, refreshToken: string): Promise<AuthUserToken>;
+    logout(refreshToken: string): Promise<boolean>;
+}

package/dist/auth/index.d.ts

@@ -0,0 +1,6 @@
+export * from './authHelpers';
+export * from './authClient';
+export * from './authClientDirect';
+export * from './authClientProxy';
+export * from './authService';
+export * from './authServiceClient';

package/dist/geinsCRM.d.ts

@@ -0,0 +1,34 @@
+import { GeinsCore, BasePackage } from '@geins/core';
+import { AuthSettings, AuthTokens } from '@geins/types';
+import type { AuthInterface, UserInterface } from './types';
+declare class GeinsCRM extends BasePackage {
+    private _authClient;
+    private _userService;
+    private _passwordResetService;
+    private _userOrdersService;
+    constructor(core: GeinsCore, authSettings: AuthSettings);
+    private initUserService;
+    private initPasswordService;
+    private initUserOrderService;
+    setAuthTokens(tokens: AuthTokens): void;
+    clearAuthAndUser(): void;
+    spoofUser(token: string): string;
+    get auth(): AuthInterface;
+    private handleAuthResponse;
+    private authAuthorized;
+    private authLogin;
+    private authLogout;
+    private authRefresh;
+    private authGetUser;
+    get user(): UserInterface;
+    private userGet;
+    private userUpdate;
+    private userRegisterAndCreate;
+    private userCreate;
+    private userRemove;
+    private userOrders;
+    private userChangePassword;
+    private userPasswordResetRequest;
+    private userPasswordResetCommit;
+}
+export { GeinsCRM };

package/dist/graphql/index.d.ts

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

package/dist/graphql/queries.d.ts

@@ -0,0 +1,12 @@
+declare const queries: {
+    userGet: string;
+    userOrders: string;
+};
+declare const mutations: {
+    userRegister: string;
+    userUpdate: string;
+    userDelete: string;
+    pwResetRequest: string;
+    pwResetCommit: string;
+};
+export { queries, mutations };