@reventlessdev/online-shop-hybrid-seed 1.0.0-alpha.2

package/lib/ocaml/HybridSeedData.res

@@ -0,0 +1,418 @@
+// The online-shop-hybrid demo data set(s), exported as `Seed.dataSet` values.
+//
+// This is the shareable artifact: `dataSets` carries everything domain-specific
+// — the phases, the view verification, and the summary board — behind the
+// generic `Seed.dataSet` shape, so any platform script (this example's
+// `platform-local`/`platform-aws`, or a downstream consumer) seeds it with just
+// `Seed.Runner.seed(~sets=HybridSeedData.dataSets, ~connect=…)`.
+//
+// Because every phase drives the public GraphQL command API, a run doubles as a
+// smoke test: it exercises the DCB append path, both extension points, and the
+// AutoShipOrder automation. `DemoData.res` holds *what* to seed; `DemoCommands.res`
+// maps command values onto mutations; the transport and reporting come from
+// `ReventlessSeed`.
+
+open ReventlessSeed
+
+// Every queryable view this example exposes. `Unfillable` is not a way to
+// silence a gap — it records a view no volume of seed data can reach, with the
+// reason, so a zero is never read as a seeding miss.
+let views = [
+  Seed.Runner.Seeded("Catalog_Categories"),
+  Seed.Runner.Seeded("Catalog_Products"),
+  Seed.Runner.Seeded("Catalog_ProductDemands"),
+  Seed.Runner.Seeded("Catalog_ImportProductAudits"),
+  Seed.Runner.Seeded("Ordering_AvailableProducts"),
+  Seed.Runner.Seeded("Ordering_Orders"),
+  Seed.Runner.Seeded("Ordering_Customers"),
+  Seed.Runner.Seeded("Ordering_AutoShipOrderTodos"),
+  Seed.Runner.Seeded("Ordering_SendOrderConfirmationTodos"),
+]
+
+// ── Phases ──────────────────────────────────────────────────────────────────
+
+let seedCategories = async (~client: Seed.Client.t) => {
+  await client->Seed.Client.sendAll(
+    DemoData.categories->Array.map(c =>
+      DemoCommands.addCategory(AddCategory({categoryId: c.id, name: c.name}))
+    ),
+  )
+  Seed.Runner.report(`categories: ${(DemoData.categories->Array.length)->Int.toString} added`)
+}
+
+// Upload each product's deterministic placeholder SVG through the deployment's
+// upload endpoint and swap `imageUrl` for the returned served `/{prefix}/{key}`
+// ref, so the demo image travels the real upload → store → serve loop (local
+// dev store or AWS bucket) exactly like a user upload — no external image URL.
+let uploadProductImages = async (
+  products: array<DemoData.product>,
+  ~client: Seed.Client.t,
+  ~uploadEndpoint: string,
+): array<DemoData.product> => {
+  let out = []
+  for i in 0 to products->Array.length - 1 {
+    switch products->Array.get(i) {
+    | Some(p) =>
+      let svg = DemoData.productSvg(~name=p.name, ~index=i)
+      switch await Seed.Upload.uploadAsset(
+        ~uploadEndpoint,
+        ~bytes=svg,
+        ~fileName=`${p.id}.svg`,
+        ~contentType="image/svg+xml",
+        ~authToken=?Seed.Client.currentToken(client),
+      ) {
+      | Ok(servedRef) => out->Array.push({...p, imageUrl: servedRef})
+      | Error(msg) => throw(Seed.Failed(`product image upload for ${p.id} failed: ${msg}`))
+      }
+    | None => ()
+    }
+  }
+  Seed.Runner.report(
+    `product images: ${(out->Array.length)->Int.toString} uploaded to the served bucket`,
+  )
+  out
+}
+
+let seedProducts = async (products: array<DemoData.product>, ~client: Seed.Client.t) => {
+  await client->Seed.Client.sendAll(
+    products->Array.map(p =>
+      DemoCommands.addProduct(
+        AddProduct({
+          productId: p.id,
+          name: p.name,
+          description: p.description,
+          price: p.price,
+          imageUrl: p.imageUrl,
+          categoryId: p.categoryId,
+        }),
+      )
+    ),
+  )
+  Seed.Runner.report(`products: ${(products->Array.length)->Int.toString} added`)
+}
+
+let seedCatalogEdits = async (products: array<DemoData.product>, ~client: Seed.Client.t) => {
+  let repriced = DemoData.repricedProducts(products)
+  await client->Seed.Client.sendAll(
+    repriced->Array.map(p =>
+      DemoCommands.changeProductPrice(
+        ChangeProductPrice({productId: p.id, price: DemoData.discountedPrice(p)}),
+      )
+    ),
+  )
+  let redescribed = DemoData.redescribedProducts(products)
+  await client->Seed.Client.sendAll(
+    redescribed->Array.map(p =>
+      DemoCommands.changeProductDescription(
+        ChangeProductDescription({
+          productId: p.id,
+          description: `${p.description} Updated listing copy.`,
+        }),
+      )
+    ),
+  )
+  await client->Seed.Client.sendAll([
+    DemoCommands.renameCategory(
+      RenameCategory({
+        categoryId: DemoData.renamedCategoryId,
+        name: DemoData.renamedCategoryName,
+      }),
+    ),
+  ])
+  let archived = DemoData.categories->Array.filter(c => c.archive)
+  await client->Seed.Client.sendAll(
+    archived->Array.map(c => DemoCommands.archiveCategory(ArchiveCategory({categoryId: c.id}))),
+  )
+  Seed.Runner.report(
+    `catalog edits: ${(repriced->Array.length)->Int.toString} repriced, ${(redescribed
+        ->Array.length)
+        ->Int.toString} redescribed, 1 renamed, ${(archived->Array.length)
+        ->Int.toString} archived`,
+  )
+}
+
+let seedSupplierFeed = async (~client: Seed.Client.t) => {
+  for i in 0 to DemoData.supplierFeed->Array.length - 1 {
+    switch DemoData.supplierFeed->Array.get(i) {
+    | Some(row) =>
+      // One feed row is deliberately invalid, so a translation rejection is an
+      // expected outcome here rather than a seeding failure.
+      (
+        await client->Seed.Client.send(
+          DemoCommands.importProduct(row),
+          ~tolerate=["TranslationFailed"],
+        )
+      )->ignore
+    | None => ()
+    }
+  }
+  // Cross-check the per-request outcomes against the slice's audit view.
+  let audits = await client->Seed.Client.queryAllNodes(
+    ~field="Catalog_ImportProductAudits",
+    ~selection="status",
+  )
+  let countWith = status =>
+    audits->Array.filter(a => a->Seed.Client.nodeString("status") == Some(status))->Array.length
+  let successes = countWith("Success")
+  let failures = countWith("Failure")
+  if (
+    successes != DemoData.expectedImportSuccesses || failures != DemoData.expectedImportFailures
+  ) {
+    throw(
+      Seed.Failed(
+        `supplier feed: expected ${DemoData.expectedImportSuccesses->Int.toString} Success / ${DemoData.expectedImportFailures->Int.toString} Failure audit rows, got ${successes->Int.toString}/${failures->Int.toString}`,
+      ),
+    )
+  }
+  Seed.Runner.report(
+    `supplier feed: ${successes->Int.toString} imported, ${failures->Int.toString} rejected (both shown in the audit view)`,
+  )
+}
+
+let seedCustomers = async (customers: array<DemoData.customer>, ~client: Seed.Client.t) => {
+  await client->Seed.Client.sendAll(
+    customers->Array.map(c =>
+      DemoCommands.customer(~id=c.id, Register({email: c.email, address: c.address}))
+    ),
+  )
+  // Give every customer a map coordinate so the Customers map view renders a
+  // pin per row. The geo-point payload is a `{lat, lng}` input object.
+  await client->Seed.Client.sendAll(
+    customers->Array.map(c =>
+      DemoCommands.customer(~id=c.id, SetLocation({location: {lat: c.lat, lng: c.lng}}))
+    ),
+  )
+  let moved = DemoData.movedCustomers(customers)
+  await client->Seed.Client.sendAll(
+    moved->Array.map(c =>
+      DemoCommands.customer(~id=c.id, UpdateAddress({address: DemoData.newAddress()}))
+    ),
+  )
+  Seed.Runner.report(
+    `customers: ${(customers->Array.length)->Int.toString} registered, ${(moved->Array.length)
+        ->Int.toString} moved`,
+  )
+}
+
+let seedOrders = async (orders: array<DemoData.order>, ~client: Seed.Client.t) => {
+  for i in 0 to orders->Array.length - 1 {
+    switch orders->Array.get(i) {
+    | Some(order) =>
+      (await client->Seed.Client.send(
+        DemoCommands.placeOrder(
+          PlaceOrder({
+            orderId: order.id,
+            customerId: order.customerId,
+            productIds: order.productIds,
+            shippingMethod: order.shippingMethod,
+          }),
+        ),
+      ))->ignore
+      if mod(i + 1, 50) == 0 {
+        Seed.Runner.report(
+          `orders: ${(i + 1)->Int.toString}/${(orders->Array.length)->Int.toString} placed`,
+        )
+      }
+    | None => ()
+    }
+  }
+  let countMethod = (method: OrderingPlugin.PlaceOrder.shippingMethod) =>
+    orders->Array.filter(o => o.shippingMethod == method)->Array.length
+  Seed.Runner.report(
+    `orders: ${(orders->Array.length)->Int.toString} placed (Standard ${countMethod(
+        Standard,
+      )->Int.toString}, Express ${countMethod(Express)->Int.toString}, Pickup ${countMethod(
+        Pickup,
+      )->Int.toString}) — Express placements were auto-shipped on arrival`,
+  )
+}
+
+let dispatchStandardBatch = async (orders: array<DemoData.order>, ~client: Seed.Client.t) => {
+  let dispatched = DemoData.batchDispatched(orders)
+  await client->Seed.Client.sendAll(
+    dispatched->Array.map(o => DemoCommands.shipOrder(ShipOrder({orderId: o.id}))),
+  )
+  let standardTotal = orders->Array.filter(o => o.shippingMethod == Standard)->Array.length
+  Seed.Runner.report(
+    `batch dispatch: ${(dispatched->Array.length)
+        ->Int.toString}/${standardTotal->Int.toString} Standard orders shipped, ${(standardTotal -
+      dispatched->Array.length)->Int.toString} left pending`,
+  )
+  dispatched->Array.map(o => o.id)
+}
+
+let seedCancellations = async (
+  orders: array<DemoData.order>,
+  ~client: Seed.Client.t,
+  ~dispatched: array<string>,
+) => {
+  let cancellable = DemoData.cancellable(orders, ~dispatched)
+  let targets = DemoData.cancelled(cancellable)
+  await client->Seed.Client.sendAll(
+    targets->Array.map(o => DemoCommands.cancelOrder(CancelOrder({orderId: o.id}))),
+  )
+  Seed.Runner.report(
+    `cancellations: ${(targets->Array.length)->Int.toString} of ${(cancellable->Array.length)
+        ->Int.toString} cancellable orders cancelled`,
+  )
+}
+
+let seedDeactivations = async (customers: array<DemoData.customer>, ~client: Seed.Client.t) => {
+  let targets = DemoData.deactivatedCustomers(customers)
+  await client->Seed.Client.sendAll(
+    targets->Array.map(c => DemoCommands.customer(~id=c.id, Deactivate)),
+  )
+  Seed.Runner.report(`customers: ${(targets->Array.length)->Int.toString} deactivated`)
+}
+
+// ── Summary ─────────────────────────────────────────────────────────────────
+
+let summarise = async (~client: Seed.Client.t, ~counts: dict<int>) => {
+  let orders = await client->Seed.Client.queryAllNodes(
+    ~field="Ordering_Orders",
+    ~selection="status shippingMethod",
+  )
+  let statuses = ["Placed", "Shipped", "Cancelled"]
+  let methods = ["Standard", "Express", "Pickup"]
+  let countCell = (status, method) =>
+    orders
+    ->Array.filter(o =>
+      o->Seed.Client.nodeString("status") == Some(status) &&
+        o->Seed.Client.nodeString("shippingMethod") == Some(method)
+    )
+    ->Array.length
+  let countStatus = status =>
+    orders->Array.filter(o => o->Seed.Client.nodeString("status") == Some(status))->Array.length
+
+  let demand = await client->Seed.Client.queryAllNodes(
+    ~field="Catalog_ProductDemands",
+    ~selection="name orderCount",
+  )
+  let orderCountOf = node =>
+    switch node->Seed.Client.field("orderCount") {
+    | Some(Number(n)) => n->Int.fromFloat
+    | _ => 0
+    }
+  let ranked = demand->Array.toSorted((a, b) => Int.compare(orderCountOf(b), orderCountOf(a)))
+  let withDemand = ranked->Array.filter(n => orderCountOf(n) > 0)
+  let head =
+    ranked
+    ->Array.slice(~start=0, ~end=3)
+    ->Array.map(n =>
+      `${n->Seed.Client.nodeString("name")->Option.getOr("?")} (${orderCountOf(n)->Int.toString})`
+    )
+    ->Array.join(", ")
+
+  Seed.Runner.heading("Seeded:")
+  Console.log(
+    `  order status:  ${statuses
+      ->Array.map(s => `${s} ${countStatus(s)->Int.toString}`)
+      ->Array.join(", ")}`,
+  )
+  Console.log(`  demand head:   ${head}`)
+  Console.log(
+    `  demand spread: ${(withDemand->Array.length)->Int.toString}/${(ranked->Array.length)
+        ->Int.toString} products ordered, tail min ${withDemand
+      ->Array.last
+      ->Option.mapOr(0, orderCountOf)
+      ->Int.toString}`,
+  )
+
+  Console.log("")
+  Console.log("  status × shippingMethod:")
+  Console.log(
+    `    ${" "->String.padEnd(10, " ")}${methods
+      ->Array.map(m => m->String.padStart(10, " "))
+      ->Array.join("")}`,
+  )
+  statuses->Array.forEach(status =>
+    Console.log(
+      `    ${status->String.padEnd(10, " ")}${methods
+        ->Array.map(m => countCell(status, m)->Int.toString->String.padStart(10, " "))
+        ->Array.join("")}`,
+    )
+  )
+
+  let observedStatuses = statuses->Array.filter(s => countStatus(s) > 0)
+  let spreadWarning = if observedStatuses->Array.length < 3 {
+    [
+      `the board shows only ${(observedStatuses->Array.length)
+          ->Int.toString} of the 3 order statuses (${observedStatuses->Array.join(
+          ", ",
+        )}) — the shipping-method mix or the batch-dispatch share needs adjusting.`,
+    ]
+  } else {
+    []
+  }
+  Seed.Runner.warn(Array.concat(spreadWarning, Seed.Runner.unfillableWarnings(~views, ~counts)))
+}
+
+// ── Run ─────────────────────────────────────────────────────────────────────
+
+// The shared seed run, parameterized only by volume so every data set walks the
+// same phases. Uploads no-op when the connection carries no upload endpoint
+// (a deployment that serves none), keeping `imageUrl` empty rather than failing.
+let run = async (
+  connection: Seed.connection,
+  ~productCount: int,
+  ~customerCount: int,
+  ~orderCount: int,
+): unit => {
+  let client = connection.client
+
+  let built = DemoData.buildProducts(~count=productCount, ())
+  let products = if connection.uploadEndpoint == "" {
+    Seed.Runner.report(
+      "product images: skipped (no upload endpoint / SEED_SKIP_UPLOADS) — imageUrl left empty",
+    )
+    built
+  } else {
+    await uploadProductImages(built, ~client, ~uploadEndpoint=connection.uploadEndpoint)
+  }
+  let customers = DemoData.buildCustomers(~count=customerCount, ())
+  let orders = DemoData.buildOrders(products, customers, ~count=orderCount, ())
+
+  await seedCategories(~client)
+  await seedProducts(products, ~client)
+  await seedCatalogEdits(products, ~client)
+  await seedSupplierFeed(~client)
+  await seedCustomers(customers, ~client)
+
+  // Products reach Ordering asynchronously through the Products extension
+  // point; PlaceOrder rejects until the shadow copy lands.
+  let expected = Array.concat(products->Array.map(p => p.id), DemoData.importedSkus)
+  let available = await client->Seed.Client.waitForIds(
+    ~field="Ordering_AvailableProductsByIds",
+    ~ids=expected,
+  )
+  Seed.Runner.report(`ordering: ${available->Int.toString} products available`)
+
+  await seedOrders(orders, ~client)
+  let dispatched = await dispatchStandardBatch(orders, ~client)
+  await seedCancellations(orders, ~client, ~dispatched)
+  await seedDeactivations(customers, ~client)
+
+  let counts = await Seed.Runner.verifyViews(client, ~views)
+  await summarise(~client, ~counts)
+}
+
+// Two sets, so `Seed.Runner.seed` presents a selection: the full demo, and a
+// compact sample for a quick end-to-end check. Both walk identical phases.
+let dataSets: array<Seed.dataSet> = [
+  {
+    name: "full",
+    label: `full — ${DemoData.productCount->Int.toString} products, ${DemoData.customerCount->Int.toString} customers, ${DemoData.orderCount->Int.toString} orders`,
+    seed: connection =>
+      run(
+        connection,
+        ~productCount=DemoData.productCount,
+        ~customerCount=DemoData.customerCount,
+        ~orderCount=DemoData.orderCount,
+      ),
+  },
+  {
+    name: "sample",
+    label: "sample — 16 products, 8 customers, 40 orders",
+    seed: connection => run(connection, ~productCount=16, ~customerCount=8, ~orderCount=40),
+  },
+]

package/lib/ocaml/OnlineShopHybridSeed.mlmap

@@ -0,0 +1,4 @@
+randjbuildsystem
+DemoCommands
+DemoData
+HybridSeedData

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@reventlessdev/online-shop-hybrid-seed",
+  "version": "1.0.0-alpha.2",
+  "description": "Shareable demo data set(s) for the online-shop-hybrid example, exported as reventless-seed data sets",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "sury": "^11.0.0-alpha.4",
+    "@reventlessdev/online-shop-hybrid-ordering": "1.0.0-alpha.155",
+    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.74",
+    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.74",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.2",
+    "@reventlessdev/online-shop-hybrid-catalog": "1.0.0-alpha.156"
+  },
+  "devDependencies": {
+    "rescript": "12.3.0"
+  },
+  "peerDependencies": {
+    "rescript": "12.3.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReventlessDev/reventless-core.git",
+    "directory": "examples/online-shop-hybrid/seed-data"
+  },
+  "scripts": {
+    "build": "rescript build",
+    "start": "rescript watch",
+    "clean": "rescript clean",
+    "rebuild": "pnpm run clean && pnpm run build"
+  }
+}

package/rescript.json

@@ -0,0 +1,27 @@
+{
+  "name": "@reventlessdev/online-shop-hybrid-seed",
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "namespace": "OnlineShopHybridSeed",
+  "warnings": {
+    "error": "-44+101"
+  },
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    }
+  ],
+  "dependencies": [
+    "sury",
+    "@reventlessdev/reventless-seed",
+    "@reventlessdev/online-shop-hybrid-catalog",
+    "@reventlessdev/online-shop-hybrid-catalog-spec",
+    "@reventlessdev/online-shop-hybrid-ordering",
+    "@reventlessdev/online-shop-hybrid-ordering-spec"
+  ],
+  "compiler-flags": [],
+  "suffix": ".res.mjs"
+}

package/src/DemoCommands.res

@@ -0,0 +1,154 @@
+// Adapter: online-shop-hybrid command values → GraphQL mutations.
+//
+// This is the only place that knows how this example's commands are exposed on
+// the API — the mutation field names and how each variant's payload maps onto
+// arguments. Everything above it works in plugin command types; everything
+// below it (`ReventlessSeed`) works in generic mutations.
+//
+// Each encoder pattern-matches the real command variant, so a renamed field or
+// a new payload member is a compile error here rather than a rejected mutation
+// at seed time. That is the whole point of routing the seed through typed
+// commands instead of hand-written GraphQL strings.
+
+open ReventlessSeed
+
+// Mutation fields are `<PluginName>_<CommandVariant>`; aggregates additionally
+// carry the entity id as a separate `id` argument.
+let catalog = (name: string): string => `Catalog_${name}`
+let ordering = (name: string): string => `Ordering_${name}`
+
+// ── Catalog ─────────────────────────────────────────────────────────────────
+
+let addCategory = (command: CatalogPlugin.AddCategory.command): Seed.mutation =>
+  switch command {
+  | AddCategory({categoryId, name}) =>
+    Seed.mutation(catalog("AddCategory"), [("categoryId", Id(categoryId)), ("name", String(name))])
+  }
+
+let renameCategory = (command: CatalogPlugin.RenameCategory.command): Seed.mutation =>
+  switch command {
+  | RenameCategory({categoryId, name}) =>
+    Seed.mutation(
+      catalog("RenameCategory"),
+      [("categoryId", Id(categoryId)), ("name", String(name))],
+    )
+  }
+
+let archiveCategory = (command: CatalogPlugin.ArchiveCategory.command): Seed.mutation =>
+  switch command {
+  | ArchiveCategory({categoryId}) =>
+    Seed.mutation(catalog("ArchiveCategory"), [("categoryId", Id(categoryId))])
+  }
+
+let addProduct = (command: CatalogPlugin.AddProduct.command): Seed.mutation =>
+  switch command {
+  | AddProduct({productId, name, description, price, imageUrl, categoryId}) =>
+    Seed.mutation(
+      catalog("AddProduct"),
+      [
+        ("productId", Id(productId)),
+        ("name", String(name)),
+        ("description", String(description)),
+        ("price", Float(price)),
+        ("imageUrl", String(imageUrl)),
+        ("categoryId", Id(categoryId)),
+      ],
+    )
+  }
+
+let changeProductPrice = (command: CatalogPlugin.ChangeProductPrice.command): Seed.mutation =>
+  switch command {
+  | ChangeProductPrice({productId, price}) =>
+    Seed.mutation(
+      catalog("ChangeProductPrice"),
+      [("productId", Id(productId)), ("price", Float(price))],
+    )
+  }
+
+let changeProductDescription = (
+  command: CatalogPlugin.ChangeProductDescription.command,
+): Seed.mutation =>
+  switch command {
+  | ChangeProductDescription({productId, description}) =>
+    Seed.mutation(
+      catalog("ChangeProductDescription"),
+      [("productId", Id(productId)), ("description", String(description))],
+    )
+  }
+
+/** InboundTranslationSlice: the mutation arguments are the external input's
+    fields, not a command payload — the slice translates them itself. */
+let importProduct = (input: CatalogPlugin.ImportProduct.externalInput): Seed.mutation =>
+  Seed.mutation(
+    catalog("ImportProduct"),
+    [
+      ("sku", String(input.sku)),
+      ("title", String(input.title)),
+      ("desc", String(input.desc)),
+      ("unitPrice", Int(input.unitPrice)),
+      ("currency", String(input.currency)),
+      ("category", Id(input.category)),
+    ],
+  )
+
+// ── Ordering ────────────────────────────────────────────────────────────────
+
+let shippingMethod = (method: OrderingPlugin.PlaceOrder.shippingMethod): Seed.value =>
+  switch method {
+  | Standard => Enum("Standard")
+  | Express => Enum("Express")
+  | Pickup => Enum("Pickup")
+  }
+
+let placeOrder = (command: OrderingPlugin.PlaceOrder.command): Seed.mutation =>
+  switch command {
+  | PlaceOrder({orderId, customerId, productIds, shippingMethod: method}) =>
+    Seed.mutation(
+      ordering("PlaceOrder"),
+      [
+        ("orderId", Id(orderId)),
+        ("customerId", Id(customerId)),
+        ("productIds", Seed.ids(productIds)),
+        ("shippingMethod", shippingMethod(method)),
+      ],
+    )
+  }
+
+let shipOrder = (command: OrderingPlugin.ShipOrder.command): Seed.mutation =>
+  switch command {
+  | ShipOrder({orderId}) => Seed.mutation(ordering("ShipOrder"), [("orderId", Id(orderId))])
+  }
+
+/** CancelOrder's ReopenOrder variant is `@noApi`, so it has no mutation field to
+    encode to — reaching it here means the seed tried to drive an internal-only
+    command through the public API. */
+let cancelOrder = (command: OrderingPlugin.CancelOrder.command): Seed.mutation =>
+  switch command {
+  | CancelOrder({orderId}) => Seed.mutation(ordering("CancelOrder"), [("orderId", Id(orderId))])
+  | ReopenOrder(_) =>
+    throw(Seed.Failed("ReopenOrder is @noApi — it cannot be seeded through the GraphQL API"))
+  }
+
+/** Aggregate commands are exposed as `<Plugin>_<Aggregate>_<Variant>` and take
+    the aggregate id alongside the payload. */
+let customer = (~id: string, command: OrderingPlugin.Customer.command): Seed.mutation =>
+  switch command {
+  | Register({email, address}) =>
+    Seed.mutation(
+      ordering("Customer_Register"),
+      [("id", Id(id)), ("email", String(email)), ("address", String(address))],
+    )
+  | UpdateEmail({email}) =>
+    Seed.mutation(ordering("Customer_UpdateEmail"), [("id", Id(id)), ("email", String(email))])
+  | UpdateAddress({address}) =>
+    Seed.mutation(
+      ordering("Customer_UpdateAddress"),
+      [("id", Id(id)), ("address", String(address))],
+    )
+  | SetLocation({location}) =>
+    Seed.mutation(
+      ordering("Customer_SetLocation"),
+      [("id", Id(id)), ("location", Object([("lat", Float(location.lat)), ("lng", Float(location.lng))]))],
+    )
+  | Deactivate => Seed.mutation(ordering("Customer_Deactivate"), [("id", Id(id))])
+  }