@reventlessdev/reventless-aws 3.0.0-alpha.344 → 3.0.0-alpha.346

package/tests/ProvisionIdentityTest.res.mjs

@@ -2,7 +2,9 @@
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Auth_SignUpMode$ReventlessAws from "../src/adapter/Auth/Auth_SignUpMode.res.mjs";
 import * as ProvisionIdentity$ReventlessAws from "../scripts/ProvisionIdentity.res.mjs";
+import * as Auth_LoginIdentifier$ReventlessAws from "../src/adapter/Auth/Auth_LoginIdentifier.res.mjs";
 
 globalThis.describe("ProvisionIdentity.parseArgs", () => {
   globalThis.test("no arguments means adopt-or-create the default name", () => {
@@ -11,6 +13,8 @@ globalThis.describe("ProvisionIdentity.parseArgs", () => {
       _0: {
         poolName: ProvisionIdentity$ReventlessAws.defaultPoolName,
         providerId: undefined,
+        loginIdentifier: "Email",
+        signUpMode: "AdminOnly",
         help: false
       }
     });
@@ -24,6 +28,8 @@ globalThis.describe("ProvisionIdentity.parseArgs", () => {
       _0: {
         poolName: ProvisionIdentity$ReventlessAws.defaultPoolName,
         providerId: "eu-west-1_AbCdEfGhI",
+        loginIdentifier: "Email",
+        signUpMode: "AdminOnly",
         help: false
       }
     });
@@ -37,6 +43,8 @@ globalThis.describe("ProvisionIdentity.parseArgs", () => {
       _0: {
         poolName: "examples-dev",
         providerId: undefined,
+        loginIdentifier: "Email",
+        signUpMode: "AdminOnly",
         help: false
       }
     });
@@ -52,10 +60,48 @@ globalThis.describe("ProvisionIdentity.parseArgs", () => {
       _0: {
         poolName: "ignored",
         providerId: "eu-west-1_x",
+        loginIdentifier: "Email",
+        signUpMode: "AdminOnly",
         help: false
       }
     });
   });
+  globalThis.test("--login-identifier picks the sign-in attribute", () => {
+    globalThis.expect(Stdlib_Result.map(ProvisionIdentity$ReventlessAws.parseArgs([
+      "--login-identifier",
+      "emailOrPhone"
+    ]), a => a.loginIdentifier)).toEqual({
+      TAG: "Ok",
+      _0: "EmailOrPhone"
+    });
+  });
+  globalThis.test("an unrecognised sign-in attribute is refused, never defaulted", () => {
+    globalThis.expect(Stdlib_Result.isError(ProvisionIdentity$ReventlessAws.parseArgs([
+      "--login-identifier",
+      "e-mail"
+    ]))).toBe(true);
+  });
+  globalThis.test("--sign-up-mode opens the pool to self-registration", () => {
+    globalThis.expect(Stdlib_Result.map(ProvisionIdentity$ReventlessAws.parseArgs([
+      "--sign-up-mode",
+      "selfService"
+    ]), a => a.signUpMode)).toEqual({
+      TAG: "Ok",
+      _0: "SelfService"
+    });
+  });
+  globalThis.test("an unrecognised sign-up mode is refused, never defaulted", () => {
+    globalThis.expect(Stdlib_Result.isError(ProvisionIdentity$ReventlessAws.parseArgs([
+      "--sign-up-mode",
+      "self-service"
+    ]))).toBe(true);
+  });
+  globalThis.test("sign-up mode defaults to admin-only, so an existing pool is unchanged", () => {
+    globalThis.expect(Stdlib_Result.map(ProvisionIdentity$ReventlessAws.parseArgs([]), a => a.signUpMode)).toEqual({
+      TAG: "Ok",
+      _0: "AdminOnly"
+    });
+  });
   globalThis.test("a misspelled flag is refused, not ignored", () => {
     globalThis.expect(ProvisionIdentity$ReventlessAws.parseArgs([
       "--provider_id",
@@ -77,6 +123,12 @@ globalThis.describe("ProvisionIdentity.parseArgs", () => {
       _0: "--name needs a value"
     });
   });
+  globalThis.test("--login-identifier with no value is refused too", () => {
+    globalThis.expect(ProvisionIdentity$ReventlessAws.parseArgs(["--login-identifier"])).toEqual({
+      TAG: "Error",
+      _0: "--login-identifier needs a value"
+    });
+  });
   globalThis.test("--help and -h both ask for the usage text", () => {
     globalThis.expect([
       Stdlib_Result.map(ProvisionIdentity$ReventlessAws.parseArgs(["--help"]), a => a.help),
@@ -104,7 +156,7 @@ globalThis.describe("ProvisionIdentity.parseArgs", () => {
 });
 
 globalThis.describe("ProvisionIdentity.poolSettings", () => {
-  let settings = ProvisionIdentity$ReventlessAws.poolSettings("MyIdentity");
+  let settings = ProvisionIdentity$ReventlessAws.poolSettings("MyIdentity", Auth_LoginIdentifier$ReventlessAws.default, Auth_SignUpMode$ReventlessAws.default);
   globalThis.test("carries the name it was asked for", () => {
     globalThis.expect(settings.PoolName).toBe("MyIdentity");
   });
@@ -119,6 +171,19 @@ globalThis.describe("ProvisionIdentity.poolSettings", () => {
       true
     ]);
   });
+  globalThis.test("a phone pool is created signing in on phone_number", () => {
+    globalThis.expect(ProvisionIdentity$ReventlessAws.poolSettings("MyIdentity", "Phone", Auth_SignUpMode$ReventlessAws.default).UsernameAttributes).toEqual(["phone_number"]);
+  });
+  globalThis.test("selfService clears allowAdminCreateUserOnly, adminOnly sets it", () => {
+    let openPool = ProvisionIdentity$ReventlessAws.poolSettings("MyIdentity", Auth_LoginIdentifier$ReventlessAws.default, "SelfService");
+    globalThis.expect([
+      Stdlib_Option.flatMap(openPool.AdminCreateUserConfig, c => c.AllowAdminCreateUserOnly),
+      Stdlib_Option.flatMap(settings.AdminCreateUserConfig, c => c.AllowAdminCreateUserOnly)
+    ]).toEqual([
+      false,
+      true
+    ]);
+  });
   globalThis.test("keeps the 12-character password policy", () => {
     globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(settings.Policies, p => p.PasswordPolicy), p => p.MinimumLength)).toEqual(12);
   });

package/tests/QueryDbOwnerIndexTableTest.res

@@ -26,10 +26,12 @@ describe("the derived owner index", () => {
   testSync("is provisioned projecting every attribute", () => {
     let gsis = QueryDbStorage_DynamoDb.globalSecondaryIndexes([ownerIndex])->unwrap
     expect(
-      gsis->Array.map(g => {
-        let g = g->unwrap
-        (g.name, g.hashKey, g.rangeKey, g.projectionType)
-      }),
+      gsis->Array.map(
+        g => {
+          let g = g->unwrap
+          (g.name, g.hashKey, g.rangeKey, g.projectionType)
+        },
+      ),
     )->toEqual([("_owner", "customerId", Some("id"), PulumiAws.DynamoDb.Table.ALL)])
   })
 

package/tests/QueryDbResolvers_AppSyncTest.res

@@ -20,21 +20,27 @@ describe("QueryDbResolvers_AppSync.internalRowRequiredAttr", () => {
 })
 
 describe("AppSync_Resolver_Retrying.Functions.listAllItemsConnection", () => {
-  testSync("with ~requireAttribute emits an attribute_exists filter that excludes internal rows", () => {
-    let code =
-      AppSync_Resolver_Retrying.Functions.listAllItemsConnection(
-        ~labelField="name",
-        ~requireAttribute="name",
-      )->codeOf
-    expect(code->String.includes("attribute_exists(#name)"))->toBe(true)
-    expect(code->String.includes("names['#name'] = 'name'"))->toBe(true)
-  })
+  testSync(
+    "with ~requireAttribute emits an attribute_exists filter that excludes internal rows",
+    () => {
+      let code =
+        AppSync_Resolver_Retrying.Functions.listAllItemsConnection(
+          ~labelField="name",
+          ~requireAttribute="name",
+        )->codeOf
+      expect(code->String.includes("attribute_exists(#name)"))->toBe(true)
+      expect(code->String.includes("names['#name'] = 'name'"))->toBe(true)
+    },
+  )
 
-  testSync("without ~requireAttribute emits no attribute_exists filter (default read models unchanged)", () => {
-    let code =
-      AppSync_Resolver_Retrying.Functions.listAllItemsConnection(~labelField="name")->codeOf
-    expect(code->String.includes("attribute_exists"))->toBe(false)
-  })
+  testSync(
+    "without ~requireAttribute emits no attribute_exists filter (default read models unchanged)",
+    () => {
+      let code =
+        AppSync_Resolver_Retrying.Functions.listAllItemsConnection(~labelField="name")->codeOf
+      expect(code->String.includes("attribute_exists"))->toBe(false)
+    },
+  )
 })
 
 // Tripwires for the Scan connection's paging. The behaviour itself is exercised
@@ -56,8 +62,9 @@ describe("listAllItemsConnection — paging", () => {
     expect(
       code->String.includes("parts.length > 0 ? ((_backward ? _upTo : _first + _from) > 1000"),
     )->toBe(true)
-    expect(code->String.includes("const _page = _backward ? _rest : _rest.slice(0, _first);"))
-    ->toBe(true)
+    expect(
+      code->String.includes("const _page = _backward ? _rest : _rest.slice(0, _first);"),
+    )->toBe(true)
     expect(code->String.includes("hasNextPage: _more || !!_next,"))->toBe(true)
   })
 

package/tests/QueryInterceptor_LambdaTest.res

@@ -54,14 +54,12 @@ describe("interceptor handler", () => {
 
   testPromise("an allowing hook is consulted and the read proceeds", async () => {
     let seen = ref([])
-    QueryDb_Callback.registerQueryInterceptor(async (
-      ~identity as _,
-      ~readModelName,
-      ~args as _,
-    ) => {
-      seen := seen.contents->Array.concat([readModelName])
-      QueryDb_Callback.Allow
-    })
+    QueryDb_Callback.registerQueryInterceptor(
+      async (~identity as _, ~readModelName, ~args as _) => {
+        seen := seen.contents->Array.concat([readModelName])
+        QueryDb_Callback.Allow
+      },
+    )
     let allowed = await QueryInterceptor_Lambda.handler(read(~readModelName="Order"), context)
     expect((allowed, seen.contents))->toEqual((true, ["Order"]))
   })
@@ -70,11 +68,11 @@ describe("interceptor handler", () => {
     // The refusal has to surface as a thrown error: the pipeline's response
     // function turns `ctx.error` into a GraphQL field error, and a returned
     // `false` would read as a successful read of nothing.
-    QueryDb_Callback.registerQueryInterceptor(async (
-      ~identity as _,
-      ~readModelName as _,
-      ~args as _,
-    ) => QueryDb_Callback.Deny("over the allowance"))
+    QueryDb_Callback.registerQueryInterceptor(
+      async (~identity as _, ~readModelName as _, ~args as _) => QueryDb_Callback.Deny(
+        "over the allowance",
+      ),
+    )
     let message = try {
       let _ = await QueryInterceptor_Lambda.handler(read(), context)
       "did not throw"

package/tests/ReadModelEntryPoint_OpsTest.res

@@ -18,32 +18,33 @@ describe("ReadModelEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("decodes a full entry incl. attribution and Postgres fields", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("@x/spec/src/ReadModel/Products.res.mjs")),
-            ("mappingsModule", str("@x/spec/src/ReadModel/Products_Projections.res.mjs")),
-            ("queryDbTableName", str("Products-abc")),
-            ("sourceUrn", str("arn:aws:sqs:eu-west-1:1:q")),
-            ("comp", str("EventCollector(ProductsEC)")),
-            ("plugin", str("Catalog")),
-            ("stateTopicName", str("catalogProducts")),
-            (
-              "pgConnection",
-              obj([
-                ("host", str("db.local")),
-                ("port", JSON.Encode.int(5432)),
-                ("database", str("app")),
-                ("username", str("master")),
-                ("secretArn", str("arn:secret")),
-              ]),
-            ),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("@x/spec/src/ReadModel/Products.res.mjs")),
+              ("mappingsModule", str("@x/spec/src/ReadModel/Products_Projections.res.mjs")),
+              ("queryDbTableName", str("Products-abc")),
+              ("sourceUrn", str("arn:aws:sqs:eu-west-1:1:q")),
+              ("comp", str("EventCollector(ProductsEC)")),
+              ("plugin", str("Catalog")),
+              ("stateTopicName", str("catalogProducts")),
+              (
+                "pgConnection",
+                obj([
+                  ("host", str("db.local")),
+                  ("port", JSON.Encode.int(5432)),
+                  ("database", str("app")),
+                  ("username", str("master")),
+                  ("secretArn", str("arn:secret")),
+                ]),
+              ),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let entries = ReadModelEntryPoint_Ops.parseHandlerConfig(config)
     expect(entries->Array.length)->toBe(1)
     let e = entries->Array.getUnsafe(0)
@@ -65,20 +66,21 @@ describe("ReadModelEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("optional fields default to None; null pgConnection maps to None", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("a.res.mjs")),
-            ("mappingsModule", str("b.res.mjs")),
-            ("queryDbTableName", str("t")),
-            ("sourceUrn", str("u")),
-            ("pgConnection", JSON.Null),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("a.res.mjs")),
+              ("mappingsModule", str("b.res.mjs")),
+              ("queryDbTableName", str("t")),
+              ("sourceUrn", str("u")),
+              ("pgConnection", JSON.Null),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let e = ReadModelEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
     expect(e.comp->Option.isNone)->toBe(true)
     expect(e.plugin->Option.isNone)->toBe(true)
@@ -99,9 +101,9 @@ describe("ReadModelEntryPoint_Ops.injectId", () => {
 
   testSync("passes non-object states through unchanged", () => {
     expect(ReadModelEntryPoint_Ops.injectId("p-1", str("scalar")))->toEqual(str("scalar"))
-    expect(
-      ReadModelEntryPoint_Ops.injectId("p-1", JSON.Encode.array([str("a")])),
-    )->toEqual(JSON.Encode.array([str("a")]))
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", JSON.Encode.array([str("a")])))->toEqual(
+      JSON.Encode.array([str("a")]),
+    )
     expect(ReadModelEntryPoint_Ops.injectId("p-1", JSON.Null))->toEqual(JSON.Null)
   })
 })

package/tests/RuntimeExtensionEntryPoint_OpsTest.res

@@ -99,9 +99,10 @@ describe("RuntimeExtensionEntryPoint_Ops.fire", () => {
     // ComponentType and the layer's. Firing under a guessed kind would silently
     // attach a kind-routing extension to the wrong runtime.
     let seen: array<string> = []
-    let config = RuntimeExtensionEntryPoint_Ops.parseConfig(
-      Some(`{"modules":["a"],"runtimeKind":"SomethingNewer","component":"X"}`),
-    )->Option.getOrThrow
+    let config =
+      RuntimeExtensionEntryPoint_Ops.parseConfig(
+        Some(`{"modules":["a"],"runtimeKind":"SomethingNewer","component":"X"}`),
+      )->Option.getOrThrow
 
     RuntimeExtensionEntryPoint_Ops.fire(config, [recordingHook("tracing", seen)])
 

package/tests/SideEffectEntryPoint_OpsTest.res

@@ -16,23 +16,27 @@ describe("SideEffectEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("decodes handlers incl. attribution fields", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("sideEffectModules", JSON.Encode.array([str("@x/p/src/A.res.mjs"), str("@x/p/src/B.res.mjs")])),
-            ("sourceUrn", str("arn:stream-1")),
-            ("comp", str("SideEffectHandler(Mailer)")),
-            ("plugin", str("Ordering")),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              (
+                "sideEffectModules",
+                JSON.Encode.array([str("@x/p/src/A.res.mjs"), str("@x/p/src/B.res.mjs")]),
+              ),
+              ("sourceUrn", str("arn:stream-1")),
+              ("comp", str("SideEffectHandler(Mailer)")),
+              ("plugin", str("Ordering")),
+            ]),
+            obj([
+              ("sideEffectModules", JSON.Encode.array([str("@x/p/src/C.res.mjs")])),
+              ("sourceUrn", str("arn:stream-2")),
+            ]),
           ]),
-          obj([
-            ("sideEffectModules", JSON.Encode.array([str("@x/p/src/C.res.mjs")])),
-            ("sourceUrn", str("arn:stream-2")),
-          ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let entries = SideEffectEntryPoint_Ops.parseHandlerConfig(config)
     expect(entries->Array.length)->toBe(2)
     let first = entries->Array.getUnsafe(0)
@@ -70,8 +74,9 @@ describe("SideEffectEntryPoint_Ops.makeRegisteredHandler", () => {
       comp: Some("SideEffectHandler(Mailer)"),
       plugin: Some("Ordering"),
     }
-    let registered = SideEffectEntryPoint_Ops.makeRegisteredHandler(entry, _stream =>
-      Effect.succeed()
+    let registered = SideEffectEntryPoint_Ops.makeRegisteredHandler(
+      entry,
+      _stream => Effect.succeed(),
     )
     expect(registered.comp)->toEqual(Some("SideEffectHandler(Mailer)"))
     expect(registered.plugin)->toEqual(Some("Ordering"))

package/tests/StateChangeDescriptorParityTest.res

@@ -30,16 +30,17 @@ describe("state-change descriptor parity", () => {
     let cases = await buildAll()
     // A silent zero-case run would pass while asserting nothing.
     expect(cases->Array.length)->toBe(11)
-    cases->Array.forEach(c => {
-      expect((c.name, c.relay))->toEqual((c.name, c.local))
-      expect((c.name, c.postgres))->toEqual((c.name, c.local))
-    })
+    cases->Array.forEach(
+      c => {
+        expect((c.name, c.relay))->toEqual((c.name, c.local))
+        expect((c.name, c.postgres))->toEqual((c.name, c.local))
+      },
+    )
   })
 
   testAsync("a save carries the row, a delete carries none", async () => {
     let cases = await buildAll()
-    let stateOf = (d: JSON.t) =>
-      d->JSON.Decode.object->Option.flatMap(o => o->Dict.get("state"))
+    let stateOf = (d: JSON.t) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get("state"))
     let byName = name => cases->Array.find(c => c.name == name)
 
     switch byName("single-key save with updatedAt") {
@@ -102,26 +103,27 @@ describe("state-change descriptor parity", () => {
     [
       "row in the first retired state degrades to metadata only",
       "row in the second retired state degrades to metadata only",
-    ]->Array.forEach(name =>
-      switch byName(name) {
-      | Some(c) =>
-        expect((name, keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((
-          name,
-          None,
-          None,
-        ))
-        expect((name, keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((
-          name,
-          None,
-          None,
-        ))
-        expect((name, keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((
-          name,
-          None,
-          None,
-        ))
-      | None => expect(name ++ " missing")->toBe("present")
-      }
+    ]->Array.forEach(
+      name =>
+        switch byName(name) {
+        | Some(c) =>
+          expect((name, keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((
+            name,
+            None,
+            None,
+          ))
+          expect((name, keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((
+            name,
+            None,
+            None,
+          ))
+          expect((name, keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((
+            name,
+            None,
+            None,
+          ))
+        | None => expect(name ++ " missing")->toBe("present")
+        },
     )
 
     // The control for the state form: a live state on the same lifecycle, so an

package/tests/StateTopicKeySchemaTest.res

@@ -16,32 +16,35 @@ let capture = f =>
 
 describe("StateTopic_AppSync_Helpers.checkPartitionKeyName", () => {
   testSync("accepts the framework convention", () => {
-    let thrown = capture(() =>
-      StateTopic_AppSync_Helpers.checkPartitionKeyName(
-        ~tableName="PlatformUsageLedger-1a2b3c4",
-        ~partitionKeyName="id",
-      )
+    let thrown = capture(
+      () =>
+        StateTopic_AppSync_Helpers.checkPartitionKeyName(
+          ~tableName="PlatformUsageLedger-1a2b3c4",
+          ~partitionKeyName="id",
+        ),
     )
     expect(thrown)->toEqual(None)
   })
 
   testSync("rejects a table keyed on anything else", () => {
-    let thrown = capture(() =>
-      StateTopic_AppSync_Helpers.checkPartitionKeyName(
-        ~tableName="PlatformUsageLedger-1a2b3c4",
-        ~partitionKeyName="pluginId",
-      )
+    let thrown = capture(
+      () =>
+        StateTopic_AppSync_Helpers.checkPartitionKeyName(
+          ~tableName="PlatformUsageLedger-1a2b3c4",
+          ~partitionKeyName="pluginId",
+        ),
     )
     expect(thrown->Option.isSome)->toBe(true)
   })
 
   testSync("names the table and its actual key in the message", () => {
     let message =
-      capture(() =>
-        StateTopic_AppSync_Helpers.checkPartitionKeyName(
-          ~tableName="PlatformUsageLedger-1a2b3c4",
-          ~partitionKeyName="pluginId",
-        )
+      capture(
+        () =>
+          StateTopic_AppSync_Helpers.checkPartitionKeyName(
+            ~tableName="PlatformUsageLedger-1a2b3c4",
+            ~partitionKeyName="pluginId",
+          ),
       )->Option.getOr("")
     expect(message->String.includes("PlatformUsageLedger-1a2b3c4"))->toBe(true)
     expect(message->String.includes("pluginId"))->toBe(true)