@projectdochelp/s3te 3.1.1 → 3.1.2

package/README.md

@@ -6,14 +6,19 @@ This README is the user guide for the rewrite generation. The deeper implementat
 
 ## Table of Contents
 
-1. [Motivation](#motivation)
-2. [Support](#support)
-3. [Concept](#concept)
-4. [Installation (AWS)](#installation-aws)
-5. [Installation (VSCode)](#installation-vscode)
-6. [Installation (S3TE)](#installation-s3te)
-7. [Usage](#usage)
-8. [Optional: Webiny CMS](#optional-webiny-cms)
+- [S3TemplateEngine](#s3templateengine)
+  - [Table of Contents](#table-of-contents)
+  - [Motivation](#motivation)
+  - [Support](#support)
+  - [Concept](#concept)
+  - [Installation (AWS)](#installation-aws)
+  - [Installation (VSCode)](#installation-vscode)
+  - [Installation (S3TE)](#installation-s3te)
+  - [Usage](#usage)
+    - [Daily Workflow](#daily-workflow)
+    - [CLI Commands](#cli-commands)
+    - [Template Commands](#template-commands)
+  - [Optional: Webiny CMS](#optional-webiny-cms)
 
 ## Motivation
 
@@ -152,7 +157,7 @@ With the local package installed, initialize the project like this:
 npx s3te init --project-name mywebsite --base-url example.com
 ```
 
-If `npm install` already created a minimal `package.json`, `s3te init` extends it with the missing S3TE defaults and scripts instead of failing.
+You can safely run `s3te init` more than once. If `npm install` already created a minimal `package.json`, `s3te init` extends it with the missing S3TE defaults and scripts instead of failing. An existing `s3te.config.json` is completed with missing scaffold defaults, explicit `--project-name` and `--base-url` values are refreshed on re-run, and the generated schema file is updated to the current package version. Existing content files and templates stay untouched unless you use `--force`.
 
 If you want a one-shot scaffold without installing first, and `@projectdochelp/s3te` is already published on npm, this also works:
 
@@ -160,19 +165,6 @@ If you want a one-shot scaffold without installing first, and `@projectdochelp/s
 npx --package @projectdochelp/s3te s3te init --project-name mywebsite --base-url example.com
 ```
 
-That command only works after a real npm publish. A GitHub repository on its own is not enough.
-
-If you are still working from this repository before the first npm publish, run the CLI directly from the repo root instead:
-
-```bash
-node packages/cli/bin/s3te.mjs init --dir ./mywebsite --project-name mywebsite --base-url example.com
-```
-
-</details>
-
-<details>
-  <summary>4. What the scaffold creates</summary>
-
 The default scaffold creates:
 
 ```text
@@ -198,7 +190,7 @@ mywebsite/
 </details>
 
 <details>
-  <summary>5. Fill in the real AWS values in <code>s3te.config.json</code></summary>
+  <summary>4. Fill in the real AWS values in <code>s3te.config.json</code></summary>
 
 The most important fields for a first deployment are:
 
@@ -227,10 +219,12 @@ The most important fields for a first deployment are:
 
 `route53HostedZoneId` is optional. Leave it out if you want to manage DNS yourself.
 
+Use plain hostnames in `baseUrl` and `cloudFrontAliases`, not full URLs. If your config contains a `prod` environment plus additional environments such as `test` or `stage`, S3TE keeps the `prod` hostname unchanged and derives non-production hostnames automatically by prepending `<env>.`.
+
 </details>
 
 <details>
-  <summary>6. Run the first local check and deploy</summary>
+  <summary>5. Run the first local check and deploy</summary>
 
 ```bash
 npx s3te validate
@@ -378,6 +372,13 @@ npx s3te migrate --enable-webiny --webiny-source-table webiny-1234567 --webiny-t
 
 `staticContent` and `staticCodeContent` are kept automatically. Add `--webiny-model` once per custom model you want S3TE to mirror.
 
+If different environments should read from different Webiny installations or tenants, run the migration per environment:
+
+```bash
+npx s3te migrate --env test --enable-webiny --webiny-source-table webiny-test-1234567 --webiny-tenant preview --write
+npx s3te migrate --env prod --enable-webiny --webiny-source-table webiny-live-1234567 --webiny-tenant root --write
+```
+
 4. Turn on DynamoDB Streams for the Webiny source table with `NEW_AND_OLD_IMAGES`.
 5. If your S3TE language keys are not identical to your Webiny locales, add `webinyLocale` per language in `s3te.config.json`, for example `"en": { "webinyLocale": "en-US" }`.
 6. If your Webiny installation hosts multiple tenants, keep `integrations.webiny.tenant` set so S3TE only mirrors the intended tenant.
@@ -411,7 +412,17 @@ Example config block:
     "sourceTableName": "webiny-1234567",
     "mirrorTableName": "{stackPrefix}_s3te_content_{project}",
     "tenant": "root",
-    "relevantModels": ["article", "staticContent", "staticCodeContent"]
+    "relevantModels": ["article", "staticContent", "staticCodeContent"],
+    "environments": {
+      "test": {
+        "sourceTableName": "webiny-test-1234567",
+        "tenant": "preview"
+      },
+      "prod": {
+        "sourceTableName": "webiny-live-1234567",
+        "tenant": "root"
+      }
+    }
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectdochelp/s3te",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "CLI, render core, AWS adapter, and testkit for S3TemplateEngine projects",
   "repository": {
     "type": "git",

package/packages/aws-adapter/src/deploy.mjs

@@ -243,12 +243,12 @@ export async function deployAwsProject({
 }) {
   const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
   const requestedFeatureSet = new Set(features);
-  const featureSet = new Set(resolveRequestedFeatures(config, features));
+  const featureSet = new Set(resolveRequestedFeatures(config, features, environment));
   const stackName = resolveStackName(config, environment);
   const tempStackName = temporaryStackName(stackName);
   const runtimeManifestPath = path.join(projectDir, packageDir ?? path.join("offline", "IAAS", "package", environment), "runtime-manifest.json");
 
-  if (requestedFeatureSet.has("webiny") && !config.integrations.webiny.enabled) {
+  if (requestedFeatureSet.has("webiny") && !runtimeConfig.integrations.webiny.enabled) {
     throw new S3teError("ADAPTER_ERROR", "Feature webiny was requested but is not enabled in s3te.config.json.");
   }
 

package/packages/aws-adapter/src/features.mjs

@@ -1,16 +1,29 @@
-export function getConfiguredFeatures(config) {
+import { resolveEnvironmentWebinyIntegration } from "../../core/src/index.mjs";
+
+export function getConfiguredFeatures(config, environment) {
   const features = [];
 
-  if (config.integrations?.webiny?.enabled) {
+  if (environment) {
+    if (resolveEnvironmentWebinyIntegration(config, environment).enabled) {
+      features.push("webiny");
+    }
+    return features;
+  }
+
+  const hasAnyEnvironmentWebiny = Object.keys(config.environments ?? {}).some((environmentName) => (
+    resolveEnvironmentWebinyIntegration(config, environmentName).enabled
+  ));
+
+  if (hasAnyEnvironmentWebiny) {
     features.push("webiny");
   }
 
   return features;
 }
 
-export function resolveRequestedFeatures(config, requestedFeatures = []) {
+export function resolveRequestedFeatures(config, requestedFeatures = [], environment) {
   return [...new Set([
     ...requestedFeatures,
-    ...getConfiguredFeatures(config)
+    ...getConfiguredFeatures(config, environment)
   ])].sort();
 }

package/packages/aws-adapter/src/package.mjs

@@ -221,11 +221,13 @@ export async function packageAwsProject({
   clean = false,
   features = []
 }) {
-  if (features.includes("webiny") && !config.integrations.webiny.enabled) {
+  const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
+
+  if (features.includes("webiny") && !runtimeConfig.integrations.webiny.enabled) {
     throw new S3teError("ADAPTER_ERROR", "Feature webiny was requested but is not enabled in s3te.config.json.");
   }
 
-  const resolvedFeatures = resolveRequestedFeatures(config, features);
+  const resolvedFeatures = resolveRequestedFeatures(config, features, environment);
   const packageDir = outDir
     ? path.join(projectDir, outDir)
     : path.join(projectDir, "offline", "IAAS", "package", environment);
@@ -234,7 +236,6 @@ export async function packageAwsProject({
   }
   await ensureDirectory(packageDir);
 
-  const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
   const lambdaDir = path.join(packageDir, "lambda");
   const templatePath = path.join(packageDir, "cloudformation.template.json");
   const packagingManifestPath = path.join(packageDir, "manifest.json");

package/packages/cli/bin/s3te.mjs

@@ -349,6 +349,7 @@ async function main() {
     const rawConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
     const migration = await migrateProject(configPath, rawConfig, {
       writeChanges: Boolean(options.write) && !Boolean(options["dry-run"]),
+      environment: asArray(options.env)[0],
       enableWebiny: Boolean(options["enable-webiny"]),
       disableWebiny: Boolean(options["disable-webiny"]),
       webinySourceTable: options["webiny-source-table"],

package/packages/cli/src/project.mjs

@@ -31,6 +31,26 @@ function normalizePath(value) {
   return String(value).replace(/\\/g, "/");
 }
 
+function normalizeBaseUrl(value) {
+  const trimmed = String(value).trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
+    try {
+      return new URL(trimmed).host;
+    } catch {
+      // fall back to lightweight normalization below
+    }
+  }
+
+  return trimmed
+    .replace(/^[a-z][a-z0-9+.-]*:\/\//i, "")
+    .replace(/^\/+|\/+$/g, "")
+    .split("/")[0];
+}
+
 function schemaTemplate() {
   return {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -67,23 +87,53 @@ function schemaTemplate() {
           }
         }
       },
+      rendering: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          minifyHtml: { type: "boolean" },
+          renderExtensions: {
+            type: "array",
+            items: { type: "string" }
+          },
+          outputDir: { type: "string" },
+          maxRenderDepth: {
+            type: "integer",
+            minimum: 1
+          }
+        }
+      },
       variants: {
         type: "object",
         additionalProperties: {
           type: "object",
-          additionalProperties: true,
+          additionalProperties: false,
+          required: ["defaultLanguage", "languages"],
           properties: {
+            sourceDir: { type: "string" },
+            partDir: { type: "string" },
+            defaultLanguage: { type: "string" },
+            routing: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                indexDocument: { type: "string" },
+                notFoundDocument: { type: "string" }
+              }
+            },
             languages: {
               type: "object",
               additionalProperties: {
                 type: "object",
                 additionalProperties: false,
+                required: ["baseUrl", "cloudFrontAliases"],
                 properties: {
                   baseUrl: { type: "string" },
                   targetBucket: { type: "string" },
                   cloudFrontAliases: {
                     type: "array",
-                    items: { type: "string" }
+                    items: { type: "string" },
+                    minItems: 1
                   },
                   webinyLocale: { type: "string" }
                 }
@@ -92,6 +142,56 @@ function schemaTemplate() {
           }
         }
       },
+      aws: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          codeBuckets: {
+            type: "object",
+            additionalProperties: { type: "string" }
+          },
+          dependencyStore: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              tableName: { type: "string" }
+            }
+          },
+          contentStore: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              tableName: { type: "string" },
+              contentIdIndexName: { type: "string" }
+            }
+          },
+          invalidationStore: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              tableName: { type: "string" },
+              debounceSeconds: {
+                type: "integer",
+                minimum: 0
+              }
+            }
+          },
+          lambda: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              runtime: {
+                type: "string",
+                enum: ["nodejs22.x"]
+              },
+              architecture: {
+                type: "string",
+                enum: ["arm64", "x86_64"]
+              }
+            }
+          }
+        }
+      },
       integrations: {
         type: "object",
         additionalProperties: false,
@@ -107,6 +207,23 @@ function schemaTemplate() {
               relevantModels: {
                 type: "array",
                 items: { type: "string" }
+              },
+              environments: {
+                type: "object",
+                additionalProperties: {
+                  type: "object",
+                  additionalProperties: false,
+                  properties: {
+                    enabled: { type: "boolean" },
+                    sourceTableName: { type: "string" },
+                    mirrorTableName: { type: "string" },
+                    tenant: { type: "string" },
+                    relevantModels: {
+                      type: "array",
+                      items: { type: "string" }
+                    }
+                  }
+                }
               }
             }
           }
@@ -129,14 +246,34 @@ function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-async function writeProjectFile(targetPath, body, force = false) {
-  if (!force && await fileExists(targetPath)) {
-    throw new Error(`Refusing to overwrite existing file: ${targetPath}`);
+async function writeProjectFile(targetPath, body, force = false, overwriteExisting = false) {
+  if (!force && !overwriteExisting && await fileExists(targetPath)) {
+    return;
   }
   await writeTextFile(targetPath, body);
 }
 
-function mergeProjectPackageJson(existingPackageJson, projectPackageJson) {
+function mergeDefaults(existingValue, defaultValue) {
+  if (existingValue === undefined) {
+    return defaultValue;
+  }
+
+  if (isPlainObject(defaultValue)) {
+    if (!isPlainObject(existingValue)) {
+      throw new Error("Existing JSON content must use an object where S3TE expects one.");
+    }
+
+    const mergedValue = { ...existingValue };
+    for (const [key, value] of Object.entries(defaultValue)) {
+      mergedValue[key] = mergeDefaults(existingValue[key], value);
+    }
+    return mergedValue;
+  }
+
+  return existingValue;
+}
+
+function mergeProjectPackageJson(existingPackageJson, projectPackageJson, scaffoldOptions = {}) {
   if (!isPlainObject(existingPackageJson)) {
     throw new Error("Existing package.json must contain a JSON object.");
   }
@@ -167,10 +304,14 @@ function mergeProjectPackageJson(existingPackageJson, projectPackageJson) {
     mergedPackageJson.scripts = mergedScripts;
   }
 
+  if (scaffoldOptions.projectNameProvided) {
+    mergedPackageJson.name = scaffoldOptions.projectName;
+  }
+
   return mergedPackageJson;
 }
 
-async function writeProjectPackageJson(targetPath, projectPackageJson, force = false) {
+async function writeProjectPackageJson(targetPath, projectPackageJson, scaffoldOptions = {}, force = false) {
   if (force || !await fileExists(targetPath)) {
     await writeTextFile(targetPath, JSON.stringify(projectPackageJson, null, 2) + "\n");
     return;
@@ -183,10 +324,63 @@ async function writeProjectPackageJson(targetPath, projectPackageJson, force = f
     throw new Error(`Existing package.json is not valid JSON: ${targetPath}`, { cause: error });
   }
 
-  const mergedPackageJson = mergeProjectPackageJson(existingPackageJson, projectPackageJson);
+  const mergedPackageJson = mergeProjectPackageJson(existingPackageJson, projectPackageJson, scaffoldOptions);
   await writeTextFile(targetPath, JSON.stringify(mergedPackageJson, null, 2) + "\n");
 }
 
+function applyScaffoldConfigOverrides(config, scaffoldOptions = {}) {
+  if (scaffoldOptions.projectNameProvided) {
+    config.project.name = scaffoldOptions.projectName;
+  }
+
+  const variantConfig = config.variants?.[scaffoldOptions.variant];
+  const languageConfig = variantConfig?.languages?.[scaffoldOptions.language];
+  if (!variantConfig || !languageConfig) {
+    return config;
+  }
+
+  if (scaffoldOptions.languageProvided) {
+    variantConfig.defaultLanguage = scaffoldOptions.language;
+  }
+
+  if (languageConfig.webinyLocale === undefined) {
+    languageConfig.webinyLocale = scaffoldOptions.language;
+  }
+
+  if (scaffoldOptions.baseUrlProvided) {
+    const previousBaseUrl = languageConfig.baseUrl;
+    languageConfig.baseUrl = scaffoldOptions.baseUrl;
+    if (!Array.isArray(languageConfig.cloudFrontAliases)
+      || languageConfig.cloudFrontAliases.length === 0
+      || (languageConfig.cloudFrontAliases.length === 1 && languageConfig.cloudFrontAliases[0] === previousBaseUrl)) {
+      languageConfig.cloudFrontAliases = [scaffoldOptions.baseUrl];
+    }
+  }
+
+  return config;
+}
+
+async function writeProjectConfigJson(targetPath, projectConfig, scaffoldOptions = {}, force = false) {
+  if (force || !await fileExists(targetPath)) {
+    await writeTextFile(targetPath, JSON.stringify(projectConfig, null, 2) + "\n");
+    return;
+  }
+
+  let existingConfig;
+  try {
+    existingConfig = JSON.parse(await fs.readFile(targetPath, "utf8"));
+  } catch (error) {
+    throw new Error(`Existing s3te.config.json is not valid JSON: ${targetPath}`, { cause: error });
+  }
+
+  if (!isPlainObject(existingConfig)) {
+    throw new Error("Existing s3te.config.json must contain a JSON object.");
+  }
+
+  const mergedConfig = applyScaffoldConfigOverrides(mergeDefaults(existingConfig, projectConfig), scaffoldOptions);
+  await writeTextFile(targetPath, JSON.stringify(mergedConfig, null, 2) + "\n");
+}
+
 async function loadRenderState(projectDir, environment) {
   const statePath = path.join(projectDir, "offline", "S3TELocal", "render-state", `${environment}.json`);
   try {
@@ -268,10 +462,20 @@ export async function validateProject(projectDir, config, options = {}) {
 
 export async function scaffoldProject(projectDir, options = {}) {
   const projectName = options.projectName ?? path.basename(projectDir).toLowerCase().replace(/[^a-z0-9-]/g, "-");
-  const baseUrl = options.baseUrl ?? "example.com";
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? "example.com");
   const variant = options.variant ?? "website";
   const language = options.language ?? "en";
   const force = Boolean(options.force);
+  const scaffoldOptions = {
+    projectName,
+    projectNameProvided: options.projectName !== undefined,
+    baseUrl,
+    baseUrlProvided: options.baseUrl !== undefined,
+    variant,
+    variantProvided: options.variant !== undefined,
+    language,
+    languageProvided: options.language !== undefined
+  };
 
   await ensureDirectory(path.join(projectDir, "app", "part"));
   await ensureDirectory(path.join(projectDir, "app", variant));
@@ -323,9 +527,9 @@ export async function scaffoldProject(projectDir, options = {}) {
     }
   };
 
-  await writeProjectPackageJson(path.join(projectDir, "package.json"), projectPackageJson, force);
-  await writeProjectFile(path.join(projectDir, "s3te.config.json"), JSON.stringify(config, null, 2) + "\n", force);
-  await writeProjectFile(path.join(projectDir, "offline", "schemas", "s3te.config.schema.json"), JSON.stringify(schemaTemplate(), null, 2) + "\n", force);
+  await writeProjectPackageJson(path.join(projectDir, "package.json"), projectPackageJson, scaffoldOptions, force);
+  await writeProjectConfigJson(path.join(projectDir, "s3te.config.json"), config, scaffoldOptions, force);
+  await writeProjectFile(path.join(projectDir, "offline", "schemas", "s3te.config.schema.json"), JSON.stringify(schemaTemplate(), null, 2) + "\n", force, true);
   await writeProjectFile(path.join(projectDir, "app", "part", "head.part"), "<meta charset='utf-8'>\n<title>My S3TE Site</title>\n", force);
   await writeProjectFile(path.join(projectDir, "app", variant, "index.html"), "<!doctype html>\n<html lang=\"<lang>2</lang>\">\n  <head>\n    <part>head.part</part>\n  </head>\n  <body>\n    <h1>Hello from S3TemplateEngine</h1>\n  </body>\n</html>\n", force);
   await writeProjectFile(path.join(projectDir, "offline", "content", `${language}.json`), "[]\n", force);
@@ -529,6 +733,7 @@ export async function migrateProject(configPath, rawConfig, writeChanges) {
 
   const enableWebiny = Boolean(options.enableWebiny);
   const disableWebiny = Boolean(options.disableWebiny);
+  const targetEnvironment = options.environment ? String(options.environment).trim() : "";
   const webinySourceTable = options.webinySourceTable ? String(options.webinySourceTable).trim() : "";
   const webinyTenant = options.webinyTenant ? String(options.webinyTenant).trim() : "";
   const webinyModels = normalizeStringList(options.webinyModels);
@@ -537,45 +742,84 @@ export async function migrateProject(configPath, rawConfig, writeChanges) {
     throw new S3teError("CONFIG_CONFLICT_ERROR", "migrate does not allow --enable-webiny and --disable-webiny at the same time.");
   }
 
-  const touchesWebiny = enableWebiny || disableWebiny || Boolean(webinySourceTable) || webinyModels.length > 0;
+  const touchesWebiny = enableWebiny || disableWebiny || Boolean(webinySourceTable) || Boolean(webinyTenant) || webinyModels.length > 0;
   if (touchesWebiny) {
+    if (targetEnvironment && !nextConfig.environments?.[targetEnvironment]) {
+      throw new S3teError("CONFIG_CONFLICT_ERROR", `Unknown environment for migrate: ${targetEnvironment}.`);
+    }
+
     const existingIntegrations = nextConfig.integrations ?? {};
     const existingWebiny = existingIntegrations.webiny ?? {};
-    const existingModels = normalizeStringList(existingWebiny.relevantModels ?? ["staticContent", "staticCodeContent"]);
+    const existingEnvironmentOverrides = existingWebiny.environments ?? {};
+    const existingTargetWebiny = targetEnvironment
+      ? (existingEnvironmentOverrides[targetEnvironment] ?? {})
+      : existingWebiny;
+    const inheritedModels = normalizeStringList(
+      existingTargetWebiny.relevantModels
+      ?? (targetEnvironment ? existingWebiny.relevantModels : undefined)
+      ?? ["staticContent", "staticCodeContent"]
+    );
     const shouldEnableWebiny = disableWebiny
       ? false
       : (enableWebiny || Boolean(webinySourceTable) || webinyModels.length > 0
           ? true
-          : Boolean(existingWebiny.enabled));
-    const nextSourceTableName = webinySourceTable || existingWebiny.sourceTableName || "";
+          : Boolean(targetEnvironment
+              ? (existingTargetWebiny.enabled ?? existingWebiny.enabled)
+              : existingWebiny.enabled));
+    const nextSourceTableName = webinySourceTable
+      || existingTargetWebiny.sourceTableName
+      || (targetEnvironment ? existingWebiny.sourceTableName : "")
+      || "";
 
     if (shouldEnableWebiny && !nextSourceTableName) {
-      throw new S3teError("CONFIG_CONFLICT_ERROR", "Enabling Webiny requires --webiny-source-table <table> or an existing integrations.webiny.sourceTableName.");
+      throw new S3teError(
+        "CONFIG_CONFLICT_ERROR",
+        targetEnvironment
+          ? `Enabling Webiny for environment ${targetEnvironment} requires --webiny-source-table <table> or an existing sourceTableName.`
+          : "Enabling Webiny requires --webiny-source-table <table> or an existing integrations.webiny.sourceTableName."
+      );
     }
 
+    const nextWebinyConfig = {
+      enabled: shouldEnableWebiny,
+      sourceTableName: nextSourceTableName || undefined,
+      mirrorTableName: existingTargetWebiny.mirrorTableName
+        ?? (targetEnvironment ? existingWebiny.mirrorTableName : undefined)
+        ?? "{stackPrefix}_s3te_content_{project}",
+      tenant: webinyTenant || existingTargetWebiny.tenant || (targetEnvironment ? existingWebiny.tenant : undefined) || undefined,
+      relevantModels: normalizeStringList([
+        ...(inheritedModels.length > 0 ? inheritedModels : ["staticContent", "staticCodeContent"]),
+        ...webinyModels
+      ])
+    };
+
     nextConfig.integrations = {
       ...existingIntegrations,
-      webiny: {
-        enabled: shouldEnableWebiny,
-        sourceTableName: nextSourceTableName || undefined,
-        mirrorTableName: existingWebiny.mirrorTableName ?? "{stackPrefix}_s3te_content_{project}",
-        tenant: webinyTenant || existingWebiny.tenant || undefined,
-        relevantModels: normalizeStringList([
-          ...(existingModels.length > 0 ? existingModels : ["staticContent", "staticCodeContent"]),
-          ...webinyModels
-        ])
-      }
+      webiny: targetEnvironment
+        ? {
+            ...existingWebiny,
+            environments: {
+              ...existingEnvironmentOverrides,
+              [targetEnvironment]: nextWebinyConfig
+            }
+          }
+        : {
+            ...existingWebiny,
+            ...nextWebinyConfig,
+            environments: existingEnvironmentOverrides
+          }
     };
 
-    changes.push(shouldEnableWebiny ? "Enabled Webiny integration." : "Disabled Webiny integration.");
+    const scopeLabel = targetEnvironment ? ` for environment ${targetEnvironment}` : "";
+    changes.push(shouldEnableWebiny ? `Enabled Webiny integration${scopeLabel}.` : `Disabled Webiny integration${scopeLabel}.`);
     if (webinySourceTable) {
-      changes.push(`Set Webiny source table to ${webinySourceTable}.`);
+      changes.push(`Set Webiny source table${scopeLabel} to ${webinySourceTable}.`);
     }
     if (webinyTenant) {
-      changes.push(`Set Webiny tenant to ${webinyTenant}.`);
+      changes.push(`Set Webiny tenant${scopeLabel} to ${webinyTenant}.`);
     }
     if (webinyModels.length > 0) {
-      changes.push(`Added Webiny models: ${webinyModels.join(", ")}.`);
+      changes.push(`Added Webiny models${scopeLabel}: ${webinyModels.join(", ")}.`);
     }
   }
 

package/packages/core/src/config.mjs

@@ -3,7 +3,7 @@ import path from "node:path";
 
 import { assert, S3teError } from "./errors.mjs";
 
-const KNOWN_PLACEHOLDERS = new Set(["env", "stackPrefix", "project", "variant", "lang"]);
+const KNOWN_PLACEHOLDERS = new Set(["env", "envPrefix", "stackPrefix", "project", "variant", "lang"]);
 
 function upperSnakeCase(value) {
   return value.replace(/-/g, "_").toUpperCase();
@@ -28,7 +28,7 @@ function ensureKnownPlaceholders(input, fieldPath, errors) {
 }
 
 function replacePlaceholders(input, values) {
-  return String(input).replace(/\{(env|stackPrefix|project|variant|lang)\}/g, (_, token) => values[token]);
+  return String(input).replace(/\{(env|envPrefix|stackPrefix|project|variant|lang)\}/g, (_, token) => values[token]);
 }
 
 function normalizeRelativeProjectPath(relativePath) {
@@ -46,12 +46,58 @@ function isValidUpperSnake(value) {
   return /^[A-Z0-9_]+$/.test(value);
 }
 
+function normalizeStringList(values, fallback = []) {
+  const source = values ?? fallback;
+  const items = Array.isArray(source) ? source : [source];
+  return [...new Set(items
+    .map((value) => String(value).trim())
+    .filter(Boolean))];
+}
+
+function isProductionEnvironment(environmentName) {
+  return String(environmentName).trim().toLowerCase() === "prod";
+}
+
+function hasProductionEnvironment(config) {
+  return Object.keys(config.environments ?? {}).some((environmentName) => isProductionEnvironment(environmentName));
+}
+
+function environmentResourcePrefix(environmentName) {
+  return isProductionEnvironment(environmentName) ? "" : `${environmentName}-`;
+}
+
+function environmentHostPrefix(config, environmentName) {
+  if (!hasProductionEnvironment(config) || isProductionEnvironment(environmentName)) {
+    return "";
+  }
+
+  return `${environmentName}.`;
+}
+
+function prefixHostForEnvironment(config, host, environmentName) {
+  const prefix = environmentHostPrefix(config, environmentName);
+  if (!prefix) {
+    return host;
+  }
+
+  return host.startsWith(prefix) ? host : `${prefix}${host}`;
+}
+
+function isValidConfiguredHost(value) {
+  const candidate = String(value).trim();
+  if (!candidate || candidate.includes("://") || candidate.includes("/") || candidate.includes(":")) {
+    return false;
+  }
+
+  return /^[A-Za-z0-9.-]+$/.test(candidate);
+}
+
 function defaultTargetBucketPattern({ variant, language, languageCount, isDefaultLanguage, project }) {
   if (languageCount === 1 || isDefaultLanguage) {
-    return `{env}-${variant}-${project}`;
+    return `{envPrefix}${variant}-${project}`;
   }
 
-  return `{env}-${variant}-${project}-${language}`;
+  return `{envPrefix}${variant}-${project}-${language}`;
 }
 
 async function ensureDirectoryExists(projectDir, relativePath, errors) {
@@ -79,6 +125,7 @@ function createPlaceholderContext(config, environmentName, variantName, language
   const variantConfig = variantName ? config.variants[variantName] : null;
   return {
     env: environmentName,
+    envPrefix: environmentResourcePrefix(environmentName),
     stackPrefix: environmentConfig.stackPrefix,
     project: config.project.name,
     variant: variantName ?? "website",
@@ -86,6 +133,35 @@ function createPlaceholderContext(config, environmentName, variantName, language
   };
 }
 
+function resolveWebinyConfigDefaults(webinyConfig = {}) {
+  return {
+    enabled: webinyConfig.enabled ?? false,
+    sourceTableName: webinyConfig.sourceTableName,
+    mirrorTableName: webinyConfig.mirrorTableName ?? "{stackPrefix}_s3te_content_{project}",
+    relevantModels: normalizeStringList(webinyConfig.relevantModels, ["staticContent", "staticCodeContent"]),
+    tenant: webinyConfig.tenant
+  };
+}
+
+function resolveProjectWebinyConfig(projectConfig) {
+  const baseConfig = resolveWebinyConfigDefaults(projectConfig.integrations?.webiny ?? {});
+  const environmentConfigs = Object.fromEntries(Object.entries(projectConfig.integrations?.webiny?.environments ?? {}).map(([environmentName, webinyConfig]) => ([
+    environmentName,
+    {
+      enabled: webinyConfig.enabled,
+      sourceTableName: webinyConfig.sourceTableName,
+      mirrorTableName: webinyConfig.mirrorTableName,
+      relevantModels: webinyConfig.relevantModels ? normalizeStringList(webinyConfig.relevantModels) : undefined,
+      tenant: webinyConfig.tenant
+    }
+  ])));
+
+  return {
+    ...baseConfig,
+    environments: environmentConfigs
+  };
+}
+
 export async function loadProjectConfig(configPath) {
   const raw = await fs.readFile(configPath, "utf8");
   try {
@@ -148,7 +224,7 @@ export function resolveProjectConfig(projectConfig) {
       languages
     };
 
-    awsCodeBuckets[variantName] = awsCodeBuckets[variantName] ?? "{env}-{variant}-code-{project}";
+    awsCodeBuckets[variantName] = awsCodeBuckets[variantName] ?? "{envPrefix}{variant}-code-{project}";
   }
 
   const aws = {
@@ -171,13 +247,7 @@ export function resolveProjectConfig(projectConfig) {
   };
 
   const integrations = {
-    webiny: {
-      enabled: projectConfig.integrations?.webiny?.enabled ?? false,
-      sourceTableName: projectConfig.integrations?.webiny?.sourceTableName,
-      mirrorTableName: projectConfig.integrations?.webiny?.mirrorTableName ?? "{stackPrefix}_s3te_content_{project}",
-      relevantModels: projectConfig.integrations?.webiny?.relevantModels ?? ["staticContent", "staticCodeContent"],
-      tenant: projectConfig.integrations?.webiny?.tenant
-    }
+    webiny: resolveProjectWebinyConfig(projectConfig)
   };
 
   for (const [variantName, variantConfig] of Object.entries(variants)) {
@@ -219,13 +289,42 @@ export function resolveTargetBucketName(config, environmentName, variantName, la
   );
 }
 
+export function resolveBaseUrl(config, environmentName, variantName, languageCode) {
+  return prefixHostForEnvironment(
+    config,
+    config.variants[variantName].languages[languageCode].baseUrl,
+    environmentName
+  );
+}
+
+export function resolveCloudFrontAliases(config, environmentName, variantName, languageCode) {
+  return config.variants[variantName].languages[languageCode].cloudFrontAliases
+    .map((alias) => prefixHostForEnvironment(config, alias, environmentName));
+}
+
+export function resolveEnvironmentWebinyIntegration(config, environmentName) {
+  const baseConfig = resolveWebinyConfigDefaults(config.integrations?.webiny ?? {});
+  const environmentOverride = config.integrations?.webiny?.environments?.[environmentName] ?? {};
+
+  return {
+    enabled: environmentOverride.enabled ?? baseConfig.enabled,
+    sourceTableName: environmentOverride.sourceTableName ?? baseConfig.sourceTableName,
+    mirrorTableName: environmentOverride.mirrorTableName ?? baseConfig.mirrorTableName,
+    relevantModels: environmentOverride.relevantModels
+      ? normalizeStringList(environmentOverride.relevantModels)
+      : [...baseConfig.relevantModels],
+    tenant: environmentOverride.tenant ?? baseConfig.tenant
+  };
+}
+
 export function resolveTableNames(config, environmentName) {
   const context = createPlaceholderContext(config, environmentName);
+  const webinyConfig = resolveEnvironmentWebinyIntegration(config, environmentName);
   return {
     dependency: replacePlaceholders(config.aws.dependencyStore.tableName, context),
     content: replacePlaceholders(config.aws.contentStore.tableName, context),
     invalidation: replacePlaceholders(config.aws.invalidationStore.tableName, context),
-    webinyMirror: replacePlaceholders(config.integrations.webiny.mirrorTableName, context)
+    webinyMirror: replacePlaceholders(webinyConfig.mirrorTableName, context)
   };
 }
 
@@ -240,6 +339,7 @@ export function resolveStackName(config, environmentName) {
 
 export function buildEnvironmentRuntimeConfig(config, environmentName, stackOutputs = {}) {
   const environmentConfig = config.environments[environmentName];
+  const webinyConfig = resolveEnvironmentWebinyIntegration(config, environmentName);
   const tables = resolveTableNames(config, environmentName);
   const runtimeParameterName = resolveRuntimeManifestParameterName(config, environmentName);
   const stackName = resolveStackName(config, environmentName);
@@ -249,11 +349,13 @@ export function buildEnvironmentRuntimeConfig(config, environmentName, stackOutp
     const languages = {};
     for (const [languageCode, languageConfig] of Object.entries(variantConfig.languages)) {
       const targetBucket = resolveTargetBucketName(config, environmentName, variantName, languageCode);
+      const baseUrl = resolveBaseUrl(config, environmentName, variantName, languageCode);
+      const cloudFrontAliases = resolveCloudFrontAliases(config, environmentName, variantName, languageCode);
       languages[languageCode] = {
         code: languageCode,
-        baseUrl: languageConfig.baseUrl,
+        baseUrl,
         targetBucket,
-        cloudFrontAliases: [...languageConfig.cloudFrontAliases],
+        cloudFrontAliases,
         webinyLocale: languageConfig.webinyLocale,
         distributionId: stackOutputs.distributionIds?.[variantName]?.[languageCode] ?? "",
         distributionDomainName: stackOutputs.distributionDomains?.[variantName]?.[languageCode] ?? ""
@@ -284,7 +386,7 @@ export function buildEnvironmentRuntimeConfig(config, environmentName, stackOutp
     rendering: { ...config.rendering },
     integrations: {
       webiny: {
-        ...config.integrations.webiny,
+        ...webinyConfig,
         mirrorTableName: tables.webinyMirror
       }
     },
@@ -363,12 +465,28 @@ export async function validateAndResolveProjectConfig(projectConfig, options = {
           code: "CONFIG_SCHEMA_ERROR",
           message: `Variant ${variantName} language ${languageCode} is missing baseUrl.`
         });
+      } else if (!isValidConfiguredHost(languageConfig.baseUrl)) {
+        errors.push({
+          code: "CONFIG_SCHEMA_ERROR",
+          message: `Variant ${variantName} language ${languageCode} baseUrl must be a hostname without protocol or path.`,
+          details: { value: languageConfig.baseUrl }
+        });
       }
       if (!Array.isArray(languageConfig.cloudFrontAliases) || languageConfig.cloudFrontAliases.length === 0) {
         errors.push({
           code: "CONFIG_SCHEMA_ERROR",
           message: `Variant ${variantName} language ${languageCode} needs at least one cloudFrontAlias.`
         });
+      } else {
+        for (const alias of languageConfig.cloudFrontAliases) {
+          if (!isValidConfiguredHost(alias)) {
+            errors.push({
+              code: "CONFIG_SCHEMA_ERROR",
+              message: `Variant ${variantName} language ${languageCode} cloudFrontAliases must contain hostnames without protocol or path.`,
+              details: { value: alias }
+            });
+          }
+        }
       }
       if (languageConfig.webinyLocale !== undefined && typeof languageConfig.webinyLocale !== "string") {
         errors.push({
@@ -383,11 +501,27 @@ export async function validateAndResolveProjectConfig(projectConfig, options = {
     }
   }
 
-  if (projectConfig.integrations?.webiny?.enabled && !projectConfig.integrations?.webiny?.sourceTableName) {
-    errors.push({
-      code: "CONFIG_CONFLICT_ERROR",
-      message: "Webiny integration requires sourceTableName when enabled."
-    });
+  const configuredWebiny = projectConfig.integrations?.webiny;
+  for (const [environmentName] of environmentEntries) {
+    const environmentWebinyConfig = resolveEnvironmentWebinyIntegration(resolveProjectConfig({
+      ...projectConfig,
+      environments: Object.fromEntries(environmentEntries)
+    }), environmentName);
+    if (environmentWebinyConfig.enabled && !environmentWebinyConfig.sourceTableName) {
+      errors.push({
+        code: "CONFIG_CONFLICT_ERROR",
+        message: `Webiny integration requires sourceTableName when enabled for environment ${environmentName}.`
+      });
+    }
+  }
+
+  for (const environmentName of Object.keys(configuredWebiny?.environments ?? {})) {
+    if (!projectConfig.environments?.[environmentName]) {
+      errors.push({
+        code: "CONFIG_CONFLICT_ERROR",
+        message: `integrations.webiny.environments.${environmentName} does not match a configured environment.`
+      });
+    }
   }
 
   for (const [variantName, pattern] of Object.entries(projectConfig.aws?.codeBuckets ?? {})) {
@@ -403,8 +537,13 @@ export async function validateAndResolveProjectConfig(projectConfig, options = {
   if (projectConfig.aws?.invalidationStore?.tableName) {
     ensureKnownPlaceholders(projectConfig.aws.invalidationStore.tableName, "aws.invalidationStore.tableName", errors);
   }
-  if (projectConfig.integrations?.webiny?.mirrorTableName) {
-    ensureKnownPlaceholders(projectConfig.integrations.webiny.mirrorTableName, "integrations.webiny.mirrorTableName", errors);
+  if (configuredWebiny?.mirrorTableName) {
+    ensureKnownPlaceholders(configuredWebiny.mirrorTableName, "integrations.webiny.mirrorTableName", errors);
+  }
+  for (const [environmentName, webinyConfig] of Object.entries(configuredWebiny?.environments ?? {})) {
+    if (webinyConfig.mirrorTableName) {
+      ensureKnownPlaceholders(webinyConfig.mirrorTableName, `integrations.webiny.environments.${environmentName}.mirrorTableName`, errors);
+    }
   }
 
   if (errors.length > 0) {
@@ -414,6 +553,7 @@ export async function validateAndResolveProjectConfig(projectConfig, options = {
   const resolvedConfig = resolveProjectConfig(projectConfig);
   const seenTargetBuckets = new Set();
   const seenCodeBuckets = new Set();
+  const seenCloudFrontAliases = new Set();
 
   for (const variantConfig of Object.values(resolvedConfig.variants)) {
     await ensureDirectoryExists(projectDir, variantConfig.sourceDir, errors);
@@ -452,6 +592,16 @@ export async function validateAndResolveProjectConfig(projectConfig, options = {
           });
         }
         seenTargetBuckets.add(targetBucket);
+
+        for (const alias of resolveCloudFrontAliases(resolvedConfig, environmentName, variantName, languageCode)) {
+          if (seenCloudFrontAliases.has(alias)) {
+            errors.push({
+              code: "CONFIG_CONFLICT_ERROR",
+              message: `Duplicate cloudFrontAlias ${alias}.`
+            });
+          }
+          seenCloudFrontAliases.add(alias);
+        }
       }
     }
   }

package/packages/core/src/index.mjs

@@ -4,7 +4,10 @@ export { minifyHtml, repairTruncatedHtml } from "./minify.mjs";
 export {
   buildEnvironmentRuntimeConfig,
   loadProjectConfig,
+  resolveBaseUrl,
   resolveCodeBucketName,
+  resolveCloudFrontAliases,
+  resolveEnvironmentWebinyIntegration,
   resolveRuntimeManifestParameterName,
   resolveProjectConfig,
   resolveStackName,

package/packages/core/src/render.mjs

@@ -4,6 +4,7 @@ import { assert, S3teError } from "./errors.mjs";
 import { getContentTypeForPath } from "./mime.mjs";
 import { minifyHtml, repairTruncatedHtml } from "./minify.mjs";
 import { readContentField, serializeContentValue } from "./content-query.mjs";
+import { resolveBaseUrl } from "./config.mjs";
 
 function createWarning(code, message, sourceKey) {
   return { code, message, sourceKey };
@@ -442,7 +443,7 @@ export async function renderSourceTemplate({ config, templateRepository, content
     language: languageCode,
     sourceKey,
     outputKey: sourceWithinVariant,
-    baseUrl: buildDefaultBaseUrl(languageConfig.baseUrl)
+    baseUrl: buildDefaultBaseUrl(resolveBaseUrl(config, environment, variantName, languageCode))
   };
 
   const trimmed = stripLeadingWhitespace(body);
@@ -527,7 +528,7 @@ export function createManualRenderTargets({ config, templateEntries, environment
           language: languageCode,
           sourceKey: templateEntry.key,
           outputKey,
-          baseUrl: config.variants[variantName].languages[languageCode].baseUrl
+          baseUrl: resolveBaseUrl(config, environment, variantName, languageCode)
         });
       }
     }