sst 3.0.0 → 3.0.1-2

package/node/queue/index.d.ts

@@ -1,3 +0,0 @@
-export interface QueueResources {
-}
-export declare const Queue: QueueResources;

package/node/queue/index.js

@@ -1,2 +0,0 @@
-import { createProxy } from "../util/index.js";
-export const Queue = /* @__PURE__ */ createProxy("Queue");

package/node/rds/index.d.ts

@@ -1,3 +0,0 @@
-export interface RDSResources {
-}
-export declare const RDS: RDSResources;

package/node/rds/index.js

@@ -1,2 +0,0 @@
-import { createProxy } from "../util/index.js";
-export const RDS = /* @__PURE__ */ createProxy("RDS");

package/node/service/index.d.ts

@@ -1,3 +0,0 @@
-export interface ServiceResources {
-}
-export declare const Service: ServiceResources;

package/node/service/index.js

@@ -1,4 +0,0 @@
-import { createProxy } from "../util/index.js";
-export const Service = 
-/* @__PURE__ */
-createProxy("Service");

package/node/site/index.d.ts

@@ -1,18 +0,0 @@
-export interface StaticSiteResources {
-}
-export interface NextjsSiteResources {
-}
-export interface AstroSiteResources {
-}
-export interface RemixSiteResources {
-}
-export interface SolidStartSiteResources {
-}
-export interface SvelteKitSiteResources {
-}
-export declare const StaticSite: StaticSiteResources;
-export declare const AstroSite: AstroSiteResources;
-export declare const RemixSite: RemixSiteResources;
-export declare const NextjsSite: NextjsSiteResources;
-export declare const SolidStartSite: SolidStartSiteResources;
-export declare const SvelteKitSite: SvelteKitSiteResources;

package/node/site/index.js

@@ -1,18 +0,0 @@
-import { createProxy } from "../util/index.js";
-export const StaticSite = 
-/* @__PURE__ */ createProxy("StaticSite");
-export const AstroSite = 
-/* @__PURE__ */
-createProxy("AstroSite");
-export const RemixSite = 
-/* @__PURE__ */
-createProxy("RemixSite");
-export const NextjsSite = 
-/* @__PURE__ */
-createProxy("NextjsSite");
-export const SolidStartSite = 
-/* @__PURE__ */
-createProxy("SolidStartSite");
-export const SvelteKitSite = 
-/* @__PURE__ */
-createProxy("SvelteKitSite");

package/node/table/index.d.ts

@@ -1,3 +0,0 @@
-export interface TableResources {
-}
-export declare const Table: TableResources;

package/node/table/index.js

@@ -1,4 +0,0 @@
-import { createProxy } from "../util/index.js";
-export const Table = 
-/* @__PURE__ */
-createProxy("Table");

package/node/topic/index.d.ts

@@ -1,3 +0,0 @@
-export interface TopicResources {
-}
-export declare const Topic: TopicResources;

package/node/topic/index.js

@@ -1,4 +0,0 @@
-import { createProxy } from "../util/index.js";
-export const Topic = 
-/* @__PURE__ */
-createProxy("Topic");

package/node/util/index.d.ts

@@ -1,2 +0,0 @@
-export declare function createProxy<T extends object>(constructName: string): T;
-export declare function getVariables2(constructName: string): Record<string, Record<string, string>>;

package/node/util/index.js

@@ -1,196 +0,0 @@
-import { GetParametersCommand, SSMClient, } from "@aws-sdk/client-ssm";
-const ssm = new SSMClient({ region: process.env.SST_REGION });
-// Example:
-// {
-//   Bucket: {
-//     myBucket: {
-//       name: "my-bucket",
-//     }
-//   }
-// }
-let allVariables = {};
-// NOTE: in some setups, top level await must be assigned to a variable,
-//       otherwise it would throw a top level await error.
-//       https://discord.com/channels/983865673656705025/1089184080534446110
-const _placeholder = await parseEnvironment();
-export function createProxy(constructName) {
-    const result = new Proxy({}, {
-        get(target, prop) {
-            if (typeof prop === "string") {
-                // If SST_APP and SST_STAGE are not set, it is likely the
-                // user is using an older version of SST.
-                // Note: cannot run this check at the top level b/c SvelteKit
-                //       run code analysis after build. The code analysis runs
-                //       the top level code, and would fail b/c "SST_APP" and
-                //       "SST_STAGE" are undefined at build time.
-                if (!process.env.SST_APP) {
-                    throw new Error(buildMissingBuiltInEnvError());
-                }
-                // normalize prop to convert kebab cases like `my-table` to `my_table`
-                const normProp = normalizeId(prop);
-                if (!(normProp in target)) {
-                    throw new Error(`Cannot use ${constructName}.${String(prop)}. Please make sure it is bound to this function.`);
-                }
-                return Reflect.get(target, normProp);
-            }
-            return Reflect.get(target, prop);
-        },
-    });
-    Object.assign(result, getVariables2(constructName));
-    return result;
-}
-export function getVariables2(constructName) {
-    return allVariables[constructName] || {};
-}
-async function parseEnvironment() {
-    const variablesFromSsm = [];
-    const variablesFromSecret = [];
-    Object.keys(process.env)
-        .filter((name) => name.startsWith("SST_"))
-        .forEach((name) => {
-        const variable = parseEnvName(name);
-        // Ignore if env var is not in the correct format
-        if (!variable.constructName ||
-            !variable.constructId ||
-            !variable.propName) {
-            return;
-        }
-        const value = process.env[name];
-        if (value === "__FETCH_FROM_SSM__") {
-            variablesFromSsm.push(variable);
-        }
-        else if (value.startsWith("__FETCH_FROM_SECRET__:")) {
-            variablesFromSecret.push([variable, value.split(":")[1]]);
-        }
-        else {
-            storeVariable(variable, value);
-        }
-    });
-    // Fetch values from SSM
-    await fetchValuesFromSSM(variablesFromSsm);
-    // Fetch values from Secrets
-    variablesFromSecret.forEach(([variable, secretName]) => {
-        const value = allVariables["Secret"]?.[secretName]?.value;
-        if (value) {
-            storeVariable(variable, value);
-        }
-    });
-    return allVariables;
-}
-async function fetchValuesFromSSM(variablesFromSsm) {
-    // Get all env vars that need to be fetched from SSM
-    const ssmPaths = variablesFromSsm.map((variable) => buildSsmPath(variable));
-    if (ssmPaths.length === 0)
-        return;
-    // Fetch
-    const results = await loadSecrets(ssmPaths);
-    results.validParams.forEach((item) => {
-        const variable = parseSsmPath(item.Name);
-        storeVariable(variable, item.Value);
-    });
-    // Get all fallback values to be fetched
-    const ssmFallbackPaths = results.invalidParams
-        .map((name) => parseSsmPath(name))
-        .filter((variable) => variable.constructName === "Secret")
-        .map((variable) => buildSsmFallbackPath(variable));
-    if (ssmFallbackPaths.length === 0)
-        return;
-    // Fetch fallback values
-    const fallbackResults = await loadSecrets(ssmFallbackPaths);
-    fallbackResults.validParams.forEach((item) => {
-        const variable = parseSsmFallbackPath(item.Name);
-        storeVariable(variable, item.Value);
-    });
-    // Throw error if any values are missing
-    const missingSecrets = fallbackResults.invalidParams
-        .map((name) => parseSsmFallbackPath(name))
-        .filter((variable) => variable.constructName === "Secret")
-        .map((variable) => variable.constructId);
-    if (missingSecrets.length > 0) {
-        throw new Error(`The following secret values are not set in the "${process.env.SST_STAGE} stage": ${missingSecrets.join(", ")}`);
-    }
-}
-async function loadSecrets(paths) {
-    // Split paths into chunks of 10
-    const chunks = [];
-    for (let i = 0; i < paths.length; i += 10) {
-        chunks.push(paths.slice(i, i + 10));
-    }
-    // Fetch secrets
-    const validParams = [];
-    const invalidParams = [];
-    await Promise.all(chunks.map(async (chunk) => {
-        const command = new GetParametersCommand({
-            Names: chunk,
-            WithDecryption: true,
-        });
-        const result = await ssm.send(command);
-        validParams.push(...(result.Parameters || []));
-        invalidParams.push(...(result.InvalidParameters || []));
-    }));
-    return { validParams, invalidParams };
-}
-function parseEnvName(env) {
-    const [_SST, constructName, propName, ...idParts] = env.split("_");
-    return {
-        constructName,
-        constructId: idParts.join("_"),
-        propName,
-    };
-}
-function parseSsmPath(path) {
-    const prefix = ssmPrefix();
-    const parts = path.substring(prefix.length).split("/");
-    return {
-        constructName: parts[0],
-        constructId: parts[1],
-        propName: parts[2],
-    };
-}
-function parseSsmFallbackPath(path) {
-    const parts = path.split("/");
-    return {
-        constructName: parts[4],
-        constructId: parts[5],
-        propName: parts[6],
-    };
-}
-function buildSsmPath(data) {
-    return `${ssmPrefix()}${data.constructName}/${data.constructId}/${data.propName}`;
-}
-function buildSsmFallbackPath(data) {
-    return `/sst/${process.env.SST_APP}/.fallback/${data.constructName}/${data.constructId}/${data.propName}`;
-}
-function normalizeId(name) {
-    return name.replace(/-/g, "_");
-}
-function ssmPrefix() {
-    return process.env.SST_SSM_PREFIX || "";
-}
-function storeVariable(variable, value) {
-    const { constructId: id, constructName: c, propName: prop } = variable;
-    allVariables[c] = allVariables[c] || {};
-    allVariables[c][id] = allVariables[c][id] || {};
-    allVariables[c][id][prop] = value;
-}
-function buildMissingBuiltInEnvError() {
-    // Build environment => building SSR sites
-    if (process.env.SST) {
-        return [
-            "",
-            `Cannot access bound resources. This usually happens if the "sst/node" package is used at build time. For example:`,
-            "",
-            `  - The "sst/node" package is used inside the "getStaticProps()" function of a Next.js app.`,
-            `  - The "sst/node" package is used at the top level outside of the "load()" function of a SvelteKit app.`,
-            "",
-            `Please wrap your build script with "sst bind". For example, "sst bind next build".`,
-            "",
-        ].join("\n");
-    }
-    // Lambda/CodeBuild environment => Function/Job or SSR function
-    if (process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.CODEBUILD_BUILD_ARN) {
-        return `Cannot access bound resources. This usually happens if you are using an older version of SST. Please update SST to the latest version.`;
-    }
-    // Unknown environment => client-side code
-    return `Cannot access bound resources. This usually happens if the "sst/node" package is used on the client-side. Ensure that it's only called in your server functions.`;
-}

package/node/util/loader.d.ts

@@ -1,2 +0,0 @@
-export declare function createLoader<Key, Value>(batchFn: (keys: Key[]) => Promise<Value[]>): (key: Key) => Promise<Value>;
-export declare function useLoader<Key, Value>(key: any, batchFn: (keys: Key[]) => Promise<Value[]>): (key: Key) => Promise<Value>;

package/node/util/loader.js

@@ -1,51 +0,0 @@
-import { Context } from "../../context/context2.js";
-const LoaderContext = Context.memo(() => {
-    const loaders = new Map();
-    return loaders;
-});
-export function createLoader(batchFn) {
-    let current;
-    async function run() {
-        const batch = current;
-        if (!batch)
-            return;
-        const result = await batchFn(batch.keys);
-        for (let i = 0; i < result.length; i++) {
-            batch.promises[i](result[i]);
-        }
-        current = undefined;
-    }
-    function getBatch() {
-        if (current)
-            return current;
-        process.nextTick(run);
-        current = {
-            keys: [],
-            promises: [],
-        };
-        return current;
-    }
-    return (key) => {
-        const batch = getBatch();
-        batch.keys.push(key);
-        const promise = new Promise((resolve, reject) => {
-            batch.promises.push((val) => {
-                if (val instanceof Error) {
-                    reject(val);
-                    return;
-                }
-                resolve(val);
-            });
-        });
-        return promise;
-    };
-}
-export function useLoader(key, batchFn) {
-    const loaders = LoaderContext();
-    if (loaders.has(key)) {
-        return loaders.get(key);
-    }
-    const loader = createLoader(batchFn);
-    loaders.set(key, loader);
-    return loader;
-}

package/node/websocket-api/index.d.ts

@@ -1,23 +0,0 @@
-import { Handler } from "../../context/handler.js";
-export interface WebSocketApiResources {
-}
-export declare const WebSocketApi: WebSocketApiResources;
-/**
- * Create a new WebSocketApi handler that can be used to create an
- * authenticated session.
- *
- * @example
- * ```ts
- * export const handler = WebSocketApiHandler({
- * })
- * ```
- */
-export declare function WebSocketApiHandler(cb: Parameters<typeof Handler<"ws">>[1]): (event: import("aws-lambda").APIGatewayProxyWebsocketEventV2 & {
-    headers?: import("aws-lambda").APIGatewayProxyEventHeaders | undefined;
-    multiValueHeaders?: import("aws-lambda").APIGatewayProxyEventMultiValueHeaders | undefined;
-    queryStringParameters?: import("aws-lambda").APIGatewayProxyEventQueryStringParameters | null | undefined;
-    multiValueQueryStringParameters?: import("aws-lambda").APIGatewayProxyEventMultiValueQueryStringParameters | null | undefined;
-}, context: import("aws-lambda").Context) => Promise<any>;
-export declare function useRequestContext(): import("aws-lambda").APIGatewayEventWebsocketRequestContextV2;
-export declare function useConnectionId(): string;
-export declare function useEventType(): "CONNECT" | "MESSAGE" | "DISCONNECT";

package/node/websocket-api/index.js

@@ -1,48 +0,0 @@
-import { Handler, useEvent } from "../../context/handler.js";
-import { useHeader } from "../api/index.js";
-import { createProxy } from "../util/index.js";
-export const WebSocketApi = 
-/* @__PURE__ */ createProxy("WebSocketApi");
-/**
- * Create a new WebSocketApi handler that can be used to create an
- * authenticated session.
- *
- * @example
- * ```ts
- * export const handler = WebSocketApiHandler({
- * })
- * ```
- */
-export function WebSocketApiHandler(cb) {
-    return Handler("ws", async (evt, ctx) => {
-        const result = await cb(evt, ctx);
-        // TODO: Once https://github.com/sst/sst/pull/2838 is merged,
-        // then we should no longer need to check both casing for the header.
-        const token = useHeader("Sec-WebSocket-Protocol") ||
-            useHeader("sec-websocket-protocol");
-        // If a token was set as part of the sec-websocket-protocol, we need to
-        // return it as a header in the response.
-        // https://docs.aws.amazon.com/apigateway/latest/developerguide/websocket-connect-route-subprotocol.html
-        if (token) {
-            return {
-                ...(result || {}),
-                headers: {
-                    "Sec-WebSocket-Protocol": token,
-                },
-            };
-        }
-        return result;
-    });
-}
-export function useRequestContext() {
-    const evt = useEvent("ws");
-    return evt.requestContext;
-}
-export function useConnectionId() {
-    const requestContext = useRequestContext();
-    return requestContext.connectionId;
-}
-export function useEventType() {
-    const requestContext = useRequestContext();
-    return requestContext.eventType;
-}

package/pothos.d.ts

@@ -1,7 +0,0 @@
-export * as Pothos from "./pothos.js";
-interface GenerateOpts {
-    schema: string;
-    internalPackages?: string[];
-}
-export declare function generate(opts: GenerateOpts): Promise<string>;
-export declare function extractSchema(opts: GenerateOpts): Promise<any>;

package/pothos.js

@@ -1,160 +0,0 @@
-export * as Pothos from "./pothos.js";
-import babel from "@babel/core";
-import generator from "@babel/generator";
-import esbuild from "esbuild";
-import fs from "fs/promises";
-import path from "path";
-import url from "url";
-const { types, template } = babel;
-const dummyResolver = template("const %%dummy_resolver%% = { serialize: x => x, parseValue: x => x  };");
-export async function generate(opts) {
-    const { printSchema, lexicographicSortSchema } = await import("graphql");
-    const contents = await extractSchema(opts);
-    const out = path.join(path.dirname(opts.schema), "out.mjs");
-    await fs.writeFile(out, contents, "utf8");
-    const { schema } = await import(url.pathToFileURL(out).href + "?bust=" + Date.now());
-    await fs.rm(out);
-    const schemaAsString = printSchema(lexicographicSortSchema(schema));
-    return schemaAsString;
-}
-export async function extractSchema(opts) {
-    const result = await esbuild.build({
-        platform: "node",
-        bundle: true,
-        format: "esm",
-        entryPoints: [opts.schema],
-        external: ["@pothos/*"],
-        keepNames: true,
-        write: false,
-        plugins: [
-            {
-                name: "externalize",
-                setup(build) {
-                    const filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/; // Must not start with "/" or "./" or "../"
-                    build.onResolve({ filter }, (args) => {
-                        const packageName = args.path.match(/^(@[^\/]+\/[^\/]+|[^@/]+)/);
-                        if (packageName && opts.internalPackages?.includes(packageName[0]))
-                            return;
-                        return {
-                            path: args.path,
-                            external: true,
-                        };
-                    });
-                },
-            },
-        ],
-    });
-    const globalPaths = new Set();
-    const transformed = babel.transformSync(result.outputFiles[0].text, {
-        sourceType: "module",
-        plugins: [
-            {
-                name: "pothos-extractor",
-                visitor: {
-                    Program(path) {
-                        const dummyResolverId = path.scope.generateUidIdentifier("DUMMY_RESOLVER");
-                        const resolverNode = dummyResolver({
-                            dummy_resolver: dummyResolverId,
-                        });
-                        path.unshiftContainer("body", resolverNode);
-                        path.scope.crawl();
-                        let schemaBuilder = null;
-                        path.traverse({
-                            ImportDeclaration(declarator) {
-                                if (!declarator)
-                                    return;
-                                if (declarator.node.source.value.startsWith("@pothos"))
-                                    return;
-                                declarator.remove();
-                            },
-                            VariableDeclarator(declarator) {
-                                if (schemaBuilder)
-                                    return;
-                                const init = declarator.get("init");
-                                if (init.isNewExpression() &&
-                                    init.get("callee").referencesImport("@pothos/core", "default")) {
-                                    schemaBuilder = declarator;
-                                }
-                            },
-                            CallExpression(callPath) {
-                                if (!types.isMemberExpression(callPath.node.callee) ||
-                                    !types.isIdentifier(callPath.node.callee.object) ||
-                                    !types.isIdentifier(callPath.node.callee.property) ||
-                                    !schemaBuilder ||
-                                    (callPath.node.callee.object.name !==
-                                        schemaBuilder.node.id.name &&
-                                        callPath.node.callee.property.name !== "implement")) {
-                                    return;
-                                }
-                                callPath.traverse({
-                                    Property(propertyPath) {
-                                        if (types.isIdentifier(propertyPath.node.key) &&
-                                            ["resolve", "validate"].includes(propertyPath.node.key.name)) {
-                                            propertyPath.remove();
-                                        }
-                                    },
-                                });
-                                if (callPath.node.callee.property.name === "addScalarType" ||
-                                    callPath.node.callee.property.name === "scalarType") {
-                                    callPath.node.callee.property =
-                                        types.identifier("scalarType");
-                                    callPath.node.arguments = [
-                                        callPath.node.arguments[0],
-                                        dummyResolverId,
-                                    ];
-                                }
-                                const bindings = getBindings(callPath, globalPaths);
-                                for (const binding of bindings) {
-                                    globalPaths.add(findRootBinding(binding).node);
-                                }
-                                globalPaths.add(findRootBinding(callPath).node);
-                            },
-                            ExportDeclaration(exportPath) {
-                                globalPaths.add(exportPath.node);
-                            },
-                        });
-                    },
-                },
-            },
-        ],
-    });
-    if (!transformed)
-        throw new Error("Could not transform file");
-    const contents = generator.default(types.program([...globalPaths]));
-    return contents.code;
-}
-function getBindings(path, globalPaths) {
-    const bindings = [];
-    path.traverse({
-        Expression(expressionPath) {
-            if (!expressionPath.isIdentifier())
-                return;
-            const binding = path.scope.getBinding(expressionPath);
-            if (!binding ||
-                globalPaths.has(binding.path) ||
-                bindings.includes(binding.path))
-                return;
-            const rootBinding = findRootBinding(binding.path);
-            // prevents infinite loop in a few cases like having arguments in a function declaration
-            // if the path being checked is the same as the latest path, then the bindings will be same
-            if (path === rootBinding) {
-                bindings.push(binding.path);
-                return;
-            }
-            const bindingOfBindings = getBindings(rootBinding, globalPaths);
-            bindings.push(...bindingOfBindings, binding.path);
-        },
-    });
-    for (const binding of bindings) {
-        globalPaths.add(findRootBinding(binding).node);
-    }
-    return bindings;
-}
-function findRootBinding(path) {
-    let rootPath = path;
-    while (rootPath.parentPath?.node !== undefined &&
-        !rootPath.parentPath?.isProgram()) {
-        rootPath = rootPath.parentPath;
-    }
-    return rootPath;
-}

package/project.d.ts

@@ -1,75 +0,0 @@
-import { Metafile } from "esbuild";
-import type { App } from "./constructs/App.js";
-export interface SSTConfig {
-    config: (globals: GlobalOptions) => Promise<ConfigOptions> | ConfigOptions;
-    stacks: (app: App) => Promise<void> | void;
-}
-export interface ConfigOptions {
-    name: string;
-    region?: string;
-    stage?: string;
-    profile?: string;
-    role?: string;
-    ssmPrefix?: string;
-    outputs?: string;
-    advanced?: {
-        disableParameterizedStackNameCheck?: boolean;
-        disableAppModeCheck?: boolean;
-    };
-    bootstrap?: {
-        useCdkBucket?: boolean;
-        stackName?: string;
-        tags?: Record<string, string>;
-    };
-    cdk?: {
-        toolkitStackName?: string;
-        qualifier?: string;
-        bootstrapStackVersionSsmParameter?: string;
-        fileAssetsBucketName?: string;
-        customPermissionsBoundary?: string;
-        publicAccessBlockConfiguration?: boolean;
-        deployRoleArn?: string;
-        fileAssetPublishingRoleArn?: string;
-        imageAssetPublishingRoleArn?: string;
-        imageAssetsRepositoryName?: string;
-        cloudFormationExecutionRole?: string;
-        lookupRoleArn?: string;
-        pathMetadata?: boolean;
-    };
-}
-declare const DEFAULTS: {
-    readonly stage: undefined;
-    readonly ssmPrefix: undefined;
-};
-interface Project {
-    config: ConfigOptions & Required<{
-        [key in keyof typeof DEFAULTS]: Exclude<ConfigOptions[key], undefined>;
-    }>;
-    version: string;
-    cdkVersion: string;
-    constructsVersion: string;
-    paths: {
-        root: string;
-        config: string;
-        out: string;
-        artifacts: string;
-    };
-    metafile: Metafile;
-    stacks: SSTConfig["stacks"];
-}
-export declare function useProject(): Project;
-interface GlobalOptions {
-    profile?: string;
-    role?: string;
-    stage?: string;
-    root?: string;
-    region?: string;
-}
-export declare function initProject(globals: GlobalOptions): Promise<void>;
-declare function sanitizeStageName(stage: string): string;
-declare function isValidStageName(stage: string): boolean;
-export declare const exportedForTesting: {
-    sanitizeStageName: typeof sanitizeStageName;
-    isValidStageName: typeof isValidStageName;
-};
-export {};