alchemy 2.0.0-beta.73 → 2.0.0-beta.75

package/src/AWS/Website/ReactRouter.ts

@@ -0,0 +1,98 @@
+import type { InputProps } from "../../Input.ts";
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** The framework-integration package that drives the React Router build. */
+export const REACT_ROUTER_FRAMEWORK_SPECIFIER =
+  "@alchemy.run/frontend-frameworks/react-router";
+
+/** The AWS Lambda deploy target for the React Router build. */
+export const REACT_ROUTER_AWS_TARGET_SPECIFIER =
+  "@alchemy.run/frontend-frameworks/react-router/aws";
+
+export interface ReactRouterProps extends FrameworkSiteProps {}
+
+/**
+ * Deploy a [React Router](https://reactrouter.com) v7 app (framework mode)
+ * to AWS: the SSR server on a streaming Lambda Function URL, client assets
+ * in S3, and a CloudFront distribution whose edge router serves uploaded
+ * files from S3 and forwards everything else to the server.
+ *
+ * The build runs through
+ * `@alchemy.run/frontend-frameworks/react-router` with the
+ * `@alchemy.run/frontend-frameworks/react-router/aws` deploy target — both
+ * must be installed in your project, alongside `@react-router/dev`,
+ * `react-router`, and `vite`.
+ *
+ * Your `vite.config.ts` needs no adapter wiring. React Router's server
+ * build is a `ServerBuild` manifest rather than a request handler, so the
+ * integration makes the server pass's build input a module that wraps the
+ * manifest with `createRequestHandler`, forces the SSR bundle to be
+ * self-contained, and packages the resulting fetch handler as a streaming
+ * Lambda handler.
+ *
+ * React Server Components (React Router's `unstable` RSC plugin) and
+ * multi-environment builds are not supported yet — the build fails with an
+ * actionable error when more than one server entry is emitted.
+ *
+ * ### Creating React Router Sites
+ * **Example:** Basic React Router App
+ * ```typescript
+ * const site = yield* AWS.Website.ReactRouter("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* AWS.Website.ReactRouter("Web", {
+ *   rootDir: "./app",
+ *   domain: {
+ *     name: "app.example.com",
+ *     hostedZoneId: zone.hostedZoneId,
+ *   },
+ * });
+ * ```
+ *
+ * ### Server Configuration
+ * **Example:** Tune The Server Function
+ * ```typescript
+ * const site = yield* AWS.Website.ReactRouter("Web", {
+ *   rootDir: "./app",
+ *   memorySize: 2048,
+ *   env: {
+ *     API_BASE: api.url,
+ *   },
+ * });
+ * ```
+ *
+ * **Example:** Read An Environment Variable From A Loader
+ * ```typescript
+ * // app/routes/home.tsx
+ * export function loader() {
+ *   return { apiBase: process.env.API_BASE ?? "unset" };
+ * }
+ * ```
+ *
+ * ### Shared Router
+ * **Example:** Serve Through An Existing Router
+ * ```typescript
+ * const router = yield* AWS.Website.Router("FrontDoor", {});
+ *
+ * const site = yield* AWS.Website.ReactRouter("Web", {
+ *   rootDir: "./app",
+ *   domain: { router },
+ * });
+ * ```
+ *
+ * @resource
+ */
+export const ReactRouter = (
+  id: string,
+  props: InputProps<ReactRouterProps> = {},
+) =>
+  makeFrameworkSite(id, props, {
+    name: "ReactRouter",
+    framework: REACT_ROUTER_FRAMEWORK_SPECIFIER,
+    target: REACT_ROUTER_AWS_TARGET_SPECIFIER,
+  }).pipe(Namespace.push(id));

package/src/AWS/Website/Router.ts

@@ -325,7 +325,7 @@ export const Router = Effect.fn("AWS.Website.Router")(
     });
 
     const records =
-      domain?.hostedZoneId && domain.dns !== false
+      domain && domain.dns !== false
         ? yield* Effect.forEach(
             [
               domain.name,
@@ -334,7 +334,9 @@ export const Router = Effect.fn("AWS.Website.Router")(
             ],
             (name, index) =>
               Route53Record(`AliasRecord${index + 1}`, {
-                hostedZoneId: domain.hostedZoneId!,
+                // Optional — the Record provider infers the most specific
+                // public zone containing `name` when omitted.
+                hostedZoneId: domain.hostedZoneId,
                 name,
                 type: "A",
                 aliasTarget: {
@@ -351,8 +353,10 @@ export const Router = Effect.fn("AWS.Website.Router")(
     // becoming an A-alias record pointing at this distribution (see
     // `WebsiteRouterBindTargets`).
     const siteRecords =
-      domain?.hostedZoneId && domain.dns !== false
+      domain && domain.dns !== false
         ? yield* Route53Records("SiteAliasRecords", {
+            // Optional — the Records provider infers the zone from the
+            // first bound hostname when omitted.
             hostedZoneId: domain.hostedZoneId,
             type: "A",
             aliasTarget: {

package/src/AWS/Website/ServerLocal.ts

@@ -1,4 +1,4 @@
 import * as RpcServer from "../../Local/RpcServer.ts";
-import { ServerProviderLocal } from "./Server.ts";
+import { ServerProviderLocal } from "../../Website/Server.ts";
 
 ServerProviderLocal().pipe(RpcServer.launch);

package/src/AWS/Website/SolidStart.ts

@@ -0,0 +1,102 @@
+import type { InputProps } from "../../Input.ts";
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** The framework-integration package that drives the SolidStart build. */
+export const SOLIDSTART_FRAMEWORK_SPECIFIER =
+  "@alchemy.run/frontend-frameworks/solidstart";
+
+/** The AWS Lambda deploy target for the SolidStart build. */
+export const SOLIDSTART_AWS_TARGET_SPECIFIER =
+  "@alchemy.run/frontend-frameworks/solidstart/aws";
+
+export interface SolidStartProps extends FrameworkSiteProps {
+  /**
+   * Nitro options forwarded into the nitro plugin the integration appends
+   * (prerendering, route rules, storage, ...). `preset` is owned by the
+   * deploy target and may not be set here. JSON-serializable values only —
+   * no functions or plugin instances.
+   *
+   * This is a prop (rather than project config) because the integration
+   * owns the nitro plugin instance: a `nitroV2Plugin()` in your project's
+   * `vite.config.*` is rejected, so this prop is the one home for nitro
+   * options — and it accepts values derived from other resources' Outputs,
+   * which a config file cannot.
+   */
+  nitro?: Record<string, unknown>;
+}
+
+/**
+ * Deploy a [SolidStart](https://start.solidjs.com) application to AWS: the
+ * SSR server on a streaming Lambda Function URL, static assets (prerendered
+ * pages included) in S3, and a CloudFront distribution whose edge router
+ * serves uploaded files from S3 and forwards everything else to the server.
+ *
+ * The build runs through `@alchemy.run/frontend-frameworks/solidstart` with
+ * the `@alchemy.run/frontend-frameworks/solidstart/aws` deploy target — both
+ * must be installed in your project, alongside `@solidjs/start` and
+ * `@solidjs/vite-plugin-nitro-2`.
+ *
+ * Your `vite.config.ts` needs no adapter wiring: the integration drives the
+ * project's own `vite build` and appends its own nitro plugin instance
+ * carrying nitro's `aws-lambda` preset with response streaming enabled.
+ *
+ * ### Creating SolidStart Sites
+ * **Example:** Basic SolidStart App
+ * ```typescript
+ * const site = yield* AWS.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* AWS.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ *   domain: {
+ *     name: "app.example.com",
+ *     hostedZoneId: zone.hostedZoneId,
+ *   },
+ * });
+ * ```
+ *
+ * ### Server Configuration
+ * **Example:** Tune The Server Function
+ * ```typescript
+ * const site = yield* AWS.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ *   memorySize: 2048,
+ *   env: {
+ *     API_BASE: api.url,
+ *   },
+ * });
+ * ```
+ *
+ * ### Prerendering
+ * The integration owns the nitro plugin instance (a `nitroV2Plugin()` in
+ * your `vite.config.*` is rejected), so nitro options — prerendering
+ * included — go on the `nitro` prop. Prerendered pages are uploaded to S3
+ * and served from the edge automatically.
+ *
+ * **Example:** Prerender Routes
+ * ```typescript
+ * const site = yield* AWS.Website.SolidStart("Web", {
+ *   rootDir: "./app",
+ *   nitro: { prerender: { routes: ["/", "/about"] } },
+ * });
+ * ```
+ *
+ * @resource
+ */
+export const SolidStart = (
+  id: string,
+  props: InputProps<SolidStartProps> = {},
+) => {
+  const p = props as SolidStartProps;
+  return makeFrameworkSite(id, props, {
+    name: "SolidStart",
+    framework: SOLIDSTART_FRAMEWORK_SPECIFIER,
+    target: SOLIDSTART_AWS_TARGET_SPECIFIER,
+    options: { nitro: p.nitro },
+  }).pipe(Namespace.push(id));
+};

package/src/AWS/Website/SsrSite.ts

@@ -405,7 +405,7 @@ export const SsrSite = (id: string, props: SsrSiteProps) =>
     }
 
     const records =
-      domain?.hostedZoneId && domain.dns !== false
+      domain && domain.dns !== false
         ? yield* Effect.forEach(
             [
               domain.name,
@@ -414,7 +414,9 @@ export const SsrSite = (id: string, props: SsrSiteProps) =>
             ],
             (name, index) =>
               Route53Record(`AliasRecord${index + 1}`, {
-                hostedZoneId: domain.hostedZoneId!,
+                // Optional — the Record provider infers the most specific
+                // public zone containing `name` when omitted.
+                hostedZoneId: domain.hostedZoneId,
                 name,
                 type: "A",
                 aliasTarget: {

package/src/AWS/Website/StaticSite.ts

@@ -51,10 +51,6 @@ export interface StaticSiteProps {
    * Optional build configuration executed before upload.
    */
   build?: StaticSiteBuildProps;
-  /**
-   * Environment variables exposed to the build command.
-   */
-  environment?: Record<string, Input<string>>;
   /**
    * Static site asset upload configuration.
    */
@@ -191,9 +187,9 @@ export interface StaticSiteProps {
  *   build: {
  *     command: "bun run build",
  *     output: "dist",
- *   },
- *   environment: {
- *     VITE_API_URL: api.url,
+ *     env: {
+ *       VITE_API_URL: api.url,
+ *     },
  *   },
  * });
  * ```
@@ -410,7 +406,7 @@ export const makeKvSite = Effect.fn("AWS.Website.KvSite")(function* (
           lockfile: props.build.lockfile,
         },
         outdir: props.build.output,
-        env: props.environment,
+        env: props.build.env,
       })
     : undefined;
 
@@ -742,12 +738,14 @@ export const makeKvSite = Effect.fn("AWS.Website.KvSite")(function* (
     const dist = distribution;
     distributionId = dist.distributionId;
 
-    if (domain?.hostedZoneId && domain.dns !== false) {
+    if (domain && domain.dns !== false) {
       yield* Effect.forEach(
         [domain.name, ...(domain.aliases ?? []), ...(domain.redirects ?? [])],
         (name, index) =>
           Route53Record(`AliasRecord${index + 1}`, {
-            hostedZoneId: domain.hostedZoneId!,
+            // Optional — the Record provider infers the most specific
+            // public zone containing `name` when omitted.
+            hostedZoneId: domain.hostedZoneId,
             name,
             type: "A",
             aliasTarget: {

package/src/AWS/Website/SvelteKit.ts

@@ -1,3 +1,4 @@
+import type { InputProps } from "../../Input.ts";
 import * as Namespace from "../../Namespace.ts";
 import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
 
@@ -11,11 +12,12 @@ export const SVELTEKIT_AWS_TARGET_SPECIFIER =
 
 export interface SvelteKitProps extends FrameworkSiteProps {
   /**
-   * SvelteKit configuration passed to the `sveltekit(config)` Vite plugin
-   * (kit v3 takes its config in memory — a `svelte.config.js` on disk is an
-   * upstream error). The `adapter` field is injected by the AWS deploy
-   * target and may not be set here. Must be JSON-serializable (it persists
-   * in state).
+   * SvelteKit config overrides for the `sveltekit(...)` plugin call, merged
+   * over the options of the user's own call (these win). JSON-serializable
+   * only — no `preprocess`/`vitePlugin`/functions; construction-time options
+   * (`preprocess`, `extensions`, `compilerOptions`, `vitePlugin`) can only
+   * apply when no user `vite.config.*` exists. The `adapter` field is
+   * always owned by alchemy.
    */
   kit?: Record<string, unknown>;
 }
@@ -55,21 +57,40 @@ export interface SvelteKitProps extends FrameworkSiteProps {
  * ```typescript
  * const site = yield* AWS.Website.SvelteKit("Web", {
  *   rootDir: "./app",
- *   server: {
- *     memorySize: 2048,
- *     environment: {
- *       API_BASE: api.url,
- *     },
+ *   memorySize: 2048,
+ *   env: {
+ *     API_BASE: api.url,
+ *   },
+ * });
+ * ```
+ *
+ * ### Kit Overrides
+ * Kit options live in the `sveltekit(...)` call in your `vite.config.ts`,
+ * which loads natively. The `kit` prop is a deploy-time override bag
+ * merged over your own options (the prop wins) — useful for per-stage
+ * values the config file can't compute. JSON-serializable values only.
+ *
+ * **Example:** Deploy-time kit overrides
+ * ```typescript
+ * const site = yield* AWS.Website.SvelteKit("Web", {
+ *   rootDir: "./app",
+ *   kit: {
+ *     paths: { base: "/docs" },
  *   },
  * });
  * ```
  *
  * @resource
  */
-export const SvelteKit = (id: string, props: SvelteKitProps = {}) =>
-  makeFrameworkSite(id, props, {
+export const SvelteKit = (
+  id: string,
+  props: InputProps<SvelteKitProps> = {},
+) => {
+  const p = props as SvelteKitProps;
+  return makeFrameworkSite(id, props, {
     name: "SvelteKit",
     framework: SVELTEKIT_FRAMEWORK_SPECIFIER,
     target: SVELTEKIT_AWS_TARGET_SPECIFIER,
-    options: props.kit ? { kit: props.kit } : undefined,
+    options: { kit: p.kit },
   }).pipe(Namespace.push(id));
+};

package/src/AWS/Website/TanStackStart.ts

@@ -0,0 +1,92 @@
+import type { InputProps } from "../../Input.ts";
+import * as Namespace from "../../Namespace.ts";
+import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
+
+/** The framework-integration package that drives the TanStack Start build. */
+export const TANSTACK_START_FRAMEWORK_SPECIFIER =
+  "@alchemy.run/frontend-frameworks/tanstack-start";
+
+/** The AWS Lambda deploy target for the TanStack Start build. */
+export const TANSTACK_START_AWS_TARGET_SPECIFIER =
+  "@alchemy.run/frontend-frameworks/tanstack-start/aws";
+
+export interface TanStackStartProps extends FrameworkSiteProps {}
+
+/**
+ * Deploy a [TanStack Start](https://tanstack.com/start) application to AWS:
+ * the SSR server on a streaming Lambda Function URL, client assets in S3,
+ * and a CloudFront distribution whose edge router serves uploaded files from
+ * S3 and forwards everything else to the server.
+ *
+ * The build runs through
+ * `@alchemy.run/frontend-frameworks/tanstack-start` with the
+ * `@alchemy.run/frontend-frameworks/tanstack-start/aws` deploy target — both
+ * must be installed in your project, alongside `@tanstack/react-start` (or
+ * `@tanstack/solid-start`) and `vite`.
+ *
+ * Your `vite.config.ts` needs no adapter wiring: TanStack Start is pure
+ * Vite, so the integration drives the project's own `vite build`, forces the
+ * SSR bundle to be self-contained, and wraps its fetch handler as a
+ * streaming Lambda handler.
+ *
+ * ### Creating TanStack Start Sites
+ * **Example:** Basic TanStack Start App
+ * ```typescript
+ * const site = yield* AWS.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ * });
+ * ```
+ *
+ * **Example:** Custom Domain
+ * ```typescript
+ * const site = yield* AWS.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ *   domain: {
+ *     name: "app.example.com",
+ *     hostedZoneId: zone.hostedZoneId,
+ *   },
+ * });
+ * ```
+ *
+ * ### Server Configuration
+ * **Example:** Tune The Server Function
+ * ```typescript
+ * const site = yield* AWS.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ *   memorySize: 2048,
+ *   env: {
+ *     API_BASE: api.url,
+ *   },
+ * });
+ * ```
+ *
+ * **Example:** Read An Environment Variable From A Server Function
+ * ```typescript
+ * // src/routes/index.tsx
+ * const getApiBase = createServerFn({ method: "GET" }).handler(() => ({
+ *   apiBase: process.env.API_BASE,
+ * }));
+ * ```
+ *
+ * ### Shared Router
+ * **Example:** Serve Through An Existing Router
+ * ```typescript
+ * const router = yield* AWS.Website.Router("FrontDoor", {});
+ *
+ * const site = yield* AWS.Website.TanStackStart("Web", {
+ *   rootDir: "./app",
+ *   domain: { router },
+ * });
+ * ```
+ *
+ * @resource
+ */
+export const TanStackStart = (
+  id: string,
+  props: InputProps<TanStackStartProps> = {},
+) =>
+  makeFrameworkSite(id, props, {
+    name: "TanStackStart",
+    framework: TANSTACK_START_FRAMEWORK_SPECIFIER,
+    target: TANSTACK_START_AWS_TARGET_SPECIFIER,
+  }).pipe(Namespace.push(id));

package/src/AWS/Website/Vite.ts

@@ -1,3 +1,4 @@
+import type { InputProps } from "../../Input.ts";
 import * as Namespace from "../../Namespace.ts";
 import { makeFrameworkSite, type FrameworkSiteProps } from "./FrameworkSite.ts";
 
@@ -8,20 +9,47 @@ export const VITE_FRAMEWORK_SPECIFIER = "@alchemy.run/frontend-frameworks/vite";
 export const VITE_AWS_TARGET_SPECIFIER =
   "@alchemy.run/frontend-frameworks/vite/aws";
 
-export interface ViteProps extends Omit<FrameworkSiteProps, "server"> {
+/**
+ * Serializable Vite build overrides merged OVER the project's own
+ * `vite.config.*` at deploy time (deploy-time values win). Mirrors the
+ * integration seam's `ViteBuildConfig`
+ * (`@alchemy.run/frontend-frameworks/vite`). Deliberately a small,
+ * JSON-serializable subset — plugins and other non-serializable config
+ * belong in the config file, which loads natively.
+ */
+export interface ViteBuildConfig {
+  /**
+   * Public base path the site deploys under (vite's `base`). Overrides
+   * the config file's `base` for both the production build and the dev
+   * server under `alchemy dev`.
+   */
+  base?: string;
   /**
-   * Serializable Vite config merged OVER the project's own `vite.config.*`
-   * (which loads natively, plugins included).
+   * Build output directory, relative to `rootDir` (vite's
+   * `build.outDir`). Overrides the config file's `build.outDir`.
+   * @default the config file's `build.outDir` (vite's default: "dist")
    */
-  vite?: {
-    /**
-     * Build output directory, relative to `rootDir`.
-     * @default the project config's `build.outDir` (vite's default: "dist")
-     */
-    outDir?: string;
-    /** Public base path the site deploys under (vite's `base`). */
-    base?: string;
-  };
+  outDir?: string;
+}
+
+export interface ViteProps extends Omit<
+  FrameworkSiteProps,
+  // Assets-only: a plain Vite site never creates a server function.
+  "env" | "memorySize" | "timeout" | "architecture" | "runtime"
+> {
+  /**
+   * Deploy-time Vite overrides merged over your `vite.config.*`. The
+   * config file is the primary home for Vite configuration (it loads
+   * natively, plugins included) — reach for this bag when a value is
+   * decided by the deployment rather than the project, since config
+   * files cannot consume alchemy `Output`s.
+   */
+  vite?: ViteBuildConfig;
+  /**
+   * Alternate Vite config file to load instead of the auto-discovered
+   * `vite.config.*`, relative to {@link FrameworkSiteProps.rootDir | rootDir}.
+   */
+  config?: string;
   /**
    * Answer misses with the index page (200) instead of a 404, so
    * client-side routes deep-link correctly. Plain Vite apps are typically
@@ -39,6 +67,28 @@ export interface ViteProps extends Omit<FrameworkSiteProps, "server"> {
   errorPage?: string;
 }
 
+/**
+ * Assemble the framework-integration `options` bag from the resource's
+ * `vite` overrides and `config` file selection. The integration seam is
+ * `ViteOptions.vite` (`@alchemy.run/frontend-frameworks/vite`), whose
+ * `configFile` is resolved relative to the project root. Shared with
+ * {@link Foldkit | AWS.Website.Foldkit}, which builds through the same
+ * pipeline.
+ *
+ * @internal
+ */
+export const viteFrameworkOptions = (
+  p: Pick<ViteProps, "vite" | "config">,
+): Record<string, unknown> | undefined =>
+  p.vite !== undefined || p.config !== undefined
+    ? {
+        vite: {
+          ...p.vite,
+          ...(p.config !== undefined ? { configFile: p.config } : undefined),
+        },
+      }
+    : undefined;
+
 /**
  * Deploy a plain [Vite](https://vite.dev) application to AWS: static assets
  * (the `vite build` output) in S3 behind a CloudFront distribution. For
@@ -102,13 +152,22 @@ export interface ViteProps extends Omit<FrameworkSiteProps, "server"> {
  * ```
  *
  * ### Build Configuration
- * **Example:** Custom Output Directory and Base Path
+ * Vite configuration lives in your project's own `vite.config.*`, which
+ * loads natively — plugins included. The `vite` bag is for deploy-time
+ * overrides merged over that file (config files cannot consume alchemy
+ * `Output`s), and `config` selects an alternate config file.
+ *
+ * **Example:** Deploy-Time Base Path Override
  * ```typescript
  * const site = yield* AWS.Website.Vite("Docs", {
- *   vite: {
- *     outDir: "build",
- *     base: "/docs/",
- *   },
+ *   vite: { base: "/docs/" },
+ * });
+ * ```
+ *
+ * **Example:** Alternate Config File
+ * ```typescript
+ * const site = yield* AWS.Website.Vite("Web", {
+ *   config: "vite.deploy.config.ts",
  * });
  * ```
  *
@@ -122,18 +181,20 @@ export interface ViteProps extends Omit<FrameworkSiteProps, "server"> {
  *
  * @resource
  */
-export const Vite = (id: string, props: ViteProps = {}) =>
-  makeFrameworkSite(id, props, {
+export const Vite = (id: string, props: InputProps<ViteProps> = {}) => {
+  const p = props as ViteProps;
+  return makeFrameworkSite(id, props, {
     name: "Vite",
     framework: VITE_FRAMEWORK_SPECIFIER,
     target: VITE_AWS_TARGET_SPECIFIER,
-    options: props.vite !== undefined ? { vite: props.vite } : undefined,
+    options: viteFrameworkOptions(p),
     // Plain Vite is assets-only: every page is client-rendered from the
     // uploaded bundle, so the deploy never creates a server function.
     // `spa` defaults on (Vite apps are typically SPAs) but yields to an
     // explicit `errorPage` — the two are mutually exclusive downstream.
     static: {
-      spa: props.spa ?? (props.errorPage === undefined ? true : undefined),
-      errorPage: props.errorPage,
+      spa: p.spa ?? (p.errorPage === undefined ? true : undefined),
+      errorPage: p.errorPage,
     },
   }).pipe(Namespace.push(id));
+};