@lambda-kata/cdk 0.1.3-rc.97 → 0.1.5

package/out/tsc/src/index.d.ts

@@ -18,11 +18,9 @@
  * ```
  */
 export { KataProps, LicensingResponse, TransformationConfig } from './types';
-export { LicensingService, LicenseCheckParams, HttpLicensingService, createLicensingService, isValidAccountId, } from './licensing';
-export { MockLicensingService, createMockLicensingService, } from './mock-licensing';
 export { resolveAccountId, resolveAccountIdWithSource, isValidAccountIdFormat, AccountResolutionError, AccountResolutionResult, AccountResolverOptions, } from './account-resolver';
 export { resolveAccountIdSync, resolveAccountIdSyncWithSource, resolveRegionSync, SyncAccountResolutionError, SyncAccountResolutionResult, SyncAccountResolverOptions, } from './sync-account-resolver';
-export { kata, kataWithAccountId, applyTransformation, handleUnlicensed, isKataTransformed, getKataPromise, extractBundlePathFromHandler, extractNodeVersion, KataWrapperOptions, KataResult, } from './kata-wrapper';
+export { kata, applyTransformation, handleUnlicensed, isKataTransformed, getKataPromise, extractBundlePathFromHandler, extractNodeVersion, KataWrapperOptions, KataResult, } from './kata-wrapper';
 export { SnapStartActivator, SnapStartActivatorProps, } from './snapstart-construct';
 export { activateSnapStart, SnapStartActivationResult, SnapStartActivatorConfig, } from './snapstart-activator';
 export { createKataConfigLayer, generateConfigContent, KataConfigLayerProps, CONFIG_DIR_NAME, CONFIG_FILE_NAME, HANDLER_CONFIG_KEY, } from './config-layer';

package/out/tsc/src/kata-wrapper.d.ts

@@ -1,24 +1,10 @@
 import { Function as LambdaFunction } from 'aws-cdk-lib/aws-lambda';
 import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
 import { KataProps, LicensingResponse, TransformationConfig } from './types';
-import { LicensingService } from './licensing';
-import { LicensingService as NativeLicensingServiceInterface } from '@lambda-kata/licensing';
 /**
  * Options for the kata wrapper, extending KataProps with internal options.
  */
 export interface KataWrapperOptions extends KataProps {
-    /**
-     * Optional: Custom licensing service for testing.
-     * If not provided, the default HTTP licensing service will be used.
-     * @internal
-     */
-    licensingService?: LicensingService;
-    /**
-     * Optional: Custom synchronous licensing service for testing.
-     * Must implement checkEntitlementSync(accountId: string): LicensingResponse
-     * @internal
-     */
-    syncLicensingService?: NativeLicensingServiceInterface;
     /**
      * Custom bundle path.
      * If not specified, uses the default /opt/js_runtime/bundle.js
@@ -224,7 +210,7 @@ export declare function applyTransformation(lambda: NodejsFunction | LambdaFunct
  *
  * @internal
  */
-export declare function handleUnlicensed(lambda: NodejsFunction | LambdaFunction, props: KataWrapperOptions | undefined, licensingResponse: LicensingResponse): void;
+export declare function handleUnlicensed(lambda: NodejsFunction | LambdaFunction, props: KataProps | undefined, licensingResponse: LicensingResponse): void;
 /**
  * Checks if a Lambda function has been transformed by kata().
  *

package/out/tsc/src/types.d.ts

@@ -12,16 +12,10 @@ import { Runtime } from 'aws-cdk-lib/aws-lambda';
  * ```typescript
  * kata(myFunction, {
  *   unlicensedBehavior: 'fail',
- *   licensingEndpoint: 'https://custom-endpoint.example.com'
  * });
  * ```
  */
 export interface KataProps {
-    /**
-     * Optional: Override the licensing service endpoint
-     * Default: Lambda Kata production licensing endpoint
-     */
-    licensingEndpoint?: string;
     /**
      * Optional: Behavior when account is not licensed
      * 'warn' - Keep original Lambda, emit warning (default)

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@lambda-kata/cdk",
-  "version": "0.1.3-rc.97",
+  "version": "0.1.5",
   "description": "AWS CDK integration for Lambda Kata - Node.js Lambdas running via Lambda Kata runtime",
   "main": "out/dist/index.js",
   "types": "out/tsc/src/index.d.ts",
   "scripts": {
     "build": "rm -rf ./dist && rm -rf ./out && rm -rf ./lib && yarn run build:cdk && yarn run build:snapstart && yarn run types",
+    "prepare": "yarn build",
     "build:snapstart": "yarn run build:config && node dist/utils/build.js --target=snapstartHandler",
     "types": "tsc --emitDeclarationOnly && tsc-alias",
     "build:cdk": "yarn run build:config && node dist/utils/build.js --target=cdk",
@@ -58,7 +59,7 @@
     "@aws-sdk/client-lambda": "^3.500.0",
     "@aws-sdk/client-s3": "^3.500.0",
     "@aws-sdk/client-sts": "^3.500.0",
-    "@lambda-kata/licensing": "0.1.33",
+    "@lambda-kata/licensing": "0.2.1",
     "dotenv": "^17.2.3",
     "reflect-metadata": "^0.2.2"
   },

package/out/tsc/src/licensing.d.ts

@@ -1,151 +0,0 @@
-/**
- * Licensing Service for Lambda Kata CDK Integration
- *
- * This module provides the interface and implementation for validating
- * AWS Marketplace entitlements at CDK synthesis/deploy time.
- *
- * @module licensing
- */
-import { LicensingResponse } from './types';
-/**
- * Supported Node.js versions for licensing requests.
- * Valid values: "18", "20", "22", "24"
- */
-export type NodeVersion = '18' | '20' | '22' | '24';
-/**
- * Supported architectures for licensing requests.
- * Valid values: "x86_64", "arm64"
- */
-export type LicenseArchitecture = 'x86_64' | 'arm64';
-/**
- * Parameters for license entitlement check.
- */
-export interface LicenseCheckParams {
-    /**
-     * AWS account ID (12-digit string)
-     */
-    accountId: string;
-    /**
-     * Node.js version number.
-     * Valid values: "18", "20", "22", "24"
-     * @default "20"
-     */
-    nodeVersion?: NodeVersion;
-    /**
-     * Lambda architecture.
-     * Valid values: "x86_64", "arm64"
-     * @default "x86_64"
-     */
-    architecture?: LicenseArchitecture;
-}
-/**
- * Interface for the Lambda Kata licensing service.
- *
- * Implementations of this interface are responsible for validating
- * AWS account entitlements and returning customer-specific Layer ARNs.
- *
- * @example
- * ```typescript
- * const licensingService = new HttpLicensingService();
- * const response = await licensingService.checkEntitlement({
- *   accountId: '123456789012',
- *   nodeVersion: '20',
- *   architecture: 'x86_64'
- * });
- * if (response.entitled) {
- *   console.log(`Layer ARN: ${response.layerVersionArn}`);
- * }
- * ```
- */
-export interface LicensingService {
-    /**
-     * Check if an AWS account is entitled to use Lambda Kata.
-     *
-     * @param params - License check parameters (accountId, nodeVersion, architecture)
-     *                 For backward compatibility, can also be just accountId string
-     * @returns Promise resolving to entitlement status and Layer ARN if entitled
-     *
-     * @remarks
-     * - If the account is entitled, the response will include the customer-specific Layer ARN
-     * - If the account is not entitled, the response will have `entitled: false`
-     * - Network errors are handled gracefully and treated as unlicensed (Requirement 6.5)
-     */
-    checkEntitlement(params: LicenseCheckParams | string): Promise<LicensingResponse>;
-}
-/**
- * HTTP-based implementation of the LicensingService interface.
- *
- * This implementation calls the Lambda Kata licensing backend to validate
- * AWS Marketplace entitlements. Network errors are handled gracefully
- * by treating unreachable services as unlicensed (per Requirement 6.5).
- *
- * @example
- * ```typescript
- * // Use default endpoint
- * const service = new HttpLicensingService();
- *
- * // Use custom endpoint
- * const customService = new HttpLicensingService('https://custom.endpoint.com');
- * ```
- */
-export declare class HttpLicensingService implements LicensingService {
-    private readonly endpoint;
-    private readonly timeoutMs;
-    /**
-     * Creates a new HttpLicensingService instance.
-     *
-     * @param endpoint - Optional custom licensing endpoint URL
-     * @param timeoutMs - Optional request timeout in milliseconds (default: 5000)
-     */
-    constructor(endpoint?: string, timeoutMs?: number);
-    /**
-     * Check if an AWS account is entitled to use Lambda Kata.
-     *
-     * Makes an HTTP request to the licensing service to validate the account's
-     * AWS Marketplace entitlement. If the service is unreachable or returns
-     * an error, the account is treated as unlicensed (Requirement 6.5).
-     *
-     * @param params - License check parameters or accountId string for backward compatibility
-     * @returns Promise resolving to entitlement status and Layer ARN if entitled
-     *
-     * @remarks
-     * Validates: Requirements 3.2, 3.3, 6.5
-     * - 3.2: Calls the Licensing_Service to validate the account's entitlement
-     * - 3.3: Returns the customer-specific Layer_ARN if entitled
-     * - 6.5: Treats unreachable service as unlicensed with appropriate warning
-     */
-    checkEntitlement(params: LicenseCheckParams | string): Promise<LicensingResponse>;
-    /**
-     * Makes the HTTP request to the licensing service.
-     *
-     * @param accountId - The AWS account ID to check
-     * @param nodeVersion - Optional Node.js version (defaults to "20")
-     * @param architecture - Optional architecture (defaults to "x86_64")
-     * @returns Promise resolving to the licensing response
-     * @throws Error if the request fails or times out
-     */
-    private makeRequest;
-}
-/**
- * Validates that an AWS account ID is in the correct format.
- *
- * @param accountId - The account ID to validate
- * @returns true if the account ID is a valid 12-digit string
- */
-export declare function isValidAccountId(accountId: string): boolean;
-/**
- * Creates a default LicensingService instance.
- *
- * This factory function provides a convenient way to create a licensing
- * service with default configuration.
- *
- * @param endpoint - Optional custom licensing endpoint URL
- * @returns A new LicensingService instance
- *
- * @example
- * ```typescript
- * const service = createLicensingService();
- * const response = await service.checkEntitlement('123456789012');
- * ```
- */
-export declare function createLicensingService(endpoint?: string): LicensingService;

package/out/tsc/src/mock-licensing.d.ts

@@ -1,218 +0,0 @@
-/**
- * Mock Licensing Service for Lambda Kata CDK Integration Testing
- *
- * This module provides a mock implementation of the LicensingService interface
- * for testing the kata() wrapper without making real network calls.
- *
- * @module mock-licensing
- */
-import { LicensingService, LicenseCheckParams } from './licensing';
-import { LicensingResponse } from './types';
-/**
- * Mock implementation of the LicensingService interface for testing.
- *
- * This class allows programmatic control over entitlement status,
- * enabling comprehensive testing of the kata() wrapper behavior
- * for both entitled and non-entitled accounts.
- *
- * @example
- * ```typescript
- * const mockService = new MockLicensingService();
- *
- * // Set up an entitled account
- * mockService.setEntitled('123456789012', 'arn:aws:lambda:us-east-1:999999999999:layer:LambdaKata:1');
- *
- * // Check entitlement
- * const response = await mockService.checkEntitlement('123456789012');
- * console.log(response.entitled); // true
- * console.log(response.layerArn); // 'arn:aws:lambda:us-east-1:999999999999:layer:LambdaKata:1'
- *
- * // Non-entitled account
- * const response2 = await mockService.checkEntitlement('000000000000');
- * console.log(response2.entitled); // false
- * ```
- *
- * @remarks
- * Validates: Requirements 3.2, 3.3
- * - 3.2: Provides mock validation of account entitlements
- * - 3.3: Returns customer-specific Layer_ARN for entitled accounts
- */
-export declare class MockLicensingService implements LicensingService {
-    /**
-     * Map of AWS account IDs to their entitled Layer ARNs.
-     * Accounts not in this map are considered non-entitled.
-     */
-    private entitlements;
-    /**
-     * Map of AWS account IDs to custom messages (for non-entitled accounts).
-     */
-    private customMessages;
-    /**
-     * Optional custom message to return for entitled accounts.
-     */
-    private entitledMessage;
-    /**
-     * Optional custom message to return for non-entitled accounts.
-     * Default matches the expected warning message from Requirement 6.4.
-     */
-    private notEntitledMessage;
-    /**
-     * Optional expiration date for entitlements.
-     */
-    private expiresAt?;
-    /**
-     * Flag to simulate service unavailability.
-     */
-    private simulateServiceError;
-    /**
-     * Custom error message when simulating service errors.
-     */
-    private serviceErrorMessage;
-    /**
-     * Flag to simulate entitled response without layerArn (service issue).
-     */
-    private simulateEntitledWithoutLayerArn;
-    /**
-     * Sets an account as entitled with a specific Layer ARN.
-     *
-     * @param accountId - The AWS account ID (12-digit string)
-     * @param layerArn - The customer-specific Lambda Layer ARN
-     *
-     * @example
-     * ```typescript
-     * mockService.setEntitled('123456789012', 'arn:aws:lambda:us-east-1:999999999999:layer:LambdaKata:1');
-     * ```
-     */
-    setEntitled(accountId: string, layerArn: string): void;
-    /**
-     * Removes entitlement for an account.
-     *
-     * @param accountId - The AWS account ID to remove entitlement for
-     *
-     * @example
-     * ```typescript
-     * mockService.removeEntitlement('123456789012');
-     * ```
-     */
-    removeEntitlement(accountId: string): void;
-    /**
-     * Clears all entitlements.
-     *
-     * @example
-     * ```typescript
-     * mockService.clearEntitlements();
-     * ```
-     */
-    clearEntitlements(): void;
-    /**
-     * Sets a custom message for entitled accounts.
-     *
-     * @param message - The message to return for entitled accounts
-     */
-    setEntitledMessage(message: string): void;
-    /**
-     * Sets a custom message for non-entitled accounts.
-     *
-     * @param message - The message to return for non-entitled accounts
-     */
-    setNotEntitledMessage(message: string): void;
-    /**
-     * Sets a custom message for a specific non-entitled account.
-     * This allows testing per-account custom error messages from the licensing service.
-     *
-     * @param accountId - The AWS account ID
-     * @param message - The custom message to return for this account
-     *
-     * @example
-     * ```typescript
-     * mockService.setCustomMessage('123456789012', 'Custom licensing error: Account suspended');
-     * ```
-     */
-    setCustomMessage(accountId: string, message: string): void;
-    /**
-     * Sets the expiration date for entitlements.
-     *
-     * @param expiresAt - ISO 8601 formatted expiration date
-     */
-    setExpiresAt(expiresAt: string): void;
-    /**
-     * Configures the mock to simulate service unavailability.
-     *
-     * @param simulate - Whether to simulate service errors
-     * @param errorMessage - Optional custom error message
-     *
-     * @example
-     * ```typescript
-     * // Simulate service being down
-     * mockService.setSimulateServiceError(true);
-     *
-     * // With custom error message
-     * mockService.setSimulateServiceError(true, 'Connection refused');
-     * ```
-     */
-    setSimulateServiceError(simulate: boolean, errorMessage?: string): void;
-    /**
-     * Configures the mock to simulate entitled response without layerArn.
-     * This simulates a licensing service issue where the account is entitled
-     * but the service fails to return the layer ARN.
-     *
-     * @param simulate - Whether to simulate entitled without layerArn
-     *
-     * @example
-     * ```typescript
-     * // Simulate service returning entitled: true but no layerArn
-     * mockService.setSimulateEntitledWithoutLayerArn(true);
-     * ```
-     */
-    setSimulateEntitledWithoutLayerArn(simulate: boolean): void;
-    /**
-     * Check if an AWS account is entitled to use Lambda Kata.
-     *
-     * This mock implementation returns entitlement status based on
-     * accounts configured via setEntitled().
-     *
-     * @param params - License check parameters or accountId string for backward compatibility
-     * @returns Promise resolving to entitlement status and Layer ARN if entitled
-     *
-     * @remarks
-     * Validates: Requirements 3.2, 3.3
-     * - 3.2: Validates the account's entitlement based on configured entitlements
-     * - 3.3: Returns the customer-specific Layer_ARN if entitled
-     */
-    checkEntitlement(params: LicenseCheckParams | string): Promise<LicensingResponse>;
-    /**
-     * Returns the number of entitled accounts.
-     *
-     * @returns The count of entitled accounts
-     */
-    getEntitlementCount(): number;
-    /**
-     * Checks if a specific account is entitled (without async).
-     *
-     * @param accountId - The AWS account ID to check
-     * @returns true if the account is entitled
-     */
-    isEntitled(accountId: string): boolean;
-    /**
-     * Gets the Layer ARN for an entitled account (without async).
-     *
-     * @param accountId - The AWS account ID
-     * @returns The Layer ARN if entitled, undefined otherwise
-     */
-    getLayerArn(accountId: string): string | undefined;
-}
-/**
- * Creates a MockLicensingService with pre-configured entitlements.
- *
- * @param entitlements - Map of account IDs to Layer ARNs
- * @returns A new MockLicensingService instance with the specified entitlements
- *
- * @example
- * ```typescript
- * const mockService = createMockLicensingService({
- *   '123456789012': 'arn:aws:lambda:us-east-1:999999999999:layer:LambdaKata:1',
- *   '987654321098': 'arn:aws:lambda:us-west-2:999999999999:layer:LambdaKata:2',
- * });
- * ```
- */
-export declare function createMockLicensingService(entitlements?: Record<string, string>): MockLicensingService;