インテグレーション実装・AWS連携

import { MarketplaceMetering } from 'aws-sdk';

interface CustomerInfo {
  customerId: string;
  productCode: string;
  awsAccountId: string;
}

const marketplace = new MarketplaceMetering({
  region: 'us-east-1'
});

async function resolveCustomer(
  registrationToken: string
): Promise<CustomerInfo> {
  const params: MarketplaceMetering.ResolveCustomerRequest = {
    RegistrationToken: registrationToken
  };
  
  try {
    const result = await marketplace.resolveCustomer(params).promise();
    
    if (!result.CustomerIdentifier || !result.ProductCode) {
      throw new Error('Invalid response from ResolveCustomer API');
    }
    
    return {
      customerId: result.CustomerIdentifier,
      productCode: result.ProductCode,
      awsAccountId: result.CustomerAWSAccountId || ''
    };
  } catch (error) {
    console.error('ResolveCustomer failed:', error);
    throw error;
  }
}

import boto3
from typing import Dict

marketplace = boto3.client('meteringmarketplace', region_name='us-east-1')

def resolve_customer(registration_token: str) -> Dict[str, str]:
    """
    登録トークンを検証し、顧客情報を取得
    
    Args:
        registration_token: AWS Marketplaceの登録トークン
        
    Returns:
        顧客情報の辞書
        
    Raises:
        Exception: API呼び出しが失敗した場合
    """
    try:
        response = marketplace.resolve_customer(
            RegistrationToken=registration_token
        )
        
        print('Customer resolved successfully')
        print(f"Customer ID: {response['CustomerIdentifier']}")
        print(f"Product Code: {response['ProductCode']}")
        print(f"AWS Account ID: {response.get('CustomerAWSAccountId', 'N/A')}")
        
        return {
            'customer_id': response['CustomerIdentifier'],
            'product_code': response['ProductCode'],
            'aws_account_id': response.get('CustomerAWSAccountId', '')
        }
    except Exception as e:
        print(f'ResolveCustomer failed: {str(e)}')
        
        error_code = e.response.get('Error', {}).get('Code', '')
        if error_code == 'InvalidTokenException':
            raise Exception('Invalid registration token')
        elif error_code == 'ExpiredTokenException':
            raise Exception('Registration token has expired')
        
        raise

# 使用例
customer = resolve_customer('eyJ0eXAiOiJKV1QiLCJhbGc...')
print('Customer:', customer)

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 3600 }); // 1時間キャッシュ

async function getCachedEntitlements(customerId) {
  const cacheKey = `entitlements:${customerId}`;
  
  let entitlements = cache.get(cacheKey);
  
  if (!entitlements) {
    entitlements = await getEntitlements(customerId);
    cache.set(cacheKey, entitlements);
    console.log('Entitlements cached for:', customerId);
  } else {
    console.log('Entitlements retrieved from cache');
  }
  
  return entitlements;
}

function invalidateEntitlementsCache(customerId) {
  const cacheKey = `entitlements:${customerId}`;
  cache.del(cacheKey);
  console.log('Cache invalidated for:', customerId);
}

function requireEntitlement(dimension) {
  return async (req, res, next) => {
    const customerId = req.headers['x-customer-id'];
    
    if (!customerId) {
      return res.status(401).json({ error: 'Customer ID required' });
    }
    
    try {
      const hasAccess = await validateAccess(customerId, dimension);
      
      if (!hasAccess) {
        return res.status(403).json({
          error: 'Access denied',
          message: `This feature requires ${dimension} entitlement`
        });
      }
      
      req.entitlements = await getCachedEntitlements(customerId);
      next();
    } catch (error) {
      console.error('Entitlement check failed:', error);
      return res.status(500).json({ error: 'Internal server error' });
    }
  };
}

// 使用例
app.get('/api/pro-feature',
  requireEntitlement('ProFeatures'),
  (req, res) => {
    res.json({ message: 'Pro feature accessed' });
  }
);