{"version":3,"sources":["../../../../../src/server/app-render/instant-validation/instant-samples.ts"],"sourcesContent":["import type { InstantSample } from '../../../build/segment-config/app/app-segment-config'\nimport type { ReadonlyRequestCookies } from '../../web/spec-extension/adapters/request-cookies'\nimport type { ReadonlyHeaders } from '../../web/spec-extension/adapters/headers'\nimport type { DraftModeProvider } from '../../async-storage/draft-mode-provider'\nimport type { Params } from '../../request/params'\n\nimport { RequestCookies } from '../../web/spec-extension/cookies'\nimport { RequestCookiesAdapter } from '../../web/spec-extension/adapters/request-cookies'\nimport { HeadersAdapter } from '../../web/spec-extension/adapters/headers'\nimport type { SearchParams } from '../../request/search-params'\nimport { getSegmentParam } from '../../../shared/lib/router/utils/get-segment-param'\nimport { parseRelativeUrl } from '../../../shared/lib/router/utils/parse-relative-url'\nimport { InvariantError } from '../../../shared/lib/invariant-error'\nimport { InstantValidationError } from './instant-validation-error'\nimport { workUnitAsyncStorage } from '../work-unit-async-storage.external'\nimport { wellKnownProperties } from '../../../shared/lib/utils/reflect-utils'\nimport type { WorkStore } from '../work-async-storage.external'\n\nexport type InstantValidationSampleTracking = {\n  // TODO(instant-validation-build): track which samples config we used and attribute errors\n  missingSampleErrors: InstantValidationError[]\n}\n\nexport function createValidationSampleTracking(): InstantValidationSampleTracking {\n  return {\n    missingSampleErrors: [],\n  }\n}\n\nfunction getExpectedSampleTracking(): InstantValidationSampleTracking {\n  let validationSampleTracking: InstantValidationSampleTracking | null = null\n  const workUnitStore = workUnitAsyncStorage.getStore()\n  if (workUnitStore) {\n    switch (workUnitStore.type) {\n      case 'request':\n      case 'validation-client':\n        // TODO(instant-validation-build): do we need any special handling for caches?\n        validationSampleTracking =\n          workUnitStore.validationSampleTracking ?? null\n        break\n      case 'cache':\n      case 'private-cache':\n      case 'unstable-cache':\n      case 'prerender-legacy':\n      case 'prerender-ppr':\n      case 'prerender-client':\n      case 'prerender':\n      case 'prerender-runtime':\n      case 'generate-static-params':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n  if (!validationSampleTracking) {\n    throw new InvariantError(\n      'Expected to have a workUnitStore that provides validationSampleTracking'\n    )\n  }\n  return validationSampleTracking\n}\n\nexport function trackMissingSampleError(error: InstantValidationError): void {\n  const validationSampleTracking = getExpectedSampleTracking()\n  validationSampleTracking.missingSampleErrors.push(error)\n}\n\nexport function trackMissingSampleErrorAndThrow(\n  error: InstantValidationError\n): never {\n  // TODO(instant-validation-build): this should abort the render\n  trackMissingSampleError(error)\n  throw error\n}\n\n/**\n * Creates ReadonlyRequestCookies from sample cookie data.\n * Accessing a cookie not declared in the sample will throw an error.\n * Cookies with `value: null` are declared (allowed to access) but return no value.\n */\nexport function createCookiesFromSample(\n  sampleCookies: InstantSample['cookies'],\n  route: string\n): ReadonlyRequestCookies {\n  const declaredNames = new Set<string>()\n\n  const cookies = new RequestCookies(new Headers())\n  if (sampleCookies) {\n    for (const cookie of sampleCookies) {\n      declaredNames.add(cookie.name)\n      if (cookie.value !== null) {\n        cookies.set(cookie.name, cookie.value)\n      }\n    }\n  }\n\n  const sealed = RequestCookiesAdapter.seal(cookies)\n\n  return new Proxy(sealed, {\n    get(target, prop, receiver) {\n      if (prop === 'has') {\n        const originalMethod = Reflect.get(target, prop, receiver)\n        const wrappedMethod: typeof originalMethod = function (name) {\n          if (!declaredNames.has(name)) {\n            trackMissingSampleErrorAndThrow(\n              createMissingCookieSampleError(route, name)\n            )\n          }\n          return originalMethod.call(target, name)\n        }\n        return wrappedMethod\n      }\n      if (prop === 'get') {\n        const originalMethod = Reflect.get(target, prop, receiver)\n        const wrappedMethod: typeof originalMethod = function (nameOrCookie) {\n          let name: string\n          if (typeof nameOrCookie === 'string') {\n            name = nameOrCookie\n          } else if (\n            nameOrCookie &&\n            typeof nameOrCookie === 'object' &&\n            typeof nameOrCookie.name === 'string'\n          ) {\n            name = nameOrCookie.name\n          } else {\n            // This is an invalid input. Pass it through to the original method so it can error.\n            return originalMethod.call(target, nameOrCookie)\n          }\n\n          if (!declaredNames.has(name)) {\n            trackMissingSampleErrorAndThrow(\n              createMissingCookieSampleError(route, name)\n            )\n          }\n          return originalMethod.call(target, name)\n        }\n        return wrappedMethod\n      }\n\n      // TODO(instant-validation-build): what should getAll do?\n      // Maybe we should only allow it if there's an array (possibly empty?)\n\n      return Reflect.get(target, prop, receiver)\n    },\n  })\n}\n\nfunction createMissingCookieSampleError(\n  route: string,\n  name: string\n): InstantValidationError {\n  return new InstantValidationError(\n    `Route \"${route}\" accessed cookie \"${name}\" which is not defined in the \\`samples\\` ` +\n      `of \\`unstable_instant\\`. Add it to the sample's \\`cookies\\` array, ` +\n      `or \\`{ name: \"${name}\", value: null }\\` if it should be absent.`\n  )\n}\n\n/**\n * Creates ReadonlyHeaders from sample header data.\n * Accessing a header not declared in the sample will throw an error.\n * Headers with `value: null` are declared (allowed to access) but return null.\n */\nexport function createHeadersFromSample(\n  rawSampleHeaders: InstantSample['headers'],\n  sampleCookies: InstantSample['cookies'],\n  route: string\n): ReadonlyHeaders {\n  // If we have cookie samples, add a `cookie` header to match.\n  // Accessing it will be implicitly allowed by the proxy --\n  // if the user defined some cookies, accessing the \"cookie\" header is also fine.\n  const sampleHeaders = rawSampleHeaders ? [...rawSampleHeaders] : []\n  if (sampleHeaders.find(([name]) => name.toLowerCase() === 'cookie')) {\n    throw new InstantValidationError(\n      'Invalid sample: Defining cookies via a \"cookie\" header is not supported. Use `cookies: [{ name: ..., value: ... }]` instead.'\n    )\n  }\n  if (sampleCookies) {\n    const cookieHeaderValue = sampleCookies.toString()\n    sampleHeaders.push([\n      'cookie',\n      // if the `cookies` samples were empty, or they were all `null`, then we have no cookies,\n      // and the header isn't present, but should remains readable, so we set it to null.\n      cookieHeaderValue !== '' ? cookieHeaderValue : null,\n    ])\n  }\n\n  const declaredNames = new Set<string>()\n  const headersInit: Record<string, string> = {}\n\n  for (const [name, value] of sampleHeaders) {\n    declaredNames.add(name.toLowerCase())\n    if (value !== null) {\n      headersInit[name.toLowerCase()] = value\n    }\n  }\n\n  const sealed = HeadersAdapter.seal(HeadersAdapter.from(headersInit))\n\n  return new Proxy(sealed, {\n    get(target, prop, receiver) {\n      if (prop === 'get' || prop === 'has') {\n        const originalMethod = Reflect.get(target, prop, receiver)\n        const patchedMethod: typeof originalMethod = function (rawName) {\n          const name = rawName.toLowerCase()\n          if (!declaredNames.has(name)) {\n            trackMissingSampleErrorAndThrow(\n              new InstantValidationError(\n                `Route \"${route}\" accessed header \"${name}\" which is not defined in the \\`samples\\` ` +\n                  `of \\`unstable_instant\\`. Add it to the sample's \\`headers\\` array, ` +\n                  `or \\`[\"${name}\", null]\\` if it should be absent.`\n              )\n            )\n          }\n          // typescript can't reconcile a union of functions with a union of return types,\n          // so we have to cast the original return type away\n          return (originalMethod as (...args: any[]) => any).call(target, name)\n        }\n        return patchedMethod\n      }\n      return Reflect.get(target, prop, receiver)\n    },\n  })\n}\n\n/**\n * Creates a DraftModeProvider that always returns isEnabled: false.\n */\nexport function createDraftModeForValidation(): DraftModeProvider {\n  // Create a minimal DraftModeProvider-compatible object\n  // that always reports draft mode as disabled.\n  //\n  // private properties that can't be set from outside the class.\n  return {\n    get isEnabled() {\n      return false\n    },\n    enable() {\n      throw new Error(\n        'Draft mode cannot be enabled during build-time instant validation.'\n      )\n    },\n    disable() {\n      throw new Error(\n        'Draft mode cannot be disabled during build-time instant validation.'\n      )\n    },\n  } as Partial<DraftModeProvider> as DraftModeProvider\n}\n\n/**\n * Creates params wrapped with an exhaustive proxy.\n * Accessing a param not declared in the sample will throw an error.\n */\nexport function createExhaustiveParamsProxy<TParams extends Params>(\n  underlyingParams: TParams,\n  declaredParamNames: Set<string>,\n  route: string\n): TParams {\n  return new Proxy(underlyingParams, {\n    get(target, prop, receiver) {\n      if (\n        typeof prop === 'string' &&\n        !wellKnownProperties.has(prop) &&\n        // Only error when accessing a param that is part of the route but wasn't provided.\n        // accessing properties that aren't expected to be a valid param value is fine.\n        prop in underlyingParams &&\n        !declaredParamNames.has(prop)\n      ) {\n        trackMissingSampleErrorAndThrow(\n          new InstantValidationError(\n            `Route \"${route}\" accessed param \"${prop}\" which is not defined in the \\`samples\\` ` +\n              `of \\`unstable_instant\\`. Add it to the sample's \\`params\\` object.`\n          )\n        )\n      }\n      return Reflect.get(target, prop, receiver)\n    },\n    // We don't need to override `has` or `ownKeys`.\n    // the shape of the params object is determined by the routing structure\n    // and independent of the samples. We only need to instrument accessing the values.\n  })\n}\n\n/**\n * Creates searchParams wrapped with an exhaustive proxy.\n * Accessing a searchParam not declared in the sample will throw an error.\n * A searchParam with `value: undefined` means \"declared but absent\" (allowed to access, returns undefined).\n */\nexport function createExhaustiveSearchParamsProxy(\n  searchParams: SearchParams,\n  declaredSearchParamNames: Set<string>,\n  route: string\n): SearchParams {\n  return new Proxy(searchParams, {\n    get(target, prop, receiver) {\n      if (\n        typeof prop === 'string' &&\n        !wellKnownProperties.has(prop) &&\n        !declaredSearchParamNames.has(prop)\n      ) {\n        trackMissingSampleErrorAndThrow(\n          createMissingSearchParamSampleError(route, prop)\n        )\n      }\n      return Reflect.get(target, prop, receiver)\n    },\n    has(target, prop) {\n      if (\n        typeof prop === 'string' &&\n        !wellKnownProperties.has(prop) &&\n        !declaredSearchParamNames.has(prop)\n      ) {\n        trackMissingSampleErrorAndThrow(\n          createMissingSearchParamSampleError(route, prop)\n        )\n      }\n      return Reflect.has(target, prop)\n    },\n  })\n}\n\n/**\n * Wraps a URLSearchParams (or subclass like ReadonlyURLSearchParams) with an\n * exhaustive proxy. Accessing a search param not declared in the sample via\n * get/getAll/has will throw an error.\n */\nexport function createExhaustiveURLSearchParamsProxy<T extends URLSearchParams>(\n  searchParams: T,\n  declaredSearchParamNames: Set<string>,\n  route: string\n): T {\n  return new Proxy(searchParams, {\n    get(target, prop, receiver) {\n      // Intercept method calls that access specific param names\n      if (prop === 'get' || prop === 'getAll' || prop === 'has') {\n        const originalMathod = Reflect.get(target, prop, receiver)\n        return (name: string) => {\n          if (typeof name === 'string' && !declaredSearchParamNames.has(name)) {\n            trackMissingSampleErrorAndThrow(\n              createMissingSearchParamSampleError(route, name)\n            )\n          }\n          return (originalMathod as (...args: any[]) => any).call(target, name)\n        }\n      }\n      const value = Reflect.get(target, prop, receiver)\n      // Prevent `TypeError: Value of \"this\" must be of type URLSearchParams` for methods\n      if (typeof value === 'function' && !Object.hasOwn(target, prop)) {\n        return value.bind(target)\n      }\n      return value\n    },\n  })\n}\n\nfunction createMissingSearchParamSampleError(\n  route: string,\n  name: string\n): InstantValidationError {\n  return new InstantValidationError(\n    `Route \"${route}\" accessed searchParam \"${name}\" which is not defined in the \\`samples\\` ` +\n      `of \\`unstable_instant\\`. Add it to the sample's \\`searchParams\\` object, ` +\n      `or \\`{ \"${name}\": null }\\` if it should be absent.`\n  )\n}\n\nexport function createRelativeURLFromSamples(\n  route: string,\n  sampleParams: InstantSample['params'],\n  sampleSearchParams: InstantSample['searchParams']\n) {\n  // Build searchParams query object and URL search string from sample\n  const pathname = createPathnameFromRouteAndSampleParams(\n    route,\n    sampleParams ?? {}\n  )\n\n  let search = ''\n  if (sampleSearchParams) {\n    const qs = createURLSearchParamsFromSample(sampleSearchParams).toString()\n    if (qs) {\n      search = '?' + qs\n    }\n  }\n\n  return parseRelativeUrl(pathname + search, undefined, true)\n}\n\nfunction createURLSearchParamsFromSample(\n  sampleSearchParams: InstantSample['searchParams']\n) {\n  const result = new URLSearchParams()\n  if (sampleSearchParams) {\n    for (const [key, value] of Object.entries(sampleSearchParams)) {\n      if (value === null || value === undefined) continue\n      if (Array.isArray(value)) {\n        for (const v of value) {\n          result.append(key, v)\n        }\n      } else {\n        result.set(key, value)\n      }\n    }\n  }\n  return result\n}\n\n/**\n * Substitute sample params into `workStore.route` to create a plausible pathname.\n * TODO(instant-validation-build): this logic is somewhat hacky and likely incomplete,\n * but it should be good enough for some initial testing.\n */\nfunction createPathnameFromRouteAndSampleParams(route: string, params: Params) {\n  let interpolatedSegments: string[] = []\n  const rawSegments = route.split('/')\n  for (const rawSegment of rawSegments) {\n    const param = getSegmentParam(rawSegment)\n    if (param) {\n      switch (param.paramType) {\n        case 'catchall':\n        case 'optional-catchall': {\n          let paramValue = params[param.paramName]\n          if (paramValue === undefined) {\n            // The value for the param was not provided. `usePathname` will detect this and throw\n            // before this can surface to userspace. Use `[...NAME]` as a placeholder for the param value\n            // in case it pops up somewhere unexpectedly.\n            paramValue = [rawSegment]\n          } else if (!Array.isArray(paramValue)) {\n            // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`\n            throw new InstantValidationError(\n              `Expected sample param value for segment '${rawSegment}' to be an array of strings, got ${typeof paramValue}`\n            )\n          }\n          interpolatedSegments.push(\n            ...paramValue.map((v) => encodeURIComponent(v))\n          )\n          break\n        }\n        case 'dynamic': {\n          let paramValue = params[param.paramName]\n          if (paramValue === undefined) {\n            // The value for the param was not provided. `usePathname` will detect this and throw\n            // before this can surface to userspace. Use `[NAME]` as a placeholder for the param value\n            // in case it pops up somewhere unexpectedly.\n            paramValue = rawSegment\n          } else if (typeof paramValue !== 'string') {\n            // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`\n            throw new InstantValidationError(\n              `Expected sample param value for segment '${rawSegment}' to be a string, got ${typeof paramValue}`\n            )\n          }\n          interpolatedSegments.push(encodeURIComponent(paramValue))\n          break\n        }\n        case 'catchall-intercepted-(..)(..)':\n        case 'catchall-intercepted-(.)':\n        case 'catchall-intercepted-(..)':\n        case 'catchall-intercepted-(...)':\n        case 'dynamic-intercepted-(..)(..)':\n        case 'dynamic-intercepted-(.)':\n        case 'dynamic-intercepted-(..)':\n        case 'dynamic-intercepted-(...)': {\n          // TODO(instant-validation-build): i don't know how these are supposed to work, or if we can even get them here\n          throw new InvariantError(\n            'Not implemented: Validation of interception routes'\n          )\n        }\n        default: {\n          param.paramType satisfies never\n        }\n      }\n    } else {\n      interpolatedSegments.push(rawSegment)\n    }\n  }\n  return interpolatedSegments.join('/')\n}\n\nexport function assertRootParamInSamples(\n  workStore: WorkStore,\n  sampleParams: Params | undefined,\n  paramName: string\n) {\n  if (sampleParams && paramName in sampleParams) {\n    // The param is defined in the samples.\n  } else {\n    const route = workStore.route\n    trackMissingSampleErrorAndThrow(\n      new InstantValidationError(\n        `Route \"${route}\" accessed root param \"${paramName}\" which is not defined in the \\`samples\\` ` +\n          `of \\`unstable_instant\\`. Add it to the sample's \\`params\\` object.`\n      )\n    )\n  }\n}\n"],"names":["RequestCookies","RequestCookiesAdapter","HeadersAdapter","getSegmentParam","parseRelativeUrl","InvariantError","InstantValidationError","workUnitAsyncStorage","wellKnownProperties","createValidationSampleTracking","missingSampleErrors","getExpectedSampleTracking","validationSampleTracking","workUnitStore","getStore","type","trackMissingSampleError","error","push","trackMissingSampleErrorAndThrow","createCookiesFromSample","sampleCookies","route","declaredNames","Set","cookies","Headers","cookie","add","name","value","set","sealed","seal","Proxy","get","target","prop","receiver","originalMethod","Reflect","wrappedMethod","has","createMissingCookieSampleError","call","nameOrCookie","createHeadersFromSample","rawSampleHeaders","sampleHeaders","find","toLowerCase","cookieHeaderValue","toString","headersInit","from","patchedMethod","rawName","createDraftModeForValidation","isEnabled","enable","Error","disable","createExhaustiveParamsProxy","underlyingParams","declaredParamNames","createExhaustiveSearchParamsProxy","searchParams","declaredSearchParamNames","createMissingSearchParamSampleError","createExhaustiveURLSearchParamsProxy","originalMathod","Object","hasOwn","bind","createRelativeURLFromSamples","sampleParams","sampleSearchParams","pathname","createPathnameFromRouteAndSampleParams","search","qs","createURLSearchParamsFromSample","undefined","result","URLSearchParams","key","entries","Array","isArray","v","append","params","interpolatedSegments","rawSegments","split","rawSegment","param","paramType","paramValue","paramName","map","encodeURIComponent","join","assertRootParamInSamples","workStore"],"mappings":"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","ignoreList":[0]}