@sst-community/sst 4.20.0 → 5.0.0-alpha.1

package/platform/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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"}

package/platform/types/global-aliases.d.ts

@@ -0,0 +1,37 @@
+// The globals that are aliases of modules, `sst` and `$util`, which an app's
+// config.d.ts has with global.d.ts. They're on their own so that the
+// platform's declarations are built without them: then the declarations name
+// SST's and Pulumi's types through their modules, as `sst/components` does,
+// and a component package reads them without an app's config.d.ts. The docs
+// put them back in global.d.ts (www/generate.ts).
+import * as util from "@pulumi/pulumi";
+import * as _sst from "./components/index";
+
+declare global {
+  // @ts-expect-error
+  export import sst = _sst;
+
+  /**
+   * A convenience reference to the [`util`](https://www.pulumi.com/docs/reference/pkg/nodejs/pulumi/pulumi/) module from Pulumi.
+   *
+   * This is useful for working with components. You can use these without importing or installing the Pulumi SDK.
+   *
+   * @example
+   *
+   * For example, to create a new asset, you can:
+   *
+   * ```ts title="sst.config.ts"
+   * const myFiles = new $util.asset.FileArchive("./path/to/files");
+   * ```
+   *
+   * This is equivalent to doing:
+   *
+   * ```ts title="sst.config.ts"
+   * import * as pulumi from "@pulumi/pulumi";
+   *
+   * const myFiles = new pulumi.asset.FileArchive("./path/to/files");
+   * ```
+   */
+  // @ts-expect-error
+  export import $util = util;
+}

package/platform/types/global.d.ts

@@ -0,0 +1,374 @@
+/**
+ * The Global library is a collection of `$` functions and variables that are available in the `run` function, of your [`sst.config.ts`](/docs/reference/config/).
+ *
+ * You don't need to import the Global library. It's available in the `run` function of your `sst.config.ts`.
+ *
+ * :::note
+ * The Global library is only available in the `run` function of your `sst.config.ts`.
+ * :::
+ *
+ * For example, you can get the name of your app in your app config using `$app.name`.
+ *
+ * ```ts title="sst.config.ts" {4}
+ * export default $config({
+ *   // ...
+ *   async run() {
+ *     console.log($app.name);
+ *   }
+ * });
+ * ```
+ *
+ * The **variables** contain the context of the app that's being run. While the **functions** help you work with the [Outputs of components](/docs/components##inputs--outputs).
+ *
+ * @packageDocumentation
+ */
+
+import "@types/node";
+import * as util from "@pulumi/pulumi";
+import { $config as config, App } from "./config";
+
+type Simplify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+/** @internal */
+interface $APP
+  extends Readonly<{
+    /**
+     * The name of the current app.
+     */
+    name: string;
+    /**
+     * The stage currently being run. You can use this to conditionally deploy resources based
+     * on the stage.
+     *
+     * For example, to deploy a bucket only in the `dev` stage:
+     *
+     * ```ts title="sst.config.ts"
+     * if ($app.stage === "dev") {
+     *   new sst.aws.Bucket("MyBucket");
+     * }
+     * ```
+     */
+    stage: string;
+    /**
+     * The removal policy for the current stage. If `removal` was not set in the `sst.config.ts`, this will be return its default value, `retain`.
+     */
+    removal: "remove" | "retain" | "retain-all";
+    /**
+     * The providers currently being used in the app.
+     */
+    providers: App["providers"];
+
+    /**
+     * If true, prevents `sst remove` from being executed on this stage
+     */
+    protect: boolean;
+  }> {}
+
+declare global {
+  /** @internal */
+  export const $linkable: typeof import("./components/link").Link.linkable;
+
+  /** @internal */
+  export const $output: typeof util.output;
+  /**
+   * Wait for a list of Output values to be resolved, and then apply a function to their resolved values.
+   *
+   * @example
+   * Say you had a couple of S3 Buckets:
+   * ```ts title="sst.config.ts"
+   * const bucket1 = new sst.aws.Bucket("MyBucket1");
+   * const bucket2 = new sst.aws.Bucket("MyBucket2");
+   * ```
+   *
+   * You can run a function after both of them are resolved:
+   *
+   * ```ts title="sst.config.ts"
+   * $resolve([bucket1.name, bucket2.name]).apply(([value1, value2]) =>
+   *   console.log({ value1, value2 })
+   * );
+   * ```
+   */
+  export function $resolve<T extends Record<string, any>>(
+    val: T,
+  ): util.Output<util.Unwrap<T>>;
+  export function $resolve<T1, T2, T3, T4, T5, T6, T7, T8>(
+    values: [
+      util.Input<T1>,
+      util.Input<T2>,
+      util.Input<T3>,
+      util.Input<T4>,
+      util.Input<T5>,
+      util.Input<T6>,
+      util.Input<T7>,
+      util.Input<T8>,
+    ],
+  ): util.Output<
+    [
+      util.Unwrap<T1>,
+      util.Unwrap<T2>,
+      util.Unwrap<T3>,
+      util.Unwrap<T4>,
+      util.Unwrap<T5>,
+      util.Unwrap<T6>,
+      util.Unwrap<T7>,
+      util.Unwrap<T8>,
+    ]
+  >;
+  export function $resolve<T1, T2, T3, T4, T5, T6, T7>(
+    values: [
+      util.Input<T1>,
+      util.Input<T2>,
+      util.Input<T3>,
+      util.Input<T4>,
+      util.Input<T5>,
+      util.Input<T6>,
+      util.Input<T7>,
+    ],
+  ): util.Output<
+    [
+      util.Unwrap<T1>,
+      util.Unwrap<T2>,
+      util.Unwrap<T3>,
+      util.Unwrap<T4>,
+      util.Unwrap<T5>,
+      util.Unwrap<T6>,
+      util.Unwrap<T7>,
+    ]
+  >;
+  export function $resolve<T1, T2, T3, T4, T5, T6>(
+    values: [
+      util.Input<T1>,
+      util.Input<T2>,
+      util.Input<T3>,
+      util.Input<T4>,
+      util.Input<T5>,
+      util.Input<T6>,
+    ],
+  ): util.Output<
+    [
+      util.Unwrap<T1>,
+      util.Unwrap<T2>,
+      util.Unwrap<T3>,
+      util.Unwrap<T4>,
+      util.Unwrap<T5>,
+      util.Unwrap<T6>,
+    ]
+  >;
+  export function $resolve<T1, T2, T3, T4, T5>(
+    values: [
+      util.Input<T1>,
+      util.Input<T2>,
+      util.Input<T3>,
+      util.Input<T4>,
+      util.Input<T5>,
+    ],
+  ): util.Output<
+    [
+      util.Unwrap<T1>,
+      util.Unwrap<T2>,
+      util.Unwrap<T3>,
+      util.Unwrap<T4>,
+      util.Unwrap<T5>,
+    ]
+  >;
+  export function $resolve<T1, T2, T3, T4>(
+    values: [util.Input<T1>, util.Input<T2>, util.Input<T3>, util.Input<T4>],
+  ): util.Output<[Unwrap<T1>, util.Unwrap<T2>, Unwrap<T3>, Unwrap<T4>]>;
+  export function $resolve<T1, T2, T3>(
+    values: [util.Input<T1>, util.Input<T2>, util.Input<T3>],
+  ): util.Output<[util.Unwrap<T1>, util.Unwrap<T2>, util.Unwrap<T3>]>;
+  export function $resolve<T1, T2>(
+    values: [util.Input<T1>, util.Input<T2>],
+  ): util.Output<[Unwrap<T1>, util.Unwrap<T2>]>;
+  /**
+   * Use string interpolation on Output values.
+   *
+   * @example
+   * This is takes care of resolving the Output values for you. Say you had a bucket:
+   *
+   * ```ts title="sst.config.ts"
+   * const bucket = new sst.aws.Bucket("MyBucket");
+   * ```
+   *
+   * Instead of resolving the bucket name first:
+   *
+   * ```ts title="sst.config.ts"
+   * const description = bucket.name.apply(name => `This is a bucket named ${name}`);
+   * ```
+   *
+   * You can directly do this:
+   * ```ts title="sst.config.ts"
+   * const description = $interpolate`This is a bucket named ${bucket.name}`;
+   * ```
+   */
+  export const $interpolate: typeof util.interpolate;
+  /**
+   * Takes a sequence of Output values or plain JavaScript values, stringifies each,
+   * and concatenates them into one final string.
+   *
+   * @example
+   * This is takes care of resolving the Output values for you. Say you had a bucket:
+   *
+   * ```ts title="sst.config.ts"
+   * const bucket = new sst.aws.Bucket("MyBucket");
+   * ```
+   *
+   * Instead of having to resolve the bucket name first::
+   *
+   * ```ts title="sst.config.ts"
+   * const description = bucket.name.apply(name =>
+   *   "This is a bucket named ".concat(name)
+   * );
+   * ```
+   *
+   * You can directly do this:
+   *
+   * ```ts title="sst.config.ts"
+   * const description = $concat("This is a bucket named ", bucket.name);
+   * ```
+   */
+  export const $concat: typeof util.concat;
+  /**
+   * Takes an Output value or plain JavaScript value, uses `JSON.parse`
+   * on the resolved JSON string to turn it into a JSON object.
+   *
+   * @example
+   * So for example, instead of doing of resolving the value first:
+   *
+   * ```ts title="sst.config.ts"
+   * const policy = policyStr.apply((policy) =>
+   *   JSON.parse(policy)
+   * );
+   * ```
+   *
+   * You can directly do this:
+   *
+   * ```ts title="sst.config.ts"
+   * const policy = $jsonParse(policyStr);
+   * ```
+   */
+  export const $jsonParse: typeof util.jsonParse;
+  /**
+   * Takes an Output value or plain JSON object, uses `JSON.stringify`
+   * on the resolved JSON object to turn it into a JSON string.
+   *
+   * @example
+   * So for example, instead of doing of resolving the value first:
+   *
+   * ```ts title="sst.config.ts"
+   * const policy = policyObj.apply((policy) =>
+   *   JSON.stringify(policy)
+   * );
+   * ```
+   *
+   * You can directly do this:
+   *
+   * ```ts title="sst.config.ts"
+   * const policy = $jsonStringify(policyObj);
+   * ```
+   */
+  export const $jsonStringify: typeof util.jsonStringify;
+
+  /**
+   * Context about the app being run.
+   */
+  export const $app: Simplify<$APP>;
+
+  /**
+   * Register a function that'll be called when a component of the given type is about
+   * to be created. This is useful for setting global defaults for your components.
+   *
+   * :::note
+   * This function is only called for components that are created **after** the function is registered.
+   * :::
+   *
+   * The function takes the arguments and options that are being passed to the component,
+   * and can modify them.
+   *
+   * @example
+   *
+   * For example, to set a default runtime for all function components.
+   *
+   * ```ts title="sst.config.ts"
+   * $transform(sst.aws.Function, (args, opts, name) => {
+   *   // Set the default if it's not set by the component
+   *   args.runtime ??= "nodejs24.x";
+   * });
+   * ```
+   *
+   * Here, `args`, `opts` and `name` are what you'd pass to the `Function` component. Recall
+   * the signature of the `Function` component:
+   *
+   * ```ts title="sst.config.ts"
+   * new sst.aws.Function(name: string, args: FunctionArgs, opts?: pulumi.ComponentResourceOptions)
+   * ```
+   */
+  export const $transform: typeof import("./components/component").$transform;
+
+  /**
+   * Packages a file or directory into a Pulumi asset. This can be used for Pulumi resources that
+   * take an asset as input.
+   *
+   * When the given path is a file, it returns a
+   * [`FileAsset`](https://www.pulumi.com/docs/iac/concepts/assets-archives/#assets). If the
+   * path is a directory, it returns a
+   * [`FileArchive`](https://www.pulumi.com/docs/iac/concepts/assets-archives/#assets) with the
+   * zipped contents of the directory.
+   *
+   * :::tip
+   * This automatically resolves paths relative to the root of the app.
+   * :::
+   *
+   * Relative paths are resolved relative to the root of the app. While, absolute paths are used as is.
+   *
+   * @example
+   *
+   * If you have a file inside the `images` directory at the root of your app, you can upload it
+   * to S3 on deploy.
+   *
+   * ```ts title="sst.config.ts" {7}
+   * const bucket = new aws.s3.Bucket("MyBucket");
+   *
+   * new aws.s3.BucketObjectv2("MyImage", {
+   *   bucket: bucket.name,
+   *   key: "public/spongebob.svg",
+   *   contentType: "image/svg+xml",
+   *   source: $asset("images/spongebob.svg"),
+   * });
+   * ```
+   *
+   * You can also use this to zip up the files in the `files/` directory and upload it to S3.
+   *
+   * ```ts title="sst.config.ts" {5}
+   * new aws.s3.BucketObjectv2("MyZip", {
+   *   bucket: bucket.name,
+   *   key: "public/spongebob.zip",
+   *   contentType: "application/zip",
+   *   source: $asset("files"),
+   * });
+   * ```
+   */
+  export const $asset: typeof import("./components/component").$asset;
+
+  /**
+   * Returns `true` if the app is running in `sst dev`.
+   */
+  export const $dev: boolean;
+
+  /** @internal */
+  export const $cli: {
+    command: string;
+    rpc: string;
+    paths: {
+      home: string;
+      root: string;
+      work: string;
+      platform: string;
+    };
+    state: {
+      version: Record<string, number>;
+    };
+  };
+}

package/platform/types/internal.d.ts

@@ -0,0 +1,18 @@
+declare global {
+  export const $cli: {
+    command: string;
+    rpc: string;
+    paths: {
+      home: string;
+      root: string;
+      work: string;
+      platform: string;
+    };
+    home: string;
+    state: {
+      version: Record<string, number>;
+    };
+  };
+}
+
+export const {};

package/platform/types/runtime/worker/unenv.d.ts

@@ -0,0 +1,14 @@
+export interface CloudflareUnenvInput {
+  date?: string;
+  flags?: string[];
+}
+
+export interface CloudflareUnenvConfig {
+  alias: Record<string, string>;
+  external: string[];
+  polyfill: string[];
+}
+
+export function getCloudflareUnenvConfig(
+  input?: CloudflareUnenvInput,
+): CloudflareUnenvConfig;

package/platform/types/testing/global.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The `sst` global a test is given: what SST's components share, and the
+ * components of each provider whose packages are installed. A config's `sst`
+ * has every group, and a deploy's bundle keeps the ones the app uses. A test
+ * loads what it's given without a bundler, so a group the app hasn't
+ * installed is left out, and says what to install when a test uses it.
+ */
+export declare function sstGlobal(providers?: Record<string, string[]>): Promise<Record<string, unknown>>;
+/** Those of `names` that SST's components can't load */
+export declare function notInstalled(names: string[]): string[];
+//# sourceMappingURL=global.d.ts.map

package/platform/types/testing/global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../../../src/testing/global.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,SAAS,2BAAmB,oCA6B3D;AA2BD,wDAAwD;AACxD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,YAY3C"}

package/platform/types/testing/index.d.ts

@@ -0,0 +1,80 @@
+import { type MockInput } from "./mock";
+export type { MockInput, RecordedResource } from "./mock";
+/**
+ * Test a component without deploying it. `mock()` stands in for the engine
+ * that deploys your app and gives your test what your `sst.config.ts` has:
+ * `sst`, your providers like `aws`, `$app`, `$dev` and the other `$` globals.
+ *
+ * Nothing is deployed and no provider is called. Each resource your component
+ * creates is recorded, with the inputs and options it was given, and comes
+ * back with an id and an ARN made from its name.
+ *
+ * Call it before the file that defines your component is loaded, if that
+ * file reads `sst` or `aws` when it loads. `sst/components` and the
+ * components of each provider, like `sst/components/aws`, can be imported
+ * anywhere.
+ *
+ * `sst` has the components of each provider whose packages are installed,
+ * like `sst.aws`. Using one that isn't fails, and says what to install.
+ *
+ * @example
+ * ```ts title="uploads.test.ts"
+ * import { expect, test } from "vitest";
+ * import { mock } from "./.sst/platform/src/testing";
+ *
+ * const app = await mock();
+ * const { Uploads } = await import("./infra/uploads");
+ *
+ * test("creates a role for each team", async () => {
+ *   app.reset();
+ *   new Uploads("Docs", { teams: ["design", "legal"] });
+ *   await app.settle();
+ *
+ *   expect(app.resources.map((r) => r.name)).toContain("DocsReaderLegal");
+ * });
+ * ```
+ */
+export declare function mock(input?: MockInput & {
+    dev?: boolean;
+}): Promise<{
+    resources: import("./mock").RecordedResource[];
+    input: MockInput | undefined;
+    deployed: (graph: import("./mock").RecordedResource[]) => import("./mock").RecordedResource[];
+    reset(): void;
+    outputsOf(name: string): Record<string, any> | undefined;
+    settle(): Promise<void>;
+    resolve<T>(value: T): Promise<any>;
+    dependsOn(from: string, to: string | RegExp): boolean;
+    graph(): {
+        build?: Record<string, any>;
+        outputs?: Record<string, any>;
+        inputs: any;
+        kind: "register" | "read";
+        type: string;
+        name: string;
+        parent: string;
+        custom: boolean;
+        options: Record<string, any>;
+    }[];
+    takesOver(original: () => unknown, v5: () => unknown): Promise<{
+        unclaimed: string[];
+        changed: {
+            fields: string[];
+            name: string;
+            original: any;
+            now: any;
+        }[];
+        unordered: string[];
+    }>;
+    takeover(original: import("./mock").RecordedResource[]): {
+        unclaimed: string[];
+        changed: {
+            fields: string[];
+            name: string;
+            original: any;
+            now: any;
+        }[];
+        unordered: string[];
+    };
+}>;
+//# sourceMappingURL=index.d.ts.map

package/platform/types/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,SAAS,EAAc,MAAM,QAAQ,CAAC;AAEpD,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,IAAI,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0C/D"}

package/platform/types/testing/mock.d.ts

@@ -0,0 +1,136 @@
+import * as pulumi from "@pulumi/pulumi";
+/**
+ * A resource a component registered, with what decides whether a deployed
+ * app would see a change: its inputs, its parent, and options like aliases,
+ * `ignoreChanges` and `retainOnDelete`.
+ *
+ * A difference between two of these is a difference `sst diff` would show on
+ * a deployed stage.
+ */
+export interface RecordedResource {
+    kind: "register" | "read";
+    type: string;
+    name: string;
+    parent: string;
+    custom: boolean;
+    inputs: Record<string, any>;
+    options: Record<string, any>;
+    /** What a component registered as its outputs. The CLI reads some of them. */
+    outputs?: Record<string, any>;
+    /**
+     * What the CLI was given to build a function's code from: its handler,
+     * runtime and links. The links go into the code, so they aren't in any
+     * resource's inputs.
+     */
+    build?: Record<string, any>;
+}
+export interface MockInput {
+    /** The app's name. Defaults to "app". */
+    app?: string;
+    /** The stage. Defaults to "test". */
+    stage?: string;
+    /** The root of the app, which paths like a function's handler are relative to. */
+    root?: string;
+    /**
+     * For the platform's own takeover tests: the components a 4.x component
+     * wraps things in, which go when its V5 component takes over.
+     */
+    wrappers?: RegExp;
+    /** Extra state for a resource, on top of its inputs. */
+    state?: (args: pulumi.runtime.MockResourceArgs) => Record<string, any>;
+    /** The result of a provider function call, like a data source lookup. */
+    call?: (args: pulumi.runtime.MockCallArgs) => Record<string, any> | undefined;
+    /** The source maps the build of a function writes, by the function's name. */
+    sourcemaps?: (functionID: string) => string[];
+}
+/**
+ * Stands in for the Pulumi engine and for the CLI, and records what's
+ * registered. Nothing is deployed: a resource comes back with the inputs it
+ * was given, and an id and ARN made from its name.
+ *
+ * This is the part of `mock()` that needs nothing loaded. It sets the
+ * globals the components read, and not the ones a config has, like `sst`.
+ */
+export declare function mockPulumi(input?: MockInput): {
+    resources: RecordedResource[];
+    /** What the mock was created with. */
+    input: MockInput | undefined;
+    /** What a deploy leaves in the state, of a `graph()`. */
+    deployed: (graph: RecordedResource[]) => RecordedResource[];
+    /** Empties the list, so each test sees only its own resources. */
+    reset(): void;
+    /** The outputs a component registered, by the component's name. */
+    outputsOf(name: string): Record<string, any> | undefined;
+    /**
+     * Lets pending `.apply()` chains and registrations finish: waits until
+     * nothing new has been registered for a few rounds, resources or a
+     * component's outputs, and nothing is being read or written on disk.
+     */
+    settle(): Promise<void>;
+    /** The value of an output, or of anything holding outputs. */
+    resolve<T>(value: T): Promise<any>;
+    /**
+     * Whether a resource depends on another, directly or through what it
+     * depends on. A deploy removes resources in the reverse of that order,
+     * so it's also whether the first is removed before the second.
+     *
+     * @param from The name of the resource.
+     * @param to The name of what it should depend on, or a pattern for it.
+     */
+    dependsOn(from: string, to: string | RegExp): boolean;
+    /** The recorded graph in a stable order, ready to compare. */
+    graph(): {
+        build?: Record<string, any>;
+        outputs?: Record<string, any>;
+        inputs: any;
+        kind: "register" | "read";
+        type: string;
+        name: string;
+        parent: string;
+        custom: boolean;
+        options: Record<string, any>;
+    }[];
+    /**
+     * Deploys a component, then what replaces it, and checks the second
+     * against the first with `takeover()`: a V5 component against the one it
+     * takes over from, or a component against how it was before a change.
+     *
+     * @param original Creates the component that's deployed.
+     * @param v5 Creates the same thing with what replaces it.
+     */
+    takesOver(original: () => unknown, v5: () => unknown): Promise<{
+        unclaimed: string[];
+        changed: {
+            fields: string[];
+            name: string;
+            original: any;
+            now: any;
+        }[];
+        unordered: string[];
+    }>;
+    /**
+     * Checks that what's registered now takes over from an original graph:
+     * each original resource has to be claimed by one resource registered
+     * now, under the same address or through an alias, and with the same
+     * inputs.
+     *
+     * A resource claimed this way is kept on deploy. One that isn't claimed
+     * is deleted, and one whose inputs changed is updated or replaced.
+     * `unordered` lists what the original removed in order and this doesn't:
+     * "MyService before MyNamespace".
+     *
+     * @param original The `graph()` of what's deployed: taken a moment ago,
+     * or saved to a file and read back.
+     */
+    takeover(original: RecordedResource[]): {
+        unclaimed: string[];
+        changed: {
+            fields: string[];
+            name: string;
+            original: any;
+            now: any;
+        }[];
+        unordered: string[];
+    };
+};
+//# sourceMappingURL=mock.d.ts.map