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

package/dist/shared/validation.js

@@ -1,12 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropertyValidator = exports.ValidationResult = void 0;
+exports.PropertyValidator = void 0;
 exports.isValidUUID = isValidUUID;
-exports.validateRequiredUUID = validateRequiredUUID;
-exports.validateOptionalUUID = validateOptionalUUID;
-exports.validateRequiredString = validateRequiredString;
-exports.validateOptionalString = validateOptionalString;
-exports.createValidator = createValidator;
 exports.validate = validate;
 /**
  * Copyright 2025-present Coinbase Global, Inc.
@@ -26,332 +21,169 @@ exports.validate = validate;
 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;
 /**
- * Validation result that accumulates errors with fluent/builder pattern support
+ * Validates that a string is a valid UUID v4 format
  */
-class ValidationResult {
-    constructor() {
+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;
     }
     /**
-     * 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];
-    }
-    /**
-     * Validates that a required UUID parameter is present and valid.
-     * Returns this for method chaining.
+     * Validates that a required UUID field is present and valid.
+     * Automatically extracts the field name from the property accessor.
      *
      * @example
      * ```typescript
-     * validator
-     *   .validateRequiredUUID(request.portfolioId, 'portfolioId')
-     *   .validateRequiredUUID(request.orderId, 'orderId')
+     * validate(request)
+     *   .requiredUUID(r => r.portfolioId)
      *   .check();
      * ```
      */
-    validateRequiredUUID(value, paramName) {
+    requiredUUID(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
         if (value === undefined || value === null || value === '') {
-            this.addError(paramName, 'is required and cannot be empty', 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(paramName, 'cannot be empty or whitespace only', value);
+            this.addError(propertyName, 'cannot be empty or whitespace only', value);
             return this;
         }
         if (!isValidUUID(trimmedValue)) {
-            this.addError(paramName, 'must be a valid UUID', value);
+            this.addError(propertyName, 'must be a valid UUID', value);
         }
         return this;
     }
     /**
-     * Validates that an optional UUID parameter is valid if provided.
-     * Returns this for method chaining.
+     * Validates that an optional UUID field is valid if provided.
      */
-    validateOptionalUUID(value, paramName) {
+    optionalUUID(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
         if (value === undefined || value === null || value === '') {
-            return this; // Optional, so undefined/null/empty is valid
+            return this;
         }
         const trimmedValue = typeof value === 'string' ? value.trim() : value;
         if (trimmedValue !== '' && !isValidUUID(trimmedValue)) {
-            this.addError(paramName, 'must be a valid UUID if provided', value);
+            this.addError(propertyName, 'must be a valid UUID if provided', value);
         }
         return this;
     }
     /**
-     * Validates that a required string parameter is present and not empty.
-     * Returns this for method chaining.
+     * Validates that a required string field is present and not empty.
      */
-    validateRequiredString(value, paramName) {
+    requiredString(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
         if (value === undefined || value === null || value === '') {
-            this.addError(paramName, 'is required and cannot be empty', 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(paramName, 'cannot be empty or whitespace only', value);
+            this.addError(propertyName, 'cannot be empty or whitespace only', value);
         }
         return this;
     }
     /**
-     * Validates that an optional string parameter is not empty if provided.
-     * Returns this for method chaining.
+     * Validates that an optional string field is not empty if provided.
      */
-    validateOptionalString(value, paramName) {
+    optionalString(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
         if (value === undefined || value === null) {
-            return this; // Optional, so undefined/null is valid
+            return this;
         }
         if (typeof value === 'string') {
             const trimmedValue = value.trim();
             if (value !== '' && trimmedValue === '') {
-                this.addError(paramName, 'cannot be whitespace only if provided', value);
+                this.addError(propertyName, 'cannot be whitespace only if provided', value);
             }
         }
         return this;
     }
     /**
-     * Throw an exception if there are validation errors.
-     * Automatically detects the calling method name if no context is provided.
-     *
-     * @param contextMessage - Optional context message. If not provided, attempts to detect method name.
-     * @throws {CoinbasePrimeClientException} if there are validation errors
-     *
-     * @example
-     * ```typescript
-     * const validator = createValidator();
-     * validateRequiredUUID(validator, request.id, 'id');
-     * validator.throwIfInvalid(); // Automatically detects calling method
-     * ```
+     * Validates that a required array field is present and not empty.
      */
-    throwIfInvalid(contextMessage) {
-        if (this.hasErrors()) {
-            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 || this.getCallerContext();
-            throw new errors_1.CoinbasePrimeClientException(`${prefix}:\n${errorDetails}`);
+    requiredArray(accessor) {
+        const { propertyName, value } = this.extractProperty(accessor);
+        if (value === undefined || value === null) {
+            this.addError(propertyName, 'is required', value);
         }
-    }
-    /**
-     * Alias for throwIfInvalid() - more natural for fluent/builder pattern.
-     * Throw an exception if there are validation errors.
-     *
-     * @param contextMessage - Optional context message. If not provided, attempts to detect method name.
-     * @throws {CoinbasePrimeClientException} if there are validation errors
-     *
-     * @example
-     * ```typescript
-     * validator
-     *   .validateRequiredUUID(request.portfolioId, 'portfolioId')
-     *   .validateRequiredUUID(request.orderId, 'orderId')
-     *   .check(); // ✅ Fluent pattern
-     * ```
-     */
-    check(contextMessage) {
-        this.throwIfInvalid(contextMessage);
-    }
-    /**
-     * Attempts to extract the calling method name from the stack trace.
-     * This provides automatic context for validation errors.
-     * Falls back to 'Request validation failed' if method name cannot be determined.
-     */
-    getCallerContext() {
-        try {
-            const stack = new Error().stack;
-            if (stack) {
-                // Parse stack to find the calling method
-                const lines = stack.split('\n');
-                // Stack trace format:
-                // Line 0: Error
-                // Line 1: getCallerContext
-                // Line 2: throwIfInvalid
-                // Line 3: actual calling method (e.g., getOrder, listOnchainAddressBook)
-                const callerLine = lines[3];
-                // Try to match various stack trace formats
-                // Format: "at ClassName.methodName" or "at methodName" or "methodName@file.ts"
-                let match = callerLine.match(/at (?:\w+\.)?(\w+)/);
-                if (!match) {
-                    // Try Firefox/Safari format: methodName@file.ts:line:col
-                    match = callerLine.match(/^(\w+)@/);
-                }
-                if (match && match[1]) {
-                    const methodName = match[1];
-                    // Filter out common internal/utility method names
-                    if (!['async', 'Function', 'Object'].includes(methodName)) {
-                        return `${methodName} request validation failed`;
-                    }
-                }
-            }
+        else if (!Array.isArray(value)) {
+            this.addError(propertyName, 'must be an array', value);
         }
-        catch (e) {
-            // Silently fail - stack parsing is best-effort
-            // This might happen in different JavaScript engines or minified code
+        else if (value.length === 0) {
+            this.addError(propertyName, 'must not be an empty array', value);
         }
-        return 'Request validation failed';
-    }
-}
-exports.ValidationResult = ValidationResult;
-/**
- * Validates that a string is a valid UUID v4 format
- */
-function isValidUUID(value) {
-    return UUID_REGEX.test(value);
-}
-/**
- * Validates that a required UUID parameter is present and valid
- */
-function validateRequiredUUID(validator, value, paramName) {
-    if (value === undefined || value === null || value === '') {
-        validator.addError(paramName, 'is required and cannot be empty', value);
-        return;
-    }
-    const trimmedValue = typeof value === 'string' ? value.trim() : value;
-    if (trimmedValue === '') {
-        validator.addError(paramName, 'cannot be empty or whitespace only', value);
-        return;
-    }
-    if (!isValidUUID(trimmedValue)) {
-        validator.addError(paramName, 'must be a valid UUID', value);
-    }
-}
-/**
- * Validates that an optional UUID parameter is valid if provided
- */
-function validateOptionalUUID(validator, value, paramName) {
-    if (value === undefined || value === null || value === '') {
-        return; // Optional, so undefined/null/empty is valid
-    }
-    const trimmedValue = typeof value === 'string' ? value.trim() : value;
-    if (trimmedValue !== '' && !isValidUUID(trimmedValue)) {
-        validator.addError(paramName, 'must be a valid UUID if provided', value);
-    }
-}
-/**
- * Validates that a required string parameter is present and not empty
- */
-function validateRequiredString(validator, value, paramName) {
-    if (value === undefined || value === null || value === '') {
-        validator.addError(paramName, 'is required and cannot be empty', value);
-        return;
-    }
-    const trimmedValue = typeof value === 'string' ? value.trim() : value;
-    if (trimmedValue === '') {
-        validator.addError(paramName, 'cannot be empty or whitespace only', value);
-    }
-}
-/**
- * Validates that an optional string parameter is not empty if provided
- */
-function validateOptionalString(validator, value, paramName) {
-    if (value === undefined || value === null) {
-        return; // Optional, so undefined/null is valid
-    }
-    if (typeof value === 'string') {
-        const trimmedValue = value.trim();
-        if (value !== '' && trimmedValue === '') {
-            validator.addError(paramName, 'cannot be whitespace only if provided', value);
-        }
-    }
-}
-/**
- * Convenience function to create a new ValidationResult
- */
-function createValidator() {
-    return new ValidationResult();
-}
-/**
- * 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.validator = new ValidationResult();
-        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);
-        this.validator.validateRequiredUUID(value, propertyName);
         return this;
     }
     /**
-     * Validates that an optional UUID field is valid if provided.
+     * Validates that a required boolean field is present.
      */
-    optionalUUID(accessor) {
+    requiredBoolean(accessor) {
         const { propertyName, value } = this.extractProperty(accessor);
-        this.validator.validateOptionalUUID(value, propertyName);
+        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;
     }
     /**
-     * Validates that a required string field is present and not empty.
+     * Throws if there are validation errors.
      */
-    requiredString(accessor) {
-        const { propertyName, value } = this.extractProperty(accessor);
-        this.validator.validateRequiredString(value, propertyName);
-        return this;
+    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}`);
+        }
     }
     /**
-     * Validates that an optional string field is not empty if provided.
+     * Add a validation error
      */
-    optionalString(accessor) {
-        const { propertyName, value } = this.extractProperty(accessor);
-        this.validator.validateOptionalString(value, propertyName);
-        return this;
+    addError(paramName, message, value) {
+        this.errors.push({ paramName, message, value });
     }
     /**
-     * Throws if there are validation errors.
-     * Automatically detects the calling method name.
+     * Check if there are any validation errors
      */
-    check(contextMessage) {
-        this.validator.throwIfInvalid(contextMessage);
+    hasErrors() {
+        return this.errors.length > 0;
     }
     /**
-     * Alias for check() for backward compatibility.
+     * Get all validation errors
      */
-    throwIfInvalid(contextMessage) {
-        this.validator.throwIfInvalid(contextMessage);
+    getErrors() {
+        return [...this.errors];
     }
     /**
      * Extracts the property name and value from a property accessor function.
@@ -359,7 +191,6 @@ class PropertyValidator {
      */
     extractProperty(accessor) {
         let accessedProperty;
-        // Create a Proxy that tracks property accesses
         const proxy = new Proxy(this.source, {
             get(target, prop) {
                 if (typeof prop === 'string') {
@@ -369,7 +200,6 @@ class PropertyValidator {
                 return undefined;
             },
         });
-        // Call the accessor to trigger the Proxy
         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)');

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,
@@ -117,6 +149,11 @@ class StakingService {
     }
     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`,
@@ -129,6 +166,10 @@ class StakingService {
     }
     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`,
@@ -137,5 +178,19 @@ class StakingService {
             return response.data;
         });
     }
+    getStakingStatus(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/status`,
+                callOptions: options,
+            });
+            return response.data;
+        });
+    }
 }
 exports.StakingService = StakingService;