@reventlessdev/reventless-core 3.0.0-alpha.199 → 3.0.0-alpha.201

package/src/util/StorePrefixCollision.res

@@ -0,0 +1,96 @@
+// Two declared object stores a platform cannot keep apart.
+//
+// Lives in core, not in an adapter: the rule is about a namespace, not about a
+// cloud. The deployed platform enforces it as a gate before it provisions
+// anything, and the local platform reports it at composition — one predicate, so
+// the two cannot drift into disagreeing about what a collision is.
+
+/** One declared store as the collision check sees it: its qualified key and the
+    prefix its objects are rooted at.
+
+    `site` is the `{component}.{field}` that declared it, when the caller has it.
+    The deploy-time capability list does not — `Platform.capability` carries only
+    `{plugin, store}`, and the generator renders provenance as comments in the
+    platform's generated capability file — so the deploy message points a reader
+    there instead of inventing a site it cannot know. */
+type declaredStore = {
+  qualified: string,
+  prefix: string,
+  site?: string,
+}
+
+/**
+Two stores a platform cannot keep apart.
+
+The prefix is a **platform-global** namespace, not a per-bucket one: exactly one
+distribution fronts every store bucket, and it takes one cache behavior per
+served prefix. So two stores on one prefix are unroutable in either layout — a
+shared bucket lists the prefix twice, a per-store layout lists it once per
+bucket, and CloudFront accepts neither. Left to the deploy, that surfaces as an
+AWS error naming a path pattern rather than the two plugins that caused it,
+minutes in, after the silent damage below has already been provisioned:
+intermixed objects, and a presign grant scoped by prefix that reaches into both
+stores at once.
+
+Compares **prefixes, not store names**, and on **containment, not equality**:
+`a` collides with `a/b`, because a store rooted at `a` encloses one rooted at
+`a/b` for serving, for IAM and for wiping alike. Both choices are what let a
+qualified prefix scheme relax this check without rewriting it — a qualified
+prefix simply stops colliding.
+*/
+type collision = {
+  first: declaredStore,
+  second: declaredStore,
+  /** True when the first prefix encloses the second rather than equalling it. */
+  nested: bool,
+}
+
+let collisionsFor = (~stores: array<declaredStore>): array<collision> =>
+  stores->Array.reduceWithIndex([], (found, a, i) =>
+    stores->Array.reduceWithIndex(found, (found, b, j) =>
+      if j <= i || a.qualified == b.qualified {
+        found
+      } else if a.prefix == b.prefix {
+        Array.concat(found, [{first: a, second: b, nested: false}])
+      } else if b.prefix->String.startsWith(a.prefix ++ "/") {
+        Array.concat(found, [{first: a, second: b, nested: true}])
+      } else if a.prefix->String.startsWith(b.prefix ++ "/") {
+        Array.concat(found, [{first: b, second: a, nested: true}])
+      } else {
+        found
+      }
+    )
+  )
+
+/** The refusal text. Names both declaration sites, because "two stores collide"
+    without them sends a reader hunting through every schema in the platform —
+    and states both remedies, because a cross-plugin store is legitimate when the
+    `@storageRef` annotation qualifies it, and only accidental when it does not. */
+let collisionMessage = (c: collision): string => {
+  let site = (s: declaredStore) =>
+    switch s.site {
+    | Some(site) => `  ${s.qualified} — declared at ${site}\n`
+    | None => ""
+    }
+  let sites = site(c.first) ++ site(c.second)
+  let where = sites == ""
+    ? `  Both keys appear in the platform's generated capability file, which records each ` ++
+      `declaring component and field as a comment.\n`
+    : sites
+  if c.nested {
+    `Object store "${c.first.qualified}" is rooted at "${c.first.prefix}/", which encloses ` ++
+    `"${c.second.qualified}" at "${c.second.prefix}/".\n` ++
+    where ++
+    `  One store's objects would sit inside the other's — for serving, for upload grants and ` ++
+    `for a store wipe alike. Rename one of them.`
+  } else {
+    `Object stores "${c.first.qualified}" and "${c.second.qualified}" both root their objects ` ++
+    `at "${c.first.prefix}/".\n` ++
+    where ++
+    `  A platform serves one cache behavior per prefix and scopes upload grants by prefix, so ` ++
+    `two stores cannot share one.\n` ++
+    `  Rename one store, or — if they were meant to be one shared store — qualify the ` ++
+    `\`@storageRef\` annotation with the owning plugin.`
+  }
+}
+

package/src/util/StorePrefixCollision.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+
+function collisionsFor(stores) {
+  return Stdlib_Array.reduceWithIndex(stores, [], (found, a, i) => Stdlib_Array.reduceWithIndex(stores, found, (found, b, j) => {
+    if (j <= i || a.qualified === b.qualified) {
+      return found;
+    } else if (a.prefix === b.prefix) {
+      return found.concat([{
+          first: a,
+          second: b,
+          nested: false
+        }]);
+    } else if (b.prefix.startsWith(a.prefix + "/")) {
+      return found.concat([{
+          first: a,
+          second: b,
+          nested: true
+        }]);
+    } else if (a.prefix.startsWith(b.prefix + "/")) {
+      return found.concat([{
+          first: b,
+          second: a,
+          nested: true
+        }]);
+    } else {
+      return found;
+    }
+  }));
+}
+
+function collisionMessage(c) {
+  let site = s => {
+    let site$1 = s.site;
+    if (site$1 !== undefined) {
+      return `  ` + s.qualified + ` — declared at ` + site$1 + `\n`;
+    } else {
+      return "";
+    }
+  };
+  let sites = site(c.first) + site(c.second);
+  let where = sites === "" ? `  Both keys appear in the platform's generated capability file, which records each declaring component and field as a comment.\n` : sites;
+  if (c.nested) {
+    return `Object store "` + c.first.qualified + `" is rooted at "` + c.first.prefix + `/", which encloses ` + (`"` + c.second.qualified + `" at "` + c.second.prefix + `/".\n`) + where + `  One store's objects would sit inside the other's — for serving, for upload grants and for a store wipe alike. Rename one of them.`;
+  } else {
+    return `Object stores "` + c.first.qualified + `" and "` + c.second.qualified + `" both root their objects ` + (`at "` + c.first.prefix + `/".\n`) + where + `  A platform serves one cache behavior per prefix and scopes upload grants by prefix, so two stores cannot share one.\n  Rename one store, or — if they were meant to be one shared store — qualify the \`@storageRef\` annotation with the owning plugin.`;
+  }
+}
+
+export {
+  collisionsFor,
+  collisionMessage,
+}
+/* No side effect */

package/tests/StorePrefixCollisionTest.res

@@ -0,0 +1,160 @@
+open JestGlobals
+
+// The rule these guard is that a store's key prefix is a PLATFORM-global
+// namespace: one distribution fronts every store bucket and takes one cache
+// behavior per prefix, so two stores on one prefix are unroutable whatever the
+// bucket layout. Left to the deploy that surfaces as a CloudFront error about a
+// path pattern, minutes in and naming neither plugin.
+
+module Collision = StorePrefixCollision
+
+let store = (~qualified, ~prefix, ~site=?): Collision.declaredStore => {
+  qualified,
+  prefix,
+  ?site,
+}
+
+describe("collisionsFor", () => {
+  testSync("distinct prefixes do not collide", () =>
+    expect(
+      Collision.collisionsFor(
+        ~stores=[
+          store(~qualified="Catalog.productImages", ~prefix="productImages"),
+          store(~qualified="Ordering.labels", ~prefix="labels"),
+        ],
+      )->Array.length,
+    )->toBe(0)
+  )
+
+  testSync("two plugins declaring one store name collide", () =>
+    switch Collision.collisionsFor(
+      ~stores=[
+        store(~qualified="Catalog.productImages", ~prefix="productImages"),
+        store(~qualified="Ordering.productImages", ~prefix="productImages"),
+      ],
+    ) {
+    | [c] => expect((c.first.qualified, c.second.qualified, c.nested))->toEqual((
+        "Catalog.productImages",
+        "Ordering.productImages",
+        false,
+      ))
+    | other => fail(`expected exactly one collision, got ${other->Array.length->Int.toString}`)
+    }
+  )
+
+  // Deliberate cross-plugin sharing resolves to ONE qualified key upstream, so
+  // it never reaches this predicate as two stores. Sharing is legitimate; only
+  // two independent claims on one prefix are not.
+  testSync("one store referenced by several plugins is a single entry, not a collision", () =>
+    expect(
+      Collision.collisionsFor(
+        ~stores=[store(~qualified="Catalog.productImages", ~prefix="productImages")],
+      )->Array.length,
+    )->toBe(0)
+  )
+
+  // Containment, not equality: a store rooted at `a` encloses one at `a/b` for
+  // serving, for upload grants and for a store wipe alike.
+  testSync("an enclosing prefix collides with what it encloses", () =>
+    switch Collision.collisionsFor(
+      ~stores=[
+        store(~qualified="Catalog.productImages", ~prefix="Catalog/productImages"),
+        store(~qualified="Legacy.catalog", ~prefix="Catalog"),
+      ],
+    ) {
+    | [c] =>
+      // The enclosing store is reported first whichever order they arrive in.
+      expect((c.first.qualified, c.nested))->toEqual(("Legacy.catalog", true))
+    | other => fail(`expected exactly one collision, got ${other->Array.length->Int.toString}`)
+    }
+  )
+
+  // A shared character run is not nesting — the delete/serve boundary is a path
+  // segment, so `images` does not reach `images-archive`.
+  testSync("a sibling prefix sharing a character run does not collide", () =>
+    expect(
+      Collision.collisionsFor(
+        ~stores=[
+          store(~qualified="Catalog.images", ~prefix="images"),
+          store(~qualified="Catalog.imagesArchive", ~prefix="images-archive"),
+        ],
+      )->Array.length,
+    )->toBe(0)
+  )
+
+  // This is the property that lets a plugin-qualified prefix scheme relax the
+  // rule without the predicate changing: qualified prefixes simply stop
+  // colliding, so "unique per platform" narrows to "unique per plugin".
+  testSync("qualifying the prefix with the plugin removes the collision", () =>
+    expect(
+      Collision.collisionsFor(
+        ~stores=[
+          store(~qualified="Catalog.productImages", ~prefix="Catalog/productImages"),
+          store(~qualified="Ordering.productImages", ~prefix="Ordering/productImages"),
+        ],
+      )->Array.length,
+    )->toBe(0)
+  )
+
+  testSync("each colliding pair is reported once, not twice", () =>
+    expect(
+      Collision.collisionsFor(
+        ~stores=[
+          store(~qualified="A.images", ~prefix="images"),
+          store(~qualified="B.images", ~prefix="images"),
+          store(~qualified="C.images", ~prefix="images"),
+        ],
+      )->Array.length,
+    )->toBe(3)
+  )
+})
+
+describe("collisionMessage", () => {
+  testSync("names both stores and both remedies", () => {
+    let message =
+      Collision.collisionsFor(
+        ~stores=[
+          store(~qualified="Catalog.productImages", ~prefix="productImages"),
+          store(~qualified="Ordering.productImages", ~prefix="productImages"),
+        ],
+      )
+      ->Array.get(0)
+      ->Option.mapOr("", Collision.collisionMessage)
+    expect(
+      message->String.includes("Catalog.productImages") &&
+      message->String.includes("Ordering.productImages") &&
+      message->String.includes("Rename one store") &&
+      message->String.includes("@storageRef"),
+    )->toBe(true)
+  })
+
+  // Without provenance the message must not invent a declaration site; it points
+  // at the file that does record one.
+  testSync("points at the capability file when it has no declaration site", () => {
+    let message =
+      Collision.collisionsFor(
+        ~stores=[
+          store(~qualified="A.images", ~prefix="images"),
+          store(~qualified="B.images", ~prefix="images"),
+        ],
+      )
+      ->Array.get(0)
+      ->Option.mapOr("", Collision.collisionMessage)
+    expect(message->String.includes("capability file"))->toBe(true)
+  })
+
+  testSync("uses the declaration site when the caller has one", () => {
+    let message =
+      Collision.collisionsFor(
+        ~stores=[
+          store(~qualified="A.images", ~prefix="images", ~site="Product.imageUrl"),
+          store(~qualified="B.images", ~prefix="images", ~site="Shipment.imageUrl"),
+        ],
+      )
+      ->Array.get(0)
+      ->Option.mapOr("", Collision.collisionMessage)
+    expect(
+      message->String.includes("Product.imageUrl") && message->String.includes("Shipment.imageUrl"),
+    )->toBe(true)
+  })
+})

package/tests/StorePrefixCollisionTest.res.mjs

@@ -0,0 +1,174 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as StorePrefixCollision$ReventlessCore from "../src/util/StorePrefixCollision.res.mjs";
+
+function store(qualified, prefix, site) {
+  return {
+    qualified: qualified,
+    prefix: prefix,
+    site: site
+  };
+}
+
+globalThis.describe("collisionsFor", () => {
+  globalThis.test("distinct prefixes do not collide", () => {
+    globalThis.expect(StorePrefixCollision$ReventlessCore.collisionsFor([
+      {
+        qualified: "Catalog.productImages",
+        prefix: "productImages"
+      },
+      {
+        qualified: "Ordering.labels",
+        prefix: "labels"
+      }
+    ]).length).toBe(0);
+  });
+  globalThis.test("two plugins declaring one store name collide", () => {
+    let other = StorePrefixCollision$ReventlessCore.collisionsFor([
+      {
+        qualified: "Catalog.productImages",
+        prefix: "productImages"
+      },
+      {
+        qualified: "Ordering.productImages",
+        prefix: "productImages"
+      }
+    ]);
+    if (other.length !== 1) {
+      return JestGlobals.fail(`expected exactly one collision, got ` + other.length.toString());
+    }
+    let c = other[0];
+    globalThis.expect([
+      c.first.qualified,
+      c.second.qualified,
+      c.nested
+    ]).toEqual([
+      "Catalog.productImages",
+      "Ordering.productImages",
+      false
+    ]);
+  });
+  globalThis.test("one store referenced by several plugins is a single entry, not a collision", () => {
+    globalThis.expect(StorePrefixCollision$ReventlessCore.collisionsFor([{
+        qualified: "Catalog.productImages",
+        prefix: "productImages"
+      }]).length).toBe(0);
+  });
+  globalThis.test("an enclosing prefix collides with what it encloses", () => {
+    let other = StorePrefixCollision$ReventlessCore.collisionsFor([
+      {
+        qualified: "Catalog.productImages",
+        prefix: "Catalog/productImages"
+      },
+      {
+        qualified: "Legacy.catalog",
+        prefix: "Catalog"
+      }
+    ]);
+    if (other.length !== 1) {
+      return JestGlobals.fail(`expected exactly one collision, got ` + other.length.toString());
+    }
+    let c = other[0];
+    globalThis.expect([
+      c.first.qualified,
+      c.nested
+    ]).toEqual([
+      "Legacy.catalog",
+      true
+    ]);
+  });
+  globalThis.test("a sibling prefix sharing a character run does not collide", () => {
+    globalThis.expect(StorePrefixCollision$ReventlessCore.collisionsFor([
+      {
+        qualified: "Catalog.images",
+        prefix: "images"
+      },
+      {
+        qualified: "Catalog.imagesArchive",
+        prefix: "images-archive"
+      }
+    ]).length).toBe(0);
+  });
+  globalThis.test("qualifying the prefix with the plugin removes the collision", () => {
+    globalThis.expect(StorePrefixCollision$ReventlessCore.collisionsFor([
+      {
+        qualified: "Catalog.productImages",
+        prefix: "Catalog/productImages"
+      },
+      {
+        qualified: "Ordering.productImages",
+        prefix: "Ordering/productImages"
+      }
+    ]).length).toBe(0);
+  });
+  globalThis.test("each colliding pair is reported once, not twice", () => {
+    globalThis.expect(StorePrefixCollision$ReventlessCore.collisionsFor([
+      {
+        qualified: "A.images",
+        prefix: "images"
+      },
+      {
+        qualified: "B.images",
+        prefix: "images"
+      },
+      {
+        qualified: "C.images",
+        prefix: "images"
+      }
+    ]).length).toBe(3);
+  });
+});
+
+globalThis.describe("collisionMessage", () => {
+  globalThis.test("names both stores and both remedies", () => {
+    let message = Stdlib_Option.mapOr(StorePrefixCollision$ReventlessCore.collisionsFor([
+        {
+          qualified: "Catalog.productImages",
+          prefix: "productImages"
+        },
+        {
+          qualified: "Ordering.productImages",
+          prefix: "productImages"
+        }
+      ])[0], "", StorePrefixCollision$ReventlessCore.collisionMessage);
+    globalThis.expect(message.includes("Catalog.productImages") && message.includes("Ordering.productImages") && message.includes("Rename one store") && message.includes("@storageRef")).toBe(true);
+  });
+  globalThis.test("points at the capability file when it has no declaration site", () => {
+    let message = Stdlib_Option.mapOr(StorePrefixCollision$ReventlessCore.collisionsFor([
+        {
+          qualified: "A.images",
+          prefix: "images"
+        },
+        {
+          qualified: "B.images",
+          prefix: "images"
+        }
+      ])[0], "", StorePrefixCollision$ReventlessCore.collisionMessage);
+    globalThis.expect(message.includes("capability file")).toBe(true);
+  });
+  globalThis.test("uses the declaration site when the caller has one", () => {
+    let message = Stdlib_Option.mapOr(StorePrefixCollision$ReventlessCore.collisionsFor([
+        {
+          qualified: "A.images",
+          prefix: "images",
+          site: "Product.imageUrl"
+        },
+        {
+          qualified: "B.images",
+          prefix: "images",
+          site: "Shipment.imageUrl"
+        }
+      ])[0], "", StorePrefixCollision$ReventlessCore.collisionMessage);
+    globalThis.expect(message.includes("Product.imageUrl") && message.includes("Shipment.imageUrl")).toBe(true);
+  });
+});
+
+let Collision;
+
+export {
+  Collision,
+  store,
+}
+/*  Not a pure module */

package/tests/TaskBucketNamingTest.res

@@ -0,0 +1,97 @@
+open JestGlobals
+
+// A task bucket's name is emitted into S3, which lowercases it — so the rule
+// these guard is that word boundaries have to survive that lowercasing, and that
+// the name says which plugin's task owns the bucket. The runtime lookup key
+// (`Task.bucketNames`) is a separate string and is deliberately untouched.
+
+module Naming = Task_Builder
+
+describe("kebabCase", () => {
+  testSync("splits PascalCase humps", () =>
+    expect(Naming.kebabCase("ImportProducts"))->toBe("import-products")
+  )
+
+  testSync("splits camelCase humps", () =>
+    expect(Naming.kebabCase("productImages"))->toBe("product-images")
+  )
+
+  testSync("keeps an acronym together but splits the word after it", () =>
+    expect(Naming.kebabCase("HTTPServerLog"))->toBe("http-server-log")
+  )
+
+  testSync("normalises kebab and snake input to one shape", () => {
+    expect(Naming.kebabCase("product-imports"))->toBe("product-imports")
+    expect(Naming.kebabCase("product_imports"))->toBe("product-imports")
+  })
+
+  testSync("drops empty segments rather than emitting a double dash", () =>
+    expect(Naming.kebabCase("product--imports_"))->toBe("product-imports")
+  )
+
+  testSync("is idempotent", () =>
+    expect(Naming.kebabCase(Naming.kebabCase("ImportProducts")))->toBe("import-products")
+  )
+})
+
+describe("bucketResourceName", () => {
+  testSync("qualifies a task's default bucket with its plugin", () =>
+    expect(Naming.bucketResourceName(~plugin=Some("Catalog"), ~task="ImportProducts", ~bucketId=None))
+    ->toBe("catalog-import-products")
+  )
+
+  testSync("appends a declared bucket id", () =>
+    expect(
+      Naming.bucketResourceName(
+        ~plugin=Some("Catalog"),
+        ~task="ImportProducts",
+        ~bucketId=Some("product-imports"),
+      ),
+    )->toBe("catalog-import-products-product-imports")
+  )
+
+  // A task built outside any plugin has no ambient plugin to qualify with; the
+  // name stays valid rather than growing an empty leading segment.
+  testSync("omits the plugin segment when there is no ambient plugin", () =>
+    expect(Naming.bucketResourceName(~plugin=None, ~task="ImportProducts", ~bucketId=None))->toBe(
+      "import-products",
+    )
+  )
+
+  // `aws:s3/bucket` and the `reventless:role=Bucket` tag already say what it is.
+  testSync("carries no Bucket suffix", () =>
+    expect(
+      Naming.bucketResourceName(
+        ~plugin=Some("Catalog"),
+        ~task="ImportProducts",
+        ~bucketId=None,
+      )->String.endsWith("bucket"),
+    )->toBe(false)
+  )
+
+  testSync("fits S3's limit once Pulumi's uniqueness suffix is added", () =>
+    expect(
+      Naming.bucketResourceName(
+        ~plugin=Some("Catalog"),
+        ~task="ImportProducts",
+        ~bucketId=Some("product-imports"),
+      )->String.length <= Naming.maxBucketNameLength,
+    )->toBe(true)
+  )
+
+  // Truncating would silently collide two long names that share a prefix, so an
+  // over-long name is the declaration's to fix and the error has to name it.
+  testSync("throws rather than truncating an over-long name", () => {
+    let threw = try {
+      let _ = Naming.bucketResourceName(
+        ~plugin=Some("SomeRatherLongPluginName"),
+        ~task="AnEquallyLongRunningTaskName",
+        ~bucketId=Some("with-a-verbose-bucket-identifier"),
+      )
+      false
+    } catch {
+    | _ => true
+    }
+    expect(threw)->toBe(true)
+  })
+})

package/tests/TaskBucketNamingTest.res.mjs

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Task_Builder$ReventlessCore from "../src/components/Task/Task_Builder.res.mjs";
+
+globalThis.describe("kebabCase", () => {
+  globalThis.test("splits PascalCase humps", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.kebabCase("ImportProducts")).toBe("import-products");
+  });
+  globalThis.test("splits camelCase humps", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.kebabCase("productImages")).toBe("product-images");
+  });
+  globalThis.test("keeps an acronym together but splits the word after it", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.kebabCase("HTTPServerLog")).toBe("http-server-log");
+  });
+  globalThis.test("normalises kebab and snake input to one shape", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.kebabCase("product-imports")).toBe("product-imports");
+    globalThis.expect(Task_Builder$ReventlessCore.kebabCase("product_imports")).toBe("product-imports");
+  });
+  globalThis.test("drops empty segments rather than emitting a double dash", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.kebabCase("product--imports_")).toBe("product-imports");
+  });
+  globalThis.test("is idempotent", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.kebabCase(Task_Builder$ReventlessCore.kebabCase("ImportProducts"))).toBe("import-products");
+  });
+});
+
+globalThis.describe("bucketResourceName", () => {
+  globalThis.test("qualifies a task's default bucket with its plugin", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.bucketResourceName("Catalog", "ImportProducts", undefined)).toBe("catalog-import-products");
+  });
+  globalThis.test("appends a declared bucket id", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.bucketResourceName("Catalog", "ImportProducts", "product-imports")).toBe("catalog-import-products-product-imports");
+  });
+  globalThis.test("omits the plugin segment when there is no ambient plugin", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.bucketResourceName(undefined, "ImportProducts", undefined)).toBe("import-products");
+  });
+  globalThis.test("carries no Bucket suffix", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.bucketResourceName("Catalog", "ImportProducts", undefined).endsWith("bucket")).toBe(false);
+  });
+  globalThis.test("fits S3's limit once Pulumi's uniqueness suffix is added", () => {
+    globalThis.expect(Task_Builder$ReventlessCore.bucketResourceName("Catalog", "ImportProducts", "product-imports").length <= Task_Builder$ReventlessCore.maxBucketNameLength).toBe(true);
+  });
+  globalThis.test("throws rather than truncating an over-long name", () => {
+    let threw;
+    try {
+      Task_Builder$ReventlessCore.bucketResourceName("SomeRatherLongPluginName", "AnEquallyLongRunningTaskName", "with-a-verbose-bucket-identifier");
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
+    globalThis.expect(threw).toBe(true);
+  });
+});
+
+let Naming;
+
+export {
+  Naming,
+}
+/*  Not a pure module */