npm - @fluentcommerce/fc-connect-sdk - Versions diffs - 0.1.53 → 0.1.55 - Mend

@fluentcommerce/fc-connect-sdk 0.1.53 → 0.1.55

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (495) hide show

package/docs/04-REFERENCE/resolver-signature/modules/resolver-signature-05-sdk-resolvers.md CHANGED Viewed

@@ -1,531 +1,531 @@
-# Module 5: SDK Resolvers
-**Level:** Intermediate
-**Estimated Time:** 15 minutes
-## Overview
-This module explains how the SDK's built-in resolvers (the `sdk.*` namespace) use the same 4-parameter signature as your custom resolvers. Understanding this helps you extend SDK resolvers and maintain consistency.
-## Learning Objectives
-By the end of this module, you will:
-- ✅ Understand how SDK resolvers follow the 4-parameter signature
-- ✅ Know which parameters SDK resolvers typically use
-- ✅ Learn how to extend or wrap SDK resolvers
-- ✅ Recognize the consistency pattern across all resolvers
-## SDK Resolvers Overview
-All SDK resolvers use the standard 4-parameter signature, even when they only need one or two parameters:
-```typescript
-// SDK resolver implementation
-'sdk.parseFloat': (value, sourceData, config, helpers) => {
-  return helpers.parseFloatSafe(value, 0);
-}
-// Your custom resolver
-'custom.parseFloat': (value, sourceData, config, helpers) => {
-  return helpers.parseFloatSafe(value, 0);
-}
-// Identical signature = consistent behavior
-```
-## Available SDK Resolvers
-The SDK provides 16 built-in resolvers (17 including aliases) organized by category:
-> **Note:** `sdk.number` is an alias for `sdk.parseFloat`. The sections below list 16 unique functional resolvers.
-### String Transformations
-```typescript
-// All follow 4-parameter signature
-'sdk.uppercase': (value, sourceData, config, helpers) => {
-  return String(value).toUpperCase();
-}
-'sdk.lowercase': (value, sourceData, config, helpers) => {
-  return String(value).toLowerCase();
-}
-'sdk.trim': (value, sourceData, config, helpers) => {
-  return String(value).trim();
-}
-'sdk.toString': (value, sourceData, config, helpers) => {
-  return String(value);
-}
-```
-### Number Transformations
-```typescript
-'sdk.parseInt': (value, sourceData, config, helpers) => {
-  return helpers.parseIntSafe(value, 0);
-}
-'sdk.parseFloat': (value, sourceData, config, helpers) => {
-  return helpers.parseFloatSafe(value, 0);
-}
-'sdk.number': (value, sourceData, config, helpers) => {
-  return helpers.parseFloatSafe(value, 0);
-}
-```
-### Date Transformations
-```typescript
-'sdk.formatDate': (value, sourceData, config, helpers) => {
-  const format = config?.dateFormat || 'YYYY-MM-DD';
-  return helpers.formatDate(value, format);
-}
-'sdk.formatDateShort': (value, sourceData, config, helpers) => {
-  return helpers.formatDateShort(value);
-}
-'sdk.parseDate': (value, sourceData, config, helpers) => {
-  return helpers.parseDate(value);
-}
-```
-### Type Conversions
-```typescript
-'sdk.boolean': (value, sourceData, config, helpers) => {
-  if (typeof value === 'boolean') return value;
-  const str = String(value).toLowerCase();
-  return str === 'true' || str === '1' || str === 'yes';
-}
-'sdk.parseJson': (value, sourceData, config, helpers) => {
-  return helpers.safeJsonParse(value, null);
-}
-'sdk.toJson': (value, sourceData, config, helpers) => {
-  return JSON.stringify(value);
-}
-```
-### Utility Resolvers
-```typescript
-'sdk.identity': (value, sourceData, config, helpers) => {
-  return value;  // Pass-through
-}
-'sdk.coalesce': (value, sourceData, config, helpers) => {
-  return helpers.coalesce(value);
-}
-'sdk.default': (value, sourceData, config, helpers) => {
-  // Default value logic is handled by UniversalMapper
-  // This resolver just returns the value as-is
-  // The actual defaultValue is applied before resolvers run
-  return value;
-}
-```
-## Why SDK Resolvers Use All 4 Parameters
-Even though most SDK resolvers only use `value` and `helpers`, they include all 4 parameters for:
-### 1. Consistency
-```typescript
-// All resolvers have the same signature
-const allResolvers = {
-  // SDK resolvers
-  'sdk.parseFloat': (value, sourceData, config, helpers) => { ... },
-  'sdk.formatDate': (value, sourceData, config, helpers) => { ... },
-  // Custom resolvers
-  'custom.transform': (value, sourceData, config, helpers) => { ... },
-  // No special cases, no exceptions
-};
-```
-### 2. Future Extensibility
-SDK resolvers can evolve to use more parameters without breaking changes:
-```typescript
-// Today: Simple implementation
-'sdk.formatDate': (value, sourceData, config, helpers) => {
-  return helpers.formatDate(value, 'YYYY-MM-DD');
-}
-// Tomorrow: Configurable without breaking change
-'sdk.formatDate': (value, sourceData, config, helpers) => {
-  const format = config?.dateFormat || 'YYYY-MM-DD';
-  return helpers.formatDate(value, format);
-}
-// Your code still works!
-```
-### 3. Testing Uniformity
-All resolvers can be tested with the same test utilities:
-```typescript
-// Generic resolver tester works for SDK and custom resolvers
-function testResolver(resolver, value, sourceData, config, helpers) {
-  return resolver(value, sourceData, config, helpers);
-}
-// Test SDK resolver
-testResolver(sdkResolvers['sdk.parseFloat'], '19.99', {}, {}, helpers);
-// Test custom resolver
-testResolver(customResolvers['custom.transform'], 'test', {}, {}, helpers);
-```
-## Extending SDK Resolvers
-You can wrap or extend SDK resolvers while maintaining the signature:
-### Wrapping with Additional Logic
-```typescript
-'custom.parseFloatWithLogging': (value, sourceData, config, helpers) => {
-  // Call SDK resolver
-  const sdkResolver = getSdkResolver('sdk.parseFloat');
-  const result = sdkResolver(value, sourceData, config, helpers);
-  // Add custom logic
-  helpers.log.debug(`Parsed ${value} to ${result}`);
-  return result;
-}
-```
-### Adding Configuration
-```typescript
-'custom.parseFloatWithDefault': (value, sourceData, config, helpers) => {
-  // Use config to override default
-  const defaultValue = config?.defaultFloat || 0;
-  // Enhanced version of SDK resolver
-  const parsed = helpers.parseFloatSafe(value, defaultValue);
-  return parsed;
-}
-```
-### Combining Multiple SDK Resolvers
-```typescript
-'custom.formatAndTrim': (value, sourceData, config, helpers) => {
-  // Chain SDK resolver functionality
-  const trimmed = String(value).trim();
-  const upper = trimmed.toUpperCase();
-  return upper;
-}
-```
-## Accessing SDK Resolvers Programmatically
-The SDK provides utilities to access resolvers:
-```typescript
-import { getSdkResolver, isSdkResolver, sdkResolvers } from '@fluentcommerce/fc-connect-sdk';
-// Get a specific SDK resolver
-const parseFloat = getSdkResolver('sdk.parseFloat');
-const result = parseFloat('19.99', {}, {}, helpers);
-// Check if a resolver name is an SDK resolver
-if (isSdkResolver('sdk.parseFloat')) {
-  console.log('This is an SDK resolver');
-}
-// Access all SDK resolvers
-console.log(Object.keys(sdkResolvers));
-// Output: ['sdk.uppercase', 'sdk.lowercase', 'sdk.parseInt', ...]
-```
-## Real-World Usage Patterns
-### Using SDK Resolvers in Mappings
-```json
-{
-  "fields": {
-    "sku": {
-      "source": "product_id",
-      "resolver": "sdk.uppercase"
-    },
-    "quantity": {
-      "source": "qty",
-      "resolver": "sdk.parseInt"
-    },
-    "price": {
-      "source": "unit_price",
-      "resolver": "sdk.parseFloat"
-    },
-    "expectedOn": {
-      "source": "delivery_date",
-      "resolver": "sdk.formatDate"
-    }
-  }
-}
-```
-### Mixing SDK and Custom Resolvers
-```typescript
-const customResolvers = {
-  // Custom resolver
-  'custom.formatSKU': (value, sourceData, config, helpers) => {
-    // Use SDK resolver helper
-    const upper = String(value).toUpperCase();
-    const prefix = config.skuPrefix || 'SKU';
-    return `${prefix}-${upper}`;
-  }
-};
-const mapper = new UniversalMapper(
-  {
-    fields: {
-      // SDK resolver
-      sku: { source: 'id', resolver: 'sdk.uppercase' },
-      // Custom resolver
-      formattedSKU: { source: 'id', resolver: 'custom.formatSKU' },
-      // SDK resolver
-      quantity: { source: 'qty', resolver: 'sdk.parseInt' }
-    }
-  },
-  {
-    customResolvers,
-    context: { skuPrefix: 'PROD' }
-  }
-);
-```
-## SDK Resolver Implementation Example
-Here's how SDK resolvers are actually implemented:
-```typescript
-// In the SDK: src/services/resolvers/sdk-resolvers.ts
-export const sdkResolvers: Record<string, FieldResolverFunction> = {
-  'sdk.uppercase': (value, sourceData, config, helpers) => {
-    return String(value).toUpperCase();
-  },
-  'sdk.lowercase': (value, sourceData, config, helpers) => {
-    return String(value).toLowerCase();
-  },
-  'sdk.trim': (value, sourceData, config, helpers) => {
-    return String(value).trim();
-  },
-  'sdk.parseInt': (value, sourceData, config, helpers) => {
-    return helpers.parseIntSafe(value, 0);
-  },
-  'sdk.parseFloat': (value, sourceData, config, helpers) => {
-    return helpers.parseFloatSafe(value, 0);
-  },
-  'sdk.number': (value, sourceData, config, helpers) => {
-    return helpers.parseFloatSafe(value, 0);
-  },
-  'sdk.formatDate': (value, sourceData, config, helpers) => {
-    if (!value) return value;
-    return helpers.formatDate(value);
-  },
-  'sdk.formatDateShort': (value, sourceData, config, helpers) => {
-    if (!value) return value;
-    const date = new Date(value);
-    if (isNaN(date.getTime())) return value;
-    return date.toISOString().split('T')[0];
-  },
-  'sdk.parseDate': (value, sourceData, config, helpers) => {
-    return helpers.parseDate(value);
-  },
-  'sdk.boolean': (value, sourceData, config, helpers) => {
-    if (value === null || value === undefined) {
-      return false;
-    }
-    const checkValue = typeof value === 'string' ? value.toLowerCase() : value;
-    return ['true', '1', 'yes', 'y', true, 1].includes(checkValue);
-  },
-  'sdk.parseJson': (value, sourceData, config, helpers) => {
-    if (typeof value === 'string') {
-      return helpers.safeJsonParse(value, value);
-    }
-    return value;
-  },
-  'sdk.toJson': (value, sourceData, config, helpers) => {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return value;
-    }
-  },
-  'sdk.identity': (value, sourceData, config, helpers) => {
-    return value;
-  },
-  'sdk.toString': (value, sourceData, config, helpers) => {
-    if (value === null || value === undefined) return '';
-    return String(value);
-  },
-  'sdk.coalesce': (value, sourceData, config, helpers) => {
-    return helpers.coalesce(value);
-  },
-  'sdk.default': (value, sourceData, config, helpers) => {
-    // Default value logic is handled by UniversalMapper.mapField()
-    // which applies config.defaultValue before calling resolvers
-    // This resolver exists for backward compatibility
-    return value;
-  }
-};
-// Utility to get SDK resolver
-export function getSdkResolver(name: string): FieldResolverFunction | undefined {
-  return sdkResolvers[name];
-}
-// Utility to check if resolver is SDK resolver
-export function isSdkResolver(name: string): boolean {
-  return name.startsWith('sdk.') && name in sdkResolvers;
-}
-```
-## Complete SDK Resolver List
-| Resolver | Parameters Used | Purpose |
-|----------|----------------|---------|
-| `sdk.uppercase` | value, helpers | Convert to uppercase |
-| `sdk.lowercase` | value, helpers | Convert to lowercase |
-| `sdk.trim` | value, helpers | Trim whitespace |
-| `sdk.toString` | value, helpers | Convert to string |
-| `sdk.parseInt` | value, helpers | Parse integer safely |
-| `sdk.parseFloat` | value, helpers | Parse float safely |
-| `sdk.number` | value, helpers | Parse number (alias for parseFloat) |
-| `sdk.formatDate` | value, helpers | Format date to ISO8601 |
-| `sdk.formatDateShort` | value, helpers | Format date (YYYY-MM-DD) |
-| `sdk.parseDate` | value, helpers | Parse date string |
-| `sdk.boolean` | value, helpers | Convert to boolean |
-| `sdk.parseJson` | value, helpers | Parse JSON safely |
-| `sdk.toJson` | value, helpers | Convert to JSON string |
-| `sdk.identity` | value | Pass-through (no transformation) |
-| `sdk.coalesce` | value, helpers | Return first non-null value |
-| `sdk.default` | value | No-op (defaultValue handled by mapper) |
-## Creating Your Own SDK-Style Resolvers
-You can create custom resolvers that follow SDK conventions:
-```typescript
-// Create a library of reusable resolvers
-export const myResolvers = {
-  'my.formatPhone': (value, sourceData, config, helpers) => {
-    const digits = String(value).replace(/\D/g, '');
-    if (digits.length !== 10) return null;
-    return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`;
-  },
-  'my.validateEmail': (value, sourceData, config, helpers) => {
-    if (!helpers.isValidEmail(value)) {
-      helpers.log.warn(`Invalid email: ${value}`);
-      return null;
-    }
-    return value;
-  },
-  'my.formatCurrency': (value, sourceData, config, helpers) => {
-    const currency = config?.currency || 'USD';
-    const locale = config?.locale || 'en-US';
-    return helpers.formatCurrency(value, currency, locale);
-  }
-};
-// Use alongside SDK resolvers
-const mapper = new UniversalMapper(mapping, {
-  customResolvers: {
-    ...sdkResolvers,  // Include SDK resolvers
-    ...myResolvers    // Add your resolvers
-  }
-});
-```
-## Key Takeaways
-- 🎯 **SDK resolvers use 4 parameters** - Same signature as custom resolvers
-- 🎯 **Consistency everywhere** - No exceptions, no special cases
-- 🎯 **Extend easily** - Wrap SDK resolvers with custom logic
-- 🎯 **Access programmatically** - Use `getSdkResolver()` and `isSdkResolver()`
-- 🎯 **Mix and match** - Combine SDK and custom resolvers freely
-## Practice Exercise
-Create a custom resolver that wraps an SDK resolver and adds validation:
-**Requirements:**
-- Call `sdk.parseFloat` to parse value
-- Validate result is within range (from config)
-- Log warning if out of range
-- Return null if invalid, result if valid
-<details>
-<summary>Show Solution</summary>
-```typescript
-'custom.parseFloatWithRange': (value, sourceData, config, helpers) => {
-  // Use SDK resolver to parse
-  const sdkParseFloat = getSdkResolver('sdk.parseFloat');
-  const parsed = sdkParseFloat(value, sourceData, config, helpers);
-  // Validate range from config
-  const min = config?.minValue ?? -Infinity;
-  const max = config?.maxValue ?? Infinity;
-  if (parsed < min || parsed > max) {
-    helpers.log.warn(
-      `Value ${parsed} out of range [${min}, ${max}]`
-    );
-    return null;
-  }
-  return parsed;
-}
-// Usage
-const mapper = new UniversalMapper(mapping, {
-  customResolvers: {
-    'custom.parseFloatWithRange': parseFloatWithRange
-  },
-  context: {
-    minValue: 0,
-    maxValue: 10000
-  }
-});
-```
-</details>
-## Next Steps
-Continue to [Module 6: Migration Guide](./resolver-signature-06-migration-guide.md) to learn how to migrate from old 3-parameter resolvers to the new 4-parameter signature.
+# Module 5: SDK Resolvers
+**Level:** Intermediate
+**Estimated Time:** 15 minutes
+## Overview
+This module explains how the SDK's built-in resolvers (the `sdk.*` namespace) use the same 4-parameter signature as your custom resolvers. Understanding this helps you extend SDK resolvers and maintain consistency.
+## Learning Objectives
+By the end of this module, you will:
+- ✅ Understand how SDK resolvers follow the 4-parameter signature
+- ✅ Know which parameters SDK resolvers typically use
+- ✅ Learn how to extend or wrap SDK resolvers
+- ✅ Recognize the consistency pattern across all resolvers
+## SDK Resolvers Overview
+All SDK resolvers use the standard 4-parameter signature, even when they only need one or two parameters:
+```typescript
+// SDK resolver implementation
+'sdk.parseFloat': (value, sourceData, config, helpers) => {
+  return helpers.parseFloatSafe(value, 0);
+}
+// Your custom resolver
+'custom.parseFloat': (value, sourceData, config, helpers) => {
+  return helpers.parseFloatSafe(value, 0);
+}
+// Identical signature = consistent behavior
+```
+## Available SDK Resolvers
+The SDK provides 16 built-in resolvers (17 including aliases) organized by category:
+> **Note:** `sdk.number` is an alias for `sdk.parseFloat`. The sections below list 16 unique functional resolvers.
+### String Transformations
+```typescript
+// All follow 4-parameter signature
+'sdk.uppercase': (value, sourceData, config, helpers) => {
+  return String(value).toUpperCase();
+}
+'sdk.lowercase': (value, sourceData, config, helpers) => {
+  return String(value).toLowerCase();
+}
+'sdk.trim': (value, sourceData, config, helpers) => {
+  return String(value).trim();
+}
+'sdk.toString': (value, sourceData, config, helpers) => {
+  return String(value);
+}
+```
+### Number Transformations
+```typescript
+'sdk.parseInt': (value, sourceData, config, helpers) => {
+  return helpers.parseIntSafe(value, 0);
+}
+'sdk.parseFloat': (value, sourceData, config, helpers) => {
+  return helpers.parseFloatSafe(value, 0);
+}
+'sdk.number': (value, sourceData, config, helpers) => {
+  return helpers.parseFloatSafe(value, 0);
+}
+```
+### Date Transformations
+```typescript
+'sdk.formatDate': (value, sourceData, config, helpers) => {
+  const format = config?.dateFormat || 'YYYY-MM-DD';
+  return helpers.formatDate(value, format);
+}
+'sdk.formatDateShort': (value, sourceData, config, helpers) => {
+  return helpers.formatDateShort(value);
+}
+'sdk.parseDate': (value, sourceData, config, helpers) => {
+  return helpers.parseDate(value);
+}
+```
+### Type Conversions
+```typescript
+'sdk.boolean': (value, sourceData, config, helpers) => {
+  if (typeof value === 'boolean') return value;
+  const str = String(value).toLowerCase();
+  return str === 'true' || str === '1' || str === 'yes';
+}
+'sdk.parseJson': (value, sourceData, config, helpers) => {
+  return helpers.safeJsonParse(value, null);
+}
+'sdk.toJson': (value, sourceData, config, helpers) => {
+  return JSON.stringify(value);
+}
+```
+### Utility Resolvers
+```typescript
+'sdk.identity': (value, sourceData, config, helpers) => {
+  return value;  // Pass-through
+}
+'sdk.coalesce': (value, sourceData, config, helpers) => {
+  return helpers.coalesce(value);
+}
+'sdk.default': (value, sourceData, config, helpers) => {
+  // Default value logic is handled by UniversalMapper
+  // This resolver just returns the value as-is
+  // The actual defaultValue is applied before resolvers run
+  return value;
+}
+```
+## Why SDK Resolvers Use All 4 Parameters
+Even though most SDK resolvers only use `value` and `helpers`, they include all 4 parameters for:
+### 1. Consistency
+```typescript
+// All resolvers have the same signature
+const allResolvers = {
+  // SDK resolvers
+  'sdk.parseFloat': (value, sourceData, config, helpers) => { ... },
+  'sdk.formatDate': (value, sourceData, config, helpers) => { ... },
+  // Custom resolvers
+  'custom.transform': (value, sourceData, config, helpers) => { ... },
+  // No special cases, no exceptions
+};
+```
+### 2. Future Extensibility
+SDK resolvers can evolve to use more parameters without breaking changes:
+```typescript
+// Today: Simple implementation
+'sdk.formatDate': (value, sourceData, config, helpers) => {
+  return helpers.formatDate(value, 'YYYY-MM-DD');
+}
+// Tomorrow: Configurable without breaking change
+'sdk.formatDate': (value, sourceData, config, helpers) => {
+  const format = config?.dateFormat || 'YYYY-MM-DD';
+  return helpers.formatDate(value, format);
+}
+// Your code still works!
+```
+### 3. Testing Uniformity
+All resolvers can be tested with the same test utilities:
+```typescript
+// Generic resolver tester works for SDK and custom resolvers
+function testResolver(resolver, value, sourceData, config, helpers) {
+  return resolver(value, sourceData, config, helpers);
+}
+// Test SDK resolver
+testResolver(sdkResolvers['sdk.parseFloat'], '19.99', {}, {}, helpers);
+// Test custom resolver
+testResolver(customResolvers['custom.transform'], 'test', {}, {}, helpers);
+```
+## Extending SDK Resolvers
+You can wrap or extend SDK resolvers while maintaining the signature:
+### Wrapping with Additional Logic
+```typescript
+'custom.parseFloatWithLogging': (value, sourceData, config, helpers) => {
+  // Call SDK resolver
+  const sdkResolver = getSdkResolver('sdk.parseFloat');
+  const result = sdkResolver(value, sourceData, config, helpers);
+  // Add custom logic
+  helpers.log.debug(`Parsed ${value} to ${result}`);
+  return result;
+}
+```
+### Adding Configuration
+```typescript
+'custom.parseFloatWithDefault': (value, sourceData, config, helpers) => {
+  // Use config to override default
+  const defaultValue = config?.defaultFloat || 0;
+  // Enhanced version of SDK resolver
+  const parsed = helpers.parseFloatSafe(value, defaultValue);
+  return parsed;
+}
+```
+### Combining Multiple SDK Resolvers
+```typescript
+'custom.formatAndTrim': (value, sourceData, config, helpers) => {
+  // Chain SDK resolver functionality
+  const trimmed = String(value).trim();
+  const upper = trimmed.toUpperCase();
+  return upper;
+}
+```
+## Accessing SDK Resolvers Programmatically
+The SDK provides utilities to access resolvers:
+```typescript
+import { getSdkResolver, isSdkResolver, sdkResolvers } from '@fluentcommerce/fc-connect-sdk';
+// Get a specific SDK resolver
+const parseFloat = getSdkResolver('sdk.parseFloat');
+const result = parseFloat('19.99', {}, {}, helpers);
+// Check if a resolver name is an SDK resolver
+if (isSdkResolver('sdk.parseFloat')) {
+  console.log('This is an SDK resolver');
+}
+// Access all SDK resolvers
+console.log(Object.keys(sdkResolvers));
+// Output: ['sdk.uppercase', 'sdk.lowercase', 'sdk.parseInt', ...]
+```
+## Real-World Usage Patterns
+### Using SDK Resolvers in Mappings
+```json
+{
+  "fields": {
+    "sku": {
+      "source": "product_id",
+      "resolver": "sdk.uppercase"
+    },
+    "quantity": {
+      "source": "qty",
+      "resolver": "sdk.parseInt"
+    },
+    "price": {
+      "source": "unit_price",
+      "resolver": "sdk.parseFloat"
+    },
+    "expectedOn": {
+      "source": "delivery_date",
+      "resolver": "sdk.formatDate"
+    }
+  }
+}
+```
+### Mixing SDK and Custom Resolvers
+```typescript
+const customResolvers = {
+  // Custom resolver
+  'custom.formatSKU': (value, sourceData, config, helpers) => {
+    // Use SDK resolver helper
+    const upper = String(value).toUpperCase();
+    const prefix = config.skuPrefix || 'SKU';
+    return `${prefix}-${upper}`;
+  }
+};
+const mapper = new UniversalMapper(
+  {
+    fields: {
+      // SDK resolver
+      sku: { source: 'id', resolver: 'sdk.uppercase' },
+      // Custom resolver
+      formattedSKU: { source: 'id', resolver: 'custom.formatSKU' },
+      // SDK resolver
+      quantity: { source: 'qty', resolver: 'sdk.parseInt' }
+    }
+  },
+  {
+    customResolvers,
+    context: { skuPrefix: 'PROD' }
+  }
+);
+```
+## SDK Resolver Implementation Example
+Here's how SDK resolvers are actually implemented:
+```typescript
+// In the SDK: src/services/resolvers/sdk-resolvers.ts
+export const sdkResolvers: Record<string, FieldResolverFunction> = {
+  'sdk.uppercase': (value, sourceData, config, helpers) => {
+    return String(value).toUpperCase();
+  },
+  'sdk.lowercase': (value, sourceData, config, helpers) => {
+    return String(value).toLowerCase();
+  },
+  'sdk.trim': (value, sourceData, config, helpers) => {
+    return String(value).trim();
+  },
+  'sdk.parseInt': (value, sourceData, config, helpers) => {
+    return helpers.parseIntSafe(value, 0);
+  },
+  'sdk.parseFloat': (value, sourceData, config, helpers) => {
+    return helpers.parseFloatSafe(value, 0);
+  },
+  'sdk.number': (value, sourceData, config, helpers) => {
+    return helpers.parseFloatSafe(value, 0);
+  },
+  'sdk.formatDate': (value, sourceData, config, helpers) => {
+    if (!value) return value;
+    return helpers.formatDate(value);
+  },
+  'sdk.formatDateShort': (value, sourceData, config, helpers) => {
+    if (!value) return value;
+    const date = new Date(value);
+    if (isNaN(date.getTime())) return value;
+    return date.toISOString().split('T')[0];
+  },
+  'sdk.parseDate': (value, sourceData, config, helpers) => {
+    return helpers.parseDate(value);
+  },
+  'sdk.boolean': (value, sourceData, config, helpers) => {
+    if (value === null || value === undefined) {
+      return false;
+    }
+    const checkValue = typeof value === 'string' ? value.toLowerCase() : value;
+    return ['true', '1', 'yes', 'y', true, 1].includes(checkValue);
+  },
+  'sdk.parseJson': (value, sourceData, config, helpers) => {
+    if (typeof value === 'string') {
+      return helpers.safeJsonParse(value, value);
+    }
+    return value;
+  },
+  'sdk.toJson': (value, sourceData, config, helpers) => {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return value;
+    }
+  },
+  'sdk.identity': (value, sourceData, config, helpers) => {
+    return value;
+  },
+  'sdk.toString': (value, sourceData, config, helpers) => {
+    if (value === null || value === undefined) return '';
+    return String(value);
+  },
+  'sdk.coalesce': (value, sourceData, config, helpers) => {
+    return helpers.coalesce(value);
+  },
+  'sdk.default': (value, sourceData, config, helpers) => {
+    // Default value logic is handled by UniversalMapper.mapField()
+    // which applies config.defaultValue before calling resolvers
+    // This resolver exists for backward compatibility
+    return value;
+  }
+};
+// Utility to get SDK resolver
+export function getSdkResolver(name: string): FieldResolverFunction | undefined {
+  return sdkResolvers[name];
+}
+// Utility to check if resolver is SDK resolver
+export function isSdkResolver(name: string): boolean {
+  return name.startsWith('sdk.') && name in sdkResolvers;
+}
+```
+## Complete SDK Resolver List
+| Resolver | Parameters Used | Purpose |
+|----------|----------------|---------|
+| `sdk.uppercase` | value, helpers | Convert to uppercase |
+| `sdk.lowercase` | value, helpers | Convert to lowercase |
+| `sdk.trim` | value, helpers | Trim whitespace |
+| `sdk.toString` | value, helpers | Convert to string |
+| `sdk.parseInt` | value, helpers | Parse integer safely |
+| `sdk.parseFloat` | value, helpers | Parse float safely |
+| `sdk.number` | value, helpers | Parse number (alias for parseFloat) |
+| `sdk.formatDate` | value, helpers | Format date to ISO8601 |
+| `sdk.formatDateShort` | value, helpers | Format date (YYYY-MM-DD) |
+| `sdk.parseDate` | value, helpers | Parse date string |
+| `sdk.boolean` | value, helpers | Convert to boolean |
+| `sdk.parseJson` | value, helpers | Parse JSON safely |
+| `sdk.toJson` | value, helpers | Convert to JSON string |
+| `sdk.identity` | value | Pass-through (no transformation) |
+| `sdk.coalesce` | value, helpers | Return first non-null value |
+| `sdk.default` | value | No-op (defaultValue handled by mapper) |
+## Creating Your Own SDK-Style Resolvers
+You can create custom resolvers that follow SDK conventions:
+```typescript
+// Create a library of reusable resolvers
+export const myResolvers = {
+  'my.formatPhone': (value, sourceData, config, helpers) => {
+    const digits = String(value).replace(/\D/g, '');
+    if (digits.length !== 10) return null;
+    return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`;
+  },
+  'my.validateEmail': (value, sourceData, config, helpers) => {
+    if (!helpers.isValidEmail(value)) {
+      helpers.log.warn(`Invalid email: ${value}`);
+      return null;
+    }
+    return value;
+  },
+  'my.formatCurrency': (value, sourceData, config, helpers) => {
+    const currency = config?.currency || 'USD';
+    const locale = config?.locale || 'en-US';
+    return helpers.formatCurrency(value, currency, locale);
+  }
+};
+// Use alongside SDK resolvers
+const mapper = new UniversalMapper(mapping, {
+  customResolvers: {
+    ...sdkResolvers,  // Include SDK resolvers
+    ...myResolvers    // Add your resolvers
+  }
+});
+```
+## Key Takeaways
+- 🎯 **SDK resolvers use 4 parameters** - Same signature as custom resolvers
+- 🎯 **Consistency everywhere** - No exceptions, no special cases
+- 🎯 **Extend easily** - Wrap SDK resolvers with custom logic
+- 🎯 **Access programmatically** - Use `getSdkResolver()` and `isSdkResolver()`
+- 🎯 **Mix and match** - Combine SDK and custom resolvers freely
+## Practice Exercise
+Create a custom resolver that wraps an SDK resolver and adds validation:
+**Requirements:**
+- Call `sdk.parseFloat` to parse value
+- Validate result is within range (from config)
+- Log warning if out of range
+- Return null if invalid, result if valid
+<details>
+<summary>Show Solution</summary>
+```typescript
+'custom.parseFloatWithRange': (value, sourceData, config, helpers) => {
+  // Use SDK resolver to parse
+  const sdkParseFloat = getSdkResolver('sdk.parseFloat');
+  const parsed = sdkParseFloat(value, sourceData, config, helpers);
+  // Validate range from config
+  const min = config?.minValue ?? -Infinity;
+  const max = config?.maxValue ?? Infinity;
+  if (parsed < min || parsed > max) {
+    helpers.log.warn(
+      `Value ${parsed} out of range [${min}, ${max}]`
+    );
+    return null;
+  }
+  return parsed;
+}
+// Usage
+const mapper = new UniversalMapper(mapping, {
+  customResolvers: {
+    'custom.parseFloatWithRange': parseFloatWithRange
+  },
+  context: {
+    minValue: 0,
+    maxValue: 10000
+  }
+});
+```
+</details>
+## Next Steps
+Continue to [Module 6: Migration Guide](./resolver-signature-06-migration-guide.md) to learn how to migrate from old 3-parameter resolvers to the new 4-parameter signature.