@paakd/api 0.0.4 → 0.0.6

package/dist/src/policies.spec.js

@@ -1,463 +0,0 @@
-"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

@@ -1,39 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,95 +0,0 @@
-"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

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

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

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