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

package/lib/bs/src/HybridSeedData.res.mjs

@@ -0,0 +1,317 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Seed$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed.res.mjs";
+import * as Seed_Client$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Client.res.mjs";
+import * as Seed_Runner$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Runner.res.mjs";
+import * as Seed_Upload$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Upload.res.mjs";
+import * as DemoData$OnlineShopHybridSeed from "./DemoData.res.mjs";
+import * as DemoCommands$OnlineShopHybridSeed from "./DemoCommands.res.mjs";
+
+let views = [
+  {
+    TAG: "Seeded",
+    _0: "Catalog_Categories"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Catalog_Products"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Catalog_ProductDemands"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Catalog_ImportProductAudits"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Ordering_AvailableProducts"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Ordering_Orders"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Ordering_Customers"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Ordering_AutoShipOrderTodos"
+  },
+  {
+    TAG: "Seeded",
+    _0: "Ordering_SendOrderConfirmationTodos"
+  }
+];
+
+async function seedCategories(client) {
+  await Seed_Client$ReventlessSeed.sendAll(client, DemoData$OnlineShopHybridSeed.categories.map(c => DemoCommands$OnlineShopHybridSeed.addCategory({
+    TAG: "AddCategory",
+    categoryId: c.id,
+    name: c.name
+  })));
+  return Seed_Runner$ReventlessSeed.report(`categories: ` + DemoData$OnlineShopHybridSeed.categories.length.toString() + ` added`);
+}
+
+async function uploadProductImages(products, client, uploadEndpoint) {
+  let out = [];
+  for (let i = 0, i_finish = products.length; i < i_finish; ++i) {
+    let p = products[i];
+    if (p !== undefined) {
+      let svg = DemoData$OnlineShopHybridSeed.productSvg(p.name, i);
+      let servedRef = await Seed_Upload$ReventlessSeed.uploadAsset(uploadEndpoint, svg, p.id + `.svg`, "image/svg+xml", Seed_Client$ReventlessSeed.currentToken(client));
+      if (servedRef.TAG === "Ok") {
+        out.push({
+          id: p.id,
+          name: p.name,
+          description: p.description,
+          price: p.price,
+          imageUrl: servedRef._0,
+          categoryId: p.categoryId
+        });
+      } else {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `product image upload for ` + p.id + ` failed: ` + servedRef._0,
+          Error: new Error()
+        };
+      }
+    }
+  }
+  Seed_Runner$ReventlessSeed.report(`product images: ` + out.length.toString() + ` uploaded to the served bucket`);
+  return out;
+}
+
+async function seedProducts(products, client) {
+  await Seed_Client$ReventlessSeed.sendAll(client, products.map(p => DemoCommands$OnlineShopHybridSeed.addProduct({
+    TAG: "AddProduct",
+    productId: p.id,
+    name: p.name,
+    description: p.description,
+    price: p.price,
+    imageUrl: p.imageUrl,
+    categoryId: p.categoryId
+  })));
+  return Seed_Runner$ReventlessSeed.report(`products: ` + products.length.toString() + ` added`);
+}
+
+async function seedCatalogEdits(products, client) {
+  let repriced = DemoData$OnlineShopHybridSeed.repricedProducts(products);
+  await Seed_Client$ReventlessSeed.sendAll(client, repriced.map(p => DemoCommands$OnlineShopHybridSeed.changeProductPrice({
+    TAG: "ChangeProductPrice",
+    productId: p.id,
+    price: DemoData$OnlineShopHybridSeed.discountedPrice(p)
+  })));
+  let redescribed = DemoData$OnlineShopHybridSeed.redescribedProducts(products);
+  await Seed_Client$ReventlessSeed.sendAll(client, redescribed.map(p => DemoCommands$OnlineShopHybridSeed.changeProductDescription({
+    TAG: "ChangeProductDescription",
+    productId: p.id,
+    description: p.description + ` Updated listing copy.`
+  })));
+  await Seed_Client$ReventlessSeed.sendAll(client, [DemoCommands$OnlineShopHybridSeed.renameCategory({
+      TAG: "RenameCategory",
+      categoryId: DemoData$OnlineShopHybridSeed.renamedCategoryId,
+      name: DemoData$OnlineShopHybridSeed.renamedCategoryName
+    })]);
+  let archived = DemoData$OnlineShopHybridSeed.categories.filter(c => c.archive);
+  await Seed_Client$ReventlessSeed.sendAll(client, archived.map(c => DemoCommands$OnlineShopHybridSeed.archiveCategory({
+    TAG: "ArchiveCategory",
+    categoryId: c.id
+  })));
+  return Seed_Runner$ReventlessSeed.report(`catalog edits: ` + repriced.length.toString() + ` repriced, ` + redescribed.length.toString() + ` redescribed, 1 renamed, ` + archived.length.toString() + ` archived`);
+}
+
+async function seedSupplierFeed(client) {
+  for (let i = 0, i_finish = DemoData$OnlineShopHybridSeed.supplierFeed.length; i < i_finish; ++i) {
+    let row = DemoData$OnlineShopHybridSeed.supplierFeed[i];
+    if (row !== undefined) {
+      await Seed_Client$ReventlessSeed.send(client, DemoCommands$OnlineShopHybridSeed.importProduct(row), ["TranslationFailed"]);
+    }
+  }
+  let audits = await Seed_Client$ReventlessSeed.queryAllNodes(client, "Catalog_ImportProductAudits", "status");
+  let countWith = status => audits.filter(a => Primitive_object.equal(Seed_Client$ReventlessSeed.nodeString(a, "status"), status)).length;
+  let successes = countWith("Success");
+  let failures = countWith("Failure");
+  if (successes !== DemoData$OnlineShopHybridSeed.expectedImportSuccesses || failures !== DemoData$OnlineShopHybridSeed.expectedImportFailures) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: `supplier feed: expected ` + DemoData$OnlineShopHybridSeed.expectedImportSuccesses.toString() + ` Success / ` + DemoData$OnlineShopHybridSeed.expectedImportFailures.toString() + ` Failure audit rows, got ` + successes.toString() + `/` + failures.toString(),
+      Error: new Error()
+    };
+  }
+  return Seed_Runner$ReventlessSeed.report(`supplier feed: ` + successes.toString() + ` imported, ` + failures.toString() + ` rejected (both shown in the audit view)`);
+}
+
+async function seedCustomers(customers, client) {
+  await Seed_Client$ReventlessSeed.sendAll(client, customers.map(c => DemoCommands$OnlineShopHybridSeed.customer(c.id, {
+    TAG: "Register",
+    email: c.email,
+    address: c.address
+  })));
+  await Seed_Client$ReventlessSeed.sendAll(client, customers.map(c => DemoCommands$OnlineShopHybridSeed.customer(c.id, {
+    TAG: "SetLocation",
+    location: {
+      lat: c.lat,
+      lng: c.lng
+    }
+  })));
+  let moved = DemoData$OnlineShopHybridSeed.movedCustomers(customers);
+  await Seed_Client$ReventlessSeed.sendAll(client, moved.map(c => DemoCommands$OnlineShopHybridSeed.customer(c.id, {
+    TAG: "UpdateAddress",
+    address: DemoData$OnlineShopHybridSeed.newAddress()
+  })));
+  return Seed_Runner$ReventlessSeed.report(`customers: ` + customers.length.toString() + ` registered, ` + moved.length.toString() + ` moved`);
+}
+
+async function seedOrders(orders, client) {
+  for (let i = 0, i_finish = orders.length; i < i_finish; ++i) {
+    let order = orders[i];
+    if (order !== undefined) {
+      await Seed_Client$ReventlessSeed.send(client, DemoCommands$OnlineShopHybridSeed.placeOrder({
+        TAG: "PlaceOrder",
+        orderId: order.id,
+        customerId: order.customerId,
+        productIds: order.productIds,
+        shippingMethod: order.shippingMethod
+      }), undefined);
+      if ((i + 1 | 0) % 50 === 0) {
+        Seed_Runner$ReventlessSeed.report(`orders: ` + (i + 1 | 0).toString() + `/` + orders.length.toString() + ` placed`);
+      }
+    }
+  }
+  let countMethod = method => orders.filter(o => o.shippingMethod === method).length;
+  return Seed_Runner$ReventlessSeed.report(`orders: ` + orders.length.toString() + ` placed (Standard ` + countMethod("Standard").toString() + `, Express ` + countMethod("Express").toString() + `, Pickup ` + countMethod("Pickup").toString() + `) — Express placements were auto-shipped on arrival`);
+}
+
+async function dispatchStandardBatch(orders, client) {
+  let dispatched = DemoData$OnlineShopHybridSeed.batchDispatched(orders);
+  await Seed_Client$ReventlessSeed.sendAll(client, dispatched.map(o => DemoCommands$OnlineShopHybridSeed.shipOrder({
+    TAG: "ShipOrder",
+    orderId: o.id
+  })));
+  let standardTotal = orders.filter(o => o.shippingMethod === "Standard").length;
+  Seed_Runner$ReventlessSeed.report(`batch dispatch: ` + dispatched.length.toString() + `/` + standardTotal.toString() + ` Standard orders shipped, ` + (standardTotal - dispatched.length | 0).toString() + ` left pending`);
+  return dispatched.map(o => o.id);
+}
+
+async function seedCancellations(orders, client, dispatched) {
+  let cancellable = DemoData$OnlineShopHybridSeed.cancellable(orders, dispatched);
+  let targets = DemoData$OnlineShopHybridSeed.cancelled(cancellable);
+  await Seed_Client$ReventlessSeed.sendAll(client, targets.map(o => DemoCommands$OnlineShopHybridSeed.cancelOrder({
+    TAG: "CancelOrder",
+    orderId: o.id
+  })));
+  return Seed_Runner$ReventlessSeed.report(`cancellations: ` + targets.length.toString() + ` of ` + cancellable.length.toString() + ` cancellable orders cancelled`);
+}
+
+async function seedDeactivations(customers, client) {
+  let targets = DemoData$OnlineShopHybridSeed.deactivatedCustomers(customers);
+  await Seed_Client$ReventlessSeed.sendAll(client, targets.map(c => DemoCommands$OnlineShopHybridSeed.customer(c.id, "Deactivate")));
+  return Seed_Runner$ReventlessSeed.report(`customers: ` + targets.length.toString() + ` deactivated`);
+}
+
+async function summarise(client, counts) {
+  let orders = await Seed_Client$ReventlessSeed.queryAllNodes(client, "Ordering_Orders", "status shippingMethod");
+  let statuses = [
+    "Placed",
+    "Shipped",
+    "Cancelled"
+  ];
+  let methods = [
+    "Standard",
+    "Express",
+    "Pickup"
+  ];
+  let countCell = (status, method) => orders.filter(o => {
+    if (Primitive_object.equal(Seed_Client$ReventlessSeed.nodeString(o, "status"), status)) {
+      return Primitive_object.equal(Seed_Client$ReventlessSeed.nodeString(o, "shippingMethod"), method);
+    } else {
+      return false;
+    }
+  }).length;
+  let countStatus = status => orders.filter(o => Primitive_object.equal(Seed_Client$ReventlessSeed.nodeString(o, "status"), status)).length;
+  let demand = await Seed_Client$ReventlessSeed.queryAllNodes(client, "Catalog_ProductDemands", "name orderCount");
+  let orderCountOf = node => {
+    let match = Seed_Client$ReventlessSeed.field(node, "orderCount");
+    if (typeof match === "number") {
+      return match | 0;
+    } else {
+      return 0;
+    }
+  };
+  let ranked = demand.toSorted((a, b) => Primitive_int.compare(orderCountOf(b), orderCountOf(a)));
+  let withDemand = ranked.filter(n => orderCountOf(n) > 0);
+  let head = ranked.slice(0, 3).map(n => Stdlib_Option.getOr(Seed_Client$ReventlessSeed.nodeString(n, "name"), "?") + ` (` + orderCountOf(n).toString() + `)`).join(", ");
+  Seed_Runner$ReventlessSeed.heading("Seeded:");
+  console.log(`  order status:  ` + statuses.map(s => s + ` ` + countStatus(s).toString()).join(", "));
+  console.log(`  demand head:   ` + head);
+  console.log(`  demand spread: ` + withDemand.length.toString() + `/` + ranked.length.toString() + ` products ordered, tail min ` + Stdlib_Option.mapOr(Stdlib_Array.last(withDemand), 0, orderCountOf).toString());
+  console.log("");
+  console.log("  status × shippingMethod:");
+  console.log(`    ` + " ".padEnd(10, " ") + methods.map(m => m.padStart(10, " ")).join(""));
+  statuses.forEach(status => {
+    console.log(`    ` + status.padEnd(10, " ") + methods.map(m => countCell(status, m).toString().padStart(10, " ")).join(""));
+  });
+  let observedStatuses = statuses.filter(s => countStatus(s) > 0);
+  let spreadWarning = observedStatuses.length < 3 ? [`the board shows only ` + observedStatuses.length.toString() + ` of the 3 order statuses (` + observedStatuses.join(", ") + `) — the shipping-method mix or the batch-dispatch share needs adjusting.`] : [];
+  return Seed_Runner$ReventlessSeed.warn(spreadWarning.concat(Seed_Runner$ReventlessSeed.unfillableWarnings(views, counts)));
+}
+
+async function run(connection, productCount, customerCount, orderCount) {
+  let client = connection.client;
+  let built = DemoData$OnlineShopHybridSeed.buildProducts(productCount, undefined);
+  let products = connection.uploadEndpoint === "" ? (Seed_Runner$ReventlessSeed.report("product images: skipped (no upload endpoint / SEED_SKIP_UPLOADS) — imageUrl left empty"), built) : await uploadProductImages(built, client, connection.uploadEndpoint);
+  let customers = DemoData$OnlineShopHybridSeed.buildCustomers(customerCount, undefined);
+  let orders = DemoData$OnlineShopHybridSeed.buildOrders(products, customers, orderCount, undefined);
+  await seedCategories(client);
+  await seedProducts(products, client);
+  await seedCatalogEdits(products, client);
+  await seedSupplierFeed(client);
+  await seedCustomers(customers, client);
+  let expected = products.map(p => p.id).concat(DemoData$OnlineShopHybridSeed.importedSkus);
+  let available = await Seed_Client$ReventlessSeed.waitForIds(client, "Ordering_AvailableProductsByIds", expected, undefined);
+  Seed_Runner$ReventlessSeed.report(`ordering: ` + available.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$ReventlessSeed.verifyViews(client, views);
+  return await summarise(client, counts);
+}
+
+let dataSets = [
+  {
+    name: "full",
+    label: `full — ` + DemoData$OnlineShopHybridSeed.productCount.toString() + ` products, ` + DemoData$OnlineShopHybridSeed.customerCount.toString() + ` customers, ` + DemoData$OnlineShopHybridSeed.orderCount.toString() + ` orders`,
+    seed: connection => run(connection, DemoData$OnlineShopHybridSeed.productCount, DemoData$OnlineShopHybridSeed.customerCount, DemoData$OnlineShopHybridSeed.orderCount)
+  },
+  {
+    name: "sample",
+    label: "sample — 16 products, 8 customers, 40 orders",
+    seed: connection => run(connection, 16, 8, 40)
+  }
+];
+
+export {
+  views,
+  seedCategories,
+  uploadProductImages,
+  seedProducts,
+  seedCatalogEdits,
+  seedSupplierFeed,
+  seedCustomers,
+  seedOrders,
+  dispatchStandardBatch,
+  seedCancellations,
+  seedDeactivations,
+  summarise,
+  run,
+  dataSets,
+}
+/* dataSets Not a pure module */

package/lib/ocaml/.compiler.log

@@ -0,0 +1,2 @@
+#Start(1785092483130)
+#Done(1785092488026)

package/lib/ocaml/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))])
+  }