@eventcatalog/create-eventcatalog 4.3.12 → 4.3.14-beta.0

package/templates/default/domains/Customer/systems/customer-management-system/services/CustomerAPI/commands/RegisterCustomer/examples/index.mdx

@@ -0,0 +1,168 @@
+<Columns cols={2}>
+
+<Column>
+
+## 1. Register a customer with only the required fields
+
+A shopper signs up at checkout using just an email address and password so they can finish buying a hoodie quickly. The Customer API creates the account and publishes `CustomerRegistered`.
+
+### Payload details
+
+- `email` is the customer's address. It must be unique, so a second registration with the same email is rejected with a `409`.
+- `password` is the initial password and must be at least 8 characters.
+- `name` is optional and is left out here. The customer can add it later with `UpdateCustomer`.
+
+### Using this example
+
+Use this to check that a registration with no `name` succeeds, and that the password is hashed before storage and never logged or echoed back.
+
+The examples use a **fictional Acme Events SDK** to send a payload matching the RegisterCustomer schema. The package names and send methods are illustrative.
+
+</Column>
+
+<Column>
+
+<CodeGroup dropdown>
+
+```typescript send-register-customer.ts
+import { EventsClient } from '@acme/events';
+import type { RegisterCustomer } from './schemas/register-customer';
+
+const client = new EventsClient({
+  apiKey: process.env.ACME_API_KEY!,
+});
+
+const command: RegisterCustomer = {
+  email: 'tom.okafor@example.co.uk',
+  password: 'Hoodie-Season-2026',
+};
+
+await client.send('RegisterCustomer', command);
+```
+
+```python send_register_customer.py
+import os
+from acme_events import EventsClient
+
+client = EventsClient(api_key=os.environ["ACME_API_KEY"])
+
+command = {
+    "email": "tom.okafor@example.co.uk",
+    "password": "Hoodie-Season-2026",
+}
+
+client.send("RegisterCustomer", command)
+```
+
+```java SendRegisterCustomer.java
+import com.acme.events.EventsClient;
+import java.util.Map;
+
+public class SendRegisterCustomer {
+  public static void main(String[] args) {
+    var client = new EventsClient(
+      System.getenv("ACME_API_KEY")
+    );
+
+    var command = Map.of(
+      "email", "tom.okafor@example.co.uk",
+      "password", "Hoodie-Season-2026"
+    );
+
+    client.send("RegisterCustomer", command);
+  }
+}
+```
+
+</CodeGroup>
+
+</Column>
+
+</Columns>
+
+---
+
+<Columns cols={2}>
+
+<Column>
+
+## 2. Register a customer with their full name
+
+A shopper creates an account from the sign-up page and fills in every field, including their name, so it can be used on order confirmations and delivery labels.
+
+### Payload details
+
+- `email` is the customer's unique address, used for sign-in and order emails.
+- `name` is the customer's full name. When supplied it must be at least 1 character.
+- `password` meets the 8-character minimum.
+
+### Using this example
+
+Use this to check that `name` is stored and carried through to the `CustomerRegistered` event, and that registering the same `email` again returns a `409`.
+
+The examples use a **fictional Acme Events SDK** to send a payload matching the RegisterCustomer schema. The package names and send methods are illustrative.
+
+</Column>
+
+<Column>
+
+<CodeGroup dropdown>
+
+```typescript send-register-customer.ts
+import { EventsClient } from '@acme/events';
+import type { RegisterCustomer } from './schemas/register-customer';
+
+const client = new EventsClient({
+  apiKey: process.env.ACME_API_KEY!,
+});
+
+const command: RegisterCustomer = {
+  email: 'amelia.hart@example.com',
+  name: 'Amelia Hart',
+  password: 'Blue-Tshirt-42!',
+};
+
+await client.send('RegisterCustomer', command);
+```
+
+```python send_register_customer.py
+import os
+from acme_events import EventsClient
+
+client = EventsClient(api_key=os.environ["ACME_API_KEY"])
+
+command = {
+    "email": "amelia.hart@example.com",
+    "name": "Amelia Hart",
+    "password": "Blue-Tshirt-42!",
+}
+
+client.send("RegisterCustomer", command)
+```
+
+```java SendRegisterCustomer.java
+import com.acme.events.EventsClient;
+import java.util.Map;
+
+public class SendRegisterCustomer {
+  public static void main(String[] args) {
+    var client = new EventsClient(
+      System.getenv("ACME_API_KEY")
+    );
+
+    var command = Map.of(
+      "email", "amelia.hart@example.com",
+      "name", "Amelia Hart",
+      "password", "Blue-Tshirt-42!"
+    );
+
+    client.send("RegisterCustomer", command);
+  }
+}
+```
+
+</CodeGroup>
+
+</Column>
+
+</Columns>

package/templates/default/domains/Customer/systems/customer-management-system/services/CustomerAPI/commands/UpdateCustomer/examples/index.mdx

@@ -0,0 +1,168 @@
+<Columns cols={2}>
+
+<Column>
+
+## 1. Update a customer's name and email
+
+A customer changes their surname and email address from the account settings page. The Customer API applies the partial update and publishes `CustomerUpdated` with the new values.
+
+### Payload details
+
+- `customerId` identifies the customer to update and is the only required field.
+- `email` and `name` are the new values. Only the fields supplied are changed.
+- `status` is omitted, so the account status stays as it is.
+
+### Using this example
+
+Use this to check that only `email` and `name` change, that the new `email` is still unique, and that the `CustomerUpdated` event lists exactly these two fields in `changes`.
+
+The examples use a **fictional Acme Events SDK** to send a payload matching the UpdateCustomer schema. The package names and send methods are illustrative.
+
+</Column>
+
+<Column>
+
+<CodeGroup dropdown>
+
+```typescript send-update-customer.ts
+import { EventsClient } from '@acme/events';
+import type { UpdateCustomer } from './schemas/update-customer';
+
+const client = new EventsClient({
+  apiKey: process.env.ACME_API_KEY!,
+});
+
+const command: UpdateCustomer = {
+  customerId: '3f2b8c1e-7a4d-4e9b-9c21-5d8e6f0a1b2c',
+  email: 'amelia.hart-jones@example.com',
+  name: 'Amelia Hart-Jones',
+};
+
+await client.send('UpdateCustomer', command);
+```
+
+```python send_update_customer.py
+import os
+from acme_events import EventsClient
+
+client = EventsClient(api_key=os.environ["ACME_API_KEY"])
+
+command = {
+    "customerId": "3f2b8c1e-7a4d-4e9b-9c21-5d8e6f0a1b2c",
+    "email": "amelia.hart-jones@example.com",
+    "name": "Amelia Hart-Jones",
+}
+
+client.send("UpdateCustomer", command)
+```
+
+```java SendUpdateCustomer.java
+import com.acme.events.EventsClient;
+import java.util.Map;
+
+public class SendUpdateCustomer {
+  public static void main(String[] args) {
+    var client = new EventsClient(
+      System.getenv("ACME_API_KEY")
+    );
+
+    var command = Map.of(
+      "customerId", "3f2b8c1e-7a4d-4e9b-9c21-5d8e6f0a1b2c",
+      "email", "amelia.hart-jones@example.com",
+      "name", "Amelia Hart-Jones"
+    );
+
+    client.send("UpdateCustomer", command);
+  }
+}
+```
+
+</CodeGroup>
+
+</Column>
+
+</Columns>
+
+---
+
+<Columns cols={2}>
+
+<Column>
+
+## 2. Suspend a customer's account
+
+The fraud team suspends an account after a chargeback on a cap order. Only the status changes, so the command carries just the customer ID and the new status.
+
+### Payload details
+
+- `customerId` identifies the account to suspend.
+- `status` is `SUSPENDED`. The other allowed values are `ACTIVE` and `CLOSED`.
+- `email` and `name` are omitted, so they stay unchanged.
+
+### Using this example
+
+Use this to check that a status-only update leaves the profile fields untouched and that the customer can no longer check out while `SUSPENDED`.
+
+The examples use a **fictional Acme Events SDK** to send a payload matching the UpdateCustomer schema. The package names and send methods are illustrative.
+
+</Column>
+
+<Column>
+
+<CodeGroup dropdown>
+
+```typescript send-update-customer.ts
+import { EventsClient } from '@acme/events';
+import type { UpdateCustomer } from './schemas/update-customer';
+
+const client = new EventsClient({
+  apiKey: process.env.ACME_API_KEY!,
+});
+
+const command: UpdateCustomer = {
+  customerId: 'c9a4e2f7-1b3d-4c8e-a5f6-7d2e9b0c4a13',
+  status: 'SUSPENDED',
+};
+
+await client.send('UpdateCustomer', command);
+```
+
+```python send_update_customer.py
+import os
+from acme_events import EventsClient
+
+client = EventsClient(api_key=os.environ["ACME_API_KEY"])
+
+command = {
+    "customerId": "c9a4e2f7-1b3d-4c8e-a5f6-7d2e9b0c4a13",
+    "status": "SUSPENDED",
+}
+
+client.send("UpdateCustomer", command)
+```
+
+```java SendUpdateCustomer.java
+import com.acme.events.EventsClient;
+import java.util.Map;
+
+public class SendUpdateCustomer {
+  public static void main(String[] args) {
+    var client = new EventsClient(
+      System.getenv("ACME_API_KEY")
+    );
+
+    var command = Map.of(
+      "customerId", "c9a4e2f7-1b3d-4c8e-a5f6-7d2e9b0c4a13",
+      "status", "SUSPENDED"
+    );
+
+    client.send("UpdateCustomer", command);
+  }
+}
+```
+
+</CodeGroup>
+
+</Column>
+
+</Columns>

package/templates/default/domains/Customer/systems/customer-management-system/services/CustomerAPI/events/CustomerRegistered/examples/index.mdx

@@ -0,0 +1,201 @@
+<Columns cols={2}>
+
+<Column>
+
+## 1. Publish a registration with the customer's name
+
+A shopper has signed up from the sign-up page with their full name. The Customer API publishes this event so downstream systems can onboard them, for example by sending a welcome email with a first-order discount.
+
+### Payload details
+
+- `eventId` is a unique UUID for this event, used by consumers to ignore duplicates.
+- `occurredAt` is the ISO-8601 UTC time the customer registered.
+- `customer.customerId` is the new customer's UUID, and `customer.email` is their sign-in address.
+- `customer.name` is included because the customer supplied it at sign-up.
+- `customer.status` is `ACTIVE`, the normal status for a newly registered account.
+
+### Using this example
+
+Use this to check that consumers create their own customer record keyed on `customer.customerId`, and that replaying the same `eventId` does not send a second welcome email.
+
+The examples use a **fictional Acme Events SDK** to publish a payload matching the CustomerRegistered schema. The package names and publish methods are illustrative.
+
+</Column>
+
+<Column>
+
+<CodeGroup dropdown>
+
+```typescript publish-customer-registered.ts
+import { EventsClient } from '@acme/events';
+import type { CustomerRegistered } from './schemas/customer-registered';
+
+const client = new EventsClient({
+  apiKey: process.env.ACME_API_KEY!,
+});
+
+const event: CustomerRegistered = {
+  eventId: '5e7d1a90-2c4b-4f3e-8a6d-1b9c0e2f4a57',
+  occurredAt: '2026-03-14T10:22:05Z',
+  customer: {
+    customerId: '3f2b8c1e-7a4d-4e9b-9c21-5d8e6f0a1b2c',
+    email: 'amelia.hart@example.com',
+    name: 'Amelia Hart',
+    status: 'ACTIVE',
+  },
+};
+
+await client.publish('CustomerRegistered', event);
+```
+
+```python publish_customer_registered.py
+import os
+from acme_events import EventsClient
+
+client = EventsClient(api_key=os.environ["ACME_API_KEY"])
+
+event = {
+    "eventId": "5e7d1a90-2c4b-4f3e-8a6d-1b9c0e2f4a57",
+    "occurredAt": "2026-03-14T10:22:05Z",
+    "customer": {
+        "customerId": "3f2b8c1e-7a4d-4e9b-9c21-5d8e6f0a1b2c",
+        "email": "amelia.hart@example.com",
+        "name": "Amelia Hart",
+        "status": "ACTIVE",
+    },
+}
+
+client.publish("CustomerRegistered", event)
+```
+
+```java PublishCustomerRegistered.java
+import com.acme.events.EventsClient;
+import java.util.Map;
+
+public class PublishCustomerRegistered {
+  public static void main(String[] args) {
+    var client = new EventsClient(
+      System.getenv("ACME_API_KEY")
+    );
+
+    var event = Map.of(
+      "eventId", "5e7d1a90-2c4b-4f3e-8a6d-1b9c0e2f4a57",
+      "occurredAt", "2026-03-14T10:22:05Z",
+      "customer", Map.of(
+        "customerId", "3f2b8c1e-7a4d-4e9b-9c21-5d8e6f0a1b2c",
+        "email", "amelia.hart@example.com",
+        "name", "Amelia Hart",
+        "status", "ACTIVE"
+      )
+    );
+
+    client.publish("CustomerRegistered", event);
+  }
+}
+```
+
+</CodeGroup>
+
+</Column>
+
+</Columns>
+
+---
+
+<Columns cols={2}>
+
+<Column>
+
+## 2. Publish a registration without a name
+
+A shopper registered at checkout with only an email address and password, so the event carries no name. Consumers must handle this case, for example by greeting the customer without a first name.
+
+### Payload details
+
+- `eventId` and `occurredAt` identify this event and when the registration happened.
+- `customer` contains only the required fields: `customerId`, `email` and `status`.
+- `customer.name` is omitted because the customer did not provide one.
+- `customer.status` is `ACTIVE`.
+
+### Using this example
+
+Use this to check that consumers do not fail when `customer.name` is missing, and that any welcome email falls back to a generic greeting.
+
+The examples use a **fictional Acme Events SDK** to publish a payload matching the CustomerRegistered schema. The package names and publish methods are illustrative.
+
+</Column>
+
+<Column>
+
+<CodeGroup dropdown>
+
+```typescript publish-customer-registered.ts
+import { EventsClient } from '@acme/events';
+import type { CustomerRegistered } from './schemas/customer-registered';
+
+const client = new EventsClient({
+  apiKey: process.env.ACME_API_KEY!,
+});
+
+const event: CustomerRegistered = {
+  eventId: 'a1c3e5f7-9b2d-4a6c-8e0f-2d4b6a8c0e13',
+  occurredAt: '2026-09-02T18:47:31Z',
+  customer: {
+    customerId: 'c9a4e2f7-1b3d-4c8e-a5f6-7d2e9b0c4a13',
+    email: 'tom.okafor@example.co.uk',
+    status: 'ACTIVE',
+  },
+};
+
+await client.publish('CustomerRegistered', event);
+```
+
+```python publish_customer_registered.py
+import os
+from acme_events import EventsClient
+
+client = EventsClient(api_key=os.environ["ACME_API_KEY"])
+
+event = {
+    "eventId": "a1c3e5f7-9b2d-4a6c-8e0f-2d4b6a8c0e13",
+    "occurredAt": "2026-09-02T18:47:31Z",
+    "customer": {
+        "customerId": "c9a4e2f7-1b3d-4c8e-a5f6-7d2e9b0c4a13",
+        "email": "tom.okafor@example.co.uk",
+        "status": "ACTIVE",
+    },
+}
+
+client.publish("CustomerRegistered", event)
+```
+
+```java PublishCustomerRegistered.java
+import com.acme.events.EventsClient;
+import java.util.Map;
+
+public class PublishCustomerRegistered {
+  public static void main(String[] args) {
+    var client = new EventsClient(
+      System.getenv("ACME_API_KEY")
+    );
+
+    var event = Map.of(
+      "eventId", "a1c3e5f7-9b2d-4a6c-8e0f-2d4b6a8c0e13",
+      "occurredAt", "2026-09-02T18:47:31Z",
+      "customer", Map.of(
+        "customerId", "c9a4e2f7-1b3d-4c8e-a5f6-7d2e9b0c4a13",
+        "email", "tom.okafor@example.co.uk",
+        "status", "ACTIVE"
+      )
+    );
+
+    client.publish("CustomerRegistered", event);
+  }
+}
+```
+
+</CodeGroup>
+
+</Column>
+
+</Columns>