Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

9.82 kB

use anyhow::Result;
use serde_json::Value as JsonValue;
use turbo_rcstr::{RcStr, rcstr};
use turbo_tasks::{FxIndexSet, OperationVc, ResolvedVc, Vc};
use turbo_tasks_env::ProcessEnv;
use turbo_tasks_fs::FileSystemPath;
use turbopack_core::{
    introspect::{
        Introspectable, IntrospectableChildren, module::IntrospectableModule,
        output_asset::IntrospectableOutputAsset,
    },
    issue::IssueDescriptionExt,
    module::Module,
    output::OutputAsset,
    version::VersionedContentExt,
};
use turbopack_dev_server::{
    html::DevHtmlAsset,
    source::{
        ContentSource, ContentSourceContent, ContentSourceData, ContentSourceDataVary,
        GetContentSourceContent, ProxyResult,
        asset_graph::AssetGraphContentSource,
        conditional::ConditionalContentSource,
        lazy_instantiated::{GetContentSource, LazyInstantiatedContentSource},
        route_tree::{BaseSegment, RouteTree, RouteType},
    },
};

use super::{
    RenderData,
    render_static::{StaticResult, render_static_operation},
};
use crate::{
    external_asset_entrypoints, get_intermediate_asset, node_entry::NodeEntry,
    route_matcher::RouteMatcher,
};

/// Creates a content source that renders something in Node.js with the passed
/// `entry` when it matches a `path_regex`. Once rendered it serves
/// all assets referenced by the `entry` that are within the `server_root`.
/// It needs a temporary directory (`intermediate_output_path`) to place file
/// for Node.js execution during rendering. The `chunking_context` should emit
/// to this directory.
#[turbo_tasks::function]
pub fn create_node_rendered_source(
    cwd: FileSystemPath,
    env: ResolvedVc<Box<dyn ProcessEnv>>,
    base_segments: Vec<BaseSegment>,
    route_type: RouteType,
    server_root: FileSystemPath,
    route_match: ResolvedVc<Box<dyn RouteMatcher>>,
    pathname: ResolvedVc<RcStr>,
    entry: ResolvedVc<Box<dyn NodeEntry>>,
    fallback_page: ResolvedVc<DevHtmlAsset>,
    render_data: ResolvedVc<JsonValue>,
    debug: bool,
) -> Vc<Box<dyn ContentSource>> {
    let source = NodeRenderContentSource {
        cwd,
        env,
        base_segments,
        route_type,
        server_root,
        route_match,
        pathname,
        entry,
        fallback_page,
        render_data,
        debug,
    }
    .resolved_cell();
    Vc::upcast(ConditionalContentSource::new(
        Vc::upcast(*source),
        Vc::upcast(
            LazyInstantiatedContentSource {
                get_source: ResolvedVc::upcast(source),
            }
            .cell(),
        ),
    ))
}

/// see [create_node_rendered_source]
#[turbo_tasks::value]
pub struct NodeRenderContentSource {
    cwd: FileSystemPath,
    env: ResolvedVc<Box<dyn ProcessEnv>>,
    base_segments: Vec<BaseSegment>,
    route_type: RouteType,
    server_root: FileSystemPath,
    route_match: ResolvedVc<Box<dyn RouteMatcher>>,
    pathname: ResolvedVc<RcStr>,
    entry: ResolvedVc<Box<dyn NodeEntry>>,
    fallback_page: ResolvedVc<DevHtmlAsset>,
    render_data: ResolvedVc<JsonValue>,
    debug: bool,
}

#[turbo_tasks::value_impl]
impl NodeRenderContentSource {
    #[turbo_tasks::function]
    pub fn get_pathname(&self) -> Vc<RcStr> {
        *self.pathname
    }
}

#[turbo_tasks::value_impl]
impl GetContentSource for NodeRenderContentSource {
    /// Returns the [ContentSource] that serves all referenced external
    /// assets. This is wrapped into [LazyInstantiatedContentSource].
    #[turbo_tasks::function]
    async fn content_source(&self) -> Result<Vc<Box<dyn ContentSource>>> {
        let entries = self.entry.entries();
        let mut set = FxIndexSet::default();
        for &reference in self.fallback_page.references().await?.iter() {
            set.insert(reference);
        }
        for &entry in entries.await?.iter() {
            let entry = entry.await?;
            set.extend(
                external_asset_entrypoints(
                    *entry.module,
                    *entry.runtime_entries,
                    *entry.chunking_context,
                    entry.intermediate_output_path.clone(),
                )
                .await?
                .iter()
                .copied(),
            )
        }
        Ok(Vc::upcast(AssetGraphContentSource::new_lazy_multiple(
            self.server_root.clone(),
            Vc::cell(set),
        )))
    }
}

#[turbo_tasks::value_impl]
impl ContentSource for NodeRenderContentSource {
    #[turbo_tasks::function]
    async fn get_routes(self: Vc<Self>) -> Result<Vc<RouteTree>> {
        let this = self.await?;
        Ok(RouteTree::new_route(
            this.base_segments.clone(),
            this.route_type.clone(),
            Vc::upcast(self),
        ))
    }
}

#[turbo_tasks::value_impl]
impl GetContentSourceContent for NodeRenderContentSource {
    #[turbo_tasks::function]
    fn vary(&self) -> Vc<ContentSourceDataVary> {
        ContentSourceDataVary {
            method: true,
            url: true,
            original_url: true,
            raw_headers: true,
            raw_query: true,
            ..Default::default()
        }
        .cell()
    }

    #[turbo_tasks::function]
    async fn get(&self, path: RcStr, data: ContentSourceData) -> Result<Vc<ContentSourceContent>> {
        let pathname = self.pathname.await?;
        let Some(params) = &*self.route_match.params(path.clone()).await? else {
            anyhow::bail!("Non matching path ({}) provided for {}", path, pathname)
        };
        let ContentSourceData {
            method: Some(method),
            url: Some(url),
            original_url: Some(original_url),
            raw_headers: Some(raw_headers),
            raw_query: Some(raw_query),
            ..
        } = &data
        else {
            anyhow::bail!("Missing request data")
        };
        let entry = (*self.entry).entry(data.clone()).await?;
        let result_op = render_static_operation(
            self.cwd.clone(),
            self.env,
            self.server_root.join(&path)?,
            ResolvedVc::upcast(entry.module),
            entry.runtime_entries,
            self.fallback_page,
            entry.chunking_context,
            entry.intermediate_output_path.clone(),
            entry.output_root.clone(),
            entry.project_dir.clone(),
            RenderData {
                params: params.clone(),
                method: method.clone(),
                url: url.clone(),
                original_url: original_url.clone(),
                raw_query: raw_query.clone(),
                raw_headers: raw_headers.clone(),
                path: pathname.as_str().into(),
                data: Some(self.render_data.await?),
            }
            .resolved_cell(),
            self.debug,
        )
        .issue_file_path(
            entry.module.ident().path().owned().await?,
            format!("server-side rendering {pathname}"),
        )
        .await?;
        Ok(match *result_op.connect().await? {
            StaticResult::Content {
                content,
                status_code,
                headers,
            } => ContentSourceContent::static_with_headers(
                content.versioned(),
                status_code,
                *headers,
            ),
            StaticResult::StreamedContent {
                status,
                headers,
                ref body,
            } => {
                ContentSourceContent::HttpProxy(static_streamed_content_to_proxy_result_operation(
                    result_op,
                    ProxyResult {
                        status,
                        headers: headers.owned().await?,
                        body: body.clone(),
                    }
                    .resolved_cell(),
                ))
                .cell()
            }
            StaticResult::Rewrite(rewrite) => ContentSourceContent::Rewrite(rewrite).cell(),
        })
    }
}

#[turbo_tasks::function(operation)]
async fn static_streamed_content_to_proxy_result_operation(
    result_op: OperationVc<StaticResult>,
    proxy_result: ResolvedVc<ProxyResult>,
) -> Result<Vc<ProxyResult>> {
    // we already assume `result_op`'s value here because we're called inside of a match arm, but
    // await `result_op` anyways, so that if it generates any collectible issues, they're captured
    // here.
    let _ = result_op.connect().await?;
    Ok(*proxy_result)
}

#[turbo_tasks::value_impl]
impl Introspectable for NodeRenderContentSource {
    #[turbo_tasks::function]
    fn ty(&self) -> Vc<RcStr> {
        Vc::cell(rcstr!("node render content source"))
    }

    #[turbo_tasks::function]
    fn title(&self) -> Vc<RcStr> {
        *self.pathname
    }

    #[turbo_tasks::function]
    fn details(&self) -> Vc<RcStr> {
        Vc::cell(
            format!(
                "base: {:?}\ntype: {:?}",
                self.base_segments, self.route_type
            )
            .into(),
        )
    }

    #[turbo_tasks::function]
    async fn children(&self) -> Result<Vc<IntrospectableChildren>> {
        let mut set = FxIndexSet::default();
        for &entry in self.entry.entries().await?.iter() {
            let entry = entry.await?;
            set.insert((
                rcstr!("module"),
                IntrospectableModule::new(Vc::upcast(*entry.module))
                    .to_resolved()
                    .await?,
            ));
            set.insert((
                rcstr!("intermediate asset"),
                IntrospectableOutputAsset::new(get_intermediate_asset(
                    *entry.chunking_context,
                    *entry.module,
                    *entry.runtime_entries,
                ))
                .to_resolved()
                .await?,
            ));
        }
        Ok(Vc::cell(set))
    }
}

	use anyhow::Result;
	use serde_json::Value as JsonValue;
	use turbo_rcstr::{RcStr, rcstr};
	use turbo_tasks::{FxIndexSet, OperationVc, ResolvedVc, Vc};
	use turbo_tasks_env::ProcessEnv;
	use turbo_tasks_fs::FileSystemPath;
	use turbopack_core::{
	introspect::{
	Introspectable, IntrospectableChildren, module::IntrospectableModule,
	output_asset::IntrospectableOutputAsset,
	},
	issue::IssueDescriptionExt,
	module::Module,
	output::OutputAsset,
	version::VersionedContentExt,
	};
	use turbopack_dev_server::{
	html::DevHtmlAsset,
	source::{
	ContentSource, ContentSourceContent, ContentSourceData, ContentSourceDataVary,
	GetContentSourceContent, ProxyResult,
	asset_graph::AssetGraphContentSource,
	conditional::ConditionalContentSource,
	lazy_instantiated::{GetContentSource, LazyInstantiatedContentSource},
	route_tree::{BaseSegment, RouteTree, RouteType},
	},
	};

	use super::{
	RenderData,
	render_static::{StaticResult, render_static_operation},
	};
	use crate::{
	external_asset_entrypoints, get_intermediate_asset, node_entry::NodeEntry,
	route_matcher::RouteMatcher,
	};

	/// Creates a content source that renders something in Node.js with the passed
	/// `entry` when it matches a `path_regex`. Once rendered it serves
	/// all assets referenced by the `entry` that are within the `server_root`.
	/// It needs a temporary directory (`intermediate_output_path`) to place file
	/// for Node.js execution during rendering. The `chunking_context` should emit
	/// to this directory.
	#[turbo_tasks::function]
	pub fn create_node_rendered_source(
	cwd: FileSystemPath,
	env: ResolvedVc<Box<dyn ProcessEnv>>,
	base_segments: Vec<BaseSegment>,
	route_type: RouteType,
	server_root: FileSystemPath,
	route_match: ResolvedVc<Box<dyn RouteMatcher>>,
	pathname: ResolvedVc<RcStr>,
	entry: ResolvedVc<Box<dyn NodeEntry>>,
	fallback_page: ResolvedVc<DevHtmlAsset>,
	render_data: ResolvedVc<JsonValue>,
	debug: bool,
	) -> Vc<Box<dyn ContentSource>> {
	let source = NodeRenderContentSource {
	cwd,
	env,
	base_segments,
	route_type,
	server_root,
	route_match,
	pathname,
	entry,
	fallback_page,
	render_data,
	debug,
	}
	.resolved_cell();
	Vc::upcast(ConditionalContentSource::new(
	Vc::upcast(*source),
	Vc::upcast(
	LazyInstantiatedContentSource {
	get_source: ResolvedVc::upcast(source),
	}
	.cell(),
	),
	))
	}

	/// see [create_node_rendered_source]
	#[turbo_tasks::value]
	pub struct NodeRenderContentSource {
	cwd: FileSystemPath,
	env: ResolvedVc<Box<dyn ProcessEnv>>,
	base_segments: Vec<BaseSegment>,
	route_type: RouteType,
	server_root: FileSystemPath,
	route_match: ResolvedVc<Box<dyn RouteMatcher>>,
	pathname: ResolvedVc<RcStr>,
	entry: ResolvedVc<Box<dyn NodeEntry>>,
	fallback_page: ResolvedVc<DevHtmlAsset>,
	render_data: ResolvedVc<JsonValue>,
	debug: bool,
	}

	#[turbo_tasks::value_impl]
	impl NodeRenderContentSource {
	#[turbo_tasks::function]
	pub fn get_pathname(&self) -> Vc<RcStr> {
	*self.pathname
	}
	}

	#[turbo_tasks::value_impl]
	impl GetContentSource for NodeRenderContentSource {
	/// Returns the [ContentSource] that serves all referenced external
	/// assets. This is wrapped into [LazyInstantiatedContentSource].
	#[turbo_tasks::function]
	async fn content_source(&self) -> Result<Vc<Box<dyn ContentSource>>> {
	let entries = self.entry.entries();
	let mut set = FxIndexSet::default();
	for &reference in self.fallback_page.references().await?.iter() {
	set.insert(reference);
	}
	for &entry in entries.await?.iter() {
	let entry = entry.await?;
	set.extend(
	external_asset_entrypoints(
	*entry.module,
	*entry.runtime_entries,
	*entry.chunking_context,
	entry.intermediate_output_path.clone(),
	)
	.await?
	.iter()
	.copied(),
	)
	}
	Ok(Vc::upcast(AssetGraphContentSource::new_lazy_multiple(
	self.server_root.clone(),
	Vc::cell(set),
	)))
	}
	}

	#[turbo_tasks::value_impl]
	impl ContentSource for NodeRenderContentSource {
	#[turbo_tasks::function]
	async fn get_routes(self: Vc<Self>) -> Result<Vc<RouteTree>> {
	let this = self.await?;
	Ok(RouteTree::new_route(
	this.base_segments.clone(),
	this.route_type.clone(),
	Vc::upcast(self),
	))
	}
	}

	#[turbo_tasks::value_impl]
	impl GetContentSourceContent for NodeRenderContentSource {
	#[turbo_tasks::function]
	fn vary(&self) -> Vc<ContentSourceDataVary> {
	ContentSourceDataVary {
	method: true,
	url: true,
	original_url: true,
	raw_headers: true,
	raw_query: true,
	..Default::default()
	}
	.cell()
	}

	#[turbo_tasks::function]
	async fn get(&self, path: RcStr, data: ContentSourceData) -> Result<Vc<ContentSourceContent>> {
	let pathname = self.pathname.await?;
	let Some(params) = &*self.route_match.params(path.clone()).await? else {
	anyhow::bail!("Non matching path ({}) provided for {}", path, pathname)
	};
	let ContentSourceData {
	method: Some(method),
	url: Some(url),
	original_url: Some(original_url),
	raw_headers: Some(raw_headers),
	raw_query: Some(raw_query),
	..
	} = &data
	else {
	anyhow::bail!("Missing request data")
	};
	let entry = (*self.entry).entry(data.clone()).await?;
	let result_op = render_static_operation(
	self.cwd.clone(),
	self.env,
	self.server_root.join(&path)?,
	ResolvedVc::upcast(entry.module),
	entry.runtime_entries,
	self.fallback_page,
	entry.chunking_context,
	entry.intermediate_output_path.clone(),
	entry.output_root.clone(),
	entry.project_dir.clone(),
	RenderData {
	params: params.clone(),
	method: method.clone(),
	url: url.clone(),
	original_url: original_url.clone(),
	raw_query: raw_query.clone(),
	raw_headers: raw_headers.clone(),
	path: pathname.as_str().into(),
	data: Some(self.render_data.await?),
	}
	.resolved_cell(),
	self.debug,
	)
	.issue_file_path(
	entry.module.ident().path().owned().await?,
	format!("server-side rendering {pathname}"),
	)
	.await?;
	Ok(match *result_op.connect().await? {
	StaticResult::Content {
	content,
	status_code,
	headers,
	} => ContentSourceContent::static_with_headers(
	content.versioned(),
	status_code,
	*headers,
	),
	StaticResult::StreamedContent {
	status,
	headers,
	ref body,
	} => {
	ContentSourceContent::HttpProxy(static_streamed_content_to_proxy_result_operation(
	result_op,
	ProxyResult {
	status,
	headers: headers.owned().await?,
	body: body.clone(),
	}
	.resolved_cell(),
	))
	.cell()
	}
	StaticResult::Rewrite(rewrite) => ContentSourceContent::Rewrite(rewrite).cell(),
	})
	}
	}

	#[turbo_tasks::function(operation)]
	async fn static_streamed_content_to_proxy_result_operation(
	result_op: OperationVc<StaticResult>,
	proxy_result: ResolvedVc<ProxyResult>,
	) -> Result<Vc<ProxyResult>> {
	// we already assume `result_op`'s value here because we're called inside of a match arm, but
	// await `result_op` anyways, so that if it generates any collectible issues, they're captured
	// here.
	let _ = result_op.connect().await?;
	Ok(*proxy_result)
	}

	#[turbo_tasks::value_impl]
	impl Introspectable for NodeRenderContentSource {
	#[turbo_tasks::function]
	fn ty(&self) -> Vc<RcStr> {
	Vc::cell(rcstr!("node render content source"))
	}

	#[turbo_tasks::function]
	fn title(&self) -> Vc<RcStr> {
	*self.pathname
	}

	#[turbo_tasks::function]
	fn details(&self) -> Vc<RcStr> {
	Vc::cell(
	format!(
	"base: {:?}\ntype: {:?}",
	self.base_segments, self.route_type
	)
	.into(),
	)
	}

	#[turbo_tasks::function]
	async fn children(&self) -> Result<Vc<IntrospectableChildren>> {
	let mut set = FxIndexSet::default();
	for &entry in self.entry.entries().await?.iter() {
	let entry = entry.await?;
	set.insert((
	rcstr!("module"),
	IntrospectableModule::new(Vc::upcast(*entry.module))
	.to_resolved()
	.await?,
	));
	set.insert((
	rcstr!("intermediate asset"),
	IntrospectableOutputAsset::new(get_intermediate_asset(
	*entry.chunking_context,
	*entry.module,
	*entry.runtime_entries,
	))
	.to_resolved()
	.await?,
	));
	}
	Ok(Vc::cell(set))
	}
	}