cloudstructs 0.12.7 → 0.12.9

package/lib/toolkit-cleaner/index.js

@@ -50,11 +50,11 @@ class ToolkitCleaner extends constructs_1.Construct {
         new aws_scheduler_1.Schedule(this, 'Schedule', {
             enabled: props.scheduleEnabled ?? true,
             schedule: props.scheduleExpression ?? aws_scheduler_1.ScheduleExpression.rate(aws_cdk_lib_1.Duration.days(1)),
-            target: new aws_scheduler_targets_1.LambdaInvoke(cleanFunction, {}),
+            target: new aws_scheduler_targets_1.LambdaInvoke(cleanFunction.latestVersion, {}),
         });
     }
 }
 exports.ToolkitCleaner = ToolkitCleaner;
 _a = JSII_RTTI_SYMBOL_1;
-ToolkitCleaner[_a] = { fqn: "cloudstructs.ToolkitCleaner", version: "0.12.7" };
-//# sourceMappingURL=data:application/json;base64,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
+ToolkitCleaner[_a] = { fqn: "cloudstructs.ToolkitCleaner", version: "0.12.9" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/url-shortener/index.js

@@ -132,5 +132,5 @@ class UrlShortener extends constructs_1.Construct {
 }
 exports.UrlShortener = UrlShortener;
 _a = JSII_RTTI_SYMBOL_1;
-UrlShortener[_a] = { fqn: "cloudstructs.UrlShortener", version: "0.12.7" };
+UrlShortener[_a] = { fqn: "cloudstructs.UrlShortener", version: "0.12.9" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/url-shortener/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, Fn, RemovalPolicy } from 'aws-cdk-lib';\nimport * as apigateway from 'aws-cdk-lib/aws-apigateway';\nimport * as acm from 'aws-cdk-lib/aws-certificatemanager';\nimport * as cloudfront from 'aws-cdk-lib/aws-cloudfront';\nimport * as origins from 'aws-cdk-lib/aws-cloudfront-origins';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as route53 from 'aws-cdk-lib/aws-route53';\nimport * as targets from 'aws-cdk-lib/aws-route53-targets';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport { Construct } from 'constructs';\nimport { RedirectFunction } from './redirect-function';\nimport { ShortenerFunction } from './shortener-function';\n\n/**\n * Properties for a UrlShortener\n */\nexport interface UrlShortenerProps {\n  /**\n   * The hosted zone for the short URLs domain\n   */\n  readonly hostedZone: route53.IHostedZone;\n\n  /**\n   * The ACM certificate to use for the CloudFront distribution.\n   * Must be in us-east-1.\n   */\n  readonly certificate: acm.ICertificate;\n\n  /**\n   * The record name to use in the hosted zone\n   *\n   * @default - zone root\n   */\n  readonly recordName?: string;\n\n  /**\n   * Expiration for short urls\n   *\n   * @default cdk.Duration.days(365)\n   */\n  readonly expiration?: Duration;\n\n  /**\n   * An interface VPC endpoint for API gateway. Specifying this property will\n   * make the API private.\n   *\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html\n   *\n   * @default - API is public\n   */\n  readonly apiGatewayEndpoint?: ec2.IInterfaceVpcEndpoint;\n\n  /**\n   * Authorizer for API gateway.\n   *\n   * @default - do not use an authorizer for the API\n   */\n  readonly apiGatewayAuthorizer?: apigateway.IAuthorizer;\n\n  /**\n   * Whether to use IAM authorization\n   *\n   * @default - do not use IAM authorization\n   */\n  readonly iamAuthorization?: boolean;\n\n  /**\n   * Allowed origins for CORS\n   *\n   * @default - CORS is not enabled\n   */\n  readonly corsAllowOrigins?: string[];\n\n  /**\n   * A name for the bucket saving the redirects\n   *\n   * @default - derived from short link domain name\n   */\n  readonly bucketName?: string;\n}\n\n/**\n * URL shortener\n */\nexport class UrlShortener extends Construct {\n  /**\n   * The endpoint of the URL shortener API\n   */\n  public readonly apiEndpoint: string;\n\n  /**\n   * The underlying API Gateway REST API\n   */\n  public readonly api: apigateway.RestApi;\n\n  private readonly iamAuthorization?: boolean;\n\n  constructor(scope: Construct, id: string, props: UrlShortenerProps) {\n    super(scope, id);\n\n    const domainName = props.recordName ? `${props.recordName}.${props.hostedZone.zoneName}` : props.hostedZone.zoneName;\n\n    // Table to save a counter\n    const table = new dynamodb.Table(this, 'Table', {\n      partitionKey: {\n        name: 'key',\n        type: dynamodb.AttributeType.STRING,\n      },\n      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,\n      removalPolicy: RemovalPolicy.DESTROY,\n    });\n\n    // Bucket to save redirects\n    const bucket = new s3.Bucket(this, 'Bucket', {\n      lifecycleRules: [{\n        expiration: props.expiration ?? Duration.days(365),\n      }],\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n      bucketName: props.bucketName ?? `cloudstructs-url-shortener-${domainName}`,\n    });\n\n    // Redirect function\n    const redirectFunction = new RedirectFunction(this, 'Redirect', {\n      environment: {\n        BUCKET_NAME: bucket.bucketName,\n      },\n    });\n    bucket.grantRead(redirectFunction);\n\n    const distribution = new cloudfront.Distribution(this, 'Distribution', {\n      defaultBehavior: {\n        origin: origins.FunctionUrlOrigin.withOriginAccessControl(redirectFunction.addFunctionUrl()),\n      },\n      certificate: props.certificate,\n      domainNames: [domainName],\n      httpVersion: cloudfront.HttpVersion.HTTP2_AND_3,\n    });\n\n    // Route53 records\n    const aliasProps = {\n      zone: props.hostedZone,\n      target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),\n      recordName: props.recordName,\n    };\n    new route53.ARecord(this, 'ARecord', aliasProps);\n    new route53.AaaaRecord(this, 'AaaaRecord', aliasProps);\n    new route53.HttpsRecord(this, 'HttpsRecord', aliasProps);\n\n    // Lambda function to increment counter and write redirect in bucket\n    const shortenerFunction = new ShortenerFunction(this, 'Shortener', {\n      logRetention: logs.RetentionDays.ONE_MONTH,\n      environment: {\n        DOMAIN_NAME: domainName,\n        BUCKET_NAME: bucket.bucketName,\n        TABLE_NAME: table.tableName,\n      },\n    });\n    if (props.corsAllowOrigins) {\n      shortenerFunction.addEnvironment('CORS_ALLOW_ORIGINS', props.corsAllowOrigins.join(' '));\n    }\n    bucket.grantPut(shortenerFunction);\n    table.grant(shortenerFunction, 'dynamodb:UpdateItem');\n\n    // API\n    this.api = new apigateway.RestApi(this, `UrlShortener${props.hostedZone.zoneName}`, {\n      endpointTypes: props.apiGatewayEndpoint ? [apigateway.EndpointType.PRIVATE] : undefined,\n      policy: props.apiGatewayEndpoint\n        ? new iam.PolicyDocument({\n          statements: [\n            new iam.PolicyStatement({\n              effect: iam.Effect.ALLOW,\n              actions: ['execute-api:Invoke'],\n              principals: [new iam.AnyPrincipal()],\n              resources: [Fn.join('', ['execute-api:/', '*'])],\n              conditions: {\n                StringEquals: { 'aws:SourceVpce': props.apiGatewayEndpoint.vpcEndpointId },\n              },\n            }),\n          ],\n        })\n        : undefined,\n      defaultCorsPreflightOptions: props.corsAllowOrigins\n        ? { allowOrigins: props.corsAllowOrigins }\n        : undefined,\n    });\n\n    if (props.iamAuthorization && props.apiGatewayAuthorizer) {\n      throw new Error('Cannot use both IAM authorization and an authorizer');\n    }\n\n    this.iamAuthorization = props.iamAuthorization;\n\n    this.api.root.addMethod('POST', new apigateway.LambdaIntegration(shortenerFunction), {\n      authorizer: props.apiGatewayAuthorizer,\n      authorizationType: props.iamAuthorization ? apigateway.AuthorizationType.IAM : undefined,\n    });\n    this.api.root\n      .addResource('{proxy+}')\n      .addMethod('POST', new apigateway.LambdaIntegration(shortenerFunction), {\n        authorizer: props.apiGatewayAuthorizer,\n        authorizationType: this.iamAuthorization ? apigateway.AuthorizationType.IAM : undefined,\n      });\n\n    this.apiEndpoint = this.api.url;\n  }\n\n  /**\n   * Grant access to invoke the URL shortener if protected by IAM authorization\n   */\n  public grantInvoke(grantee: iam.IGrantable): iam.Grant {\n    if (this.iamAuthorization === false) {\n      throw new Error('The URL shortener is not protected by IAM authorization');\n    }\n\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: ['execute-api:Invoke'],\n      resourceArns: [`arn:aws:execute-api:${this.api.env.region}:${this.api.env.account}:${this.api.restApiId}/${this.api.deploymentStage.stageName}/POST/*`],\n    });\n  }\n}\n"]}

package/node_modules/@aws/durable-execution-sdk-js/README.md

@@ -285,17 +285,37 @@ Control execution guarantees:
 ```typescript
 import { StepSemantics } from "@aws/durable-execution-sdk-js";
 
-// At-most-once per retry (default)
+// At-least-once per retry (default)
+await context.step("retriable-operation", async () => sendNotification(), {
+  semantics: StepSemantics.AtLeastOncePerRetry,
+});
+
+// At-most-once per retry
 await context.step("idempotent-operation", async () => updateDatabase(), {
   semantics: StepSemantics.AtMostOncePerRetry,
 });
+```
 
-// At-least-once per retry
-await context.step("retriable-operation", async () => sendNotification(), {
-  semantics: StepSemantics.AtLeastOncePerRetry,
-});
+**Important**: These semantics apply _per retry_, not per overall execution:
+
+- **AtLeastOncePerRetry**: The step will execute at least once on each retry attempt. If the step succeeds but the checkpoint fails (e.g., sandbox crash), the step will re-execute on replay.
+- **AtMostOncePerRetry**: The step will execute at most once per retry attempt. A checkpoint is created before execution, so if a failure occurs after the checkpoint but before step completion, the previous step retry attempt is skipped on replay.
+
+**To achieve at-most-once semantics on a step-level**, use a custom retry strategy:
+
+```typescript
+await context.step(
+  "truly-once-only",
+  async () => callThatCannotTolerateDuplicates(),
+  {
+    semantics: StepSemantics.AtMostOncePerRetry,
+    retryStrategy: () => ({ shouldRetry: false }), // No retries
+  },
+);
 ```
 
+Without this, a step using `AtMostOncePerRetry` with retries enabled could still execute multiple times across different retry attempts.
+
 ### Jitter Strategies
 
 Prevent thundering herd:

package/node_modules/@aws/durable-execution-sdk-js/dist/index.mjs

@@ -165,11 +165,56 @@ var DurableLogLevel;
 })(DurableLogLevel || (DurableLogLevel = {}));
 
 /**
+ * Execution semantics for step operations.
+ *
+ * @remarks
+ * These semantics control how step execution is checkpointed and replayed. **Important**: The guarantees apply *per
+ * retry attempt*, not per overall workflow execution.
+ *
+ * With retries enabled (the default), a step could execute multiple times across different retry attempts even when
+ * using `AtMostOncePerRetry`. To achieve step-level at-most-once execution, combine `AtMostOncePerRetry` with a retry
+ * strategy that disables retries (`shouldRetry: false`).
+ *
+ * @example
+ * ```typescript
+ * // At-least-once per retry (default) - safe for idempotent operations
+ * await context.step("send-notification", async () => sendEmail(), {
+ *   semantics: StepSemantics.AtLeastOncePerRetry,
+ * });
+ *
+ * // At-most-once per retry - for non-idempotent operations
+ * await context.step("charge-payment", async () => processPayment(), {
+ *   semantics: StepSemantics.AtMostOncePerRetry,
+ *   retryStrategy: () => ({ shouldRetry: false }),
+ * });
+ * ```
+ *
  * @public
  */
 var StepSemantics;
 (function (StepSemantics) {
+    /**
+     * At-most-once execution per retry attempt.
+     *
+     * @remarks
+     * A checkpoint is created before step execution. If a failure occurs after the checkpoint
+     * but before step completion, the previous step retry attempt is skipped on replay.
+     *
+     * **Note**: This is "at-most-once *per retry*". With multiple retry attempts, the step
+     * could still execute multiple times across different retries. To guarantee the step
+     * executes at most once, disable retries by returning
+     * `{ shouldRetry: false }` from your retry strategy.
+     */
     StepSemantics["AtMostOncePerRetry"] = "AT_MOST_ONCE_PER_RETRY";
+    /**
+     * At-least-once execution per retry attempt (default).
+     *
+     * @remarks
+     * The step will execute at least once on each retry attempt. If the step succeeds
+     * but the checkpoint fails (e.g., due to a sandbox crash), the step will re-execute
+     * on replay. This is the safer default for operations that are idempotent or can
+     * tolerate duplicate execution.
+     */
     StepSemantics["AtLeastOncePerRetry"] = "AT_LEAST_ONCE_PER_RETRY";
 })(StepSemantics || (StepSemantics = {}));
 /**
@@ -2794,7 +2839,13 @@ class ConcurrencyController {
                     tryStartNext();
                 }
             };
-            tryStartNext();
+            if (items.length === 0) {
+                log("🎉", `${this.operationName} completed with no items`);
+                resolve(new BatchResultImpl([], getCompletionReason(0)));
+            }
+            else {
+                tryStartNext();
+            }
         });
     }
 }
@@ -3232,6 +3283,13 @@ class CheckpointUnrecoverableExecutionError extends UnrecoverableExecutionError
 }
 
 const STEP_DATA_UPDATED_EVENT = "stepDataUpdated";
+const TERMINAL_STATUSES = [
+    OperationStatus.SUCCEEDED,
+    OperationStatus.CANCELLED,
+    OperationStatus.FAILED,
+    OperationStatus.STOPPED,
+    OperationStatus.TIMED_OUT,
+];
 class CheckpointManager {
     durableExecutionArn;
     stepData;
@@ -3246,6 +3304,7 @@ class CheckpointManager {
     forceCheckpointPromises = [];
     queueCompletionResolver = null;
     MAX_PAYLOAD_SIZE = 750 * 1024; // 750KB in bytes
+    MAX_ITEMS_IN_BATCH = 250;
     isTerminating = false;
     static textEncoder = new TextEncoder();
     // Operation lifecycle tracking
@@ -3407,7 +3466,9 @@ class CheckpointManager {
         while (this.queue.length > 0) {
             const nextItem = this.queue[0];
             const itemSize = CheckpointManager.textEncoder.encode(JSON.stringify(nextItem)).length;
-            if (currentSize + itemSize > this.MAX_PAYLOAD_SIZE && batch.length > 0) {
+            if ((currentSize + itemSize > this.MAX_PAYLOAD_SIZE ||
+                batch.length >= this.MAX_ITEMS_IN_BATCH) &&
+                batch.length > 0) {
                 break;
             }
             this.queue.shift();
@@ -3589,6 +3650,11 @@ class CheckpointManager {
         if (op.state !== OperationLifecycleState.RETRY_WAITING) {
             throw new Error(`Operation ${stepId} must be in RETRY_WAITING state, got ${op.state}`);
         }
+        // Resolve immediately if the step was completed already
+        const stepData = this.stepData[hashId(stepId)];
+        if (stepData?.Status && TERMINAL_STATUSES.includes(stepData.Status)) {
+            return Promise.resolve();
+        }
         // Start timer with polling
         this.startTimerWithPolling(stepId, op.endTimestamp);
         // Return promise that resolves when status changes
@@ -3604,6 +3670,11 @@ class CheckpointManager {
         if (op.state !== OperationLifecycleState.IDLE_AWAITED) {
             throw new Error(`Operation ${stepId} must be in IDLE_AWAITED state, got ${op.state}`);
         }
+        // Resolve immediately if the step was completed already
+        const stepData = this.stepData[hashId(stepId)];
+        if (stepData?.Status && TERMINAL_STATUSES.includes(stepData.Status)) {
+            return Promise.resolve();
+        }
         // Start timer with polling
         this.startTimerWithPolling(stepId, op.endTimestamp);
         // Return promise that resolves when status changes
@@ -3653,28 +3724,28 @@ class CheckpointManager {
             op.resolver = undefined;
         }
     }
-    checkAndTerminate() {
+    /**
+     * Determines if the function should terminate.
+     * @returns TerminationReason if the function should terminate, or undefined if the function should not terminate
+     */
+    shouldTerminate() {
         // Rule 1: Can't terminate if checkpoint queue is not empty
         if (this.queue.length > 0) {
-            this.abortTermination();
-            return;
+            return undefined;
         }
         // Rule 2: Can't terminate if checkpoint is currently processing
         if (this.isProcessing) {
-            this.abortTermination();
-            return;
+            return undefined;
         }
         // Rule 3: Can't terminate if there are pending force checkpoint promises
         if (this.forceCheckpointPromises.length > 0) {
-            this.abortTermination();
-            return;
+            return undefined;
         }
         const allOps = Array.from(this.operations.values());
         // Rule 4: Can't terminate if any operation is EXECUTING
         const hasExecuting = allOps.some((op) => op.state === OperationLifecycleState.EXECUTING);
         if (hasExecuting) {
-            this.abortTermination();
-            return;
+            return undefined;
         }
         // Rule 5: Clean up operations whose ancestors are complete or pending completion
         for (const op of allOps) {
@@ -3697,12 +3768,17 @@ class CheckpointManager {
             op.state === OperationLifecycleState.IDLE_NOT_AWAITED ||
             op.state === OperationLifecycleState.IDLE_AWAITED);
         if (hasWaiting) {
-            const reason = this.determineTerminationReason(remainingOps);
-            this.scheduleTermination(reason);
+            return this.determineTerminationReason(remainingOps);
         }
-        else {
-            this.abortTermination();
+        return undefined;
+    }
+    checkAndTerminate() {
+        const terminationReason = this.shouldTerminate();
+        if (terminationReason) {
+            this.scheduleTermination(terminationReason);
+            return;
         }
+        this.abortTermination();
     }
     abortTermination() {
         if (this.terminationTimer) {
@@ -3726,6 +3802,11 @@ class CheckpointManager {
             cooldownMs: this.TERMINATION_COOLDOWN_MS,
         });
         this.terminationTimer = setTimeout(() => {
+            if (!this.shouldTerminate()) {
+                log("🔄", "Termination conditions no longer valid after cooldown, aborting termination");
+                this.abortTermination();
+                return;
+            }
             this.executeTermination(reason);
         }, this.TERMINATION_COOLDOWN_MS);
     }
@@ -4477,16 +4558,10 @@ async function runHandler(event, context, executionContext, durableExecutionMode
  * Validates that the event is a proper durable execution input
  */
 function validateDurableExecutionEvent(event) {
-    try {
-        const eventObj = event;
-        if (!eventObj?.DurableExecutionArn || !eventObj?.CheckpointToken) {
-            throw new Error("Missing required durable execution fields");
-        }
-    }
-    catch {
-        const msg = `Unexpected payload provided to start the durable execution. 
-Check your resource configurations to confirm the durability is set.`;
-        throw new Error(msg);
+    const eventObj = event;
+    if (!eventObj?.DurableExecutionArn || !eventObj?.CheckpointToken) {
+        throw new Error("Unexpected payload provided to start the durable execution.\n" +
+            "Check your resource configurations to confirm the durability is set.");
     }
 }
 /**
@@ -4564,14 +4639,7 @@ const withDurableExecution = (handler, config) => {
     return async (event, context) => {
         validateDurableExecutionEvent(event);
         const { executionContext, durableExecutionMode, checkpointToken } = await initializeExecutionContext(event, context, config?.client);
-        let response = null;
-        try {
-            response = await runHandler(event, context, executionContext, durableExecutionMode, checkpointToken, handler);
-            return response;
-        }
-        catch (err) {
-            throw err;
-        }
+        return runHandler(event, context, executionContext, durableExecutionMode, checkpointToken, handler);
     };
 };