@adobe/spacecat-shared-utils 1.114.0 → 1.115.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [@adobe/spacecat-shared-utils-v1.115.1](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-utils-v1.115.0...@adobe/spacecat-shared-utils-v1.115.1) (2026-05-06)
+
+### Bug Fixes
+
+* **utils:** include subpath in resolveCustomerSecretsName to prevent credential collisions ([#1577](https://github.com/adobe/spacecat-shared/issues/1577)) ([db95707](https://github.com/adobe/spacecat-shared/commit/db95707796c53d0fbe22c4fc40fed9ab271dd59c))
+
+## [@adobe/spacecat-shared-utils-v1.115.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-utils-v1.114.0...@adobe/spacecat-shared-utils-v1.115.0) (2026-05-04)
+
+### Features
+
+* **strategy:** add type discriminator and experimentId for Atomic strategies | LLMO-4643 ([#1571](https://github.com/adobe/spacecat-shared/issues/1571)) ([0151ff5](https://github.com/adobe/spacecat-shared/commit/0151ff510f7643021e6c1ccf21298f6d3c07034b))
+
 ## [@adobe/spacecat-shared-utils-v1.114.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-utils-v1.113.0...@adobe/spacecat-shared-utils-v1.114.0) (2026-05-04)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-utils",
-  "version": "1.114.0",
+  "version": "1.115.1",
   "description": "Shared modules of the Spacecat Services - utils",
   "type": "module",
   "exports": {

package/src/helpers.js

@@ -39,18 +39,60 @@ export function resolveSecretsName(opts, ctx, defaultPath) {
 
 /**
  * Resolves the name of the customer secrets based on the baseURL.
- * @param {string} baseURL - The base URL to resolve the customer secrets name from.
+ *
+ * The hostname (per RFC 1035, case-insensitive) and each URL path segment are
+ * percent-decoded and individually sanitized: runs of non-alphanumeric characters
+ * are replaced with a single `_`, leading/trailing `_` are trimmed, and the
+ * result is lowercased. Segments that reduce to empty after sanitization are
+ * dropped. Sanitized parts are joined with `__` as the path-segment delimiter.
+ *
+ * The `__` delimiter cannot appear inside a sanitized segment (any run of
+ * non-alphanumeric characters, including `__`, collapses to a single `_`),
+ * so URLs that differ in path structure (different number of segments, or
+ * segments with different alphanumeric content) produce distinct keys. Note
+ * that path segments differing only in punctuation (e.g. `us-kings` vs
+ * `us_kings`) produce the same sanitized segment and therefore the same key;
+ * this is an inherent limitation of lossy sanitization.
+ *
+ * Key format: /helix-deploy/spacecat-services/customer-secrets/<host>[__<seg>...]/<version>
+ *
+ * Examples:
+ *   https://nba.com           -> .../nba_com/<version>
+ *   https://nba.com/kings     -> .../nba_com__kings/<version>
+ *   https://nba.com/us/kings  -> .../nba_com__us__kings/<version>
+ *
+ * @param {string} baseURL - The base URL (must be http(s) with a hostname).
  * @param {Object} ctx - The context object containing the function version.
  * @returns {string} - The resolved secret name.
+ * @since next - key now includes URL path segments; prior versions used hostname
+ *   only, causing subpath sites on the same domain to share a secret. LLMO-4186.
  */
 export function resolveCustomerSecretsName(baseURL, ctx) {
   const basePath = '/helix-deploy/spacecat-services/customer-secrets';
-  let customer;
+  let url;
   try {
-    customer = new URL(baseURL).host.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+    url = new URL(baseURL);
   } catch {
     throw new Error('Invalid baseURL: must be a valid URL');
   }
+  if (!url.hostname || !['http:', 'https:'].includes(url.protocol)) {
+    throw new Error('Invalid baseURL: must be an http(s) URL with a hostname');
+  }
+  const sanitize = (s) => s.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '').toLowerCase();
+  const host = sanitize(url.hostname);
+  if (!host) {
+    throw new Error('Invalid baseURL: hostname reduces to empty after sanitization');
+  }
+  const segments = url.pathname.split('/').filter(Boolean)
+    .map((seg) => {
+      let decoded = seg;
+      try {
+        decoded = decodeURIComponent(seg);
+      } catch { /* keep raw on percent-encoded sequences that are not valid UTF-8 */ }
+      return sanitize(decoded);
+    })
+    .filter(Boolean);
+  const customer = segments.length > 0 ? `${host}__${segments.join('__')}` : host;
   return resolveSecretsName({}, ctx, `${basePath}/${customer}`);
 }
 

package/src/strategy-schema.js

@@ -38,6 +38,10 @@ const strategyGoalType = z.union([
   z.string(), // Catchall for future goal types
 ]);
 
+// Discriminator between Atomic (experiment-driven) and Evolving (iterative) strategies.
+// Existing pre-GA strategies have no `type` field and default to 'evolving' for backward compat.
+const strategyType = z.enum(['atomic', 'evolving']);
+
 /**
  * Library opportunity - user-created reusable opportunity template
  */
@@ -76,6 +80,7 @@ const strategyPromptSelection = z.object({
  */
 const strategy = z.object({
   id: nonEmptyString,
+  type: strategyType.default('evolving'),
   name: nonEmptyString,
   status: workflowStatus,
   url: z.union([z.string(), z.array(z.string())]),
@@ -90,6 +95,7 @@ const strategy = z.object({
   createdBy: z.string().optional(), // Email of strategy creator/owner
   completedAt: z.string().optional(), // ISO 8601 date string
   goalType: strategyGoalType.optional(),
+  experimentId: z.uuid().nullable().optional(),
 });
 
 /**
@@ -138,4 +144,37 @@ export const strategyWorkspaceData = z.object({
       }
     });
   });
+
+  // Validate type-based invariants (Atomic vs Evolving)
+  strategies.forEach((strat, strategyIndex) => {
+    // Atomic must have a non-null experimentId
+    if (strat.type === 'atomic' && (strat.experimentId === undefined || strat.experimentId === null)) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['strategies', strategyIndex, 'experimentId'],
+        message: 'Atomic strategies require a non-null experimentId',
+      });
+    }
+
+    // Atomic must not carry selectedPrompts (those come from GeoExperiment)
+    if (strat.type === 'atomic' && Array.isArray(strat.selectedPrompts) && strat.selectedPrompts.length > 0) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['strategies', strategyIndex, 'selectedPrompts'],
+        message: 'Atomic strategies must not carry selectedPrompts (use GeoExperiment.promptsLocation)',
+      });
+    }
+
+    // Evolving: schema is intentionally permissive on `selectedPrompts`. Today's
+    // CreateStrategyDialog initializes selectedPrompts as `[]` for newly-created
+    // Evolving strategies (no prompt-selection UI yet). Enforcing "must be
+    // non-empty" at the schema would reject those in-flight reads + writes.
+    //
+    // The "newly-created Evolving strategies must include selectedPrompts" rule
+    // is deferred to the milestone where Evolving promotes out of co-innovation
+    // mode — at that point the schema tightens, the API layer (saveStrategy)
+    // adds the creation-time check, and the prompt-selection screen ships.
+    // All three land together. Until then, selectedPrompts on Evolving is
+    // structurally validated only.
+  });
 });