@websolutespa/bom-next 3.0.2 → 4.0.0-next.1

package/src/server/context.test.ts

@@ -0,0 +1,467 @@
+// @vitest-environment node
+
+import type { SanitizedConfig } from 'payload';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+
+/**
+ * Emulates one Next.js request: React `cache` memoizes by argument identity
+ * until `newRequest()` starts the next request.
+ */
+const request = vi.hoisted(() => ({
+  memo: new Map<Function, { args: unknown[]; value: unknown }[]>(),
+  draft: false,
+  headers: new Headers(),
+}));
+
+vi.mock('server-only', () => ({}));
+
+vi.mock('react', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('react')>();
+  return {
+    ...actual,
+    cache: <T extends (...args: any[]) => any>(fn: T) => ((...args: unknown[]) => {
+      const entries = request.memo.get(fn) ?? [];
+      request.memo.set(fn, entries);
+      const hit = entries.find(entry => entry.args.length === args.length && entry.args.every((arg, i) => Object.is(arg, args[i])));
+      if (hit) {
+        return hit.value;
+      }
+      const value = fn(...args);
+      entries.push({ args, value });
+      return value;
+    }) as T,
+  };
+});
+
+vi.mock('next/headers', () => ({
+  draftMode: vi.fn(async () => ({ isEnabled: request.draft })),
+  headers: vi.fn(async () => request.headers),
+}));
+
+vi.mock('@websolutespa/payload-plugin-bowl', () => ({
+  InMemoryCache: class<T> {
+    private map = new Map<string, T>();
+    has(key: string) { return this.map.has(key); }
+    get(key: string) { return this.map.get(key); }
+    set(key: string, value: T) { this.map.set(key, value); }
+  },
+}));
+
+const fake = vi.hoisted(() => {
+  type Doc = Record<string, any>;
+  const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+
+  const db: Record<string, Record<string, Doc>> = {
+    page: {
+      p1: {
+        id: 'p1',
+        title: 'Post',
+        slug: 'post',
+        abstract: 'Abstract',
+        order: 1,
+        category: 'blog',
+        template: 'tpl',
+        markets: ['ww'],
+        meta: { title: 'Meta title', description: 'Meta description' },
+        media: 'm1',
+        components: [{ blockType: 'hero', media: 'm1', related: 'p2' }],
+      },
+      p2: { id: 'p2', title: 'Related', slug: 'related', category: 'blog', markets: ['ww'], media: 'm2' },
+    },
+    media: {
+      m1: { id: 'm1', url: '/m1.jpg', alt: 'one', width: 10 },
+      m2: { id: 'm2', url: '/m2.jpg', alt: 'two', width: 20 },
+    },
+    category: {
+      root: { id: 'root', title: 'Home', slug: 'home' },
+      blog: { id: 'blog', title: 'Blog', slug: 'blog', category: 'root' },
+    },
+    market: { ww: { id: 'ww', title: 'World', isActive: true, isDefault: true } },
+    label: { hello: { id: 'hello', text: 'Hello' } },
+    menu: {},
+  };
+  const relations: Record<string, string> = { media: 'media', related: 'page' };
+
+  const applySelect = (doc: Doc, select?: Record<string, unknown>): Doc => {
+    if (!select) {
+      return doc;
+    }
+    const exclude = Object.values(select).some(value => value === false);
+    return Object.fromEntries(Object.entries(doc).filter(([key]) =>
+      key === 'id' || (exclude ? select[key] !== false : select[key] !== undefined)
+    ));
+  };
+
+  // Bowl decorates every document read with a mixer context, populated ones included.
+  const decorate = (doc: Doc, collection: string, context?: Doc) =>
+    context?.market ? { ...doc, schema: collection } : doc;
+
+  const populate = (value: any, depth: number, select: Doc | undefined, context?: Doc): any => {
+    if (Array.isArray(value)) {
+      return value.map(item => populate(item, depth, select, context));
+    }
+    if (value && typeof value === 'object') {
+      return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+        const collection = relations[key];
+        if (collection && typeof item === 'string' && depth > 0 && db[collection][item]) {
+          const related = applySelect(clone(db[collection][item]), select?.[collection]);
+          return [key, decorate(populate(related, depth - 1, select, context), collection, context)];
+        }
+        return [key, populate(item, depth, select, context)];
+      }));
+    }
+    return value;
+  };
+
+  const payload = {
+    config: {
+      collections: [{ slug: 'page', fields: [{ name: 'slug' }] }],
+    },
+    auth: vi.fn(async ({ headers }: { headers: Headers }) => ({
+      user: headers.get('Authorization') ? { id: 'u1', collection: 'users', roles: ['admin'] } : null,
+    })),
+    findByID: vi.fn(async ({ collection, id, depth = 0, select, populate: populateSelect, context }: Doc) => {
+      if (id === 'boom') {
+        throw new Error('database unavailable');
+      }
+      const doc = db[collection]?.[id];
+      if (!doc) {
+        return null;
+      }
+      return decorate(populate(applySelect(clone(doc), select), depth, populateSelect, context), collection, context);
+    }),
+    find: vi.fn(async ({ collection }: Doc) => ({
+      docs: Object.values(db[collection] ?? {}).map(doc => clone(doc)),
+    })),
+    findGlobal: vi.fn(async ({ slug }: Doc) => slug === 'locale'
+      ? { items: [{ id: 'it', title: 'Italiano', isActive: true, isDefault: true }] }
+      : { id: slug, name: 'App' }),
+  };
+
+  return { payload };
+});
+
+vi.mock('payload', () => ({
+  getPayload: vi.fn(async () => fake.payload),
+}));
+
+const { createLayoutContext, createNotFoundContext, createPageContext } = await import('./context');
+const { getMetadata } = await import('./metadata');
+const { buildReadOptions } = await import('./mixer');
+const { withEnvelopeSelect } = await import('./page');
+const { DEFAULT_LAYOUT_DEPTH, DEFAULT_PAGE_DEPTH } = await import('../lib/const');
+const { draftMode, headers: getHeaders } = await import('next/headers');
+
+const config = Promise.resolve({} as SanitizedConfig);
+
+const pageReads = () => fake.payload.findByID.mock.calls.map(([options]) => options as Record<string, any>);
+
+function newRequest() {
+  request.memo.clear();
+  request.draft = false;
+  request.headers = new Headers();
+  (globalThis as any)._mixer = undefined;
+  (globalThis as any)._route = undefined;
+  vi.clearAllMocks();
+}
+
+describe('createPageContext', () => {
+  beforeEach(newRequest);
+
+  test('reads the page at the default depth, populating uploads inside blocks', async () => {
+    const { page } = await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(DEFAULT_PAGE_DEPTH).toBe(2);
+    expect(pageReads()[0]).toMatchObject({ collection: 'page', id: 'p1', depth: DEFAULT_PAGE_DEPTH, draft: false });
+    const [hero] = page!.components as any[];
+    expect(hero.media).toMatchObject({ id: 'm1', url: '/m1.jpg' });
+    // depth 2: relations of relations
+    expect(hero.related.media).toMatchObject({ id: 'm2', url: '/m2.jpg' });
+    expect(page!.media).toMatchObject({ id: 'm1', url: '/m1.jpg' });
+  });
+
+  test('depth 0 returns ids', async () => {
+    const { page } = await createPageContext('ww', 'it', 'page', 'p1', { config, depth: 0 });
+
+    expect(pageReads()[0]).toMatchObject({ depth: 0 });
+    expect(page!.media).toBe('m1');
+    expect((page!.components as any[])[0].media).toBe('m1');
+  });
+
+  test('builds the envelope (href, alternates, breadcrumb) and the layout', async () => {
+    const { page, layout, label, link } = await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(page!.href).toBeTruthy();
+    expect(page!.alternates).toHaveLength(1);
+    expect(page!.breadcrumb.length).toBeGreaterThan(0);
+    expect(page!.breadcrumb[page!.breadcrumb.length - 1].href).toBe(page!.href);
+    expect(layout.market).toBe('ww');
+    expect(layout.labels).toHaveLength(1);
+    expect(typeof label).toBe('function');
+    expect(typeof link).toBe('function');
+  });
+
+  test('select keeps the envelope fields, so breadcrumb and href still work', async () => {
+    const full = await createPageContext('ww', 'it', 'page', 'p1', { config, depth: 0 });
+    newRequest();
+    const { page } = await createPageContext('ww', 'it', 'page', 'p1', {
+      config,
+      depth: 0,
+      select: { title: true, media: true },
+    });
+
+    expect(pageReads()[0].select).toEqual({
+      title: true,
+      media: true,
+      id: true,
+      slug: true,
+      category: true,
+      markets: true,
+      meta: true,
+      template: true,
+    });
+    expect(page!.title).toBe('Post');
+    expect((page as any).order).toBeUndefined();
+    expect((page as any).abstract).toBeUndefined();
+    expect(page!.href).toBe(full.page!.href);
+    expect(page!.breadcrumb).toEqual(full.page!.breadcrumb);
+  });
+
+  test('passes populate to the read and trims populated documents', async () => {
+    const { page } = await createPageContext('ww', 'it', 'page', 'p1', {
+      config,
+      depth: 1,
+      populate: { media: { url: true } },
+    });
+
+    expect(pageReads()[0]).toMatchObject({ depth: 1, populate: { media: { url: true } } });
+    expect(page!.media).toEqual({ id: 'm1', url: '/m1.jpg', schema: 'media' });
+  });
+
+  test('populated documents keep Bowl decoration: the mixer context is passed to the read', async () => {
+    const { page } = await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(pageReads()[0].context).toMatchObject({ market: 'ww', locale: 'it' });
+    expect(page!.schema).toBe('page');
+    expect(page!.media).toMatchObject({ schema: 'media' });
+    expect((page!.components as any[])[0].related).toMatchObject({ schema: 'page' });
+  });
+
+  test('legacy positional signature still works, with the new default depth', async () => {
+    const legacy = await createPageContext('ww', 'it', 'page', 'p1', config);
+
+    expect(pageReads()[0]).toMatchObject({ depth: DEFAULT_PAGE_DEPTH });
+    expect(legacy.page!.id).toBe('p1');
+    expect(legacy.layout.market).toBe('ww');
+  });
+
+  test('legacy signature warns once in development', async () => {
+    vi.stubEnv('NODE_ENV', 'development');
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    try {
+      await createPageContext('ww', 'it', 'page', 'p1', config);
+      request.memo.clear();
+      await createPageContext('ww', 'it', 'page', 'p1', config);
+      expect(warn.mock.calls.filter(([message]) => String(message).includes('createPageContext'))).toHaveLength(1);
+    } finally {
+      warn.mockRestore();
+      vi.unstubAllEnvs();
+    }
+  });
+
+  test('legacy headers authenticate the user', async () => {
+    const headers = new Headers({ Authorization: 'JWT token' });
+    const { user } = await createPageContext('ww', 'it', 'page', 'p1', config, headers as any);
+
+    expect(user).toMatchObject({ id: 'u1' });
+    expect(pageReads()[0].user).toMatchObject({ id: 'u1' });
+  });
+
+  test('metadata plus page trigger a single findByID per request', async () => {
+    const generateMetadata = getMetadata('page', config);
+    const metadata = await generateMetadata({ params: Promise.resolve({ market: 'ww', locale: 'it', id: 'p1' }) }, {} as any);
+    const { page } = await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(metadata).toEqual({ title: 'Meta title', description: 'Meta description' });
+    expect(page!.id).toBe('p1');
+    expect(fake.payload.findByID).toHaveBeenCalledTimes(1);
+    // layout reads are shared too
+    expect(fake.payload.find.mock.calls.filter(([options]) => options.collection === 'label')).toHaveLength(1);
+  });
+
+  test('each caller gets its own page object', async () => {
+    const first = await createPageContext('ww', 'it', 'page', 'p1', { config });
+    const second = await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(fake.payload.findByID).toHaveBeenCalledTimes(1);
+    expect(first.page).not.toBe(second.page);
+    expect(first.page).toEqual(second.page);
+  });
+
+  test('different options are different reads', async () => {
+    await createPageContext('ww', 'it', 'page', 'p1', { config, depth: 1 });
+    await createPageContext('ww', 'it', 'page', 'p1', { config, depth: 2 });
+
+    expect(fake.payload.findByID).toHaveBeenCalledTimes(2);
+  });
+
+  test('a new request reads again', async () => {
+    await createPageContext('ww', 'it', 'page', 'p1', { config });
+    newRequest();
+    await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(fake.payload.findByID).toHaveBeenCalledTimes(1);
+  });
+
+  test('returns undefined when the page is not found', async () => {
+    const { page } = await createPageContext('ww', 'it', 'page', 'missing', { config });
+
+    expect(page).toBeUndefined();
+  });
+
+  test('rethrows query errors instead of returning a 404', async () => {
+    const error = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    try {
+      await expect(createPageContext('ww', 'it', 'page', 'boom', { config })).rejects.toThrow('database unavailable');
+    } finally {
+      error.mockRestore();
+    }
+  });
+
+  test('draft auto reads Next draftMode() and reads as the request user', async () => {
+    request.draft = true;
+    request.headers = new Headers({ Authorization: 'JWT token' });
+
+    const { user } = await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(draftMode).toHaveBeenCalled();
+    expect(getHeaders).toHaveBeenCalled();
+    expect(user).toMatchObject({ id: 'u1' });
+    expect(pageReads()[0]).toMatchObject({ draft: true, user: { id: 'u1' } });
+    // the mixer context and routes are read with draft too
+    expect(fake.payload.find.mock.calls.find(([options]) => options.collection === 'category')![0]).toMatchObject({ draft: true });
+    expect(fake.payload.find.mock.calls.find(([options]) => options.collection === 'label')![0]).toMatchObject({ draft: true });
+  });
+
+  test('draft: false ignores draftMode()', async () => {
+    request.draft = true;
+
+    await createPageContext('ww', 'it', 'page', 'p1', { config, draft: false });
+
+    expect(pageReads()[0]).toMatchObject({ draft: false });
+  });
+
+  test('layout options: own depth, or skipped', async () => {
+    await createPageContext('ww', 'it', 'page', 'p1', { config, layout: { depth: 0 } });
+    expect(fake.payload.find.mock.calls.find(([options]) => options.collection === 'label')![0]).toMatchObject({ depth: 0 });
+
+    newRequest();
+    const { layout, page, label } = await createPageContext('ww', 'it', 'page', 'p1', { config, layout: false });
+    expect(layout).toBeUndefined();
+    expect(page!.id).toBe('p1');
+    expect(label('missing')).toBeTypeOf('string');
+    expect(fake.payload.find.mock.calls.filter(([options]) => options.collection === 'label')).toHaveLength(0);
+  });
+
+  test('reads page and layout in parallel', async () => {
+    let releasePage!: () => void;
+    const pageGate = new Promise<void>(resolve => releasePage = resolve);
+    const findByID = fake.payload.findByID.getMockImplementation()!;
+    fake.payload.findByID.mockImplementationOnce(async (options) => {
+      await pageGate;
+      return findByID(options);
+    });
+
+    const pending = createPageContext('ww', 'it', 'page', 'p1', { config });
+    await vi.waitFor(() => {
+      expect(fake.payload.find.mock.calls.some(([options]) => options.collection === 'label')).toBe(true);
+    });
+    releasePage();
+
+    expect((await pending).page!.id).toBe('p1');
+  });
+});
+
+describe('createNotFoundContext', () => {
+  beforeEach(newRequest);
+
+  test('always reads published content', async () => {
+    request.draft = true;
+
+    await createNotFoundContext('ww', 'it', 'page', 'p1', { config, draft: true });
+
+    expect(pageReads()[0]).toMatchObject({ draft: false });
+    expect(fake.payload.find.mock.calls.find(([options]) => options.collection === 'label')![0]).toMatchObject({ draft: false });
+  });
+
+  test('supports the legacy signature', async () => {
+    const { page } = await createNotFoundContext('ww', 'it', 'page', 'p1', config);
+
+    expect(page!.id).toBe('p1');
+    expect(pageReads()[0]).toMatchObject({ draft: false, depth: DEFAULT_PAGE_DEPTH });
+  });
+});
+
+describe('createLayoutContext', () => {
+  beforeEach(newRequest);
+
+  test('options form reads the layout at the default layout depth', async () => {
+    const { layout } = await createLayoutContext('ww', 'it', { config });
+
+    expect(DEFAULT_LAYOUT_DEPTH).toBe(1);
+    expect(layout.market).toBe('ww');
+    expect(fake.payload.findByID).not.toHaveBeenCalled();
+    expect(fake.payload.find.mock.calls.find(([options]) => options.collection === 'label')![0]).toMatchObject({ depth: 1 });
+  });
+
+  test('legacy signature still works', async () => {
+    const { layout, user } = await createLayoutContext('ww', 'it', config, new Headers({ Authorization: 'JWT token' }) as any);
+
+    expect(layout.locale).toBe('it');
+    expect(user).toMatchObject({ id: 'u1' });
+  });
+
+  test('shares the layout reads with createPageContext', async () => {
+    await createLayoutContext('ww', 'it', { config });
+    await createPageContext('ww', 'it', 'page', 'p1', { config });
+
+    expect(fake.payload.find.mock.calls.filter(([options]) => options.collection === 'label')).toHaveLength(1);
+  });
+});
+
+describe('withEnvelopeSelect', () => {
+  test('leaves an empty select untouched', () => {
+    expect(withEnvelopeSelect(undefined)).toBeUndefined();
+    expect(withEnvelopeSelect({})).toEqual({});
+  });
+
+  test('adds the envelope fields in include mode, keeping nested selects', () => {
+    expect(withEnvelopeSelect({ abstract: true, meta: { title: true } })).toEqual({
+      abstract: true,
+      meta: { title: true },
+      id: true,
+      slug: true,
+      title: true,
+      category: true,
+      markets: true,
+      template: true,
+    });
+  });
+
+  test('removes the envelope fields from the exclusion list in exclude mode', () => {
+    expect(withEnvelopeSelect({ components: false, category: false, meta: false })).toEqual({ components: false });
+  });
+});
+
+describe('buildReadOptions', () => {
+  test('has no hardcoded depth and only sets select / populate / joins when given', () => {
+    const options = buildReadOptions({ user: { id: 'u1' }, locale: 'it', depth: 3 });
+
+    expect(options).toMatchObject({ locale: 'it', depth: 3, draft: false, overrideAccess: false });
+    expect(options).not.toHaveProperty('select');
+    expect(options).not.toHaveProperty('populate');
+    expect(options).not.toHaveProperty('joins');
+    expect(buildReadOptions({ user: null, locale: 'it', select: { title: true }, populate: {}, joins: false }))
+      .toMatchObject({ select: { title: true }, populate: {}, joins: false });
+  });
+});