@byline/core 3.20.4 → 4.0.0

package/dist/auth/apply-before-read.test.node.js

@@ -5,11 +5,12 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-import { createRequestContext } from '@byline/auth';
-import { describe, expect, it } from 'vitest';
+import { AdminAuth, createRequestContext } from '@byline/auth';
+import { describe, expect, it, vi } from 'vitest';
 import { defineCollection, defineWorkflow, } from '../@types/collection-types.js';
 import { createReadContext } from '../services/populate.js';
-import { applyBeforeRead } from './apply-before-read.js';
+import { applyBeforeRead, compileBeforeReadFilters } from './apply-before-read.js';
+import { resolveReadContextRoot } from './read-context-scope.js';
 const baseCollection = (hook) => defineCollection({
     path: 'posts',
     labels: { singular: 'Post', plural: 'Posts' },
@@ -101,6 +102,55 @@ describe('applyBeforeRead', () => {
         expect(second).toBeNull();
         expect(callCount).toBe(1);
     });
+    it('ignores a caller-preseeded public cache entry', async () => {
+        const hook = vi.fn(() => ({ title: 'allowed' }));
+        const readContext = createReadContext({
+            beforeReadCache: new Map([['posts:any', null]]),
+        });
+        const result = await applyBeforeRead({
+            definition: baseCollection(hook),
+            requestContext: createRequestContext(),
+            readContext,
+        });
+        expect(hook).toHaveBeenCalledOnce();
+        expect(result).toEqual({ title: 'allowed' });
+    });
+    it('ignores a caller-preseeded public cache entry on the compiled-filter path', async () => {
+        const hook = vi.fn(() => ({ title: 'allowed' }));
+        const readContext = createReadContext({
+            beforeReadCache: new Map([['posts:any', null]]),
+        });
+        const filters = await compileBeforeReadFilters({
+            definition: baseCollection(hook),
+            requestContext: createRequestContext(),
+            readContext,
+            securityDomain: {},
+            parseContext: { collections: [], resolveCollectionId: vi.fn() },
+        });
+        expect(hook).toHaveBeenCalledOnce();
+        expect(filters).toEqual([
+            expect.objectContaining({ kind: 'field', fieldName: 'title', value: 'allowed' }),
+        ]);
+    });
+    it('rejects reuse under a different actor authority', async () => {
+        const hook = vi.fn(({ requestContext }) => ({
+            title: requestContext.actor?.id,
+        }));
+        const definition = baseCollection(hook);
+        const readContext = createReadContext();
+        const requestId = 'same-logical-request';
+        const alice = createRequestContext({
+            actor: new AdminAuth({ id: 'alice', abilities: ['collections.posts.read'] }),
+            requestId,
+        });
+        const bob = createRequestContext({
+            actor: new AdminAuth({ id: 'bob', abilities: ['collections.posts.read'] }),
+            requestId,
+        });
+        await applyBeforeRead({ definition, requestContext: alice, readContext });
+        await expect(applyBeforeRead({ definition, requestContext: bob, readContext })).rejects.toThrow('cannot be reused across request authorities');
+        expect(hook).toHaveBeenCalledOnce();
+    });
     it('runs the hook again on a fresh ReadContext', async () => {
         let callCount = 0;
         const hook = () => {
@@ -113,6 +163,32 @@ describe('applyBeforeRead', () => {
         await applyBeforeRead({ definition: def, requestContext, readContext: createReadContext() });
         expect(callCount).toBe(2);
     });
+    it('caches independently by effective read mode', async () => {
+        const modes = [];
+        const hook = ({ requestContext }) => {
+            modes.push(requestContext.readMode);
+            return { status: requestContext.readMode === 'published' ? 'published' : 'draft' };
+        };
+        const definition = baseCollection(hook);
+        const readContext = createReadContext();
+        const base = createRequestContext();
+        await applyBeforeRead({
+            definition,
+            requestContext: { ...base, readMode: 'published' },
+            readContext,
+        });
+        await applyBeforeRead({
+            definition,
+            requestContext: { ...base, readMode: 'any' },
+            readContext,
+        });
+        await applyBeforeRead({
+            definition,
+            requestContext: { ...base, readMode: 'published' },
+            readContext,
+        });
+        expect(modes).toEqual(['published', 'any']);
+    });
     it('passes collectionPath, requestContext, and readContext through to the hook', async () => {
         let received;
         const hook = (ctx) => {
@@ -125,8 +201,40 @@ describe('applyBeforeRead', () => {
         expect(received).toMatchObject({
             collectionPath: 'posts',
             requestContext,
+        });
+        expect(received.readContext.visited).toBe(readContext.visited);
+    });
+    it('delegates scoped read-budget state to the logical root context', async () => {
+        const readContext = createReadContext({ maxReads: 4 });
+        const hook = ({ readContext: scoped }) => {
+            scoped.visited.add('posts:nested');
+            scoped.readCount += 1;
+            scoped.maxReads = 3;
+        };
+        await applyBeforeRead({
+            definition: baseCollection(hook),
+            requestContext: createRequestContext(),
+            readContext,
+        });
+        expect(readContext.visited).toContain('posts:nested');
+        expect(readContext.readCount).toBe(1);
+        expect(readContext.maxReads).toBe(3);
+    });
+    it('resolves scoped hook contexts to their logical root', async () => {
+        const readContext = createReadContext();
+        let scopedContext;
+        const hook = ({ readContext: scoped }) => {
+            scopedContext = scoped;
+        };
+        await applyBeforeRead({
+            definition: baseCollection(hook),
+            requestContext: createRequestContext(),
             readContext,
         });
+        if (!scopedContext)
+            throw new Error('beforeRead did not receive a scoped ReadContext');
+        expect(resolveReadContextRoot(scopedContext)).toBe(readContext);
+        expect(resolveReadContextRoot(readContext)).toBe(readContext);
     });
     it('supports an async hook', async () => {
         const hook = async () => {
@@ -140,4 +248,134 @@ describe('applyBeforeRead', () => {
         });
         expect(result).toEqual({ tenantId: 't-1' });
     });
+    it('compiles security filters and resolves relation collection ids once per read context', async () => {
+        const categories = defineCollection({
+            path: 'categories',
+            labels: { singular: 'Category', plural: 'Categories' },
+            fields: [{ name: 'tenant', type: 'text', label: 'Tenant' }],
+        });
+        const definition = defineCollection({
+            path: 'posts',
+            labels: { singular: 'Post', plural: 'Posts' },
+            fields: [
+                {
+                    name: 'category',
+                    type: 'relation',
+                    label: 'Category',
+                    targetCollection: 'categories',
+                },
+            ],
+            hooks: { beforeRead: () => ({ category: { tenant: 'alice' } }) },
+        });
+        const readContext = createReadContext();
+        const requestContext = createRequestContext({ readMode: 'published' });
+        const resolveCollectionId = vi.fn(async () => 'categories-id');
+        const params = {
+            definition,
+            requestContext,
+            readContext,
+            securityDomain: {},
+            parseContext: { collections: [definition, categories], resolveCollectionId },
+        };
+        const [first, second] = await Promise.all([
+            compileBeforeReadFilters(params),
+            compileBeforeReadFilters(params),
+        ]);
+        expect(second).toBe(first);
+        expect(resolveCollectionId).toHaveBeenCalledOnce();
+    });
+    it('compiles the same definition independently for different security domains', async () => {
+        const categories = defineCollection({
+            path: 'categories',
+            labels: { singular: 'Category', plural: 'Categories' },
+            fields: [{ name: 'tenant', type: 'text', label: 'Tenant' }],
+        });
+        const hook = vi.fn(() => ({ category: { tenant: 'alice' } }));
+        const definition = defineCollection({
+            path: 'posts',
+            labels: { singular: 'Post', plural: 'Posts' },
+            fields: [
+                {
+                    name: 'category',
+                    type: 'relation',
+                    label: 'Category',
+                    targetCollection: 'categories',
+                },
+            ],
+            hooks: { beforeRead: hook },
+        });
+        const readContext = createReadContext();
+        const requestContext = createRequestContext({ readMode: 'published' });
+        const resolveA = vi.fn(async () => 'categories-a');
+        const resolveB = vi.fn(async () => 'categories-b');
+        await compileBeforeReadFilters({
+            definition,
+            requestContext,
+            readContext,
+            securityDomain: {},
+            parseContext: { collections: [definition, categories], resolveCollectionId: resolveA },
+        });
+        await compileBeforeReadFilters({
+            definition,
+            requestContext,
+            readContext,
+            securityDomain: {},
+            parseContext: { collections: [definition, categories], resolveCollectionId: resolveB },
+        });
+        expect(hook).toHaveBeenCalledTimes(2);
+        expect(resolveA).toHaveBeenCalledOnce();
+        expect(resolveB).toHaveBeenCalledOnce();
+    });
+    it('fails closed on a recursive beforeRead for the same collection', async () => {
+        const readContext = createReadContext();
+        const requestContext = createRequestContext();
+        let definition;
+        const hook = async (ctx) => {
+            await applyBeforeRead({
+                definition,
+                requestContext: ctx.requestContext,
+                readContext: ctx.readContext,
+            });
+        };
+        definition = baseCollection(hook);
+        await expect(applyBeforeRead({ definition, requestContext, readContext })).rejects.toMatchObject({ code: 'ERR_READ_RECURSION' });
+    });
+    it('fails closed on an A to B to A beforeRead cycle', async () => {
+        const readContext = createReadContext();
+        const requestContext = createRequestContext();
+        const securityDomain = {};
+        let a;
+        let b;
+        a = defineCollection({
+            path: 'a',
+            labels: { singular: 'A', plural: 'As' },
+            fields: [{ name: 'title', type: 'text', label: 'Title' }],
+            hooks: {
+                beforeRead: async (ctx) => {
+                    await applyBeforeRead({
+                        definition: b,
+                        requestContext: ctx.requestContext,
+                        readContext: ctx.readContext,
+                        securityDomain,
+                    });
+                },
+            },
+        });
+        b = defineCollection({
+            path: 'b',
+            labels: { singular: 'B', plural: 'Bs' },
+            fields: [{ name: 'title', type: 'text', label: 'Title' }],
+            hooks: {
+                beforeRead: async (ctx) => {
+                    await applyBeforeRead({
+                        definition: a,
+                        requestContext: ctx.requestContext,
+                        readContext: ctx.readContext,
+                        securityDomain,
+                    });
+                },
+            },
+        });
+        await expect(applyBeforeRead({ definition: a, requestContext, readContext, securityDomain })).rejects.toMatchObject({ code: 'ERR_READ_RECURSION' });
+    });
 });

package/dist/auth/index.d.ts

@@ -5,6 +5,6 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export { applyBeforeRead } from './apply-before-read.js';
+export { applyBeforeRead, bindReadContextAuthority, compileBeforeReadFilters, } from './apply-before-read.js';
 export { assertActorCanPerform } from './assert-actor-can-perform.js';
 export { COLLECTION_ABILITY_VERBS, type CollectionAbilityVerb, collectionAbilityKey, registerCollectionAbilities, } from './register-collection-abilities.js';

package/dist/auth/index.js

@@ -5,6 +5,6 @@
  *
  * Copyright (c) Infonomic Company Limited
  */
-export { applyBeforeRead } from './apply-before-read.js';
+export { applyBeforeRead, bindReadContextAuthority, compileBeforeReadFilters, } from './apply-before-read.js';
 export { assertActorCanPerform } from './assert-actor-can-perform.js';
 export { COLLECTION_ABILITY_VERBS, collectionAbilityKey, registerCollectionAbilities, } from './register-collection-abilities.js';

package/dist/auth/read-context-scope.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { ReadContext } from '../@types/db-types.js';
+export interface ReadContextScope {
+    root: ReadContext;
+    ancestry: readonly object[];
+}
+export declare function getReadContextScope(readContext: ReadContext): ReadContextScope;
+/** Resolve a scoped hook context to the ReadContext for its logical request. */
+export declare function resolveReadContextRoot(readContext: ReadContext): ReadContext;
+/**
+ * Carry hook ancestry by object identity, not by a forgeable public property.
+ * All mutable read-budget state still delegates to the logical root context.
+ */
+export declare function createHookReadContext(parent: ReadContextScope, entry: object): ReadContext;

package/dist/auth/read-context-scope.js

@@ -0,0 +1,48 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+const readContextScopes = new WeakMap();
+export function getReadContextScope(readContext) {
+    return readContextScopes.get(readContext) ?? { root: readContext, ancestry: [] };
+}
+/** Resolve a scoped hook context to the ReadContext for its logical request. */
+export function resolveReadContextRoot(readContext) {
+    return getReadContextScope(readContext).root;
+}
+/**
+ * Carry hook ancestry by object identity, not by a forgeable public property.
+ * All mutable read-budget state still delegates to the logical root context.
+ */
+export function createHookReadContext(parent, entry) {
+    const root = parent.root;
+    const scoped = {};
+    Object.defineProperties(scoped, {
+        visited: { enumerable: true, get: () => root.visited, set: (value) => (root.visited = value) },
+        beforeReadCache: {
+            enumerable: true,
+            get: () => root.beforeReadCache,
+            set: (value) => (root.beforeReadCache = value),
+        },
+        readCount: {
+            enumerable: true,
+            get: () => root.readCount,
+            set: (value) => (root.readCount = value),
+        },
+        maxReads: {
+            enumerable: true,
+            get: () => root.maxReads,
+            set: (value) => (root.maxReads = value),
+        },
+        maxDepth: {
+            enumerable: true,
+            get: () => root.maxDepth,
+            set: (value) => (root.maxDepth = value),
+        },
+    });
+    readContextScopes.set(scoped, { root, ancestry: [...parent.ancestry, entry] });
+    return scoped;
+}