@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/IdentityTest.res.mjs

@@ -0,0 +1,174 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as RequestContext$ReventlessCore from "../src/RequestContext.res.mjs";
+
+S.enableJson();
+
+globalThis.describe("Identity", () => {
+  globalThis.describe("anonymous", () => {
+    globalThis.test("has userId 'anonymous'", () => {
+      globalThis.expect(Identity$Reventless.anonymous.userId).toBe("anonymous");
+    });
+    globalThis.test("has empty groups", () => {
+      globalThis.expect(Identity$Reventless.anonymous.groups).toEqual([]);
+    });
+    globalThis.test("has InMemory provider", () => {
+      globalThis.expect(Identity$Reventless.anonymous.provider).toEqual("InMemory");
+    });
+  });
+  globalThis.describe("hasGroup", () => {
+    let identity_groups = [
+      "admin",
+      "editors"
+    ];
+    let identity = {
+      userId: "user-1",
+      username: "alice",
+      groups: identity_groups,
+      provider: "Cognito"
+    };
+    globalThis.test("returns true when group is present", () => {
+      globalThis.expect(Identity$Reventless.hasGroup(identity, "admin")).toBe(true);
+    });
+    globalThis.test("returns false when group is absent", () => {
+      globalThis.expect(Identity$Reventless.hasGroup(identity, "viewers")).toBe(false);
+    });
+  });
+  globalThis.describe("getClaim", () => {
+    let identity_groups = [];
+    let identity_claims = Object.fromEntries([
+      [
+        "tenant",
+        "acme"
+      ],
+      [
+        "role",
+        "manager"
+      ]
+    ]);
+    let identity = {
+      userId: "user-1",
+      username: "alice",
+      groups: identity_groups,
+      claims: identity_claims,
+      provider: "InMemory"
+    };
+    globalThis.test("returns Some for existing claim", () => {
+      globalThis.expect(Identity$Reventless.getClaim(identity, "tenant")).toEqual("acme");
+    });
+    globalThis.test("returns None for missing claim", () => {
+      globalThis.expect(Identity$Reventless.getClaim(identity, "missing")).toEqual(undefined);
+    });
+    globalThis.test("returns None when claims are absent", () => {
+      let noClaims_groups = [];
+      let noClaims = {
+        userId: "user-2",
+        username: "bob",
+        groups: noClaims_groups,
+        provider: "InMemory"
+      };
+      globalThis.expect(Identity$Reventless.getClaim(noClaims, "tenant")).toEqual(undefined);
+    });
+  });
+  globalThis.describe("schema roundtrip", () => {
+    globalThis.test("encode then decode preserves identity", () => {
+      let identity_groups = ["admin"];
+      let identity_claims = Object.fromEntries([[
+          "tenant",
+          "acme"
+        ]]);
+      let identity = {
+        userId: "user-1",
+        username: "alice",
+        groups: identity_groups,
+        claims: identity_claims,
+        provider: "Cognito"
+      };
+      let json = S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema);
+      let decoded = S.parseJsonOrThrow(json, Identity$Reventless.schema);
+      globalThis.expect(decoded).toEqual(identity);
+    });
+    globalThis.test("roundtrip with Custom provider", () => {
+      let identity_groups = [];
+      let identity_provider = {
+        TAG: "Custom",
+        _0: "oauth2"
+      };
+      let identity = {
+        userId: "ext-1",
+        username: "external",
+        groups: identity_groups,
+        provider: identity_provider
+      };
+      let json = S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema);
+      let decoded = S.parseJsonOrThrow(json, Identity$Reventless.schema);
+      globalThis.expect(decoded).toEqual(identity);
+    });
+    globalThis.test("roundtrip without optional claims", () => {
+      let identity_groups = [];
+      let identity = {
+        userId: "user-3",
+        username: "charlie",
+        groups: identity_groups,
+        provider: "InMemory"
+      };
+      let json = S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema);
+      let decoded = S.parseJsonOrThrow(json, Identity$Reventless.schema);
+      globalThis.expect(decoded.userId).toBe("user-3");
+      globalThis.expect(decoded.provider).toEqual("InMemory");
+    });
+  });
+});
+
+globalThis.describe("RequestContext", () => {
+  globalThis.describe("test() constructor", () => {
+    globalThis.test("defaults to anonymous identity", () => {
+      let ctx = RequestContext$ReventlessCore.test(undefined, undefined, undefined);
+      globalThis.expect(ctx.identity.userId).toBe("anonymous");
+    });
+    globalThis.test("accepts custom identity", () => {
+      let identity_groups = ["admin"];
+      let identity = {
+        userId: "user-1",
+        username: "alice",
+        groups: identity_groups,
+        provider: "Cognito"
+      };
+      let ctx = RequestContext$ReventlessCore.test(undefined, identity, undefined);
+      globalThis.expect(ctx.identity.userId).toBe("user-1");
+    });
+    globalThis.test("defaults to empty claims", () => {
+      let ctx = RequestContext$ReventlessCore.test(undefined, undefined, undefined);
+      globalThis.expect(Object.keys(ctx.claims)).toEqual([]);
+    });
+  });
+  globalThis.describe("getClaim", () => {
+    globalThis.test("returns claim value when present", () => {
+      let ctx = RequestContext$ReventlessCore.test(undefined, undefined, Object.fromEntries([[
+          "tenant",
+          "acme"
+        ]]));
+      globalThis.expect(RequestContext$ReventlessCore.getClaim(ctx, "tenant")).toEqual("acme");
+    });
+    globalThis.test("returns None when absent", () => {
+      let ctx = RequestContext$ReventlessCore.test(undefined, undefined, undefined);
+      globalThis.expect(RequestContext$ReventlessCore.getClaim(ctx, "missing")).toEqual(undefined);
+    });
+  });
+  globalThis.describe("withClaim", () => {
+    globalThis.test("adds a claim to the context", () => {
+      let ctx = RequestContext$ReventlessCore.test(undefined, undefined, undefined);
+      let updated = RequestContext$ReventlessCore.withClaim(ctx, "tenant", "acme");
+      globalThis.expect(RequestContext$ReventlessCore.getClaim(updated, "tenant")).toEqual("acme");
+    });
+    globalThis.test("does not mutate the original context", () => {
+      let ctx = RequestContext$ReventlessCore.test(undefined, undefined, undefined);
+      RequestContext$ReventlessCore.withClaim(ctx, "tenant", "acme");
+      globalThis.expect(RequestContext$ReventlessCore.getClaim(ctx, "tenant")).toEqual(undefined);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -0,0 +1,237 @@
+// Asserts the canonical JSON shape produced by encodePluginStructureEntry —
+// shared by both the in-memory and AWS adapters. If this test changes, every
+// console parsing the Platform_ComponentDefinitions response is affected.
+
+open JestGlobals
+open Reventless.Plugin
+
+let cmd: commandDef = {
+  name: "Add",
+  schema: "{}",
+  level: Collection,
+  aggregateIdField: None,
+  mutationField: "AddProduct",
+  references: [
+    {fieldName: "categoryId", entity: "Category", plugin: Some("Catalog")},
+  ],
+  allowedStates: None,
+  apiExposed: Some(true),
+}
+
+let qbl: queryableDef = {
+  name: "Products",
+  queryField: "Catalog_Products",
+  schema: "{}",
+  consumedEventTypes: ["ProductAdded"],
+  linkedWriteSide: ["Product"],
+  labelField: "displayName",
+  searchableFields: ["displayName"],
+  statusField: None,
+  visibility: None,
+}
+
+let wbl: writableDef = {
+  name: "Product",
+  commands: [cmd],
+  linkedViews: ["Products"],
+  consistencyRead: None,
+  producedEventTypes: ["ProductAdded"],
+  consumedEventTypes: [],
+  events: [{name: "ProductAdded", schema: "{}", references: []}],
+}
+
+let structure: pluginStructure = {
+  readModels: [qbl],
+  stateViewSlices: [],
+  stateChangeSlices: [],
+  aggregates: [wbl],
+  automationSlices: [
+    {
+      name: "Restocker",
+      consumedEventTypes: ["StockLow"],
+      producedCommandTypes: ["Restock"],
+      targetName: "Product",
+    },
+  ],
+  outboundTranslationSlices: [
+    {
+      name: "ToShipper",
+      consumedEventTypes: ["OrderPlaced"],
+      inboundCommandTypes: ["Ship"],
+      targetName: None,
+    },
+  ],
+  inboundTranslationSlices: [
+    {name: "FromBilling", commandTypes: ["RecordPayment"], targetName: "Order"},
+  ],
+  extensions: [
+    {
+      name: "Catalog.Products.Watcher",
+      delegateNames: ["onAdded"],
+      eventTypes: ["ProductAdded"],
+      commandTypes: [],
+    },
+  ],
+  extensionPoints: None,
+}
+
+let encoded = Platform_ComponentDefinitionsApi.encodePluginStructureEntry(
+  ~pluginId="Catalog",
+  structure,
+)
+let json = encoded->JSON.stringify
+
+describe("encodePluginStructureEntry", () => {
+  testSync("produces a JSON object with the expected top-level keys", () => {
+    let dict = encoded->JSON.Decode.object->Option.getOr(Dict.make())
+    let keys = dict->Dict.keysToArray->Array.toSorted(String.compare)
+    expect(keys)->toEqual([
+      "aggregates",
+      "automationSlices",
+      "extensions",
+      "inboundTranslationSlices",
+      "outboundTranslationSlices",
+      "pluginId",
+      "readModels",
+      "stateChangeSlices",
+      "stateViewSlices",
+    ])
+  })
+
+  testSync("encodes pluginId", () =>
+    expect(json->String.includes("\"pluginId\":\"Catalog\""))->toEqual(true)
+  )
+
+  testSync("encodes commandLevel as a literal string", () =>
+    expect(json->String.includes("\"level\":\"Collection\""))->toEqual(true)
+  )
+
+  testSync("encodes None aggregateIdField as null", () =>
+    expect(json->String.includes("\"aggregateIdField\":null"))->toEqual(true)
+  )
+
+  testSync("encodes None consistencyRead as null", () =>
+    expect(json->String.includes("\"consistencyRead\":null"))->toEqual(true)
+  )
+
+  testSync("encodes Some plugin reference as its inner string", () =>
+    expect(json->String.includes("\"plugin\":\"Catalog\""))->toEqual(true)
+  )
+
+  testSync("includes the queryableDef name", () =>
+    expect(json->String.includes("\"name\":\"Products\""))->toEqual(true)
+  )
+
+  testSync("includes the automation slice name", () =>
+    expect(json->String.includes("\"name\":\"Restocker\""))->toEqual(true)
+  )
+
+  testSync("encodes None allowedStates as null", () =>
+    expect(json->String.includes("\"allowedStates\":null"))->toEqual(true)
+  )
+
+  testSync("encodes the command's apiExposed flag (drives the event-graph API badge)", () =>
+    expect(json->String.includes("\"apiExposed\":true"))->toEqual(true)
+  )
+
+  testSync("encodes None statusField as null", () =>
+    expect(json->String.includes("\"statusField\":null"))->toEqual(true)
+  )
+
+  // Phase 6.3: write-side emitted-event field schemas.
+  testSync("encodes writableDef events", () =>
+    expect(json->String.includes("\"events\":[{\"name\":\"ProductAdded\""))->toEqual(true)
+  )
+})
+
+describe("visibility filtering (deployed AutoUI hides Internal)", () => {
+  // Internal ReadModels / StateViewSlices are carried in pluginStructure for developer
+  // tooling but must not surface in the UI definitions the deployed AutoUI builds its
+  // menu / pages from — see Plugin_Structure.res / Visibility.res.
+  let internalQbl: queryableDef = {
+    name: "AvailableProducts",
+    queryField: "Ordering_AvailableProducts",
+    schema: "{}",
+    consumedEventTypes: ["CatalogProductSynced"],
+    linkedWriteSide: [],
+    labelField: "name",
+    searchableFields: ["name"],
+    statusField: None,
+    visibility: Some("Internal"),
+  }
+  let mixed: pluginStructure = {
+    ...structure,
+    readModels: [qbl, internalQbl],
+    stateViewSlices: [internalQbl],
+  }
+  let mixedJson =
+    Platform_ComponentDefinitionsApi.encodePluginStructureEntry(~pluginId="Ordering", mixed)->JSON.stringify
+
+  testSync("excludes an Internal queryableDef from the encoded read-side", () =>
+    expect(mixedJson->String.includes("AvailableProducts"))->toEqual(false)
+  )
+
+  testSync("keeps a Public queryableDef", () =>
+    expect(mixedJson->String.includes("\"name\":\"Products\""))->toEqual(true)
+  )
+})
+
+describe("allowedStates + statusField populated", () => {
+  let cmdWithStates: commandDef = {
+    name: "Activate",
+    schema: "{}",
+    level: Instance,
+    aggregateIdField: Some("id"),
+    mutationField: "Platform_Plugin_Activate",
+    references: [],
+    allowedStates: Some(["Inactive"]),
+    apiExposed: Some(true),
+  }
+
+  let qblWithStatus: queryableDef = {
+    name: "Plugin",
+    queryField: "Platform_Plugins",
+    schema: "{}",
+    consumedEventTypes: [],
+    linkedWriteSide: ["Plugin"],
+    labelField: "name",
+    searchableFields: ["name"],
+    statusField: Some("status"),
+    visibility: None,
+  }
+
+  let wblWithStates: writableDef = {
+    name: "Plugin",
+    commands: [cmdWithStates],
+    linkedViews: ["Plugin"],
+    consistencyRead: None,
+    producedEventTypes: [],
+    consumedEventTypes: [],
+    events: [],
+  }
+
+  let structureWithStates: pluginStructure = {
+    readModels: [qblWithStatus],
+    stateViewSlices: [],
+    stateChangeSlices: [],
+    aggregates: [wblWithStates],
+    automationSlices: [],
+    outboundTranslationSlices: [],
+    inboundTranslationSlices: [],
+    extensions: [],
+    extensionPoints: None,
+  }
+
+  let json =
+    structureWithStates
+    ->Platform_ComponentDefinitionsApi.encodePluginStructureEntry(~pluginId="Platform", _)
+    ->JSON.stringify
+
+  testSync("encodes populated allowedStates as a JSON array", () =>
+    expect(json->String.includes("\"allowedStates\":[\"Inactive\"]"))->toEqual(true)
+  )
+
+  testSync("encodes populated statusField as the field name string", () =>
+    expect(json->String.includes("\"statusField\":\"status\""))->toEqual(true)
+  )
+})