@sst-community/sst 0.0.0-placeholder.0 → 4.17.2

package/dist/aws/workflow.js

@@ -0,0 +1,504 @@
+import * as durable from "@aws/durable-execution-sdk-js";
+import { awsFetch } from "./client.js";
+/**
+ * The `workflow` SDK is a thin wrapper around the
+ * [`@aws/durable-execution-sdk-js`](https://www.npmjs.com/package/@aws/durable-execution-sdk-js)
+ * package and the AWS Lambda durable execution APIs.
+ *
+ * SST also adds a few helpers on top, including `ctx.stepWithRollback()`,
+ * `ctx.rollbackAll()`, and `ctx.waitUntil()`.
+ *
+ * @example
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ * ```
+ *
+ * @example
+ * Use `stepWithRollback()` and `rollbackAll()` to register compensating actions.
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(async (_event, ctx) => {
+ *   try {
+ *     const order = await ctx.stepWithRollback("create-order", {
+ *       run: async () => ({ orderId: "order_123" }),
+ *       undo: async (error, result) => {
+ *         await fetch(`https://example.com/orders/${result.orderId}`, {
+ *           method: "DELETE",
+ *         });
+ *       },
+ *     });
+ *
+ *     await ctx.step("charge-card", async () => {
+ *       throw new Error("Card declined");
+ *     });
+ *
+ *     return order;
+ *   } catch (error) {
+ *     await ctx.rollbackAll(error);
+ *     throw error;
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * Use `waitUntil()` when you already know the exact time the workflow should resume.
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(
+ *   async (_event, ctx) => {
+ *     const resumeAt = new Date();
+ *     resumeAt.setMinutes(resumeAt.getMinutes() + 10);
+ *
+ *     await ctx.waitUntil("wait-for-follow-up", resumeAt);
+ *
+ *     return ctx.step("send-follow-up", async () => {
+ *       return { delivered: true };
+ *     });
+ *   },
+ * );
+ * ```
+ */
+export var workflow;
+(function (workflow) {
+    /**
+     * Create a durable workflow handler.
+     *
+     * @example
+     * ```ts title="src/workflow.ts"
+     * import { workflow } from "sst/aws/workflow";
+     *
+     * export const handler = workflow.handler(
+     *   async (_event, ctx) => {
+     *     const user = await ctx.step("load-user", async () => {
+     *       return { id: "user_123", email: "alice@example.com" };
+     *     });
+     *
+     *     await ctx.wait("pause-before-email", "1 minute");
+     *
+     *     return ctx.step("send-email", async () => {
+     *       return { sent: true, userId: user.id };
+     *     });
+     *   },
+     * );
+     * ```
+     */
+    function handler(input, config) {
+        return durable.withDurableExecution((event, context) => input(event, withRollback(context)), config);
+    }
+    workflow.handler = handler;
+    /**
+     * Start a new workflow execution.
+     *
+     * This is the equivalent to calling
+     * [`Invoke`](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)
+     * for a durable Lambda function, using the durable invocation flow described in
+     * [Invoking durable Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/durable-invoking.html).
+     */
+    async function start(resource, input, options) {
+        const query = new URLSearchParams({
+            Qualifier: resource.qualifier,
+        });
+        const response = await awsFetch("lambda", `/2015-03-31/functions/${encodeURIComponent(resource.name)}/invocations?${query.toString()}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Amz-Durable-Execution-Name": input.name,
+                "X-Amz-Invocation-Type": "Event",
+            },
+            body: input.payload === undefined
+                ? undefined
+                : JSON.stringify(input.payload),
+        }, options);
+        if (!response.ok)
+            throw new StartError(response);
+        return {
+            arn: response.headers.get("X-Amz-Durable-Execution-Arn") ?? undefined,
+            statusCode: response.status,
+            version: response.headers.get("X-Amz-Executed-Version") ?? undefined,
+        };
+    }
+    workflow.start = start;
+    /**
+     * List workflow executions.
+     *
+     * The SDK returns only the first page of results.
+     */
+    async function list(resource, query, options) {
+        const startedAfter = query.createdAt?.from?.toISOString();
+        const startedBefore = query.createdAt?.to?.toISOString();
+        const direction = query.createdAt?.order ?? "asc";
+        const status = query.status;
+        if (startedAfter && startedBefore && startedAfter > startedBefore) {
+            throw new TypeError("workflow.list createdAt.from must be before createdAt.to");
+        }
+        if (direction !== "asc" && direction !== "desc") {
+            throw new TypeError(`Unsupported workflow order direction '${direction}'`);
+        }
+        const params = new URLSearchParams({
+            MaxItems: String(workflowListPageSize),
+            Qualifier: resource.qualifier,
+        });
+        if (Array.isArray(status)) {
+            throw new TypeError("workflow.list status must be a single status");
+        }
+        if (status)
+            params.append("Statuses", status);
+        if (startedAfter)
+            params.set("StartedAfter", startedAfter);
+        if (startedBefore)
+            params.set("StartedBefore", startedBefore);
+        if (direction === "desc")
+            params.set("ReverseOrder", "true");
+        const response = await awsFetch("lambda", `/2025-12-01/functions/${encodeURIComponent(resource.name)}/durable-executions?${params.toString()}`, {
+            method: "GET",
+        }, options);
+        if (!response.ok)
+            throw new ListError(response);
+        const data = (await response.json());
+        const executions = Array.isArray(data.DurableExecutions)
+            ? data.DurableExecutions
+            : [];
+        return {
+            executions: executions.map(parseExecution),
+        };
+    }
+    workflow.list = list;
+    /**
+     * Get the details for a single workflow execution.
+     */
+    async function describe(arn, options) {
+        const response = await awsFetch("lambda", `/2025-12-01/durable-executions/${encodeURIComponent(arn)}`, {
+            method: "GET",
+        }, options);
+        if (!response.ok)
+            throw new DescribeError(response);
+        const data = (await response.json());
+        if (!data.DurableExecutionArn ||
+            !data.DurableExecutionName ||
+            !data.FunctionArn ||
+            data.StartTimestamp === undefined ||
+            data.Status === undefined) {
+            throw new DescribeError(response);
+        }
+        const execution = parseExecution(data);
+        return {
+            ...execution,
+            version: data.Version,
+        };
+    }
+    workflow.describe = describe;
+    /**
+     * Stop a running workflow execution.
+     */
+    async function stop(arn, input, options) {
+        const response = await awsFetch("lambda", `/2025-12-01/durable-executions/${encodeURIComponent(arn)}/stop`, {
+            method: "POST",
+            headers: input?.error
+                ? {
+                    "Content-Type": "application/json",
+                }
+                : undefined,
+            body: input?.error === undefined
+                ? undefined
+                : JSON.stringify(normalizeError(input.error)),
+        }, options);
+        if (!response.ok)
+            throw new StopError(response);
+        const data = (await response.json());
+        return {
+            arn,
+            status: "STOPPED",
+            stoppedAt: data.StopTimestamp === undefined
+                ? undefined
+                : parseTimestamp(data.StopTimestamp),
+        };
+    }
+    workflow.stop = stop;
+    /**
+     * Send a successful result for a pending workflow callback.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackSuccess`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackSuccess.html).
+     */
+    async function succeed(token, input = {}, options) {
+        const response = await awsFetch("lambda", `/2025-12-01/durable-execution-callbacks/${encodeURIComponent(token)}/succeed`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: input.payload === undefined
+                ? undefined
+                : JSON.stringify(input.payload),
+        }, options);
+        if (!response.ok)
+            throw new SucceedError(response);
+    }
+    workflow.succeed = succeed;
+    /**
+     * Send a failure result for a pending workflow callback.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackFailure`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackFailure.html).
+     */
+    async function fail(token, input, options) {
+        const response = await awsFetch("lambda", `/2025-12-01/durable-execution-callbacks/${encodeURIComponent(token)}/fail`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(normalizeError(input.error)),
+        }, options);
+        if (!response.ok)
+            throw new FailError(response);
+    }
+    workflow.fail = fail;
+    /**
+     * Send a heartbeat for a pending workflow callback.
+     *
+     * This is useful when the external system handling the callback is still doing
+     * work and needs to prevent the callback from timing out.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackHeartbeat`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackHeartbeat.html).
+     */
+    async function heartbeat(token, options) {
+        const response = await awsFetch("lambda", `/2025-12-01/durable-execution-callbacks/${encodeURIComponent(token)}/heartbeat`, {
+            method: "POST",
+        }, options);
+        if (!response.ok)
+            throw new HeartbeatError(response);
+    }
+    workflow.heartbeat = heartbeat;
+    class StartError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to start workflow");
+            this.response = response;
+        }
+    }
+    workflow.StartError = StartError;
+    class ListError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to list workflows");
+            this.response = response;
+        }
+    }
+    workflow.ListError = ListError;
+    class DescribeError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to describe workflow");
+            this.response = response;
+        }
+    }
+    workflow.DescribeError = DescribeError;
+    class StopError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to stop workflow");
+            this.response = response;
+        }
+    }
+    workflow.StopError = StopError;
+    class SucceedError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to succeed workflow callback");
+            this.response = response;
+        }
+    }
+    workflow.SucceedError = SucceedError;
+    class FailError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to fail workflow callback");
+            this.response = response;
+        }
+    }
+    workflow.FailError = FailError;
+    class HeartbeatError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to heartbeat workflow callback");
+            this.response = response;
+        }
+    }
+    workflow.HeartbeatError = HeartbeatError;
+    class RollbackError extends Error {
+        stepName;
+        originalError;
+        undoError;
+        constructor(stepName, originalError, undoError) {
+            super(`Failed to rollback workflow step '${stepName}': ${undoError instanceof Error ? undoError.message : String(undoError)}`);
+            this.stepName = stepName;
+            this.originalError = originalError;
+            this.undoError = undoError;
+            this.name = "RollbackError";
+        }
+    }
+    workflow.RollbackError = RollbackError;
+})(workflow || (workflow = {}));
+const workflowListPageSize = 1000;
+const rollbackStateSymbol = Symbol("sst.workflow.rollback.state");
+function normalizeError(error) {
+    function serializeErrorData(input) {
+        if (input === undefined)
+            return undefined;
+        if (typeof input === "string")
+            return input;
+        try {
+            return JSON.stringify(input);
+        }
+        catch {
+            return String(input);
+        }
+    }
+    function normalizeStack(input) {
+        if (typeof input === "string") {
+            return input.split("\n").map((line) => line.trim());
+        }
+        if (Array.isArray(input))
+            return input.map(String);
+        return undefined;
+    }
+    if (error === undefined) {
+        return {
+            ErrorMessage: "Callback failed",
+            ErrorType: "Error",
+        };
+    }
+    if (error instanceof Error) {
+        const { message, name, stack, ...rest } = error;
+        return {
+            ErrorMessage: message,
+            ErrorType: name,
+            ErrorData: Object.keys(rest).length
+                ? serializeErrorData(rest)
+                : undefined,
+            StackTrace: normalizeStack(stack),
+        };
+    }
+    if (typeof error === "string") {
+        return {
+            ErrorMessage: error,
+            ErrorType: "Error",
+        };
+    }
+    if (error === null || typeof error !== "object") {
+        return {
+            ErrorMessage: String(error),
+            ErrorType: "Error",
+        };
+    }
+    const value = error;
+    const { data, message, name, stack, type, ...rest } = value;
+    const hasKnownFields = message !== undefined ||
+        name !== undefined ||
+        type !== undefined ||
+        data !== undefined ||
+        stack !== undefined;
+    return {
+        ErrorMessage: typeof message === "string" ? message : "Callback failed",
+        ErrorType: typeof type === "string"
+            ? type
+            : typeof name === "string"
+                ? name
+                : "Error",
+        ErrorData: data !== undefined
+            ? serializeErrorData(data)
+            : Object.keys(rest).length
+                ? serializeErrorData(rest)
+                : hasKnownFields
+                    ? undefined
+                    : serializeErrorData(error),
+        StackTrace: normalizeStack(stack),
+    };
+}
+function parseExecution(execution) {
+    return {
+        arn: execution.DurableExecutionArn,
+        name: execution.DurableExecutionName,
+        functionArn: execution.FunctionArn,
+        status: execution.Status,
+        createdAt: parseTimestamp(execution.StartTimestamp),
+        endedAt: execution.EndTimestamp === undefined
+            ? undefined
+            : parseTimestamp(execution.EndTimestamp),
+    };
+}
+function parseTimestamp(timestamp) {
+    const value = typeof timestamp === "number" ? timestamp : Number(timestamp);
+    if (Number.isFinite(value)) {
+        return new Date(value < 1_000_000_000_000 ? value * 1000 : value);
+    }
+    return new Date(timestamp);
+}
+function resolveWaitUntilDuration(until) {
+    const timestamp = until.getTime();
+    if (!Number.isFinite(timestamp)) {
+        throw new TypeError("waitUntil requires a valid Date");
+    }
+    return {
+        seconds: Math.max(0, Math.ceil((timestamp - Date.now()) / 1000)),
+    };
+}
+function withRollback(context) {
+    const wrapped = context;
+    if (wrapped[rollbackStateSymbol])
+        return wrapped;
+    const rollbackState = { undoStack: [] };
+    wrapped[rollbackStateSymbol] = rollbackState;
+    Object.defineProperty(wrapped, "stepWithRollback", {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: function (name, handler, config) {
+            const undoConfig = config?.retryStrategy || config?.semantics
+                ? {
+                    retryStrategy: config.retryStrategy,
+                    semantics: config.semantics,
+                }
+                : undefined;
+            return new durable.DurablePromise(async () => {
+                const result = await context.step(name, handler.run, config);
+                rollbackState.undoStack.push({
+                    name,
+                    execute: async (error, rollbackContext) => {
+                        await rollbackContext.step(`Undo '${name}'`, (stepContext) => handler.undo(error, result, stepContext), undoConfig);
+                    },
+                });
+                return result;
+            });
+        },
+    });
+    Object.defineProperty(wrapped, "waitUntil", {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: (name, until) => context.wait(name, resolveWaitUntilDuration(until)),
+    });
+    Object.defineProperty(wrapped, "rollbackAll", {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: async (error) => {
+            while (rollbackState.undoStack.length > 0) {
+                const rollbackStep = rollbackState.undoStack.pop();
+                if (!rollbackStep)
+                    continue;
+                try {
+                    await rollbackStep.execute(error, context);
+                }
+                catch (undoError) {
+                    throw new workflow.RollbackError(rollbackStep.name, error, undoError);
+                }
+            }
+        },
+    });
+    return wrapped;
+}

package/dist/event/index.d.ts

@@ -0,0 +1,72 @@
+export declare namespace event {
+    export type Definition = {
+        type: string;
+        $input: any;
+        $output: any;
+        $metadata: any;
+        $payload: any;
+        create: (...args: any[]) => Promise<any>;
+    };
+    export function builder<Metadata extends ((type: string, properties: any) => any) | Parameters<Validator>[0], Validator extends (schema: any) => (input: any) => any>(input: {
+        validator: Validator;
+        metadata?: Metadata;
+    }): {
+        <Type extends string, Schema extends Parameters<Validator>[0]>(type: Type, schema: Schema): {
+            create: Metadata extends (type: string, properties: any) => any ? (properties: inferParser<Schema>["in"]) => Promise<{
+                type: Type;
+                properties: inferParser<Schema>["out"];
+                metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
+            }> : (properties: inferParser<Schema>["in"], metadata: inferParser<Metadata>["in"]) => Promise<{
+                type: Type;
+                properties: inferParser<Schema>["out"];
+                metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
+            }>;
+            type: Type;
+            $input: inferParser<Schema>["in"];
+            $output: inferParser<Schema>["out"];
+            $payload: {
+                type: Type;
+                properties: inferParser<Schema>["out"];
+                metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
+            };
+            $metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
+        };
+        coerce<Events extends Definition>(_events: Events | Events[], raw: any): { [K in Events["type"]]: Extract<Events, {
+            type: K;
+        }>["$payload"]; }[Events["type"]];
+    };
+    type ParserZodEsque<TInput, TParsedInput> = {
+        _input: TInput;
+        _output: TParsedInput;
+    };
+    type ParserValibotEsque<TInput, TParsedInput> = {
+        _types?: {
+            input: TInput;
+            output: TParsedInput;
+        };
+    };
+    type ParserMyZodEsque<TInput> = {
+        parse: (input: any) => TInput;
+    };
+    type ParserSuperstructEsque<TInput> = {
+        create: (input: unknown) => TInput;
+    };
+    type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
+    type ParserYupEsque<TInput> = {
+        validateSync: (input: unknown) => TInput;
+    };
+    type ParserScaleEsque<TInput> = {
+        assert(value: unknown): asserts value is TInput;
+    };
+    export type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
+    export type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput>;
+    export type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+    export type inferParser<TParser extends Parser> = TParser extends ParserWithInputOutput<infer $TIn, infer $TOut> ? {
+        in: $TIn;
+        out: $TOut;
+    } : TParser extends ParserWithoutInput<infer $InOut> ? {
+        in: $InOut;
+        out: $InOut;
+    } : never;
+    export {};
+}

package/dist/event/index.js

@@ -0,0 +1,35 @@
+export var event;
+(function (event) {
+    function builder(input) {
+        const validator = input.validator;
+        const fn = function event(type, schema) {
+            const validate = validator(schema);
+            async function create(properties, metadata) {
+                metadata = input.metadata
+                    ? typeof input.metadata === "function"
+                        ? input.metadata(type, properties)
+                        : input.metadata(metadata)
+                    : metadata ?? {};
+                properties = validate(properties);
+                return {
+                    type,
+                    properties,
+                    metadata,
+                };
+            }
+            return {
+                create: create,
+                type,
+                $input: {},
+                $output: {},
+                $payload: {},
+                $metadata: {},
+            };
+        };
+        fn.coerce = (_events, raw) => {
+            return raw;
+        };
+        return fn;
+    }
+    event.builder = builder;
+})(event || (event = {}));

package/dist/event/validator.d.ts

@@ -0,0 +1,4 @@
+import { ZodSchema, z } from "zod";
+export declare function ZodValidator<Schema extends ZodSchema>(schema: Schema): (input: z.input<Schema>) => z.output<Schema>;
+import { BaseSchema, InferInput } from "valibot";
+export declare function ValibotValidator<T extends BaseSchema<any, any, any>>(schema: T): (value: InferInput<T>) => import("valibot").InferOutput<T>;

package/dist/event/validator.js

@@ -0,0 +1,11 @@
+export function ZodValidator(schema) {
+    return (input) => {
+        return schema.parse(input);
+    };
+}
+import { parse } from "valibot";
+export function ValibotValidator(schema) {
+    return (value) => {
+        return parse(schema, value);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./realtime/index.js";
+export { Resource } from "./resource/index.js";
+export * from "./vector/index.js";

package/dist/index.js

@@ -0,0 +1,17 @@
+export * from "./realtime/index.js";
+export { Resource } from "./resource/index.js";
+export * from "./vector/index.js";
+import { format } from "util";
+if (process.env?.ECS_CONTAINER_METADATA_URI_V4 &&
+    !process.env.SST_DISABLE_LOG_POLYFILL) {
+    const log = (level) => (msg, ...rest) => {
+        let line = `${level}\t${format(msg, ...rest)}`;
+        line = line.replace(/\n/g, "\r");
+        process.stdout.write(line + "\n");
+    };
+    console.log = log("INFO");
+    console.warn = log("WARN");
+    console.error = log("ERROR");
+    console.trace = log("TRACE");
+    console.debug = log("DEBUG");
+}

package/dist/realtime/index.d.ts

@@ -0,0 +1,25 @@
+import { realtime } from "../aws/realtime.js";
+export type RealtimeAuthResult = realtime.AuthResult;
+/**
+ * @deprecated import from `sst/aws/realtime` instead.
+ *
+ * Creates an authorization handler for the `Realtime` component, that validates
+ * the token and grants permissions for the topics the client can subscribe and publish to.
+ *
+ * @example
+ * ```js
+ * import { RealtimeAuthHandler, Resource } from "sst";
+ *
+ * export const handler = RealtimeAuthHandler(async (token) => {
+ *   // Validate the token
+ *   console.log(token);
+ *
+ *   // Return the topics to subscribe and publish
+ *   return {
+ *     subscribe: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
+ *     publish: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
+ *   };
+ * });
+ * ```
+ */
+export declare const RealtimeAuthHandler: typeof realtime.authorizer;