@paakd/api 0.0.1 → 0.0.2

package/dist/src/profile.js

@@ -0,0 +1,151 @@
+"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.getBasicProfile = getBasicProfile;
+exports.getProfile = getProfile;
+exports.updateProfile = updateProfile;
+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/customers/v1/service_pb");
+const brotli_1 = require("./compressor/brotli");
+const interceptors_1 = require("./interceptors");
+function getBasicProfile(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: { customerId, jwt }, headers, }) {
+        try {
+            const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+            const profileClient = (0, connect_1.createClient)(service_pb_1.CustomerService, (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 value = yield profileClient.basicProfile({
+                customerId,
+            });
+            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 fetching the profile.',
+                message: 'An unexpected error occurred while fetching the profile.',
+                status: 'failed',
+            };
+        }
+    });
+}
+function getProfile(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: { customerId, jwt }, headers, }) {
+        try {
+            const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+            const profileClient = (0, connect_1.createClient)(service_pb_1.CustomerService, (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 value = yield profileClient.profile({
+                customerId,
+            });
+            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 fetching the profile.',
+                message: 'An unexpected error occurred while fetching the profile.',
+                status: 'failed',
+            };
+        }
+    });
+}
+function updateProfile(_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_1.CustomerService, transport);
+        try {
+            const value = yield profile.updateProfile(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 update failed',
+                message: 'An unexpected error occurred during profile update.',
+                status: 'failed',
+            };
+        }
+    });
+}

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

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

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

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

package/dist/src/profile.spec.js

@@ -0,0 +1,475 @@
+"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 profile_1 = require("./profile");
+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 mockCreateAuthenticationInterceptor = vi.mocked(interceptors_1.createAuthenticationInterceptor);
+const mockCreateCustomerAuthenticationInterceptor = vi.mocked(interceptors_1.createCustomerAuthenticationInterceptor);
+const mockCreateHeadersInterceptor = vi.mocked(interceptors_1.createHeadersInterceptor);
+function setupProfileService() {
+    (0, test_utils_1.clearAllMocks)();
+    const { config, interceptors, transport } = (0, test_utils_1.setupCommonMocks)();
+    const client = {
+        basicProfile: vi.fn(),
+        profile: vi.fn(),
+        updateProfile: 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('Profile Service', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    describe('getBasicProfile', () => {
+        it('should successfully fetch basic profile for customer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const mockProfile = {
+                customerId: 'cust-1',
+                email: 'user@example.com',
+                firstName: 'John',
+                lastName: 'Doe',
+            };
+            client.basicProfile.mockResolvedValue(mockProfile);
+            const result = yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockProfile);
+        }));
+        it('should reject request without authentication', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Invalid JWT token');
+            client.basicProfile.mockRejectedValue(error);
+            const result = yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'invalid-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle customer not found error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(5, 'NOT_FOUND', 'Customer not found');
+            client.basicProfile.mockRejectedValue(error);
+            const result = yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'invalid-cust',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result.code).toBe(5);
+        }));
+        it('should apply customer authentication interceptor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const jwt = 'user-jwt-token';
+            client.basicProfile.mockResolvedValue({
+                customerId: 'cust-1',
+                email: 'user@example.com',
+            });
+            yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt,
+                },
+                headers: {},
+            });
+            expect(mockCreateCustomerAuthenticationInterceptor).toHaveBeenCalledWith(jwt);
+        }));
+    });
+    describe('getProfile', () => {
+        it('should successfully fetch full profile for customer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const mockProfile = {
+                customerId: 'cust-1',
+                email: 'user@example.com',
+                firstName: 'John',
+                lastName: 'Doe',
+                phone: '555-1234',
+                dateOfBirth: '1990-01-01',
+                preferences: {
+                    newsletter: true,
+                    sms: false,
+                },
+            };
+            client.profile.mockResolvedValue(mockProfile);
+            const result = yield (0, profile_1.getProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockProfile);
+        }));
+        it('should reject unauthenticated requests', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Session expired');
+            client.profile.mockRejectedValue(error);
+            const result = yield (0, profile_1.getProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'expired-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle service unavailability', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(14, 'UNAVAILABLE', 'Service temporarily unavailable');
+            client.profile.mockRejectedValue(error);
+            const result = yield (0, profile_1.getProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should use checkout config for enterprise URL', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client, config } = setupProfileService();
+            client.profile.mockResolvedValue({
+                customerId: 'cust-1',
+                email: 'user@example.com',
+            });
+            yield (0, profile_1.getProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(mockCreateGrpcTransport).toHaveBeenCalledWith(expect.objectContaining({
+                baseUrl: config.enterpriseURL,
+            }));
+        }));
+    });
+    describe('updateProfile', () => {
+        it('should successfully update customer profile', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const updateData = {
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    email: 'jane@example.com',
+                    otherNames: 'Jane Marie',
+                    dateOfBirth: '1990-01-01',
+                    gender: 'female',
+                    phone: '555-1234',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            };
+            const mockResponse = {
+                customerId: 'cust-1',
+                firstName: 'Jane',
+                lastName: 'Smith',
+                email: 'user@example.com',
+            };
+            client.updateProfile.mockResolvedValue(mockResponse);
+            const result = yield (0, profile_1.updateProfile)(updateData);
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockResponse);
+        }));
+        it('should reject invalid profile data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(3, 'INVALID_ARGUMENT', 'Invalid profile data');
+            client.updateProfile.mockRejectedValue(error);
+            const result = yield (0, profile_1.updateProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: '',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should reject update without authentication', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Invalid JWT');
+            client.updateProfile.mockRejectedValue(error);
+            const result = yield (0, profile_1.updateProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'John',
+                    jwt: 'invalid-token',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle permission denied error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(7, 'PERMISSION_DENIED', 'Cannot update profile for another customer');
+            client.updateProfile.mockRejectedValue(error);
+            const result = yield (0, profile_1.updateProfile)({
+                body: {
+                    customerId: 'other-cust',
+                    firstName: 'Jane',
+                    jwt: 'user-jwt',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should not include JWT in service request body', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            client.updateProfile.mockResolvedValue({
+                customerId: 'cust-1',
+                firstName: 'Jane',
+            });
+            const jwt = 'user-jwt-token';
+            const updateData = {
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    email: 'jane@example.com',
+                    otherNames: 'Jane Marie',
+                    dateOfBirth: '1990-01-01',
+                    gender: 'female',
+                    phone: '555-1234',
+                    jwt,
+                },
+                headers: {},
+            };
+            yield (0, profile_1.updateProfile)(updateData);
+            const callArgs = client.updateProfile.mock.calls[0][0];
+            expect(callArgs).not.toHaveProperty('jwt');
+        }));
+        it('should apply three interceptors in correct order', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            client.updateProfile.mockResolvedValue({
+                customerId: 'cust-1',
+                firstName: 'Jane',
+            });
+            const headers = {
+                'x-shop-id': '123',
+            };
+            const jwt = 'user-jwt-token';
+            yield (0, profile_1.updateProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    email: 'jane@example.com',
+                    otherNames: 'Jane Marie',
+                    dateOfBirth: '1990-01-01',
+                    gender: 'female',
+                    phone: '555-1234',
+                    jwt,
+                },
+                headers,
+            });
+            expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(headers);
+            expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled();
+            expect(mockCreateCustomerAuthenticationInterceptor).toHaveBeenCalledWith(jwt);
+        }));
+        it('should handle database errors gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const error = (0, test_utils_1.createMockConnectError)(13, 'INTERNAL', 'Database error');
+            client.updateProfile.mockRejectedValue(error);
+            const result = yield (0, profile_1.updateProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'Jane',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result.code).toBe(connect_1.Code.Internal);
+        }));
+    });
+    describe('Profile Service - Common Behavior', () => {
+        it('should load configuration for each request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            client.basicProfile.mockResolvedValue({
+                customerId: 'cust-1',
+                email: 'user@example.com',
+            });
+            yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    email: 'john@example.com',
+                    otherNames: 'John Michael',
+                    dateOfBirth: '1985-05-15',
+                    gender: 'male',
+                    phone: '555-5678',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(mockGetCheckoutConfig).toHaveBeenCalled();
+        }));
+        it('should enable compression for all operations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            client.basicProfile.mockResolvedValue({
+                customerId: 'cust-1',
+                email: 'user@example.com',
+            });
+            yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    email: 'john@example.com',
+                    otherNames: 'John Michael',
+                    dateOfBirth: '1985-05-15',
+                    gender: 'male',
+                    phone: '555-5678',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            const transportConfig = mockCreateGrpcTransport.mock.calls[0][0];
+            expect(transportConfig).toHaveProperty('acceptCompression');
+            expect(transportConfig).toHaveProperty('sendCompression');
+        }));
+        it('should handle concurrent profile operations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const mockProfile1 = {
+                customerId: 'cust-1',
+                email: 'user1@example.com',
+                firstName: 'John',
+            };
+            const mockProfile2 = {
+                customerId: 'cust-2',
+                email: 'user2@example.com',
+                firstName: 'Jane',
+            };
+            client.basicProfile.mockResolvedValueOnce(mockProfile1);
+            client.basicProfile.mockResolvedValueOnce(mockProfile2);
+            const results = yield Promise.all([
+                (0, profile_1.getBasicProfile)({
+                    body: {
+                        customerId: 'cust-1',
+                        jwt: 'token-1',
+                    },
+                    headers: {},
+                }),
+                (0, profile_1.getBasicProfile)({
+                    body: {
+                        customerId: 'cust-2',
+                        jwt: 'token-2',
+                    },
+                    headers: {},
+                }),
+            ]);
+            expect(results).toHaveLength(2);
+            expect(results.every(r => r.status === 'success')).toBe(true);
+        }));
+        it('should handle edge cases with special characters in data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            const mockProfile = {
+                customerId: 'cust-1',
+                email: 'user+tag@example.com',
+                firstName: "O'Connor",
+                lastName: 'François',
+            };
+            client.basicProfile.mockResolvedValue(mockProfile);
+            const result = yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockProfile);
+        }));
+        it('should handle null or undefined headers gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProfileService();
+            client.basicProfile.mockResolvedValue({
+                customerId: 'cust-1',
+                email: 'user@example.com',
+            });
+            const result = yield (0, profile_1.getBasicProfile)({
+                body: {
+                    customerId: 'cust-1',
+                    jwt: 'token-123',
+                },
+                headers: {
+                    'x-header': null,
+                },
+            });
+            expect(result.status).toBe('success');
+        }));
+    });
+});