### Install Prisma Adapter and Dependencies

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-prisma/readme.md

Installs the `@schemeless/event-store-adapter-prisma` package, `@prisma/client`, and `prisma` development dependency using Yarn.

```bash
yarn add @schemeless/event-store-adapter-prisma @prisma/client
yarn add -D prisma
```

--------------------------------

### Install TypeORM Event Store Adapter

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-typeorm/readme.md

Installs the @schemeless/event-store-adapter-typeorm package and TypeORM. Database drivers like sqlite3, mysql2, or pg must also be installed as peer dependencies.

```bash
yarn add @schemeless/event-store-adapter-typeorm typeorm
```

--------------------------------

### Install MikroORM Adapter and Dependencies

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-mikroorm/README.md

Installs the @schemeless/event-store, its MikroORM adapter, types, and the MikroORM core with a specific SQL driver. Replace the SQL driver with the one appropriate for your database.

```bash
yarn add @schemeless/event-store @schemeless/event-store-adapter-mikroorm @schemeless/event-store-types @mikro-orm/core @mikro-orm/postgresql
```

--------------------------------

### Install Project Dependencies with Yarn

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Installs all necessary project dependencies using Yarn. This command is typically the first step in setting up the project environment.

```bash
yarn install
```

--------------------------------

### Initialize Event Store with Example Domain

Source: https://github.com/schemeless/event-store/blob/master/examples/example-domain-pacakges/readme.md

This snippet demonstrates how to initialize the event store by importing all necessary event flows and feature entities from the example domain. It sets up a TypeORM repository using an in-memory SQLite database and builds the event store instance.

```typescript
import { allEventFlows, featureEntities } from '@schemeless/example-domain';
import { makeEventStore } from '@schemeless/event-store';
import { EventStoreRepo as TypeOrmRepo } from '@schemeless/event-store-adapter-typeorm';

const repo = new TypeOrmRepo({ type: 'sqlite', database: ':memory:' });
const buildStore = makeEventStore(repo);
const eventStore = await buildStore(allEventFlows);

```

--------------------------------

### Install @schemeless/event-store-adapter-dynamodb

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-dynamodb/readme.md

Installs the necessary packages for the DynamoDB event store adapter, including the adapter itself, AWS Data Mapper, and AWS SDK.

```bash
yarn add @schemeless/event-store-adapter-dynamodb @aws/dynamodb-data-mapper @aws/dynamodb-data-mapper-annotations aws-sdk
```

--------------------------------

### Basic Usage with MikroORM

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-mikroorm/README.md

Shows how to initialize MikroORM, create an EventStoreRepo instance with the EntityManager, and then use it to build and interact with an event store. This example demonstrates storing and replaying events.

```typescript
import { makeEventStore } from '@schemeless/event-store';
import { MikroORM } from '@mikro-orm/core';
import { EventStoreEntity, EventStoreRepo } from '@schemeless/event-store-adapter-mikroorm';

const orm = await MikroORM.init({
  type: 'postgresql',
  clientUrl: process.env.DATABASE_URL,
  entities: [EventStoreEntity],
});

const repo = new EventStoreRepo(orm.em);

const buildEventStore = makeEventStore(repo);
const eventStore = await buildEventStore([
  /* your event flows */
]);

// store events as usual
const [created] = await eventStore.receive(userRegisteredFlow)({
  payload: { id: 'user-123', email: 'user@example.com' },
});

// replay later if you need projections or observers to catch up
await eventStore.replay();
```

--------------------------------

### Install WatermelonDB Dependencies

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-watermelondb/readme.md

Installs required WatermelonDB, React, and React Native dependencies. These are expected to be provided by the host application.

```bash
yarn add @nozbe/watermelondb react react-native
```

--------------------------------

### Testing with In-Memory SQLite Database

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-mikroorm/README.md

Provides an example of setting up an in-memory SQLite database with MikroORM for testing purposes. It demonstrates initializing MikroORM, creating the schema, and instantiating the EventStoreRepo with the entity manager.

```typescript
import { MikroORM } from '@mikro-orm/core';
import { SqliteDriver } from '@mikro-orm/sqlite';
import { EventStoreEntity, EventStoreRepo } from '@schemeless/event-store-adapter-mikroorm';

const orm = await MikroORM.init({
  driver: SqliteDriver,
  dbName: ':memory:',
  entities: [EventStoreEntity],
});
await orm.getSchemaGenerator().createSchema();

const repo = new EventStoreRepo(orm.em);
```

--------------------------------

### Install @schemeless/event-store-adapter-watermelondb

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-watermelondb/readme.md

Installs the @schemeless/event-store-adapter-watermelondb package using Yarn. This package provides the persistence layer for @schemeless/event-store-react-native.

```bash
yarn add @schemeless/event-store-adapter-watermelondb
```

--------------------------------

### Bootstrap Project Packages with Yarn Lerna

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Bootstraps the project's packages using Yarn and Lerna. This command installs dependencies and runs prepublish scripts for each workspace, preparing them for local development.

```bash
yarn bootstrap
```

--------------------------------

### Install @schemeless/dynamodb-orm

Source: https://github.com/schemeless/event-store/blob/master/packages/dynamodb-orm/readme.md

Installs the dynamodb-orm package along with its required dependencies, aws-sdk and dynamodb-data-mapper. The aws-sdk is a peer dependency allowing control over credentials and region.

```bash
yarn add @schemeless/dynamodb-orm @aws/dynamodb-data-mapper aws-sdk
```

--------------------------------

### Install Null Event Store Adapter

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-null/readme.md

Installs the null event store adapter using Yarn. This package provides a no-op implementation of IEventStoreRepo for testing purposes.

```bash
yarn add @schemeless/event-store-adapter-null
```

--------------------------------

### Usage Example: Null Event Store Adapter

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-null/readme.md

Demonstrates how to use the NullRepo with @schemeless/event-store. It shows initializing the repository, creating an event store, and receiving an event, all within a testable, non-persisted context.

```typescript
import { EventStoreRepo as NullRepo } from '@schemeless/event-store-adapter-null';
import { makeEventStore } from '@schemeless/event-store';

const repo = new NullRepo();
const eventStore = await makeEventStore(repo)(eventFlows);

await eventStore.receive(flow)({ payload: { /* ... */ } });
```

--------------------------------

### Polyfill crypto.getRandomValues for React Native

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-react-native/readme.md

Shows how to install and import the react-native-get-random-values package to polyfill crypto.getRandomValues, which is required by some libraries like uuid in React Native apps.

```sh
npm install react-native-get-random-values
npx pod-install
```

```javascript
import 'react-native-get-random-values';
```

--------------------------------

### Update EventStoreRepo Instantiation (NestJS Example)

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-mikroorm/README.md

Demonstrates how to update the EventStoreRepo provider in a NestJS application to inject and pass the EntityManager instance to the constructor, as required from v2.5.0 onwards. This replaces the previous method of passing MikroORM options.

```typescript
// In your event-store.module.ts
import { EntityManager } from '@mikro-orm/core';
import { EventStoreRepo } from '@schemeless/event-store-adapter-mikroorm';

const eventStoreRepoProvider = {
  provide: EventStoreRepo,
  useFactory: (em: EntityManager) => new EventStoreRepo(em), // <-- Pass the EntityManager
  inject: [EntityManager], // <-- Inject the default EntityManager from NestJS DI
};
```

--------------------------------

### Update MikroORM Configuration (NestJS Example)

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-mikroorm/README.md

Adds the EventStoreEntity to your MikroORM configuration in your NestJS application. This is necessary for the adapter to manage the event store's database schema. If using a separate database for events, configure it as a second connection.

```typescript
// in your app.module.ts or mikro-orm.config.ts
import { EventStoreEntity } from '@schemeless/event-store-adapter-mikroorm';
import { YourOtherEntity } from './entities';

MikroOrmModule.forRoot({
  // ... your main database configuration
  entities: [YourOtherEntity, EventStoreEntity], // <-- Add EventStoreEntity here
}),
```

--------------------------------

### Initialize Event Store with Prisma Adapter

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-prisma/readme.md

Demonstrates setting up an event store using the Prisma adapter. It initializes a PrismaClient, creates an EventStoreRepo instance, initializes the repository, and then creates the event store.

```typescript
import { PrismaClient } from '@prisma/client';
import { makeEventStore } from '@schemeless/event-store';
import { EventStoreRepo } from '@schemeless/event-store-adapter-prisma';

const prisma = new PrismaClient();
const repo = new EventStoreRepo(prisma);

await repo.init(); // ensures the Prisma client is connected

const eventStore = await makeEventStore({
  repo,
});

// Store new events through the Event Store APIs as usual
```

--------------------------------

### Initialize Event Store with WatermelonDB Repository

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-watermelondb/readme.md

Shows how to initialize the event store using the `EventStoreRepo` with a WatermelonDB instance. It then creates an event store instance and demonstrates receiving an event.

```typescript
import { appSchema, Database } from '@nozbe/watermelondb';
import SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite';
import { makeEventStore } from '@schemeless/event-store-react-native';
import { EventStoreRepo, eventStoreSchema } from '@schemeless/event-store-adapter-watermelondb';
import { eventFlows } from './eventFlows';

const schema = appSchema({
  version: 1,
  tables: [eventStoreSchema],
});

const adapter = new SQLiteAdapter({ schema });
const database = new Database({
  adapter,
  modelClasses: [],
});

const repo = new EventStoreRepo(database);
await repo.init(); // no-op but kept for interface symmetry

const eventStore = await makeEventStore(repo)(eventFlows);

await eventStore.receive(eventFlows.userRegistered)({
  payload: { id: 'user-123', email: 'user@example.com' },
});
```

--------------------------------

### Publish Package with npm

Source: https://github.com/schemeless/event-store/blob/master/AGENT.md

Publishes a package to the npm registry. Requires a two-factor authentication code. The OTP should only be reused once per npm prompt. Execute this command from within the package directory.

```bash
npm publish --otp <two-factor-code>
```

--------------------------------

### Prepare Distribution Builds with Yarn

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Prepares distribution builds for all packages using Yarn. This command runs the prepublish script for each package, compiling TypeScript sources into 'dist' directories.

```bash
yarn prepare
```

--------------------------------

### Initialize TypeORM Event Store Adapter in TypeScript

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-typeorm/readme.md

Demonstrates how to import and initialize the TypeORM repository and the event store. The repository requires connection options for the database. The event store is then created using the repository and event handlers.

```typescript
import { EventStoreRepo as TypeOrmRepo } from '@schemeless/event-store-adapter-typeorm';
import { makeEventStore } from '@schemeless/event-store';

const repo = new TypeOrmRepo({
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  username: 'postgres',
  password: 'postgres',
  database: 'event_store',
});

const eventStore = await makeEventStore(repo)(eventFlows, successObservers);

```

--------------------------------

### Compile Package Artifacts with Yarn

Source: https://github.com/schemeless/event-store/blob/master/AGENT.md

Builds package artifacts, specifically refreshing the `dist/` directory, before publishing. Replace `<package-name>` with the actual name of the package to be compiled.

```bash
yarn workspace <package-name> run compile
```

--------------------------------

### Compile and Test @schemeless/event-store-react-native

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-react-native/readme.md

Provides commands to compile and run tests for the @schemeless/event-store-react-native package within a monorepo development environment.

```bash
yarn workspace @schemeless/event-store-react-native compile
```

```bash
yarn workspace @schemeless/event-store-react-native test
```

--------------------------------

### Initialize Event Store with Custom Event Flows (TypeScript)

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Demonstrates how to initialize the Schemeless Event Store in TypeScript. It involves defining event flows, setting up a repository (e.g., TypeORM with SQLite), building the event store, and receiving an event.

```typescript
import { makeEventStore } from '@schemeless/event-store';
import { EventStoreRepo as TypeOrmRepo } from '@schemeless/event-store-adapter-typeorm';

const eventFlows = [userRegisteredFlow, userEmailVerifiedFlow];
const repo = new TypeOrmRepo({ type: 'sqlite', database: ':memory:' });
const buildEventStore = makeEventStore(repo);
const eventStore = await buildEventStore(eventFlows);

const [created] = await eventStore.receive(userRegisteredFlow)({
  payload: { id: '123', email: 'user@example.com' },
});
```

--------------------------------

### Generate Prisma Client

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-prisma/readme.md

Generates the Prisma Client, which is required by the adapter to include the `eventStoreEntity` model.

```bash
npx prisma generate
```

--------------------------------

### Initialize Event Store with DynamoDB Adapter

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-dynamodb/readme.md

Demonstrates how to initialize the event store with the DynamoDB adapter. It configures DynamoDB and S3 clients, instantiates the repository with specific settings like table name prefix and S3 bucket, and then builds and initializes the event store.

```typescript
import { DynamoDB, S3 } from 'aws-sdk';
import { EventStoreRepo as EventStoreDynamoRepo } from '@schemeless/event-store-adapter-dynamodb';
import { makeEventStore } from '@schemeless/event-store';

const dynamodb = new DynamoDB({ region: 'us-east-1' });
const s3 = new S3({ region: 'us-east-1' });

const repo = new EventStoreDynamoRepo(dynamodb, s3, {
  tableNamePrefix: 'prod-',
  s3BucketName: 'my-event-archive',
  eventStoreTableReadCapacityUnits: 20,
  eventStoreTableWriteCapacityUnits: 10,
});

const buildStore = makeEventStore(repo);
const eventStore = await buildStore(eventFlows);
```

--------------------------------

### Event Store Runtime Initialization (TypeScript)

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Initializes the core event store runtime, setting up queues for deterministic processing. It coordinates a main queue, a side effect queue with retry semantics, and observer queues.

```typescript
import { makeEventStore } from '@schemeless/event-store';
import { makeMainQueue } from '@schemeless/event-store/src/queue/makeMainQueue';
import { makeSideEffectQueue } from '@schemeless/event-store/src/queue/makeSideEffectQueue';

async function initializeEventStore() {
  const mainQueue = makeMainQueue();
  const sideEffectQueue = makeSideEffectQueue();

  const eventStore = makeEventStore({
    mainQueue,
    sideEffectQueue,
    // ... other configurations like repo, eventHandlers
  });

  // Start processing queues
  await mainQueue.start();
  await sideEffectQueue.start();

  return eventStore;
}

```

--------------------------------

### Run Lerna-Specific Tests with Yarn

Source: https://github.com/schemeless/event-store/blob/master/AGENT.md

Optionally runs package-specific scripts using Lerna, useful for exercising individual package functionalities. This command complements the main `yarn test` command.

```bash
yarn lerna-test
```

--------------------------------

### Build Event Store with TypeORM Adapter in TypeScript

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store/readme.md

Builds an event store using the TypeORM adapter and a defined event flow. It demonstrates how to initialize the repository, create the store, receive an event, and wait for side effects to complete. This is a key part of setting up the event processing pipeline.

```typescript
import { makeEventStore, sideEffectFinishedPromise } from '@schemeless/event-store';
import { EventStoreRepo as TypeOrmRepo } from '@schemeless/event-store-adapter-typeorm';

const repo = new TypeOrmRepo({ type: 'sqlite', database: ':memory:' });
const buildStore = makeEventStore(repo);

const eventStore = await buildStore([userRegisteredFlow]);

const [created] = await eventStore.receive(userRegisteredFlow)({
  payload: { id: '123', email: 'user@example.com' },
});

await sideEffectFinishedPromise(eventStore); // Wait until the side-effect queue drains.
```

--------------------------------

### Implement Event Store Repository Interface

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-types/readme.md

Shows how to implement the `IEventStoreRepo` interface from '@schemeless/event-store-types' to create a custom event store persistence layer. This includes methods for initialization, retrieving all events, creating event entities, storing events, and resetting the store.

```typescript
import { IEventStoreRepo } from '@schemeless/event-store-types';

class CustomRepo implements IEventStoreRepo {
  async init() {}
  async getAllEvents(pageSize: number) {
    // return an async iterator of stored events
  }
  createEventEntity(event) {
    return event;
  }
  async storeEvents(events) {}
  async resetStore() {}
}
```

--------------------------------

### Run Jest Tests with Yarn

Source: https://github.com/schemeless/event-store/blob/master/AGENT.md

Executes the Jest test suite across the monorepo to verify changes to TypeScript, JavaScript, or runtime configuration. Ensure Yarn (classic v1) is used for dependency management.

```bash
yarn test
```

--------------------------------

### Define Event Primitives with TypeScript

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-types/readme.md

Demonstrates the usage of `BaseEventInput` and `EventFlow` from '@schemeless/event-store-types' to define event structures and flow logic. `BaseEventInput` defines the payload shape, while `EventFlow` outlines the domain, type, and reception logic for events.

```typescript
import { BaseEventInput, CreatedEvent, EventFlow } from '@schemeless/event-store-types';

const draft: BaseEventInput<{ id: string }> = {
  payload: { id: '123' },
};

const eventFlow: EventFlow = {
  domain: 'user',
  type: 'registered',
  receive: (eventStore) => eventStore.receive(eventFlow),
};
```

--------------------------------

### Add Observer and Replay Event Store in TypeScript

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store/readme.md

Registers a console logging observer for user registration events and then replays the event store. This allows for reacting to committed events and rebuilding projections by re-applying historical data.

```typescript
const logObserver = {
  filters: [{ domain: 'user', type: 'registered' }],
  priority: 100,
  apply: async (event) => {
    console.log('User registered:', event.payload.email);
  },
};

const eventStore = await buildStore([userRegisteredFlow], [logObserver]);
await eventStore.replay();
```

--------------------------------

### Import Event Store for React Native

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-react-native/readme.md

Demonstrates how to import the makeEventStore function from the @schemeless/event-store-react-native package for use in a React Native application.

```typescript
import { makeEventStore } from '@schemeless/event-store-react-native';
```

--------------------------------

### Define Event Store Schema with WatermelonDB

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-watermelondb/readme.md

Demonstrates how to compose the `eventStoreSchema` into a WatermelonDB database schema. This defines the 'events' table structure for storing domain events.

```typescript
import { appSchema, Database } from '@nozbe/watermelondb';
import SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite';
import { eventStoreSchema } from '@schemeless/event-store-adapter-watermelondb';

const schema = appSchema({
  version: 1,
  tables: [eventStoreSchema],
});

const adapter = new SQLiteAdapter({ schema });
const database = new Database({ adapter, modelClasses: [] });
```

--------------------------------

### Replay Functionality (TypeScript)

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Enables replaying historical events through event flows. This is crucial for ensuring projections and observers remain consistent with the event history, using an `IEventStoreRepo` implementation.

```typescript
import { makeReplay } from '@schemeless/event-store/src/makeReplay';
import { IEventStoreRepo } from '@schemeless/event-store-types/src/Repo.types';

async function replayEvents(repo: IEventStoreRepo, eventHandlers: any) {
  const replay = makeReplay(repo, eventHandlers);
  await replay.execute();
}

```

--------------------------------

### Create and Use DynamoDB Manager with @schemeless/dynamodb-orm

Source: https://github.com/schemeless/event-store/blob/master/packages/dynamodb-orm/readme.md

Creates a function to generate a cached DynamoDB manager using makeGetDynamoDbManager. This manager lazily initializes repositories, ensures table existence, and caches instances for reuse, simplifying event saving operations.

```typescript
import { DynamoDB } from 'aws-sdk';
import { makeGetDynamoDbManager } from '@schemeless/dynamodb-orm';

const getManager = makeGetDynamoDbManager('dev-', { region: 'us-east-1' });

async function saveEvent(event: UserEvent) {
  const manager = await getManager(UserEvent);
  await manager.repo.put(event);
}
```

--------------------------------

### Define a User Registration Event Flow in TypeScript

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store/readme.md

Defines an event flow for user registration. It includes validation to ensure an email is present and an apply function for updating projections. This flow is a core component of the @schemeless/event-store.

```typescript
import { EventFlow } from '@schemeless/event-store';

export const userRegisteredFlow: EventFlow = {
  domain: 'user',
  type: 'registered',
  receive: (eventStore) => async (eventInput) =>
    eventStore.receive(userRegisteredFlow)(eventInput),
  validate: async (event) => {
    if (!event.payload.email) {
      throw new Error('email is required');
    }
  },
  apply: async (event) => {
    // Update projections, write to read models, etc.
  },
};
```

--------------------------------

### Event Flow Definitions (TypeScript)

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Defines the structure and types for event flows in Schemeless Event Store. This includes types for event creation, validation, and lifecycle hooks. It serves as the blueprint for authoring event logic.

```typescript
export interface IEventStoreTypes {
  root: IRootEvent;
  // ... other event types
}

export type EventFlowHandler<TRootEvent extends IRootEvent = IRootEvent> = {
  receive?: (rawInput: any) => Promise<TRootEvent | TRootEvent[]> | TRootEvent | TRootEvent[];
  validate?: (event: TRootEvent) => Promise<void> | void;
  preApply?: (event: TRootEvent) => Promise<TRootEvent> | TRootEvent;
  apply?: (event: TRootEvent) => Promise<void> | void;
  sideEffect?: (event: TRootEvent) => Promise<void> | void;
  createConsequentEvents?: (event: TRootEvent) => Promise<TRootEvent | TRootEvent[]> | TRootEvent | TRootEvent[];
};

interface IRootEvent {
  id: string;
  type: string;
  streamId: string;
  streamType: string;
  timestamp: number;
  meta?: Record<string, any>;
  payload: any;
  correlationId?: string;
  causationId?: string;
}

```

--------------------------------

### Reset Event Store with WatermelonDB

Source: https://github.com/schemeless/event-store/blob/master/packages/event-store-adapter-watermelondb/readme.md

Demonstrates how to reset the event store, purging all locally stored events. This is useful for scenarios like user logout.

```typescript
await repo.resetStore();
```

--------------------------------

### Define DynamoDB Entity with @schemeless/dynamodb-orm

Source: https://github.com/schemeless/event-store/blob/master/packages/dynamodb-orm/readme.md

Defines a DynamoDB entity class using AWS Data Mapper annotations and the @schemeless/dynamodb-orm repo decorator. The repo decorator specifies table name and creation options, while DateType handles ISO string persistence for date attributes.

```typescript
import { attribute, hashKey, table } from '@aws-sdk/dynamodb-data-mapper-annotations';
import { repo, DateType } from '@schemeless/dynamodb-orm';

@table('user-events')
@repo('user-events', {
  readCapacityUnits: 5,
  writeCapacityUnits: 5,
})
class UserEvent {
  @hashKey()
  id!: string;

  @attribute(DateType)
  created!: Date;

  @attribute()
  payload!: Record<string, unknown>;
}
```

--------------------------------

### Default Event Creator (TypeScript)

Source: https://github.com/schemeless/event-store/blob/master/readme.md

Assigns ULID-based identifiers, correlation IDs, and causation IDs to events. This ensures traceability for downstream consumers.

```typescript
import { createDefaultEvent } from '@schemeless/event-store/src/operators/defaultEventCreator';
import { ulid } from '@schemeless/event-store/src/util/ulid';

// Example usage within an event flow's receive hook
async function receiveHandler(rawInput: any) {
  const baseEvent = {
    streamId: 'some-stream-id',
    streamType: 'some-stream-type',
    type: 'SOME_EVENT',
    payload: rawInput.data,
    correlationId: 'initial-correlation-id',
    causationId: ulid(),
  };
  return createDefaultEvent(baseEvent);
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.