json-rest-api 1.0.23 → 1.0.24

package/README.md

@@ -72,4 +72,25 @@ app.listen(3000, () => {
 - [Quick Start](QUICKSTART.md) - Quick start
 - [Complete guide](GUIDE/) - Comprehensive guide
 - [API Reference](API.md) - API reference
-- [Why json-rest-api?](docs/COMPARISON.md) - Step-by-step tutorial
+- [Why json-rest-api?](docs/COMPARISON.md) - Step-by-step tutorial
+
+## Development
+
+```bash
+# Run the normalizeId contract suites under the default backend and AnyAPI,
+# then rebuild the checked-in docs site
+npm run verify
+
+# Run lint separately
+npm run lint
+
+# Run the focused normalizeId suites directly
+npm run test:id-contracts
+npm run test:id-contracts:anyapi
+
+# Rebuild the checked-in docs site
+npm run docs
+
+# Serve the docs locally with live rebuild
+npm run docs:dev
+```

package/docs/API.md

@@ -14,6 +14,8 @@ This reference provides comprehensive documentation for all methods, parameters,
 
 4. **All parameters must be passed within a single params object** as the first argument to each method.
 
+5. **Simplified shorthand is payload-only**: when you pass attributes directly (for example, `post({ title: 'Hello' })`), that plain object is treated as the resource payload. If you also need per-call options such as `transaction`, `queryParams`, `simplified`, or `returnFullRecord`, put the record under `inputRecord` and keep those options at the top level of `params`.
+
 ## Table of Contents
 
 1. [Core API Methods](#core-api-methods)
@@ -291,6 +293,8 @@ const result = await api.resources.[resourceType].get(params, context)
 | `simplified` | Boolean | No | Override simplified mode setting (default: true) |
 | `transaction` | Object | No | Database transaction object |
 
+`id` is normalized with the effective `normalizeId` function before validation and lookup. If it normalizes to an empty value, the operation fails as `REST_API_RESOURCE` with subtype `not_found`.
+
 #### Return Value
 
 **JSON:API Mode (simplified: false):**
@@ -430,7 +434,9 @@ const result = await api.resources.[resourceType].post(params, context)
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `inputRecord` | Object | Yes | Resource data to create |
+| `inputRecord.id` | String | No (simplified) | Optional explicit logical resource ID |
 | `inputRecord.data` | Object | Yes (JSON:API) | Resource data container |
+| `inputRecord.data.id` | String | No (JSON:API) | Optional explicit logical resource ID |
 | `inputRecord.data.type` | String | Yes (JSON:API) | Resource type |
 | `inputRecord.data.attributes` | Object | Yes (JSON:API) | Resource attributes |
 | `inputRecord.data.relationships` | Object | No | Related resources |
@@ -439,6 +445,8 @@ const result = await api.resources.[resourceType].post(params, context)
 | `transaction` | Object | No | Database transaction object |
 | `returnFullRecord` | String | No | Override return setting ('no', 'minimal', 'full') |
 
+When an explicit resource id is provided, `normalizeId` runs before persistence and before any follow-up record fetch used for the return payload. If the normalized id is empty, the request fails as `REST_API_VALIDATION` on `data.id`.
+
 #### Return Value Behavior
 
 The return value depends on `returnFullRecord` setting and whether it's an API or transport call:
@@ -515,6 +523,25 @@ const result = await api.resources.articles.post({
 });
 ```
 
+**Create with Explicit ID and Normalization:**
+```javascript
+// With normalizeId configured to trim and uppercase ids,
+// this record is stored as ARTICLE-42
+const result = await api.resources.articles.post({
+  inputRecord: {
+    data: {
+      type: 'articles',
+      id: '  article-42  ',
+      attributes: {
+        title: 'Canonical ID Example',
+        content: 'Stored under the normalized id'
+      }
+    }
+  },
+  simplified: false
+});
+```
+
 **Create with Multiple Relationships:**
 ```javascript
 // Create article with author and tags (simplified)
@@ -591,8 +618,8 @@ const result = await api.resources.[resourceType].put(params, context)
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `inputRecord` | Object | Yes | Complete resource data |
-| `inputRecord.id` | String | Yes (simplified) | Resource ID |
-| `inputRecord.data.id` | String | Yes (JSON:API) | Must match the resource ID |
+| `inputRecord.id` | String | Yes (simplified) | Logical resource ID |
+| `inputRecord.data.id` | String | Yes (JSON:API) | Logical resource ID |
 | `inputRecord.data.type` | String | Yes (JSON:API) | Resource type |
 | `inputRecord.data.attributes` | Object | Yes (JSON:API) | All resource attributes |
 | `inputRecord.data.relationships` | Object | No | All relationships (missing ones are nulled) |
@@ -601,6 +628,10 @@ const result = await api.resources.[resourceType].put(params, context)
 | `transaction` | Object | No | Database transaction object |
 | `returnFullRecord` | String | No | Override return setting |
 
+`inputRecord.id` and `inputRecord.data.id` always refer to the logical resource id. `idProperty` and storage mapping affect the backing column name, not the API field name, and the resource id is not part of `attributes`.
+
+If both the URL id and body id are present, both are normalized before the equality check. If either id normalizes to an empty value, the operation fails before storage is touched.
+
 #### Return Value
 
 Updated resource based on `returnFullRecord` setting (defaults: API='full', transport='no').
@@ -718,8 +749,8 @@ const result = await api.resources.[resourceType].patch(params, context)
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `inputRecord` | Object | Yes | Partial resource data |
-| `inputRecord.id` | String | Yes (simplified) | Resource ID |
-| `inputRecord.data.id` | String | Yes (JSON:API) | Resource ID |
+| `inputRecord.id` | String | Yes (simplified) | Logical resource ID |
+| `inputRecord.data.id` | String | Yes (JSON:API) | Logical resource ID |
 | `inputRecord.data.type` | String | Yes (JSON:API) | Resource type |
 | `inputRecord.data.attributes` | Object | No | Attributes to update |
 | `inputRecord.data.relationships` | Object | No | Relationships to update |
@@ -728,6 +759,8 @@ const result = await api.resources.[resourceType].patch(params, context)
 | `transaction` | Object | No | Database transaction object |
 | `returnFullRecord` | String | No | Override return setting |
 
+If both the URL id and body id are present, both are normalized before the equality check. If either id normalizes to an empty value, the operation fails before storage is touched.
+
 #### Return Value
 
 Updated resource based on `returnFullRecord` setting (defaults: API='full', transport='no').
@@ -849,6 +882,8 @@ const result = await api.resources.[resourceType].delete(params, context)
 | `id` | String\|Number | Yes | ID of resource to delete |
 | `transaction` | Object | No | Database transaction object |
 
+`id` is normalized with the effective `normalizeId` function before validation and lookup. If it normalizes to an empty value, the operation fails as `REST_API_RESOURCE` with subtype `not_found`.
+
 #### Return Value
 
 Returns `undefined` (204 No Content)
@@ -935,6 +970,8 @@ const result = await api.resources.[resourceType].getRelated(params, context)
 | `queryParams` | Object | No | Standard query parameters for related resources |
 | `transaction` | Object | No | Database transaction object |
 
+`id` is normalized with the effective `normalizeId` function before validation and lookup. If it normalizes to an empty value, the operation fails as `REST_API_RESOURCE` with subtype `not_found`.
+
 #### Return Value
 
 JSON:API response with related resources (supports all query features like filtering, pagination, etc.)
@@ -1007,6 +1044,8 @@ const result = await api.resources.[resourceType].getRelationship(params, contex
 }
 ```
 
+`id` is normalized with the effective `normalizeId` function before validation and lookup. If it normalizes to an empty value, the operation fails as `REST_API_RESOURCE` with subtype `not_found`.
+
 #### Return Value
 
 JSON:API relationship document with resource identifiers only
@@ -1081,6 +1120,8 @@ const result = await api.resources.[resourceType].postRelationship(params, conte
 }
 ```
 
+The parent `id` is normalized with the parent resource's normalizer. Each `relationshipData[*].id` is normalized with the related target resource's normalizer before validation and persistence.
+
 #### Return Value
 
 Returns `undefined` (204 No Content)
@@ -1116,6 +1157,8 @@ await api.resources.articles.postRelationship({
 // Existing tags remain, new tags are added
 ```
 
+If `normalizeId` is configured, both the parent id and each relationship identifier are normalized before the relationship is written.
+
 ---
 
 ### patchRelationship - Replace Relationship
@@ -1138,6 +1181,8 @@ const result = await api.resources.[resourceType].patchRelationship(params, cont
 }
 ```
 
+The parent `id` is normalized with the parent resource's normalizer. Each relationship identifier inside `relationshipData` is normalized with the related target resource's normalizer before validation and persistence.
+
 #### Return Value
 
 Returns `undefined` (204 No Content)
@@ -1219,6 +1264,8 @@ const result = await api.resources.[resourceType].deleteRelationship(params, con
 }
 ```
 
+The parent `id` is normalized with the parent resource's normalizer. Each `relationshipData[*].id` is normalized with the related target resource's normalizer before validation and persistence.
+
 #### Return Value
 
 Returns `undefined` (204 No Content)
@@ -2075,24 +2122,30 @@ api.resource('articles').hook('afterDataQuery', async (context) => {
 ### Plugin Configuration
 
 ```javascript
-const restApiPlugin = new RestApiPlugin({
+await api.use(RestApiPlugin, {
   // API behavior
   simplifiedApi: true,              // Use simplified mode for programmatic calls (default: true)
   simplifiedTransport: false,       // Use JSON:API for HTTP transport (default: false)
+  normalizeId: (value) => {
+    if (value === null || value === undefined) {
+      return null
+    }
+
+    const normalized = String(value).trim()
+    return normalized ? normalized.toUpperCase() : null
+  },
   
   // Return record configuration
   returnRecordApi: {
     post: 'full',                   // Return full record after create (default)
     put: 'full',                    // Return full record after replace (default)
-    patch: 'full',                  // Return full record after update (default)
-    delete: 'no'                    // Return nothing after delete (default)
+    patch: 'full'                   // Return full record after update (default)
   },
   
   returnRecordTransport: {
     post: 'no',                     // Return 204 for HTTP POST (default)
     put: 'no',                      // Return 204 for HTTP PUT (default)
-    patch: 'no',                    // Return 204 for HTTP PATCH (default)
-    delete: 'no'                    // Return 204 for HTTP DELETE (default)
+    patch: 'no'                     // Return 204 for HTTP PATCH (default)
   },
   
   // Query limits
@@ -2103,15 +2156,7 @@ const restApiPlugin = new RestApiPlugin({
   includeDepthLimit: 3,             // Maximum relationship nesting depth
   
   // Performance
-  enablePaginationCounts: true,     // Execute count queries for total pages
-  
-  // Error handling
-  exposeErrors: false,              // Include error details in responses
-  
-  // Custom serializers
-  serializers: {
-    articles: customArticleSerializer
-  }
+  enablePaginationCounts: true      // Execute count queries for total pages
 });
 ```
 
@@ -2126,7 +2171,7 @@ api.addResource({
   name: 'articles',
   
   // Primary key configuration
-  idProperty: 'id',                 // Custom primary key field (default: 'id')
+  idProperty: 'id',                 // Physical primary-key column name for table-backed resources
   
   schema: {
     // Attributes
@@ -2273,19 +2318,95 @@ api.addResource({
 
 #### ID Property Configuration
 ```javascript
-// Custom primary key
+// Physical primary key column: user_id
 api.addResource({
   name: 'users',
-  idProperty: 'user_id',  // Use 'user_id' instead of 'id'
+  idProperty: 'user_id',
   schema: {
-    attributes: {
-      user_id: { type: 'number', required: true },
-      email: { type: 'string', required: true }
+    id: { type: 'id', required: true, storage: { column: 'user_id' } },
+    email: { type: 'string', required: true },
+    displayName: { type: 'string' }
+  }
+});
+```
+
+`idProperty` names the physical primary-key column for table-backed resources. At the API layer, the resource id remains `id`, so writes use `inputRecord.id` or `inputRecord.data.id`, reads return `id` or `data.id`, and the resource id is not part of `attributes`.
+
+#### Resource ID Normalization
+
+`normalizeId` canonicalizes resource identifiers before the library reads, writes, validates, or links records.
+
+The default normalizer:
+
+- trims surrounding whitespace from strings
+- converts finite numbers and bigints to strings
+- rejects values that normalize to an empty identifier
+
+Provide a custom normalizer when your ids need additional canonicalization:
+
+```javascript
+await api.use(RestApiPlugin, {
+  normalizeId: (value) => {
+    if (value === null || value === undefined) {
+      return null
     }
+
+    const normalized = String(value).trim()
+    return normalized ? normalized.toUpperCase() : null
+  }
+});
+```
+
+Resource-level overrides take precedence over the plugin-level default:
+
+```javascript
+await api.addResource('countries', {
+  normalizeId: (value) => {
+    if (value === null || value === undefined) {
+      return null
+    }
+
+    const normalized = String(value).trim()
+    return normalized ? normalized.toLowerCase() : null
+  },
+  schema: {
+    name: { type: 'string', required: true }
+  }
+});
+```
+
+Normalization is applied to:
+
+- parent ids used by `get`, `put`, `patch`, `delete`, `getRelated`, and `getRelationship`
+- explicit `POST`, `PUT`, and `PATCH` document ids
+- relationship identifiers used by `postRelationship`, `patchRelationship`, and `deleteRelationship`
+
+Relationship identifiers use the normalizer of the related target resource, not the parent resource.
+
+If an id normalizes to an empty value:
+
+- existing-resource operations fail as `REST_API_RESOURCE` with subtype `not_found`
+- explicit `POST` document ids fail as `REST_API_VALIDATION` on `data.id`
+
+#### Storage Column Naming
+
+Table-backed resources use snake_case physical columns by default. For example, `displayName` maps to `display_name`.
+
+Use `storage.column` when a field needs a specific column name:
+
+```javascript
+api.addResource({
+  name: 'profiles',
+  schema: {
+    id: { type: 'id' },
+    displayName: { type: 'string', required: true },
+    legacyRef: { type: 'string', storage: { column: 'legacy_profile_ref' } }
   }
 });
 ```
 
+If physical columns should match logical field names exactly for an entire resource, use `storage: { naming: 'exact' }`.
+
 #### Virtual Fields
 Virtual fields are excluded from database operations but can be used for temporary UI state:
 

package/docs/GUIDE/GUIDE_1_Initial_Setup.md

@@ -325,6 +325,8 @@ const result = await api.resources.countries.post({
 });
 ```
 
+If you need per-call options such as `transaction`, `returnFullRecord`, or `queryParams`, move the record under `inputRecord` and keep those options at the top level of the params object.
+
 By default, `simplifiedApi` is `true` for programmatic usage, making it easier to work with the API in your code while still maintaining full JSON:API compliance internally.
 
 #### API usage and returning records
@@ -778,6 +780,7 @@ Here is a full list of parameters and their respective variables:
 | `simplifiedApi` | `vars.simplifiedApi` | `true` | Use simplified format for programmatic API calls | ✓ |
 | `simplifiedTransport` | `vars.simplifiedTransport` | `false` | Use simplified format for HTTP/REST endpoints | ✓ |
 | `idProperty` | `vars.idProperty` | `'id'` | Name of the ID field in resources | ✓ |
+| `normalizeId` | `vars.normalizeId` | trim strings, stringify finite numbers | Normalize resource identifiers before lookups and writes | ✓ |
 | `returnRecordApi` | `vars.returnRecordApi` | `{ post: 'full', put: 'full', patch: 'full' }` | What to return for programmatic API write operations | ✓ |
 | `returnRecordTransport` | `vars.returnRecordTransport` | `{ post: 'no', put: 'no', patch: 'no' }` | What to return for HTTP/REST write operations | ✓ |
 
@@ -795,9 +798,79 @@ Here is a full list of parameters and their respective variables:
   - An object: `{ post: 'full', put: 'minimal', patch: 'no' }` (per-method configuration)
 - All parameters support the cascade: per-call → resource-level → plugin-level default
 
-# Custom ID parameter
+# Logical IDs and Physical Columns
+
+For table-backed resources, `idProperty` defines the physical primary-key column. The API surface still uses the logical resource id.
+
+- simplified writes use `inputRecord.id`
+- JSON:API writes use `inputRecord.data.id`
+- responses expose `id` or `data.id`
+- the resource id is not part of `attributes`
+
+```javascript
+await api.addResource('profiles', {
+  idProperty: 'user_id',
+  schema: {
+    id: { type: 'id', required: true, storage: { column: 'user_id' } },
+    displayName: { type: 'string', required: true },
+    loginCount: { type: 'number', defaultTo: 0 }
+  },
+  tableName: 'profiles'
+});
+```
+
+For table-backed resources, storage columns default to snake_case, so `displayName` maps to `display_name` and `loginCount` maps to `login_count`. Use `storage.column` for a per-field override, or `storage: { naming: 'exact' }` when physical column names should match logical field names exactly.
+
+## ID normalization
+
+`normalizeId` lets you canonicalize resource identifiers before the library reads, writes, validates, or links records.
+
+The default normalizer already handles the common cases:
+
+- trims surrounding whitespace from strings
+- converts finite numbers and bigints to strings
+- rejects values that normalize to an empty identifier
+
+You only need to provide `normalizeId` when your resource ids need additional canonicalization, such as uppercasing, lowercasing, or removing formatting characters.
+
+```javascript
+await api.use(RestApiPlugin, {
+  normalizeId: (value) => {
+    if (value === null || value === undefined) return null
+
+    const normalized = String(value).trim()
+    return normalized ? normalized.toUpperCase() : null
+  }
+})
+
+await api.addResource('countries', {
+  // Override the plugin-wide normalizer for this one resource
+  normalizeId: (value) => {
+    if (value === null || value === undefined) return null
+
+    const normalized = String(value).trim()
+    return normalized ? normalized.toLowerCase() : null
+  },
+  schema: {
+    name: { type: 'string', required: true }
+  }
+})
+```
+
+Normalization is applied consistently to:
+
+- `get`, `put`, `patch`, `delete`, `getRelated`, and `getRelationship` parent ids
+- explicit resource ids in `POST`, `PUT`, and `PATCH` documents
+- relationship identifiers supplied to `postRelationship`, `patchRelationship`, and `deleteRelationship`
+
+The resource-level `normalizeId` override also applies to relationship identifiers when that resource appears as the related target.
+
+If an id normalizes to an empty value:
+
+- existing-resource operations behave as `not_found`
+- explicit `POST` document ids are rejected as validation errors on `data.id`
 
-TODO: Explain how idParam works, clarify that for the api it's always 'id' and there is no ID in the attributes
+For full examples of table creation, physical column naming, and migration generation, see [Knex Schema and Migrations](GUIDE_X_Knex_Schema_And_Migrations.md).
 
 # Helpers and Methods Provided by REST API Plugins
 
@@ -828,8 +901,14 @@ When you install the REST API plugins, the following helpers are added to `api.h
   const trx = await api.helpers.newTransaction();
   try {
     // Use transaction in multiple operations
-    await api.resources.countries.post({ name: 'France', code: 'FR' }, { transaction: trx });
-    await api.resources.publishers.post({ name: 'French Press', country: 1 }, { transaction: trx });
+    await api.resources.countries.post({
+      inputRecord: { name: 'France', code: 'FR' },
+      transaction: trx
+    });
+    await api.resources.publishers.post({
+      inputRecord: { name: 'French Press', country: 1 },
+      transaction: trx
+    });
     await trx.commit();
   } catch (error) {
     await trx.rollback();

package/docs/GUIDE/GUIDE_X_Knex_Schema_And_Migrations.md

@@ -29,8 +29,8 @@ Example:
 await api.addResource('memberships', {
   schema: {
     id: { type: 'id' },
-    workspaceId: { type: 'id', required: true, storage: { column: 'workspace_id' } },
-    userId: { type: 'id', required: true, storage: { column: 'user_id' } },
+    workspaceId: { type: 'id', required: true },
+    userId: { type: 'id', required: true },
     role: { type: 'string', enum: ['owner', 'member'], required: true, defaultTo: 'member' }
   },
 
@@ -64,6 +64,126 @@ await api.addResource('memberships', {
 })
 ```
 
+## Default Column Naming
+
+Table-backed resources keep logical field names in the resource schema and map them to physical columns for Knex operations.
+
+By default, physical columns use snake_case:
+
+- `workspaceId` -> `workspace_id`
+- `userId` -> `user_id`
+- `createdAt` -> `created_at`
+
+This keeps the API surface expressive without repeating `storage.column` on every camelCase field.
+
+You only need `storage.column` when a field should use a non-standard column name:
+
+```js
+await api.addResource('profiles', {
+  schema: {
+    id: { type: 'id' },
+    displayName: { type: 'string', required: true },
+    legacyRef: { type: 'string', storage: { column: 'legacy_profile_ref' } }
+  },
+  tableName: 'profiles'
+})
+```
+
+If you need physical columns to match the logical field names exactly for a whole resource, opt out explicitly:
+
+```js
+await api.addResource('verbatim_profiles', {
+  storage: { naming: 'exact' },
+  schema: {
+    id: { type: 'id' },
+    displayName: { type: 'string', required: true }
+  },
+  tableName: 'verbatim_profiles'
+})
+```
+
+## Logical IDs and `idProperty`
+
+`idProperty` names the physical primary-key column for table-backed resources. The API contract still uses the logical resource id.
+
+```js
+await api.addResource('profiles', {
+  idProperty: 'user_id',
+  schema: {
+    id: { type: 'id', required: true, storage: { column: 'user_id' } },
+    displayName: { type: 'string', required: true },
+    loginCount: { type: 'number', defaultTo: 0 }
+  },
+  tableName: 'profiles'
+})
+```
+
+With this definition:
+
+- writes send the resource id as `id` or `data.id`
+- reads return the resource id as `id` or `data.id`
+- the primary key is stored in `user_id`
+- `displayName` and `loginCount` are stored in `display_name` and `login_count`
+
+The resource id is not part of `attributes`:
+
+```js
+await api.resources.profiles.post({
+  inputRecord: {
+    data: {
+      type: 'profiles',
+      id: '42',
+      attributes: {
+        displayName: 'Mercury'
+      }
+    }
+  }
+})
+```
+
+### ID normalization
+
+If your primary keys need canonicalization beyond the default trim-and-stringify behavior, configure `normalizeId`.
+
+```js
+await api.use(RestApiPlugin, {
+  normalizeId: (value) => {
+    if (value === null || value === undefined) return null
+
+    const normalized = String(value).trim()
+    return normalized ? normalized.toUpperCase() : null
+  }
+})
+```
+
+You can override that per resource:
+
+```js
+await api.addResource('profiles', {
+  idProperty: 'user_id',
+  normalizeId: (value) => {
+    if (value === null || value === undefined) return null
+
+    const normalized = String(value).trim()
+    return normalized ? normalized.toLowerCase() : null
+  },
+  schema: {
+    id: { type: 'id', required: true, storage: { column: 'user_id' } },
+    displayName: { type: 'string', required: true }
+  },
+  tableName: 'profiles'
+})
+```
+
+For table-backed resources, `normalizeId` is applied before:
+
+- reading a record by id
+- replacing, patching, or deleting a record
+- persisting an explicit `POST` resource id
+- validating or writing relationship identifiers that point at the resource
+
+If the normalizer returns an empty value, existing-resource operations fail as `not_found`, while explicit `POST` document ids fail validation on `data.id`.
+
 ## Create Tables
 
 Create the table directly from the resource definition:

package/lib/enhanced-logger.js

@@ -3,7 +3,7 @@
  * Wraps any logger to provide comprehensive error logging
  */
 
-import { formatError, formatErrorSummary, formatErrorString } from './error-formatter.js'
+import { formatError, formatErrorSummary } from './error-formatter.js'
 
 /**
  * Creates an enhanced logger that automatically formats errors

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "json-rest-api",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "main": "index.js",
   "type": "module",
   "scripts": {
     "test": "node --test tests/*.test.js",
     "test:anyapi": "JSON_REST_API_STORAGE=anyapi node --test tests/*.test.js",
+    "test:id-contracts": "node --test tests/id-normalization.test.js tests/logical-id-write-validation.test.js tests/custom-id-simplified-post.test.js",
+    "test:id-contracts:anyapi": "JSON_REST_API_STORAGE=anyapi node --test tests/id-normalization.test.js",
     "docs": "node scripts/run-docs.js",
+    "docs:dev": "node scripts/run-docs.js --serve",
+    "verify": "npm run test:id-contracts && npm run test:id-contracts:anyapi && npm run docs",
     "sloc": "sloc --exclude \"(_site|node_modules|\\.git|vendor|docs)\" .",
     "slod": "cd docs;echo 'DOC LINES:'; cat `find . -iname \\*md | grep -v _site | grep -v vendor` | wc",
     "lint": "eslint .",
@@ -25,7 +29,7 @@
   "description": "REST API plugin for hooked-api with JSON:API compliance",
   "dependencies": {
     "hooked-api": "^1.0.24",
-    "json-rest-schema": "^1.0.13",
+    "json-rest-schema": "^1.0.14",
     "semver": "^7.7.2"
   },
   "peerDependencies": {