Create a Category Add-on Manually with the CLI

// action/home-services/src/handlers/get_services_handler.ts

import { getGetServicesHandler } from "@alexa-ai/category-home-services-spi";
import { APIGatewayProxyHandler } from "aws-lambda";
import { GetServicesOperation } from "../operations/get_services";
import { getApiGatewayHandler } from "../apigateway";

export const lambdaHandler: APIGatewayProxyHandler = getApiGatewayHandler(
    getGetServicesHandler(GetServicesOperation)
);

// action/local-booking/src/handlers/get_business_handler.ts

import { getGetBusinessHandler } from "@alexa-ai/category-local-booking-spi";
import { APIGatewayProxyHandler } from "aws-lambda";
import { GetBusinessOperation } from "../operations/get_business";
import { getApiGatewayHandler } from "../apigateway";

export const lambdaHandler: APIGatewayProxyHandler = getApiGatewayHandler(
    getGetBusinessHandler(GetBusinessOperation)
);

// action/restaurant-reservation/src/handlers/get_availability_handler.ts

import { getGetAvailabilityHandler } from "@alexa-ai/category-restaurant-reservation-spi";
import { APIGatewayProxyHandler } from "aws-lambda";
import { GetAvailabilityOperation } from "../operations/get_availability";
import { getApiGatewayHandler } from "../apigateway";

// This is the entry point for the Lambda Function that services the GetAvailabilityOperation
export const lambdaHandler: APIGatewayProxyHandler = getApiGatewayHandler(getGetAvailabilityHandler(GetAvailabilityOperation));

// action/ticketing/src/handlers/search_events_handler.ts

import { getSearchEventsHandler } from "@alexa-ai/category-ticketing-spi";
import { APIGatewayProxyHandler } from "aws-lambda";
import { SearchEventsOperation } from "../operations/search_events";
import { getApiGatewayHandler } from "../apigateway";

export const lambdaHandler: APIGatewayProxyHandler = getApiGatewayHandler(
    getSearchEventsHandler(SearchEventsOperation)
);

// action/home-services/src/operations/get_services.ts

import { Operation } from "@aws-smithy/server-common";
import { GetServicesServerInput, GetServicesServerOutput } from "@alexa-ai/category-home-services-spi";
import { HandlerContext } from "../apigateway";

export const GetServicesOperation: Operation<GetServicesServerInput, GetServicesServerOutput, HandlerContext> =
  async (input, context) => {
    console.log(`Received GetServices from: ${context.user}`);
    console.log(`Input: ${JSON.stringify(input)}`);

    // TODO: Implement actual provider logic to return matching services
    return {
      services: [
        {
          id: "svc-001",
          name: "House Cleaning",
          description: "Professional house cleaning service",
          confidence: 0.95,
        },
      ],
    };
  };

// action/local-booking/src/operations/get_business.ts

import { Operation } from "@aws-smithy/server-common";
import { GetBusinessServerInput, GetBusinessServerOutput } from "@alexa-ai/category-local-booking-spi";
import { HandlerContext } from "../apigateway";

export const GetBusinessOperation: Operation<GetBusinessServerInput, GetBusinessServerOutput, HandlerContext> =
  async (input, context) => {
    console.log(`Received GetBusiness from: ${context.user}`);
    console.log(`Input: ${JSON.stringify(input)}`);

    // TODO: Implement actual provider logic to return business details
    return {
      business: {
        businessId: input.businessId,
        name: "Example Salon",
        description: "Full-service hair salon and spa",
      },
    };
  };

// action/restaurant-reservation/src/operations/get_availability.ts

import { Operation } from "@aws-smithy/server-common";
import { GetAvailabilityServerInput, GetAvailabilityServerOutput } from "@alexa-ai/category-restaurant-reservation-spi";
import { HandlerContext } from "../apigateway";

// This is the mock implementation of business logic for the GetAvailability operation
export const GetAvailabilityOperation: Operation<GetAvailabilityServerInput, GetAvailabilityServerOutput, HandlerContext> = async (input, context) => {

    console.log(`Received GetAvailability operation from: ${context.user}`);
    console.log(`Restaurant ID: ${input.restaurantId}, Party Size: ${input.partySize}, Start: ${input.startDateTime!}, End: ${input.endDateTime!}`);

    // Input format is YYYY-MM-DDTHH:MM and treat it as PST
    const startTime = input.startDateTime!;
    const endTime = input.endDateTime!;

    // If start time equals end time, return empty array
    if (startTime === endTime) {
        console.log(`Empty time range, returning no slots`);
        return { availableTimeSlots: [] };
    }

    // Extract date from start time for generating slots
    const dateMatch = startTime.match(/^(\d{4}-\d{2}-\d{2})/);
    if (!dateMatch) {
        console.log('Invalid date format in startDateTime');
        return { availableTimeSlots: [] };
    }
    const dateString = dateMatch[1];

    // Generate all possible time slots for the day in PST
    const allSlots = [];

    // Lunch slots: 11:30am to 2pm (every 30 minutes) in PST
    for (let hour = 11; hour <= 13; hour++) {
        for (let minute = (hour === 11 ? 30 : 0); minute < 60; minute += 30) {
            if (hour === 13 && minute > 30) continue; // Stop at 2pm

            const slotTime = `${dateString}T${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
            allSlots.push({ datetime: slotTime });
        }
    }

    // Dinner slots: 5pm to 10pm (every 30 minutes) in PST
    for (let hour = 17; hour <= 21; hour++) {
        for (let minute = 0; minute < 60; minute += 30) {
            if (hour === 21 && minute > 30) continue; // Stop at 10pm

            const slotTime = `${dateString}T${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
            allSlots.push({ datetime: slotTime });
        }
    }

    // Filter slots to only include those within the requested time range
    const availableSlots = allSlots.filter(slot => {
        const slotTime = slot.datetime!;
        return slotTime >= startTime && slotTime <= endTime;
    });

    // Limit to 20 slots max
    const limitedSlots = availableSlots.slice(0, 20);

    console.log(`Generated ${limitedSlots.length} available time slots`);
    // Log the available slots for debugging
    if (limitedSlots.length > 0) {
        console.log('Available slots:');
        limitedSlots.forEach(slot => {
            console.log(`- ${slot.datetime!}`);
        });
    } else {
        console.log('No available slots within the requested time range');
    }

    return {
        availableTimeSlots: limitedSlots
    };
};

// action/ticketing/src/operations/search_events.ts

import { Operation } from "@aws-smithy/server-common";
import { SearchEventsServerInput, SearchEventsServerOutput } from "@alexa-ai/category-ticketing-spi";
import { HandlerContext } from "../apigateway";

export const SearchEventsOperation: Operation<SearchEventsServerInput, SearchEventsServerOutput, HandlerContext> =
  async (input, context) => {
    console.log(`Received SearchEvents from: ${context.user}`);
    console.log(`Input: ${JSON.stringify(input)}`);

    // TODO: Implement actual provider logic to search events
    return {
      events: [
        {
          eventId: "evt-001",
          name: "Example Concert",
          description: "Live music performance",
        },
      ],
    };
  };

// action/home-services/src/config_builder.ts

import { ActionSPIConfigBuilder } from "@alexa-ai/addon-build-plugin";
import { HomeServicesServiceMetadata, HomeServicesServiceOperations } from "@alexa-ai/category-home-services-spi";

export const actionConfig = new ActionSPIConfigBuilder()
    .name(HomeServicesServiceMetadata.interfaceName)
    .spiVersion(HomeServicesServiceMetadata.version)
    .operation(HomeServicesServiceOperations.ListProfessionals)
    .operation(HomeServicesServiceOperations.MessageProfessional)
    .operation(HomeServicesServiceOperations.GetUserInfo)
    .operation(HomeServicesServiceOperations.GetServices)
    .operation(HomeServicesServiceOperations.GetServiceSpecification)
    .operation(HomeServicesServiceOperations.CreateBooking)
    .operation(HomeServicesServiceOperations.CancelBooking)
    .operation(HomeServicesServiceOperations.ModifyBooking)
    .operation(HomeServicesServiceOperations.GetBooking)
    .endpoints(ep => ep
        .default("https://home-services-api.example.com/prod")
    )
    .build();

// action/local-booking/src/config_builder.ts

import { ActionSPIConfigBuilder } from "@alexa-ai/addon-build-plugin";
import { LocalBookingServiceMetadata, LocalBookingServiceOperations } from "@alexa-ai/category-local-booking-spi";

export const actionConfig = new ActionSPIConfigBuilder()
    .name(LocalBookingServiceMetadata.interfaceName)
    .spiVersion(LocalBookingServiceMetadata.version)
    .operation(LocalBookingServiceOperations.GetBusiness)
    .operation(LocalBookingServiceOperations.GetReviews)
    .operation(LocalBookingServiceOperations.GetServices)
    .operation(LocalBookingServiceOperations.GetAvailability)
    .operation(LocalBookingServiceOperations.CreateAppointment)
    .operation(LocalBookingServiceOperations.UpdateAppointment)
    .operation(LocalBookingServiceOperations.CancelAppointment)
    .operation(LocalBookingServiceOperations.GetAppointment)
    .operation(LocalBookingServiceOperations.GetUserInfo)
    .endpoints(ep => ep
        .default("https://local-booking-api.example.com/prod")
    )
    .build();

// action/restaurant-reservation/src/config_builder.ts

import { ActionSPIConfigBuilder } from "@alexa-ai/addon-build-plugin";
import { ReservationServiceMetadata, ReservationServiceOperations } from "@alexa-ai/category-restaurant-reservation-spi"

export const actionConfig = new ActionSPIConfigBuilder()
    .name(ReservationServiceMetadata.interfaceName)
    .spiVersion(ReservationServiceMetadata.version)
    .operation(ReservationServiceOperations.GetAvailability)
    .operation(ReservationServiceOperations.CreateReservation)
    .operation(ReservationServiceOperations.UpdateReservation)
    .operation(ReservationServiceOperations.DeleteReservation)
    .endpoints(ep => ep
        .default("https://rr-api.example.com/prod")
    )
    .build();

// action/ticketing/src/config_builder.ts

import { ActionSPIConfigBuilder } from "@alexa-ai/addon-build-plugin";
import { TicketingServiceMetadata, TicketingServiceOperations } from "@alexa-ai/category-ticketing-spi";

export const actionConfig = new ActionSPIConfigBuilder()
    .name(TicketingServiceMetadata.interfaceName)
    .spiVersion(TicketingServiceMetadata.version)
    .operation(TicketingServiceOperations.SearchEvents)
    .operation(TicketingServiceOperations.SearchVenues)
    .operation(TicketingServiceOperations.GetEventDetails)
    .operation(TicketingServiceOperations.GetSeatDetails)
    .operation(TicketingServiceOperations.ReserveTicket)
    .operation(TicketingServiceOperations.ConfirmTicket)
    .operation(TicketingServiceOperations.ReleaseTicket)
    .operation(TicketingServiceOperations.GetOrderSummary)
    .endpoints(ep => ep
        .default("https://ticketing-api.example.com/prod")
    )
    .build();