@coinbase-sample/prime-sdk-ts 0.6.3 → 0.6.4

package/dist/constants.js

@@ -16,7 +16,7 @@ exports.DEFAULT_MAX_ITEMS = exports.DEFAULT_MAX_PAGES = exports.DEFAULT_PAGINATI
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-exports.VERSION = '0.6.3';
+exports.VERSION = '0.6.4';
 exports.API_BASE_PATH = 'https://api.prime.coinbase.com/v1/';
 exports.USER_AGENT = 'coinbase-prime-ts/' + exports.VERSION;
 exports.CB_ACCESS_KEY_HEADER = 'X-CB-ACCESS-KEY';

package/dist/model/enumPrefixes.js

@@ -0,0 +1,330 @@
+"use strict";
+/**
+ * Copyright 2025-present Coinbase Global, Inc.
+ *
+ * This file is auto-generated during the type generation process.
+ * Do not edit manually - regenerate by running: npm run generate-types
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENUM_ANALYSIS = exports.GENERATED_ENUM_PREFIXES = void 0;
+/**
+ * Auto-generated enum prefix patterns extracted from OpenAPI specification
+ * Total enums analyzed: 43
+ * Prefix patterns discovered: 77
+ */
+exports.GENERATED_ENUM_PREFIXES = [
+    'ACTION_',
+    'ACTIVITY_CATEGORY_',
+    'ACTIVITY_LEVEL_',
+    'ACTIVITY_SECONDARY_',
+    'ACTIVITY_STATUS_',
+    'ACTIVITY_TYPE_',
+    'ADDRESS_BOOK_',
+    'ALLOCATION_STATUS_',
+    'BALANCE_',
+    'BENCHMARK_',
+    'BILATERAL_',
+    'BILLING_',
+    'CHANGE_',
+    'CLAIM_',
+    'COINBASE_',
+    'COMPLETE_',
+    'CONCENTRATION_',
+    'COUNTERPARTY_',
+    'CRYPTO_',
+    'DEPOSIT_',
+    'DESTINATION_',
+    'DESTINATION_PAYMENT_',
+    'FCM_FUTURES_',
+    'FCM_MARGIN_',
+    'FCM_POSITION_',
+    'FILL_OR_',
+    'FULL_',
+    'GOOD_UNTIL_',
+    'HIERARCHY_TYPE_',
+    'IMMEDIATE_OR_',
+    'INTERNAL_',
+    'INVOICE_STATE_',
+    'INVOICE_TYPE_',
+    'ITEM_',
+    'ITEM_APPROVAL_',
+    'LOAN_TYPE_',
+    'MACRO_',
+    'MARGIN_ADD_',
+    'METHOD_',
+    'MULTIPLE_',
+    'NETWORK_FAMILY_',
+    'NETWORK_TYPE_',
+    'NO_SECONDARY_',
+    'ONCHAIN_',
+    'OTHER_',
+    'OTHER_ACTIVITY_',
+    'OTHER_TRANSACTION_',
+    'PAYMENT_',
+    'PORTFOLIO_',
+    'POSITION_REFERENCE_',
+    'PRIME_CUSTODY_',
+    'PRODUCT_PERMISSION_',
+    'PROXY_',
+    'RATE_TYPE_',
+    'REMOVE_AUTHORIZED_',
+    'SHORT_',
+    'SHORT_BIASED_',
+    'SHORT_COLLATERAL_',
+    'SINGLE_COIN_',
+    'STAKE_ACCOUNT_',
+    'STAKE_AUTHORIZE_',
+    'STOP_',
+    'SWEEP_',
+    'TEAM_',
+    'TOTAL_',
+    'TRADE_',
+    'TRADING_',
+    'TRANSACTION_',
+    'TRANSACTION_IMPORT_',
+    'TRANSACTION_TYPE_',
+    'UNIFIED_TOTAL_',
+    'VAULT_',
+    'VOTE_',
+    'WALLET_TYPE_',
+    'WALLET_VISIBILITY_',
+    'WITHDRAWAL_',
+    'WITHDRAW_',
+];
+/**
+ * Detailed enum analysis for debugging and insights
+ */
+exports.ENUM_ANALYSIS = {
+    totalEnums: 43,
+    discoveredPrefixes: 77,
+    prefixPatterns: exports.GENERATED_ENUM_PREFIXES,
+    enumDetails: [
+        {
+            name: 'CoinbaseCustodyApiActivityType',
+            valueCount: 29,
+            file: 'coinbaseCustodyApiActivityType.ts',
+        },
+        {
+            name: 'CoinbaseCustodyApiAddressBookType',
+            valueCount: 3,
+            file: 'coinbaseCustodyApiAddressBookType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiAction',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiAction.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiActivityCategory',
+            valueCount: 7,
+            file: 'coinbasePublicRestApiActivityCategory.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiActivityLevel',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiActivityLevel.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiActivitySecondaryType',
+            valueCount: 7,
+            file: 'coinbasePublicRestApiActivitySecondaryType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiActivityStatus',
+            valueCount: 7,
+            file: 'coinbasePublicRestApiActivityStatus.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiActivityType',
+            valueCount: 42,
+            file: 'coinbasePublicRestApiActivityType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiAllocationSizeType',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiAllocationSizeType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiAllocationStatus',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiAllocationStatus.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiAssetChangeType',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiAssetChangeType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiBenchmark',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiBenchmark.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiDestinationType',
+            valueCount: 4,
+            file: 'coinbasePublicRestApiDestinationType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiFcmFuturesSweepStatus',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiFcmFuturesSweepStatus.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiFcmMarginCallState',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiFcmMarginCallState.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiFcmMarginCallType',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiFcmMarginCallType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiFcmPositionSide',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiFcmPositionSide.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiHierarchyType',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiHierarchyType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiInvoiceState',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiInvoiceState.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiInvoiceType',
+            valueCount: 6,
+            file: 'coinbasePublicRestApiInvoiceType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiLoanType',
+            valueCount: 6,
+            file: 'coinbasePublicRestApiLoanType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiMarginAddOnType',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiMarginAddOnType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiNetworkFamily',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiNetworkFamily.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiNetworkType',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiNetworkType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiOrderSide',
+            valueCount: 2,
+            file: 'coinbasePublicRestApiOrderSide.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiOrderStatus',
+            valueCount: 6,
+            file: 'coinbasePublicRestApiOrderStatus.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiOrderType',
+            valueCount: 7,
+            file: 'coinbasePublicRestApiOrderType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiPaymentMethodType',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiPaymentMethodType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiPortfolioBalanceType',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiPortfolioBalanceType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiPositionReferenceType',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiPositionReferenceType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiProductPermissions',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiProductPermissions.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiRateType',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiRateType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiSigningStatus',
+            valueCount: 2,
+            file: 'coinbasePublicRestApiSigningStatus.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiSortDirection',
+            valueCount: 2,
+            file: 'coinbasePublicRestApiSortDirection.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiTimeInForceType',
+            valueCount: 4,
+            file: 'coinbasePublicRestApiTimeInForceType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiTransactionStatus',
+            valueCount: 21,
+            file: 'coinbasePublicRestApiTransactionStatus.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiTransactionType',
+            valueCount: 33,
+            file: 'coinbasePublicRestApiTransactionType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiTransferLocationType',
+            valueCount: 6,
+            file: 'coinbasePublicRestApiTransferLocationType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiUserRole',
+            valueCount: 9,
+            file: 'coinbasePublicRestApiUserRole.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiVisibilityStatus',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiVisibilityStatus.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiWalletDepositInstructionType',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiWalletDepositInstructionType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiWalletType',
+            valueCount: 5,
+            file: 'coinbasePublicRestApiWalletType.ts',
+        },
+        {
+            name: 'CoinbasePublicRestApiWalletVisibility',
+            valueCount: 3,
+            file: 'coinbasePublicRestApiWalletVisibility.ts',
+        },
+    ],
+};

package/dist/paymentMethods/index.js

@@ -14,6 +14,7 @@ class PaymentMethodsService {
     constructor(client) {
         this.client = client;
     }
+    // TODO: rename me to remove Entity in a minor version change
     listEntityPaymentMethods(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.client.request({
@@ -26,7 +27,7 @@ class PaymentMethodsService {
     getPaymentMethod(request, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.client.request({
-                url: `entities/${request.entityId}/payment-methods`,
+                url: `entities/${request.entityId}/payment-methods/${request.paymentMethodId}`,
                 callOptions: options,
             });
             return response.data;

package/dist/shared/dynamicEnumValidation.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumRegistry = exports.DynamicEnumValidationError = void 0;
+exports.setDynamicValidationConfig = setDynamicValidationConfig;
+exports.getDynamicValidationConfig = getDynamicValidationConfig;
+exports.dynamicValidateRequest = dynamicValidateRequest;
+exports.getEnumInfo = getEnumInfo;
+/**
+ * Dynamic enum validation system that automatically discovers and validates
+ * enum fields in request objects without manual service-specific configuration.
+ *
+ * This approach is more scalable and maintainable than manual validation rules.
+ */
+const enumRegistry_1 = require("./enumRegistry");
+Object.defineProperty(exports, "enumRegistry", { enumerable: true, get: function () { return enumRegistry_1.enumRegistry; } });
+const enumValidationCore_1 = require("./enumValidationCore");
+Object.defineProperty(exports, "DynamicEnumValidationError", { enumerable: true, get: function () { return enumValidationCore_1.DynamicEnumValidationError; } });
+// Default configuration
+const defaultConfig = {
+    enabled: true,
+    strict: true,
+    autoNormalize: true,
+    logWarnings: true,
+};
+let currentConfig = Object.assign({}, defaultConfig);
+// Cache for request type analysis to improve performance
+const requestTypeCache = new Map();
+/**
+ * Set global configuration for dynamic enum validation
+ */
+function setDynamicValidationConfig(config) {
+    currentConfig = Object.assign(Object.assign({}, currentConfig), config);
+}
+/**
+ * Get current dynamic validation configuration
+ */
+function getDynamicValidationConfig() {
+    return Object.assign({}, currentConfig);
+}
+/**
+ * Analyze request structure to identify enum fields
+ */
+function analyzeRequestType(request, serviceName) {
+    // Use object structure and service name as cache key
+    const cacheKey = JSON.stringify({
+        structure: Object.keys(request || {})
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = typeof request[key];
+            return acc;
+        }, {}),
+        serviceName: serviceName || 'unknown',
+    });
+    // Return cached result if available
+    const cached = requestTypeCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const enumFields = [];
+    if (!request || typeof request !== 'object') {
+        return enumFields;
+    }
+    Object.entries(request).forEach(([fieldName, value]) => {
+        const fieldInfo = (0, enumValidationCore_1.analyzeField)(fieldName, value, serviceName);
+        if (fieldInfo) {
+            enumFields.push(fieldInfo);
+        }
+    });
+    // Cache the result
+    requestTypeCache.set(cacheKey, enumFields);
+    return enumFields;
+}
+/**
+ * Validate request object and normalize enum values
+ */
+function validateRequestEnums(request, config = currentConfig) {
+    const validatedRequest = Object.assign({}, request);
+    const errors = [];
+    if (!config.enabled) {
+        return { validatedRequest, errors };
+    }
+    const enumFields = analyzeRequestType(request, config.serviceName);
+    enumFields.forEach((fieldInfo) => {
+        const { fieldName, enumName, isArray } = fieldInfo;
+        const fieldValue = request[fieldName];
+        if (fieldValue === undefined || fieldValue === null) {
+            return;
+        }
+        try {
+            const enumObject = enumRegistry_1.enumRegistry.getEnum(enumName);
+            if (!enumObject) {
+                errors.push(`${fieldName}: Enum ${enumName} not found`);
+                return;
+            }
+            if (isArray && Array.isArray(fieldValue)) {
+                // Handle array values
+                const validatedArray = [];
+                for (const item of fieldValue) {
+                    if (typeof item === 'string') {
+                        const validation = (0, enumValidationCore_1.validateEnumValue)(item, enumObject, enumName, fieldName, config);
+                        if (validation.isValid && validation.normalizedValue) {
+                            validatedArray.push(validation.normalizedValue);
+                        }
+                        else if (validation.error) {
+                            if (config.strict) {
+                                throw new enumValidationCore_1.DynamicEnumValidationError(fieldName, item, enumName, Object.values(enumObject), Object.keys(enumObject));
+                            }
+                            else {
+                                if (config.logWarnings) {
+                                    console.warn(`[Prime SDK] Dynamic enum validation warning: ${validation.error}`);
+                                }
+                                validatedArray.push(item); // Keep original value
+                            }
+                        }
+                    }
+                }
+                validatedRequest[fieldName] = validatedArray;
+            }
+            else if (typeof fieldValue === 'string') {
+                // Handle single string values
+                const validation = (0, enumValidationCore_1.validateEnumValue)(fieldValue, enumObject, enumName, fieldName, config);
+                if (validation.isValid && validation.normalizedValue) {
+                    validatedRequest[fieldName] = validation.normalizedValue;
+                }
+                else if (validation.error) {
+                    if (config.strict) {
+                        throw new enumValidationCore_1.DynamicEnumValidationError(fieldName, fieldValue, enumName, Object.values(enumObject), Object.keys(enumObject));
+                    }
+                    else {
+                        if (config.logWarnings) {
+                            console.warn(`[Prime SDK] Dynamic enum validation warning: ${validation.error}`);
+                        }
+                        // Keep original value in non-strict mode
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof enumValidationCore_1.DynamicEnumValidationError) {
+                throw error; // Re-throw enum validation errors
+            }
+            errors.push(`${fieldName}: Unexpected validation error: ${error}`);
+        }
+    });
+    return { validatedRequest, errors };
+}
+/**
+ * Main API: Validate and normalize request with type-safe generics
+ */
+function dynamicValidateRequest(request, config) {
+    const validationConfig = config
+        ? Object.assign(Object.assign({}, currentConfig), config) : currentConfig;
+    const result = validateRequestEnums(request, validationConfig);
+    if (result.errors.length > 0) {
+        throw new enumValidationCore_1.DynamicEnumValidationError('request', 'multiple fields', 'various', [], result.errors);
+    }
+    return result.validatedRequest;
+}
+/**
+ * Get information about discovered enums
+ */
+function getEnumInfo() {
+    const stats = enumRegistry_1.enumRegistry.getStats();
+    return {
+        totalEnums: stats.totalEnums,
+        enumNames: enumRegistry_1.enumRegistry.getAllEnumNames(),
+        enumDetails: enumRegistry_1.enumRegistry.getEnumDetails(),
+    };
+}