@paakd/api 0.0.1 → 0.0.2

package/dist/src/address.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.spec.d.ts","sourceRoot":"","sources":["../../src/address.spec.ts"],"names":[],"mappings":""}

package/dist/src/address.spec.js

@@ -0,0 +1,488 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connect_1 = require("@connectrpc/connect");
+const connect_node_1 = require("@connectrpc/connect-node");
+const config_1 = require("@paakd/config");
+const address_1 = require("./address");
+const interceptors_1 = require("./interceptors");
+const test_utils_1 = require("./test-utils");
+// Mock dependencies
+vi.mock('@connectrpc/connect', () => __awaiter(void 0, void 0, void 0, function* () {
+    const actual = yield vi.importActual('@connectrpc/connect');
+    return Object.assign(Object.assign({}, actual), { createClient: vi.fn() });
+}));
+vi.mock('@connectrpc/connect-node', () => ({
+    createGrpcTransport: vi.fn(),
+}));
+vi.mock('@paakd/config', () => ({
+    getCheckoutConfig: vi.fn(),
+}));
+vi.mock('./interceptors', () => ({
+    createAuthenticationInterceptor: vi.fn(),
+    createCustomerAuthenticationInterceptor: vi.fn(),
+    createHeadersInterceptor: vi.fn(),
+}));
+vi.mock('./compressor/brotli', () => ({
+    brotliCompression: {
+        name: 'brotli',
+        compress: vi.fn(),
+        decompress: vi.fn(),
+    },
+}));
+vi.mock('../gen/src/proto/customers/v1/service_pb', () => ({
+    CustomerService: {},
+}));
+const mockGetCheckoutConfig = vi.mocked(config_1.getCheckoutConfig);
+const mockCreateGrpcTransport = vi.mocked(connect_node_1.createGrpcTransport);
+const mockCreateClient = vi.mocked(connect_1.createClient);
+const mockCreateHeadersInterceptor = vi.mocked(interceptors_1.createHeadersInterceptor);
+const mockCreateAuthenticationInterceptor = vi.mocked(interceptors_1.createAuthenticationInterceptor);
+const mockCreateCustomerAuthenticationInterceptor = vi.mocked(interceptors_1.createCustomerAuthenticationInterceptor);
+function setupAddressService() {
+    (0, test_utils_1.clearAllMocks)();
+    const { config, interceptors, transport } = (0, test_utils_1.setupCommonMocks)();
+    const client = {
+        getAddresses: vi.fn(),
+        getAddress: vi.fn(),
+        addAddress: vi.fn(),
+        updateAddress: vi.fn(),
+        deleteAddress: vi.fn(),
+    };
+    mockGetCheckoutConfig.mockResolvedValue(config);
+    mockCreateGrpcTransport.mockReturnValue(transport);
+    mockCreateHeadersInterceptor.mockImplementation(() => next => (req) => __awaiter(this, void 0, void 0, function* () {
+        return yield next(req);
+    }));
+    mockCreateAuthenticationInterceptor.mockImplementation(() => next => (req) => __awaiter(this, void 0, void 0, function* () {
+        return yield next(req);
+    }));
+    mockCreateCustomerAuthenticationInterceptor.mockImplementation(() => next => (req) => __awaiter(this, void 0, void 0, function* () {
+        return yield next(req);
+    }));
+    mockCreateClient.mockReturnValue(client);
+    return {
+        client,
+        config,
+        interceptors,
+        transport,
+    };
+}
+describe('Address Service', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    describe('getAddresses', () => {
+        it('should successfully fetch all addresses for a customer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const mockAddresses = [
+                {
+                    id: 'addr-1',
+                    customerId: 'cust-1',
+                    street: '123 Main St',
+                    city: 'New York',
+                },
+                {
+                    id: 'addr-2',
+                    customerId: 'cust-1',
+                    street: '456 Oak Ave',
+                    city: 'Los Angeles',
+                },
+            ];
+            client.getAddresses.mockResolvedValue({ addresses: mockAddresses });
+            const result = yield (0, address_1.getAddresses)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status === 'success' && result.value).toBe(mockAddresses);
+        }));
+        it('should handle customer not found error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(5, 'NOT_FOUND', 'Customer not found');
+            client.getAddresses.mockRejectedValue(error);
+            const result = yield (0, address_1.getAddresses)({
+                body: {
+                    customerId: 'invalid-customer',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result.code).toBe(5);
+        }));
+        it('should reject request with invalid JWT', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Invalid JWT token');
+            client.getAddresses.mockRejectedValue(error);
+            const result = yield (0, address_1.getAddresses)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'invalid-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should return empty list when customer has no addresses', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            client.getAddresses.mockResolvedValue({ addresses: [] });
+            const result = yield (0, address_1.getAddresses)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual([]);
+        }));
+    });
+    describe('getAddress', () => {
+        it('should successfully fetch a single address', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const mockAddress = {
+                id: 'addr-1',
+                customerId: 'cust-1',
+                street: '123 Main St',
+                city: 'New York',
+                state: 'NY',
+                zipCode: '10001',
+            };
+            client.getAddress.mockResolvedValue(mockAddress);
+            const result = yield (0, address_1.getAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    addressId: 'addr-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockAddress);
+        }));
+        it('should return not found when address does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(5, 'NOT_FOUND', 'Address not found');
+            client.getAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.getAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    addressId: 'invalid-addr',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should require valid JWT', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Unauthenticated');
+            client.getAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.getAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    addressId: 'addr-1',
+                    jwt: '',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+    });
+    describe('addAddress', () => {
+        it('should successfully add a new address', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const newAddress = {
+                customerId: 'cust-1',
+                firstName: 'Jane',
+                lastName: 'Doe',
+                address1: '789 Pine St',
+                address2: '',
+                address3: '',
+                city: 'Chicago',
+                zipCode: '60601',
+                country: 'US',
+                phoneNumber: '555-9999',
+            };
+            const mockResponse = {
+                address: Object.assign({ id: 'addr-3' }, newAddress),
+            };
+            client.addAddress.mockResolvedValue(mockResponse);
+            const result = yield (0, address_1.addAddress)({
+                body: Object.assign(Object.assign({}, newAddress), { jwt: 'token-123' }),
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockResponse.address);
+        }));
+        it('should reject invalid address data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(3, 'INVALID_ARGUMENT', 'Invalid address data');
+            client.addAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.addAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    address1: '',
+                    address2: '',
+                    address3: '',
+                    city: '',
+                    zipCode: '',
+                    country: 'US',
+                    phoneNumber: '555-1234',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should reject requests without authentication', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Authentication required');
+            client.addAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.addAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    address1: '789 Pine St',
+                    address2: '',
+                    address3: '',
+                    city: 'Chicago',
+                    zipCode: '60601',
+                    country: 'US',
+                    phoneNumber: '555-1234',
+                    jwt: 'invalid-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+    });
+    describe('updateAddress', () => {
+        it('should successfully update an existing address', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const updateData = {
+                id: 'addr-1',
+                customerId: 'cust-1',
+                firstName: 'John',
+                lastName: 'Doe',
+                address1: '123 Main St Updated',
+                address2: '',
+                address3: '',
+                city: 'New York',
+                zipCode: '10001',
+                country: 'US',
+                phoneNumber: '555-1234',
+            };
+            const mockResponse = {
+                address: Object.assign(Object.assign({}, updateData), { zipCode: '10001' }),
+            };
+            client.updateAddress.mockResolvedValue(mockResponse);
+            const result = yield (0, address_1.updateAddress)({
+                body: Object.assign(Object.assign({}, updateData), { jwt: 'token-123' }),
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockResponse.address);
+        }));
+        it('should return not found for non-existent address', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(5, 'NOT_FOUND', 'Address not found');
+            client.updateAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.updateAddress)({
+                body: {
+                    id: 'addr-1',
+                    customerId: 'cust-1',
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    addressId: 'addr-1',
+                    street: 'Some St',
+                    address1: 'Some St',
+                    address2: '',
+                    city: 'Some City',
+                    state: 'NY',
+                    zipCode: '10001',
+                    country: 'US',
+                    phoneNumber: '555-1234',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should reject updates with invalid data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(3, 'INVALID_ARGUMENT', 'Invalid update data');
+            client.updateAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.updateAddress)({
+                body: {
+                    id: 'addr-1',
+                    customerId: 'cust-1',
+                    street: '',
+                    city: '',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+    });
+    describe('deleteAddress', () => {
+        it('should successfully delete an address', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const mockResponse = {
+                success: true,
+            };
+            client.deleteAddress.mockResolvedValue(mockResponse);
+            const result = yield (0, address_1.deleteAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    addressId: 'addr-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockResponse);
+        }));
+        it('should return not found when address does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(5, 'NOT_FOUND', 'Address not found');
+            client.deleteAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.deleteAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    addressId: 'invalid-addr',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should reject deletion without authentication', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Authentication required');
+            client.deleteAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.deleteAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    addressId: 'addr-1',
+                    jwt: 'invalid-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle service errors gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const error = (0, test_utils_1.createMockConnectError)(13, 'INTERNAL', 'Internal server error');
+            client.deleteAddress.mockRejectedValue(error);
+            const result = yield (0, address_1.deleteAddress)({
+                body: {
+                    customerId: 'cust-1',
+                    addressId: 'addr-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result.code).toBe(connect_1.Code.Internal);
+        }));
+    });
+    describe('Address Service - Common Behavior', () => {
+        it('should apply all interceptors correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            client.getAddresses.mockResolvedValue({ addresses: [] });
+            const headers = {
+                'x-shop-id': '123',
+                'x-locale': 'en-US',
+            };
+            yield (0, address_1.getAddresses)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers,
+            });
+            expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(headers);
+            expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled();
+            expect(mockCreateCustomerAuthenticationInterceptor).toHaveBeenCalledWith('token-123');
+        }));
+        it('should load configuration for each request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            client.getAddresses.mockResolvedValue({ addresses: [] });
+            yield (0, address_1.getAddresses)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(mockGetCheckoutConfig).toHaveBeenCalled();
+        }));
+        it('should create transport with compression enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            client.getAddresses.mockResolvedValue({ addresses: [] });
+            yield (0, address_1.getAddresses)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(mockCreateGrpcTransport).toHaveBeenCalledWith(expect.objectContaining({
+                acceptCompression: expect.any(Array),
+                sendCompression: expect.any(Object),
+            }));
+        }));
+        it('should handle concurrent requests independently', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupAddressService();
+            const mockAddresses = [
+                { id: 'addr-1', customerId: 'cust-1', street: '123 Main St' },
+            ];
+            client.getAddresses.mockResolvedValue({ addresses: mockAddresses });
+            const results = yield Promise.all([
+                (0, address_1.getAddresses)({
+                    body: {
+                        customerId: 'cust-1',
+                        jwt: 'token-1',
+                    },
+                    headers: {},
+                }),
+                (0, address_1.getAddresses)({
+                    body: {
+                        customerId: 'cust-2',
+                        jwt: 'token-2',
+                    },
+                    headers: {},
+                }),
+                (0, address_1.getAddresses)({
+                    body: {
+                        customerId: 'cust-3',
+                        jwt: 'token-3',
+                    },
+                    headers: {},
+                }),
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results.every(r => r.status === 'success')).toBe(true);
+        }));
+    });
+});

package/dist/src/auth.d.ts

@@ -0,0 +1,27 @@
+import type { ChangePasswordRequest } from '../gen/src/proto/customers/v1/entities/profile_pb';
+import type { LoginResponse } from '../gen/src/proto/auth/v1/entities/auth_pb';
+import type { ApiResponse, SuccessResponse, ErrorResponse } from './address';
+export interface LoginRequestProps {
+    body: {
+        email: string;
+        password: string;
+    };
+    headers: Record<string, string | null>;
+}
+export interface RefreshTokenRequestProps {
+    body: {
+        refreshToken: string;
+    };
+    headers: Record<string, string | null>;
+}
+export interface ChangePasswordRequestProps {
+    body: ChangePasswordRequest & {
+        jwt: string;
+    };
+    headers: Record<string, string | null>;
+}
+export type { ApiResponse, SuccessResponse, ErrorResponse };
+export declare function login({ body: { email, password }, headers, }: LoginRequestProps): Promise<ApiResponse<LoginResponse>>;
+export declare function refreshToken({ body: { refreshToken }, headers, }: RefreshTokenRequestProps): Promise<ApiResponse<LoginResponse>>;
+export declare function changePassword({ body: { jwt, ...prop }, headers, }: ChangePasswordRequestProps): Promise<ApiResponse<any>>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/src/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAA;AAE9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAA;AAO9E,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE5E,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM,CAAA;QACb,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE;QACJ,YAAY,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,qBAAqB,GAAG;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAGD,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,CAAA;AAE3D,wBAAsB,KAAK,CAAC,EAC1B,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,EACzB,OAAO,GACR,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAwCzD;AAED,wBAAsB,YAAY,CAAC,EACjC,IAAI,EAAE,EAAE,YAAY,EAAE,EACtB,OAAO,GACR,EAAE,wBAAwB,GAAG,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAsChE;AAED,wBAAsB,cAAc,CAAC,EACnC,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,EACtB,OAAO,GACR,EAAE,0BAA0B,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAsCxD"}

package/dist/src/auth.js

@@ -0,0 +1,155 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+exports.refreshToken = refreshToken;
+exports.changePassword = changePassword;
+const connect_1 = require("@connectrpc/connect");
+const connect_node_1 = require("@connectrpc/connect-node");
+const config_1 = require("@paakd/config");
+const service_pb_1 = require("../gen/src/proto/auth/v1/service_pb");
+const service_pb_2 = require("../gen/src/proto/customers/v1/service_pb");
+const brotli_1 = require("./compressor/brotli");
+const interceptors_1 = require("./interceptors");
+function login(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: { email, password }, headers, }) {
+        const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+        const transport = (0, connect_node_1.createGrpcTransport)({
+            baseUrl: checkoutConfig.enterpriseURL,
+            interceptors: [
+                (0, interceptors_1.createHeadersInterceptor)(headers),
+                (0, interceptors_1.createAuthenticationInterceptor)(checkoutConfig),
+            ],
+            acceptCompression: [brotli_1.brotliCompression],
+            sendCompression: brotli_1.brotliCompression,
+        });
+        const auth = (0, connect_1.createClient)(service_pb_1.AuthService, transport);
+        try {
+            const value = yield auth.login({
+                email,
+                password,
+            });
+            console.log('Login successful for email:', email);
+            return {
+                value,
+                status: 'success',
+            };
+        }
+        catch (err) {
+            console.log('Error during login:', err);
+            if (err instanceof connect_1.ConnectError) {
+                return {
+                    code: err.code,
+                    rawMessage: err.rawMessage,
+                    message: err.rawMessage,
+                    status: 'failed',
+                };
+            }
+            return {
+                code: connect_1.Code.Internal,
+                rawMessage: 'An unexpected error occurred during login.',
+                message: 'An unexpected error occurred during login.',
+                status: 'failed',
+            };
+        }
+    });
+}
+function refreshToken(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: { refreshToken }, headers, }) {
+        const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+        const transport = (0, connect_node_1.createGrpcTransport)({
+            baseUrl: checkoutConfig.enterpriseURL,
+            interceptors: [
+                (0, interceptors_1.createHeadersInterceptor)(headers),
+                (0, interceptors_1.createAuthenticationInterceptor)(checkoutConfig),
+            ],
+            acceptCompression: [brotli_1.brotliCompression],
+            sendCompression: brotli_1.brotliCompression,
+        });
+        const auth = (0, connect_1.createClient)(service_pb_1.AuthService, transport);
+        try {
+            const value = yield auth.refreshToken({
+                refreshToken,
+            });
+            return {
+                value,
+                status: 'success',
+            };
+        }
+        catch (err) {
+            if (err instanceof connect_1.ConnectError) {
+                return {
+                    code: err.code,
+                    rawMessage: err.rawMessage,
+                    message: err.rawMessage,
+                    status: 'failed',
+                };
+            }
+            return {
+                code: connect_1.Code.Internal,
+                rawMessage: 'An unexpected error occurred while refreshing the token.',
+                message: 'An unexpected error occurred while refreshing the token.',
+                status: 'failed',
+            };
+        }
+    });
+}
+function changePassword(_a) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _b = _a.body, { jwt } = _b, prop = __rest(_b, ["jwt"]), { headers } = _a;
+        const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+        const transport = (0, connect_node_1.createGrpcTransport)({
+            baseUrl: checkoutConfig.enterpriseURL,
+            interceptors: [
+                (0, interceptors_1.createHeadersInterceptor)(headers),
+                (0, interceptors_1.createAuthenticationInterceptor)(checkoutConfig),
+                (0, interceptors_1.createCustomerAuthenticationInterceptor)(jwt),
+            ],
+            acceptCompression: [brotli_1.brotliCompression],
+            sendCompression: brotli_1.brotliCompression,
+        });
+        const profile = (0, connect_1.createClient)(service_pb_2.CustomerService, transport);
+        try {
+            const value = yield profile.changePassword(prop);
+            return {
+                value,
+                status: 'success',
+            };
+        }
+        catch (err) {
+            if (err instanceof connect_1.ConnectError) {
+                return {
+                    code: err.code,
+                    rawMessage: err.rawMessage,
+                    message: err.rawMessage,
+                    status: 'failed',
+                };
+            }
+            return {
+                code: connect_1.Code.Internal,
+                rawMessage: 'profile change password failed',
+                message: 'An unexpected error occurred during profile change password.',
+                status: 'failed',
+            };
+        }
+    });
+}

package/dist/src/auth.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=auth.spec.d.ts.map