@projectdochelp/s3te 3.4.1 → 3.4.4

package/README.md

@@ -724,7 +724,8 @@ Filter notes:
 - multiple clauses are combined with logical `AND`
 - `__typename` matches the content model, for example `article`
 - supported legacy value wrappers are `S`, `N`, `BOOL`, `NULL`, and `L`
-- results are sorted deterministically; numeric `order` comes first, then `contentId`, then `id`
+- results are sorted deterministically; items with a numeric field `order` are rendered first in ascending order, then items without a numeric `order`, then `contentId`, then `id`
+- this also works with mirrored Webiny content if the model contains a field with the exact field ID `order` and type `number`
 
 **Example**
 
@@ -1018,6 +1019,13 @@ That makes the option example above equivalent to a config that contains:
 
 Use this for every Webiny model whose entries should be available to S3TE template commands like `dbitem`, `dbmulti`, `dbmultifile`, `dbmultifileitem`, or `dbpart`.
 
+If a Webiny model should control the output order for `dbmulti` or `dbmultifile`, add a field with:
+
+- field ID `order`
+- field type `number`
+
+S3TE sorts matching items by that numeric `order` in ascending order. Items without a numeric `order` stay at the end.
+
 If different environments should read from different Webiny installations or tenants, run the option command per environment:
 
 ```bash

package/package.json

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

package/packages/cli/src/fs-adapters.mjs

@@ -7,6 +7,12 @@ function normalizeKey(value) {
   return String(value).replace(/\\/g, "/");
 }
 
+function matchesProjectRelativeRoot(key, root) {
+  const normalizedKey = normalizeKey(key);
+  const normalizedRoot = normalizeKey(root);
+  return normalizedKey === normalizedRoot || normalizedKey.startsWith(`${normalizedRoot}/`);
+}
+
 function normalizeLocale(value) {
   return String(value).trim().toLowerCase();
 }
@@ -122,6 +128,15 @@ export class FileSystemTemplateRepository {
   resolveKey(key) {
     const normalized = normalizeKey(key);
 
+    for (const variantConfig of Object.values(this.config.variants)) {
+      if (
+        matchesProjectRelativeRoot(normalized, variantConfig.sourceDir)
+        || matchesProjectRelativeRoot(normalized, variantConfig.partDir)
+      ) {
+        return path.join(this.projectDir, normalized);
+      }
+    }
+
     for (const [variantName, variantConfig] of Object.entries(this.config.variants)) {
       if (normalized === variantName || normalized.startsWith(`${variantName}/`)) {
         const suffix = normalized === variantName ? "" : normalized.slice(variantName.length + 1);

package/packages/core/src/content-query.mjs

@@ -83,13 +83,42 @@ function compareFilter(actual, expected, filterType) {
   return actual === expected;
 }
 
+function coerceNumericOrderValue(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+
+  const legacyValue = legacyAttributeValueToPlain(value);
+  if (legacyValue !== undefined && legacyValue !== value) {
+    return coerceNumericOrderValue(legacyValue);
+  }
+
+  return null;
+}
+
+function readOrderValue(item) {
+  const candidate = item?.values?.order ?? item?.order;
+  return coerceNumericOrderValue(candidate);
+}
+
 function compareOrder(a, b) {
-  const aHasOrder = typeof a.values?.order === "number";
-  const bHasOrder = typeof b.values?.order === "number";
+  const aOrder = readOrderValue(a);
+  const bOrder = readOrderValue(b);
+  const aHasOrder = aOrder !== null;
+  const bHasOrder = bOrder !== null;
 
   if (aHasOrder && bHasOrder) {
-    if (a.values.order !== b.values.order) {
-      return a.values.order - b.values.order;
+    if (aOrder !== bOrder) {
+      return aOrder - bOrder;
     }
   } else if (aHasOrder && !bHasOrder) {
     return -1;