@antelopejs/interface-data-api 0.4.0 → 0.6.0

package/docs/7.foreign-keys.md

@@ -1,18 +1,22 @@
-# Foreign Keys
+---
+title: Foreign keys
+description: Resolve a foreign key field into the referenced record with @Foreign, for single and array references, across schemas, and per route.
+mode: reference
+---
 
 ## Overview
 
-The `@Foreign` decorator establishes relationships between database tables in your data controller. When a field holds a foreign key (an ID referencing another table), the Data API automatically resolves the reference and includes the related record in API responses. This works for both single references and arrays of references.
+The `@Foreign` decorator links a field of your data controller to another table. When a field holds a foreign key (an ID of a record in another table), the Data API looks up the referenced record and puts it in the response. The field can hold one key or an array of keys.
 
-## Basic Usage
+## Basic usage
 
-Apply `@Foreign` to a field that stores a foreign key value. The decorator replaces the raw ID in the response with the full referenced record.
+Apply `@Foreign` to a field that stores a foreign key value. The response then holds the referenced record in place of the raw ID.
 
-Choose the response fields explicitly with `pluck`. A foreign lookup reads the target table, not its API controller: do not rely on the target controller's `@Access` policy to hide passwords or internal fields. The example below selects only the user's ID, name, and email.
+Choose the response fields with `pluck`. A foreign lookup reads the target table, not its API controller, so the target controller's `@Access` policy does not hide passwords or internal fields. The example below selects only the user's ID, name, and email.
 
-The snippets use the `myapp` schema. Register it in the declaring module before serving requests, as in the [quick start](./1.introduction.md#quick-start). Controller snippets assume the corresponding model and shared imports are already declared.
+The snippets use the `myapp` schema. Register it in the declaring module before serving requests, as in the [quick start](./1.introduction.md#quick-start). The controller snippets assume that the matching model and the shared imports exist.
 
-```typescript
+```typescript fragment
 import { Foreign } from "@antelopejs/interface-data-api/metadata";
 import {
   Field,
@@ -71,7 +75,7 @@ class OrderAPI extends DataController(
 }
 ```
 
-A GET request to `/orders/get?id=order-123` returns the full user object instead of a raw ID:
+A GET request to `/orders/get?id=order-123` returns the user object in place of the raw ID:
 
 ```json
 {
@@ -85,47 +89,48 @@ A GET request to `/orders/get?id=order-123` returns the full user object instead
 }
 ```
 
-## Decorator Parameters
+## Decorator parameters
 
-```typescript
-@Foreign(table, index?, multi?, pluck?, schema?)
+```typescript fragment
+@Foreign(table, index?, multi?, pluck?, schema?, targetMeta?)
 ```
 
-| Parameter | Type                       | Required | Default           | Description                                                                                        |
-| --------- | -------------------------- | -------- | ----------------- | -------------------------------------------------------------------------------------------------- |
-| `table`   | `Class<Table>` or `string` | Yes      | -                 | The target table class or table name string                                                        |
-| `index`   | `string`                   | No       | `"_id"`           | The index on the target table to match against                                                     |
-| `multi`   | `boolean`                  | No       | `false`           | Set to `true` when the field holds an array of foreign keys                                        |
-| `pluck`   | `string[]`                 | No       | All fields        | List of fields to include from the referenced record                                               |
-| `schema`  | `string`                   | No       | Controller schema | Name of the schema the target table is registered in, when it differs from the controller's schema |
+| Parameter    | Type                       | Required | Default           | Description                                                                                                                                                             |
+| ------------ | -------------------------- | -------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `table`      | `Class<Table>` or `string` | Yes      | None              | The target table class or table name string                                                                                                                             |
+| `index`      | `string`                   | No       | `"_id"`           | The index on the target table to match against                                                                                                                          |
+| `multi`      | `boolean`                  | No       | `false`           | Set to `true` when the field holds an array of foreign keys                                                                                                             |
+| `pluck`      | `string[]`                 | No       | All fields        | List of fields to include from the referenced record                                                                                                                    |
+| `schema`     | `string`                   | No       | Controller schema | Name of the schema the target table is registered in, when it differs from the controller's schema                                                                      |
+| `targetMeta` | `DataAPIMeta`              | No       | None              | Metadata of the target's data controller. Its `@Joined` fields that `pluck` names, or all of them when `pluck` is unset, are resolved on a relation that is not `multi` |
 
-## Table Reference Methods
+## Table reference methods
 
-### Class Reference
+### Class reference
 
-Pass the table class directly. This provides IDE autocompletion, refactoring support, and compile-time validation.
+Pass the table class. Your editor can then complete and rename the reference, and the compiler checks it.
 
-```typescript
+```typescript fragment
 @Foreign(User)
 declare userId: User;
 ```
 
-### String Reference
+### String reference
 
-Pass the registered table name as a string. Use this when importing the class would create circular dependencies.
+Pass the registered table name as a string. Use a string when importing the class would create a circular import.
 
-```typescript
+```typescript fragment
 @Foreign("users")
 declare userId: User;
 ```
 
-## Multi-Record References
+## Multi-record references
 
-When a field stores an array of foreign key IDs, set the `multi` parameter to `true`. The API resolves each ID and returns an array of full records.
+When a field stores an array of foreign key IDs, set the `multi` parameter to `true`. The API looks up each ID and returns an array of records.
 
-The table-level `@Relation({ many: true })` is declarative metadata recording that the field holds multiple target keys; API-side resolution is controlled solely by the `multi` parameter of `@Foreign`.
+The table-level `@Relation({ many: true })` is metadata only. It records that the field holds several target keys. Only the `multi` parameter of `@Foreign` controls how the API resolves the field.
 
-```typescript
+```typescript fragment
 @RegisterTable("carts", "myapp")
 class Cart extends Table {
   @Field("string")
@@ -181,11 +186,11 @@ Response:
 }
 ```
 
-## Selective Field Retrieval with Pluck
+## Selective field retrieval with pluck
 
-The `pluck` parameter limits which fields are included from the referenced record. This reduces response payload size when you only need specific fields.
+The `pluck` parameter limits the fields taken from the referenced record. Use it to keep the response small when you need only some fields.
 
-```typescript
+```typescript fragment
 @RegisterDataController()
 class CartAPI extends DataController(
   Cart,
@@ -239,46 +244,48 @@ Response with `pluck: ["name", "email"]`:
 }
 ```
 
-## Custom Index
+## Custom index
 
-Use the `index` parameter to match against a secondary index instead of the primary key.
+The `index` parameter matches the field against a secondary index of the target table, in place of the primary key.
 
-```typescript
-// Match userId against the "email" index on the User table
+```typescript fragment
+// Match userEmail against the "email" index on the User table
 @Foreign(User, "email")
 declare userEmail: User;
 ```
 
-## Cross-Schema References
+## Cross-schema references
 
-By default, the target table is resolved in the same schema as the controller's table. Use the `schema` parameter to reference a table registered in a different schema. At runtime the foreign lookup is resolved through the target's table class, against the default instance of the schema `RegisterSchema` bound it to, so it follows the database of the module that declared the table. The target's class must be registered with `@RegisterTable` before the field is declared; a string table name with no registered class in that schema throws at declaration.
+By default, the Data API looks for the target table in the schema of the controller's table. The `schema` parameter names a different schema. At runtime, the foreign lookup goes through the target's table class, against the default instance of the schema that `RegisterSchema` bound it to. The lookup therefore uses the database of the module that declared the table. Register the target's class with `@RegisterTable` before you declare the field. A string table name with no registered class in that schema throws at declaration.
 
-```typescript
+```typescript fragment
 // Resolve userId against the User table registered in the "auth" schema
 @Access(AccessMode.ReadOnly)
 @Foreign(User, undefined, false, undefined, "auth")
 declare userId: User;
 ```
 
-When a table class is passed (instead of a string), its schema is inferred from its `@RegisterTable` metadata, so the `schema` parameter is only needed to override that or when passing a string table name. If both the class metadata and the explicit `schema` option specify a schema and they disagree, an error is thrown.
+When you pass a table class, the Data API reads its schema from its `@RegisterTable` metadata. The `schema` parameter is then needed only with a string table name, or when the class metadata names no schema. If the class metadata and the `schema` parameter name different schemas, the declaration throws.
 
-## Disable Foreign Key Resolution
+## Disable foreign key resolution
 
-Use the `noForeign` route option to skip foreign key resolution for specific endpoints. This returns raw IDs instead of resolved objects.
+The `noForeign` route option skips foreign key resolution on one route. The route then returns raw IDs in place of records. On a `get` route the option is a string, and on a `list` route it is a boolean.
 
 ```typescript
+import { DefaultRoutes } from "@antelopejs/interface-data-api";
+
 const routes = {
   get: DefaultRoutes.Get,
   getRaw: DefaultRoutes.WithOptions(DefaultRoutes.Get, { noForeign: "true" }),
 };
 ```
 
-## Error Handling
+## Error handling
 
-- **Missing References** - If a referenced record does not exist, the field value is `null`.
-- **Invalid IDs** - Invalid foreign key values result in `null` for the resolved field.
-- **Arrays with Missing Items** - In multi-record references, missing items appear as `null` in the array.
+- If a referenced record does not exist, the field value is `null`.
+- An invalid foreign key value resolves to `null`.
+- In a multi-record reference, each missing item is `null` in the array.
 
-## Next Steps
+## Next steps
 
-See the [filters documentation](./8.filters.md) to learn how to add filtering capabilities to list endpoints.
+To filter list results, see [Filters](./8.filters.md).

package/docs/8.filters.md

@@ -1,16 +1,20 @@
-# Filters
+---
+title: Filters
+description: Let list requests filter rows with @Filter, through the default comparisons, custom filter functions, and mandatory route filters.
+mode: reference
+---
 
 ## Overview
 
-The `@Filter` decorator adds filtering capabilities to list endpoints. Filters allow clients to narrow down results using query parameters. The module provides a default filter with standard comparison operators and supports custom filter functions for advanced logic.
+The `@Filter` decorator lets a list request narrow its results through query parameters. The default filter compares the field with six comparison operators. A custom filter function can hold any other logic.
 
-## Basic Usage
+## Basic usage
 
-### Default Filter
+### Default filter
 
-Apply `@Filter()` without arguments to enable standard comparison filtering on a string field. Query filter values remain strings: TypeScript annotations, `@Field`, and write validators do not parse them into numbers or booleans.
+`@Filter()` without arguments enables the default comparison filter on a string field. Filter values stay strings. TypeScript annotations, `@Field`, and write validators do not parse them into numbers or booleans.
 
-```typescript
+```typescript fragment
 import { Filter } from "@antelopejs/interface-data-api/metadata";
 
 @RegisterDataController()
@@ -39,18 +43,18 @@ class UserAPI extends DataController(
 }
 ```
 
-### Query Parameter Format
+### Query parameter format
 
-Filters are applied through query parameters using the following format:
+A filter is a query parameter in one of these forms:
 
 ```
 filter_<fieldName>=<value>
 filter_<fieldName>=<operator>:<value>
 ```
 
-When no operator is specified, `eq` (equal) is used by default.
+Without an operator, the filter uses `eq` (equal). The text before the first colon is the operator, so a value that contains a colon needs the `eq:` prefix. The default filter answers `400` to an operator that is not in the table below.
 
-### Comparison Operators
+### Comparison operators
 
 | Operator | Description              |
 | -------- | ------------------------ |
@@ -75,7 +79,7 @@ Retrieve users whose role is not admin:
 GET /users/list?filter_role=ne:admin
 ```
 
-Combine multiple filters:
+Combine filters on several fields:
 
 ```http
 GET /users/list?filter_status=active&filter_role=ne:admin
@@ -87,16 +91,24 @@ Filter one field several times to keep the rows that pass every filter (AND):
 GET /users/list?filter_age=ge:18&filter_age=lt:65
 ```
 
-The route receives that field's filters as a list of `FilterValue` tuples (`FieldFilter`); a field filtered once keeps a single tuple. Read either shape with `FilterValuesOf(filter)` from `@antelopejs/interface-data-api/metadata`. An indexed equality filter only uses its index when it is the field's only filter.
+The route receives the filters of that field as a list of `FilterValue` tuples (`FieldFilter`). A field filtered once keeps a single tuple. `FilterValuesOf(filter)` from `@antelopejs/interface-data-api/metadata` reads either shape as a list. An indexed equality filter uses its index only when it is the only filter on the field.
 
-### Numeric and Boolean Filters
+### Numeric and boolean filters
 
-Parse and validate values explicitly in a custom filter. These filters support the six numeric comparisons and boolean equality/inequality; unsupported input throws an HTTP 400 response.
+Parse and validate numbers and booleans in a custom filter. The filters below support the six numeric comparisons and boolean `eq` and `ne`. Any other input fails with an HTTP 400 response.
 
 ```ts docs-check
 import { assert } from "@antelopejs/interface-api-util";
 import type { FilterFunction } from "@antelopejs/interface-data-api/metadata";
 
+type Comparison = "eq" | "ne" | "gt" | "ge" | "lt" | "le";
+
+const COMPARISONS: readonly Comparison[] = ["eq", "ne", "gt", "ge", "lt", "le"];
+
+function isComparison(mode: string): mode is Comparison {
+  return COMPARISONS.some((comparison) => comparison === mode);
+}
+
 export const numberFilter: FilterFunction<Record<string, unknown>> = (
   _context,
   proxy,
@@ -106,11 +118,7 @@ export const numberFilter: FilterFunction<Record<string, unknown>> = (
 ) => {
   const value = Number(raw);
   assert(raw.trim() !== "" && Number.isFinite(value), 400, "Invalid number");
-  assert(
-    ["eq", "ne", "gt", "ge", "lt", "le"].includes(mode),
-    400,
-    "Invalid comparison",
-  );
+  assert(isComparison(mode), 400, "Invalid comparison");
   return proxy[mode](value);
 };
 
@@ -127,9 +135,9 @@ export const booleanFilter: FilterFunction<Record<string, unknown>> = (
 };
 ```
 
-Apply the functions to the corresponding fields in your controller:
+Apply the functions to the matching fields of your controller:
 
-```typescript
+```typescript fragment
 @Filter(numberFilter, false)
 declare age: number;
 
@@ -137,37 +145,40 @@ declare age: number;
 declare isActive: boolean;
 ```
 
-With these custom filters, `?filter_age=gt:30&filter_isActive=true` compares against `30` and `true`, not `"30"` and `"true"`. Keep `useIndex` false for callbacks that parse values: indexed equality uses the raw string directly and bypasses the filter callback.
+With these custom filters, `?filter_age=gt:30&filter_isActive=true` compares against `30` and `true`, not `"30"` and `"true"`. Keep `useIndex` false for a filter that parses its value. An indexed equality lookup uses the raw string and skips the filter function.
 
-## Custom Filters
+## Custom filters
 
-For filtering logic beyond simple comparisons, pass a custom filter function to `@Filter`.
+For logic beyond the comparison operators, pass a custom filter function to `@Filter`.
 
-### Filter Function Signature
+### Filter function signature
 
-```typescript
-type FilterFunction<T, U> = (
+```typescript fragment
+type FilterFunction<
+  T extends Record<string, any>,
+  U extends Record<string, any> = FieldValues,
+> = (
   context: RequestContext & { this: T },
   proxy: ValueProxy<any>,
   key: string,
-  value: string,
-  mode: "eq" | "ne" | "gt" | "ge" | "lt" | "le",
-  row: ValueProxy<U>,
+  ...rest: [value: FilterValue[0], mode: FilterValue[1], row: ValueProxy<U>]
 ) => ValueProxyOrValue<boolean>;
 ```
 
-| Parameter | Description                                                                                             |
-| --------- | ------------------------------------------------------------------------------------------------------- |
-| `context` | The request context, extended with `this` referencing the controller instance                           |
-| `proxy`   | A query expression produced by the field modifier's `unlockrequest()` method; see the limitations below |
-| `key`     | The field name being filtered                                                                           |
-| `value`   | The filter value from the query parameter                                                               |
-| `mode`    | The comparison operator from the query parameter                                                        |
-| `row`     | The full database row as a `ValueProxy`                                                                 |
+| Parameter | Description                                                                                              |
+| --------- | -------------------------------------------------------------------------------------------------------- |
+| `context` | The request context, with `this` set to the controller instance                                          |
+| `proxy`   | A query expression that the field modifier's `unlockrequest()` method builds. See the limitations below. |
+| `key`     | The name of the filtered field                                                                           |
+| `value`   | The filter value from the query parameter, a string                                                      |
+| `mode`    | The text before the first colon of the query parameter, unchecked. The filter defines its own modes.     |
+| `row`     | The full database row as a `ValueProxy`                                                                  |
+
+`value`, `mode`, and `row` form one rest tuple, so the function type stays within five parameters. A function that declares them as separate parameters is assignable to the type, and `Parameters<FilterFunction<T, U>>` lists all six.
 
-### Example: Pattern Matching Filter
+### Example: pattern matching filter
 
-```typescript
+```typescript fragment
 function filterByEmailDomain(
   context: RequestContext,
   proxy: ValueProxy<any>,
@@ -209,13 +220,13 @@ Query for users with Gmail addresses:
 GET /users/list?filter_email=gmail.com
 ```
 
-Import `assert` from `@antelopejs/interface-api-util`. Escaping the domain makes the dot literal rather than a regular-expression wildcard. This example deliberately rejects operators other than `eq` instead of silently treating every request as equality.
+Import `assert` from `@antelopejs/interface-api-util`. The function escapes the domain, so the dot matches a literal dot and not any character. The function rejects operators other than `eq`, so a request with another operator fails instead of running as an equality filter.
 
-### The `useIndex` Parameter
+### The `useIndex` parameter
 
-The `@Filter` decorator accepts an optional second parameter, `useIndex`, that controls whether the filter can use a database index for optimized lookups.
+The second parameter of `@Filter`, `useIndex`, allows the filter to use a database index.
 
-```typescript
+```typescript fragment
 @Filter(undefined, true)   // Default filter with index optimization
 declare status: string;
 
@@ -223,16 +234,16 @@ declare status: string;
 declare name: string;
 ```
 
-When `useIndex` is not specified:
+When `useIndex` is not set:
 
-- Default filters (no custom function) automatically use the index if the field has one.
-- Custom filters default to no index usage.
+- The default filter (no custom function) uses the index when the field has a single-field index.
+- A custom filter uses no index.
 
-Index-optimized filters with an `eq` operator perform an indexed lookup instead of a full table scan, which significantly improves performance on large datasets.
+An indexed filter with the `eq` operator reads the matching rows through the index instead of scanning the whole table.
 
-## Mandatory Route Filters
+## Mandatory route filters
 
-Use `DefaultRoutes.WithOptions` to constrain a list route. The `filters` map contains `[stringValue, comparison]` tuples for fields declared with `@Filter`. Request filters for other fields are retained, but a route filter wins when both specify the same field.
+`DefaultRoutes.WithOptions` can constrain a list route. Its `filters` map holds `[stringValue, comparison]` tuples for fields declared with `@Filter`. The route keeps request filters on other fields. When the route and the request filter the same field, the route filter wins.
 
 ```ts docs-check
 import { DefaultRoutes } from "@antelopejs/interface-data-api";
@@ -242,10 +253,10 @@ const activeUsers = DefaultRoutes.WithOptions(DefaultRoutes.List, {
 });
 ```
 
-On a controller with a `status` filter, `?filter_status=inactive&filter_role=admin` still restricts `status` to `"active"` while retaining the requested `role`. Route filters are list-query constraints, not authorization for separate get/edit/delete routes.
+On a controller with a `status` filter, `?filter_status=inactive&filter_role=admin` still restricts `status` to `"active"` and keeps the requested `role`. Route filters constrain list queries only. They do not authorize or restrict the `get`, `edit`, or `delete` routes.
 
-## Modifier Integration
+## Modifier integration
 
-The `proxy` parameter is a database expression, not an unlocked model instance. The Data API calls the modifier's `unlockrequest()` method to build that expression. Localization can select a locale at query time, but the built-in `EncryptionModifier.unlockrequest()` returns the stored expression unchanged: it does not decrypt ciphertext in the database. A custom modifier must explicitly support query-time access before a filter can operate on its logical value.
+The `proxy` parameter is a database expression, not an unlocked model instance. The Data API calls the modifier's `unlockrequest()` method to build that expression. Localization can select a locale at query time. The built-in `EncryptionModifier.unlockrequest()` returns the stored expression unchanged, so it does not decrypt ciphertext in the database. A custom modifier must support query-time access before a filter can compare its plain value.
 
-For raw database values, use the `row` parameter and access the field directly.
+For raw database values, read the field from the `row` parameter.

package/docs/9.modifiers.md

@@ -1,14 +1,18 @@
-# Modifiers
+---
+title: Modifiers
+description: Use database modifiers such as @Hashed, @Encrypted, and @Localized with a data controller, and pass a per-request modifier key with @ModifierKey.
+mode: reference
+---
 
 ## Overview
 
-Modifiers from `@antelopejs/interface-database-decorators` work automatically with the Data API. Modifiers such as `@Hashed` or `@Encrypted` transform data transparently during read and write operations without any additional configuration in the data controller.
+Modifiers from `@antelopejs/interface-database-decorators` work with the Data API without extra configuration in the data controller. Modifiers such as `@Hashed` or `@Encrypted` transform data on every read and write.
 
-Some modifiers require a runtime parameter (for example, a locale key for localization). The `@ModifierKey` decorator bridges this gap by mapping a controller field to a modifier's runtime key.
+Some modifiers need a value at runtime, such as the locale key of the localization modifier. The `@ModifierKey` decorator maps a controller field to the runtime key of one modifier.
 
-## The `@ModifierKey` Decorator
+## The `@ModifierKey` decorator
 
-Use `@ModifierKey` when a modifier needs a runtime value that varies per request. The decorator associates a controller field with a specific modifier class. The field's value at request time is passed to the modifier during lock and unlock operations.
+Use `@ModifierKey` when a modifier needs a value that changes per request. The decorator links a controller field to a modifier class. At request time, the Data API passes the value of the field to the modifier when it locks and unlocks data.
 
 ```typescript
 import { ModifierKey } from "@antelopejs/interface-data-api/metadata";
@@ -16,17 +20,17 @@ import { ModifierKey } from "@antelopejs/interface-data-api/metadata";
 
 ### Signature
 
-```typescript
+```typescript fragment
 @ModifierKey(modifierClass: typeof ContainerModifier<any>)
 ```
 
-| Parameter       | Description                                                                   |
-| --------------- | ----------------------------------------------------------------------------- |
-| `modifierClass` | The modifier class that requires a runtime key (e.g., `LocalizationModifier`) |
+| Parameter       | Description                                                                     |
+| --------------- | ------------------------------------------------------------------------------- |
+| `modifierClass` | The modifier class that needs a runtime key, for example `LocalizationModifier` |
 
-### Example: Localized Content
+### Example: localized content
 
-The `LocalizationModifier` requires a locale identifier to determine which translation to store or retrieve. Use `@ModifierKey` to supply this value from an HTTP header.
+The `LocalizationModifier` needs a locale identifier to choose which translation to store or read. In this example, `@ModifierKey` takes that value from an HTTP header.
 
 ```typescript
 import { Controller, Parameter } from "@antelopejs/interface-api";
@@ -92,14 +96,14 @@ class ContentAPI extends DataController(
 }
 ```
 
-### How It Works
+### How it works
 
 1. The HTTP request includes the header `x-content-language: fr`.
 2. The `language` property receives the value `"fr"`.
-3. During write operations, the modifier uses `"fr"` as the key to store the localized value.
-4. During read operations, the modifier uses `"fr"` to retrieve the correct localized value.
+3. On a write, the modifier stores the localized value under the key `"fr"`.
+4. On a read, the modifier reads the localized value stored under `"fr"`.
 
-**Example request:**
+This request writes French values:
 
 ```http
 POST /content/new
@@ -112,24 +116,24 @@ Content-Type: application/json
 }
 ```
 
-The data is stored under the `"fr"` locale key. A subsequent request with `x-content-language: en` accesses different localized values for the same record.
+The record stores the data under the `"fr"` locale key. A later request with `x-content-language: en` reads and writes other localized values of the same record.
 
-> **Note:** Most modifiers (such as `@Hashed` and `@Encrypted`) do not require `@ModifierKey`. Only modifiers that need a runtime parameter per request require this decorator.
+Most modifiers, such as `@Hashed` and `@Encrypted`, do not need `@ModifierKey`. Only a modifier that needs a runtime value per request needs this decorator.
 
-## Integration with Other Features
+## Integration with other features
 
-### Foreign Keys
+### Foreign keys
 
-Modifiers work automatically with foreign key relationships. When the Data API resolves foreign records, modifier-protected fields on those records are properly unlocked during retrieval. See the [foreign keys documentation](./7.foreign-keys.md) for details.
+Modifiers work with foreign key relationships. When the Data API resolves foreign records, it unlocks the modifier fields of those records. See [Foreign keys](./7.foreign-keys.md) for details.
 
 ### Filters
 
-Custom filters receive a query expression produced by the modifier's `unlockrequest()` method, not a decrypted JavaScript value. Localization supports query-time access; the built-in encryption modifier leaves its stored representation unchanged in query expressions. Do not use it to filter by plaintext. See the [filters documentation](./8.filters.md#modifier-integration) for details.
+A custom filter receives a query expression that the modifier's `unlockrequest()` method builds, not a decrypted JavaScript value. Localization supports access at query time. The built-in encryption modifier leaves its stored value unchanged in query expressions, so do not filter on the plain text of an encrypted field. See [Modifier integration](./8.filters.md#modifier-integration) in the filters page for details.
 
-## Learn More
+## Learn more
 
-For the full list of available modifiers and instructions on creating custom ones, see the [@antelopejs/interface-database-decorators documentation](https://github.com/AntelopeJS/interface-database-decorators).
+For the full list of modifiers and how to write your own, see the [`@antelopejs/interface-database-decorators` repository](https://github.com/AntelopeJS/interface-database-decorators).
 
-## Next Steps
+## Next steps
 
-See the [joined fields documentation](./10.joined.md) to learn how to flatten a remote field onto rows for native sorting and filtering.
+To flatten a field of another table onto each row for sorting and filtering in the database, see [Joined fields](./10.joined.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/interface-data-api",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "AntelopeJS interface that generates CRUD REST endpoints from database tables, with access rules, validation and pagination",
   "keywords": [
     "antelopejs",
@@ -60,16 +60,25 @@
     "release": "pnpm run lint && pnpm run prepack && release-it",
     "test": "pnpm run build && ajs module test .",
     "format:check": "oxfmt --check .",
-    "knip": "knip"
+    "knip": "knip",
+    "prepare": "if git rev-parse --is-inside-work-tree >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1; then lefthook install; fi",
+    "checks": "antelopejs-checks",
+    "size": "antelopejs-check-size",
+    "sync": "antelopejs-sync",
+    "sync:check": "antelopejs-sync --check",
+    "typecheck": "tsc --noEmit",
+    "suppressions": "antelopejs-suppressions",
+    "suppressions:update": "antelopejs-suppressions --update"
   },
   "devDependencies": {
-    "@antelopejs/core": "^1.16.0",
-    "@antelopejs/interface-api": "^0.0.15",
-    "@antelopejs/interface-api-util": "^0.1.3",
-    "@antelopejs/interface-core": "^0.2.4",
-    "@antelopejs/interface-database": "^0.1.11",
-    "@antelopejs/interface-database-decorators": "^0.1.10",
-    "@antelopejs/tooling-configs": "^0.0.9",
+    "@antelopejs/api": "file:.campaign/tgz/antelopejs-api-6afe3e2.tgz",
+    "@antelopejs/core": "~1.20.0",
+    "@antelopejs/interface-api": "^0.2.0",
+    "@antelopejs/interface-api-util": "^0.3.0",
+    "@antelopejs/interface-core": "^0.4.0",
+    "@antelopejs/interface-database": "^0.3.0",
+    "@antelopejs/interface-database-decorators": "^0.2.0",
+    "@antelopejs/tooling-configs": "^0.2.17",
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10.0.10",
     "@types/node": "^22.19.15",
@@ -77,6 +86,7 @@
     "chai": "^4.5.0",
     "eslint-plugin-perfectionist": "^5.11.0",
     "knip": "^6.34.0",
+    "lefthook": "^2.2.2",
     "mongodb-memory-server-core": "^10.4.3",
     "oxfmt": "^0.66.0",
     "oxlint": "1.81.0",
@@ -84,21 +94,32 @@
     "release-it": "^19.2.4",
     "release-it-changelogen": "^0.1.0",
     "rimraf": "^6.1.3",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "zod": "4.5.4"
   },
   "peerDependencies": {
-    "@antelopejs/interface-api": ">=0.0.15 <1.0.0",
+    "@antelopejs/interface-api": ">=0.3.0 <1.0.0",
     "@antelopejs/interface-api-util": ">=0.1.3 <1.0.0",
     "@antelopejs/interface-core": ">=0.2.4 <1.0.0",
     "@antelopejs/interface-database": ">=0.1.10 <1.0.0",
     "@antelopejs/interface-database-decorators": ">=0.1.10 <1.0.0"
   },
-  "packageManager": "pnpm@10.6.5",
+  "packageManager": "pnpm@10.33.0",
+  "pnpm": {
+    "overrides": {
+      "@antelopejs/interface-api": "0.2.0",
+      "@antelopejs/interface-api-util": "0.3.0",
+      "@antelopejs/api": "file:.campaign/tgz/antelopejs-api-6afe3e2.tgz"
+    }
+  },
   "antelopeJs": {
     "standalone": true,
     "test": "src/antelope.test.ts",
     "skills": [
       "./skills"
-    ]
+    ],
+    "docs": {
+      "standard": true
+    }
   }
 }