@projectdochelp/s3te 3.3.1 → 3.3.3

package/package.json

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

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

@@ -17,6 +17,7 @@ import {
   BatchWriteCommand,
   DeleteCommand,
   DynamoDBDocumentClient,
+  GetCommand,
   PutCommand,
   QueryCommand,
   ScanCommand
@@ -75,8 +76,37 @@ function localeMatchScore(itemLocale, language, languageLocaleMap) {
   return 0;
 }
 
-function matchesRequestedLocale(item, language, languageLocaleMap) {
-  return localeMatchScore(item?.locale, language, languageLocaleMap) > 0;
+function comparableTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+
+  const timestamp = Date.parse(String(value ?? ""));
+  return Number.isFinite(timestamp) ? timestamp : -1;
+}
+
+function compareContentFreshness(left, right) {
+  const updatedDiff = comparableTimestamp(right.updatedAt) - comparableTimestamp(left.updatedAt);
+  if (updatedDiff !== 0) {
+    return updatedDiff;
+  }
+
+  const changedDiff = comparableTimestamp(right.lastChangedAt) - comparableTimestamp(left.lastChangedAt);
+  if (changedDiff !== 0) {
+    return changedDiff;
+  }
+
+  const createdDiff = comparableTimestamp(right.createdAt) - comparableTimestamp(left.createdAt);
+  if (createdDiff !== 0) {
+    return createdDiff;
+  }
+
+  const versionDiff = Number(right.version ?? -1) - Number(left.version ?? -1);
+  if (versionDiff !== 0) {
+    return versionDiff;
+  }
+
+  return String(right.id ?? "").localeCompare(String(left.id ?? ""));
 }
 
 function filterItemsByRequestedLocale(items, language, languageLocaleMap) {
@@ -102,7 +132,11 @@ function filterItemsByRequestedLocale(items, language, languageLocaleMap) {
     }
 
     const bestScore = Math.max(...scored.map((entry) => entry.score));
-    return scored.filter((entry) => entry.score === bestScore).map((entry) => entry.item);
+    return scored
+      .filter((entry) => entry.score === bestScore)
+      .map((entry) => entry.item)
+      .sort(compareContentFreshness)
+      .slice(0, 1);
   });
 }
 
@@ -143,6 +177,7 @@ export function createAwsClients(region = process.env.AWS_REGION) {
       invoke: InvokeCommand
     }),
     dynamo: wrapCommandClient(dynamoDocumentClient, {
+      get: GetCommand,
       query: QueryCommand,
       scan: ScanCommand,
       batchWrite: BatchWriteCommand,
@@ -247,7 +282,7 @@ export function buildCoreConfigFromEnvironment(manifest, environmentName) {
         debounceSeconds: 60
       },
       lambda: {
-        runtime: "nodejs22.x",
+        runtime: "nodejs24.x",
         architecture: "arm64"
       }
     },
@@ -388,14 +423,7 @@ export class DynamoContentRepository {
       }
     }).promise();
     const items = response.Items ?? [];
-    const candidates = items
-      .map((item) => ({
-        item,
-        score: localeMatchScore(item.locale, language, this.languageLocaleMap)
-      }))
-      .filter((entry) => entry.score > 0)
-      .sort((left, right) => right.score - left.score || String(left.item.id).localeCompare(String(right.item.id)));
-    return candidates[0]?.item ?? null;
+    return filterItemsByRequestedLocale(items, language, this.languageLocaleMap)[0] ?? null;
   }
 
   async query(query, language) {

package/packages/aws-adapter/src/runtime/content-mirror.mjs

@@ -1,3 +1,5 @@
+import { gunzipSync } from "node:zlib";
+
 import { createAwsClients, invokeLambdaEvent } from "./common.mjs";
 
 function escapeHtml(value) {
@@ -134,10 +136,118 @@ function toSimpleValue(value) {
   return String(value);
 }
 
-function normalizeValues(item) {
-  const valueSource = item.values && typeof item.values === "object"
-    ? item.values
-    : (item.data && typeof item.data === "object" && !Array.isArray(item.data) ? item.data : null);
+function getItemRoot(item) {
+  return hasNestedEntryEnvelope(item)
+    ? item.data
+    : item;
+}
+
+function hasNestedEntryEnvelope(item) {
+  if (!item?.data || typeof item.data !== "object" || Array.isArray(item.data)) {
+    return false;
+  }
+
+  return [
+    "id",
+    "entryId",
+    "model",
+    "modelId",
+    "tenant",
+    "tenantId",
+    "status",
+    "values",
+    "createdOn",
+    "savedOn",
+    "publishedOn",
+    "lastPublishedOn"
+  ].some((key) => Object.prototype.hasOwnProperty.call(item.data, key));
+}
+
+function decodeCompressedValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+
+  if (typeof value.compression !== "string" || typeof value.value !== "string") {
+    return value;
+  }
+
+  try {
+    const compressed = Buffer.from(value.value, "base64");
+    if (value.compression === "gzip") {
+      const inflated = gunzipSync(compressed).toString("utf8");
+      if (value.isArray) {
+        return JSON.parse(inflated);
+      }
+      return inflated;
+    }
+  } catch {
+    return "";
+  }
+
+  return value.value;
+}
+
+function getFieldIdentifiers(field) {
+  return [field?.storageId, field?.fieldId].filter(Boolean);
+}
+
+function findFieldValue(rawValues, field) {
+  for (const identifier of getFieldIdentifiers(field)) {
+    if (Object.prototype.hasOwnProperty.call(rawValues, identifier)) {
+      return rawValues[identifier];
+    }
+  }
+  return undefined;
+}
+
+function normalizeFieldValue(rawValue, field) {
+  const decodedValue = decodeCompressedValue(rawValue);
+
+  if (field?.type === "object") {
+    const nestedFields = Array.isArray(field.settings?.fields) ? field.settings.fields : [];
+    if (Array.isArray(decodedValue)) {
+      return decodedValue.map((entry) => normalizeFieldValue(entry, {
+        ...field,
+        list: false
+      }));
+    }
+    if (decodedValue && typeof decodedValue === "object") {
+      return normalizeMappedValues(decodedValue, nestedFields);
+    }
+  }
+
+  if (Array.isArray(decodedValue)) {
+    return decodedValue.map((entry) => toSimpleValue(entry));
+  }
+
+  return toSimpleValue(decodedValue);
+}
+
+function normalizeMappedValues(rawValues, fields = []) {
+  const values = {};
+  for (const field of fields) {
+    const rawValue = findFieldValue(rawValues, field);
+    if (rawValue === undefined) {
+      continue;
+    }
+    values[field.fieldId] = normalizeFieldValue(rawValue, field);
+  }
+  return values;
+}
+
+function normalizeValues(item, modelFields = []) {
+  const root = getItemRoot(item);
+  const valueSource = root?.values && typeof root.values === "object"
+    ? root.values
+    : (!hasNestedEntryEnvelope(item) && item?.data && typeof item.data === "object" && !Array.isArray(item.data) ? item.data : null);
+
+  if (valueSource && Array.isArray(modelFields) && modelFields.length > 0) {
+    const mappedValues = normalizeMappedValues(valueSource, modelFields);
+    if (Object.keys(mappedValues).length > 0) {
+      return mappedValues;
+    }
+  }
 
   if (valueSource) {
     return Object.fromEntries(Object.entries(valueSource).map(([key, value]) => [key, toSimpleValue(value)]));
@@ -178,44 +288,62 @@ function normalizeValues(item) {
 }
 
 function isPublished(item) {
-  return item.status === "published"
-    || item.published === true
-    || item.isPublished === true
-    || item.publishedOn != null;
+  const root = getItemRoot(item);
+  return root.status === "published"
+    || root.published === true
+    || root.isPublished === true
+    || root.publishedOn != null
+    || root.firstPublishedOn != null
+    || root.lastPublishedOn != null;
 }
 
 function extractWebinyLocale(item) {
-  return item.locale
-    ?? item.localeCode
-    ?? item.i18n?.locale?.code
-    ?? item.i18n?.localeCode
+  const root = getItemRoot(item);
+  return root.locale
+    ?? root.localeCode
+    ?? root.i18n?.locale?.code
+    ?? root.i18n?.localeCode
     ?? null;
 }
 
 function extractWebinyTenant(item) {
-  return item.tenant
-    ?? item.tenantId
-    ?? item.createdBy?.tenant
+  const root = getItemRoot(item);
+  return root.tenant
+    ?? root.tenantId
+    ?? root.createdBy?.tenant
     ?? null;
 }
 
-export function normalizeContentItem(item) {
-  const model = item.model
-    ?? item.modelId
-    ?? item.__typename
-    ?? item.contentModel?.modelId
+function normalizeMirrorLocale(value) {
+  return value == null ? "" : String(value).trim().toLowerCase();
+}
+
+function isSameMirroredContentIdentity(existingItem, contentItem) {
+  return String(existingItem.contentId ?? "") === String(contentItem.contentId ?? "")
+    && String(existingItem.model ?? "") === String(contentItem.model ?? "")
+    && String(existingItem.tenant ?? "") === String(contentItem.tenant ?? "")
+    && normalizeMirrorLocale(existingItem.locale) === normalizeMirrorLocale(contentItem.locale);
+}
+
+export function normalizeContentItem(item, options = {}) {
+  const root = getItemRoot(item);
+  const values = normalizeValues(item, options.modelFields);
+  const model = root.model
+    ?? root.modelId
+    ?? root.__typename
+    ?? root.contentModel?.modelId
     ?? null;
   return {
-    id: item.id,
-    contentId: item.contentId ?? item.contentid ?? item.entryId ?? item.id,
+    id: root.id ?? item.id,
+    contentId: values.contentId ?? values.contentid ?? root.contentId ?? root.contentid ?? root.entryId ?? root.id ?? item.id,
     model,
     locale: extractWebinyLocale(item) ?? undefined,
     tenant: extractWebinyTenant(item) ?? undefined,
-    values: normalizeValues(item),
-    createdAt: item.createdAt ?? item.createdOn,
-    updatedAt: item.updatedAt ?? item.savedOn ?? item.publishedOn,
-    version: item._version ?? item.version,
-    lastChangedAt: item._lastChangedAt ?? item.lastChangedAt
+    values,
+    createdAt: root.createdAt ?? root.createdOn,
+    updatedAt: root.updatedAt ?? root.savedOn ?? root.publishedOn ?? root.lastPublishedOn,
+    version: root._version ?? root.version,
+    lastChangedAt: root._lastChangedAt ?? root.lastChangedAt
   };
 }
 
@@ -224,20 +352,87 @@ export function matchesConfiguredTenant(item, configuredTenant) {
     return true;
   }
 
-  const tenant = item.tenant ?? item.tenantId ?? item.createdBy?.tenant ?? null;
+  const root = getItemRoot(item);
+  const tenant = root.tenant ?? root.tenantId ?? root.createdBy?.tenant ?? null;
   return tenant != null && String(tenant) === String(configuredTenant);
 }
 
+async function loadModelFields(clients, sourceTableName, tenant, modelId, cache) {
+  if (!sourceTableName || !tenant || !modelId) {
+    return [];
+  }
+
+  const cacheKey = `${tenant}#${modelId}`;
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey);
+  }
+
+  const response = await clients.dynamo.get({
+    TableName: sourceTableName,
+    Key: {
+      PK: `T#${tenant}#CMS#CM`,
+      SK: modelId
+    }
+  }).promise();
+  const model = response.Item?.data ?? response.Item ?? null;
+  const fields = Array.isArray(model?.fields) ? model.fields : [];
+  cache.set(cacheKey, fields);
+  return fields;
+}
+
+async function listMirroredContentItems(clients, tableName, indexName, contentId) {
+  const items = [];
+  let lastEvaluatedKey;
+
+  do {
+    const response = await clients.dynamo.query({
+      TableName: tableName,
+      IndexName: indexName,
+      KeyConditionExpression: "contentId = :contentId",
+      ExpressionAttributeValues: {
+        ":contentId": contentId
+      },
+      ExclusiveStartKey: lastEvaluatedKey
+    }).promise();
+    items.push(...(response.Items ?? []));
+    lastEvaluatedKey = response.LastEvaluatedKey;
+  } while (lastEvaluatedKey);
+
+  return items;
+}
+
+async function removeMirroredContentRevisions(clients, tableName, indexName, contentItem, excludeId = null) {
+  const mirroredItems = await listMirroredContentItems(clients, tableName, indexName, contentItem.contentId);
+  const removals = mirroredItems.filter((existingItem) => (
+    isSameMirroredContentIdentity(existingItem, contentItem)
+    && existingItem.id !== excludeId
+  ));
+
+  for (const existingItem of removals) {
+    await clients.dynamo.delete({
+      TableName: tableName,
+      Key: {
+        id: existingItem.id
+      }
+    }).promise();
+  }
+
+  return removals.length;
+}
+
 export async function handler(event) {
   const clients = createAwsClients();
   const tableName = process.env.S3TE_CONTENT_TABLE;
   const renderWorkerName = process.env.S3TE_RENDER_WORKER_NAME;
   const environmentName = process.env.S3TE_ENVIRONMENT;
+  const sourceTableName = process.env.S3TE_WEBINY_SOURCE_TABLE;
+  const contentIndexName = process.env.S3TE_CONTENT_ID_INDEX_NAME ?? "contentid";
   const configuredTenant = String(process.env.S3TE_WEBINY_TENANT ?? "").trim();
   const relevantModels = new Set(String(process.env.S3TE_RELEVANT_MODELS ?? "")
     .split(",")
     .map((entry) => entry.trim())
     .filter(Boolean));
+  const modelFieldCache = new Map();
 
   let mirrored = 0;
   let deleted = 0;
@@ -253,20 +448,22 @@ export async function handler(event) {
       continue;
     }
 
-    const contentItem = normalizeContentItem(item);
+    const itemRoot = getItemRoot(item);
+    const modelFields = await loadModelFields(
+      clients,
+      sourceTableName,
+      extractWebinyTenant(item),
+      itemRoot?.modelId ?? itemRoot?.model,
+      modelFieldCache
+    );
+    const contentItem = normalizeContentItem(item, { modelFields });
     if (!contentItem.id || !contentItem.model || (relevantModels.size > 0 && !relevantModels.has(contentItem.model))) {
       continue;
     }
 
     const shouldDelete = record.eventName === "REMOVE" || !isPublished(item);
     if (shouldDelete) {
-      await clients.dynamo.delete({
-        TableName: tableName,
-        Key: {
-          id: contentItem.id
-        }
-      }).promise();
-      deleted += 1;
+      deleted += await removeMirroredContentRevisions(clients, tableName, contentIndexName, contentItem);
       await invokeLambdaEvent(clients.lambda, renderWorkerName, {
         type: "content-item",
         action: "delete",
@@ -278,6 +475,7 @@ export async function handler(event) {
       continue;
     }
 
+    await removeMirroredContentRevisions(clients, tableName, contentIndexName, contentItem, contentItem.id);
     await clients.dynamo.put({
       TableName: tableName,
       Item: contentItem

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

@@ -631,7 +631,9 @@ export function buildWebinyCloudFormationTemplate({ config, environment }) {
             Variables: {
               S3TE_ENVIRONMENT: environment,
               S3TE_CONTENT_TABLE: runtimeConfig.tables.content,
+              S3TE_CONTENT_ID_INDEX_NAME: config.aws.contentStore.contentIdIndexName,
               S3TE_RELEVANT_MODELS: runtimeConfig.integrations.webiny.relevantModels.join(","),
+              S3TE_WEBINY_SOURCE_TABLE: runtimeConfig.integrations.webiny.sourceTableName,
               S3TE_WEBINY_TENANT: runtimeConfig.integrations.webiny.tenant ?? "",
               S3TE_RENDER_WORKER_NAME: functionNames.renderWorker
             }

package/packages/cli/src/project.mjs

@@ -291,7 +291,7 @@ function schemaTemplate() {
             properties: {
               runtime: {
                 type: "string",
-                enum: ["nodejs22.x"]
+                enum: ["nodejs24.x"]
               },
               architecture: {
                 type: "string",

package/packages/core/src/config.mjs

@@ -277,7 +277,7 @@ export function resolveProjectConfig(projectConfig) {
       debounceSeconds: projectConfig.aws?.invalidationStore?.debounceSeconds ?? 60
     },
     lambda: {
-      runtime: projectConfig.aws?.lambda?.runtime ?? "nodejs22.x",
+      runtime: projectConfig.aws?.lambda?.runtime ?? "nodejs24.x",
       architecture: projectConfig.aws?.lambda?.architecture ?? "arm64"
     }
   };