@teaminabottle/domain-cdk-packer 0.1.0

package/dist/lambda-factory.js

@@ -0,0 +1,72 @@
+import * as cdk from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as lambdaNode from 'aws-cdk-lib/aws-lambda-nodejs';
+import * as logs from 'aws-cdk-lib/aws-logs';
+import path from 'node:path';
+/**
+ * Factory for creating CDK NodejsFunction instances from domain registry entries with consistent defaults.
+ */
+export class LambdaFactory {
+    scope;
+    registry;
+    domainRoot;
+    sharedEnv;
+    /**
+     * Create a new LambdaFactory instance.
+     * @param props - Factory configuration
+     */
+    constructor(props) {
+        this.scope = props.scope;
+        this.registry = props.registry;
+        this.domainRoot = props.domainRoot;
+        this.sharedEnv = props.sharedEnv;
+    }
+    /**
+     * Convert a kebab-case or snake_case string to PascalCase.
+     * @param s - Input string
+     * @returns PascalCase string
+     */
+    toPascalCase(s) {
+        return s
+            .split(/[-_]/)
+            .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+            .join('');
+    }
+    /**
+     * Create a NodejsFunction from a registry entry.
+     * @param entry - Registry entry with handlerFile property
+     * @param overrides - Optional deployment configuration overrides
+     * @param extraEnv - Optional extra environment variables
+     * @returns Created NodejsFunction
+     */
+    createFunction(entry, overrides, extraEnv) {
+        const merged = { ...this.registry.domain.defaultDeployment, ...overrides };
+        const architecture = merged.architecture === 'x86_64'
+            ? lambda.Architecture.X86_64
+            : lambda.Architecture.ARM_64;
+        const environment = {
+            DOMAIN_ID: this.registry.domain.id,
+            NODE_OPTIONS: '--enable-source-maps',
+            ...this.sharedEnv,
+            ...extraEnv,
+        };
+        return new lambdaNode.NodejsFunction(this.scope, `${this.toPascalCase(entry.id)}Fn`, {
+            runtime: lambda.Runtime.NODEJS_22_X,
+            architecture,
+            tracing: lambda.Tracing.ACTIVE,
+            logRetention: logs.RetentionDays.ONE_WEEK,
+            memorySize: merged.memory ?? 512,
+            timeout: cdk.Duration.seconds(merged.timeout ?? 30),
+            ...(merged.reservedConcurrency !== undefined
+                ? { reservedConcurrentExecutions: merged.reservedConcurrency }
+                : {}),
+            entry: path.join(this.domainRoot, entry.handlerFile),
+            handler: 'handler',
+            bundling: {
+                externalModules: ['@aws-sdk/*'],
+                sourceMap: true,
+            },
+            environment,
+        });
+    }
+}

package/dist/pack-domain.d.ts

@@ -0,0 +1,30 @@
+import * as cdk from 'aws-cdk-lib';
+import { DomainStack } from './DomainStack.js';
+import type { DomainRegistry } from './registry.js';
+/**
+ * Options for packDomain function.
+ */
+export interface PackDomainOptions {
+    /** Optional CDK environment (account + region). */
+    env?: cdk.Environment;
+    /** Optional Cognito User Pool ARN for JWT-authenticated routes. */
+    userPoolArn?: string;
+    /** Optional Cognito User Pool Client ID — required when userPoolArn is provided. */
+    userPoolClientId?: string;
+    /** Optional database connection URL. */
+    databaseUrl?: string;
+    /** Optional Secrets Manager ARN for database master credentials. */
+    dbSecretArn?: string;
+}
+/**
+ * Convenience entry-point: constructs a DomainStack from a compiled registry.
+ * Intended to be called from a CDK app entrypoint (e.g. bin/app.ts in the project's infra).
+ * Supports both old (env as 5th arg) and new (options object) calling conventions.
+ * @param registry - The compiled domain registry read from .tib/domain-registry.json.
+ * @param app - The CDK App instance.
+ * @param stackId - CloudFormation stack logical ID.
+ * @param eventBusArn - ARN of the named EventBridge event bus for event subscribers.
+ * @param options - Optional configuration (env, userPoolArn, userPoolClientId, databaseUrl, dbSecretArn).
+ * @returns The constructed DomainStack.
+ */
+export declare function packDomain(registry: DomainRegistry, app: cdk.App, stackId: string, eventBusArn: string, options?: PackDomainOptions | cdk.Environment): DomainStack;

package/dist/pack-domain.js

@@ -0,0 +1,30 @@
+import { DomainStack } from './DomainStack.js';
+/**
+ * Convenience entry-point: constructs a DomainStack from a compiled registry.
+ * Intended to be called from a CDK app entrypoint (e.g. bin/app.ts in the project's infra).
+ * Supports both old (env as 5th arg) and new (options object) calling conventions.
+ * @param registry - The compiled domain registry read from .tib/domain-registry.json.
+ * @param app - The CDK App instance.
+ * @param stackId - CloudFormation stack logical ID.
+ * @param eventBusArn - ARN of the named EventBridge event bus for event subscribers.
+ * @param options - Optional configuration (env, userPoolArn, userPoolClientId, databaseUrl, dbSecretArn).
+ * @returns The constructed DomainStack.
+ */
+export function packDomain(registry, app, stackId, eventBusArn, options) {
+    // Support both old (env as 5th arg) and new (options object) calling conventions
+    // Check if options looks like a CDK Environment (has 'account' and/or 'region' props, not the full options interface)
+    const opts = options && typeof options === 'object'
+        && ('account' in options || 'region' in options)
+        && !('userPoolArn' in options || 'userPoolClientId' in options || 'databaseUrl' in options || 'dbSecretArn' in options)
+        ? { env: options }
+        : options || {};
+    return new DomainStack(app, stackId, {
+        registry,
+        eventBusArn,
+        env: opts.env,
+        userPoolArn: opts.userPoolArn,
+        userPoolClientId: opts.userPoolClientId,
+        databaseUrl: opts.databaseUrl,
+        dbSecretArn: opts.dbSecretArn,
+    });
+}

package/dist/pack-flows.d.ts

@@ -0,0 +1,26 @@
+import * as cdk from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import type { FlowRegistry } from './flow-registry.js';
+/** Options for packFlows. */
+export interface PackFlowsOptions {
+    env?: cdk.Environment;
+    /** Map of "{domainId}-{primitiveType}" -> grouped Lambda function ARN. */
+    domainLambdaArns: Record<string, string>;
+    /** EventBridge bus ARN for domain-event steps and triggers. */
+    eventBusArn: string;
+}
+/** CDK stack containing one Step Functions state machine per flow in the registry. */
+export declare class FlowsStack extends cdk.Stack {
+    /** Map of flow id -> SFN ARN. Used by domain Lambdas via FLOWS_SFN_ARN_MAP env var. */
+    readonly flowArnMap: Record<string, string>;
+    constructor(scope: Construct, id: string, props: {
+        registry: FlowRegistry;
+        options: PackFlowsOptions;
+    } & cdk.StackProps);
+    private buildStateMachine;
+    private translateToAsl;
+    private translateStep;
+    private translateFlowControl;
+}
+/** Convenience: construct a FlowsStack from a registry. */
+export declare function packFlows(registry: FlowRegistry, app: cdk.App, stackId: string, options: PackFlowsOptions): FlowsStack;

package/dist/pack-flows.js

@@ -0,0 +1,112 @@
+import * as cdk from 'aws-cdk-lib';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as eventsTargets from 'aws-cdk-lib/aws-events-targets';
+/** CDK stack containing one Step Functions state machine per flow in the registry. */
+export class FlowsStack extends cdk.Stack {
+    /** Map of flow id -> SFN ARN. Used by domain Lambdas via FLOWS_SFN_ARN_MAP env var. */
+    flowArnMap = {};
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const { registry, options } = props;
+        for (const flow of registry.flows) {
+            const stateMachine = this.buildStateMachine(flow, options);
+            this.flowArnMap[flow.id] = stateMachine.stateMachineArn;
+            if (flow.trigger?.type === 'event') {
+                const bus = events.EventBus.fromEventBusArn(this, `${flow.id}TriggerBus`, options.eventBusArn);
+                new events.Rule(this, `${flow.id}TriggerRule`, {
+                    eventBus: bus,
+                    eventPattern: { detailType: [flow.trigger.eventId] },
+                    targets: [new eventsTargets.SfnStateMachine(stateMachine)],
+                });
+            }
+            new cdk.CfnOutput(this, `${flow.id}FlowArn`, {
+                value: stateMachine.stateMachineArn,
+                exportName: `${this.stackName}-flow-${flow.id}`,
+            });
+        }
+    }
+    buildStateMachine(flow, options) {
+        const definition = this.translateToAsl(flow, options);
+        return new sfn.StateMachine(this, `${flow.id}StateMachine`, {
+            stateMachineName: `${this.stackName}-flow-${flow.id}`,
+            definitionBody: sfn.DefinitionBody.fromString(JSON.stringify(definition)),
+            stateMachineType: sfn.StateMachineType.STANDARD,
+        });
+    }
+    translateToAsl(flow, options) {
+        if (flow.steps.length === 0)
+            throw new Error(`packFlows: flow ${flow.id} has no steps`);
+        const states = {};
+        for (const step of flow.steps) {
+            states[step.name] = this.translateStep(step, options, flow.id);
+        }
+        return { StartAt: flow.steps[0].name, States: states };
+    }
+    translateStep(step, options, flowId) {
+        switch (step.type) {
+            case 'domain-action': {
+                const arnKey = `${step.domainId}-action`;
+                const fnArn = options.domainLambdaArns[arnKey];
+                if (!fnArn)
+                    throw new Error(`packFlows: no Lambda ARN for ${arnKey} (flow ${flowId} step ${step.name})`);
+                return {
+                    Type: 'Task',
+                    Resource: 'arn:aws:states:::lambda:invoke',
+                    Parameters: { FunctionName: fnArn, Payload: { actionId: `${step.domainId}.${step.actionId}`, 'input.$': '$', ...(step.parameters ?? {}) } },
+                    ...(step.next ? { Next: step.next } : { End: true }),
+                };
+            }
+            case 'domain-api': {
+                const arnKey = `${step.domainId}-api`;
+                const fnArn = options.domainLambdaArns[arnKey];
+                if (!fnArn)
+                    throw new Error(`packFlows: no Lambda ARN for ${arnKey} (flow ${flowId} step ${step.name})`);
+                return {
+                    Type: 'Task',
+                    Resource: 'arn:aws:states:::lambda:invoke',
+                    Parameters: { FunctionName: fnArn, Payload: { apiId: `${step.domainId}.${step.apiId}`, 'input.$': '$', ...(step.parameters ?? {}) } },
+                    ...(step.next ? { Next: step.next } : { End: true }),
+                };
+            }
+            case 'domain-event': {
+                return {
+                    Type: 'Task',
+                    Resource: 'arn:aws:states:::events:putEvents',
+                    Parameters: {
+                        Entries: [{
+                                EventBusName: options.eventBusArn,
+                                Source: `tib.${step.eventId.split('.')[0]}`,
+                                DetailType: step.eventId,
+                                Detail: JSON.stringify(step.payload),
+                            }],
+                    },
+                    ...(step.next ? { Next: step.next } : { End: true }),
+                };
+            }
+            case 'flow-control':
+                return this.translateFlowControl(step);
+        }
+    }
+    translateFlowControl(step) {
+        switch (step.control) {
+            case 'choice':
+                return { Type: 'Choice', Choices: step.choices.map(c => ({ Variable: '$.path', StringEquals: c.when, Next: c.next })), Default: step.default };
+            case 'parallel':
+                // TODO(#1787): full nested branch translation. For Wave 2, single linear branch only.
+                return { Type: 'Parallel', Branches: step.branches.map(() => ({ StartAt: 'Pass', States: { Pass: { Type: 'Pass', End: true } } })), ...(step.next ? { Next: step.next } : { End: true }) };
+            case 'wait':
+                return { Type: 'Wait', Seconds: step.seconds, ...(step.next ? { Next: step.next } : { End: true }) };
+            case 'succeed':
+                return { Type: 'Succeed' };
+            case 'fail':
+                return { Type: 'Fail', Cause: step.cause, Error: step.error };
+            case 'pass':
+                return { Type: 'Pass', Result: step.result, ...(step.next ? { Next: step.next } : { End: true }) };
+        }
+    }
+}
+/** Convenience: construct a FlowsStack from a registry. */
+export function packFlows(registry, app, stackId, options) {
+    return new FlowsStack(app, stackId, { registry, options, env: options.env });
+}

package/dist/registry.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Serialized JSON Schema representation.
+ */
+export type SchemaSnapshot = Record<string, unknown>;
+/**
+ * Kind discriminant for registry entries.
+ */
+export type RegistryEntryKind = 'api' | 'webhook' | 'subscriber' | 'schedule' | 'job' | 'action' | 'integration' | 'event' | 'domain';
+/**
+ * Plain-value subset of DeploymentConfig for serialization.
+ */
+export interface SerialDeploymentConfig {
+    /** Target deployment strategy: 'single' or 'split'. */
+    target?: 'single' | 'split';
+    /** Lambda memory in MB. */
+    memory?: number;
+    /** Lambda timeout in seconds. */
+    timeout?: number;
+    /** Reserved concurrency limit. */
+    reservedConcurrency?: number;
+    /** CPU architecture. */
+    architecture?: 'arm64' | 'x86_64';
+    /** Isolation level: 'dedicated' creates one Lambda per handler, 'shared' uses grouped Lambdas. */
+    isolation?: 'dedicated' | 'shared';
+}
+/**
+ * Base registry entry with common properties.
+ */
+export interface BaseRegistryEntry {
+    /** Unique identifier. */
+    id: string;
+    /** Entry kind discriminant. */
+    kind: RegistryEntryKind;
+    /** Path to handler file, relative to domain root. */
+    handlerFile?: string;
+}
+/**
+ * API registry entry for HTTP endpoint handlers.
+ */
+export interface ApiRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'api';
+    /** Handler file path (required for API). */
+    handlerFile: string;
+    /** HTTP route path, e.g. '/users/:id'. */
+    path: string;
+    /** HTTP method. */
+    method: string;
+    /** Authentication type. */
+    authType: 'jwt' | 'api-key' | 'none';
+    /** Optional deployment overrides. */
+    deployment?: SerialDeploymentConfig;
+    /** JSON Schema snapshot for the HTTP request body. */
+    requestSchema?: SchemaSnapshot;
+    /** JSON Schema snapshot for the HTTP response body. */
+    responseSchema?: SchemaSnapshot;
+}
+/**
+ * Webhook registry entry for webhook handlers.
+ */
+export interface WebhookRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'webhook';
+    /** Handler file path (required for webhook). */
+    handlerFile: string;
+    /** Webhook path, e.g. '/github/push'. */
+    path: string;
+    /** Webhook provider. */
+    provider: string;
+    /** HMAC algorithm for signature verification. */
+    hmacAlgorithm?: string;
+    /** Reference to HMAC secret in secrets store. */
+    hmacSecretRef?: string;
+    /** Optional deployment overrides. */
+    deployment?: SerialDeploymentConfig;
+}
+/**
+ * Event subscriber registry entry.
+ */
+export interface SubscriberRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'subscriber';
+    /** Handler file path (required for subscriber). */
+    handlerFile: string;
+    /** Event type to subscribe to. */
+    event: string;
+    /** Semver range for event versions. */
+    semverRange: string;
+    /** Concurrency limit for event processing. */
+    concurrency?: number;
+    /** Optional deployment overrides. */
+    deployment?: SerialDeploymentConfig;
+}
+/**
+ * Schedule (cron) registry entry.
+ */
+export interface ScheduleRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'schedule';
+    /** Handler file path (required for schedule). */
+    handlerFile: string;
+    /** Cron expression in AWS EventBridge format. */
+    cron: string;
+    /** Whether the schedule is enabled. */
+    enabled: boolean;
+    /** Optional deployment overrides. */
+    deployment?: SerialDeploymentConfig;
+}
+/**
+ * Background job registry entry.
+ */
+export interface JobRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'job';
+    /** Handler file path (required for job). */
+    handlerFile: string;
+    /** Maximum number of retry attempts. */
+    maxRetries: number;
+    /** Visibility timeout in seconds for SQS message. */
+    visibilityTimeoutSeconds: number;
+    /** Optional deployment overrides. */
+    deployment?: SerialDeploymentConfig;
+}
+/**
+ * Action registry entry for callable domain actions.
+ */
+export interface ActionRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'action';
+    /** Handler file path (required for action). */
+    handlerFile: string;
+    /** Visibility scope: 'private', 'domain', or 'workspace'. */
+    visibility: 'private' | 'domain' | 'workspace';
+    /** Whether the action enforces idempotency. */
+    idempotent: boolean;
+    /** Optional deployment overrides. */
+    deployment?: SerialDeploymentConfig;
+    /** JSON Schema snapshot for the action input. */
+    inputSchema?: SchemaSnapshot;
+    /** JSON Schema snapshot for the action output. */
+    outputSchema?: SchemaSnapshot;
+}
+/**
+ * Integration registry entry for external service integrations.
+ */
+export interface IntegrationRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'integration';
+    /** Base URL of the external service. */
+    baseUrl: string;
+}
+/**
+ * Event registry entry for event type definitions.
+ */
+export interface EventRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'event';
+    /** Event bus name. */
+    busName: string;
+    /** Versioned schemas for this event type. */
+    versions?: Array<{
+        version: number;
+        schema: SchemaSnapshot;
+    }>;
+}
+/**
+ * Domain registry entry representing the domain itself.
+ */
+export interface DomainRegistryEntry extends BaseRegistryEntry {
+    /** Discriminant. */
+    kind: 'domain';
+    /** Human-readable domain name. */
+    name: string;
+    /** Tenancy mode: 'required', 'none', or 'system'. */
+    tenancy: string;
+    /** Optional default deployment configuration for the domain. */
+    defaultDeployment?: SerialDeploymentConfig;
+}
+/**
+ * Union type of all registry entry kinds.
+ */
+export type RegistryEntry = ApiRegistryEntry | WebhookRegistryEntry | SubscriberRegistryEntry | ScheduleRegistryEntry | JobRegistryEntry | ActionRegistryEntry | IntegrationRegistryEntry | EventRegistryEntry | DomainRegistryEntry;
+/**
+ * Top-level domain registry — the compiled snapshot for CDK packer.
+ */
+export interface DomainRegistry {
+    /** Schema version. */
+    schemaVersion: '1';
+    /** Root directory of the domain. */
+    domainRoot: string;
+    /** The domain itself. */
+    domain: DomainRegistryEntry;
+    /** All API endpoints. */
+    apis: ApiRegistryEntry[];
+    /** All webhook receivers. */
+    webhooks: WebhookRegistryEntry[];
+    /** All event subscribers. */
+    subscribers: SubscriberRegistryEntry[];
+    /** All scheduled tasks. */
+    schedules: ScheduleRegistryEntry[];
+    /** All background jobs. */
+    jobs: JobRegistryEntry[];
+    /** All callable actions. */
+    actions: ActionRegistryEntry[];
+    /** All external integrations. */
+    integrations: IntegrationRegistryEntry[];
+    /** All event type definitions. */
+    events: EventRegistryEntry[];
+}

package/dist/registry.js

@@ -0,0 +1 @@
+export {};

package/dist/step-functions-codegen.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A domain-action node from a TIB Flow definition.
+ */
+export interface DomainActionFlowNode {
+    /** Node type discriminant. */
+    type: 'domain-action';
+    /** The domain ID (e.g. 'payments'). */
+    domainId: string;
+    /** The action ID within the domain (e.g. 'charge-card'). */
+    actionId: string;
+    /** Display label for this step. */
+    label?: string;
+    /** Static input parameters merged into the task payload. */
+    parameters?: Record<string, unknown>;
+    /** Step name for the next state (undefined = End). */
+    next?: string;
+}
+/**
+ * A minimal Step Functions ASL Task state for a domain-action node.
+ */
+export interface StepFunctionsTaskState {
+    /** Always 'Task' for Lambda invocations. */
+    Type: 'Task';
+    /** Lambda ARN pattern using the function name and $LATEST alias. */
+    Resource: string;
+    /** Parameters passed to the Lambda. */
+    Parameters?: Record<string, unknown>;
+    /** Next state name. */
+    Next?: string;
+    /** True when there is no Next (terminal state). */
+    End?: true;
+    /** Human-readable comment. */
+    Comment?: string;
+}
+/**
+ * Generates Step Functions ASL Task states for domain-action flow nodes.
+ *
+ * Each domain action maps to a Lambda invoke task targeting the function name
+ * `${domainId}-${actionId}` with the `$LATEST` alias.
+ */
+export declare class StepFunctionsCodegen {
+    /**
+     * Generate a Step Functions ASL Task state for a single domain-action node.
+     *
+     * The Resource ARN uses the intrinsic `arn:aws:states:::lambda:invoke` resource
+     * and a FunctionName parameter of the form `${domainId}-${actionId}`.
+     *
+     * @param node - The domain-action flow node to generate a task state for.
+     * @returns A Step Functions ASL Task state object.
+     */
+    generateTaskState(node: DomainActionFlowNode): StepFunctionsTaskState;
+    /**
+     * Generate a full Step Functions state machine definition from a list of
+     * domain-action nodes. Nodes are ordered by their `next` links; the first
+     * node that has no `next` becomes the terminal state.
+     *
+     * @param nodes - Ordered list of domain-action nodes.
+     * @param startAt - Name of the first state. Defaults to the first node's label or actionId.
+     * @returns A Step Functions state machine definition object.
+     */
+    generateStateMachine(nodes: DomainActionFlowNode[], startAt?: string): {
+        StartAt: string;
+        States: Record<string, StepFunctionsTaskState>;
+    };
+}

package/dist/step-functions-codegen.js

@@ -0,0 +1,55 @@
+/**
+ * Generates Step Functions ASL Task states for domain-action flow nodes.
+ *
+ * Each domain action maps to a Lambda invoke task targeting the function name
+ * `${domainId}-${actionId}` with the `$LATEST` alias.
+ */
+export class StepFunctionsCodegen {
+    /**
+     * Generate a Step Functions ASL Task state for a single domain-action node.
+     *
+     * The Resource ARN uses the intrinsic `arn:aws:states:::lambda:invoke` resource
+     * and a FunctionName parameter of the form `${domainId}-${actionId}`.
+     *
+     * @param node - The domain-action flow node to generate a task state for.
+     * @returns A Step Functions ASL Task state object.
+     */
+    generateTaskState(node) {
+        const functionName = `${node.domainId}-${node.actionId}`;
+        const state = {
+            Type: 'Task',
+            Resource: 'arn:aws:states:::lambda:invoke',
+            Parameters: {
+                FunctionName: functionName,
+                'Payload.$': '$',
+                ...(node.parameters ?? {}),
+            },
+            Comment: node.label ?? `Invoke domain action ${node.domainId}/${node.actionId}`,
+        };
+        if (node.next) {
+            state.Next = node.next;
+        }
+        else {
+            state.End = true;
+        }
+        return state;
+    }
+    /**
+     * Generate a full Step Functions state machine definition from a list of
+     * domain-action nodes. Nodes are ordered by their `next` links; the first
+     * node that has no `next` becomes the terminal state.
+     *
+     * @param nodes - Ordered list of domain-action nodes.
+     * @param startAt - Name of the first state. Defaults to the first node's label or actionId.
+     * @returns A Step Functions state machine definition object.
+     */
+    generateStateMachine(nodes, startAt) {
+        const states = {};
+        for (const node of nodes) {
+            const stateName = node.label ?? `${node.domainId}/${node.actionId}`;
+            states[stateName] = this.generateTaskState(node);
+        }
+        const firstStateName = startAt ?? (nodes[0] ? (nodes[0].label ?? `${nodes[0].domainId}/${nodes[0].actionId}`) : 'Start');
+        return { StartAt: firstStateName, States: states };
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@teaminabottle/domain-cdk-packer",
+  "version": "0.1.0",
+  "type": "module",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": ["dist"],
+  "exports": {
+    ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.0.0",
+    "constructs": "^10.0.0"
+  },
+  "devDependencies": {
+    "aws-cdk-lib": "^2.100.0",
+    "constructs": "^10.3.0",
+    "esbuild": "^0.21.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "dependencies": {}
+}