create-qpq-app 0.1.5

package/template/docusaurus/docs/actions/core/graph-database/ask-graph-database-execute-open-cypher-query.md

@@ -0,0 +1,164 @@
+---
+title: askGraphDatabaseExecuteOpenCypherQuery
+description: Run an openCypher query against a graph database and get back nodes, relationships, and scalar values.
+---
+
+# askGraphDatabaseExecuteOpenCypherQuery
+
+Runs an [openCypher](https://opencypher.org/) query against a [graph database](../../../config/core/graph-database.md) and returns the matching rows. Each returned column is normalised into a **node**, a **relationship**, or a **scalar** value, so stories work against one engine-agnostic result shape rather than the raw driver output.
+
+- **Action type:** `GraphDatabaseActionType.ExecuteOpenCypherQuery`
+- **On AWS:** the processor resolves the database's Neptune endpoints, picks the reader or writer based on `instance`, POSTs the query to Neptune's `/openCypher` HTTP endpoint, and converts the Neptune response into the [`GraphCypherResponse`](#returns) shape.
+
+```typescript
+import { askGraphDatabaseExecuteOpenCypherQuery, GraphDatabaseInstanceType } from 'quidproquo-core';
+
+export function* askFindFriends(userId: string) {
+  const response = yield* askGraphDatabaseExecuteOpenCypherQuery(
+    'social-graph',
+    GraphDatabaseInstanceType.Read,
+    'MATCH (u:User { id: $userId })-[:FOLLOWS]->(f:User) RETURN f',
+    { userId },
+  );
+
+  // Each row is keyed by the RETURN alias — here, `f`.
+  return response.results.map((row) => row.f);
+}
+```
+
+## Signature
+
+```typescript
+function* askGraphDatabaseExecuteOpenCypherQuery(
+  graphDatabaseName: string,
+  instance: GraphDatabaseInstanceType,
+  openCypherQuery: string,
+  params?: Record<string, any>,
+): AskResponse<GraphCypherResponse>;
+```
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `graphDatabaseName` | `string` | – | Name of the graph database to query — must match a database declared with [defineGraphDatabase](../../../config/core/graph-database.md) (or one shared via its `owner` option). |
+| `instance` | `GraphDatabaseInstanceType` | – | Which cluster endpoint to run against — the reader or the writer. See below. |
+| `openCypherQuery` | `string` | – | The openCypher query text. Use named parameters (e.g. `$userId`) rather than string-concatenating values. |
+| `params` | `Record<string, any>` | `undefined` | Values bound to the named parameters referenced in the query. |
+
+### `GraphDatabaseInstanceType`
+
+Selects which endpoint of the cluster the query runs against.
+
+| Member | Value | Use for |
+| --- | --- | --- |
+| `GraphDatabaseInstanceType.Read` | `'read'` | Read-only queries (`MATCH … RETURN`). Routed to the read endpoint, which can serve from read replicas. |
+| `GraphDatabaseInstanceType.Write` | `'write'` | Queries that mutate the graph (`CREATE`, `MERGE`, `SET`, `DELETE`). Routed to the write (primary) endpoint. |
+
+## Returns
+
+`GraphCypherResponse` — an envelope with a single `results` array. Each element is one **row** returned by the query:
+
+```typescript
+interface GraphCypherResponse {
+  results: GraphQueryResult[];
+}
+```
+
+### `GraphQueryResult` — a row
+
+A row is a map keyed by the column names (the aliases in your `RETURN` clause). Each value is normalised into one of three result kinds:
+
+```typescript
+interface GraphQueryResult {
+  [column: string]: AnyGraphResult;
+}
+
+type AnyGraphResult = GraphNodeResult | GraphRelationshipResult | GraphScalarResult;
+```
+
+For example, `RETURN u, r, count(*) AS total` produces rows with keys `u` (a node), `r` (a relationship), and `total` (a scalar).
+
+### The result kinds
+
+`AnyGraphResult` is a discriminated union. Node and relationship results carry the shared base fields from `GraphEntity` plus a `$entityType` tag you can switch on; scalars are plain primitives.
+
+```typescript
+// Shared base for graph entities
+interface GraphEntity {
+  $id: string;                       // engine-assigned entity id
+  $properties: Record<string, any>;  // the entity's property bag
+}
+
+enum GraphEntityType {
+  Node = 'node',
+  Relationship = 'relationship',
+}
+```
+
+**`GraphNodeResult`** — a vertex:
+
+```typescript
+interface GraphNodeResult extends GraphEntity {
+  $entityType: GraphEntityType.Node;
+  $labels: string[];   // the node's labels, e.g. ['User']
+}
+```
+
+**`GraphRelationshipResult`** — an edge:
+
+```typescript
+interface GraphRelationshipResult extends GraphEntity {
+  $entityType: GraphEntityType.Relationship;
+  $start: string;   // $id of the start node
+  $end: string;     // $id of the end node
+  $type: string;    // the relationship type, e.g. 'FOLLOWS'
+}
+```
+
+**`GraphScalarResult`** — a primitive returned directly (counts, sums, property values, etc.):
+
+```typescript
+type GraphScalarResult = number | string | boolean | null;
+```
+
+Because nodes and relationships share `$id` and `$properties` and are tagged by `$entityType`, you can narrow a value safely:
+
+```typescript
+import { GraphEntityType } from 'quidproquo-core';
+
+function describe(value: AnyGraphResult): string {
+  if (value === null || typeof value !== 'object') {
+    return `scalar: ${value}`; // GraphScalarResult
+  }
+
+  if (value.$entityType === GraphEntityType.Node) {
+    return `node ${value.$id} [${value.$labels.join(', ')}]`;
+  }
+
+  return `relationship ${value.$type} ${value.$start} -> ${value.$end}`;
+}
+```
+
+## Notes
+
+- **Referencing internal ids in a query.** To read an entity's engine id inside a query, wrap the variable in `qpqElementId(...)` — e.g. `RETURN qpqElementId(n) AS id`. The runtime rewrites this to the underlying engine's internal id field, keeping queries portable. The related [askGraphDatabaseInternalFieldNames](./ask-graph-database-internal-field-names.md) action exposes the raw internal field-name tokens for the more advanced cases.
+- **Errors.** This action declares no custom error enum. Failures (for example, an unreachable endpoint or a rejected query) surface as generic errors, which you can trap with `askCatch`:
+
+  ```typescript
+  const outcome = yield* askCatch(
+    askGraphDatabaseExecuteOpenCypherQuery('social-graph', GraphDatabaseInstanceType.Read, 'MATCH (n) RETURN n'),
+  );
+
+  if (outcome.success) {
+    const response = outcome.result;
+    // ...
+  } else {
+    // outcome.error.errorType / outcome.error.errorText
+  }
+  ```
+
+## Related
+
+- [defineGraphDatabase](../../../config/core/graph-database.md) — declares the database this action queries.
+- [askGraphDatabaseInternalFieldNames](./ask-graph-database-internal-field-names.md) — the internal field-name tokens for referencing engine metadata in queries.

package/template/docusaurus/docs/actions/core/graph-database/ask-graph-database-internal-field-names.md

@@ -0,0 +1,64 @@
+---
+title: askGraphDatabaseInternalFieldNames
+description: Get the engine-internal field-name tokens for referencing node/relationship metadata in openCypher queries.
+---
+
+# askGraphDatabaseInternalFieldNames
+
+Returns the set of **internal field-name tokens** the underlying graph engine uses for entity metadata — id, label, type, and relationship endpoints. Use these when you need to reference an engine's internal fields directly inside an openCypher query without hard-coding engine-specific syntax.
+
+Most stories don't need this: for the common case of reading an entity's id, wrap the variable in `qpqElementId(...)` inside your query and the runtime rewrites it for you. Reach for this action only when you need the other tokens (label, type, start/end node) in a portable way.
+
+- **Action type:** `GraphDatabaseActionType.InternalFieldNames`
+
+```typescript
+import {
+  askGraphDatabaseExecuteOpenCypherQuery,
+  askGraphDatabaseInternalFieldNames,
+  GraphDatabaseInstanceType,
+} from 'quidproquo-core';
+
+export function* askNodesByLabel(label: string) {
+  const fields = yield* askGraphDatabaseInternalFieldNames();
+
+  const response = yield* askGraphDatabaseExecuteOpenCypherQuery(
+    'social-graph',
+    GraphDatabaseInstanceType.Read,
+    `MATCH (n) WHERE n.${fields.internalLabel} = $label RETURN n`,
+    { label },
+  );
+
+  return response.results.map((row) => row.n);
+}
+```
+
+## Signature
+
+```typescript
+function* askGraphDatabaseInternalFieldNames(): AskResponse<GraphDatabaseInternalFieldNames>;
+```
+
+## Parameters
+
+None.
+
+## Returns
+
+`GraphDatabaseInternalFieldNames` — a map of the engine's internal field-name tokens:
+
+```typescript
+type GraphDatabaseInternalFieldNames = {
+  internalId: string;         // token for an entity's internal id
+  internalLabel: string;      // token for a node's label
+  internalType: string;       // token for a relationship's type
+  internalStartNode: string;  // token for a relationship's start node
+  internalEndNode: string;    // token for a relationship's end node
+};
+```
+
+On the AWS (Neptune) runtime these resolve to Neptune's backtick-wrapped field references — for example `` `~id` ``, `` `~label` ``, `` `~type` ``, `` `~start` ``, and `` `~end` ``. Treat the exact values as engine-specific and always obtain them through this action rather than hard-coding them, so queries stay portable.
+
+## Related
+
+- [askGraphDatabaseExecuteOpenCypherQuery](./ask-graph-database-execute-open-cypher-query.md) — run the query these tokens are embedded in.
+- [defineGraphDatabase](../../../config/core/graph-database.md) — declares the database being queried.

package/template/docusaurus/docs/actions/core/guid/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "GUID",
+  "link": {
+    "type": "generated-index",
+    "description": "Generate globally-unique identifiers."
+  }
+}

package/template/docusaurus/docs/actions/core/guid/ask-new-guid.md

@@ -0,0 +1,45 @@
+---
+title: askNewGuid
+description: Generate a new random (version 4) UUID.
+---
+
+# askNewGuid
+
+Generates a new random, globally-unique identifier and returns it as a string.
+
+- **Action type:** `GuidActionType.New`
+- **At runtime:** resolves to a random (version 4) UUID via the platform's `crypto.randomUUID()`.
+
+Minting an id is non-deterministic — two runs would otherwise produce different values. By yielding this as an action, the story stays a pure generator: the runtime produces the id and records it in the execution log, so the run can be inspected, tested, and replayed with the exact same id it saw originally.
+
+```typescript
+import { askNewGuid } from 'quidproquo-core';
+
+export function* askCreateUser(name: string) {
+  const userId = yield* askNewGuid();
+  return { userId, name };
+}
+```
+
+## Signature
+
+```typescript
+function* askNewGuid(): AskResponse<string>;
+```
+
+## Parameters
+
+None.
+
+## Returns
+
+`string` — a random version 4 UUID, e.g. `109156be-c4fb-41ea-b1b4-efe1671c5836`.
+
+## Notes
+
+- The id is fully random. It carries no ordering information, so rows keyed by it are not naturally sorted by creation time — use [askNewSortableGuid](./ask-new-sortable-guid.md) when you want that.
+
+## Related
+
+- [askNewSortableGuid](./ask-new-sortable-guid.md) — a time-ordered, lexicographically sortable id.
+- [askEventDocCreate](../../features/event-doc/ask-event-doc-create.md) — uses this to mint a new event document's id.

package/template/docusaurus/docs/actions/core/guid/ask-new-sortable-guid.md

@@ -0,0 +1,49 @@
+---
+title: askNewSortableGuid
+description: Generate a new time-ordered, lexicographically sortable UUID.
+---
+
+# askNewSortableGuid
+
+Generates a new globally-unique identifier that is **sortable** — ids minted later sort after ids minted earlier — and returns it as a string.
+
+- **Action type:** `GuidActionType.NewSortable`
+- **At runtime:** resolves to a UUID **version 7** (via the `uuidv7` library). UUIDv7 embeds a Unix millisecond timestamp in its leading bits, so the ids are time-ordered and sort chronologically as plain text.
+
+Like [askNewGuid](./ask-new-guid.md), minting an id is non-deterministic, so it is done as an action: the runtime produces the id and records it in the execution log, keeping the story a pure generator that can be inspected, tested, and replayed with the same id.
+
+**What "sortable" means:** because the timestamp is in the most-significant bits, a lexicographic (alphabetical / byte-order) sort of these ids matches their creation order. That makes them a good primary/sort key in a key-value store when you want "newest last" (or "newest first" reversed) without storing a separate timestamp column, while still being globally unique.
+
+```typescript
+import { askNewSortableGuid } from 'quidproquo-core';
+
+export function* askAppendEvent(kind: string) {
+  // Later events get larger ids, so a range scan returns them in order.
+  const eventId = yield* askNewSortableGuid();
+  return { eventId, kind };
+}
+```
+
+## Signature
+
+```typescript
+function* askNewSortableGuid(): AskResponse<string>;
+```
+
+## Parameters
+
+None.
+
+## Returns
+
+`string` — a UUID version 7, e.g. `018f9a3c-1c2e-7a4b-8e2d-2f1a6b5c9d0e`. Two ids generated at different times compare in creation order under an ordinary string sort.
+
+## Notes
+
+- Ids minted within the same millisecond stay unique (the remaining bits are random) and keep a stable relative order.
+- Use this over [askNewGuid](./ask-new-guid.md) whenever the id doubles as a sort key; use plain [askNewGuid](./ask-new-guid.md) when you specifically do **not** want the creation time to be inferable from the id.
+
+## Related
+
+- [askNewGuid](./ask-new-guid.md) — a fully random (v4) id with no ordering.
+- [askDateNow](../date/ask-date-now.md) — read the current timestamp directly instead of embedding it in an id.

package/template/docusaurus/docs/actions/core/inline-function/_category_.json

@@ -0,0 +1 @@
+{ "label": "Inline Function", "link": { "type": "generated-index", "description": "Invoke a referenced function/story by reference from within a story." } }

package/template/docusaurus/docs/actions/core/inline-function/ask-inline-function-execute.md

@@ -0,0 +1,66 @@
+---
+title: askInlineFunctionExecute
+description: Invoke a registered inline function by name and return its result, running it in-process as a nested story.
+---
+
+# askInlineFunctionExecute
+
+Invokes an [inline function](../../../config/core/inline-function.md) by name, passing it a payload, and returns whatever the function's story returns. Unlike a queue or event-bus message, this is **synchronous** — the caller waits for the result. The referenced story runs in-process as a nested story (one depth deeper), sharing the caller's action processors and session context.
+
+- **Action type:** `InlineFunctionActionType.Execute`
+
+```typescript
+import { askInlineFunctionExecute } from 'quidproquo-core';
+
+export function* quoteOrder(order: { subtotal: number; region: string }) {
+  const tax = yield* askInlineFunctionExecute<number, { amount: number; region: string }>(
+    'calculateTax',
+    { amount: order.subtotal, region: order.region },
+  );
+
+  return order.subtotal + tax;
+}
+```
+
+## Signature
+
+```typescript
+function* askInlineFunctionExecute<R, T>(
+  functionName: string,
+  payload: T,
+): AskResponse<R>;
+```
+
+The two generics are the **return type** `R` (what the invoked story resolves to) and the **payload type** `T` (what you pass in). They are independent — set `R` to the invoked function's return type.
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `functionName` | `string` | Name of the inline function to run — must match the `functionName` of a function registered with [defineInlineFunction](../../../config/core/inline-function.md). |
+| `payload` | `T` | The single argument passed to the invoked story. |
+
+## Returns
+
+`R` — the value the invoked story returns. The result is returned directly to the caller (there is no wrapper object).
+
+## Notes
+
+- The invoked story runs **in the same process** as the caller (nested one level deeper), not as a separate deployed service — inline functions add no infrastructure of their own.
+- If no inline function matches `functionName`, the action fails with `ErrorTypeEnum.NotFound`. If the invoked story itself throws, that error is propagated to the caller (with the function name added to the error stack). `askInlineFunctionExecute` does not define its own error enum; catch failures with `askCatch`:
+
+```typescript
+const outcome = yield* askCatch(
+  askInlineFunctionExecute('calculateTax', { amount, region }),
+);
+
+if (outcome.success) {
+  const tax = outcome.result;
+} else {
+  // outcome.error.errorType / outcome.error.errorText
+}
+```
+
+## Related
+
+- [defineInlineFunction](../../../config/core/inline-function.md) — registers the story this action can invoke by name.

package/template/docusaurus/docs/actions/core/json/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "JSON",
+  "link": {
+    "type": "generated-index",
+    "description": "Parse JSON safely from within a story."
+  }
+}

package/template/docusaurus/docs/actions/core/json/ask-decode-json.md

@@ -0,0 +1,76 @@
+---
+title: askDecodeJson
+description: Parse a JSON string safely from within a story, turning parse failures into catchable qpq errors.
+---
+
+# askDecodeJson
+
+Parses a JSON string into a typed value, optionally validating the result with a predicate. On invalid JSON — or when the validator rejects the parsed value — it raises a **catchable qpq error** rather than letting a raw `SyntaxError` escape, so failures flow through the normal `askCatch` error-handling path.
+
+- A composed story that wraps `JSON.parse` and, on failure, delegates to `askThrowError` with `ErrorTypeEnum.Invalid`.
+
+```typescript
+import { askDecodeJson } from 'quidproquo-core';
+
+interface Settings {
+  theme: string;
+  maxItems: number;
+}
+
+export function* askLoadSettings(raw: string) {
+  const settings = yield* askDecodeJson<Settings>(
+    raw,
+    (s) => typeof s.theme === 'string' && typeof s.maxItems === 'number',
+  );
+  return settings;
+}
+```
+
+## Signature
+
+```typescript
+function* askDecodeJson<T>(
+  json: string,
+  validateObject?: (item: T) => boolean,
+): AskResponse<T>;
+```
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `json` | `string` | — | The JSON text to parse. |
+| `validateObject` | `(item: T) => boolean` | none | Optional predicate run against the parsed value. Return `false` to reject it — the story then raises an `Invalid` error instead of returning. If omitted, any successfully-parsed JSON is returned as-is. |
+
+The generic `T` is the expected shape of the decoded value; it is applied as a cast (`JSON.parse(json) as T`) and is not checked at runtime beyond your optional `validateObject` predicate.
+
+## Returns
+
+`T` — the parsed (and, if a predicate was supplied, validated) value.
+
+## Errors
+
+`askDecodeJson` does not define its own error enum; it throws the shared `ErrorTypeEnum.Invalid` error in two cases:
+
+| Condition | Error |
+| --- | --- |
+| The input is not valid JSON (`JSON.parse` throws). | `ErrorTypeEnum.Invalid` — the error text includes the underlying parser message. |
+| `validateObject` is supplied and returns `false`. | `ErrorTypeEnum.Invalid` — the error text notes the JSON parsed but failed structural validation. |
+
+Because these are thrown through the qpq error mechanism, catch them with `askCatch` from quidproquo-core, which returns an `EitherActionResult` — `{ success: true, result }` on success, or `{ success: false, error }` on failure:
+
+```typescript
+const outcome = yield* askCatch(askDecodeJson<Settings>(raw));
+
+if (outcome.success) {
+  const settings = outcome.result;
+} else {
+  // outcome.error.errorType === ErrorTypeEnum.Invalid
+  // outcome.error.errorText
+}
+```
+
+## Related
+
+- [askFileReadObjectJson](../file/ask-file-read-object-json.md) — read a file and JSON-decode it in one action.
+- [askFileReadTextContents](../file/ask-file-read-text-contents.md) — read raw text you can then hand to `askDecodeJson`.

package/template/docusaurus/docs/actions/core/key-value-store/_category_.json

@@ -0,0 +1 @@
+{ "label": "Key-Value Store", "link": { "type": "generated-index", "description": "DynamoDB-style key-value storage: get, query, scan, update, upsert, and delete records on a store defined with defineKeyValueStore." } }

package/template/docusaurus/docs/actions/core/key-value-store/ask-key-value-store-delete.md

@@ -0,0 +1,57 @@
+---
+title: askKeyValueStoreDelete
+description: Delete a single record from a key-value store by its key.
+---
+
+# askKeyValueStoreDelete
+
+Removes one record from a [key-value store](../../../config/core/key-value-store.md), addressed by its key. Deleting a record that doesn't exist is a no-op.
+
+- **Action type:** `KeyValueStoreActionType.Delete`
+
+```typescript
+import { askKeyValueStoreDelete } from 'quidproquo-core';
+
+export function* askRemoveUser(userId: string) {
+  yield* askKeyValueStoreDelete('users', userId);
+}
+```
+
+## Signature
+
+```typescript
+function* askKeyValueStoreDelete(
+  keyValueStoreName: string,
+  key: KvsCoreDataType,
+  sortKey?: KvsCoreDataType,
+  options?: KeyValueStoreDeleteOptions,
+): AskResponse<void>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `keyValueStoreName` | `string` | Name of the store — must match a store declared with [defineKeyValueStore](../../../config/core/key-value-store.md) (or one shared via its `owner` option). |
+| `key` | `KvsCoreDataType` | Partition key value of the record to delete (`string \| number`). |
+| `sortKey` | `KvsCoreDataType` | Sort key value, required only if the store declares a sort key (`string \| number`). |
+| `options` | `KeyValueStoreDeleteOptions` | Reserved for future delete options; currently empty. |
+
+## Returns
+
+`void` — the story resumes once the delete has committed.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `KeyValueStoreDeleteErrorTypeEnum.ServiceUnavailable` | DynamoDB internal error or throttling. |
+| `KeyValueStoreDeleteErrorTypeEnum.ResourceNotFound` | The underlying table does not exist. |
+
+Catch errors with `askCatch` — it returns `{ success: true, result }` or `{ success: false, error }`.
+
+## Related
+
+- [defineKeyValueStore](../../../config/core/key-value-store.md) — declares the store and its keys.
+- [askKeyValueStoreGet](./ask-key-value-store-get.md) — read the record before deleting.
+- [askKeyValueStoreUpsert](./ask-key-value-store-upsert.md) — write the record.

package/template/docusaurus/docs/actions/core/key-value-store/ask-key-value-store-get-all.md

@@ -0,0 +1,60 @@
+---
+title: askKeyValueStoreGetAll
+description: Read every record in a key-value store.
+---
+
+# askKeyValueStoreGetAll
+
+Returns **all** records in a [key-value store](../../../config/core/key-value-store.md) as an array. Best reserved for small, bounded stores (config-like or reference data) — for large tables prefer [askKeyValueStoreQuery](./ask-key-value-store-query.md) or [askKeyValueStoreScanAll](./ask-key-value-store-scan-all.md).
+
+- **Action type:** `KeyValueStoreActionType.GetAll`
+
+```typescript
+import { askKeyValueStoreGetAll } from 'quidproquo-core';
+
+interface FeatureFlag {
+  name: string;
+  enabled: boolean;
+}
+
+export function* askGetAllFlags() {
+  const flags = yield* askKeyValueStoreGetAll<FeatureFlag>('feature-flags');
+  return flags; // FeatureFlag[]
+}
+```
+
+## Signature
+
+```typescript
+function* askKeyValueStoreGetAll<Value>(
+  keyValueStoreName: string,
+  options?: KeyValueStoreGetAllOptions,
+): AskResponse<Value[]>;
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `keyValueStoreName` | `string` | Name of the store to read from — must match a store declared with [defineKeyValueStore](../../../config/core/key-value-store.md) (or one shared via its `owner` option). |
+| `options` | `KeyValueStoreGetAllOptions` | Reserved for future read options; currently empty. |
+
+## Returns
+
+`Value[]` — every record in the store. Returns an empty array if the store is empty.
+
+## Errors
+
+| Error | Meaning |
+| --- | --- |
+| `KeyValueStoreGetAllErrorTypeEnum.ServiceUnavailable` | DynamoDB internal error or throttling. |
+| `KeyValueStoreGetAllErrorTypeEnum.ResourceNotFound` | The underlying table does not exist. |
+
+Catch errors with `askCatch` — it returns `{ success: true, result }` or `{ success: false, error }`.
+
+## Related
+
+- [defineKeyValueStore](../../../config/core/key-value-store.md) — declares the store this action reads from.
+- [askKeyValueStoreGet](./ask-key-value-store-get.md) — read a single record by key.
+- [askKeyValueStoreScanAll](./ask-key-value-store-scan-all.md) — read all records matching a filter, page by page.
+- [askKeyValueStoreQuery](./ask-key-value-store-query.md) — read records by key condition.