@stonyx/orm 0.3.2-alpha.56 → 0.3.2-alpha.58

package/README.md

@@ -463,7 +463,7 @@ const verdict = predicate?.(request, { model: 'animal', operation: 'read' });
 ```
 
 `Orm.instance.getAccess(modelName)` returns the predicate, or `undefined` when
-that model has no access class. The raw map is `Orm.instance.accessFiles`, keyed
+that model has no access class. The raw map is `Orm.instance.accessFunctions`, keyed
 by model name; prefer `getAccess()`.
 
 Passing the context explicitly is what makes the answer **model-correct**. A

package/dist/index.d.ts

@@ -9,7 +9,7 @@ import { count, avg, sum, min, max } from './aggregates.js';
 export { default } from './main.js';
 export { store, relationships } from './main.js';
 export type { PersistErrorDetail } from './main.js';
-export type { AccessContext, AccessFunction, AccessMethod } from './types/orm-types.js';
+export type { AccessContext, AccessFunction, AccessMethod, AccessOperation } from './types/orm-types.js';
 export { Model, View, Serializer };
 export { attr, belongsTo, hasMany, createRecord, updateRecord };
 export { count, avg, sum, min, max };

package/dist/main.d.ts

@@ -34,7 +34,25 @@ export default class Orm {
     transforms: Record<string, (value: unknown) => unknown>;
     warnings: Set<string>;
     /**
-     * Model name -> that model's `access` predicate (abofs/stonyx-orm#202).
+     * Model name -> the `access` predicate of the access class that CLAIMS that
+     * model (abofs/stonyx-orm#202).
+     *
+     * Not "that model's own predicate". One access class may claim many models
+     * -- `GlobalAccess` in this repo's fixtures declares five, and `models = '*'`
+     * claims every model in the store -- and it declares ONE `access` method, so
+     * the same function object is registered under every one of those keys.
+     * `getAccess('owner') === getAccess('animal')` is `true` there. The
+     * one-to-one guarantee below is key -> function, never function -> model,
+     * and a caller must not read a resolved predicate as being animal-specific.
+     * What makes the ANSWER model-specific is the context the caller passes and
+     * the predicate actually reading it -- see {@link Orm#getAccess}.
+     *
+     * NAMED FOR WHAT IT HOLDS. It was `accessFiles` through review, inherited
+     * from the function-local in `setup-rest-server.ts` where the values came
+     * straight out of `forEachFileImport` and "files" was defensible. The values
+     * are `AccessFunction`s, and the sibling public registries on this class
+     * (`models`, `serializers`, `views`, `transforms`) are all plural nouns of
+     * the thing held. Renamed here because #202 is the last moment it is free.
      *
      * Populated by `setup-rest-server.ts` at boot, from the access classes under
      * `config.orm.paths.access`, BEFORE any route is mounted -- so it is complete
@@ -53,10 +71,13 @@ export default class Orm {
      * request routed to model Y -- inexpressible, which is the capability
      * abofs/stonyx-orm#196 and abofs/stonyx-orm#207 are built on.
      *
-     * Empty when the REST server is disabled, or when no access configuration
-     * could be loaded. Prefer {@link Orm#getAccess} over indexing this directly.
+     * Empty when the REST server is disabled, and PARTIAL when one access file
+     * failed to load (`setup-rest-server.ts` catches, warns and assigns whatever
+     * it had). So a missing key does NOT mean the model has no access class.
+     * Prefer {@link Orm#getAccess} over indexing this directly -- it is guarded
+     * against the prototype chain and this is not.
      */
-    accessFiles: Record<string, AccessFunction>;
+    accessFunctions: Record<string, AccessFunction>;
     options: OrmOptions;
     sqlDb?: SqlDb;
     db?: OrmDB | SqlDb;
@@ -81,7 +102,7 @@ export default class Orm {
      * collection the request is ADDRESSED TO -- owners -- while being asked about
      * animals, and per #202's thesis it answers wrong in the granting direction.
      *
-     * OWN PROPERTIES ONLY. A bare `this.accessFiles[modelName]` walks the
+     * OWN PROPERTIES ONLY. A bare `this.accessFunctions[modelName]` walks the
      * prototype chain, so `getAccess('constructor')` resolved `Object` and
      * `getAccess('toString')` resolved `Object.prototype.toString` -- both
      * callable, and the documented `predicate?.(request, ctx)` pattern then

package/dist/main.js

@@ -39,7 +39,25 @@ export default class Orm {
     transforms = { ...baseTransforms };
     warnings = new Set();
     /**
-     * Model name -> that model's `access` predicate (abofs/stonyx-orm#202).
+     * Model name -> the `access` predicate of the access class that CLAIMS that
+     * model (abofs/stonyx-orm#202).
+     *
+     * Not "that model's own predicate". One access class may claim many models
+     * -- `GlobalAccess` in this repo's fixtures declares five, and `models = '*'`
+     * claims every model in the store -- and it declares ONE `access` method, so
+     * the same function object is registered under every one of those keys.
+     * `getAccess('owner') === getAccess('animal')` is `true` there. The
+     * one-to-one guarantee below is key -> function, never function -> model,
+     * and a caller must not read a resolved predicate as being animal-specific.
+     * What makes the ANSWER model-specific is the context the caller passes and
+     * the predicate actually reading it -- see {@link Orm#getAccess}.
+     *
+     * NAMED FOR WHAT IT HOLDS. It was `accessFiles` through review, inherited
+     * from the function-local in `setup-rest-server.ts` where the values came
+     * straight out of `forEachFileImport` and "files" was defensible. The values
+     * are `AccessFunction`s, and the sibling public registries on this class
+     * (`models`, `serializers`, `views`, `transforms`) are all plural nouns of
+     * the thing held. Renamed here because #202 is the last moment it is free.
      *
      * Populated by `setup-rest-server.ts` at boot, from the access classes under
      * `config.orm.paths.access`, BEFORE any route is mounted -- so it is complete
@@ -58,10 +76,13 @@ export default class Orm {
      * request routed to model Y -- inexpressible, which is the capability
      * abofs/stonyx-orm#196 and abofs/stonyx-orm#207 are built on.
      *
-     * Empty when the REST server is disabled, or when no access configuration
-     * could be loaded. Prefer {@link Orm#getAccess} over indexing this directly.
+     * Empty when the REST server is disabled, and PARTIAL when one access file
+     * failed to load (`setup-rest-server.ts` catches, warns and assigns whatever
+     * it had). So a missing key does NOT mean the model has no access class.
+     * Prefer {@link Orm#getAccess} over indexing this directly -- it is guarded
+     * against the prototype chain and this is not.
      */
-    accessFiles = {};
+    accessFunctions = {};
     options;
     sqlDb;
     db;
@@ -187,7 +208,7 @@ export default class Orm {
      * collection the request is ADDRESSED TO -- owners -- while being asked about
      * animals, and per #202's thesis it answers wrong in the granting direction.
      *
-     * OWN PROPERTIES ONLY. A bare `this.accessFiles[modelName]` walks the
+     * OWN PROPERTIES ONLY. A bare `this.accessFunctions[modelName]` walks the
      * prototype chain, so `getAccess('constructor')` resolved `Object` and
      * `getAccess('toString')` resolved `Object.prototype.toString` -- both
      * callable, and the documented `predicate?.(request, ctx)` pattern then
@@ -206,9 +227,9 @@ export default class Orm {
      *   note above. Treat it as deny.
      */
     getAccess(modelName) {
-        if (!Object.hasOwn(this.accessFiles, modelName))
+        if (!Object.hasOwn(this.accessFunctions, modelName))
             return undefined;
-        return this.accessFiles[modelName];
+        return this.accessFunctions[modelName];
     }
     async startup() {
         if (this.sqlDb)

package/dist/setup-rest-server.js

@@ -8,7 +8,7 @@ import { dbKey } from './db.js';
 import { getPluralName } from './plural-registry.js';
 import log from 'stonyx/log';
 export default async function (route, accessPath, metaRoute) {
-    const accessFiles = {};
+    const accessFunctions = {};
     try {
         await forEachFileImport(accessPath, (accessClass) => {
             const accessInstance = new accessClass();
@@ -25,9 +25,9 @@ export default async function (route, accessPath, metaRoute) {
                     continue;
                 if (!store.data.has(model))
                     throw new Error(`Unable to define access for Invalid Model "${model}". Model does not exist`);
-                if (accessFiles[model])
+                if (accessFunctions[model])
                     throw new Error(`Access for model "${model}" has already been defined by another access class.`);
-                accessFiles[model] = accessInstance.access;
+                accessFunctions[model] = accessInstance.access;
             }
         });
     }
@@ -38,7 +38,7 @@ export default async function (route, accessPath, metaRoute) {
     // -------------------------------------------------------------------------
     // #202 -- the registry has to survive this function.
     //
-    // `accessFiles` used to be a function-local that was discarded at the return
+    // `accessFunctions` used to be a function-local that was discarded at the return
     // below, so the only thing that ever saw it was the mount loop. Each mounted
     // OrmRequest then held its OWN model's predicate and nothing held the map, so
     // at request time there was no route from a model NAME to that model's
@@ -56,12 +56,12 @@ export default async function (route, accessPath, metaRoute) {
     // set of predicates that is actually enforcing. A guard here that skipped the
     // assignment would let the registry go silently missing, which is precisely
     // the failure #202's AC8 exists to catch.
-    Orm.instance.accessFiles = accessFiles;
+    Orm.instance.accessFunctions = accessFunctions;
     await waitForModule('rest-server');
     // Remove "/" prefix and name mount point accordingly
     const name = route === '/' ? 'index' : (route[0] === '/' ? route.slice(1) : route);
     // Configure endpoints for models and views with access configuration
-    for (const [model, access] of Object.entries(accessFiles)) {
+    for (const [model, access] of Object.entries(accessFunctions)) {
         const pluralizedModel = getPluralName(model);
         const modelName = name === 'index' ? pluralizedModel : `${name}/${pluralizedModel}`;
         RestServer.instance.mountRoute(OrmRequest, { name: modelName, options: { model, access } });

package/dist/types/orm-types.d.ts

@@ -176,6 +176,20 @@ export interface SnapshotEntry {
  * Anything else fails CLOSED. See `src/orm-request.ts` `auth()`.
  */
 export type AccessMethod = string | boolean | string[] | ((record: unknown) => boolean);
+/**
+ * The closed vocabulary `AccessContext.operation` is drawn from
+ * (abofs/stonyx-orm#202).
+ *
+ * A literal union rather than `string`, so the guarantee the prose makes is the
+ * one the compiler enforces: a consumer who writes `operation === 'GET'` or
+ * `operation === 'get'` -- the hook vocabulary, see below -- gets a compile
+ * error instead of a comparison that never matches. A predicate that stops
+ * matching falls through to the permission array, so the misreading is
+ * fail-open shaped.
+ *
+ * In-repo precedent: `PersistErrorDetail.operation` in `src/main.ts`.
+ */
+export type AccessOperation = 'read' | 'create' | 'update' | 'delete';
 /**
  * The structural facts about the request being authorised, handed to a consumer
  * `access()` predicate as its SECOND argument (abofs/stonyx-orm#202).
@@ -205,27 +219,47 @@ export interface AccessContext {
      */
     model: string;
     /**
-     * The operation being authorised: `'read'`, `'create'`, `'update'` or
-     * `'delete'`, and no second vocabulary. These are exactly the values of
+     * The operation being authorised. Exactly one of the four {@link
+     * AccessOperation} verbs, or `undefined`. These are exactly the values of
      * `methodAccessMap` in `src/orm-request.ts`, which is also what the
      * permission-array return shape is matched against -- so the two forms cannot
      * disagree.
      *
+     * NOT the hook vocabulary. `HookContext.operation` (`src/hooks.ts`) carries
+     * `'list' | 'get' | 'create' | 'update' | 'delete'` on an identically-named
+     * key of an identically-shaped context object, and the access vocabulary
+     * collapses `list` and `get` into `'read'`. For one `GET /animals/1` a hook
+     * sees `'get'` and `access()` sees `'read'`. "No second vocabulary" is a
+     * statement about the ACCESS path only.
+     *
      * `undefined` when the dispatched method has no entry in that map. Express
      * delivers `HEAD` to the `GET` handler, so this is reachable. It is left
      * undefined rather than defaulted on purpose: a fabricated `'read'` would
      * turn an unclassified request into an authorised one.
+     *
+     * The KEY is required even though the value may be undefined: `auth()` always
+     * sets it, and a context that simply omitted it would be indistinguishable
+     * from one that classified the request and found nothing.
      */
-    operation?: string;
+    operation: AccessOperation | undefined;
 }
 /**
  * A consumer `access()` predicate.
  *
- * `context` is optional in the type because the second argument is ADDITIVE:
- * JavaScript ignores extra arguments, so every pre-#202 single-argument
- * predicate keeps working untouched. Changing the FIRST argument instead would
- * have been the breaking form, and a predicate that can no longer identify its
- * collection falls through to a full CRUD grant -- so the "safer" breaking
- * change would have converted every unmigrated predicate into a fail-open.
+ * The second argument is ADDITIVE: JavaScript ignores extra arguments, so every
+ * pre-#202 single-argument predicate keeps working untouched. Changing the
+ * FIRST argument instead would have been the breaking form, and a predicate
+ * that can no longer identify its collection falls through to a full CRUD
+ * grant -- so the "safer" breaking change would have converted every unmigrated
+ * predicate into a fail-open.
+ *
+ * `context` is nonetheless REQUIRED in the type, and that costs back-compat
+ * nothing. TypeScript already lets a fewer-parameter implementation satisfy a
+ * more-parameter signature, so an arity-1 predicate assigns to this type
+ * cleanly -- measured under `--strict`. What the `?` bought was the opposite of
+ * safety: it silently permitted `getAccess('animal')?.(request)` at the CALL
+ * site, i.e. exactly the omission {@link AccessContext} exists to prevent, and
+ * that call gets the model-wrong answer. Required, a caller that drops the
+ * context gets `TS2554: Expected 2 arguments, but got 1`.
  */
-export type AccessFunction = (request: unknown, context?: AccessContext) => AccessMethod;
+export type AccessFunction = (request: unknown, context: AccessContext) => AccessMethod;

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.3.2-alpha.56",
+  "version": "0.3.2-alpha.58",
   "description": "",
   "main": "dist/index.js",
   "type": "module",

package/src/index.ts

@@ -27,7 +27,7 @@ import { count, avg, sum, min, max } from './aggregates.js';
 export { default } from './main.js';
 export { store, relationships } from './main.js';
 export type { PersistErrorDetail } from './main.js';
-export type { AccessContext, AccessFunction, AccessMethod } from './types/orm-types.js'; // access() contract (#202)
+export type { AccessContext, AccessFunction, AccessMethod, AccessOperation } from './types/orm-types.js'; // access() contract (#202)
 export { Model, View, Serializer }; // base classes
 export { attr, belongsTo, hasMany, createRecord, updateRecord }; // helpers
 export { count, avg, sum, min, max }; // aggregate helpers

package/src/main.ts

@@ -71,7 +71,25 @@ export default class Orm {
   warnings: Set<string> = new Set();
 
   /**
-   * Model name -> that model's `access` predicate (abofs/stonyx-orm#202).
+   * Model name -> the `access` predicate of the access class that CLAIMS that
+   * model (abofs/stonyx-orm#202).
+   *
+   * Not "that model's own predicate". One access class may claim many models
+   * -- `GlobalAccess` in this repo's fixtures declares five, and `models = '*'`
+   * claims every model in the store -- and it declares ONE `access` method, so
+   * the same function object is registered under every one of those keys.
+   * `getAccess('owner') === getAccess('animal')` is `true` there. The
+   * one-to-one guarantee below is key -> function, never function -> model,
+   * and a caller must not read a resolved predicate as being animal-specific.
+   * What makes the ANSWER model-specific is the context the caller passes and
+   * the predicate actually reading it -- see {@link Orm#getAccess}.
+   *
+   * NAMED FOR WHAT IT HOLDS. It was `accessFiles` through review, inherited
+   * from the function-local in `setup-rest-server.ts` where the values came
+   * straight out of `forEachFileImport` and "files" was defensible. The values
+   * are `AccessFunction`s, and the sibling public registries on this class
+   * (`models`, `serializers`, `views`, `transforms`) are all plural nouns of
+   * the thing held. Renamed here because #202 is the last moment it is free.
    *
    * Populated by `setup-rest-server.ts` at boot, from the access classes under
    * `config.orm.paths.access`, BEFORE any route is mounted -- so it is complete
@@ -90,10 +108,13 @@ export default class Orm {
    * request routed to model Y -- inexpressible, which is the capability
    * abofs/stonyx-orm#196 and abofs/stonyx-orm#207 are built on.
    *
-   * Empty when the REST server is disabled, or when no access configuration
-   * could be loaded. Prefer {@link Orm#getAccess} over indexing this directly.
+   * Empty when the REST server is disabled, and PARTIAL when one access file
+   * failed to load (`setup-rest-server.ts` catches, warns and assigns whatever
+   * it had). So a missing key does NOT mean the model has no access class.
+   * Prefer {@link Orm#getAccess} over indexing this directly -- it is guarded
+   * against the prototype chain and this is not.
    */
-  accessFiles: Record<string, AccessFunction> = {};
+  accessFunctions: Record<string, AccessFunction> = {};
 
   options!: OrmOptions;
   sqlDb?: SqlDb;
@@ -240,7 +261,7 @@ export default class Orm {
    * collection the request is ADDRESSED TO -- owners -- while being asked about
    * animals, and per #202's thesis it answers wrong in the granting direction.
    *
-   * OWN PROPERTIES ONLY. A bare `this.accessFiles[modelName]` walks the
+   * OWN PROPERTIES ONLY. A bare `this.accessFunctions[modelName]` walks the
    * prototype chain, so `getAccess('constructor')` resolved `Object` and
    * `getAccess('toString')` resolved `Object.prototype.toString` -- both
    * callable, and the documented `predicate?.(request, ctx)` pattern then
@@ -259,9 +280,9 @@ export default class Orm {
    *   note above. Treat it as deny.
    */
   getAccess(modelName: string): AccessFunction | undefined {
-    if (!Object.hasOwn(this.accessFiles, modelName)) return undefined;
+    if (!Object.hasOwn(this.accessFunctions, modelName)) return undefined;
 
-    return this.accessFiles[modelName];
+    return this.accessFunctions[modelName];
   }
 
   async startup(): Promise<void> {

package/src/orm-request.ts

@@ -122,7 +122,7 @@ import { getBeforeHooks, getAfterHooks } from './hooks.js';
 import type { HookContext } from './hooks.js';
 import config from 'stonyx/config';
 import log from 'stonyx/log';
-import type { OrmRecord, AccessContext, AccessFunction, AccessMethod } from './types/orm-types.js';
+import type { OrmRecord, AccessContext, AccessFunction, AccessMethod, AccessOperation } from './types/orm-types.js';
 import { isOrmRecord } from './utils.js';
 
 interface OrmRequest$ extends Request {
@@ -152,7 +152,7 @@ interface JsonApiResponse {
 
 type HandlerFn = (request: OrmRequest$, state: { [key: string]: unknown }) => unknown | Promise<unknown>;
 
-const methodAccessMap: { [key: string]: string } = {
+const methodAccessMap: { [key: string]: AccessOperation } = {
   GET: 'read',
   POST: 'create',
   DELETE: 'delete',

package/src/setup-rest-server.ts

@@ -20,7 +20,7 @@ interface AccessInstance {
 }
 
 export default async function(route: string, accessPath: string, metaRoute: boolean): Promise<void> {
-  const accessFiles: Record<string, AccessFunction> = {};
+  const accessFunctions: Record<string, AccessFunction> = {};
 
   try {
     await forEachFileImport(accessPath, (accessClass: unknown) => {
@@ -37,9 +37,9 @@ export default async function(route: string, accessPath: string, metaRoute: bool
       for (const model of models === '*' ? availableModels : models) {
         if (model === dbKey) continue;
         if (!store.data.has(model)) throw new Error(`Unable to define access for Invalid Model "${model}". Model does not exist`);
-        if (accessFiles![model]) throw new Error(`Access for model "${model}" has already been defined by another access class.`);
+        if (accessFunctions![model]) throw new Error(`Access for model "${model}" has already been defined by another access class.`);
 
-        accessFiles![model] = accessInstance.access;
+        accessFunctions![model] = accessInstance.access;
       }
     });
   } catch (error) {
@@ -50,7 +50,7 @@ export default async function(route: string, accessPath: string, metaRoute: bool
   // -------------------------------------------------------------------------
   // #202 -- the registry has to survive this function.
   //
-  // `accessFiles` used to be a function-local that was discarded at the return
+  // `accessFunctions` used to be a function-local that was discarded at the return
   // below, so the only thing that ever saw it was the mount loop. Each mounted
   // OrmRequest then held its OWN model's predicate and nothing held the map, so
   // at request time there was no route from a model NAME to that model's
@@ -68,7 +68,7 @@ export default async function(route: string, accessPath: string, metaRoute: bool
   // set of predicates that is actually enforcing. A guard here that skipped the
   // assignment would let the registry go silently missing, which is precisely
   // the failure #202's AC8 exists to catch.
-  Orm.instance.accessFiles = accessFiles;
+  Orm.instance.accessFunctions = accessFunctions;
 
   await waitForModule('rest-server');
 
@@ -76,7 +76,7 @@ export default async function(route: string, accessPath: string, metaRoute: bool
   const name = route === '/' ? 'index' : (route[0] === '/' ? route.slice(1) : route);
 
   // Configure endpoints for models and views with access configuration
-  for (const [model, access] of Object.entries(accessFiles!)) {
+  for (const [model, access] of Object.entries(accessFunctions!)) {
     const pluralizedModel = getPluralName(model);
     const modelName = name === 'index' ? pluralizedModel : `${name}/${pluralizedModel}`;
     RestServer.instance.mountRoute(OrmRequest, { name: modelName, options: { model, access } });

package/src/types/orm-types.ts

@@ -184,6 +184,21 @@ export interface SnapshotEntry {
  */
 export type AccessMethod = string | boolean | string[] | ((record: unknown) => boolean);
 
+/**
+ * The closed vocabulary `AccessContext.operation` is drawn from
+ * (abofs/stonyx-orm#202).
+ *
+ * A literal union rather than `string`, so the guarantee the prose makes is the
+ * one the compiler enforces: a consumer who writes `operation === 'GET'` or
+ * `operation === 'get'` -- the hook vocabulary, see below -- gets a compile
+ * error instead of a comparison that never matches. A predicate that stops
+ * matching falls through to the permission array, so the misreading is
+ * fail-open shaped.
+ *
+ * In-repo precedent: `PersistErrorDetail.operation` in `src/main.ts`.
+ */
+export type AccessOperation = 'read' | 'create' | 'update' | 'delete';
+
 /**
  * The structural facts about the request being authorised, handed to a consumer
  * `access()` predicate as its SECOND argument (abofs/stonyx-orm#202).
@@ -214,28 +229,48 @@ export interface AccessContext {
   model: string;
 
   /**
-   * The operation being authorised: `'read'`, `'create'`, `'update'` or
-   * `'delete'`, and no second vocabulary. These are exactly the values of
+   * The operation being authorised. Exactly one of the four {@link
+   * AccessOperation} verbs, or `undefined`. These are exactly the values of
    * `methodAccessMap` in `src/orm-request.ts`, which is also what the
    * permission-array return shape is matched against -- so the two forms cannot
    * disagree.
    *
+   * NOT the hook vocabulary. `HookContext.operation` (`src/hooks.ts`) carries
+   * `'list' | 'get' | 'create' | 'update' | 'delete'` on an identically-named
+   * key of an identically-shaped context object, and the access vocabulary
+   * collapses `list` and `get` into `'read'`. For one `GET /animals/1` a hook
+   * sees `'get'` and `access()` sees `'read'`. "No second vocabulary" is a
+   * statement about the ACCESS path only.
+   *
    * `undefined` when the dispatched method has no entry in that map. Express
    * delivers `HEAD` to the `GET` handler, so this is reachable. It is left
    * undefined rather than defaulted on purpose: a fabricated `'read'` would
    * turn an unclassified request into an authorised one.
+   *
+   * The KEY is required even though the value may be undefined: `auth()` always
+   * sets it, and a context that simply omitted it would be indistinguishable
+   * from one that classified the request and found nothing.
    */
-  operation?: string;
+  operation: AccessOperation | undefined;
 }
 
 /**
  * A consumer `access()` predicate.
  *
- * `context` is optional in the type because the second argument is ADDITIVE:
- * JavaScript ignores extra arguments, so every pre-#202 single-argument
- * predicate keeps working untouched. Changing the FIRST argument instead would
- * have been the breaking form, and a predicate that can no longer identify its
- * collection falls through to a full CRUD grant -- so the "safer" breaking
- * change would have converted every unmigrated predicate into a fail-open.
+ * The second argument is ADDITIVE: JavaScript ignores extra arguments, so every
+ * pre-#202 single-argument predicate keeps working untouched. Changing the
+ * FIRST argument instead would have been the breaking form, and a predicate
+ * that can no longer identify its collection falls through to a full CRUD
+ * grant -- so the "safer" breaking change would have converted every unmigrated
+ * predicate into a fail-open.
+ *
+ * `context` is nonetheless REQUIRED in the type, and that costs back-compat
+ * nothing. TypeScript already lets a fewer-parameter implementation satisfy a
+ * more-parameter signature, so an arity-1 predicate assigns to this type
+ * cleanly -- measured under `--strict`. What the `?` bought was the opposite of
+ * safety: it silently permitted `getAccess('animal')?.(request)` at the CALL
+ * site, i.e. exactly the omission {@link AccessContext} exists to prevent, and
+ * that call gets the model-wrong answer. Required, a caller that drops the
+ * context gets `TS2554: Expected 2 arguments, but got 1`.
  */
-export type AccessFunction = (request: unknown, context?: AccessContext) => AccessMethod;
+export type AccessFunction = (request: unknown, context: AccessContext) => AccessMethod;

package/src/types/stonyx-rest-server.d.ts

@@ -5,7 +5,20 @@ declare module '@stonyx/rest-server' {
 
   interface RouteOptions {
     name: string;
-    options?: { model: string; access: (request: unknown) => unknown } | Record<string, unknown>;
+    /**
+     * `access` is the two-argument post-#202 shape. This is the THIRD place the
+     * contract is declared (`AccessInstance.access` in
+     * `src/setup-rest-server.ts` and `OrmRequest.access` in
+     * `src/orm-request.ts` are the other two) and it is the one `mountRoute` is
+     * actually called through, at `src/setup-rest-server.ts`. It kept the
+     * pre-#202 single-argument signature after the other two migrated; the
+     * union with `Record<string, unknown>` meant nothing broke, which is
+     * exactly why it would have drifted silently.
+     *
+     * Spelled structurally rather than as `AccessFunction`: an ambient
+     * `declare module` block cannot carry an `import type`.
+     */
+    options?: { model: string; access: (request: unknown, context: { model: string; operation: string | undefined }) => unknown } | Record<string, unknown>;
   }
 
   export default class RestServer {