@projectdochelp/s3te 3.1.1 → 3.1.3

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)
         });
       }
     }