TMForum Product Catalog API Implementation

import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, PutCommand, GetCommand } from '@aws-sdk/lib-dynamodb';

interface ProductOffering {
  id: string;
  href: string;
  name: string;
  description: string;
  version: string;
  lifecycleStatus: 'In design' | 'In test' | 'Active' | 'Launched' | 'Retired' | 'Obsolete';
  validFor: {
    startDateTime: string;
    endDateTime?: string;
  };
  productSpecification: {
    id: string;
    name: string;
  };
  productOfferingPrice: Array<{
    name: string;
    price: {
      taxIncludedAmount: number;
      dutyFreeAmount: number;
      unit: string;
    };
    priceType: 'recurring' | 'one time' | 'usage';
    recurringChargePeriod?: 'month' | 'year';
  }>;
  category: Array<{
    id: string;
    name: string;
  }>;
}

export class ProductCatalogService {
  private docClient: DynamoDBDocumentClient;
  private tableName: string;

  constructor() {
    const client = new DynamoDBClient({});
    this.docClient = DynamoDBDocumentClient.from(client);
    this.tableName = process.env.CATALOG_TABLE!;
  }

  async createProductOffering(offering: ProductOffering): Promise<ProductOffering> {
    // Validate lifecycle status transition
    this.validateLifecycleStatus(offering.lifecycleStatus);

    // Generate ID and href
    offering.id = this.generateId();
    offering.href = `/productCatalogManagement/v4/productOffering/${offering.id}`;

    await this.docClient.send(new PutCommand({
      TableName: this.tableName,
      Item: offering,
      ConditionExpression: 'attribute_not_exists(id)'
    }));

    return offering;
  }

  async getProductOffering(id: string): Promise<ProductOffering | null> {
    const result = await this.docClient.send(new GetCommand({
      TableName: this.tableName,
      Key: { id }
    }));

    return result.Item as ProductOffering || null;
  }

  private validateLifecycleStatus(status: string): void {
    const validStatuses = ['In design', 'In test', 'Active', 'Launched', 'Retired', 'Obsolete'];
    if (!validStatuses.includes(status)) {
      throw new Error(`Invalid lifecycle status: ${status}`);
    }
  }

  private generateId(): string {
    return `PO-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  }
}

export const handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  const service = new ProductCatalogService();

  try {
    if (event.httpMethod === 'POST') {
      const offering = JSON.parse(event.body!);
      const created = await service.createProductOffering(offering);
      
      return {
        statusCode: 201,
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(created)
      };
    } else if (event.httpMethod === 'GET') {
      const id = event.pathParameters?.id!;
      const offering = await service.getProductOffering(id);
      
      if (!offering) {
        return {
          statusCode: 404,
          body: JSON.stringify({ message: 'Product offering not found' })
        };
      }
      
      return {
        statusCode: 200,
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(offering)
      };
    }

    return {
      statusCode: 405,
      body: JSON.stringify({ message: 'Method not allowed' })
    };
  } catch (error: any) {
    console.error('Error:', error);
    return {
      statusCode: error.statusCode || 500,
      body: JSON.stringify({ message: error.message })
    };
  }
};

import { EventBridgeClient, PutEventsCommand } from '@aws-sdk/client-eventbridge';

type OrderState = 
  | 'Acknowledged' 
  | 'Rejected' 
  | 'Pending' 
  | 'Held' 
  | 'InProgress' 
  | 'Cancelled' 
  | 'Completed' 
  | 'Failed' 
  | 'Partial';

interface ProductOrder {
  id: string;
  state: OrderState;
  orderDate: string;
  completionDate?: string;
  productOrderItem: Array<{
    id: string;
    quantity: number;
    action: 'add' | 'modify' | 'delete';
    state: OrderState;
    product: {
      id: string;
      name: string;
      productOffering: { id: string };
    };
  }>;
}

export class OrderStateMachine {
  private eventBridge: EventBridgeClient;
  private allowedTransitions: Record<OrderState, OrderState[]> = {
    'Acknowledged': ['Rejected', 'Pending', 'InProgress'],
    'Rejected': [],
    'Pending': ['Held', 'InProgress', 'Cancelled'],
    'Held': ['InProgress', 'Cancelled'],
    'InProgress': ['Cancelled', 'Completed', 'Failed', 'Partial'],
    'Cancelled': [],
    'Completed': [],
    'Failed': [],
    'Partial': ['Completed', 'Failed']
  };

  constructor() {
    this.eventBridge = new EventBridgeClient({});
  }

  async transitionOrderState(
    order: ProductOrder,
    newState: OrderState
  ): Promise<ProductOrder> {
    // Validate transition is allowed
    if (!this.isTransitionAllowed(order.state, newState)) {
      throw new Error(
        `Invalid state transition from ${order.state} to ${newState}`
      );
    }

    const previousState = order.state;
    order.state = newState;

    if (newState === 'Completed') {
      order.completionDate = new Date().toISOString();
    }

    // Publish state change event
    await this.publishStateChangeEvent(order, previousState, newState);

    return order;
  }

  private isTransitionAllowed(currentState: OrderState, newState: OrderState): boolean {
    return this.allowedTransitions[currentState]?.includes(newState) || false;
  }

  private async publishStateChangeEvent(
    order: ProductOrder,
    previousState: OrderState,
    newState: OrderState
  ): Promise<void> {
    await this.eventBridge.send(new PutEventsCommand({
      Entries: [{
        Source: 'tmf.productordering',
        DetailType: 'ProductOrderStateChangeEvent',
        Detail: JSON.stringify({
          eventId: `evt-${Date.now()}`,
          eventTime: new Date().toISOString(),
          eventType: 'ProductOrderStateChangeEvent',
          event: {
            productOrder: {
              id: order.id,
              state: newState,
              previousState: previousState,
              href: `/productOrderingManagement/v4/productOrder/${order.id}`
            }
          }
        })
      }]
    }));
  }
}