Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

6.81 kB

import type { ActionManifest } from '../../build/webpack/plugins/flight-client-entry-plugin'
import type {
  ClientReferenceManifest,
  ClientReferenceManifestForRsc,
} from '../../build/webpack/plugins/flight-manifest-plugin'
import type { DeepReadonly } from '../../shared/lib/deep-readonly'
import { InvariantError } from '../../shared/lib/invariant-error'
import { normalizeAppPath } from '../../shared/lib/router/utils/app-paths'
import { workAsyncStorage } from './work-async-storage.external'

let __next_loaded_action_key: CryptoKey

export function arrayBufferToString(
  buffer: ArrayBuffer | Uint8Array<ArrayBufferLike>
) {
  const bytes = new Uint8Array(buffer)
  const len = bytes.byteLength

  // @anonrig: V8 has a limit of 65535 arguments in a function.
  // For len < 65535, this is faster.
  // https://github.com/vercel/next.js/pull/56377#pullrequestreview-1656181623
  if (len < 65535) {
    return String.fromCharCode.apply(null, bytes as unknown as number[])
  }

  let binary = ''
  for (let i = 0; i < len; i++) {
    binary += String.fromCharCode(bytes[i])
  }
  return binary
}

export function stringToUint8Array(binary: string) {
  const len = binary.length
  const arr = new Uint8Array(len)

  for (let i = 0; i < len; i++) {
    arr[i] = binary.charCodeAt(i)
  }

  return arr
}

export function encrypt(key: CryptoKey, iv: Uint8Array, data: Uint8Array) {
  return crypto.subtle.encrypt(
    {
      name: 'AES-GCM',
      iv,
    },
    key,
    data
  )
}

export function decrypt(key: CryptoKey, iv: Uint8Array, data: Uint8Array) {
  return crypto.subtle.decrypt(
    {
      name: 'AES-GCM',
      iv,
    },
    key,
    data
  )
}

// This is a global singleton that is used to encode/decode the action bound args from
// the closure. This can't be using a AsyncLocalStorage as it might happen on the module
// level. Since the client reference manifest won't be mutated, let's use a global singleton
// to keep it.
const SERVER_ACTION_MANIFESTS_SINGLETON = Symbol.for(
  'next.server.action-manifests'
)

export function setReferenceManifestsSingleton({
  page,
  clientReferenceManifest,
  serverActionsManifest,
  serverModuleMap,
}: {
  page: string
  clientReferenceManifest: DeepReadonly<ClientReferenceManifest>
  serverActionsManifest: DeepReadonly<ActionManifest>
  serverModuleMap: {
    [id: string]: {
      id: string
      chunks: string[]
      name: string
    }
  }
}) {
  // @ts-expect-error
  const clientReferenceManifestsPerPage = globalThis[
    SERVER_ACTION_MANIFESTS_SINGLETON
  ]?.clientReferenceManifestsPerPage as
    | undefined
    | DeepReadonly<Record<string, ClientReferenceManifest>>

  // @ts-expect-error
  globalThis[SERVER_ACTION_MANIFESTS_SINGLETON] = {
    clientReferenceManifestsPerPage: {
      ...clientReferenceManifestsPerPage,
      [normalizeAppPath(page)]: clientReferenceManifest,
    },
    serverActionsManifest,
    serverModuleMap,
  }
}

export function getServerModuleMap() {
  const serverActionsManifestSingleton = (globalThis as any)[
    SERVER_ACTION_MANIFESTS_SINGLETON
  ] as {
    serverModuleMap: {
      [id: string]: {
        id: string
        chunks: string[]
        name: string
      }
    }
  }

  if (!serverActionsManifestSingleton) {
    throw new InvariantError('Missing manifest for Server Actions.')
  }

  return serverActionsManifestSingleton.serverModuleMap
}

export function getClientReferenceManifestForRsc(): DeepReadonly<ClientReferenceManifestForRsc> {
  const serverActionsManifestSingleton = (globalThis as any)[
    SERVER_ACTION_MANIFESTS_SINGLETON
  ] as {
    clientReferenceManifestsPerPage: DeepReadonly<
      Record<string, ClientReferenceManifest>
    >
  }

  if (!serverActionsManifestSingleton) {
    throw new InvariantError('Missing manifest for Server Actions.')
  }

  const { clientReferenceManifestsPerPage } = serverActionsManifestSingleton
  const workStore = workAsyncStorage.getStore()

  if (!workStore) {
    // If there's no work store defined, we can assume that a client reference
    // manifest is needed during module evaluation, e.g. to create a server
    // action using a higher-order function. This might also use client
    // components which need to be serialized by Flight, and therefore client
    // references need to be resolvable. To make this work, we're returning a
    // merged manifest across all pages. This is fine as long as the module IDs
    // are not page specific, which they are not for Webpack. TODO: Fix this in
    // Turbopack.
    return mergeClientReferenceManifests(clientReferenceManifestsPerPage)
  }

  const clientReferenceManifest =
    clientReferenceManifestsPerPage[workStore.route]

  if (!clientReferenceManifest) {
    throw new InvariantError(
      `Missing Client Reference Manifest for ${workStore.route}.`
    )
  }

  return clientReferenceManifest
}

export async function getActionEncryptionKey() {
  if (__next_loaded_action_key) {
    return __next_loaded_action_key
  }

  const serverActionsManifestSingleton = (globalThis as any)[
    SERVER_ACTION_MANIFESTS_SINGLETON
  ] as {
    serverActionsManifest: DeepReadonly<ActionManifest>
  }

  if (!serverActionsManifestSingleton) {
    throw new InvariantError('Missing manifest for Server Actions.')
  }

  const rawKey =
    process.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY ||
    serverActionsManifestSingleton.serverActionsManifest.encryptionKey

  if (rawKey === undefined) {
    throw new InvariantError('Missing encryption key for Server Actions')
  }

  __next_loaded_action_key = await crypto.subtle.importKey(
    'raw',
    stringToUint8Array(atob(rawKey)),
    'AES-GCM',
    true,
    ['encrypt', 'decrypt']
  )

  return __next_loaded_action_key
}

function mergeClientReferenceManifests(
  clientReferenceManifestsPerPage: DeepReadonly<
    Record<string, ClientReferenceManifest>
  >
): ClientReferenceManifestForRsc {
  const clientReferenceManifests = Object.values(
    clientReferenceManifestsPerPage as Record<string, ClientReferenceManifest>
  )

  const mergedClientReferenceManifest: ClientReferenceManifestForRsc = {
    clientModules: {},
    edgeRscModuleMapping: {},
    rscModuleMapping: {},
  }

  for (const clientReferenceManifest of clientReferenceManifests) {
    mergedClientReferenceManifest.clientModules = {
      ...mergedClientReferenceManifest.clientModules,
      ...clientReferenceManifest.clientModules,
    }
    mergedClientReferenceManifest.edgeRscModuleMapping = {
      ...mergedClientReferenceManifest.edgeRscModuleMapping,
      ...clientReferenceManifest.edgeRscModuleMapping,
    }
    mergedClientReferenceManifest.rscModuleMapping = {
      ...mergedClientReferenceManifest.rscModuleMapping,
      ...clientReferenceManifest.rscModuleMapping,
    }
  }

  return mergedClientReferenceManifest
}

	import type { ActionManifest } from '../../build/webpack/plugins/flight-client-entry-plugin'
	import type {
	ClientReferenceManifest,
	ClientReferenceManifestForRsc,
	} from '../../build/webpack/plugins/flight-manifest-plugin'
	import type { DeepReadonly } from '../../shared/lib/deep-readonly'
	import { InvariantError } from '../../shared/lib/invariant-error'
	import { normalizeAppPath } from '../../shared/lib/router/utils/app-paths'
	import { workAsyncStorage } from './work-async-storage.external'

	let __next_loaded_action_key: CryptoKey

	export function arrayBufferToString(
	buffer: ArrayBuffer \| Uint8Array<ArrayBufferLike>
	) {
	const bytes = new Uint8Array(buffer)
	const len = bytes.byteLength

	// @anonrig: V8 has a limit of 65535 arguments in a function.
	// For len < 65535, this is faster.
	// https://github.com/vercel/next.js/pull/56377#pullrequestreview-1656181623
	if (len < 65535) {
	return String.fromCharCode.apply(null, bytes as unknown as number[])
	}

	let binary = ''
	for (let i = 0; i < len; i++) {
	binary += String.fromCharCode(bytes[i])
	}
	return binary
	}

	export function stringToUint8Array(binary: string) {
	const len = binary.length
	const arr = new Uint8Array(len)

	for (let i = 0; i < len; i++) {
	arr[i] = binary.charCodeAt(i)
	}

	return arr
	}

	export function encrypt(key: CryptoKey, iv: Uint8Array, data: Uint8Array) {
	return crypto.subtle.encrypt(
	{
	name: 'AES-GCM',
	iv,
	},
	key,
	data
	)
	}

	export function decrypt(key: CryptoKey, iv: Uint8Array, data: Uint8Array) {
	return crypto.subtle.decrypt(
	{
	name: 'AES-GCM',
	iv,
	},
	key,
	data
	)
	}

	// This is a global singleton that is used to encode/decode the action bound args from
	// the closure. This can't be using a AsyncLocalStorage as it might happen on the module
	// level. Since the client reference manifest won't be mutated, let's use a global singleton
	// to keep it.
	const SERVER_ACTION_MANIFESTS_SINGLETON = Symbol.for(
	'next.server.action-manifests'
	)

	export function setReferenceManifestsSingleton({
	page,
	clientReferenceManifest,
	serverActionsManifest,
	serverModuleMap,
	}: {
	page: string
	clientReferenceManifest: DeepReadonly<ClientReferenceManifest>
	serverActionsManifest: DeepReadonly<ActionManifest>
	serverModuleMap: {
	[id: string]: {
	id: string
	chunks: string[]
	name: string
	}
	}
	}) {
	// @ts-expect-error
	const clientReferenceManifestsPerPage = globalThis[
	SERVER_ACTION_MANIFESTS_SINGLETON
	]?.clientReferenceManifestsPerPage as
	\| undefined
	\| DeepReadonly<Record<string, ClientReferenceManifest>>

	// @ts-expect-error
	globalThis[SERVER_ACTION_MANIFESTS_SINGLETON] = {
	clientReferenceManifestsPerPage: {
	...clientReferenceManifestsPerPage,
	[normalizeAppPath(page)]: clientReferenceManifest,
	},
	serverActionsManifest,
	serverModuleMap,
	}
	}

	export function getServerModuleMap() {
	const serverActionsManifestSingleton = (globalThis as any)[
	SERVER_ACTION_MANIFESTS_SINGLETON
	] as {
	serverModuleMap: {
	[id: string]: {
	id: string
	chunks: string[]
	name: string
	}
	}
	}

	if (!serverActionsManifestSingleton) {
	throw new InvariantError('Missing manifest for Server Actions.')
	}

	return serverActionsManifestSingleton.serverModuleMap
	}

	export function getClientReferenceManifestForRsc(): DeepReadonly<ClientReferenceManifestForRsc> {
	const serverActionsManifestSingleton = (globalThis as any)[
	SERVER_ACTION_MANIFESTS_SINGLETON
	] as {
	clientReferenceManifestsPerPage: DeepReadonly<
	Record<string, ClientReferenceManifest>
	>
	}

	if (!serverActionsManifestSingleton) {
	throw new InvariantError('Missing manifest for Server Actions.')
	}

	const { clientReferenceManifestsPerPage } = serverActionsManifestSingleton
	const workStore = workAsyncStorage.getStore()

	if (!workStore) {
	// If there's no work store defined, we can assume that a client reference
	// manifest is needed during module evaluation, e.g. to create a server
	// action using a higher-order function. This might also use client
	// components which need to be serialized by Flight, and therefore client
	// references need to be resolvable. To make this work, we're returning a
	// merged manifest across all pages. This is fine as long as the module IDs
	// are not page specific, which they are not for Webpack. TODO: Fix this in
	// Turbopack.
	return mergeClientReferenceManifests(clientReferenceManifestsPerPage)
	}

	const clientReferenceManifest =
	clientReferenceManifestsPerPage[workStore.route]

	if (!clientReferenceManifest) {
	throw new InvariantError(
	`Missing Client Reference Manifest for ${workStore.route}.`
	)
	}

	return clientReferenceManifest
	}

	export async function getActionEncryptionKey() {
	if (__next_loaded_action_key) {
	return __next_loaded_action_key
	}

	const serverActionsManifestSingleton = (globalThis as any)[
	SERVER_ACTION_MANIFESTS_SINGLETON
	] as {
	serverActionsManifest: DeepReadonly<ActionManifest>
	}

	if (!serverActionsManifestSingleton) {
	throw new InvariantError('Missing manifest for Server Actions.')
	}

	const rawKey =
	process.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY \|\|
	serverActionsManifestSingleton.serverActionsManifest.encryptionKey

	if (rawKey === undefined) {
	throw new InvariantError('Missing encryption key for Server Actions')
	}

	__next_loaded_action_key = await crypto.subtle.importKey(
	'raw',
	stringToUint8Array(atob(rawKey)),
	'AES-GCM',
	true,
	['encrypt', 'decrypt']
	)

	return __next_loaded_action_key
	}

	function mergeClientReferenceManifests(
	clientReferenceManifestsPerPage: DeepReadonly<
	Record<string, ClientReferenceManifest>
	>
	): ClientReferenceManifestForRsc {
	const clientReferenceManifests = Object.values(
	clientReferenceManifestsPerPage as Record<string, ClientReferenceManifest>
	)

	const mergedClientReferenceManifest: ClientReferenceManifestForRsc = {
	clientModules: {},
	edgeRscModuleMapping: {},
	rscModuleMapping: {},
	}

	for (const clientReferenceManifest of clientReferenceManifests) {
	mergedClientReferenceManifest.clientModules = {
	...mergedClientReferenceManifest.clientModules,
	...clientReferenceManifest.clientModules,
	}
	mergedClientReferenceManifest.edgeRscModuleMapping = {
	...mergedClientReferenceManifest.edgeRscModuleMapping,
	...clientReferenceManifest.edgeRscModuleMapping,
	}
	mergedClientReferenceManifest.rscModuleMapping = {
	...mergedClientReferenceManifest.rscModuleMapping,
	...clientReferenceManifest.rscModuleMapping,
	}
	}

	return mergedClientReferenceManifest
	}