sst 3.0.0 → 3.0.1-10

package/context/context2.js

@@ -1,108 +0,0 @@
-import { AsyncLocalStorage } from "async_hooks";
-export class ContextNotFoundError extends Error {
-    name;
-    constructor(name) {
-        super(`${name} context was not provided. It is possible you have multiple versions of SST installed.`);
-        this.name = name;
-    }
-}
-let count = 0;
-export function create(name) {
-    const storage = new AsyncLocalStorage();
-    const children = [];
-    // notify all memos to reset
-    function reset() {
-        for (const child of children) {
-            child();
-        }
-    }
-    const ctx = {
-        name,
-        with(value, cb) {
-            const version = (++count).toString();
-            return storage.run({ value, version }, () => {
-                return runWithCleanup(cb, () => reset());
-            });
-        },
-        use() {
-            const memo = ContextMemo.getStore();
-            // use is being called within a memo, so track dependency
-            if (memo) {
-                memo.deps.push(ctx);
-                children.push(memo.reset);
-            }
-            const result = storage.getStore();
-            if (result === undefined)
-                throw new ContextNotFoundError(name);
-            return result.value;
-        },
-        version() {
-            const result = storage.getStore();
-            if (result === undefined)
-                throw new ContextNotFoundError(name);
-            return result.version;
-        },
-    };
-    return ctx;
-}
-const ContextMemo = new AsyncLocalStorage();
-export function memo(cb) {
-    const deps = [];
-    const cache = new Map();
-    const children = [];
-    let tracked = false;
-    function key() {
-        return deps.map((dep) => dep.version()).join(",");
-    }
-    function reset() {
-        cache.delete(key());
-        for (const child of children) {
-            child();
-        }
-    }
-    function save(value) {
-        cache.set(key(), value);
-    }
-    return () => {
-        const child = ContextMemo.getStore();
-        if (child) {
-            child.deps.push({ version: () => key() });
-            children.push(child.reset);
-        }
-        // Memo never run so build up dependency list
-        if (!tracked) {
-            return ContextMemo.run({ deps, reset }, () => {
-                return runWithCleanup(cb, (result) => {
-                    tracked = true;
-                    save(result);
-                });
-            });
-        }
-        const cached = cache.get(key());
-        if (cached) {
-            return cached;
-        }
-        const result = cb();
-        save(result);
-        return result;
-    };
-}
-function runWithCleanup(cb, cleanup) {
-    const result = cb();
-    if (result &&
-        typeof result === "object" &&
-        "then" in result &&
-        typeof result.then === "function") {
-        return result.then((value) => {
-            // cleanup
-            cleanup(result);
-            return value;
-        });
-    }
-    cleanup(result);
-    return result;
-}
-export const Context = {
-    create,
-    memo,
-};

package/context/handler.d.ts

@@ -1,25 +0,0 @@
-import { APIGatewayProxyEventHeaders, APIGatewayProxyEventMultiValueHeaders, APIGatewayProxyEventMultiValueQueryStringParameters, APIGatewayProxyEventQueryStringParameters, APIGatewayProxyEventV2, APIGatewayProxyResultV2, APIGatewayProxyStructuredResultV2, APIGatewayProxyWebsocketEventV2, Context as LambdaContext, SQSBatchResponse, SQSEvent } from "aws-lambda";
-export interface Handlers {
-    api: {
-        event: APIGatewayProxyEventV2;
-        response: APIGatewayProxyStructuredResultV2 | void;
-    };
-    ws: {
-        event: APIGatewayProxyWebsocketEventV2 & {
-            headers?: APIGatewayProxyEventHeaders;
-            multiValueHeaders?: APIGatewayProxyEventMultiValueHeaders;
-            queryStringParameters?: APIGatewayProxyEventQueryStringParameters | null;
-            multiValueQueryStringParameters?: APIGatewayProxyEventMultiValueQueryStringParameters | null;
-        };
-        response: APIGatewayProxyResultV2;
-    };
-    sqs: {
-        event: SQSEvent;
-        response: SQSBatchResponse;
-    };
-}
-export type HandlerTypes = keyof Handlers;
-export declare function useContextType(): HandlerTypes;
-export declare function useEvent<Type extends HandlerTypes>(type: Type): Handlers[Type]["event"];
-export declare function useLambdaContext(): LambdaContext;
-export declare function Handler<Type extends HandlerTypes, Event = Handlers[Type]["event"], Response = Handlers[Type]["response"]>(type: Type, cb: (evt: Event, ctx: LambdaContext) => Promise<Response>): (event: Event, context: LambdaContext) => Promise<Response>;

package/context/handler.js

@@ -1,21 +0,0 @@
-import { create } from "./context2.js";
-const RequestContext = create("RequestContext");
-export function useContextType() {
-    const ctx = RequestContext.use();
-    return ctx.type;
-}
-export function useEvent(type) {
-    const ctx = RequestContext.use();
-    if (ctx.type !== type)
-        throw new Error(`Expected ${type} event`);
-    return ctx.event;
-}
-export function useLambdaContext() {
-    const ctx = RequestContext.use();
-    return ctx.context;
-}
-export function Handler(type, cb) {
-    return function handler(event, context) {
-        return RequestContext.with({ type, event: event, context }, () => cb(event, context));
-    };
-}

package/context/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./context.js";
-export * from "./handler.js";

package/context/index.js

@@ -1,2 +0,0 @@
-export * from "./context.js";
-export * from "./handler.js";

package/credentials.d.ts

@@ -1,9 +0,0 @@
-import { SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/sdk-provider.js";
-export declare const useAWSCredentialsProvider: () => import("@smithy/types").AwsCredentialIdentityProvider;
-export declare const useAWSCredentials: () => Promise<import("@smithy/types").AwsCredentialIdentity>;
-export declare const useSTSIdentity: () => Promise<import("@aws-sdk/client-sts").GetCallerIdentityCommandOutput>;
-export declare function useAWSClient<C extends any>(client: new (config: any) => C, force?: boolean): C;
-/**
- * Do not use this. It is only used for AWS CDK compatibility.
- */
-export declare const useAWSProvider: () => Promise<SdkProvider>;

package/credentials.js

@@ -1,145 +0,0 @@
-import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
-import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
-import { Logger } from "./logger.js";
-import { SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/sdk-provider.js";
-import { StandardRetryStrategy } from "@aws-sdk/middleware-retry";
-export const useAWSCredentialsProvider = lazy(() => {
-    const project = useProject();
-    Logger.debug("Using AWS profile", project.config.profile);
-    const provider = fromNodeProviderChain({
-        clientConfig: { region: project.config.region },
-        profile: project.config.profile,
-        roleArn: project.config.role,
-        mfaCodeProvider: async (serialArn) => {
-            const readline = await import("readline");
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
-            return new Promise((resolve) => {
-                Logger.debug(`Require MFA token for serial ARN ${serialArn}`);
-                const prompt = () => rl.question(`Enter MFA code for ${serialArn}: `, async (input) => {
-                    if (input.trim() !== "") {
-                        resolve(input.trim());
-                        rl.close();
-                    }
-                    else {
-                        // prompt again if no input
-                        prompt();
-                    }
-                });
-                prompt();
-            });
-        },
-    });
-    return provider;
-});
-export const useAWSCredentials = () => {
-    const provider = useAWSCredentialsProvider();
-    return provider();
-};
-export const useSTSIdentity = lazy(async () => {
-    const sts = useAWSClient(STSClient);
-    const identity = await sts.send(new GetCallerIdentityCommand({}));
-    Logger.debug("Using identity", "Account:", identity.Account, "User:", identity.UserId);
-    return identity;
-});
-const useClientCache = lazy(() => new Map());
-export function useAWSClient(client, force = false) {
-    const cache = useClientCache();
-    const existing = cache.get(client.name);
-    if (existing && !force)
-        return existing;
-    const [project, credentials] = [useProject(), useAWSCredentialsProvider()];
-    const printNoInternet = (() => {
-        let lastPrinted = 0;
-        return () => {
-            const now = Date.now();
-            if (now - lastPrinted > 5000) {
-                console.log("Waiting for internet connection...");
-                lastPrinted = now;
-            }
-        };
-    })();
-    const result = new client({
-        region: project.config.region,
-        credentials: credentials,
-        retryStrategy: new StandardRetryStrategy(async () => 10000, {
-            retryDecider: (e) => {
-                // Handle no internet connection => retry
-                if (e.code === "ENOTFOUND") {
-                    printNoInternet();
-                    return true;
-                }
-                // Handle throttling errors => retry
-                if ([
-                    "ThrottlingException",
-                    "Throttling",
-                    "TooManyRequestsException",
-                    "OperationAbortedException",
-                    "TimeoutError",
-                    "NetworkingError",
-                ].includes(e.name)) {
-                    Logger.debug("Retry AWS call", e.name, e.message);
-                    return true;
-                }
-                return false;
-            },
-            delayDecider: (_, attempts) => {
-                return Math.min(1.5 ** attempts * 100, 5000);
-            },
-            // AWS SDK v3 has an idea of "retry tokens" which are used to
-            // prevent multiple retries from happening at the same time.
-            // This is a workaround to disable that.
-            retryQuota: {
-                hasRetryTokens: () => true,
-                releaseRetryTokens: () => { },
-                retrieveRetryTokens: () => 1,
-            },
-        }),
-    });
-    cache.set(client.name, result);
-    Logger.debug("Created AWS client", client.name);
-    return result;
-}
-// @ts-expect-error
-import stupid from "aws-sdk/lib/maintenance_mode_message.js";
-stupid.suppress = true;
-import aws from "aws-sdk";
-import { useProject } from "./project.js";
-import { lazy } from "./util/lazy.js";
-const CredentialProviderChain = aws.CredentialProviderChain;
-/**
- * Do not use this. It is only used for AWS CDK compatibility.
- */
-export const useAWSProvider = lazy(async () => {
-    Logger.debug("Loading v2 AWS SDK");
-    const project = useProject();
-    const creds = await useAWSCredentials();
-    const chain = new CredentialProviderChain([
-        () => ({
-            ...creds,
-            get(cb) {
-                cb();
-            },
-            async getPromise() { },
-            needsRefresh() {
-                return false;
-            },
-            refresh(cb) {
-                cb();
-            },
-            async refreshPromise() { },
-            expired: false,
-            expireTime: creds.expiration,
-            accessKeyId: creds.accessKeyId,
-            sessionToken: creds.sessionToken,
-            secretAccessKey: creds.secretAccessKey,
-        }),
-    ]);
-    const provider = new SdkProvider(chain, project.config.region, {
-        maxRetries: 10000,
-        region: project.config.region,
-    });
-    return provider;
-});

package/error.d.ts

@@ -1,6 +0,0 @@
-export declare class VisibleError extends Error {
-    constructor(...message: string[]);
-}
-export declare class SilentError extends Error {
-    constructor(...message: string[]);
-}

package/error.js

@@ -1,10 +0,0 @@
-export class VisibleError extends Error {
-    constructor(...message) {
-        super(message.join("\n"));
-    }
-}
-export class SilentError extends Error {
-    constructor(...message) {
-        super(message.join("\n"));
-    }
-}

package/index.d.ts

@@ -1 +0,0 @@
-export type { SSTConfig } from "./project.js";

package/index.js

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

package/iot.d.ts

@@ -1,6 +0,0 @@
-export declare const useIOTEndpoint: () => Promise<string>;
-import { Events } from "./bus.js";
-export declare const useIOT: () => Promise<{
-    prefix: string;
-    publish<Type extends keyof Events>(topic: string, type: Type, properties: Events[Type]): Promise<void>;
-}>;

package/iot.js

@@ -1,163 +0,0 @@
-import { IoTClient, DescribeEndpointCommand } from "@aws-sdk/client-iot";
-import { useAWSClient, useAWSCredentials } from "./credentials.js";
-import { VisibleError } from "./error.js";
-export const useIOTEndpoint = lazy(async () => {
-    const iot = useAWSClient(IoTClient);
-    Logger.debug("Getting IoT endpoint");
-    const response = await iot.send(new DescribeEndpointCommand({
-        endpointType: "iot:Data-ATS",
-    }));
-    Logger.debug("Using IoT endpoint:", response.endpointAddress);
-    if (!response.endpointAddress)
-        throw new VisibleError("IoT Endpoint address not found");
-    return response.endpointAddress;
-});
-import iot from "aws-iot-device-sdk";
-import { useBus } from "./bus.js";
-import { useProject } from "./project.js";
-import { Logger } from "./logger.js";
-import { useBootstrap } from "./bootstrap.js";
-import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { lazy } from "./util/lazy.js";
-export const useIOT = lazy(async () => {
-    const bus = useBus();
-    const endpoint = await useIOTEndpoint();
-    const creds = await useAWSCredentials();
-    const project = useProject();
-    const bootstrap = await useBootstrap();
-    const s3 = useAWSClient(S3Client);
-    async function encode(input) {
-        const id = Math.random().toString();
-        const json = JSON.stringify(input);
-        if (json.length > 1024 * 1024 * 3) {
-            // upload to s3
-            const key = `pointers/${id}`;
-            await s3.send(new PutObjectCommand({
-                Bucket: bootstrap.bucket,
-                Key: key,
-                Body: json,
-            }));
-            return [
-                {
-                    id,
-                    index: 0,
-                    count: 1,
-                    data: JSON.stringify({
-                        type: "pointer",
-                        properties: {
-                            key,
-                            bucket: bootstrap.bucket,
-                        },
-                    }),
-                },
-            ];
-        }
-        const parts = json.match(/.{1,50000}/g);
-        if (!parts)
-            return [];
-        Logger.debug("Encoded iot message into", parts?.length, "parts");
-        return parts.map((part, index) => ({
-            id,
-            index,
-            count: parts?.length,
-            data: part,
-        }));
-    }
-    /*
-    console.log(endpoint, creds);
-    const config =
-      iotsdk.iot.AwsIotMqttConnectionConfigBuilder.new_with_websockets({
-        region: project.config.region!,
-        credentials_provider: iotsdk.auth.AwsCredentialsProvider.newStatic(
-          creds.accessKeyId,
-          creds.secretAccessKey,
-          creds.sessionToken
-        ),
-      })
-        .with_client_id(randomUUID())
-        .with_endpoint(endpoint)
-        .build();
-    console.log(config);
-  
-    const device2 = new iotsdk.mqtt.MqttClient();
-    const conn = device2.new_connection(config);
-    conn.on("connect", () => {
-      console.log("CONNECTED");
-    });
-    conn.on("error", console.log);
-    conn.on("connect", console.log);
-    conn.on("resume", console.log);
-    conn.on("message", console.log);
-    conn.on("disconnect", console.log);
-    conn.connect();
-    console.log(device2);
-    */
-    const device = new iot.device({
-        protocol: "wss",
-        host: endpoint,
-        region: project.config.region,
-        accessKeyId: creds.accessKeyId,
-        secretKey: creds.secretAccessKey,
-        sessionToken: creds.sessionToken,
-        reconnectPeriod: 1,
-    });
-    const PREFIX = `/sst/${project.config.name}/${project.config.stage}`;
-    device.subscribe(`${PREFIX}/events`, { qos: 1 });
-    const fragments = new Map();
-    device.on("connect", () => {
-        Logger.debug("IoT connected");
-    });
-    device.on("error", (err) => {
-        Logger.debug("IoT error", err);
-    });
-    device.on("close", () => {
-        Logger.debug("IoT closed");
-    });
-    device.on("reconnect", () => {
-        Logger.debug("IoT reconnected");
-    });
-    device.on("message", (_topic, buffer) => {
-        const fragment = JSON.parse(buffer.toString());
-        if (!fragment.id) {
-            bus.publish(fragment.type, fragment.properties);
-            return;
-        }
-        let pending = fragments.get(fragment.id);
-        if (!pending) {
-            pending = new Map();
-            fragments.set(fragment.id, pending);
-        }
-        pending.set(fragment.index, fragment);
-        if (pending.size === fragment.count) {
-            const data = [...pending.values()]
-                .sort((a, b) => a.index - b.index)
-                .map((item) => item.data)
-                .join("");
-            fragments.delete(fragment.id);
-            const evt = JSON.parse(data);
-            if (evt.sourceID === bus.sourceID)
-                return;
-            bus.publish(evt.type, evt.properties);
-        }
-    });
-    return {
-        prefix: PREFIX,
-        async publish(topic, type, properties) {
-            const payload = {
-                type,
-                properties,
-                sourceID: bus.sourceID,
-            };
-            for (const fragment of await encode(payload)) {
-                await new Promise((r) => {
-                    device.publish(topic, JSON.stringify(fragment), {
-                        qos: 1,
-                    }, () => {
-                        r();
-                    });
-                });
-            }
-            Logger.debug("IOT Published", topic, type);
-        },
-    };
-});

package/logger.d.ts

@@ -1,3 +0,0 @@
-export declare const Logger: {
-    debug(...parts: any[]): void;
-};

package/logger.js

@@ -1,32 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { useProject } from "./project.js";
-import { lazy } from "./util/lazy.js";
-let previous = new Date();
-const useFile = lazy(() => {
-    const project = useProject();
-    const filePath = path.join(project.paths.out, "debug.log");
-    const file = fs.createWriteStream(filePath);
-    return file;
-});
-export const Logger = {
-    debug(...parts) {
-        const now = new Date();
-        const diff = now.getTime() - previous.getTime();
-        previous = now;
-        const line = [
-            new Date().toISOString(),
-            `+${diff}ms`.padStart(8),
-            "[debug]",
-            ...parts.map((x) => {
-                if (typeof x === "string")
-                    return x;
-                return JSON.stringify(x);
-            }),
-        ];
-        if (process.env.SST_VERBOSE)
-            console.log(...line);
-        const file = useFile();
-        file.write(line.join(" ") + "\n");
-    },
-};

package/node/actor/index.d.ts

@@ -1,29 +0,0 @@
-import { SSTError } from "../../util/error.js";
-interface Definition {
-    type: string;
-    properties: Record<string, any>;
-}
-export declare class WrongActorError extends SSTError {
-}
-export declare function createActors<T extends Definition>(): {
-    useActor: () => T | {
-        type: "public";
-        properties: {};
-    };
-    withActor: <R>(value: T | {
-        type: "public";
-        properties: {};
-    }, cb: () => R) => R;
-    assertActor<T_1 extends (T | {
-        type: "public";
-        properties: {};
-    })["type"]>(type: T_1): (Extract<T, {
-        type: T_1;
-    }> | Extract<{
-        type: "public";
-        properties: {};
-    }, {
-        type: T_1;
-    }>)["properties"];
-};
-export {};

package/node/actor/index.js

@@ -1,17 +0,0 @@
-import { create } from "../../context/context2.js";
-import { SSTError } from "../../util/error.js";
-export class WrongActorError extends SSTError {
-}
-export function createActors() {
-    const ctx = create("Actors");
-    return {
-        useActor: ctx.use,
-        withActor: ctx.with,
-        assertActor(type) {
-            const actor = ctx.use();
-            if (actor.type === type)
-                return actor.properties;
-            throw new WrongActorError(`Expected actor type "${type} but got "${actor.type}"`);
-        },
-    };
-}

package/node/api/index.d.ts

@@ -1,64 +0,0 @@
-import { Handler, HandlerTypes } from "../../context/handler.js";
-import { APIGatewayProxyStructuredResultV2 } from "aws-lambda";
-export interface ApiResources {
-}
-export interface AppSyncApiResources {
-}
-export interface ApiGatewayV1ApiResources {
-}
-export type ApiHandlerTypes = Extract<HandlerTypes, "api" | "ws">;
-export declare const Api: ApiResources;
-export declare const AppSyncApi: AppSyncApiResources;
-export declare const ApiGatewayV1Api: ApiGatewayV1ApiResources;
-export declare class Response {
-    readonly result: APIGatewayProxyStructuredResultV2;
-    constructor(result: APIGatewayProxyStructuredResultV2);
-}
-/**
- * Create a new api handler that can be used to create an authenticated session.
- *
- * @example
- * ```ts
- * export const handler = ApiHandler({
- * })
- * ```
- */
-export declare function ApiHandler(cb: Parameters<typeof Handler<"api">>[1]): (event: import("aws-lambda").APIGatewayProxyEventV2, context: import("aws-lambda").Context) => Promise<APIGatewayProxyStructuredResultV2>;
-export declare const useCookies: () => {
-    [k: string]: string;
-};
-export declare function useCookie(name: string): string | undefined;
-export declare const useBody: () => string | undefined;
-export declare const useJsonBody: () => any;
-export declare const useFormData: () => URLSearchParams | undefined;
-export declare const usePath: () => string[];
-interface CookieOptions {
-    expires?: Date;
-    maxAge?: number;
-    domain?: string;
-    path?: string;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: "Strict" | "Lax" | "None";
-}
-export declare const useResponse: () => {
-    cookies(values: Record<string, string>, options: CookieOptions): any;
-    cookie(input: {
-        key: string;
-        value: string;
-        encrypted?: string;
-    } & CookieOptions): any;
-    status(code: number): any;
-    header(key: string, value: string): any;
-    serialize(input: APIGatewayProxyStructuredResultV2): APIGatewayProxyStructuredResultV2;
-};
-export declare function useDomainName(): string;
-export declare function useMethod(): string;
-export declare function useHeaders(): import("aws-lambda").APIGatewayProxyEventHeaders;
-export declare function useHeader(key: string): string | undefined;
-export declare function useFormValue(name: string): string | null | undefined;
-export declare function useQueryParams(): import("aws-lambda").APIGatewayProxyEventQueryStringParameters;
-export declare function useQueryParam<T = string>(name: string): T | undefined;
-export declare function usePathParams(): import("aws-lambda").APIGatewayProxyEventPathParameters;
-export declare function usePathParam(name: string): string | undefined;
-export {};