@paakd/api 0.0.1 → 0.0.2

package/dist/src/products.spec.js

@@ -0,0 +1,519 @@
+"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 products_1 = require("./products");
+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(),
+    createHeadersInterceptor: vi.fn(),
+}));
+vi.mock('./compressor/brotli', () => ({
+    brotliCompression: {
+        name: 'brotli',
+        compress: vi.fn(),
+        decompress: vi.fn(),
+    },
+}));
+vi.mock('../gen/src/proto/products/v1/service_pb', () => ({
+    ProductsService: {},
+}));
+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 mockCreateHeadersInterceptor = vi.mocked(interceptors_1.createHeadersInterceptor);
+/**
+ * Setup function following @testing-library's render pattern
+ */
+function setupProductsService() {
+    (0, test_utils_1.clearAllMocks)();
+    const { config, interceptors, transport } = (0, test_utils_1.setupCommonMocks)();
+    const client = {
+        getCollectionByID: vi.fn(),
+        createCollection: 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);
+    }));
+    mockCreateClient.mockReturnValue(client);
+    return { client, config, interceptors, transport };
+}
+describe('Products Service', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    describe('getCollectionByID', () => {
+        it('should successfully retrieve a collection by ID', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const mockCollection = {
+                id: 'collection-1',
+                name: 'Summer Collection',
+                description: 'Summer 2024 collection',
+                productCount: 25,
+            };
+            client.getCollectionByID.mockResolvedValue(mockCollection);
+            const result = yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockCollection);
+            expect(client.getCollectionByID).toHaveBeenCalledWith({
+                id: 'collection-1',
+            });
+        }));
+        it('should return not found when collection does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(5, 'NOT_FOUND', 'Collection not found');
+            client.getCollectionByID.mockRejectedValue(error);
+            const result = yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'invalid-collection',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result.code).toBe(5);
+        }));
+        it('should handle service unavailability', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(14, 'UNAVAILABLE', 'Service temporarily unavailable');
+            client.getCollectionByID.mockRejectedValue(error);
+            const result = yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should include custom headers in request context', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Summer Collection',
+            });
+            const customHeaders = {
+                'x-shop-id': '123',
+                'x-locale': 'en-US',
+            };
+            yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: customHeaders,
+            });
+            expect(mockCreateHeadersInterceptor).toHaveBeenCalledWith(customHeaders);
+        }));
+        it('should use checkout configuration for enterprise URL', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client, config } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Summer Collection',
+            });
+            yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            expect(mockCreateGrpcTransport).toHaveBeenCalledWith(expect.objectContaining({
+                baseUrl: config.enterpriseURL,
+            }));
+        }));
+        it('should enable compression for data transfer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Summer Collection',
+            });
+            yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            const transportConfig = mockCreateGrpcTransport.mock.calls[0][0];
+            expect(transportConfig).toHaveProperty('acceptCompression');
+            expect(transportConfig).toHaveProperty('sendCompression');
+        }));
+        it('should handle invalid collection ID format', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(3, 'INVALID_ARGUMENT', 'Invalid collection ID format');
+            client.getCollectionByID.mockRejectedValue(error);
+            const result = yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: '',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle internal server errors gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(13, 'INTERNAL', 'Internal server error');
+            client.getCollectionByID.mockRejectedValue(error);
+            const result = yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result.code).toBe(connect_1.Code.Internal);
+        }));
+        it('should support concurrent collection retrievals', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Collection',
+            });
+            const results = yield Promise.all([
+                (0, products_1.getCollectionByID)({
+                    body: { collectionId: 'collection-1' },
+                    headers: {},
+                }),
+                (0, products_1.getCollectionByID)({
+                    body: { collectionId: 'collection-2' },
+                    headers: {},
+                }),
+                (0, products_1.getCollectionByID)({
+                    body: { collectionId: 'collection-3' },
+                    headers: {},
+                }),
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results.every(r => r.status === 'success')).toBe(true);
+        }));
+    });
+    describe('createCollection', () => {
+        it('should successfully create a new collection', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const newCollection = {
+                name: 'Winter Collection',
+                description: 'Winter 2024 collection',
+            };
+            const mockCollection = Object.assign({ id: 'new-collection-1' }, newCollection);
+            const mockResponse = {
+                collection: mockCollection,
+            };
+            client.createCollection.mockResolvedValue(mockResponse);
+            const result = yield (0, products_1.createCollection)({
+                body: newCollection,
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockResponse);
+            expect(client.createCollection).toHaveBeenCalledWith(expect.objectContaining(newCollection));
+        }));
+        it('should reject collection creation with invalid data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(3, 'INVALID_ARGUMENT', 'Invalid collection data');
+            client.createCollection.mockRejectedValue(error);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: '',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle duplicate collection names', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(6, 'ALREADY_EXISTS', 'Collection with this name already exists');
+            client.createCollection.mockRejectedValue(error);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: 'Existing Collection',
+                    description: 'New description',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should reject creation without authentication', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Authentication required');
+            client.createCollection.mockRejectedValue(error);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: 'New Collection',
+                    description: 'Description',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should handle permission denied errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(7, 'PERMISSION_DENIED', 'User does not have permission to create collections');
+            client.createCollection.mockRejectedValue(error);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: 'New Collection',
+                    description: 'Description',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should include authentication interceptor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.createCollection.mockResolvedValue({
+                id: 'new-collection-1',
+                name: 'New Collection',
+            });
+            yield (0, products_1.createCollection)({
+                body: {
+                    name: 'New Collection',
+                    description: 'Description',
+                },
+                headers: {},
+            });
+            expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled();
+        }));
+        it('should handle service errors during creation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(13, 'INTERNAL', 'Database error occurred');
+            client.createCollection.mockRejectedValue(error);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: 'New Collection',
+                    description: 'Description',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+            expect(result.code).toBe(connect_1.Code.Internal);
+        }));
+        it('should handle collection limit exceeded', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(8, 'RESOURCE_EXHAUSTED', 'Collection limit exceeded');
+            client.createCollection.mockRejectedValue(error);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: 'New Collection',
+                    description: 'Description',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('failed');
+        }));
+        it('should support multiple concurrent collection creations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.createCollection.mockResolvedValue({
+                id: 'collection-id',
+                name: 'Collection',
+            });
+            const results = yield Promise.all([
+                (0, products_1.createCollection)({
+                    body: {
+                        name: 'Collection 1',
+                        description: 'Desc 1',
+                    },
+                    headers: {},
+                }),
+                (0, products_1.createCollection)({
+                    body: {
+                        name: 'Collection 2',
+                        description: 'Desc 2',
+                    },
+                    headers: {},
+                }),
+                (0, products_1.createCollection)({
+                    body: {
+                        name: 'Collection 3',
+                        description: 'Desc 3',
+                    },
+                    headers: {},
+                }),
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results.every(r => r.status === 'success')).toBe(true);
+        }));
+    });
+    describe('Products Service - Common Behavior', () => {
+        it('should apply authentication interceptor for all operations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Collection',
+            });
+            yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            expect(mockCreateAuthenticationInterceptor).toHaveBeenCalled();
+        }));
+        it('should load configuration for each request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Collection',
+            });
+            yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            expect(mockGetCheckoutConfig).toHaveBeenCalled();
+        }));
+        it('should create transport with compression enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Collection',
+            });
+            yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {},
+            });
+            expect(mockCreateGrpcTransport).toHaveBeenCalledWith(expect.objectContaining({
+                acceptCompression: expect.any(Array),
+                sendCompression: expect.any(Object),
+            }));
+        }));
+        it('should handle concurrent mixed operations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Collection',
+            });
+            client.createCollection.mockResolvedValue({
+                id: 'new-collection',
+                name: 'New Collection',
+            });
+            const results = yield Promise.all([
+                (0, products_1.getCollectionByID)({
+                    body: { collectionId: 'collection-1' },
+                    headers: {},
+                }),
+                (0, products_1.createCollection)({
+                    body: {
+                        name: 'New Collection',
+                        description: 'Desc',
+                    },
+                    headers: {},
+                }),
+                (0, products_1.getCollectionByID)({
+                    body: { collectionId: 'collection-2' },
+                    headers: {},
+                }),
+            ]);
+            expect(results).toHaveLength(3);
+            expect(results.every(r => r.status === 'success')).toBe(true);
+        }));
+        it('should handle edge cases with special characters in collection names', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const mockCollection = {
+                id: 'collection-special',
+                name: "Summer's Special Collection 2024!",
+                description: 'Special offer: 50% off - São Paulo exclusive',
+            };
+            client.createCollection.mockResolvedValue(mockCollection);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: "Summer's Special Collection 2024!",
+                    description: 'Special offer: 50% off - São Paulo exclusive',
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+            expect(result.value).toEqual(mockCollection);
+        }));
+        it('should handle very long collection descriptions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const longDescription = 'A'.repeat(500);
+            const mockCollection = {
+                id: 'collection-long',
+                name: 'Collection',
+                description: longDescription,
+            };
+            client.createCollection.mockResolvedValue(mockCollection);
+            const result = yield (0, products_1.createCollection)({
+                body: {
+                    name: 'Collection',
+                    description: longDescription,
+                },
+                headers: {},
+            });
+            expect(result.status).toBe('success');
+        }));
+        it('should handle null or undefined headers gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            client.getCollectionByID.mockResolvedValue({
+                id: 'collection-1',
+                name: 'Collection',
+            });
+            const result = yield (0, products_1.getCollectionByID)({
+                body: {
+                    collectionId: 'collection-1',
+                },
+                headers: {
+                    'x-header': null,
+                },
+            });
+            expect(result.status).toBe('success');
+        }));
+        it('should consistent error handling across operations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { client } = setupProductsService();
+            const error = (0, test_utils_1.createMockConnectError)(16, 'UNAUTHENTICATED', 'Invalid authentication');
+            client.getCollectionByID.mockRejectedValueOnce(error);
+            client.createCollection.mockRejectedValueOnce(error);
+            const results = yield Promise.all([
+                (0, products_1.getCollectionByID)({
+                    body: { collectionId: 'collection-1' },
+                    headers: {},
+                }),
+                (0, products_1.createCollection)({
+                    body: {
+                        name: 'Collection',
+                        description: 'Desc',
+                    },
+                    headers: {},
+                }),
+            ]);
+            expect(results.every(r => r.status === 'failed')).toBe(true);
+            expect(results.every(r => r.code === 16)).toBe(true);
+        }));
+    });
+});

package/dist/src/profile.d.ts

@@ -0,0 +1,62 @@
+import { Code, ConnectError } from '@connectrpc/connect';
+import type { UpdateProfileRequest } from '../gen/src/proto/customers/v1/entities/profile_pb';
+export interface GetBasicProfileProps {
+    body: {
+        customerId: string;
+        jwt: string;
+    };
+    headers: Record<string, string | null>;
+}
+export interface GetProfileProps {
+    body: {
+        customerId: string;
+        jwt: string;
+    };
+    headers: Record<string, string | null>;
+}
+export interface UpdateProfileProps {
+    body: Omit<UpdateProfileRequest, '$typeName'> & {
+        jwt: string;
+    };
+    headers: Record<string, string | null>;
+}
+export declare function getBasicProfile({ body: { customerId, jwt }, headers, }: GetBasicProfileProps): Promise<ConnectError | {
+    value: import("../gen/src/proto/customers/v1/entities/profile_pb").BasicProfileResponse;
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+    value?: undefined;
+}>;
+export declare function getProfile({ body: { customerId, jwt }, headers, }: GetProfileProps): Promise<ConnectError | {
+    value: import("../gen/src/proto/customers/v1/entities/profile_pb").ProfileResponse;
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+    value?: undefined;
+}>;
+export declare function updateProfile({ body: { jwt, ...prop }, headers, }: UpdateProfileProps): Promise<ConnectError | {
+    value: import("@bufbuild/protobuf").Message<"UpdateProfileResponse">;
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+    value?: undefined;
+}>;
+//# sourceMappingURL=profile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,YAAY,EAAgB,MAAM,qBAAqB,CAAA;AAItE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAA;AAQ7F,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAA;QAClB,GAAG,EAAE,MAAM,CAAA;KACZ,CAAA;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAA;QAClB,GAAG,EAAE,MAAM,CAAA;KACZ,CAAA;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,GAAG;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IAC/D,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,wBAAsB,eAAe,CAAC,EACpC,IAAI,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EACzB,OAAO,GACR,EAAE,oBAAoB;;;;;;;;;;;;GA0CtB;AAED,wBAAsB,UAAU,CAAC,EAC/B,IAAI,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,EACzB,OAAO,GACR,EAAE,eAAe;;;;;;;;;;;;GA0CjB;AAED,wBAAsB,aAAa,CAAC,EAClC,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,EACtB,OAAO,GACR,EAAE,kBAAkB;;;;;;;;;;;;GAsCpB"}