Manifest builder

Pick a store kind, name the tables or streams and the columns or paths, say which of your types play which part, and copy the statelens.json for the zip. Every word here is one What to put in a zip explains, and each preset is one of the example manifests, so a store one of those frameworks wrote is a few names away. A zip may carry several services: add one for each, and start each from whichever example fits it. Nothing you type leaves the browser.

Orders

Start from

1 Service

What the tool loads, and the name it browses the service under.

Name Connection string name

Description Who may read it, comma separated Assemblies, one per line Dynamic consistency boundary, Memoria's own tables

2 Domain

Which of your types play which part, how their stored names are made, and how a model is rebuilt.

Parts

Each part is a list of selectors; a type plays the part when any one of them picks it.

Streams

Picked by Type, by full name

Events

Picked by Namespace

Aggregates

A model, and the types that address it

Picked by Type, by full name Addressed by Identifier, by full name

Projections

A model, and the types that address it

No selector yet; the part is empty.

Naming

How each part's stored name is made from the type, so a row's type column meets the type that opens it.

Events

Aggregates

Labels

What your domain calls its models, when not aggregates and projections; the pages take the word.

Aggregates, one Aggregates, many

Fold

How a model is rebuilt from its events for the compare tab.

Apply methods, comma separated Version property Applies property

Wrapped events, as Marten's apply methods take them

Wrapper type Property filled from the sequence Property filled from the key Property filled from when it was written Property filled from the stream

Reading

How a payload is read back, and what the state tab leaves out.

Serializer Hidden properties, comma separated

Identifier types, as Memoria's are read back

Value property Claim property Key separator

3 Store

Where the events are, and where the snapshots are kept, if any.

Kind

Events

The one source every event is read from.

Read from Table Where

Columns

Stream id Sequence Type Payload Written Written by Id Metadata

Snapshots

Each place a folded model is kept. A store that keeps none says nothing of them.

statelens.json

Download

{
  "services": [
    {
      "name": "Orders",
      "assemblies": [
        "Contoso.Orders.Domain.dll"
      ],
      "connectionString": "Orders",
      "domain": {
        "streams": [
          {
            "type": "Contoso.Orders.Domain.OrderId"
          }
        ],
        "events": [
          {
            "namespace": "Contoso.Orders.Domain.Events"
          }
        ],
        "aggregates": [
          {
            "type": "Contoso.Orders.Domain.Order",
            "id": "Contoso.Orders.Domain.OrderId"
          }
        ],
        "naming": {
          "events": "class-name",
          "aggregates": "class-name"
        },
        "fold": {
          "methods": [
            "Apply"
          ],
          "version": "Version"
        },
        "serializer": {
          "kind": "system-text-json"
        },
        "hidden": [
          "Id",
          "Version"
        ]
      },
      "store": {
        "events": {
          "table": "Events",
          "streamId": "StreamId",
          "sequence": "Sequence",
          "type": "Type",
          "payload": "Payload",
          "written": "Written"
        }
      }
    }
  ]
}

Put it at the root of the zip, beside the assemblies it names, and upload the zip on the tool's Settings page.