sst 2.0.35 → 2.0.36

package/node/kinesis-stream/index.js

@@ -1,3 +1,3 @@
-import { createProxy, parseEnvironment } from "../util/index.js";
+import { createProxy, getVariables } from "../util/index.js";
 export const KinesisStream = createProxy("KinesisStream");
-Object.assign(KinesisStream, parseEnvironment("KinesisStream", ["streamName"]));
+Object.assign(KinesisStream, getVariables("KinesisStream"));

package/node/queue/index.js

@@ -1,3 +1,3 @@
-import { createProxy, parseEnvironment } from "../util/index.js";
+import { createProxy, getVariables } from "../util/index.js";
 export const Queue = createProxy("Queue");
-Object.assign(Queue, parseEnvironment("Queue", ["queueUrl"]));
+Object.assign(Queue, getVariables("Queue"));

package/node/rds/index.js

@@ -1,3 +1,3 @@
-import { createProxy, parseEnvironment } from "../util/index.js";
+import { createProxy, getVariables } from "../util/index.js";
 export const RDS = createProxy("RDS");
-Object.assign(RDS, parseEnvironment("RDS", ["clusterArn", "secretArn", "defaultDatabaseName"]));
+Object.assign(RDS, getVariables("RDS"));

package/node/site/index.js

@@ -1,62 +1,16 @@
-import { GetParametersCommand, SSMClient, } from "@aws-sdk/client-ssm";
-const ssm = new SSMClient({});
-import { createProxy, parseEnvironment, buildSsmPath, ssmNameToConstructId, } from "../util/index.js";
+import { createProxy, getVariables } from "../util/index.js";
 export const StaticSite = createProxy("StaticSite");
 export const ReactStaticSite = createProxy("ReactStaticSite");
 export const ViteStaticSite = createProxy("ViteStaticSite");
 export const RemixSite = createProxy("RemixSite");
 export const NextjsSite = createProxy("NextjsSite");
-const staticSiteData = parseEnvironment("StaticSite", ["url"]);
-const reactSiteData = parseEnvironment("ReactStaticSite", ["url"]);
-const viteSiteData = parseEnvironment("ViteStaticSite", ["url"]);
-const nextjsSiteData = parseEnvironment("NextjsSite", ["url"]);
-const remixSiteData = parseEnvironment("RemixSite", ["url"]);
-await replaceWithSsmValues("StaticSite", staticSiteData);
-await replaceWithSsmValues("ReactStaticSite", reactSiteData);
-await replaceWithSsmValues("ViteStaticSite", viteSiteData);
-await replaceWithSsmValues("NextjsSite", nextjsSiteData);
-await replaceWithSsmValues("RemixSite", remixSiteData);
+const staticSiteData = getVariables("StaticSite");
+const reactSiteData = getVariables("ReactStaticSite");
+const viteSiteData = getVariables("ViteStaticSite");
+const nextjsSiteData = getVariables("NextjsSite");
+const remixSiteData = getVariables("RemixSite");
 Object.assign(StaticSite, staticSiteData);
 Object.assign(ReactStaticSite, reactSiteData);
 Object.assign(ViteStaticSite, viteSiteData);
 Object.assign(NextjsSite, nextjsSiteData);
 Object.assign(RemixSite, remixSiteData);
-async function replaceWithSsmValues(className, siteData) {
-    // Find all the site data that match the prefix
-    const names = Object.keys(siteData).filter((name) => siteData[name].url === "__FETCH_FROM_SSM__");
-    if (names.length === 0) {
-        return;
-    }
-    // Fetch all secrets
-    const results = await loadSsm(className, names);
-    if (results.invalidParams.length > 0) {
-        const missingNames = results.invalidParams.map(ssmNameToConstructId);
-        throw new Error(`The following ${className} were not found: ${missingNames.join(", ")}`);
-    }
-    // Store all secrets in a map
-    for (const item of results.validParams) {
-        const name = ssmNameToConstructId(item.Name);
-        // @ts-ignore
-        siteData[name] = { url: item.Value };
-    }
-}
-async function loadSsm(className, names) {
-    // Split names into chunks of 10
-    const chunks = [];
-    for (let i = 0; i < names.length; i += 10) {
-        chunks.push(names.slice(i, i + 10));
-    }
-    // Fetch secrets
-    const validParams = [];
-    const invalidParams = [];
-    await Promise.all(chunks.map(async (chunk) => {
-        const command = new GetParametersCommand({
-            Names: chunk.map((name) => buildSsmPath(className, name, "url")),
-            WithDecryption: true,
-        });
-        const result = await ssm.send(command);
-        validParams.push(...(result.Parameters || []));
-        invalidParams.push(...(result.InvalidParameters || []));
-    }));
-    return { validParams, invalidParams };
-}

package/node/table/index.js

@@ -1,3 +1,3 @@
-import { createProxy, parseEnvironment } from "../util/index.js";
+import { createProxy, getVariables } from "../util/index.js";
 export const Table = createProxy("Table");
-Object.assign(Table, parseEnvironment("Table", ["tableName"]));
+Object.assign(Table, getVariables("Table"));

package/node/topic/index.js

@@ -1,3 +1,3 @@
-import { createProxy, parseEnvironment } from "../util/index.js";
+import { createProxy, getVariables } from "../util/index.js";
 export const Topic = createProxy("Topic");
-Object.assign(Topic, parseEnvironment("Topic", ["topicArn"]));
+Object.assign(Topic, getVariables("Topic"));

package/node/util/index.d.ts

@@ -1,7 +1,2 @@
 export declare function createProxy<T extends object>(constructName: string): T;
-export declare function parseEnvironment(constructName: string, props: string[]): Record<string, Record<string, string>>;
-export declare function buildSsmPath(constructName: string, id: string, prop: string): string;
-export declare function buildSsmFallbackPath(constructName: string, id: string, prop: string): string;
-export declare function ssmNameToConstructId(ssmName: string): string;
-export declare function ssmFallbackNameToConstructId(ssmName: string): string;
-export declare function ssmNameToPropName(ssmName: string): string | undefined;
+export declare function getVariables(constructName: string): Record<string, Record<string, string>>;

package/node/util/index.js

@@ -1,3 +1,15 @@
+import { GetParametersCommand, SSMClient, } from "@aws-sdk/client-ssm";
+const ssm = new SSMClient({});
+// Example:
+// {
+//   Bucket: {
+//     myBucket: {
+//       name: "my-bucket",
+//     }
+//   }
+// }
+let allVariables = {};
+await parseEnvironment();
 export function createProxy(constructName) {
     return new Proxy({}, {
         get(target, prop) {
@@ -13,41 +25,119 @@ export function createProxy(constructName) {
         },
     });
 }
-export function parseEnvironment(constructName, props) {
-    const acc = {};
+export function getVariables(constructName) {
+    return allVariables[constructName] || {};
+}
+async function parseEnvironment() {
+    const variablesFromSsm = [];
+    const variablesFromSecret = [];
     Object.keys(process.env)
-        .filter((env) => env.startsWith(buildEnvPrefix(constructName, props[0])))
-        .forEach((env) => {
-        const name = env.replace(new RegExp(`^${buildEnvPrefix(constructName, props[0])}`), "");
-        // @ts-ignore
-        acc[name] = {};
-        props.forEach((prop) => {
-            // @ts-ignore
-            acc[name][prop] =
-                process.env[`${buildEnvPrefix(constructName, prop)}${name}`];
-        });
+        .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 acc;
+    return allVariables;
 }
-function buildEnvPrefix(constructName, prop) {
-    return `SST_${constructName}_${prop}_`;
+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);
+    });
 }
-export function buildSsmPath(constructName, id, prop) {
-    return `${ssmPrefix()}${constructName}/${id}/${prop}`;
+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 };
 }
-export function buildSsmFallbackPath(constructName, id, prop) {
-    return `/sst/${process.env.SST_APP}/.fallback/${constructName}/${id}/${prop}`;
+function parseEnvName(env) {
+    const [_SST, constructName, propName, ...idParts] = env.split("_");
+    return {
+        constructName,
+        constructId: idParts.join("_"),
+        propName,
+    };
 }
-export function ssmNameToConstructId(ssmName) {
+function parseSsmPath(path) {
     const prefix = ssmPrefix();
-    return ssmName.substring(prefix.length).split("/")[1];
+    const parts = path.substring(prefix.length).split("/");
+    return {
+        constructName: parts[0],
+        constructId: parts[1],
+        propName: parts[2],
+    };
 }
-export function ssmFallbackNameToConstructId(ssmName) {
-    return ssmName.split("/")[5];
+function parseSsmFallbackPath(path) {
+    const parts = path.split("/");
+    return {
+        constructName: parts[4],
+        constructId: parts[5],
+        propName: parts[6],
+    };
 }
-export function ssmNameToPropName(ssmName) {
-    const prefix = ssmPrefix();
-    return ssmName.substring(prefix.length).split("/").pop();
+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, "_");
@@ -55,3 +145,9 @@ function normalizeId(name) {
 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.0.35",
+  "version": "2.0.36",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/node.js

@@ -118,6 +118,8 @@ export const useNodeHandler = Context.memo(async () => {
                             js: [
                                 `import { createRequire as topLevelCreateRequire } from 'module';`,
                                 `const require = topLevelCreateRequire(import.meta.url);`,
+                                `import { fileURLToPath as topLevelFileUrlToPath } from "url"`,
+                                `const __dirname = topLevelFileUrlToPath(new URL(".", import.meta.url))`,
                                 nodejs.banner || "",
                             ].join("\n"),
                         },

package/sst.mjs

@@ -4869,6 +4869,8 @@ var init_node = __esm({
                 js: [
                   `import { createRequire as topLevelCreateRequire } from 'module';`,
                   `const require = topLevelCreateRequire(import.meta.url);`,
+                  `import { fileURLToPath as topLevelFileUrlToPath } from "url"`,
+                  `const __dirname = topLevelFileUrlToPath(new URL(".", import.meta.url))`,
                   nodejs.banner || ""
                 ].join("\n")
               }