@iqual/nuxt-icms 1.6.1 → 1.6.2-rc.2

package/types/layerConfig.ts

@@ -0,0 +1,84 @@
+/**
+ * The `icms` key every ICMS layer may add to its Nuxt config.
+ *
+ * It is read by the dynamicParagraphResolver and
+ * dynamicEntityComponentResolver modules, which merge the fragment names of
+ * all layers into the generated GraphQL fragments.
+ */
+export type IcmsLayerConfig = {
+  /**
+   * Entity types that get a page component (e.g. `Node`).
+   */
+  pageComponentTypes?: string[]
+
+  /**
+   * Whether editors may place blökkli fragments (`defineBlokkliFragment()`).
+   *
+   * Defaults to `true`: every fragment component in any layer is offered. A
+   * project sets `false` to disable the feature; the `blokkliFragments` module
+   * then removes the editor's fragments feature.
+   */
+  blokkliFragments?: boolean
+
+  /**
+   * Fragment names contributed by the layer's paragraph components.
+   */
+  components?: {
+    fragments?: string[]
+    /**
+     * Fragments of wrapper paragraphs that embed another paragraph (e.g.
+     * `paragraphFromLibrary`). They are spread into `paragraph` only — the
+     * embedded paragraph uses `paragraphInLibrary`, which leaves them out so
+     * the fragments do not spread themselves.
+     */
+    wrapperFragments?: string[]
+    teaserFragments?: string[]
+    searchResultFragments?: string[]
+  }
+
+  /**
+   * Additional fragments spread into the generated entity fragments.
+   */
+  extendFragments?: {
+    entity?: string[]
+    teaser?: string[]
+    searchResult?: string[]
+  }
+}
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig {
+    icms?: IcmsLayerConfig
+  }
+
+  interface NuxtOptions {
+    icms?: IcmsLayerConfig
+  }
+
+  /**
+   * Re-declared because nuxt-graphql-middleware augments `nuxt/schema` instead
+   * of `@nuxt/schema`, which does not merge into the hook types used by
+   * `nuxt.hooks.hookOnce()`.
+   *
+   * The `blokkli:alter-*` hooks are declared here because @blokkli/editor ships
+   * them without types; only the members the ICMS modules use are described.
+   */
+  interface NuxtHooks {
+    'nuxt-graphql-middleware:init': (context: {
+      addDocument: (name: string, source: string) => void
+      schemaHasType: (name: string) => boolean
+    }) => void | Promise<void>
+    'blokkli:alter-features': (context: {
+      features: {
+        getDefinition: () => { id: string } | null | undefined
+        disable: () => void
+      }[]
+    }) => void | Promise<void>
+    'blokkli:alter-blocks': (context: {
+      blocks: {
+        type: 'main' | 'context' | 'fragment' | null
+        definition?: { name?: string } | null
+      }[]
+    }) => void | Promise<void>
+  }
+}

package/utils/pageCache.ts

@@ -0,0 +1,95 @@
+/**
+ * Page cache configuration (ICMS-268), shared by the Nitro server options and
+ * plugin and by the usePageCache() composable. Kept outside `server/` so the
+ * app can import it too.
+ */
+
+/**
+ * How the SSR responses are cached (ICMS-268).
+ *
+ * - `default`: no shared cache in front of Nuxt. Anonymous HTML is cached in
+ *   the bounded in-memory route cache of nuxt-multi-cache and sent with a
+ *   short browser-only Cache-Control; no s-maxage and no Cache-Tag header.
+ * - `varnish`: a shared cache (Varnish) sits in front of Nuxt. Responses carry
+ *   s-maxage and Cache-Tag for it, and the in-memory route cache stays off so
+ *   that Varnish never re-caches a page Nuxt has not purged yet.
+ */
+export type PageCacheMode = 'default' | 'varnish'
+
+export type PageCacheConfig = {
+  mode: PageCacheMode
+  /** Browser max-age (seconds) for cacheable anonymous responses. */
+  browserMaxAge: number
+  /**
+   * Byte budget of the in-memory route (HTML) cache. 0 disables it, `auto`
+   * derives it from the memory limit of the container.
+   */
+  routeMaxSize: number | 'auto'
+  /** Store route cache entries gzipped (about 8× smaller). */
+  routeCompression: boolean
+  /** Upper bound (seconds) for how long a page stays in the route cache. */
+  routeMaxAge: number
+  /** Byte budget of the in-memory data cache. */
+  dataMaxSize: number
+}
+
+const MB = 1024 * 1024
+
+export const PAGE_CACHE_DEFAULTS: PageCacheConfig = Object.freeze({
+  mode: 'default',
+  browserMaxAge: 300,
+  routeMaxSize: 'auto',
+  routeCompression: true,
+  routeMaxAge: 7 * 86_400,
+  dataMaxSize: 8 * MB,
+})
+
+/**
+ * The runtime config defaults. In development (`nuxi dev`) the route cache is
+ * off: nothing purges it locally, so anonymous pages would stay stale until
+ * the dev server restarts. NUXT_PAGE_CACHE_ROUTE_MAX_SIZE=auto turns it on.
+ */
+export function pageCacheDefaults(dev: boolean): PageCacheConfig {
+  return { ...PAGE_CACHE_DEFAULTS, ...(dev ? { routeMaxSize: 0 } : {}) }
+}
+
+function toBoolean(value: unknown, fallback: boolean): boolean {
+  if (typeof value === 'boolean') {
+    return value
+  }
+  if (value === 'true' || value === '1') {
+    return true
+  }
+  if (value === 'false' || value === '0') {
+    return false
+  }
+  return fallback
+}
+
+function toNonNegativeNumber<T>(value: unknown, fallback: T): number | T {
+  const number = typeof value === 'string' ? Number(value) : value
+  return typeof number === 'number' && Number.isFinite(number) && number >= 0
+    ? Math.floor(number)
+    : fallback
+}
+
+/**
+ * Normalize the `pageCache` runtime config; values may arrive as strings from
+ * NUXT_PAGE_CACHE_* environment variables.
+ */
+export function resolvePageCacheConfig(
+  input?: Partial<Record<keyof PageCacheConfig, unknown>> | null,
+): PageCacheConfig {
+  const d = PAGE_CACHE_DEFAULTS
+  return {
+    mode: input?.mode === 'varnish' ? 'varnish' : 'default',
+    browserMaxAge: toNonNegativeNumber(input?.browserMaxAge, d.browserMaxAge),
+    routeMaxSize:
+      input?.routeMaxSize === 'auto'
+        ? 'auto'
+        : toNonNegativeNumber(input?.routeMaxSize, d.routeMaxSize),
+    routeCompression: toBoolean(input?.routeCompression, d.routeCompression),
+    routeMaxAge: toNonNegativeNumber(input?.routeMaxAge, d.routeMaxAge),
+    dataMaxSize: toNonNegativeNumber(input?.dataMaxSize, d.dataMaxSize),
+  }
+}

package/utils/turnstile.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared constants and helpers for the Turnstile spam protection.
+ *
+ * Kept free of Nitro auto-imports and outside `server/` so both the middleware and the
+ * frontend component can use them, and so they are unit testable.
+ */
+
+/**
+ * Header carrying the Turnstile token from the browser to the Nuxt server.
+ *
+ * The token cannot travel as a GraphQL variable: `submitWebform` forwards its
+ * variables to Drupal, which knows nothing about Turnstile.
+ */
+export const TURNSTILE_TOKEN_HEADER = 'x-turnstile-token'
+
+/**
+ * Marks a rejected submission, so the form can show the right message.
+ */
+export const TURNSTILE_ERROR_CODE = 'TURNSTILE_VERIFICATION_FAILED'
+
+/**
+ * Whether a request is a webform submission and therefore has to be verified.
+ *
+ * Matched on the operation suffix rather than the full route so a project that
+ * changes `graphqlMiddleware.serverApiPrefix` stays protected.
+ */
+export function isWebformSubmissionRequest(path?: string | null): boolean {
+  if (!path) {
+    return false
+  }
+
+  const pathname = path.split('?')[0] ?? ''
+
+  return pathname.endsWith('/mutation/submitWebform')
+}

package/composables/useWebformEnrichment.ts

@@ -1,68 +0,0 @@
-// Composable for webform field enrichment system
-// Allows bundles to register custom field processors
-
-interface FormElement {
-  metadata?: {
-    key?: string
-    type?: string
-    [key: string]: any
-  }
-  [key: string]: any
-}
-
-interface EnrichmentContext {
-  formElement: FormElement
-  props: Record<string, any>
-}
-
-interface SubmissionContext {
-  data: Record<string, any>
-  elements: Array<{ element: string; value: any }>
-  props: Record<string, any>
-}
-
-type EnrichmentFunction = (context: EnrichmentContext) => FormElement | null
-type SubmissionProcessor = (context: SubmissionContext) => void
-
-const enrichmentFunctions: EnrichmentFunction[] = []
-const submissionProcessors: SubmissionProcessor[] = []
-
-export function useWebformEnrichment() {
-  const registerEnrichment = (fn: EnrichmentFunction) => {
-    if (!enrichmentFunctions.includes(fn)) {
-      enrichmentFunctions.push(fn)
-    }
-  }
-
-  const registerSubmissionProcessor = (fn: SubmissionProcessor) => {
-    if (!submissionProcessors.includes(fn)) {
-      submissionProcessors.push(fn)
-    }
-  }
-
-  const enrichFormElement = (formElement: FormElement, props: Record<string, any>): FormElement => {
-    // Try each registered enrichment function
-    for (const fn of enrichmentFunctions) {
-      const result = fn({ formElement, props })
-      if (result) {
-        return result
-      }
-    }
-    // Return original if no enrichment applied
-    return formElement
-  }
-
-  const processSubmission = (context: SubmissionContext) => {
-    // Run all submission processors
-    for (const fn of submissionProcessors) {
-      fn(context)
-    }
-  }
-
-  return {
-    registerEnrichment,
-    registerSubmissionProcessor,
-    enrichFormElement,
-    processSubmission,
-  }
-}

package/server/__tests__/graphqlMiddleware.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test, vi } from 'vitest'
-import graphqlMiddlewareConfig from './../graphqlMiddleware.serverOptions'
-import type { H3Event } from 'h3'
-
-vi.mock('#graphql-server-options', () => {
-  return {
-    defineGraphqlServerOptions(v: unknown) {
-      return v
-    },
-  }
-})
-
-const metaMock = vi.hoisted(() => ({
-  importMetaClient: false,
-}))
-
-vi.mock('~~/shared/importMeta', () => metaMock)
-
-describe('The nuxt-graphql-middleware config', () => {
-  test('Passes appropriate incoming headers', async () => {
-    metaMock.importMetaClient = false
-    expect(graphqlMiddlewareConfig.serverFetchOptions).toBeDefined()
-
-    const event = {
-      node: {
-        req: {
-          headers: {
-            foobar: 'test',
-            cookie: 'my_cookie',
-          },
-        },
-      },
-    } as unknown as H3Event
-
-    const result = await graphqlMiddlewareConfig!.serverFetchOptions!(event)
-    // @ts-ignore
-    expect(result.headers?.foobar).toBeUndefined()
-    // @ts-ignore
-    expect(result.headers?.cookie).toEqual('my_cookie')
-  })
-})

package/server/multiCache.serverOptions.ts

@@ -1,32 +0,0 @@
-import { defineMultiCacheOptions } from 'nuxt-multi-cache/server-options'
-import { getHeaders } from 'h3'
-import type { H3Event } from 'h3'
-import lruCacheDriver from 'unstorage/drivers/lru-cache'
-
-export default defineMultiCacheOptions(() => {
-  return {
-    api: {},
-    data: {},
-    enabledForRequest: (event: H3Event) => {
-      const hasSession = (event.node.req.headers.cookie || '').includes('SSESS')
-      return Promise.resolve(!hasSession)
-    },
-    route: {
-      storage: {
-        driver: lruCacheDriver({
-          max: 10000,
-        }),
-      },
-      buildCacheKey: (event: H3Event) => {
-        const path = (event.path || '')
-          .replaceAll('/', '__')
-          .replaceAll('?', '__')
-          .replaceAll('&', '__')
-
-        const headers = getHeaders(event)
-        const cookie = headers.cookie || 'anonymous'
-        return path + cookie
-      },
-    },
-  }
-})

package/vitest.config.mts

@@ -1,28 +0,0 @@
-import { defineVitestConfig } from '@nuxt/test-utils/config'
-import path from 'path'
-
-export default defineVitestConfig({
-  test: {
-    globals: true,
-    environment: 'nuxt',
-    alias: {
-      '~': path.resolve(__dirname, './app'),
-      '~~': path.resolve(__dirname, './'),
-    },
-    coverage: {
-      all: true,
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      include: [
-        'app/**/*.*',
-        'components/**/*.*',
-        'composables/**/*.*',
-        'config/**/*.*',
-        'layouts/**/*.*',
-        'middleware/**/*.*',
-        'plugins/**/*.*',
-        '/**/*.*',
-      ],
-    },
-  },
-})