@teleporthq/teleport-project-generator-next 0.43.75 → 0.44.0

package/__tests__/analytics-tracker-consent.test.ts

@@ -0,0 +1,165 @@
+import { TRACKER_SOURCE } from '../src/analytics/tracker-source'
+
+/**
+ * Retention only recognises visitors who accepted the cookie banner. The banner
+ * is accepted on a page the tracker is already running on, so the tracker must
+ * pick the consent up mid-visit — reading it only at boot left the accepting
+ * visit (and every client-side navigation after it) anonymous, and a visitor
+ * needed a THIRD visit before they could ever count as returning.
+ *
+ * These tests run the emitted tracker against a stubbed browser and read what
+ * it actually sends.
+ */
+
+type Sent = Record<string, unknown>
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
+
+function memoryStorage() {
+  const values = new Map<string, string>()
+  return {
+    getItem: (key: string) => (values.has(key) ? values.get(key) : null),
+    setItem: (key: string, value: string) => values.set(key, String(value)),
+    removeItem: (key: string) => values.delete(key),
+  }
+}
+
+function bootTracker() {
+  const localStorage = memoryStorage()
+  const sessionStorage = memoryStorage()
+  const batches: Sent[][] = []
+  const heartbeats: Sent[] = []
+  const documentListeners: Record<string, () => void> = {}
+
+  const fakeDocument = {
+    visibilityState: 'visible',
+    referrer: '',
+    documentElement: { scrollHeight: 0 },
+    addEventListener: (type: string, listener: () => void) => {
+      documentListeners[type] = listener
+    },
+    querySelector: () => null,
+  }
+  const fakeWindow = {
+    location: { hostname: 'shop.example.com', pathname: '/', search: '' },
+    localStorage,
+    sessionStorage,
+    screen: { width: 1440 },
+    innerHeight: 900,
+    scrollY: 0,
+    addEventListener: () => undefined,
+  }
+  const fakeFetch = (url: string, init: { body: string }) => {
+    const payload = JSON.parse(init.body)
+    if (url.endsWith('/heartbeat')) {
+      heartbeats.push(payload)
+    } else {
+      batches.push(payload.events)
+    }
+    return Promise.resolve({ status: 202 })
+  }
+
+  const body = TRACKER_SOURCE.replace(/^export\s+/gm, '')
+  const tracker = new Function(
+    'process',
+    'window',
+    'document',
+    'navigator',
+    'fetch',
+    'setInterval',
+    `${body}\nreturn { initTeleportAnalytics, trackRouteChange }`
+  )(
+    {
+      env: {
+        NEXT_PUBLIC_TELEPORT_ANALYTICS_URL: 'https://analytics.example.com',
+        NEXT_PUBLIC_TELEPORT_ANALYTICS_KEY: 'public-key',
+      },
+    },
+    fakeWindow,
+    fakeDocument,
+    { webdriver: false },
+    fakeFetch,
+    () => 0
+  )
+
+  // Hiding the page flushes the queue — the same path a real tab switch takes.
+  const flush = (): Sent[] => {
+    fakeDocument.visibilityState = 'hidden'
+    documentListeners.visibilitychange()
+    fakeDocument.visibilityState = 'visible'
+    return batches.splice(0).flat()
+  }
+  // Showing the page again sends a heartbeat straight away.
+  const show = () => {
+    fakeDocument.visibilityState = 'visible'
+    documentListeners.visibilitychange()
+  }
+  const navigate = (path: string) => {
+    fakeWindow.location.pathname = path
+    tracker.trackRouteChange(path)
+  }
+
+  return { tracker, localStorage, sessionStorage, heartbeats, flush, show, navigate }
+}
+
+describe('tracker — consent given or withdrawn mid-visit', () => {
+  it('upgrades the running visit to the persistent id once the banner is accepted', () => {
+    const page = bootTracker()
+    page.tracker.initTeleportAnalytics({})
+    const [landing] = page.flush()
+
+    expect(landing.visitorId).toBeNull()
+    expect(page.localStorage.getItem('tp_aid')).toBeNull()
+
+    page.localStorage.setItem('cookieConsent', 'accepted')
+    page.navigate('/pricing')
+    const [next] = page.flush()
+
+    const visitorId = page.localStorage.getItem('tp_aid')
+    expect(visitorId).toMatch(UUID)
+    expect(next.visitorId).toBe(visitorId)
+    // Same session: the server hands it to the consented visitor instead of
+    // counting a second visit.
+    expect(next.sessionId).toBe(landing.sessionId)
+    expect(page.sessionStorage.getItem('tp_sid')).toBe(landing.sessionId)
+  })
+
+  it('sends the persistent id on heartbeats after the banner is accepted', () => {
+    const page = bootTracker()
+    page.tracker.initTeleportAnalytics({})
+    expect(page.heartbeats[0].visitorId).toBeNull()
+
+    page.localStorage.setItem('cookieConsent', 'accepted')
+    page.show()
+
+    const lastBeat = page.heartbeats[page.heartbeats.length - 1]
+    expect(lastBeat.visitorId).toMatch(UUID)
+    expect(lastBeat.visitorId).toBe(page.localStorage.getItem('tp_aid'))
+  })
+
+  it('reuses the stored id for a visitor who accepted on an earlier visit', () => {
+    const page = bootTracker()
+    page.localStorage.setItem('cookieConsent', 'accepted')
+    page.localStorage.setItem('tp_aid', '0f8fad5b-d9cb-469f-a165-70867728950e')
+    page.tracker.initTeleportAnalytics({})
+
+    const [landing] = page.flush()
+    expect(landing.visitorId).toBe('0f8fad5b-d9cb-469f-a165-70867728950e')
+  })
+
+  it('drops the persistent id in a fresh anonymous session when consent disappears', () => {
+    const page = bootTracker()
+    page.localStorage.setItem('cookieConsent', 'accepted')
+    page.tracker.initTeleportAnalytics({})
+    const [landing] = page.flush()
+    expect(landing.visitorId).toMatch(UUID)
+
+    page.localStorage.removeItem('cookieConsent')
+    page.navigate('/contact')
+    const [next] = page.flush()
+
+    expect(next.visitorId).toBeNull()
+    expect(next.sessionId).toMatch(UUID)
+    expect(next.sessionId).not.toBe(landing.sessionId)
+  })
+})

package/__tests__/booking-context-plugin.test.ts

@@ -0,0 +1,96 @@
+import { FileType, ProjectPluginStructure, UIDLBookingSettings } from '@teleporthq/teleport-types'
+import { NextBookingProjectPlugin } from '../src/bookings/project-plugin'
+
+/**
+ * The booking items' category taxonomy is baked into `booking-context.js` and
+ * read through `useBookingCategories()` — the booking page's category filter is
+ * an array mapper over it, as the products' and the blog's are over theirs.
+ */
+
+const PAGE_WITHOUT_HOOK = 'export default function Book() { return null }'
+const PAGE_WITH_HOOK = [
+  "import { useBookingCategories } from '@/booking-context'",
+  'export default function Book() { return null }',
+].join('\n')
+
+const buildStructure = (params: {
+  pageContent: string
+  bookingSettings?: UIDLBookingSettings
+}): ProjectPluginStructure => {
+  const files = new Map<string, { path: string[]; files: Array<Record<string, unknown>> }>()
+  files.set('book', {
+    path: ['pages'],
+    files: [{ name: 'book', fileType: FileType.JS, content: params.pageContent }],
+  })
+  return {
+    uidl: {
+      globals: { env: {} },
+      ...(params.bookingSettings ? { bookingSettings: params.bookingSettings } : {}),
+    },
+    files,
+    dependencies: {},
+    devDependencies: {},
+  } as unknown as ProjectPluginStructure
+}
+
+const findContext = (structure: ProjectPluginStructure) =>
+  structure.files.get('booking-context')?.files?.[0] as { content: string } | undefined
+
+describe('NextBookingProjectPlugin', () => {
+  it('bakes the taxonomy behind a memoized, locale-aware hook', async () => {
+    const structure = buildStructure({
+      pageContent: PAGE_WITHOUT_HOOK,
+      bookingSettings: {
+        categories: [
+          {
+            id: 'rooms',
+            name: 'Rooms',
+            slug: 'rooms',
+            parentId: null,
+            order: 0,
+            children: [],
+            translations: { es: { name: 'Habitaciones' } },
+          },
+        ],
+      },
+    })
+
+    await new NextBookingProjectPlugin().runAfter(structure)
+
+    const context = findContext(structure)
+    expect(context).toBeDefined()
+    expect(context!.content).toContain('export const useBookingCategories')
+    expect(context!.content).toContain(
+      'resolveCategoryTranslations(BOOKING_CATEGORIES, router.locale)'
+    )
+    expect(context!.content).toContain('"Habitaciones"')
+    expect(context!.content).not.toContain('createContext')
+  })
+
+  it('emits an EMPTY taxonomy for bookings that have no categories yet', async () => {
+    const structure = buildStructure({
+      pageContent: PAGE_WITHOUT_HOOK,
+      bookingSettings: { categories: [] },
+    })
+
+    await new NextBookingProjectPlugin().runAfter(structure)
+
+    expect(findContext(structure)!.content).toContain('const BOOKING_CATEGORIES = []')
+  })
+
+  it('backstops a dangling import when the project carries no bookingSettings', async () => {
+    const structure = buildStructure({ pageContent: PAGE_WITH_HOOK })
+
+    await new NextBookingProjectPlugin().runAfter(structure)
+
+    expect(findContext(structure)!.content).toContain('const BOOKING_CATEGORIES = []')
+  })
+
+  it('leaves a project that never references the hook untouched', async () => {
+    const structure = buildStructure({ pageContent: PAGE_WITHOUT_HOOK })
+
+    await new NextBookingProjectPlugin().runAfter(structure)
+
+    expect(findContext(structure)).toBeUndefined()
+  })
+})

package/__tests__/content-category-page-end2end.test.ts

@@ -167,7 +167,9 @@ describe('a content preset category page, generated', () => {
         `import \\{[\\s\\S]*\\b${RESOLVER}\\b[\\s\\S]*\\} from '${MODULE.replace('/', '\\/')}'`
       )
     )
-    expect(page).toMatch(new RegExp(`await ${RESOLVER}\\(\\{[\\s\\S]*slug: params\\['slug'\\]`))
+    expect(page).toMatch(
+      new RegExp(`await ${RESOLVER}\\(\\{[\\s\\S]*slug: params\\?\\.\\['slug'\\]`)
+    )
     expect(page).toMatch(
       /if \(!response\?\.data\) \{\s*return \{\s*notFound: true,\s*revalidate: 60/
     )

package/__tests__/custom-pages-end2end.test.ts

@@ -232,7 +232,7 @@ describe('Next generator — Custom Pages', () => {
     it('server-fetches the published row by the slug route param and 404s when it is missing', () => {
       const { page } = generated
       expect(page).toContain('export async function getStaticProps')
-      expect(page).toMatch(/source:\s*'slug',\s*destination:\s*params\['slug'\]/)
+      expect(page).toMatch(/source:\s*'slug',\s*destination:\s*params\?\.\['slug'\]/)
       expect(page).toMatch(/source:\s*'status',\s*destination:\s*'published'/)
       expect(page).toContain('notFound: true')
     })

package/__tests__/form-inside-conditional-onsubmit.test.ts

@@ -0,0 +1,99 @@
+import { GeneratedFolder, ProjectUIDL, UIDLFormDefinition } from '@teleporthq/teleport-types'
+import uidlSample from '../../../examples/test-samples/project-sample.json'
+import { createNextProjectGenerator } from '../src'
+import NextTemplate from '../src/project-template'
+
+/**
+ * A platform form rendered inside a rendering condition (a results step of a
+ * multi-step page: `{activeStep === 7 && (<form data-form-id=…/>)}`) must
+ * still receive the generated onSubmit handler. It did not: the handler was
+ * declared but never attached, so a workflow's `form.requestSubmit()` posted
+ * the form natively and reloaded the page, losing every state value.
+ */
+
+const template = JSON.parse(JSON.stringify(NextTemplate)) as GeneratedFolder
+const FORM_ID = 'results-form'
+
+const formElement = () => ({
+  type: 'element',
+  content: {
+    elementType: 'form',
+    name: 'results',
+    attrs: { 'data-form-id': { type: 'static', content: FORM_ID } },
+    children: [
+      {
+        type: 'element',
+        content: {
+          elementType: 'textinput',
+          name: 'email',
+          attrs: {
+            name: { type: 'static', content: 'email' },
+            type: { type: 'static', content: 'email' },
+          },
+        },
+      },
+    ],
+  },
+})
+
+const formDefinition = (): UIDLFormDefinition => ({
+  id: { type: 'static', content: FORM_ID },
+  name: { type: 'static', content: 'Results' },
+  formNodeId: { type: 'static', content: 'form-node' },
+  fields: {
+    email: {
+      id: { type: 'static', content: 'email' },
+      name: { type: 'static', content: 'email' },
+      nodeId: { type: 'static', content: 'email-node' },
+      type: 'textinput',
+    },
+  },
+  behaviors: { onSuccess: { action: 'clear-form' }, onError: { action: 'clear-form' } },
+})
+
+const buildUidl = (): ProjectUIDL => {
+  const uidl = JSON.parse(JSON.stringify(uidlSample)) as ProjectUIDL
+  const indexPage = (uidl.root.node.content.children || []).find(
+    (child) =>
+      child.type === 'conditional' && (child.content as { value?: string }).value === 'index'
+  )
+  const pageElement = (indexPage as { content: { node: { content: { children: unknown[] } } } })
+    .content.node.content
+  const root = uidl.root as { stateDefinitions?: Record<string, unknown> }
+  root.stateDefinitions = {
+    ...(root.stateDefinitions || {}),
+    activeStep: { type: 'number', defaultValue: 1 },
+  }
+  pageElement.children.push({
+    type: 'conditional',
+    content: {
+      reference: { type: 'dynamic', content: { referenceType: 'state', id: 'activeStep' } },
+      value: 7,
+      node: formElement(),
+    },
+  })
+  uidl.forms = {
+    items: { [FORM_ID]: formDefinition() },
+    formsServerUrl: { type: 'env', content: 'NEXT_PUBLIC_FORMS_SERVER_URL' },
+    globalConfig: {
+      captchaProvider: 'recaptcha',
+      defaultCaptchaPublicKey: { type: 'env', content: 'NEXT_PUBLIC_CAPTCHA_PUBLIC_KEY' },
+    },
+  } as ProjectUIDL['forms']
+  return uidl
+}
+
+const indexPageOf = (folder: GeneratedFolder) =>
+  folder.subFolders.find((sub) => sub.name === 'pages')?.files.find((file) => file.name === 'index')
+    ?.content ?? ''
+
+describe('Next forms: a form inside a rendering condition keeps its submit handler', () => {
+  it('attaches onSubmit to the form rendered under `activeStep === 7`', async () => {
+    const page = indexPageOf(
+      await createNextProjectGenerator().generateProject(buildUidl(), template)
+    )
+    expect(page).toContain('activeStep === 7')
+    expect(page).toContain(`data-form-id="${FORM_ID}"`)
+    expect(page).toMatch(/onSubmit=\{handleFormSubmit_results_form\}/)
+  })
+})

package/__tests__/payment-pay-pages.test.ts

@@ -749,4 +749,44 @@ describe('what the store generator emits for its providers', () => {
       STRIPE_WEBHOOK_SECRET: '',
     })
   })
+
+  it('gives a site paid without a store (its bookings) the credentials, capture and confirmation', async () => {
+    const structure = build([])
+    delete (structure.uidl as any).ecommerceSettings
+    ;(structure.uidl as any).paymentSettings = {
+      paymentProviders: [
+        { type: 'paypal', credentials: { clientId: 'CONFIGURATION_PAYPAL_CLIENT_ID' } },
+        { type: 'razorpay', credentials: { keyId: 'CONFIGURATION_RAZORPAY_KEY_ID' } },
+      ],
+    }
+    ;(structure.uidl as any).workflows = {
+      workflows: {
+        paypalHook: {
+          name: 'PayPal Payment Webhook',
+          trigger: { type: 'event-webhook-received' },
+          webhookConfig: { urlPath: '/api/webhooks/paypal-payment' },
+        },
+      },
+    }
+    await new NextEcommerceProjectPlugin().runAfter(structure)
+    expect(structure.files.has('ecommerce-api-paypal-capture')).toBe(true)
+    expect(structure.files.has('payment-page-razorpay')).toBe(true)
+    expect(structure.files.has('ecommerce-api-payment-confirm')).toBe(true)
+    expect(structure.uidl.globals.env).toMatchObject({
+      PAYPAL_CLIENT_ID: 'teleporthq.secrets.CONFIGURATION_PAYPAL_CLIENT_ID',
+      RAZORPAY_KEY_ID: 'teleporthq.secrets.CONFIGURATION_RAZORPAY_KEY_ID',
+    })
+    // No store: no store runtime.
+    expect(structure.files.has('ecommerce-api-settings')).toBe(false)
+    expect(structure.files.has('ecommerce-api-cart')).toBe(false)
+  })
+
+  it('emits nothing for a site with neither a store nor payment settings', async () => {
+    const structure = build([])
+    delete (structure.uidl as any).ecommerceSettings
+    await new NextEcommerceProjectPlugin().runAfter(structure)
+    expect(structure.files.has('ecommerce-api-payment-confirm')).toBe(false)
+    expect(structure.files.has('payment-drivers')).toBe(false)
+    expect(structure.uidl.globals.env).toEqual({})
+  })
 })

package/__tests__/pwa-project-plugin.test.ts

@@ -322,6 +322,16 @@ describe('NextPwaProjectPlugin — installable app', () => {
     expect(clientConfig(structure).networkOnly).toEqual(workerConfig(structure).networkOnly)
   })
 
+  it('keeps the payment pages off the cache on a site paid for its bookings alone', async () => {
+    const paid = await run({
+      pwa: installableApp(),
+      paymentSettings: { paymentProviders: [{ type: 'razorpay' }] },
+    })
+    expect(workerConfig(paid).networkOnly).toContain('/pay')
+    const unpaid = await run({ pwa: installableApp() })
+    expect(workerConfig(unpaid).networkOnly).not.toContain('/pay')
+  })
+
   it('precaches nothing when the home page is private or the site is password protected', async () => {
     const privateHome = await run({ pwa: installableApp({ networkOnlyPaths: ['/'] }) })
     expect(workerConfig(privateHome).precacheUrls).toEqual([])

package/__tests__/state-data-source-fetch-grouping.test.ts

@@ -118,6 +118,37 @@ describe('state-data-source-plugin fetch grouping', () => {
     expect(listProp![1]).toBe(mirrorProp![1])
   })
 
+  it('keeps a fetch another plugin pushed into the declaration when it rebuilds it', async () => {
+    // The pagination plugin adds a paginated list's page fetch straight into
+    // the `const [...] = await Promise.all([...])` this plugin built; a later
+    // state registration rebuilt that declaration from its own bookkeeping
+    // and the list's fetch was gone — its props then read an undefined name.
+    const structure = makeStructure({
+      productsList: makeState('SELECT * FROM products ORDER BY sku ASC LIMIT 200'),
+    })
+    const first = await plugin(structure as any)
+    const chunk = first.chunks.find((c: any) => c.name === 'getStaticProps') as any
+    const declaration = chunk.meta.parallelFetchData.declaration as types.VariableDeclaration
+    const declarator = declaration.declarations[0]
+    ;(declarator.id as types.ArrayPattern).elements.push(types.identifier('Teleport_products_ds_0'))
+    ;(
+      (declarator.init as types.AwaitExpression).argument as types.CallExpression
+    ).arguments[0].elements.push(
+      types.callExpression(types.identifier('fetchProductsPage'), [types.numericLiteral(1)])
+    )
+
+    structure.uidl.stateDefinitions.lowStockAlerts = makeState()
+    const second = await plugin(structure as any)
+
+    const code = getStaticPropsCode(second as any)
+    expect(code.match(/Promise\.all/g)).toHaveLength(1)
+    expect(code).toContain('Teleport_products_ds_0')
+    expect(code).toContain('fetchProductsPage(1)')
+    const names = (second.chunks.find((c: any) => c.name === 'getStaticProps') as any).meta
+      .parallelFetchData.names
+    expect(new Set(names).size).toBe(names.length)
+  })
+
   it('separates a query-less binding from a queried one on the same table', async () => {
     // Products page shape: productsList has a rawQuery, lowStockAlerts is a
     // bare binding (whole table) — they must not share the LIMIT 200 fetch.

package/__tests__/state-data-source-page-arrival.test.ts

@@ -0,0 +1,187 @@
+import generator from '@babel/generator'
+import * as types from '@babel/types'
+import { ChunkType } from '@teleporthq/teleport-types'
+import { createStateDataSourcePlugin } from '../src/state-data-source-plugin'
+import { createEntityMutationSsrFinalizerPlugin } from '../src/entity-mutation-ssr-finalize-plugin'
+
+// A page state bound to a data source must hold the values computed for THIS
+// arrival. Seeded from getStaticProps it did not: a client-side navigation got
+// the JSON Next.js had cached in the browser (or prefetched with the link), ISR
+// served the copy rendered before the last write, and a navigation to the page
+// already on screen kept the old `useState` value whatever the new props said.
+// Such a page now renders per request and remounts on every arrival.
+
+const DS_ID = 'a784e6dd-ddc9-4d12-b9d2-137d285e313a'
+const FETCHER_FILE_NAME = 'teleport-customers-a784e6dd'
+
+const boundState = (query?: string) => ({
+  type: 'array',
+  defaultValue: [] as unknown[],
+  dataSourceBinding: { dataSourceId: DS_ID, refPath: ['customers'] },
+  ...(query ? { query } : {}),
+})
+
+const makeStructure = (stateDefinitions: Record<string, unknown>) => ({
+  uidl: {
+    name: 'Customers',
+    stateDefinitions,
+    node: { type: 'element', content: { elementType: 'container' } },
+    outputOptions: { folderPath: [] as string[] },
+  },
+  chunks: [
+    {
+      type: 'AST',
+      fileType: 'js',
+      name: 'jsx-component',
+      linkAfter: [] as string[],
+      content: types.variableDeclaration('const', [
+        types.variableDeclarator(
+          types.identifier('Customers'),
+          types.arrowFunctionExpression(
+            [types.identifier('props')],
+            types.blockStatement([types.returnStatement(types.nullLiteral())])
+          )
+        ),
+      ]),
+    },
+    {
+      type: 'AST',
+      fileType: 'js',
+      name: 'export',
+      linkAfter: ['jsx-component'],
+      content: types.exportDefaultDeclaration(types.identifier('Customers')),
+    },
+  ] as any[],
+  dependencies: {} as Record<string, unknown>,
+  options: {
+    pagesPath: ['pages'],
+    auth: { provider: 'teleport' },
+    dataSources: { [DS_ID]: { id: DS_ID, type: 'teleport', config: {} } },
+    // Pre-extracted fetcher, so the test does not depend on its generation.
+    extractedResources: {
+      [`utils/${FETCHER_FILE_NAME}`]: {
+        fileName: FETCHER_FILE_NAME,
+        fileType: 'js',
+        path: ['utils', 'data-sources'],
+        content: '// stub',
+      },
+    } as Record<string, any>,
+  },
+})
+
+const runPagePipeline = async (stateDefinitions: Record<string, unknown>) => {
+  const structure = makeStructure(stateDefinitions)
+  await createStateDataSourcePlugin()(structure as any)
+  await createEntityMutationSsrFinalizerPlugin()(structure as any)
+  const chunkCode = (name: string) => {
+    const chunk = structure.chunks.find((candidate) => candidate.name === name)
+    return chunk ? generator(chunk.content as types.Node).code : null
+  }
+  return { structure, chunkCode }
+}
+
+describe('page states seeded from a data source', () => {
+  it('render per request and remount the page on every arrival', async () => {
+    const { structure, chunkCode } = await runPagePipeline({
+      customersRows: boundState('SELECT * FROM customers ORDER BY created_at DESC LIMIT 20'),
+    })
+
+    expect(chunkCode('getStaticProps')).toBeNull()
+    const serverProps = chunkCode('getServerSideProps')
+    expect(serverProps).toContain('export async function getServerSideProps(context)')
+    expect(serverProps).toContain('customersRows:')
+    expect(serverProps).not.toContain('revalidate')
+
+    expect(chunkCode('export')).toBe('export default remountOnPageArrival(Customers);')
+    expect(structure.dependencies.remountOnPageArrival).toEqual({
+      type: 'local',
+      path: '../utils/page-arrival',
+    })
+    expect(structure.options.extractedResources['utils/page-arrival']).toBeDefined()
+  })
+
+  it('remount the page for states fetched in the browser, which stays statically generated', async () => {
+    const { structure, chunkCode } = await runPagePipeline({
+      invoicesRows: boundState(
+        "SELECT * FROM app_invoices WHERE customer_id = '{{Current User.id}}' LIMIT 20"
+      ),
+    })
+
+    expect(chunkCode('getServerSideProps')).toBeNull()
+    expect(chunkCode('jsx-component')).toContain('/api/page-state/')
+    expect(chunkCode('export')).toBe('export default remountOnPageArrival(Customers);')
+    expect(structure.options.extractedResources['utils/page-arrival']).toBeDefined()
+  })
+
+  it('leave the page alone when no state can be seeded', async () => {
+    const { structure, chunkCode } = await runPagePipeline({
+      customerRow: boundState("SELECT * FROM customers WHERE id = '{{urlDifferentiator}}'"),
+    })
+
+    expect(chunkCode('getStaticProps')).toBeNull()
+    expect(chunkCode('getServerSideProps')).toBeNull()
+    expect(chunkCode('export')).toBe('export default Customers;')
+    expect(structure.dependencies.remountOnPageArrival).toBeUndefined()
+    expect(structure.options.extractedResources['utils/page-arrival']).toBeUndefined()
+  })
+})
+
+describe('getServerSideProps finalizer — data-source states', () => {
+  const getStaticPropsChunk = () => {
+    const fn = types.functionDeclaration(
+      types.identifier('getStaticProps'),
+      [types.identifier('context')],
+      types.blockStatement([
+        types.returnStatement(
+          types.objectExpression([
+            types.objectProperty(types.identifier('props'), types.objectExpression([])),
+            types.objectProperty(types.identifier('revalidate'), types.numericLiteral(1)),
+          ])
+        ),
+      ]),
+      false,
+      true
+    )
+    return {
+      name: 'getStaticProps',
+      type: ChunkType.AST,
+      content: types.exportNamedDeclaration(fn),
+    }
+  }
+
+  const finalize = async (
+    stateDefinitions: Record<string, unknown>,
+    projectDataSources: object
+  ) => {
+    const structure: any = {
+      uidl: { name: 'Customers', node: { type: 'element', content: {} }, stateDefinitions },
+      chunks: [getStaticPropsChunk()],
+      dependencies: {},
+      options: { dataSources: projectDataSources },
+    }
+    await createEntityMutationSsrFinalizerPlugin()(structure)
+    return structure.chunks[0].name as string
+  }
+
+  const dataSources = { [DS_ID]: { id: DS_ID, type: 'teleport', config: {} } }
+
+  it('converts a page that seeds a state from a data source', async () => {
+    expect(await finalize({ rows: boundState('SELECT 1 AS value') }, dataSources)).toBe(
+      'getServerSideProps'
+    )
+    expect(await finalize({ rows: boundState() }, dataSources)).toBe('getServerSideProps')
+  })
+
+  it('keeps static generation when the bound state is only resolved in the browser', async () => {
+    expect(
+      await finalize(
+        { rows: boundState("SELECT * FROM t WHERE user_id = '{{Current User.id}}'") },
+        dataSources
+      )
+    ).toBe('getStaticProps')
+  })
+
+  it('keeps static generation when the bound data source is not in the project', async () => {
+    expect(await finalize({ rows: boundState('SELECT 1 AS value') }, {})).toBe('getStaticProps')
+  })
+})

package/__tests__/state-data-source-runtime-user-fetch.test.ts

@@ -109,7 +109,10 @@ const runPageStateRoute = async (
     throw new Error('unexpected require: ' + name)
   }
   const code = routeSource
-    .replace("import { Client } from 'pg'", "const { Client } = require('pg')")
+    .replace(
+      "import { Client, types as pgTypes } from 'pg'",
+      "const { Client, types: pgTypes } = require('pg')"
+    )
     .replace(/^export default async function handler/m, 'async function handler')
     .concat('\nmodule.exports = handler')
   const moduleObj: { exports: any } = { exports: {} }