@reventlessdev/reventless-seed-aws 1.0.0-alpha.4 → 1.0.0-alpha.6

package/src/ReventlessSeedAws.res.mjs

@@ -19,6 +19,20 @@ function asString(json) {
   }
 }
 
+function asStringDict(json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return Object.fromEntries(Stdlib_Array.filterMap(Object.entries(json), param => {
+      let k = param[0];
+      return Stdlib_Option.map(asString(param[1]), s => [
+        k,
+        s
+      ]);
+    }));
+  } else {
+    return {};
+  }
+}
+
 function envForBackend(backend) {
   if (backend === undefined) {
     return;
@@ -152,34 +166,39 @@ function resolveField(envKey, fromSource, human) {
   };
 }
 
-async function resolveEndpoints(projectDir, backend, stack) {
-  let outputs = stackOutputs(projectDir, backend, stack);
-  let hostShellUrl = Stdlib_Option.flatMap(field(outputs, "hostShellUrl"), asString);
-  if (hostShellUrl !== undefined) {
-    let cfg = await fetchConfig(hostShellUrl);
+function optionalField(envKey, fromSource) {
+  let v = Seed_Prompt$ReventlessSeed.envValue(envKey);
+  if (v !== undefined) {
+    return v;
+  } else {
+    return Stdlib_Option.getOr(fromSource, "");
+  }
+}
+
+function endpointsFrom(stack, source) {
+  if (source.TAG === "HostShellConfig") {
+    let cfg = source._0;
     let fromCfg = key => Stdlib_Option.flatMap(field(cfg, key), asString);
-    let endpoint = resolveField("REVENTLESS_GRAPHQL_ENDPOINT", fromCfg("apiEndpoint"), "apiEndpoint");
-    let uploadEndpoint = resolveField("REVENTLESS_UPLOAD_ENDPOINT", fromCfg("uploadEndpoint"), "uploadEndpoint");
-    let region = resolveField("AWS_REGION", fromCfg("region"), "region");
-    let clientId = resolveField("COGNITO_CLIENT_ID", fromCfg("cognitoClientId"), "cognitoClientId");
-    return [
-      endpoint,
-      uploadEndpoint,
-      region,
-      clientId
-    ];
+    return {
+      graphql: resolveField("REVENTLESS_GRAPHQL_ENDPOINT", fromCfg("apiEndpoint"), "apiEndpoint"),
+      uploadEndpoint: optionalField("REVENTLESS_UPLOAD_ENDPOINT", fromCfg("uploadEndpoint")),
+      uploadEndpoints: Stdlib_Option.mapOr(field(cfg, "uploadEndpoints"), {}, asStringDict),
+      cognitoRegion: resolveField("AWS_REGION", fromCfg("region"), "region"),
+      cognitoClientId: resolveField("COGNITO_CLIENT_ID", fromCfg("cognitoClientId"), "cognitoClientId")
+    };
   }
+  let outputs = source._0;
   let out = key => Stdlib_Option.flatMap(field(outputs, key), asString);
   let match = Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_GRAPHQL_ENDPOINT");
   let match$1 = out("domainMergedApiEndpoint");
   let match$2 = out("domainApiEndpoint");
-  let endpoint$1;
+  let tmp;
   if (match !== undefined) {
-    endpoint$1 = match;
+    tmp = match;
   } else if (match$1 !== undefined) {
-    endpoint$1 = match$1;
+    tmp = match$1;
   } else if (match$2 !== undefined) {
-    endpoint$1 = match$2;
+    tmp = match$2;
   } else {
     throw {
       RE_EXN_ID: Seed$ReventlessSeed.Failed,
@@ -187,15 +206,26 @@ async function resolveEndpoints(projectDir, backend, stack) {
       Error: new Error()
     };
   }
-  let region$1 = resolveField("AWS_REGION", out("cognitoRegion"), "cognitoRegion");
-  let clientId$1 = resolveField("COGNITO_CLIENT_ID", out("cognitoUserPoolClientId"), "cognitoUserPoolClientId");
-  let uploadEndpoint$1 = Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_UPLOAD_ENDPOINT"), "");
-  return [
-    endpoint$1,
-    uploadEndpoint$1,
-    region$1,
-    clientId$1
-  ];
+  return {
+    graphql: tmp,
+    uploadEndpoint: optionalField("REVENTLESS_UPLOAD_ENDPOINT", undefined),
+    uploadEndpoints: Stdlib_Option.mapOr(field(outputs, "uploadEndpoints"), {}, asStringDict),
+    cognitoRegion: resolveField("AWS_REGION", out("cognitoRegion"), "cognitoRegion"),
+    cognitoClientId: resolveField("COGNITO_CLIENT_ID", out("cognitoUserPoolClientId"), "cognitoUserPoolClientId")
+  };
+}
+
+async function resolveEndpoints(projectDir, backend, stack) {
+  let outputs = stackOutputs(projectDir, backend, stack);
+  let hostShellUrl = Stdlib_Option.flatMap(field(outputs, "hostShellUrl"), asString);
+  let source = hostShellUrl !== undefined ? ({
+      TAG: "HostShellConfig",
+      _0: await fetchConfig(hostShellUrl)
+    }) : ({
+      TAG: "StackOutputs",
+      _0: outputs
+    });
+  return endpointsFrom(stack, source);
 }
 
 function cognito(region, clientId) {
@@ -282,14 +312,15 @@ function connect($staropt$star, stack, backend, param) {
     let url = Seed_Prompt$ReventlessSeed.envValue("SEED_PULUMI_BACKEND");
     let backend$1 = url !== undefined ? url : backend;
     let stackName = await resolveStack(projectDir, backend$1, stack);
-    let match = await resolveEndpoints(projectDir, backend$1, stackName);
-    return await Seed_Connect$ReventlessSeed.make(stackName, match[0], match[1], cognito(match[2], match[3]), undefined);
+    let eps = await resolveEndpoints(projectDir, backend$1, stackName);
+    return await Seed_Connect$ReventlessSeed.make(stackName, eps.graphql, eps.uploadEndpoint, eps.uploadEndpoints, cognito(eps.cognitoRegion, eps.cognitoClientId), undefined);
   };
 }
 
 export {
   field,
   asString,
+  asStringDict,
   envForBackend,
   pulumi,
   deployedStacks,
@@ -298,6 +329,8 @@ export {
   resolveStack,
   fetchConfig,
   resolveField,
+  optionalField,
+  endpointsFrom,
   resolveEndpoints,
   cognito,
   connect,

package/src/ReventlessSeedAws_Reset.res

@@ -48,14 +48,7 @@ module Ddb = AwsSdk.DynamoDb
 module Rgt = AwsSdk.ResourceGroupsTaggingApi
 module S3 = AwsSdk.S3
 
-@scope("process") @val external exit: int => unit = "exit"
-@scope("process") @val external processEnv: dict<string> = "env"
-@module("node:fs") external readFileSync: (string, string) => string = "readFileSync"
 
-type stream
-@scope("process") @val external stdin: stream = "stdin"
-// `process.stdin.isTTY` is `true` interactively and `undefined` under a pipe/CI.
-@get external isTTY: stream => option<bool> = "isTTY"
 
 // The Pulumi project name, which the framework stamps as `reventless:platform` on
 // every resource (`Plugin.res`: `platformName = getProjectName()`). Discovery
@@ -66,7 +59,7 @@ type stream
 // the target project's Pulumi.yaml — the same dir the pulumi subprocess uses.
 let projectName = (~projectDir: string): string => {
   let path = `${projectDir}/Pulumi.yaml`
-  let raw = try readFileSync(path, "utf8") catch {
+  let raw = try NodeFs.readFileSync(path) catch {
   | _ => throw(Seed.Failed(`could not read ${path} to scope the wipe to this Pulumi project.`))
   }
   switch raw
@@ -561,7 +554,7 @@ let run = (~stack=?, ~backend=?, ~targets: array<target>, ()): unit => {
           ),
         )
       }
-      processEnv->Dict.set("AWS_REGION", region)
+      NodeProcess.env->Dict.set("AWS_REGION", region)
 
       // Discover + count each target, scoped to its own project via the platform
       // tag so a same-named stack from another project is never touched.
@@ -597,7 +590,7 @@ let run = (~stack=?, ~backend=?, ~targets: array<target>, ()): unit => {
         Seed.Prompt.close()
         Console.log("")
         Console.log(`Nothing to reset — the selected scope already reads empty in ${region}.`)
-        exit(0)
+        NodeProcess.exit(0)
       }
 
       // Confirmation. Interactively, re-typing the exact stack name IS the
@@ -606,7 +599,7 @@ let run = (~stack=?, ~backend=?, ~targets: array<target>, ()): unit => {
       // TTY (CI/scripts) there is nothing to type into, so
       // REVENTLESS_WIPE_CONFIRM=<stack> is the equivalent opt-in. Dry-run is the
       // default either way.
-      let interactive = stdin->isTTY->Option.getOr(false)
+      let interactive = NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)
       let confirmed = if interactive {
         let typed = await Seed.Prompt.ask(
           `About to permanently empty ${total->Int.toString} item(s)/object(s) across the selected scope of "${stack}". ` ++
@@ -624,7 +617,7 @@ let run = (~stack=?, ~backend=?, ~targets: array<target>, ()): unit => {
             ? "Dry run — nothing was deleted."
             : `Dry run — nothing was deleted. Set REVENTLESS_WIPE_CONFIRM=${stack} to empty this scope non-interactively.`,
         )
-        exit(0)
+        NodeProcess.exit(0)
       }
 
       for i in 0 to resolvedList->Array.length - 1 {
@@ -681,19 +674,19 @@ let run = (~stack=?, ~backend=?, ~targets: array<target>, ()): unit => {
 
       Console.log("")
       Console.log(`Reset complete — the selected scope of "${stack}" reads empty and is re-seedable.`)
-      exit(0)
+      NodeProcess.exit(0)
     } catch {
     | Seed.Failed(message) =>
       Seed.Prompt.close()
       Console.error("")
       Console.error(`Reset aborted — ${message}`)
-      exit(1)
+      NodeProcess.exit(1)
     | exn =>
       Seed.Prompt.close()
       Console.error("")
       Console.error("Reset aborted with an unexpected error:")
       Console.error(exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"))
-      exit(1)
+      NodeProcess.exit(1)
     }
   }
   go()->ignore

package/tests/EndpointResolutionTest.res

@@ -0,0 +1,180 @@
+// Which document `resolveEndpoints` reads, and what each arm takes from it.
+//
+// `endpointsFrom` is the pure half of `resolveEndpoints`; the impure half is a
+// `pulumi stack output` subprocess and a `config.json` fetch, and the decision
+// these tests pin is in neither. The defect they lock out: **neither arm read
+// `uploadEndpoints`**, so a platform that publishes a presign endpoint per
+// declared store resolved "" and the seeder reported it as serving no uploads.
+// The stack-outputs arm is the one that matters — a platform deploying no host
+// shell publishes no `hostShellUrl` by construction, so it takes that arm, and
+// the per-store endpoint is its only way to reach the store.
+
+open JestGlobals
+open ReventlessSeed
+
+
+// Every value read here has an env override, and an ambient one in the runner's
+// environment (AWS_REGION is routinely set) would silently stand in for the
+// document under test. An empty string reads as unset.
+let clearOverrides = () =>
+  [
+    "REVENTLESS_GRAPHQL_ENDPOINT",
+    "REVENTLESS_UPLOAD_ENDPOINT",
+    "AWS_REGION",
+    "COGNITO_CLIENT_ID",
+    "SEED_SKIP_UPLOADS",
+  ]->Array.forEach(k => NodeProcess.env->Dict.set(k, ""))
+
+let obj = entries => JSON.Encode.object(entries->Dict.fromArray)
+let str = JSON.Encode.string
+
+// A host shell's config.json and the stack outputs of a platform that serves no
+// shell — the two documents the two arms read, minus the upload keys each test
+// supplies.
+let config = (~extra: array<(string, JSON.t)>) =>
+  obj(
+    Array.concat(
+      [
+        ("apiEndpoint", str("https://api.example/graphql")),
+        ("region", str("eu-west-1")),
+        ("cognitoClientId", str("client-abc")),
+      ],
+      extra,
+    ),
+  )
+
+let outputs = (~extra: array<(string, JSON.t)>) =>
+  obj(
+    Array.concat(
+      [
+        ("domainApiEndpoint", str("https://domain.example/graphql")),
+        ("cognitoRegion", str("eu-west-1")),
+        ("cognitoUserPoolClientId", str("client-abc")),
+      ],
+      extra,
+    ),
+  )
+
+let storeEndpoints = obj([("Catalog.productImages", str("https://presign.example/"))])
+
+describe("endpointsFrom — host shell arm", () => {
+  beforeEach(clearOverrides)
+
+  testSync("reads the legacy single service and the per-store map together", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="alpha",
+      HostShellConfig(
+        config(
+          ~extra=[
+            ("uploadEndpoint", str("https://legacy.example/")),
+            ("uploadEndpoints", storeEndpoints),
+          ],
+        ),
+      ),
+    )
+    expect(eps.uploadEndpoint)->toBe("https://legacy.example/")
+    expect(eps.uploadEndpoints)->toEqual(
+      Dict.fromArray([("Catalog.productImages", "https://presign.example/")]),
+    )
+  })
+
+  // A shell fronting only declared stores writes no singular key. That used to
+  // fail the whole run before a command was sent ("deployment is missing
+  // uploadEndpoint"), which is a harder failure than the one this plan fixes.
+  testSync("a shell publishing only per-store endpoints resolves an empty legacy service", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="alpha",
+      HostShellConfig(config(~extra=[("uploadEndpoints", storeEndpoints)])),
+    )
+    expect(eps.uploadEndpoint)->toBe("")
+    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual(["Catalog.productImages"])
+  })
+
+  testSync("REVENTLESS_UPLOAD_ENDPOINT overrides the legacy service and leaves the map alone", () => {
+    NodeProcess.env->Dict.set("REVENTLESS_UPLOAD_ENDPOINT", "https://override.example/")
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="alpha",
+      HostShellConfig(
+        config(
+          ~extra=[
+            ("uploadEndpoint", str("https://legacy.example/")),
+            ("uploadEndpoints", storeEndpoints),
+          ],
+        ),
+      ),
+    )
+    expect(eps.uploadEndpoint)->toBe("https://override.example/")
+    expect(eps.uploadEndpoints->Dict.get("Catalog.productImages"))->toEqual(
+      Some("https://presign.example/"),
+    )
+  })
+})
+
+describe("endpointsFrom — stack outputs arm", () => {
+  beforeEach(clearOverrides)
+
+  // The lookup that was missing entirely: this arm had no upload source but the
+  // env var, so a `PlatformOwned` deployment resolved "" whatever it published.
+  testSync("reads the uploadEndpoints stack output", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(outputs(~extra=[("uploadEndpoints", storeEndpoints)])),
+    )
+    expect(eps.uploadEndpoints)->toEqual(
+      Dict.fromArray([("Catalog.productImages", "https://presign.example/")]),
+    )
+  })
+
+  // Declaring no store is a legitimate deployment, not a broken one — it stays a
+  // no-op at the data set rather than failing the run.
+  testSync("a deployment declaring no store resolves an empty map without failing", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(~stack="pr-verify", StackOutputs(outputs(~extra=[])))
+    expect(eps.uploadEndpoint)->toBe("")
+    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual([])
+  })
+
+  testSync("prefers the merged API endpoint over the per-plugin one", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(outputs(~extra=[("domainMergedApiEndpoint", str("https://merged.example/"))])),
+    )
+    expect(eps.graphql)->toBe("https://merged.example/")
+  })
+
+  testSync("fails naming both keys when the stack exports neither API endpoint", () =>
+    switch ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(obj([("cognitoRegion", str("eu-west-1"))])),
+    ) {
+    | _ => fail("expected endpointsFrom to fail")
+    | exception Seed.Failed(msg) =>
+      expect(msg)->toContain("domainMergedApiEndpoint")
+      expect(msg)->toContain("domainApiEndpoint")
+    }
+  )
+})
+
+describe("endpointsFrom — malformed uploadEndpoints", () => {
+  beforeEach(clearOverrides)
+
+  // One bad member should not cost the run every endpoint it could have used.
+  testSync("drops a non-string member rather than the whole map", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(
+        outputs(
+          ~extra=[
+            (
+              "uploadEndpoints",
+              obj([
+                ("Catalog.productImages", str("https://presign.example/")),
+                ("Catalog.broken", JSON.Encode.int(7)),
+              ]),
+            ),
+          ],
+        ),
+      ),
+    )
+    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual(["Catalog.productImages"])
+  })
+})

package/tests/EndpointResolutionTest.res.mjs

@@ -0,0 +1,208 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as ReventlessSeedAws from "../src/ReventlessSeedAws.res.mjs";
+import * as Seed$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function clearOverrides() {
+  [
+    "REVENTLESS_GRAPHQL_ENDPOINT",
+    "REVENTLESS_UPLOAD_ENDPOINT",
+    "AWS_REGION",
+    "COGNITO_CLIENT_ID",
+    "SEED_SKIP_UPLOADS"
+  ].forEach(k => {
+    process.env[k] = "";
+  });
+}
+
+function obj(entries) {
+  return Object.fromEntries(entries);
+}
+
+function str(prim) {
+  return prim;
+}
+
+function config(extra) {
+  return Object.fromEntries([
+    [
+      "apiEndpoint",
+      "https://api.example/graphql"
+    ],
+    [
+      "region",
+      "eu-west-1"
+    ],
+    [
+      "cognitoClientId",
+      "client-abc"
+    ]
+  ].concat(extra));
+}
+
+function outputs(extra) {
+  return Object.fromEntries([
+    [
+      "domainApiEndpoint",
+      "https://domain.example/graphql"
+    ],
+    [
+      "cognitoRegion",
+      "eu-west-1"
+    ],
+    [
+      "cognitoUserPoolClientId",
+      "client-abc"
+    ]
+  ].concat(extra));
+}
+
+let storeEndpoints = Object.fromEntries([[
+    "Catalog.productImages",
+    "https://presign.example/"
+  ]]);
+
+globalThis.describe("endpointsFrom — host shell arm", () => {
+  globalThis.beforeEach(clearOverrides);
+  globalThis.test("reads the legacy single service and the per-store map together", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("alpha", {
+      TAG: "HostShellConfig",
+      _0: config([
+        [
+          "uploadEndpoint",
+          "https://legacy.example/"
+        ],
+        [
+          "uploadEndpoints",
+          storeEndpoints
+        ]
+      ])
+    });
+    globalThis.expect(eps.uploadEndpoint).toBe("https://legacy.example/");
+    globalThis.expect(eps.uploadEndpoints).toEqual(Object.fromEntries([[
+        "Catalog.productImages",
+        "https://presign.example/"
+      ]]));
+  });
+  globalThis.test("a shell publishing only per-store endpoints resolves an empty legacy service", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("alpha", {
+      TAG: "HostShellConfig",
+      _0: config([[
+          "uploadEndpoints",
+          storeEndpoints
+        ]])
+    });
+    globalThis.expect(eps.uploadEndpoint).toBe("");
+    globalThis.expect(Object.keys(eps.uploadEndpoints)).toEqual(["Catalog.productImages"]);
+  });
+  globalThis.test("REVENTLESS_UPLOAD_ENDPOINT overrides the legacy service and leaves the map alone", () => {
+    process.env["REVENTLESS_UPLOAD_ENDPOINT"] = "https://override.example/";
+    let eps = ReventlessSeedAws.endpointsFrom("alpha", {
+      TAG: "HostShellConfig",
+      _0: config([
+        [
+          "uploadEndpoint",
+          "https://legacy.example/"
+        ],
+        [
+          "uploadEndpoints",
+          storeEndpoints
+        ]
+      ])
+    });
+    globalThis.expect(eps.uploadEndpoint).toBe("https://override.example/");
+    globalThis.expect(eps.uploadEndpoints["Catalog.productImages"]).toEqual("https://presign.example/");
+  });
+});
+
+globalThis.describe("endpointsFrom — stack outputs arm", () => {
+  globalThis.beforeEach(clearOverrides);
+  globalThis.test("reads the uploadEndpoints stack output", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
+      TAG: "StackOutputs",
+      _0: outputs([[
+          "uploadEndpoints",
+          storeEndpoints
+        ]])
+    });
+    globalThis.expect(eps.uploadEndpoints).toEqual(Object.fromEntries([[
+        "Catalog.productImages",
+        "https://presign.example/"
+      ]]));
+  });
+  globalThis.test("a deployment declaring no store resolves an empty map without failing", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
+      TAG: "StackOutputs",
+      _0: outputs([])
+    });
+    globalThis.expect(eps.uploadEndpoint).toBe("");
+    globalThis.expect(Object.keys(eps.uploadEndpoints)).toEqual([]);
+  });
+  globalThis.test("prefers the merged API endpoint over the per-plugin one", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
+      TAG: "StackOutputs",
+      _0: outputs([[
+          "domainMergedApiEndpoint",
+          "https://merged.example/"
+        ]])
+    });
+    globalThis.expect(eps.graphql).toBe("https://merged.example/");
+  });
+  globalThis.test("fails naming both keys when the stack exports neither API endpoint", () => {
+    let val;
+    try {
+      val = ReventlessSeedAws.endpointsFrom("pr-verify", {
+        TAG: "StackOutputs",
+        _0: Object.fromEntries([[
+            "cognitoRegion",
+            "eu-west-1"
+          ]])
+      });
+    } catch (raw_msg) {
+      let msg = Primitive_exceptions.internalToException(raw_msg);
+      if (msg.RE_EXN_ID === Seed$ReventlessSeed.Failed) {
+        let msg$1 = msg._1;
+        globalThis.expect(msg$1).toContain("domainMergedApiEndpoint");
+        globalThis.expect(msg$1).toContain("domainApiEndpoint");
+        return;
+      }
+      throw msg;
+    }
+    JestGlobals.fail("expected endpointsFrom to fail");
+  });
+});
+
+globalThis.describe("endpointsFrom — malformed uploadEndpoints", () => {
+  globalThis.beforeEach(clearOverrides);
+  globalThis.test("drops a non-string member rather than the whole map", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
+      TAG: "StackOutputs",
+      _0: outputs([[
+          "uploadEndpoints",
+          Object.fromEntries([
+            [
+              "Catalog.productImages",
+              "https://presign.example/"
+            ],
+            [
+              "Catalog.broken",
+              7
+            ]
+          ])
+        ]])
+    });
+    globalThis.expect(Object.keys(eps.uploadEndpoints)).toEqual(["Catalog.productImages"]);
+  });
+});
+
+export {
+  clearOverrides,
+  obj,
+  str,
+  config,
+  outputs,
+  storeEndpoints,
+}
+/* storeEndpoints Not a pure module */