use super::{
GenerationError, Method, Node, PayloadLimits, RUNTIME_SCHEMA_FORMAT, ValidatedRegistry,
identifier,
};
use alloc::{
collections::{BTreeMap, BTreeSet},
format,
string::String,
};
use core::fmt::{self, Write};
struct Output {
text: String,
remaining: usize,
}
impl Write for Output {
fn write_str(&mut self, value: &str) -> fmt::Result {
self.remaining = self.remaining.checked_sub(value.len()).ok_or(fmt::Error)?;
self.text.push_str(value);
Ok(())
}
}
impl Output {
fn scalar_bounds(&mut self, bounds: &super::ScalarBounds, json: bool) -> fmt::Result {
for (key, bound) in [("min", &bounds.min), ("max", &bounds.max)] {
if let Some(bound) = bound {
if json {
write!(self, ",\"{key}\":{bound}")?;
} else {
write!(self, "/* {key} {bound} */ ")?;
}
}
}
Ok(())
}
fn quoted(&mut self, value: &str) -> fmt::Result {
self.write_char('"')?;
let mut start = 0;
for (index, character) in value.char_indices() {
if !matches!(
character,
'"' | '\\' | '\u{0000}'..='\u{001f}' | '\u{2028}' | '\u{2029}'
) {
continue;
}
self.write_str(&value[start..index])?;
match character {
'"' => self.write_str("\\\"")?,
'\\' => self.write_str("\\\\")?,
'\u{0000}'..='\u{001f}' | '\u{2028}' | '\u{2029}' => {
write!(self, "\\u{:04x}", u32::from(character))?;
}
_ => unreachable!(),
}
start = index + character.len_utf8();
}
self.write_str(&value[start..])?;
self.write_char('"')
}
fn bounds(&mut self, min: Option<u64>, max: Option<u64>) -> fmt::Result {
if let Some(min) = min {
write!(self, "/* min {min} */ ")?;
}
if let Some(max) = max {
write!(self, "/* max {max} */ ")?;
}
Ok(())
}
}
impl ValidatedRegistry {
pub fn payload_module(
&self,
export: &str,
root: &str,
runtime_module: &str,
limits: PayloadLimits,
acknowledgements: &BTreeMap<String, String>,
diagnostics: impl FnOnce(super::BulkLintReport),
) -> Result<String, GenerationError> {
self.admit_client(export, root, runtime_module, limits)?;
let mut output = Output {
text: String::new(),
remaining: self.output_bytes,
};
self.render_payload_module(&mut output, export, root, runtime_module, limits)
.map_err(|_| GenerationError::Complexity)?;
let report = self.lint_roots(
[Ok((
format!("/types/{}", super::advice::escape(root)),
self.root_index(root)?,
))],
acknowledgements,
)?;
diagnostics(report);
Ok(output.text)
}
fn admit_client(
&self,
export: &str,
root: &str,
runtime_module: &str,
limits: PayloadLimits,
) -> Result<(), GenerationError> {
identifier(export)?;
if export == "globalThis"
|| self
.names
.binary_search_by(|name| name.as_str().cmp(root))
.is_err()
|| self
.names
.binary_search_by(|name| name.as_str().cmp(export))
.is_ok()
|| runtime_module.is_empty()
|| runtime_module.contains('\0')
|| limits.nodes == 0
|| limits.depth == 0
{
return Err(GenerationError::Schema);
}
if [limits.bytes, limits.nodes, limits.depth]
.into_iter()
.any(|n| n > (1_u64 << 53) - 1)
{
return Err(GenerationError::Complexity);
}
Ok(())
}
pub fn method_module(
&self,
methods: &[Method<'_>],
runtime_module: &str,
acknowledgements: &BTreeMap<String, String>,
diagnostics: impl FnOnce(super::BulkLintReport),
) -> Result<String, GenerationError> {
if methods.is_empty() {
return Err(GenerationError::Schema);
}
if methods.len() > self.output_bytes {
return Err(GenerationError::Complexity);
}
let mut names = BTreeSet::new();
let mut ids = BTreeSet::new();
for method in methods {
for (root, limits) in [
(method.request, method.request_limits),
(method.response, method.response_limits),
] {
self.admit_client(method.export, root, runtime_module, limits)?;
if limits.bytes > (1_u64 << 53) - 12 {
return Err(GenerationError::Complexity);
}
}
if !names.insert(method.export) || !ids.insert(method.id) {
return Err(GenerationError::Schema);
}
}
let mut output = Output {
text: String::new(),
remaining: self.output_bytes,
};
self.render_methods(&mut output, methods, runtime_module)
.map_err(|_| GenerationError::Complexity)?;
let roots = methods.iter().flat_map(|method| {
[("request", method.request), ("response", method.response)].map(|(direction, root)| {
Ok((
format!(
"/methods/{}/{direction}",
super::advice::escape(method.export)
),
self.root_index(root)?,
))
})
});
let report = self.lint_roots(roots, acknowledgements)?;
diagnostics(report);
Ok(output.text)
}
fn render_methods(
&self,
output: &mut Output,
methods: &[Method<'_>],
runtime_module: &str,
) -> fmt::Result {
self.module_prelude(output, runtime_module, "createCodec")?;
for method in methods {
writeln!(output, "export const {} = (() => {{", method.export)?;
write!(
output,
"const $codec = $create({{id:'{}',request:{{k:'ref',name:",
method.id
)?;
output.quoted(method.request)?;
output.write_str("},response:{k:'ref',name:")?;
output.quoted(method.response)?;
for (prefix, limits) in [
("request", method.request_limits),
("response", method.response_limits),
] {
write!(
output,
"{separator}{prefix}Bytes:{}, {prefix}Nodes:{}, {prefix}Depth:{}",
limits.bytes + 11,
limits.nodes,
limits.depth,
separator = if prefix == "request" { "}," } else { "," }
)?;
}
output.write_str("}, $types);\nreturn globalThis.Object.freeze({\n")?;
for (direction, root) in [("Request", method.request), ("Response", method.response)] {
writeln!(
output,
"encode{direction}:(value: {root}): globalThis.Uint8Array => $codec.encode{direction}(value), decode{direction}:(bytes: globalThis.Uint8Array): {root} => $codec.decode{direction}(bytes) as {root},"
)?;
}
output.write_str("});\n})();\n")?;
}
Ok(())
}
fn render_payload_module(
&self,
output: &mut Output,
export: &str,
root: &str,
runtime_module: &str,
limits: PayloadLimits,
) -> fmt::Result {
self.module_prelude(output, runtime_module, "createPayloadCodec")?;
writeln!(output, "export const {export} = (() => {{")?;
output.write_str("const $codec = $create({schema:{k:'ref',name:")?;
output.quoted(root)?;
writeln!(
output,
"}},bytes:{},nodes:{},depth:{}}}, $types);",
limits.bytes, limits.nodes, limits.depth
)?;
writeln!(
output,
"return globalThis.Object.freeze({{encode:(value: {root}): globalThis.Uint8Array => $codec.encode(value), decode:(bytes: globalThis.Uint8Array): {root} => $codec.decode(bytes) as {root}}});\n}})();"
)
}
fn module_prelude(
&self,
output: &mut Output,
runtime_module: &str,
factory: &str,
) -> fmt::Result {
write!(
output,
"// Generated IC Wire client; no transport or execution.\nimport {{ schemaFormat as $format, {factory} as $create }} from "
)?;
output.quoted(runtime_module)?;
output.write_str(";\nif ($format !== ")?;
output.quoted(RUNTIME_SCHEMA_FORMAT)?;
output.write_str(") throw new globalThis.Error('IC Wire runtime format mismatch');\n")?;
self.render(output)?;
output.write_str("const $types = globalThis.JSON.parse(")?;
let metadata = self.metadata_json().map_err(|_| fmt::Error)?;
output.quoted(&metadata)?;
output.write_str(");\n")
}
pub fn metadata_json(&self) -> Result<String, GenerationError> {
let mut output = Output {
text: String::new(),
remaining: self.output_bytes,
};
self.render_metadata(&mut output)
.map_err(|_| GenerationError::Complexity)?;
Ok(output.text)
}
fn render_metadata(&self, output: &mut Output) -> fmt::Result {
output.write_char('{')?;
for (index, (name, root)) in self.names.iter().zip(&self.roots).enumerate() {
if index != 0 {
output.write_char(',')?;
}
output.quoted(name)?;
output.write_char(':')?;
self.metadata_node(*root, output)?;
}
output.write_char('}')
}
fn metadata_node(&self, id: usize, output: &mut Output) -> fmt::Result {
output.write_str("{\"k\":")?;
match &self.nodes[id] {
Node::Unit => output.quoted("unit")?,
Node::Bool => output.quoted("bool")?,
Node::Float { bits } => {
output.quoted("float")?;
write!(output, ",\"bits\":{bits}")?;
}
Node::Integer { bits, signed } => {
output.quoted(if *signed { "i" } else { "u" })?;
write!(output, ",\"bits\":{bits}")?;
}
Node::Text { max } => {
output.quoted("text")?;
output.json_bound("max", *max)?;
}
Node::Bytes { min, max } => {
output.quoted("bytes")?;
output.json_bound("min", *min)?;
output.json_bound("max", *max)?;
}
Node::Packed { word, nonzero, max } => {
output.quoted("packed")?;
output.json_bound("max", *max)?;
output.write_str(",\"word\":")?;
output.quoted(word)?;
if *nonzero {
output.write_str(",\"nonzero\":true")?;
}
}
Node::List { item, max } => {
output.quoted("list")?;
output.json_bound("max", *max)?;
output.write_str(",\"item\":")?;
self.metadata_node(*item, output)?;
}
Node::Array { item, len } => {
output.quoted("array")?;
output.json_bound("max", Some(*len))?;
output.write_str(",\"item\":")?;
self.metadata_node(*item, output)?;
}
Node::Tuple(items) => {
output.write_str("\"tuple\",\"items\":[")?;
for (index, item) in items.iter().enumerate() {
if index != 0 {
output.write_char(',')?;
}
self.metadata_node(*item, output)?;
}
output.write_char(']')?;
}
Node::Result { ok, err } => {
output.write_str("\"result\",\"ok\":")?;
self.metadata_node(*ok, output)?;
output.write_str(",\"err\":")?;
self.metadata_node(*err, output)?;
}
Node::Option(item) | Node::Alias(item) => {
output.quoted(if matches!(self.nodes[id], Node::Option(_)) {
"option"
} else {
"newtype"
})?;
output.write_str(",\"item\":")?;
self.metadata_node(*item, output)?;
}
Node::Ref(root) => {
output.write_str("\"ref\",\"name\":")?;
output.quoted(&self.names[*root])?;
}
Node::Record(fields) => {
output.write_str("\"record\",\"fields\":[")?;
for (index, (name, child)) in fields.iter().enumerate() {
if index != 0 {
output.write_char(',')?;
}
output.write_str("{\"name\":")?;
output.quoted(name)?;
output.write_str(",\"value\":")?;
self.metadata_node(*child, output)?;
output.write_char('}')?;
}
output.write_char(']')?;
}
Node::Enum(variants) => {
output.write_str("\"enum\",\"variants\":[")?;
for (index, (name, tag, child)) in variants.iter().enumerate() {
if index != 0 {
output.write_char(',')?;
}
output.write_str("{\"name\":")?;
output.quoted(name)?;
write!(output, ",\"id\":{tag},\"value\":")?;
self.metadata_node(*child, output)?;
output.write_char('}')?;
}
output.write_char(']')?;
}
}
if let Some(annotation) = self.annotations.get(&id) {
if let Some(bounds) = &annotation.bounds {
output.scalar_bounds(bounds, true)?;
}
if let Some(check) = &annotation.check {
output.write_str(",\"check\":")?;
output.quoted(check)?;
}
}
output.write_char('}')
}
pub fn declarations(&self) -> Result<String, GenerationError> {
let mut output = Output {
text: String::new(),
remaining: self.output_bytes,
};
self.render(&mut output)
.map_err(|_| GenerationError::Complexity)?;
Ok(output.text)
}
fn render(&self, output: &mut Output) -> fmt::Result {
for (name, root) in self.names.iter().zip(&self.roots) {
write!(output, "export type {name} = ")?;
self.render_node(*root, output)?;
output.write_str(";\n")?;
}
Ok(())
}
fn render_node(&self, id: usize, output: &mut Output) -> fmt::Result {
if let Some(bounds) = self
.annotations
.get(&id)
.and_then(|annotation| annotation.bounds.as_ref())
{
output.scalar_bounds(bounds, false)?;
}
match &self.nodes[id] {
Node::Unit => output.write_str("null"),
Node::Bool => output.write_str("boolean"),
Node::Packed { word, max, .. } => {
output.bounds(None, *max)?;
output.write_str(match *word {
"bool" => "globalThis.ReadonlyArray<boolean>",
"finite-f32" => "globalThis.Float32Array",
"finite-f64" => "globalThis.Float64Array",
"i8" => "globalThis.Int8Array",
"i16" => "globalThis.Int16Array",
"u16" => "globalThis.Uint16Array",
"i32" => "globalThis.Int32Array",
"u32" => "globalThis.Uint32Array",
"i64" => "globalThis.BigInt64Array",
"u64" => "globalThis.BigUint64Array",
_ => "globalThis.Uint8Array",
})
}
Node::Float { bits } => {
write!(output, "/* f{bits} */ number")
}
Node::Integer { bits, signed } => {
write!(
output,
"/* {}{bits} */ {}",
if *signed { "i" } else { "u" },
if *bits > 32 { "bigint" } else { "number" }
)
}
Node::Text { max } => {
output.bounds(None, *max)?;
output.write_str("string")
}
Node::Bytes { min, max } => {
output.bounds(*min, *max)?;
output.write_str("globalThis.Uint8Array")
}
Node::List { item, max } => {
output.bounds(None, *max)?;
output.write_str("globalThis.ReadonlyArray<")?;
self.render_node(*item, output)?;
output.write_char('>')
}
Node::Option(item) => {
output.write_str("null | { readonly some: ")?;
self.render_node(*item, output)?;
output.write_str(" }")
}
Node::Array { item, len } => {
output.bounds(None, Some(*len))?;
output.write_str("globalThis.ReadonlyArray<")?;
self.render_node(*item, output)?;
output.write_char('>')
}
Node::Tuple(items) => {
output.write_str("readonly [")?;
for (index, item) in items.iter().enumerate() {
if index != 0 {
output.write_str(", ")?;
}
self.render_node(*item, output)?;
}
output.write_char(']')
}
Node::Result { ok, err } => {
output.write_str("{ readonly ok: ")?;
self.render_node(*ok, output)?;
output.write_str(" } | { readonly err: ")?;
self.render_node(*err, output)?;
output.write_str(" }")
}
Node::Alias(item) => self.render_node(*item, output),
Node::Ref(root) => output.write_str(&self.names[*root]),
Node::Record(fields) => {
output.write_char('{')?;
for (name, child) in fields {
output.write_str(" readonly ")?;
output.quoted(name)?;
output.write_str(": ")?;
self.render_node(*child, output)?;
output.write_char(';')?;
}
output.write_str(" }")
}
Node::Enum(variants) => {
for (index, (name, tag, child)) in variants.iter().enumerate() {
if index != 0 {
output.write_str(" | ")?;
}
write!(output, "/* id {tag} */ {{ readonly tag: ")?;
output.quoted(name)?;
output.write_str("; readonly value: ")?;
self.render_node(*child, output)?;
output.write_str(" }")?;
}
Ok(())
}
}
}
}
impl Output {
fn json_bound(&mut self, name: &str, value: Option<u64>) -> fmt::Result {
if let Some(value) = value {
write!(self, ",\"{name}\":{value}")?;
}
Ok(())
}
}