Create a Category Add-on Manually with the CLI

myhomeservicesapp/
├── action/
│   ├── home-services/
│   │   ├── api-samples.rest
│   │   ├── scripts/bundle/                   # Build scripts
│   │   ├── src/
│   │   │   ├── apigateway.ts               # API Gateway handler setup
│   │   │   ├── config_builder.ts           # SPI config builder (operations + endpoints)
│   │   │   ├── handlers/                    # Lambda entry points (one per operation)
│   │   │   │   ├── cancel_booking_handler.ts
│   │   │   │   ├── create_booking_handler.ts
│   │   │   │   ├── get_booking_handler.ts
│   │   │   │   ├── get_service_specification_handler.ts
│   │   │   │   ├── get_services_handler.ts
│   │   │   │   ├── get_user_info_handler.ts
│   │   │   │   ├── list_professionals_handler.ts
│   │   │   │   ├── message_professional_handler.ts
│   │   │   │   └── modify_booking_handler.ts
│   │   │   ├── local/                       # Local testing utilities
│   │   │   └── operations/                   # Business logic (what YOU implement)
│   │   │       ├── cancel_booking.ts
│   │   │       ├── create_booking.ts
│   │   │       ├── get_booking.ts
│   │   │       ├── get_service_specification.ts
│   │   │       ├── get_services.ts
│   │   │       ├── get_user_info.ts
│   │   │       ├── list_professionals.ts
│   │   │       ├── message_professional.ts
│   │   │       └── modify_booking.ts
│   │   ├── test-suites/
│   │   │   └── test-config.json
│   │   └── tests/                             # Unit tests per operation
│   │       ├── api_gateway.test.ts
│   │       ├── cancel_booking.test.ts
│   │       ├── create_booking.test.ts
│   │       ├── get_booking.test.ts
│   │       ├── get_service_specification.test.ts
│   │       ├── get_services.test.ts
│   │       ├── get_user_info.test.ts
│   │       ├── list_professionals.test.ts
│   │       ├── message_professional.test.ts
│   │       └── modify_booking.test.ts
│   └── infrastructure/cdk/                    # AWS CDK stacks
├── addon-package/
│   ├── action/
│   │   └── HomeServicesService-config.json     # SPI config: operations, endpoints
│   └── addon.json                               # Manifest: store listing, permissions, integrations
├── cdk.json
├── jest.config.js
├── package.json
├── README.md
└── tsconfig.json

mylocalbookingapp/
├── action/
│   ├── infrastructure/cdk/
│   │   ├── bin/
│   │   │   └── app.ts
│   │   └── lib/
│   │       └── add-on-infra-stack.ts
│   └── local-booking/
│       ├── api-samples.rest
│       ├── scripts/bundle/
│       │   └── index.js
│       ├── src/
│       │   ├── apigateway.ts                   # API Gateway handler setup
│       │   ├── config_builder.ts               # SPI config builder (operations + endpoints)
│       │   ├── handlers/                       # Lambda entry points (one per operation)
│       │   │   ├── cancel_appointment_handler.ts
│       │   │   ├── create_appointment_handler.ts
│       │   │   ├── get_appointment_handler.ts
│       │   │   ├── get_availability_handler.ts
│       │   │   ├── get_business_handler.ts
│       │   │   ├── get_reviews_handler.ts
│       │   │   ├── get_services_handler.ts
│       │   │   ├── get_user_info_handler.ts
│       │   │   └── update_appointment_handler.ts
│       │   ├── local/
│       │   │   └── server.ts                   # Local testing server
│       │   └── operations/                     # Business logic (what YOU implement)
│       │       ├── cancel_appointment.ts
│       │       ├── create_appointment.ts
│       │       ├── get_appointment.ts
│       │       ├── get_availability.ts
│       │       ├── get_business.ts
│       │       ├── get_reviews.ts
│       │       ├── get_services.ts
│       │       ├── get_user_info.ts
│       │       └── update_appointment.ts
│       ├── test-suites/
│       │   └── test-config.json
│       └── tests/
│           ├── cancel_appointment.test.ts
│           ├── create_appointment.test.ts
│           ├── get_appointment.test.ts
│           ├── get_availability.test.ts
│           ├── get_business.test.ts
│           ├── get_reviews.test.ts
│           ├── get_services.test.ts
│           ├── get_user_info.test.ts
│           └── update_appointment.test.ts
├── addon-package/
│   ├── action/
│   │   └── LocalBookingService-config.json     # SPI config: operations, endpoints
│   └── addon.json                              # Manifest: store listing, permissions, integrations
├── cdk.json
├── jest.config.js
├── package.json
├── poi-data/
│   └── test-poi-data.json
└── tsconfig.json

myrestaurantapp/
├── action/
│   ├── infrastructure/cdk/                     # AWS CDK stacks
│   └── restaurant-reservation/
│       ├── api-samples.rest
│       ├── scripts/bundle/                     # Build scripts
│       ├── src/
│       │   ├── apigateway.ts                   # API Gateway handler setup
│       │   ├── config_builder.ts               # SPI config builder (operations + endpoints)
│       │   ├── handlers/                       # Lambda entry points (one per operation)
│       │   │   ├── create_reservation_handler.ts
│       │   │   ├── delete_reservation_handler.ts
│       │   │   ├── get_availability_handler.ts
│       │   │   └── update_reservation_handler.ts
│       │   ├── local/                          # Local testing utilities
│       │   └── operations/                     # Business logic (what YOU implement)
│       │       ├── create_reservation.ts
│       │       ├── delete_reservation.ts
│       │       ├── get_availability.ts
│       │       └── update_reservation.ts
│       ├── test-suites/
│       │   └── test-config.json
│       └── tests/                              # Unit tests per operation
│           ├── api_gateway.test.ts
│           ├── create_reservation.test.ts
│           ├── delete_reservation.test.ts
│           ├── get_availability.test.ts
│           └── update_reservation.test.ts
├── addon-package/
│   ├── action/
│   │   └── RestaurantReservationService-config.json   # SPI config: operations, endpoints
│   └── addon.json                              # Manifest: store listing, permissions, integrations
├── cdk.json
├── jest.config.js
├── package.json
├── README.md
└── tsconfig.json

myticketingapp/
├── action/
│   ├── infrastructure/cdk/
│   │   ├── bin/
│   │   │   └── app.ts
│   │   └── lib/
│   │       └── add-on-infra-stack.ts
│   └── ticketing/
│       ├── scripts/bundle/
│       │   └── index.js
│       ├── src/
│       │   ├── apigateway.ts                   # API Gateway handler setup
│       │   ├── config_builder.ts               # SPI config builder (operations + endpoints)
│       │   ├── handlers/                       # Lambda entry points (one per operation)
│       │   │   ├── confirm_ticket_handler.ts
│       │   │   ├── get_event_details_handler.ts
│       │   │   ├── get_order_summary_handler.ts
│       │   │   ├── get_seat_details_handler.ts
│       │   │   ├── release_ticket_handler.ts
│       │   │   ├── reserve_ticket_handler.ts
│       │   │   ├── search_events_handler.ts
│       │   │   └── search_venues_handler.ts
│       │   ├── local/
│       │   │   └── server.ts                   # Local testing server
│       │   └── operations/                     # Business logic (what YOU implement)
│       │       ├── confirm_ticket.ts
│       │       ├── get_event_details.ts
│       │       ├── get_order_summary.ts
│       │       ├── get_seat_details.ts
│       │       ├── release_ticket.ts
│       │       ├── reserve_ticket.ts
│       │       ├── search_events.ts
│       │       └── search_venues.ts
│       ├── test-suites/
│       │   └── test-config.json
│       └── tests/
│           ├── api_gateway.test.ts
│           └── search_events.test.ts
├── addon-package/
│   ├── action/
│   │   └── TicketingService-config.json        # SPI config: operations, endpoints
│   └── addon.json                              # Manifest: store listing, permissions, integrations
├── cdk.json
├── jest.config.js
├── package.json
└── tsconfig.json

// 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();