sst 4.12.1 → 4.12.3

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,5 @@
 export * from "./realtime/index.js";
-export * from "./resource/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 &&

package/dist/resource/cloudflare.d.ts

@@ -1,4 +1,5 @@
-import { Resource } from "./shared.js";
-export declare function fromCloudflareEnv(input: any): void;
+import type { Resource as BaseResource } from "./node.js";
 export declare function wrapCloudflareHandler(handler: any): any;
-export { Resource };
+export interface Resource extends BaseResource {
+}
+export declare const Resource: Resource;

package/dist/resource/cloudflare.js

@@ -1,8 +1,7 @@
 import { env } from "cloudflare:workers";
-import { loadFromCloudflareEnv, Resource } from "./shared.js";
-loadFromCloudflareEnv(env);
-export function fromCloudflareEnv(input) {
-    loadFromCloudflareEnv(input);
+import { createResource, loadResourceEnvironment } from "./shared.js";
+function loadCloudflareResources() {
+    loadResourceEnvironment(env);
 }
 export function wrapCloudflareHandler(handler) {
     if (handler == null) {
@@ -11,14 +10,14 @@ export function wrapCloudflareHandler(handler) {
     if (typeof handler === "function" && handler.hasOwnProperty("prototype")) {
         return class extends handler {
             constructor(ctx, env) {
-                loadFromCloudflareEnv(env);
+                loadResourceEnvironment(env);
                 super(ctx, env);
             }
         };
     }
     function wrap(fn) {
         return function (req, env, ...rest) {
-            loadFromCloudflareEnv(env);
+            loadResourceEnvironment(env);
             return fn(req, env, ...rest);
         };
     }
@@ -28,4 +27,4 @@ export function wrapCloudflareHandler(handler) {
     }
     return result;
 }
-export { Resource };
+export const Resource = createResource(loadCloudflareResources);

package/dist/resource/node.d.ts

@@ -1,2 +1,4 @@
-import { Resource } from "./shared.js";
-export { Resource };
+import type { Resource as BaseResource } from "./shared.js";
+export interface Resource extends BaseResource {
+}
+export declare const Resource: Resource;

package/dist/resource/node.js

@@ -1,33 +1,38 @@
 import crypto from "crypto";
 import { readFileSync } from "fs";
 import { env } from "process";
-import { loadResourceData, loadResourceEnvironment, Resource, } from "./shared.js";
-const environment = {
-    ...env,
-    ...globalThis.process?.env,
-};
-loadResourceEnvironment(environment);
-if (environment.SST_RESOURCES_JSON) {
-    try {
-        loadResourceData(JSON.parse(environment.SST_RESOURCES_JSON));
+import { createResource, loadResourceData, loadResourceEnvironment, } from "./shared.js";
+const state = globalThis;
+function loadNodeResources() {
+    const environment = {
+        ...env,
+        ...globalThis.process?.env,
+    };
+    loadResourceEnvironment(environment);
+    if (environment.SST_RESOURCES_JSON) {
+        try {
+            loadResourceData(JSON.parse(environment.SST_RESOURCES_JSON));
+        }
+        catch (error) {
+            console.error("Failed to parse SST_RESOURCES_JSON:", error);
+        }
     }
-    catch (error) {
-        console.error("Failed to parse SST_RESOURCES_JSON:", error);
+    if (environment.SST_KEY_FILE &&
+        environment.SST_KEY &&
+        !state.SST_KEY_FILE_DATA) {
+        const key = Buffer.from(environment.SST_KEY, "base64");
+        const encryptedData = readFileSync(environment.SST_KEY_FILE);
+        const nonce = Buffer.alloc(12, 0);
+        const decipher = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        const authTag = encryptedData.subarray(-16);
+        const actualCiphertext = encryptedData.subarray(0, -16);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(actualCiphertext);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        loadResourceData(JSON.parse(decrypted.toString()));
+    }
+    if (state.SST_KEY_FILE_DATA) {
+        loadResourceData(state.SST_KEY_FILE_DATA);
     }
 }
-if (environment.SST_KEY_FILE && environment.SST_KEY && !globalThis.SST_KEY_FILE_DATA) {
-    const key = Buffer.from(environment.SST_KEY, "base64");
-    const encryptedData = readFileSync(environment.SST_KEY_FILE);
-    const nonce = Buffer.alloc(12, 0);
-    const decipher = crypto.createDecipheriv("aes-256-gcm", key, nonce);
-    const authTag = encryptedData.subarray(-16);
-    const actualCiphertext = encryptedData.subarray(0, -16);
-    decipher.setAuthTag(authTag);
-    let decrypted = decipher.update(actualCiphertext);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    loadResourceData(JSON.parse(decrypted.toString()));
-}
-if (globalThis.SST_KEY_FILE_DATA) {
-    loadResourceData(globalThis.SST_KEY_FILE_DATA);
-}
-export { Resource };
+export const Resource = createResource(loadNodeResources);

package/dist/resource/shared.d.ts

@@ -6,5 +6,4 @@ export interface Resource {
 }
 export declare function loadResourceEnvironment(input?: Record<string, any>): void;
 export declare function loadResourceData(input?: Record<string, any>): void;
-export declare function loadFromCloudflareEnv(input: any): void;
-export declare const Resource: Resource;
+export declare function createResource<T extends Resource>(load: () => void): T;

package/dist/resource/shared.js

@@ -5,46 +5,58 @@ const raw = (state.__SST_RESOURCE_RAW__ ??= {
 });
 const environment = (state.__SST_RESOURCE_ENVIRONMENT__ ??= {});
 export function loadResourceEnvironment(input) {
-    for (const [key, value] of Object.entries(input ?? {})) {
+    for (let [key, value] of Object.entries(input ?? {})) {
         if (typeof value === "string") {
             environment[key] = value;
-        }
-        if (!key.startsWith("SST_RESOURCE_") || !value) {
+            if (!key.startsWith("SST_RESOURCE_") || !value) {
+                continue;
+            }
+            raw[key.slice("SST_RESOURCE_".length)] = JSON.parse(value);
             continue;
         }
-        raw[key.slice("SST_RESOURCE_".length)] = JSON.parse(value);
+        raw[key] = value;
     }
 }
 export function loadResourceData(input) {
     Object.assign(raw, input ?? {});
 }
-export function loadFromCloudflareEnv(input) {
-    for (let [key, value] of Object.entries(input)) {
-        if (typeof value === "string") {
-            environment[key] = value;
-            try {
-                value = JSON.parse(value);
+export function createResource(load) {
+    let loaded = false;
+    const loadData = () => {
+        if (loaded)
+            return;
+        load();
+        loaded = true;
+    };
+    return new Proxy(raw, {
+        get(_target, prop) {
+            loadData();
+            if (prop in raw) {
+                return raw[prop];
             }
-            catch { }
-        }
-        raw[key] = value;
-        if (key.startsWith("SST_RESOURCE_")) {
-            raw[key.replace("SST_RESOURCE_", "")] = value;
-        }
-    }
+            if (typeof prop !== "string") {
+                return undefined;
+            }
+            if (!environment.SST_RESOURCE_App && !raw.App) {
+                throw new Error("It does not look like SST links are active. If this is in local development and you are not starting this process through the multiplexer, wrap your command with `sst dev -- <command>`");
+            }
+            let msg = `"${prop}" is not linked in your sst.config.ts`;
+            if (environment.AWS_LAMBDA_FUNCTION_NAME) {
+                msg += ` to ${environment.AWS_LAMBDA_FUNCTION_NAME}`;
+            }
+            throw new Error(msg);
+        },
+        has(_target, prop) {
+            loadData();
+            return prop in raw;
+        },
+        ownKeys() {
+            loadData();
+            return Reflect.ownKeys(raw);
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            loadData();
+            return Object.getOwnPropertyDescriptor(raw, prop);
+        },
+    });
 }
-export const Resource = new Proxy(raw, {
-    get(_target, prop) {
-        if (prop in raw) {
-            return raw[prop];
-        }
-        if (!environment.SST_RESOURCE_App) {
-            throw new Error("It does not look like SST links are active. If this is in local development and you are not starting this process through the multiplexer, wrap your command with `sst dev -- <command>`");
-        }
-        let msg = `"${prop}" is not linked in your sst.config.ts`;
-        if (environment.AWS_LAMBDA_FUNCTION_NAME) {
-            msg += ` to ${environment.AWS_LAMBDA_FUNCTION_NAME}`;
-        }
-        throw new Error(msg);
-    },
-});

package/package.json

@@ -2,11 +2,8 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "sst",
   "type": "module",
-  "sideEffects": [
-    "./dist/resource/node.js",
-    "./dist/resource/cloudflare.js"
-  ],
-  "version": "4.12.1",
+  "sideEffects": false,
+  "version": "4.12.3",
   "main": "./dist/index.js",
   "repository": {
     "type": "git",
@@ -58,14 +55,14 @@
     "sst": "./bin/sst.mjs"
   },
   "optionalDependencies": {
-    "sst-linux-x64": "4.12.1",
-    "sst-linux-x86": "4.12.1",
-    "sst-darwin-x64": "4.12.1",
-    "sst-linux-arm64": "4.12.1",
-    "sst-darwin-arm64": "4.12.1",
-    "sst-win32-x64": "4.12.1",
-    "sst-win32-x86": "4.12.1",
-    "sst-win32-arm64": "4.12.1"
+    "sst-linux-x64": "4.12.3",
+    "sst-linux-x86": "4.12.3",
+    "sst-darwin-x64": "4.12.3",
+    "sst-linux-arm64": "4.12.3",
+    "sst-darwin-arm64": "4.12.3",
+    "sst-win32-x64": "4.12.3",
+    "sst-win32-x86": "4.12.3",
+    "sst-win32-arm64": "4.12.3"
   },
   "dependencies": {
     "@aws/durable-execution-sdk-js": "1.0.2",