Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

14.5 kB

import type { IncrementalCache } from '../../lib/incremental-cache'

import { CACHE_ONE_YEAR } from '../../../lib/constants'
import { validateRevalidate, validateTags } from '../../lib/patch-fetch'
import {
  workAsyncStorage,
  type WorkStore,
} from '../../app-render/work-async-storage.external'
import {
  getCacheSignal,
  getDraftModeProviderForCacheScope,
  workUnitAsyncStorage,
} from '../../app-render/work-unit-async-storage.external'
import {
  CachedRouteKind,
  IncrementalCacheKind,
  type CachedFetchData,
} from '../../response-cache'
import type {
  UnstableCacheStore,
  WorkUnitStore,
} from '../../app-render/work-unit-async-storage.external'

type Callback = (...args: any[]) => Promise<any>

let noStoreFetchIdx = 0

async function cacheNewResult<T>(
  result: T,
  incrementalCache: IncrementalCache,
  cacheKey: string,
  tags: string[],
  revalidate: number | false | undefined,
  fetchIdx: number,
  fetchUrl: string
): Promise<unknown> {
  await incrementalCache.set(
    cacheKey,
    {
      kind: CachedRouteKind.FETCH,
      data: {
        headers: {},
        // TODO: handle non-JSON values?
        body: JSON.stringify(result),
        status: 200,
        url: '',
      } satisfies CachedFetchData,
      revalidate: typeof revalidate !== 'number' ? CACHE_ONE_YEAR : revalidate,
    },
    { fetchCache: true, tags, fetchIdx, fetchUrl }
  )
  return
}

/**
 * This function allows you to cache the results of expensive operations, like database queries, and reuse them across multiple requests.
 *
 * Read more: [Next.js Docs: `unstable_cache`](https://nextjs.org/docs/app/api-reference/functions/unstable_cache)
 */
export function unstable_cache<T extends Callback>(
  cb: T,
  keyParts?: string[],
  options: {
    /**
     * The revalidation interval in seconds.
     */
    revalidate?: number | false
    tags?: string[]
  } = {}
): T {
  if (options.revalidate === 0) {
    throw new Error(
      `Invariant revalidate: 0 can not be passed to unstable_cache(), must be "false" or "> 0" ${cb.toString()}`
    )
  }

  // Validate the tags provided are valid
  const tags = options.tags
    ? validateTags(options.tags, `unstable_cache ${cb.toString()}`)
    : []

  // Validate the revalidate options
  validateRevalidate(
    options.revalidate,
    `unstable_cache ${cb.name || cb.toString()}`
  )

  // Stash the fixed part of the key at construction time. The invocation key will combine
  // the fixed key with the arguments when actually called
  // @TODO if cb.toString() is long we should hash it
  // @TODO come up with a collision-free way to combine keyParts
  // @TODO consider validating the keyParts are all strings. TS can't provide runtime guarantees
  // and the error produced by accidentally using something that cannot be safely coerced is likely
  // hard to debug
  const fixedKey = `${cb.toString()}-${
    Array.isArray(keyParts) && keyParts.join(',')
  }`

  const cachedCb = async (...args: any[]) => {
    const workStore = workAsyncStorage.getStore()
    const workUnitStore = workUnitAsyncStorage.getStore()

    // We must be able to find the incremental cache otherwise we throw
    const maybeIncrementalCache:
      | import('../../lib/incremental-cache').IncrementalCache
      | undefined =
      workStore?.incrementalCache || (globalThis as any).__incrementalCache

    if (!maybeIncrementalCache) {
      throw new Error(
        `Invariant: incrementalCache missing in unstable_cache ${cb.toString()}`
      )
    }
    const incrementalCache = maybeIncrementalCache

    const cacheSignal = workUnitStore ? getCacheSignal(workUnitStore) : null
    if (cacheSignal) {
      cacheSignal.beginRead()
    }
    try {
      // If there's no request store, we aren't in a request (or we're not in
      // app router) and if there's no static generation store, we aren't in app
      // router. Default to an empty pathname and search params when there's no
      // request store or static generation store available.
      const fetchUrlPrefix =
        workStore && workUnitStore
          ? getFetchUrlPrefix(workStore, workUnitStore)
          : ''

      // Construct the complete cache key for this function invocation
      // @TODO stringify is likely not safe here. We will coerce undefined to null which will make
      // the keyspace smaller than the execution space
      const invocationKey = `${fixedKey}-${JSON.stringify(args)}`
      const cacheKey = await incrementalCache.generateCacheKey(invocationKey)
      // $urlWithPath,$sortedQueryStringKeys,$hashOfEveryThingElse
      const fetchUrl = `unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`
      const fetchIdx =
        (workStore ? workStore.nextFetchId : noStoreFetchIdx) ?? 1

      const implicitTags = workUnitStore?.implicitTags

      const innerCacheStore: UnstableCacheStore = {
        type: 'unstable-cache',
        phase: 'render',
        implicitTags,
        draftMode:
          workUnitStore &&
          workStore &&
          getDraftModeProviderForCacheScope(workStore, workUnitStore),
      }

      if (workStore) {
        workStore.nextFetchId = fetchIdx + 1

        // We are in an App Router context. We try to return the cached entry if it exists and is valid
        // If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
        // the background. If the entry is missing or invalid we generate a new entry and return it.

        let isNestedUnstableCache = false

        if (workUnitStore) {
          switch (workUnitStore.type) {
            case 'cache':
            case 'private-cache':
            case 'prerender':
            case 'prerender-ppr':
            case 'prerender-legacy':
              // We update the store's revalidate property if the option.revalidate is a higher precedence
              // options.revalidate === undefined doesn't affect timing.
              // options.revalidate === false doesn't shrink timing. it stays at the maximum.
              if (typeof options.revalidate === 'number') {
                if (workUnitStore.revalidate < options.revalidate) {
                  // The store is already revalidating on a shorter time interval, leave it alone
                } else {
                  workUnitStore.revalidate = options.revalidate
                }
              }

              // We need to accumulate the tags for this invocation within the store
              const collectedTags = workUnitStore.tags
              if (collectedTags === null) {
                workUnitStore.tags = tags.slice()
              } else {
                for (const tag of tags) {
                  // @TODO refactor tags to be a set to avoid this O(n) lookup
                  if (!collectedTags.includes(tag)) {
                    collectedTags.push(tag)
                  }
                }
              }
              break
            case 'unstable-cache':
              isNestedUnstableCache = true
              break
            case 'prerender-client':
            case 'request':
              break
            default:
              workUnitStore satisfies never
          }
        }

        if (
          // when we are nested inside of other unstable_cache's
          // we should bypass cache similar to fetches
          !isNestedUnstableCache &&
          workStore.fetchCache !== 'force-no-store' &&
          !workStore.isOnDemandRevalidate &&
          !incrementalCache.isOnDemandRevalidate &&
          !workStore.isDraftMode
        ) {
          // We attempt to get the current cache entry from the incremental cache.
          const cacheEntry = await incrementalCache.get(cacheKey, {
            kind: IncrementalCacheKind.FETCH,
            revalidate: options.revalidate,
            tags,
            softTags: implicitTags?.tags,
            fetchIdx,
            fetchUrl,
          })

          if (cacheEntry && cacheEntry.value) {
            // The entry exists and has a value
            if (cacheEntry.value.kind !== CachedRouteKind.FETCH) {
              // The entry is invalid and we need a special warning
              // @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
              // so bugs can be reported
              // @TODO the invocation key can have sensitive data in it. we should not log this entire object
              console.error(
                `Invariant invalid cacheEntry returned for ${invocationKey}`
              )
              // will fall through to generating a new cache entry below
            } else {
              // We have a valid cache entry so we will be returning it. We also check to see if we need
              // to background revalidate it by checking if it is stale.
              const cachedResponse =
                cacheEntry.value.data.body !== undefined
                  ? JSON.parse(cacheEntry.value.data.body)
                  : undefined
              if (cacheEntry.isStale) {
                // In App Router we return the stale result and revalidate in the background
                if (!workStore.pendingRevalidates) {
                  workStore.pendingRevalidates = {}
                }

                // We run the cache function asynchronously and save the result when it completes
                workStore.pendingRevalidates[invocationKey] =
                  workUnitAsyncStorage
                    .run(innerCacheStore, cb, ...args)
                    .then((result) => {
                      return cacheNewResult(
                        result,
                        incrementalCache,
                        cacheKey,
                        tags,
                        options.revalidate,
                        fetchIdx,
                        fetchUrl
                      )
                    })
                    // @TODO This error handling seems wrong. We swallow the error?
                    .catch((err) =>
                      console.error(
                        `revalidating cache with key: ${invocationKey}`,
                        err
                      )
                    )
              }
              // We had a valid cache entry so we return it here
              return cachedResponse
            }
          }
        }

        // If we got this far then we had an invalid cache entry and need to generate a new one
        const result = await workUnitAsyncStorage.run(
          innerCacheStore,
          cb,
          ...args
        )

        if (!workStore.isDraftMode) {
          if (!workStore.pendingRevalidates) {
            workStore.pendingRevalidates = {}
          }

          // We need to push the cache result promise to pending
          // revalidates otherwise it won't be awaited and is just
          // dangling
          workStore.pendingRevalidates[invocationKey] = cacheNewResult(
            result,
            incrementalCache,
            cacheKey,
            tags,
            options.revalidate,
            fetchIdx,
            fetchUrl
          )
        }

        return result
      } else {
        noStoreFetchIdx += 1
        // We are in Pages Router or were called outside of a render. We don't have a store
        // so we just call the callback directly when it needs to run.
        // If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
        // the background. If the entry is missing or invalid we generate a new entry and return it.

        if (!incrementalCache.isOnDemandRevalidate) {
          // We aren't doing an on demand revalidation so we check use the cache if valid
          const cacheEntry = await incrementalCache.get(cacheKey, {
            kind: IncrementalCacheKind.FETCH,
            revalidate: options.revalidate,
            tags,
            fetchIdx,
            fetchUrl,
            softTags: implicitTags?.tags,
          })

          if (cacheEntry && cacheEntry.value) {
            // The entry exists and has a value
            if (cacheEntry.value.kind !== CachedRouteKind.FETCH) {
              // The entry is invalid and we need a special warning
              // @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
              // so bugs can be reported
              console.error(
                `Invariant invalid cacheEntry returned for ${invocationKey}`
              )
              // will fall through to generating a new cache entry below
            } else if (!cacheEntry.isStale) {
              // We have a valid cache entry and it is fresh so we return it
              return cacheEntry.value.data.body !== undefined
                ? JSON.parse(cacheEntry.value.data.body)
                : undefined
            }
          }
        }

        // If we got this far then we had an invalid cache entry and need to generate a new one
        const result = await workUnitAsyncStorage.run(
          innerCacheStore,
          cb,
          ...args
        )

        // we need to wait setting the new cache result here as
        // we don't have pending revalidates on workStore to
        // push to and we can't have a dangling promise
        await cacheNewResult(
          result,
          incrementalCache,
          cacheKey,
          tags,
          options.revalidate,
          fetchIdx,
          fetchUrl
        )
        return result
      }
    } finally {
      if (cacheSignal) {
        cacheSignal.endRead()
      }
    }
  }
  // TODO: once AsyncLocalStorage.run() returns the correct types this override will no longer be necessary
  return cachedCb as unknown as T
}

function getFetchUrlPrefix(
  workStore: WorkStore,
  workUnitStore: WorkUnitStore
): string {
  switch (workUnitStore.type) {
    case 'request':
      const pathname = workUnitStore.url.pathname
      const searchParams = new URLSearchParams(workUnitStore.url.search)

      const sortedSearch = [...searchParams.keys()]
        .sort((a, b) => a.localeCompare(b))
        .map((key) => `${key}=${searchParams.get(key)}`)
        .join('&')

      return `${pathname}${sortedSearch.length ? '?' : ''}${sortedSearch}`
    case 'prerender':
    case 'prerender-client':
    case 'prerender-ppr':
    case 'prerender-legacy':
    case 'cache':
    case 'private-cache':
    case 'unstable-cache':
      return workStore.route
    default:
      return workUnitStore satisfies never
  }
}

	import type { IncrementalCache } from '../../lib/incremental-cache'

	import { CACHE_ONE_YEAR } from '../../../lib/constants'
	import { validateRevalidate, validateTags } from '../../lib/patch-fetch'
	import {
	workAsyncStorage,
	type WorkStore,
	} from '../../app-render/work-async-storage.external'
	import {
	getCacheSignal,
	getDraftModeProviderForCacheScope,
	workUnitAsyncStorage,
	} from '../../app-render/work-unit-async-storage.external'
	import {
	CachedRouteKind,
	IncrementalCacheKind,
	type CachedFetchData,
	} from '../../response-cache'
	import type {
	UnstableCacheStore,
	WorkUnitStore,
	} from '../../app-render/work-unit-async-storage.external'

	type Callback = (...args: any[]) => Promise<any>

	let noStoreFetchIdx = 0

	async function cacheNewResult<T>(
	result: T,
	incrementalCache: IncrementalCache,
	cacheKey: string,
	tags: string[],
	revalidate: number \| false \| undefined,
	fetchIdx: number,
	fetchUrl: string
	): Promise<unknown> {
	await incrementalCache.set(
	cacheKey,
	{
	kind: CachedRouteKind.FETCH,
	data: {
	headers: {},
	// TODO: handle non-JSON values?
	body: JSON.stringify(result),
	status: 200,
	url: '',
	} satisfies CachedFetchData,
	revalidate: typeof revalidate !== 'number' ? CACHE_ONE_YEAR : revalidate,
	},
	{ fetchCache: true, tags, fetchIdx, fetchUrl }
	)
	return
	}

	/**
	* This function allows you to cache the results of expensive operations, like database queries, and reuse them across multiple requests.
	*
	* Read more: [Next.js Docs: `unstable_cache`](https://nextjs.org/docs/app/api-reference/functions/unstable_cache)
	*/
	export function unstable_cache<T extends Callback>(
	cb: T,
	keyParts?: string[],
	options: {
	/**
	* The revalidation interval in seconds.
	*/
	revalidate?: number \| false
	tags?: string[]
	} = {}
	): T {
	if (options.revalidate === 0) {
	throw new Error(
	`Invariant revalidate: 0 can not be passed to unstable_cache(), must be "false" or "> 0" ${cb.toString()}`
	)
	}

	// Validate the tags provided are valid
	const tags = options.tags
	? validateTags(options.tags, `unstable_cache ${cb.toString()}`)
	: []

	// Validate the revalidate options
	validateRevalidate(
	options.revalidate,
	`unstable_cache ${cb.name \|\| cb.toString()}`
	)

	// Stash the fixed part of the key at construction time. The invocation key will combine
	// the fixed key with the arguments when actually called
	// @TODO if cb.toString() is long we should hash it
	// @TODO come up with a collision-free way to combine keyParts
	// @TODO consider validating the keyParts are all strings. TS can't provide runtime guarantees
	// and the error produced by accidentally using something that cannot be safely coerced is likely
	// hard to debug
	const fixedKey = `${cb.toString()}-${
	Array.isArray(keyParts) && keyParts.join(',')
	}`

	const cachedCb = async (...args: any[]) => {
	const workStore = workAsyncStorage.getStore()
	const workUnitStore = workUnitAsyncStorage.getStore()

	// We must be able to find the incremental cache otherwise we throw
	const maybeIncrementalCache:
	\| import('../../lib/incremental-cache').IncrementalCache
	\| undefined =
	workStore?.incrementalCache \|\| (globalThis as any).__incrementalCache

	if (!maybeIncrementalCache) {
	throw new Error(
	`Invariant: incrementalCache missing in unstable_cache ${cb.toString()}`
	)
	}
	const incrementalCache = maybeIncrementalCache

	const cacheSignal = workUnitStore ? getCacheSignal(workUnitStore) : null
	if (cacheSignal) {
	cacheSignal.beginRead()
	}
	try {
	// If there's no request store, we aren't in a request (or we're not in
	// app router) and if there's no static generation store, we aren't in app
	// router. Default to an empty pathname and search params when there's no
	// request store or static generation store available.
	const fetchUrlPrefix =
	workStore && workUnitStore
	? getFetchUrlPrefix(workStore, workUnitStore)
	: ''

	// Construct the complete cache key for this function invocation
	// @TODO stringify is likely not safe here. We will coerce undefined to null which will make
	// the keyspace smaller than the execution space
	const invocationKey = `${fixedKey}-${JSON.stringify(args)}`
	const cacheKey = await incrementalCache.generateCacheKey(invocationKey)
	// $urlWithPath,$sortedQueryStringKeys,$hashOfEveryThingElse
	const fetchUrl = `unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`
	const fetchIdx =
	(workStore ? workStore.nextFetchId : noStoreFetchIdx) ?? 1

	const implicitTags = workUnitStore?.implicitTags

	const innerCacheStore: UnstableCacheStore = {
	type: 'unstable-cache',
	phase: 'render',
	implicitTags,
	draftMode:
	workUnitStore &&
	workStore &&
	getDraftModeProviderForCacheScope(workStore, workUnitStore),
	}

	if (workStore) {
	workStore.nextFetchId = fetchIdx + 1

	// We are in an App Router context. We try to return the cached entry if it exists and is valid
	// If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
	// the background. If the entry is missing or invalid we generate a new entry and return it.

	let isNestedUnstableCache = false

	if (workUnitStore) {
	switch (workUnitStore.type) {
	case 'cache':
	case 'private-cache':
	case 'prerender':
	case 'prerender-ppr':
	case 'prerender-legacy':
	// We update the store's revalidate property if the option.revalidate is a higher precedence
	// options.revalidate === undefined doesn't affect timing.
	// options.revalidate === false doesn't shrink timing. it stays at the maximum.
	if (typeof options.revalidate === 'number') {
	if (workUnitStore.revalidate < options.revalidate) {
	// The store is already revalidating on a shorter time interval, leave it alone
	} else {
	workUnitStore.revalidate = options.revalidate
	}
	}

	// We need to accumulate the tags for this invocation within the store
	const collectedTags = workUnitStore.tags
	if (collectedTags === null) {
	workUnitStore.tags = tags.slice()
	} else {
	for (const tag of tags) {
	// @TODO refactor tags to be a set to avoid this O(n) lookup
	if (!collectedTags.includes(tag)) {
	collectedTags.push(tag)
	}
	}
	}
	break
	case 'unstable-cache':
	isNestedUnstableCache = true
	break
	case 'prerender-client':
	case 'request':
	break
	default:
	workUnitStore satisfies never
	}
	}

	if (
	// when we are nested inside of other unstable_cache's
	// we should bypass cache similar to fetches
	!isNestedUnstableCache &&
	workStore.fetchCache !== 'force-no-store' &&
	!workStore.isOnDemandRevalidate &&
	!incrementalCache.isOnDemandRevalidate &&
	!workStore.isDraftMode
	) {
	// We attempt to get the current cache entry from the incremental cache.
	const cacheEntry = await incrementalCache.get(cacheKey, {
	kind: IncrementalCacheKind.FETCH,
	revalidate: options.revalidate,
	tags,
	softTags: implicitTags?.tags,
	fetchIdx,
	fetchUrl,
	})

	if (cacheEntry && cacheEntry.value) {
	// The entry exists and has a value
	if (cacheEntry.value.kind !== CachedRouteKind.FETCH) {
	// The entry is invalid and we need a special warning
	// @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
	// so bugs can be reported
	// @TODO the invocation key can have sensitive data in it. we should not log this entire object
	console.error(
	`Invariant invalid cacheEntry returned for ${invocationKey}`
	)
	// will fall through to generating a new cache entry below
	} else {
	// We have a valid cache entry so we will be returning it. We also check to see if we need
	// to background revalidate it by checking if it is stale.
	const cachedResponse =
	cacheEntry.value.data.body !== undefined
	? JSON.parse(cacheEntry.value.data.body)
	: undefined
	if (cacheEntry.isStale) {
	// In App Router we return the stale result and revalidate in the background
	if (!workStore.pendingRevalidates) {
	workStore.pendingRevalidates = {}
	}

	// We run the cache function asynchronously and save the result when it completes
	workStore.pendingRevalidates[invocationKey] =
	workUnitAsyncStorage
	.run(innerCacheStore, cb, ...args)
	.then((result) => {
	return cacheNewResult(
	result,
	incrementalCache,
	cacheKey,
	tags,
	options.revalidate,
	fetchIdx,
	fetchUrl
	)
	})
	// @TODO This error handling seems wrong. We swallow the error?
	.catch((err) =>
	console.error(
	`revalidating cache with key: ${invocationKey}`,
	err
	)
	)
	}
	// We had a valid cache entry so we return it here
	return cachedResponse
	}
	}
	}

	// If we got this far then we had an invalid cache entry and need to generate a new one
	const result = await workUnitAsyncStorage.run(
	innerCacheStore,
	cb,
	...args
	)

	if (!workStore.isDraftMode) {
	if (!workStore.pendingRevalidates) {
	workStore.pendingRevalidates = {}
	}

	// We need to push the cache result promise to pending
	// revalidates otherwise it won't be awaited and is just
	// dangling
	workStore.pendingRevalidates[invocationKey] = cacheNewResult(
	result,
	incrementalCache,
	cacheKey,
	tags,
	options.revalidate,
	fetchIdx,
	fetchUrl
	)
	}

	return result
	} else {
	noStoreFetchIdx += 1
	// We are in Pages Router or were called outside of a render. We don't have a store
	// so we just call the callback directly when it needs to run.
	// If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
	// the background. If the entry is missing or invalid we generate a new entry and return it.

	if (!incrementalCache.isOnDemandRevalidate) {
	// We aren't doing an on demand revalidation so we check use the cache if valid
	const cacheEntry = await incrementalCache.get(cacheKey, {
	kind: IncrementalCacheKind.FETCH,
	revalidate: options.revalidate,
	tags,
	fetchIdx,
	fetchUrl,
	softTags: implicitTags?.tags,
	})

	if (cacheEntry && cacheEntry.value) {
	// The entry exists and has a value
	if (cacheEntry.value.kind !== CachedRouteKind.FETCH) {
	// The entry is invalid and we need a special warning
	// @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
	// so bugs can be reported
	console.error(
	`Invariant invalid cacheEntry returned for ${invocationKey}`
	)
	// will fall through to generating a new cache entry below
	} else if (!cacheEntry.isStale) {
	// We have a valid cache entry and it is fresh so we return it
	return cacheEntry.value.data.body !== undefined
	? JSON.parse(cacheEntry.value.data.body)
	: undefined
	}
	}
	}

	// If we got this far then we had an invalid cache entry and need to generate a new one
	const result = await workUnitAsyncStorage.run(
	innerCacheStore,
	cb,
	...args
	)

	// we need to wait setting the new cache result here as
	// we don't have pending revalidates on workStore to
	// push to and we can't have a dangling promise
	await cacheNewResult(
	result,
	incrementalCache,
	cacheKey,
	tags,
	options.revalidate,
	fetchIdx,
	fetchUrl
	)
	return result
	}
	} finally {
	if (cacheSignal) {
	cacheSignal.endRead()
	}
	}
	}
	// TODO: once AsyncLocalStorage.run() returns the correct types this override will no longer be necessary
	return cachedCb as unknown as T
	}

	function getFetchUrlPrefix(
	workStore: WorkStore,
	workUnitStore: WorkUnitStore
	): string {
	switch (workUnitStore.type) {
	case 'request':
	const pathname = workUnitStore.url.pathname
	const searchParams = new URLSearchParams(workUnitStore.url.search)

	const sortedSearch = [...searchParams.keys()]
	.sort((a, b) => a.localeCompare(b))
	.map((key) => `${key}=${searchParams.get(key)}`)
	.join('&')

	return `${pathname}${sortedSearch.length ? '?' : ''}${sortedSearch}`
	case 'prerender':
	case 'prerender-client':
	case 'prerender-ppr':
	case 'prerender-legacy':
	case 'cache':
	case 'private-cache':
	case 'unstable-cache':
	return workStore.route
	default:
	return workUnitStore satisfies never
	}
	}