@coinbase-sample/prime-sdk-ts 0.8.0 → 0.8.2

package/dist/shared/__tests__/validation.test.js

@@ -29,19 +29,17 @@ describe('validation', () => {
             expect((0, validation_1.isValidUUID)('123e4567-e89b-12d3-a456')).toBe(false);
             expect((0, validation_1.isValidUUID)('123e4567e89b12d3a456426614174000')).toBe(false);
             expect((0, validation_1.isValidUUID)('')).toBe(false);
-            expect((0, validation_1.isValidUUID)('12345678-1234-1234-1234-12345678901g')).toBe(false); // 'g' is not hex
+            expect((0, validation_1.isValidUUID)('12345678-1234-1234-1234-12345678901g')).toBe(false);
         });
     });
-    describe('ValidationResult', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
+    describe('PropertyValidator', () => {
         it('should start with no errors', () => {
+            const validator = (0, validation_1.validate)({});
             expect(validator.hasErrors()).toBe(false);
             expect(validator.getErrors()).toEqual([]);
         });
         it('should accumulate errors', () => {
+            const validator = (0, validation_1.validate)({});
             validator.addError('field1', 'is required');
             validator.addError('field2', 'must be a valid UUID', 'invalid-value');
             expect(validator.hasErrors()).toBe(true);
@@ -57,146 +55,208 @@ describe('validation', () => {
             });
         });
         it('should throw with formatted error message when there are errors', () => {
+            const validator = (0, validation_1.validate)({});
             validator.addError('portfolioId', 'must be a valid UUID', 'bad-id');
             validator.addError('orderId', 'is required');
-            expect(() => validator.throwIfInvalid()).toThrow(errors_1.CoinbasePrimeClientException);
-            expect(() => validator.throwIfInvalid()).toThrow(/Request validation failed:\n  - portfolioId: must be a valid UUID \(received: 'bad-id'\)\n  - orderId: is required/);
+            expect(() => validator.check()).toThrow(errors_1.CoinbasePrimeClientException);
+            expect(() => validator.check()).toThrow(/Request validation failed:\n  - portfolioId: must be a valid UUID \(received: 'bad-id'\)\n  - orderId: is required/);
         });
         it('should not throw when there are no errors', () => {
-            expect(() => validator.throwIfInvalid()).not.toThrow();
+            const validator = (0, validation_1.validate)({});
+            expect(() => validator.check()).not.toThrow();
         });
         it('should include custom context message', () => {
+            const validator = (0, validation_1.validate)({});
             validator.addError('field1', 'is invalid');
-            expect(() => validator.throwIfInvalid('Custom operation failed')).toThrow(/Custom operation failed:/);
+            expect(() => validator.check('Custom operation failed')).toThrow(/Custom operation failed:/);
         });
     });
-    describe('validateRequiredUUID', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid UUID', () => {
-            (0, validation_1.validateRequiredUUID)(validator, '123e4567-e89b-12d3-a456-426614174000', 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should add error for undefined', () => {
-            (0, validation_1.validateRequiredUUID)(validator, undefined, 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for null', () => {
-            (0, validation_1.validateRequiredUUID)(validator, null, 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for empty string', () => {
-            (0, validation_1.validateRequiredUUID)(validator, '', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for whitespace-only string', () => {
-            (0, validation_1.validateRequiredUUID)(validator, '   ', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('whitespace');
-        });
-        it('should add error for invalid UUID format', () => {
-            (0, validation_1.validateRequiredUUID)(validator, 'not-a-uuid', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('valid UUID');
+    describe('requiredUUID', () => {
+        it('should not throw for valid UUID', () => {
+            const request = { testId: '123e4567-e89b-12d3-a456-426614174000' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { testId: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for null', () => {
+            const request = { testId: null };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for empty string', () => {
+            const request = { testId: '' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for whitespace-only string', () => {
+            const request = { testId: '   ' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/whitespace/);
+        });
+        it('should throw for invalid UUID format', () => {
+            const request = { testId: 'not-a-uuid' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.testId)
+                .check()).toThrow(/valid UUID/);
         });
     });
-    describe('validateOptionalUUID', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid UUID', () => {
-            (0, validation_1.validateOptionalUUID)(validator, '123e4567-e89b-12d3-a456-426614174000', 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for undefined', () => {
-            (0, validation_1.validateOptionalUUID)(validator, undefined, 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for null', () => {
-            (0, validation_1.validateOptionalUUID)(validator, null, 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for empty string', () => {
-            (0, validation_1.validateOptionalUUID)(validator, '', 'testId');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should add error for invalid UUID format', () => {
-            (0, validation_1.validateOptionalUUID)(validator, 'not-a-uuid', 'testId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('valid UUID');
+    describe('optionalUUID', () => {
+        it('should not throw for valid UUID', () => {
+            const request = { testId: '123e4567-e89b-12d3-a456-426614174000' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should not throw for undefined', () => {
+            const request = { testId: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should not throw for null', () => {
+            const request = { testId: null };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should not throw for empty string', () => {
+            const request = { testId: '' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).not.toThrow();
+        });
+        it('should throw for invalid UUID format', () => {
+            const request = { testId: 'not-a-uuid' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalUUID((r) => r.testId)
+                .check()).toThrow(/valid UUID/);
         });
     });
-    describe('validateRequiredString', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid string', () => {
-            (0, validation_1.validateRequiredString)(validator, 'valid-string', 'testField');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should add error for undefined', () => {
-            (0, validation_1.validateRequiredString)(validator, undefined, 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for null', () => {
-            (0, validation_1.validateRequiredString)(validator, null, 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for empty string', () => {
-            (0, validation_1.validateRequiredString)(validator, '', 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('required');
-        });
-        it('should add error for whitespace-only string', () => {
-            (0, validation_1.validateRequiredString)(validator, '   ', 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('whitespace');
+    describe('requiredString', () => {
+        it('should not throw for valid string', () => {
+            const request = { testField: 'valid-string' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { testField: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for null', () => {
+            const request = { testField: null };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for empty string', () => {
+            const request = { testField: '' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for whitespace-only string', () => {
+            const request = { testField: '   ' };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredString((r) => r.testField)
+                .check()).toThrow(/whitespace/);
         });
     });
-    describe('validateOptionalString', () => {
-        let validator;
-        beforeEach(() => {
-            validator = (0, validation_1.createValidator)();
-        });
-        it('should not add error for valid string', () => {
-            (0, validation_1.validateOptionalString)(validator, 'valid-string', 'testField');
-            expect(validator.hasErrors()).toBe(false);
-        });
-        it('should not add error for undefined', () => {
-            (0, validation_1.validateOptionalString)(validator, undefined, 'testField');
-            expect(validator.hasErrors()).toBe(false);
+    describe('optionalString', () => {
+        it('should not throw for valid string', () => {
+            const request = { testField: 'valid-string' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should not throw for undefined', () => {
+            const request = { testField: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should not throw for null', () => {
+            const request = { testField: null };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).not.toThrow();
+        });
+        it('should throw for whitespace-only when not empty', () => {
+            const request = { testField: '   ' };
+            expect(() => (0, validation_1.validate)(request)
+                .optionalString((r) => r.testField)
+                .check()).toThrow(/whitespace/);
         });
-        it('should not add error for null', () => {
-            (0, validation_1.validateOptionalString)(validator, null, 'testField');
-            expect(validator.hasErrors()).toBe(false);
+    });
+    describe('requiredArray', () => {
+        it('should not throw for valid array', () => {
+            const request = { items: ['a', 'b', 'c'] };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredArray((r) => r.items)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { items: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredArray((r) => r.items)
+                .check()).toThrow(/required/);
+        });
+        it('should throw for empty array', () => {
+            const request = { items: [] };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredArray((r) => r.items)
+                .check()).toThrow(/empty array/);
         });
-        it('should add error for whitespace-only when not empty', () => {
-            (0, validation_1.validateOptionalString)(validator, '   ', 'testField');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()[0].message).toContain('whitespace');
+    });
+    describe('requiredBoolean', () => {
+        it('should not throw for true', () => {
+            const request = { flag: true };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredBoolean((r) => r.flag)
+                .check()).not.toThrow();
+        });
+        it('should not throw for false', () => {
+            const request = { flag: false };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredBoolean((r) => r.flag)
+                .check()).not.toThrow();
+        });
+        it('should throw for undefined', () => {
+            const request = { flag: undefined };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredBoolean((r) => r.flag)
+                .check()).toThrow(/required/);
         });
     });
     describe('multiple field validation', () => {
         it('should collect all validation errors before throwing', () => {
-            const validator = (0, validation_1.createValidator)();
-            // Simulate validating multiple fields at once
-            (0, validation_1.validateRequiredUUID)(validator, undefined, 'portfolioId');
-            (0, validation_1.validateRequiredUUID)(validator, 'invalid-uuid', 'orderId');
-            (0, validation_1.validateRequiredString)(validator, '', 'productId');
-            expect(validator.hasErrors()).toBe(true);
-            expect(validator.getErrors()).toHaveLength(3);
-            expect(() => validator.throwIfInvalid('getOrder request validation failed')).toThrow(errors_1.CoinbasePrimeClientException);
+            const request = {
+                portfolioId: undefined,
+                orderId: 'invalid-uuid',
+                productId: '',
+            };
+            expect(() => (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.orderId)
+                .requiredString((r) => r.productId)
+                .check('getOrder request validation failed')).toThrow(errors_1.CoinbasePrimeClientException);
             try {
-                validator.throwIfInvalid('getOrder request validation failed');
+                (0, validation_1.validate)(request)
+                    .requiredUUID((r) => r.portfolioId)
+                    .requiredUUID((r) => r.orderId)
+                    .requiredString((r) => r.productId)
+                    .check('getOrder request validation failed');
             }
             catch (error) {
                 if (error instanceof errors_1.CoinbasePrimeClientException) {