@coinbase-sample/prime-sdk-ts 0.7.1 → 0.8.1

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

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const validation_1 = require("../validation");
+const errors_1 = require("../../errors");
+describe('validation', () => {
+    describe('isValidUUID', () => {
+        it('should return true for valid UUIDs', () => {
+            expect((0, validation_1.isValidUUID)('123e4567-e89b-12d3-a456-426614174000')).toBe(true);
+            expect((0, validation_1.isValidUUID)('550e8400-e29b-41d4-a716-446655440000')).toBe(true);
+            expect((0, validation_1.isValidUUID)('ABCDEF12-3456-7890-ABCD-EF1234567890')).toBe(true);
+        });
+        it('should return false for invalid UUIDs', () => {
+            expect((0, validation_1.isValidUUID)('not-a-uuid')).toBe(false);
+            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);
+        });
+    });
+    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);
+            expect(validator.getErrors()).toHaveLength(2);
+            expect(validator.getErrors()[0]).toEqual({
+                paramName: 'field1',
+                message: 'is required',
+            });
+            expect(validator.getErrors()[1]).toEqual({
+                paramName: 'field2',
+                message: 'must be a valid UUID',
+                value: 'invalid-value',
+            });
+        });
+        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.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', () => {
+            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.check('Custom operation failed')).toThrow(/Custom operation failed:/);
+        });
+    });
+    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('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('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('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/);
+        });
+    });
+    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/);
+        });
+    });
+    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 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 {
+                (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) {
+                    expect(error.message).toContain('portfolioId');
+                    expect(error.message).toContain('orderId');
+                    expect(error.message).toContain('productId');
+                }
+            }
+        });
+    });
+});

package/dist/shared/validation.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyValidator = void 0;
+exports.isValidUUID = isValidUUID;
+exports.validate = validate;
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const errors_1 = require("../errors");
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Validates that a string is a valid UUID v4 format
+ */
+function isValidUUID(value) {
+    return UUID_REGEX.test(value);
+}
+/**
+ * Creates a validator with property accessor support for automatic field name inference.
+ *
+ * @param source - The source object containing the fields to validate
+ *
+ * @example
+ * ```typescript
+ * validate(request)
+ *   .requiredUUID(r => r.portfolioId)
+ *   .requiredUUID(r => r.orderId)
+ *   .check();
+ * ```
+ */
+function validate(source) {
+    return new PropertyValidator(source);
+}
+/**
+ * Validator with property accessor support for automatic field name inference.
+ * Uses Proxy to track property accesses and extract field names automatically.
+ */
+class PropertyValidator {
+    constructor(source) {
+        this.errors = [];
+        this.source = source;
+    }
+    /**
+     * Validates that a required UUID field is present and valid.
+     * Automatically extracts the field name from the property accessor.
+     *
+     * @example
+     * ```typescript
+     * validate(request)
+     *   .requiredUUID(r => r.portfolioId)
+     *   .check();
+     * ```
+     */
+    requiredUUID(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
+        if (value === undefined || value === null || value === '') {
+            this.addError(propertyName, 'is required and cannot be empty', value);
+            return this;
+        }
+        const trimmedValue = typeof value === 'string' ? value.trim() : value;
+        if (trimmedValue === '') {
+            this.addError(propertyName, 'cannot be empty or whitespace only', value);
+            return this;
+        }
+        if (!isValidUUID(trimmedValue)) {
+            this.addError(propertyName, 'must be a valid UUID', value);
+        }
+        return this;
+    }
+    /**
+     * Validates that an optional UUID field is valid if provided.
+     */
+    optionalUUID(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
+        if (value === undefined || value === null || value === '') {
+            return this;
+        }
+        const trimmedValue = typeof value === 'string' ? value.trim() : value;
+        if (trimmedValue !== '' && !isValidUUID(trimmedValue)) {
+            this.addError(propertyName, 'must be a valid UUID if provided', value);
+        }
+        return this;
+    }
+    /**
+     * Validates that a required string field is present and not empty.
+     */
+    requiredString(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
+        if (value === undefined || value === null || value === '') {
+            this.addError(propertyName, 'is required and cannot be empty', value);
+            return this;
+        }
+        const trimmedValue = typeof value === 'string' ? value.trim() : value;
+        if (trimmedValue === '') {
+            this.addError(propertyName, 'cannot be empty or whitespace only', value);
+        }
+        return this;
+    }
+    /**
+     * Validates that an optional string field is not empty if provided.
+     */
+    optionalString(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
+        if (value === undefined || value === null) {
+            return this;
+        }
+        if (typeof value === 'string') {
+            const trimmedValue = value.trim();
+            if (value !== '' && trimmedValue === '') {
+                this.addError(propertyName, 'cannot be whitespace only if provided', value);
+            }
+        }
+        return this;
+    }
+    /**
+     * Validates that a required array field is present and not empty.
+     */
+    requiredArray(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
+        if (value === undefined || value === null) {
+            this.addError(propertyName, 'is required', value);
+        }
+        else if (!Array.isArray(value)) {
+            this.addError(propertyName, 'must be an array', value);
+        }
+        else if (value.length === 0) {
+            this.addError(propertyName, 'must not be an empty array', value);
+        }
+        return this;
+    }
+    /**
+     * Validates that a required boolean field is present.
+     */
+    requiredBoolean(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
+        if (value === undefined || value === null) {
+            this.addError(propertyName, 'is required', value);
+        }
+        else if (typeof value !== 'boolean') {
+            this.addError(propertyName, 'must be a boolean', value);
+        }
+        return this;
+    }
+    /**
+     * Throws if there are validation errors.
+     */
+    check(contextMessage) {
+        if (this.errors.length > 0) {
+            const errorDetails = this.errors
+                .map((err) => {
+                const valueInfo = err.value !== undefined ? ` (received: '${err.value}')` : '';
+                return `  - ${err.paramName}: ${err.message}${valueInfo}`;
+            })
+                .join('\n');
+            const prefix = contextMessage || 'Request validation failed';
+            throw new errors_1.CoinbasePrimeClientException(`${prefix}:\n${errorDetails}`);
+        }
+    }
+    /**
+     * Add a validation error
+     */
+    addError(paramName, message, value) {
+        this.errors.push({ paramName, message, value });
+    }
+    /**
+     * Check if there are any validation errors
+     */
+    hasErrors() {
+        return this.errors.length > 0;
+    }
+    /**
+     * Get all validation errors
+     */
+    getErrors() {
+        return [...this.errors];
+    }
+    /**
+     * Extracts the property name and value from a property accessor function.
+     * Uses a Proxy to track which property was accessed.
+     */
+    extractProperty(accessor) {
+        let accessedProperty;
+        const proxy = new Proxy(this.source, {
+            get(target, prop) {
+                if (typeof prop === 'string') {
+                    accessedProperty = prop;
+                    return target[prop];
+                }
+                return undefined;
+            },
+        });
+        const value = accessor(proxy);
+        if (!accessedProperty) {
+            throw new Error('Unable to extract property name. Ensure the accessor accesses a property directly (e.g., r => r.fieldName)');
+        }
+        return { propertyName: accessedProperty, value };
+    }
+}
+exports.PropertyValidator = PropertyValidator;

package/dist/staking/index.js

@@ -27,12 +27,18 @@ exports.StakingService = void 0;
  */
 const clients_1 = require("../clients");
 const paginatedResponse_1 = require("../shared/paginatedResponse");
+const validation_1 = require("../shared/validation");
 class StakingService {
     constructor(client) {
         this.client = client;
     }
     createStake(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.walletId)
+                .requiredUUID((r) => r.idempotencyKey)
+                .check();
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined, walletId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/staking/initiate`,
@@ -45,6 +51,11 @@ class StakingService {
     }
     createUnstake(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.walletId)
+                .requiredUUID((r) => r.idempotencyKey)
+                .check();
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined, walletId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/staking/unstake`,
@@ -57,6 +68,12 @@ class StakingService {
     }
     createPortfolioStake(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.idempotencyKey)
+                .requiredString((r) => r.currencySymbol)
+                .requiredString((r) => r.amount)
+                .check();
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/staking/initiate`,
@@ -69,6 +86,12 @@ class StakingService {
     }
     createPortfolioUnstake(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.idempotencyKey)
+                .requiredString((r) => r.currencySymbol)
+                .requiredString((r) => r.amount)
+                .check();
             const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined });
             const response = yield this.client.request({
                 url: `portfolios/${request.portfolioId}/staking/unstake`,
@@ -81,6 +104,10 @@ class StakingService {
     }
     queryTransactionValidators(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredArray((r) => r.transactionIds)
+                .check();
             const paginationOptions = (0, paginatedResponse_1.getDefaultPaginationOptions)(this.client, options);
             const { transactionIds, cursor, limit, sortDirection } = request;
             const bodyParams = {
@@ -101,6 +128,11 @@ class StakingService {
     }
     claimRewards(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.walletId)
+                .requiredUUID((r) => r.idempotencyKey)
+                .check();
             const { idempotencyKey, inputs, portfolioId, walletId } = request;
             const bodyParams = {
                 idempotencyKey,
@@ -115,5 +147,36 @@ class StakingService {
             return response.data;
         });
     }
+    previewUnstake(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.walletId)
+                .requiredString((r) => r.amount)
+                .check();
+            const bodyParams = Object.assign(Object.assign({}, request), { portfolioId: undefined, walletId: undefined });
+            const response = yield this.client.request({
+                url: `portfolios/${request.portfolioId}/wallets/${request.walletId}/staking/unstake/preview`,
+                method: clients_1.Method.POST,
+                bodyParams,
+                callOptions: options,
+            });
+            return response.data;
+        });
+    }
+    getUnstakingStatus(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, validation_1.validate)(request)
+                .requiredUUID((r) => r.portfolioId)
+                .requiredUUID((r) => r.walletId)
+                .check();
+            const { portfolioId, walletId } = request;
+            const response = yield this.client.request({
+                url: `portfolios/${portfolioId}/wallets/${walletId}/staking/unstake/status`,
+                callOptions: options,
+            });
+            return response.data;
+        });
+    }
 }
 exports.StakingService = StakingService;