@paakd/api 0.0.1 → 0.0.2

package/dist/src/policies.spec.js

@@ -0,0 +1,463 @@
+"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 interceptors_1 = require("./interceptors");
+const policies_1 = require("./policies");
+// 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('./compressor/brotli', () => ({
+    brotliCompression: {
+        name: 'brotli',
+        compress: vi.fn(),
+        decompress: 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().mockReturnValue(() => { }),
+}));
+vi.mock('../gen/src/proto/auth/v1/service_pb', () => ({
+    AuthService: {},
+}));
+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);
+describe('policies', () => {
+    let mockAuthClient;
+    let mockTransport;
+    let mockCheckoutConfig;
+    let mockInterceptor;
+    beforeEach(() => {
+        // Reset all mocks
+        vi.clearAllMocks();
+        // Setup mock objects
+        mockAuthClient = {
+            getPolicies: vi.fn(),
+            savePolicies: vi.fn(),
+            addPolicy: vi.fn(),
+            addPolicies: vi.fn(),
+            removePolicy: vi.fn(),
+            removePolicies: vi.fn(),
+            removeFilteredPolicy: vi.fn(),
+            getFilteredPolicy: vi.fn(),
+        };
+        mockTransport = {};
+        mockCheckoutConfig = {
+            enterpriseURL: 'https://enterprise.example.com',
+        };
+        mockInterceptor = {};
+        // Setup mock implementations
+        mockGetCheckoutConfig.mockResolvedValue(mockCheckoutConfig);
+        mockCreateGrpcTransport.mockReturnValue(mockTransport);
+        mockCreateAuthenticationInterceptor.mockReturnValue(mockInterceptor);
+        mockCreateHeadersInterceptor.mockReturnValue(mockInterceptor);
+        mockCreateClient.mockReturnValue(mockAuthClient);
+    });
+    describe('getPolicies', () => {
+        it('should return policies on success', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockPolicies = [
+                { pType: 'p', v0: 'alice', v1: 'data1', v2: 'read' },
+                { pType: 'p', v0: 'bob', v1: 'data2', v2: 'write' },
+            ];
+            mockAuthClient.getPolicies.mockResolvedValue({
+                policies: mockPolicies,
+            });
+            const result = yield (0, policies_1.getPolicies)({
+                headers: {},
+            });
+            expect(config_1.getCheckoutConfig).toHaveBeenCalled();
+            expect(connect_node_1.createGrpcTransport).toHaveBeenCalledWith({
+                baseUrl: mockCheckoutConfig.enterpriseURL,
+                interceptors: [mockInterceptor, mockInterceptor],
+                acceptCompression: expect.any(Array), // Accept gzip and Brotli compression
+                sendCompression: expect.any(Object), // Send Brotli compression
+            });
+            expect(connect_1.createClient).toHaveBeenCalledWith({}, mockTransport);
+            expect(mockAuthClient.getPolicies).toHaveBeenCalledWith({});
+            expect(result).toEqual({
+                value: mockPolicies,
+                status: 'success',
+            });
+        }));
+        it('should handle ConnectError', () => __awaiter(void 0, void 0, void 0, function* () {
+            const connectError = {
+                code: connect_1.Code.Unauthenticated,
+                rawMessage: 'Invalid credentials',
+                message: 'Authentication failed',
+                name: 'ConnectError',
+            };
+            // Make it pass instanceof check
+            Object.setPrototypeOf(connectError, connect_1.ConnectError.prototype);
+            mockAuthClient.getPolicies.mockRejectedValue(connectError);
+            const result = yield (0, policies_1.getPolicies)({
+                headers: {},
+            });
+            expect(result).toEqual(Object.assign(Object.assign({}, connectError), { message: 'Invalid credentials', status: 'failed' }));
+        }));
+        it('should handle unexpected errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const unexpectedError = new Error('Network error');
+            mockAuthClient.getPolicies.mockRejectedValue(unexpectedError);
+            const result = yield (0, policies_1.getPolicies)({
+                headers: {},
+            });
+            expect(result).toEqual({
+                code: connect_1.Code.Internal,
+                rawMessage: 'An unexpected error occurred during login.',
+                message: 'An unexpected error occurred during login.',
+                status: 'failed',
+            });
+        }));
+    });
+    describe('savePolicies', () => {
+        it('should save policies successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const inputPolicies = [
+                ['p', 'alice', 'data1', 'read'],
+                ['p', 'bob', 'data2', 'write'],
+            ];
+            mockAuthClient.savePolicies.mockResolvedValue({});
+            const result = yield (0, policies_1.savePolicies)({
+                headers: {},
+                body: { inPolicies: inputPolicies },
+            });
+            expect(mockAuthClient.savePolicies).toHaveBeenCalledWith({
+                policies: [
+                    {
+                        pType: 'p',
+                        v0: 'alice',
+                        v1: 'data1',
+                        v2: 'read',
+                        v3: '',
+                        v4: '',
+                        v5: '',
+                    },
+                    {
+                        pType: 'p',
+                        v0: 'bob',
+                        v1: 'data2',
+                        v2: 'write',
+                        v3: '',
+                        v4: '',
+                        v5: '',
+                    },
+                ],
+            });
+            expect(result).toEqual({ status: 'success' });
+        }));
+        it('should handle policies with different lengths', () => __awaiter(void 0, void 0, void 0, function* () {
+            const inputPolicies = [
+                ['p', 'alice'],
+                ['p', 'bob', 'data2', 'write', 'extra1', 'extra2', 'extra3', 'extra4'],
+            ];
+            mockAuthClient.savePolicies.mockResolvedValue({});
+            const result = yield (0, policies_1.savePolicies)({
+                headers: {},
+                body: { inPolicies: inputPolicies },
+            });
+            expect(mockAuthClient.savePolicies).toHaveBeenCalledWith({
+                policies: [
+                    { pType: 'p', v0: 'alice', v1: '', v2: '', v3: '', v4: '', v5: '' },
+                    {
+                        pType: 'p',
+                        v0: 'bob',
+                        v1: 'data2',
+                        v2: 'write',
+                        v3: 'extra1',
+                        v4: 'extra2',
+                        v5: 'extra3',
+                    },
+                ],
+            });
+            expect(result).toEqual({ status: 'success' });
+        }));
+        it('should handle ConnectError', () => __awaiter(void 0, void 0, void 0, function* () {
+            const connectError = {
+                code: connect_1.Code.Internal,
+                rawMessage: 'Database error',
+                message: 'Save failed',
+                name: 'ConnectError',
+            };
+            // Make it pass instanceof check
+            Object.setPrototypeOf(connectError, connect_1.ConnectError.prototype);
+            mockAuthClient.savePolicies.mockRejectedValue(connectError);
+            const result = yield (0, policies_1.savePolicies)({
+                headers: {},
+                body: { inPolicies: [['p', 'alice']] },
+            });
+            expect(result).toEqual(Object.assign(Object.assign({}, connectError), { message: 'Database error', status: 'failed' }));
+        }));
+    });
+    describe('addPolicy', () => {
+        it('should add policy successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const rule = ['alice', 'data1', 'read'];
+            const pType = 'p';
+            mockAuthClient.addPolicy.mockResolvedValue({});
+            const result = yield (0, policies_1.addPolicy)({
+                headers: {},
+                body: { rule, pType },
+            });
+            expect(mockAuthClient.addPolicy).toHaveBeenCalledWith({ rule, pType });
+            expect(result).toEqual({ status: 'success' });
+        }));
+        it('should handle ConnectError', () => __awaiter(void 0, void 0, void 0, function* () {
+            const connectError = {
+                code: connect_1.Code.InvalidArgument,
+                rawMessage: 'Invalid policy format',
+                message: 'Add failed',
+                name: 'ConnectError',
+            };
+            // Make it pass instanceof check
+            Object.setPrototypeOf(connectError, connect_1.ConnectError.prototype);
+            mockAuthClient.addPolicy.mockRejectedValue(connectError);
+            const result = yield (0, policies_1.addPolicy)({
+                headers: {},
+                body: { rule: ['alice'], pType: 'p' },
+            });
+            expect(result).toEqual(Object.assign(Object.assign({}, connectError), { message: 'Invalid policy format', status: 'failed' }));
+        }));
+    });
+    describe('addPolicies', () => {
+        it('should add multiple policies successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const rules = [
+                ['alice', 'data1', 'read'],
+                ['bob', 'data2', 'write'],
+            ];
+            const pType = 'p';
+            mockAuthClient.addPolicies.mockResolvedValue({});
+            const result = yield (0, policies_1.addPolicies)({
+                headers: {},
+                body: { inRules: rules, pType },
+            });
+            expect(mockAuthClient.addPolicies).toHaveBeenCalledWith({
+                rules: [
+                    { rules: ['alice', 'data1', 'read'] },
+                    { rules: ['bob', 'data2', 'write'] },
+                ],
+                pType,
+            });
+            expect(result).toEqual({ status: 'success' });
+        }));
+        it('should handle unexpected errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const unexpectedError = new Error('Network timeout');
+            mockAuthClient.addPolicies.mockRejectedValue(unexpectedError);
+            const result = yield (0, policies_1.addPolicies)({
+                headers: {},
+                body: { inRules: [['alice']], pType: 'p' },
+            });
+            expect(result).toEqual({
+                code: connect_1.Code.Internal,
+                rawMessage: 'An unexpected error occurred while adding policies.',
+                message: 'An unexpected error occurred while adding policies.',
+                status: 'failed',
+            });
+        }));
+    });
+    describe('removePolicy', () => {
+        it('should remove policy successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const rule = ['alice', 'data1', 'read'];
+            const pType = 'p';
+            mockAuthClient.removePolicy.mockResolvedValue({});
+            const result = yield (0, policies_1.removePolicy)({
+                headers: {},
+                body: { rule, pType },
+            });
+            expect(mockAuthClient.removePolicy).toHaveBeenCalledWith({ rule, pType });
+            expect(result).toEqual({ status: 'success' });
+        }));
+        it('should handle ConnectError', () => __awaiter(void 0, void 0, void 0, function* () {
+            const connectError = {
+                code: connect_1.Code.NotFound,
+                rawMessage: 'Policy not found',
+                message: 'Remove failed',
+                name: 'ConnectError',
+            };
+            // Make it pass instanceof check
+            Object.setPrototypeOf(connectError, connect_1.ConnectError.prototype);
+            mockAuthClient.removePolicy.mockRejectedValue(connectError);
+            const result = yield (0, policies_1.removePolicy)({
+                headers: {},
+                body: { rule: ['alice'], pType: 'p' },
+            });
+            expect(result).toEqual(Object.assign(Object.assign({}, connectError), { message: 'Policy not found', status: 'failed' }));
+        }));
+    });
+    describe('removePolicies', () => {
+        it('should remove multiple policies successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const rules = [
+                ['alice', 'data1', 'read'],
+                ['bob', 'data2', 'write'],
+            ];
+            const pType = 'p';
+            mockAuthClient.removePolicies.mockResolvedValue({});
+            const result = yield (0, policies_1.removePolicies)({
+                headers: {},
+                body: { inRules: rules, pType },
+            });
+            expect(mockAuthClient.removePolicies).toHaveBeenCalledWith({
+                rules: [
+                    { rules: ['alice', 'data1', 'read'] },
+                    { rules: ['bob', 'data2', 'write'] },
+                ],
+                pType,
+            });
+            expect(result).toEqual({ status: 'success' });
+        }));
+    });
+    describe('removeFilteredPolicy', () => {
+        it('should remove filtered policy successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const pType = 'p';
+            const fieldIndex = 0;
+            const fieldValues = ['alice'];
+            mockAuthClient.removeFilteredPolicy.mockResolvedValue({});
+            const result = yield (0, policies_1.removeFilteredPolicy)({
+                headers: {},
+                body: { pType, fieldIndex, fieldValues },
+            });
+            expect(mockAuthClient.removeFilteredPolicy).toHaveBeenCalledWith({
+                pType,
+                fieldIndex,
+                fieldValues,
+            });
+            expect(result).toEqual({ status: 'success' });
+        }));
+        it('should handle ConnectError', () => __awaiter(void 0, void 0, void 0, function* () {
+            const connectError = {
+                code: connect_1.Code.InvalidArgument,
+                rawMessage: 'Invalid filter criteria',
+                message: 'Filter failed',
+                name: 'ConnectError',
+            };
+            // Make it pass instanceof check
+            Object.setPrototypeOf(connectError, connect_1.ConnectError.prototype);
+            mockAuthClient.removeFilteredPolicy.mockRejectedValue(connectError);
+            const result = yield (0, policies_1.removeFilteredPolicy)({
+                headers: {},
+                body: { pType: 'p', fieldIndex: 0, fieldValues: ['alice'] },
+            });
+            expect(result).toEqual(Object.assign(Object.assign({}, connectError), { message: 'Invalid filter criteria', status: 'failed' }));
+        }));
+    });
+    describe('getFilteredPolicy', () => {
+        it('should get filtered policies successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const filter = {
+                v0: [['alice'], ['bob']],
+                v1: [['data1']],
+            };
+            const mockPolicies = [
+                { pType: 'p', v0: 'alice', v1: 'data1', v2: 'read' },
+            ];
+            mockAuthClient.getFilteredPolicy.mockResolvedValue({
+                policies: mockPolicies,
+            });
+            const result = yield (0, policies_1.getFilteredPolicy)({
+                headers: {},
+                body: { inFilter: filter },
+            });
+            expect(mockAuthClient.getFilteredPolicy).toHaveBeenCalledWith({
+                filter: [
+                    {
+                        key: 'v0',
+                        values: [{ items: ['alice'] }, { items: ['bob'] }],
+                    },
+                    {
+                        key: 'v1',
+                        values: [{ items: ['data1'] }],
+                    },
+                ],
+            });
+            expect(result).toEqual({
+                value: mockPolicies,
+                status: 'success',
+            });
+        }));
+        it('should handle empty filter', () => __awaiter(void 0, void 0, void 0, function* () {
+            const filter = {};
+            mockAuthClient.getFilteredPolicy.mockResolvedValue({
+                policies: [],
+            });
+            const result = yield (0, policies_1.getFilteredPolicy)({
+                headers: {},
+                body: { inFilter: filter },
+            });
+            expect(mockAuthClient.getFilteredPolicy).toHaveBeenCalledWith({
+                filter: [],
+            });
+            expect(result).toEqual({
+                value: [],
+                status: 'success',
+            });
+        }));
+        it('should handle unexpected errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const unexpectedError = new Error('Database connection failed');
+            mockAuthClient.getFilteredPolicy.mockRejectedValue(unexpectedError);
+            const result = yield (0, policies_1.getFilteredPolicy)({
+                headers: {},
+                body: { inFilter: {} },
+            });
+            expect(result).toEqual({
+                code: connect_1.Code.Internal,
+                rawMessage: 'An unexpected error occurred while fetching policies.',
+                message: 'An unexpected error occurred while fetching policies.',
+                status: 'failed',
+            });
+        }));
+    });
+    describe('common functionality', () => {
+        it('should setup transport and client consistently across all functions', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Test one function to verify the setup pattern
+            yield (0, policies_1.getPolicies)({
+                headers: {},
+            });
+            expect(config_1.getCheckoutConfig).toHaveBeenCalled();
+            expect(interceptors_1.createAuthenticationInterceptor).toHaveBeenCalledWith(mockCheckoutConfig);
+            expect(connect_node_1.createGrpcTransport).toHaveBeenCalledWith({
+                baseUrl: mockCheckoutConfig.enterpriseURL,
+                interceptors: [mockInterceptor, mockInterceptor],
+                acceptCompression: expect.any(Array), // Accept gzip and Brotli compression
+                sendCompression: expect.any(Object), // Send Brotli compression
+            });
+            expect(connect_1.createClient).toHaveBeenCalledWith({}, mockTransport);
+        }));
+        it('should use consistent timeout across all functions', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockAuthClient.getPolicies.mockResolvedValue({ policies: [] });
+            mockAuthClient.addPolicy.mockResolvedValue({});
+            mockAuthClient.removePolicy.mockResolvedValue({});
+            yield (0, policies_1.getPolicies)({
+                headers: {},
+            });
+            yield (0, policies_1.addPolicy)({
+                headers: {},
+                body: { rule: ['alice'], pType: 'p' },
+            });
+            yield (0, policies_1.removePolicy)({
+                headers: {},
+                body: { rule: ['bob'], pType: 'p' },
+            });
+            // Verify all calls use the same timeout
+            expect(mockAuthClient.getPolicies).toHaveBeenCalledWith({});
+            expect(mockAuthClient.addPolicy).toHaveBeenCalledWith(expect.any(Object));
+            expect(mockAuthClient.removePolicy).toHaveBeenCalledWith(expect.any(Object));
+        }));
+    });
+});

package/dist/src/products.d.ts

@@ -0,0 +1,39 @@
+import { Code, ConnectError } from '@connectrpc/connect';
+import type { CreateCollectionRequest } from '../gen/src/proto/products/v1/entities/collection_pb';
+export interface GetCollectionByIDProps {
+    body: {
+        collectionId: string;
+    };
+    headers: Record<string, string | null>;
+}
+export interface CreateCollectionProps {
+    body: Omit<CreateCollectionRequest, '$typeName'>;
+    headers: Record<string, string | null>;
+}
+export declare function getCollectionByID({ body: { collectionId }, headers, }: GetCollectionByIDProps): Promise<ConnectError | {
+    value: import("../gen/src/proto/products/v1/entities/collection_pb").GetCollectionByIDResponse;
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+    value?: undefined;
+}>;
+export declare function createCollection({ body, headers, }: CreateCollectionProps): Promise<ConnectError | {
+    value: import("../gen/src/proto/products/v1/entities/collection_pb").CreateCollectionResponse;
+    status: string;
+    code?: undefined;
+    rawMessage?: undefined;
+    message?: undefined;
+} | {
+    code: Code;
+    rawMessage: string;
+    message: string;
+    status: string;
+    value?: undefined;
+}>;
+//# sourceMappingURL=products.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"products.d.ts","sourceRoot":"","sources":["../../src/products.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,YAAY,EAAgB,MAAM,qBAAqB,CAAA;AAItE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qDAAqD,CAAA;AAOlG,MAAM,WAAW,sBAAsB;IACrC,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,qBAAqB;IACpC,IAAI,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,CAAC,CAAA;IAChD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAA;CACvC;AAED,wBAAsB,iBAAiB,CAAC,EACtC,IAAI,EAAE,EAAE,YAAY,EAAE,EACtB,OAAO,GACR,EAAE,sBAAsB;;;;;;;;;;;;GAyCxB;AAED,wBAAsB,gBAAgB,CAAC,EACrC,IAAI,EACJ,OAAO,GACR,EAAE,qBAAqB;;;;;;;;;;;;GAuCvB"}

package/dist/src/products.js

@@ -0,0 +1,95 @@
+"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 });
+exports.getCollectionByID = getCollectionByID;
+exports.createCollection = createCollection;
+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/products/v1/service_pb");
+const brotli_1 = require("./compressor/brotli");
+const interceptors_1 = require("./interceptors");
+function getCollectionByID(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body: { collectionId }, headers, }) {
+        try {
+            const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+            const productClient = (0, connect_1.createClient)(service_pb_1.ProductsService, (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 value = yield productClient.getCollectionByID({
+                id: collectionId,
+            });
+            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 collection.',
+                message: 'An unexpected error occurred while fetching the collection.',
+                status: 'failed',
+            };
+        }
+    });
+}
+function createCollection(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ body, headers, }) {
+        try {
+            const checkoutConfig = yield (0, config_1.getCheckoutConfig)();
+            const productClient = (0, connect_1.createClient)(service_pb_1.ProductsService, (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 value = yield productClient.createCollection(body);
+            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 creating the collection.',
+                message: 'An unexpected error occurred while creating the collection.',
+                status: 'failed',
+            };
+        }
+    });
+}

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

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

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

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