use serde::{Deserialize, Serialize};
pub const USAGE_SCHEMA_VERSION: u32 = 1;
pub const COUNT_MAX: u32 = 10_000;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(tag = "kind", rename_all = "camelCase")]
#[cfg_attr(feature = "codegen", schemars(title = "Modelith usage report"))]
pub enum UsageReport {
#[cfg_attr(
feature = "codegen",
schemars(extend(
"x-modelith-when" = "startup",
"x-modelith-level" = "all",
"x-modelith-max-bytes" = 1024
))
)]
Startup(StartupReport),
#[cfg_attr(
feature = "codegen",
schemars(extend(
"x-modelith-when" = "daily",
"x-modelith-level" = "all",
"x-modelith-max-bytes" = 8192
))
)]
Daily(Box<DailyReport>),
#[cfg_attr(
feature = "codegen",
schemars(extend(
"x-modelith-when" = "error",
"x-modelith-level" = "error",
"x-modelith-max-bytes" = 4096
))
)]
Error(ErrorReport),
#[cfg_attr(
feature = "codegen",
schemars(extend(
"x-modelith-when" = "daily",
"x-modelith-level" = "all",
"x-modelith-max-bytes" = 2048
))
)]
ServerDaily(ServerDailyReport),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct StartupReport {
pub schema_version: u32,
#[serde(flatten)]
pub sender: Sender,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub browser: Option<Browser>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub os: Option<Os>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub screen: Option<ScreenClass>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub language: Option<Language>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub folder_access: Option<bool>,
pub startup_time: DurationClass,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct DailyReport {
pub schema_version: u32,
#[serde(flatten)]
pub sender: Sender,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub browser: Option<Browser>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub os: Option<Os>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub screen: Option<ScreenClass>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub language: Option<Language>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub folder_access: Option<bool>,
#[serde(default)]
#[cfg_attr(
feature = "codegen",
schemars(length(max = 7), extend("uniqueItems" = true))
)]
pub onboarding: Vec<OnboardingStep>,
#[serde(default)]
pub auto_views: AutoViews,
#[serde(default)]
pub created_views: CreatedViews,
#[serde(default)]
pub edits: Edits,
#[serde(default)]
pub layout: Layout,
#[serde(default)]
pub saves: Saves,
#[serde(default)]
pub exports: Exports,
#[serde(default)]
pub checks: Checks,
#[serde(default)]
pub plugin_uses: Count,
#[serde(default)]
pub ai_rewrites: Count,
#[serde(default)]
#[cfg_attr(feature = "codegen", schemars(length(max = 20)))]
pub parse_times: Vec<ParseTime>,
#[serde(default)]
pub wasm_load_failures: Count,
#[serde(default)]
pub worker_restarts: Count,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub weeks_used: Option<WeeksClass>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", schemars(regex(pattern = r"^\d{4}-Q[1-4]$")))]
#[cfg_attr(feature = "codegen", ts(optional))]
pub first_quarter: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct ErrorReport {
pub schema_version: u32,
#[serde(flatten)]
pub sender: Sender,
pub level: SendLevel,
pub error_kind: ErrorKind,
pub error_name: ErrorName,
#[cfg_attr(feature = "codegen", schemars(length(max = 30)))]
pub frames: Vec<StackFrame>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct StackFrame {
#[cfg_attr(
feature = "codegen",
schemars(regex(pattern = r"^[A-Za-z0-9_][A-Za-z0-9_./-]{0,119}$"))
)]
pub module: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(
feature = "codegen",
schemars(regex(pattern = r"^[A-Za-z0-9_:<>$.]{1,200}$"))
)]
#[cfg_attr(feature = "codegen", ts(optional))]
pub function: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", schemars(range(max = 10_000_000)))]
#[cfg_attr(feature = "codegen", ts(optional))]
pub line: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", schemars(range(max = 10_000_000)))]
#[cfg_attr(feature = "codegen", ts(optional))]
pub column: Option<u32>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct ServerDailyReport {
pub schema_version: u32,
#[serde(flatten)]
pub sender: Sender,
#[cfg_attr(
feature = "codegen",
schemars(regex(
pattern = r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
))
)]
pub instance_id: String,
pub os: Os,
pub deployment: Deployment,
pub login: LoginMethods,
pub users: AmountClass,
pub active_users_7d: AmountClass,
pub projects: AmountClass,
pub storage: StorageClass,
pub plugins: AmountClass,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct Sender {
#[cfg_attr(feature = "codegen", schemars(extend("x-modelith-dimension" = true)))]
pub client: Client,
#[cfg_attr(
feature = "codegen",
schemars(
regex(pattern = r"^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$"),
length(max = 32),
extend("x-modelith-dimension" = true)
)
)]
pub app_version: String,
#[cfg_attr(feature = "codegen", schemars(extend("x-modelith-dimension" = true)))]
pub channel: Channel,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum Client {
Web,
Server,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum Channel {
Stable,
Rc,
Preview,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", default)]
pub struct AutoViews {
pub trace: Count,
pub structure: Count,
pub control: Count,
pub ibd: Count,
pub behavior: Count,
pub seq: Count,
pub afv: Count,
pub stm: Count,
pub all: Count,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", default)]
pub struct CreatedViews {
pub general: Count,
pub interconnection: Count,
pub action_flow: Count,
pub state_transition: Count,
pub sequence: Count,
pub other: Count,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", default)]
pub struct Edits {
pub add_node: Count,
pub add_usage: Count,
pub rename: Count,
pub delete: Count,
pub delete_edge: Count,
pub connect: Count,
pub add_message: Count,
pub update_message: Count,
pub move_message: Count,
pub set_phase: Count,
pub init_phases: Count,
pub make_port: Count,
pub set_port_dir: Count,
pub delete_port: Count,
pub save_view: Count,
pub add_to_view: Count,
pub remove_from_view: Count,
pub rename_view: Count,
pub delete_view: Count,
pub set_attribute: Count,
pub remove_attribute: Count,
pub set_doc: Count,
pub undo: Count,
pub redo: Count,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", default)]
pub struct Layout {
pub r#move: Count,
pub adjust_edge: Count,
pub align: Count,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", default)]
pub struct Saves {
pub draft: Count,
pub download: Count,
pub folder: Count,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", default)]
pub struct Exports {
pub svg: Count,
pub png: Count,
pub jpeg: Count,
pub drawio: Count,
pub clipboard: Count,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", default)]
pub struct Checks {
pub runs: Count,
pub no_problems: Count,
pub problems_1_to_9: Count,
pub problems_10_to_99: Count,
pub problems_100_or_more: Count,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct ParseTime {
pub file_size: SizeClass,
pub duration: ParseDurationClass,
pub count: Count,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default, Serialize)]
#[cfg_attr(feature = "codegen", derive(ts_rs::TS))]
pub struct Count(u32);
impl Count {
pub fn capped(n: u64) -> Self {
Self(u32::try_from(n.min(u64::from(COUNT_MAX))).unwrap_or(COUNT_MAX))
}
pub fn get(self) -> u32 {
self.0
}
}
impl TryFrom<u32> for Count {
type Error = String;
fn try_from(n: u32) -> Result<Self, Self::Error> {
if n <= COUNT_MAX {
Ok(Self(n))
} else {
Err(format!("count {n} exceeds the maximum {COUNT_MAX}"))
}
}
}
impl<'de> Deserialize<'de> for Count {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::try_from(u32::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[cfg(feature = "codegen")]
impl schemars::JsonSchema for Count {
fn schema_name() -> std::borrow::Cow<'static, str> {
"Count".into()
}
fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
schemars::json_schema!({
"type": "integer",
"minimum": 0,
"maximum": COUNT_MAX,
"description": "A count from 0 up to the maximum. Senders cap larger counts at the maximum."
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum SendLevel {
All,
ErrorsOnly,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum Browser {
Chrome,
Edge,
Firefox,
Safari,
Other,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum Os {
Windows,
Macos,
Linux,
Android,
Ios,
Other,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum ScreenClass {
Phone,
Tablet,
Desktop,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum Language {
Ja,
En,
Other,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum OnboardingStep {
SampleOpened,
TextWritten,
DiagramOpened,
Edited,
ViewCreated,
Saved,
FolderOpened,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
pub enum DurationClass {
#[serde(rename = "lt1s")]
Under1s,
#[serde(rename = "1to3s")]
From1To3s,
#[serde(rename = "3to10s")]
From3To10s,
#[serde(rename = "ge10s")]
Over10s,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
pub enum ParseDurationClass {
#[serde(rename = "lt100ms")]
Under100Ms,
#[serde(rename = "100to300ms")]
From100To300Ms,
#[serde(rename = "300msTo1s")]
From300MsTo1s,
#[serde(rename = "1to3s")]
From1To3s,
#[serde(rename = "ge3s")]
Over3s,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
pub enum SizeClass {
#[serde(rename = "lt10kb")]
Under10Kb,
#[serde(rename = "10to100kb")]
From10To100Kb,
#[serde(rename = "100kbTo1mb")]
From100KbTo1Mb,
#[serde(rename = "ge1mb")]
Over1Mb,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
pub enum WeeksClass {
#[serde(rename = "1")]
One,
#[serde(rename = "2to4")]
From2To4,
#[serde(rename = "5to12")]
From5To12,
#[serde(rename = "ge13")]
Over13,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
pub enum AmountClass {
#[serde(rename = "0")]
Zero,
#[serde(rename = "1")]
One,
#[serde(rename = "2to10")]
From2To10,
#[serde(rename = "11to100")]
From11To100,
#[serde(rename = "101to1000")]
From101To1000,
#[serde(rename = "ge1001")]
Over1000,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
pub enum StorageClass {
#[serde(rename = "lt100mb")]
Under100Mb,
#[serde(rename = "100mbTo1gb")]
From100MbTo1Gb,
#[serde(rename = "1to10gb")]
From1To10Gb,
#[serde(rename = "ge10gb")]
Over10Gb,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum Deployment {
Docker,
Binary,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub struct LoginMethods {
pub accounts: bool,
pub oidc: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum ErrorKind {
UncaughtError,
UnhandledRejection,
WasmPanic,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase")]
pub enum ErrorName {
Error,
TypeError,
RangeError,
ReferenceError,
SyntaxError,
NotAllowedError,
QuotaExceededError,
AbortError,
SecurityError,
NotFoundError,
OtherDomException,
Panic,
Other,
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::*;
fn startup() -> serde_json::Value {
json!({
"kind": "startup", "schemaVersion": 1, "client": "web", "appVersion": "0.2.0-rc.1",
"channel": "rc", "browser": "chrome", "os": "macos", "screen": "desktop", "language": "ja",
"folderAccess": true, "startupTime": "1to3s"
})
}
fn with(mut base: serde_json::Value, key: &str, value: serde_json::Value) -> serde_json::Value {
base[key] = value;
base
}
#[test]
fn startup_report_uses_kind_tag_and_flat_sender() {
let json = startup();
let report: UsageReport = serde_json::from_value(json).unwrap();
let UsageReport::Startup(s) = report else {
panic!("not startup")
};
assert_eq!(
(s.sender.client, s.sender.channel, s.startup_time),
(Client::Web, Channel::Rc, DurationClass::From1To3s)
);
}
#[test]
fn startup_report_needs_no_environment() {
let mut json = startup();
for key in ["browser", "os", "screen", "language", "folderAccess"] {
json.as_object_mut().unwrap().remove(key);
}
let report: UsageReport = serde_json::from_value(json).unwrap();
let UsageReport::Startup(s) = report else {
panic!("not startup")
};
assert_eq!(
(s.browser, s.startup_time),
(None, DurationClass::From1To3s)
);
}
#[test]
fn daily_report_counts_default_to_zero() {
let json = json!({
"kind": "daily", "schemaVersion": 1, "client": "web", "appVersion": "0.2.0",
"channel": "stable"
});
let report: UsageReport = serde_json::from_value(json).unwrap();
let UsageReport::Daily(daily) = report else {
panic!("not daily")
};
assert_eq!(
(daily.edits, daily.exports.clipboard, daily.plugin_uses),
(Edits::default(), Count::default(), Count::default())
);
}
#[test]
fn ignores_unknown_fields() {
let json = with(startup(), "newField", json!(1));
let result = serde_json::from_value::<UsageReport>(json);
assert!(result.is_ok(), "{result:?}");
}
#[test]
fn accepts_count_at_the_maximum() {
let n = COUNT_MAX;
let count = serde_json::from_value::<Count>(json!(n));
assert_eq!(count.unwrap().get(), COUNT_MAX);
}
#[test]
fn capped_stops_at_the_maximum() {
let inputs = [u64::from(COUNT_MAX), u64::from(COUNT_MAX) + 1, u64::MAX, 3];
let counts = inputs.map(|n| Count::capped(n).get());
assert_eq!(counts, [COUNT_MAX, COUNT_MAX, COUNT_MAX, 3]);
}
#[test]
fn class_names_are_the_documented_words() {
let values = (
DurationClass::Under1s,
SizeClass::From100KbTo1Mb,
WeeksClass::Over13,
AmountClass::Zero,
SendLevel::ErrorsOnly,
);
let json = serde_json::to_value(values).unwrap();
assert_eq!(
json,
json!(["lt1s", "100kbTo1mb", "ge13", "0", "errorsOnly"])
);
}
#[test]
fn frame_function_is_omitted_when_absent() {
let frame = StackFrame {
module: "assets/index.js".into(),
function: None,
line: Some(1),
column: Some(2),
};
let json = serde_json::to_value(frame).unwrap();
assert_eq!(
json,
json!({ "module": "assets/index.js", "line": 1, "column": 2 })
);
}
#[test]
fn rejects_count_over_the_maximum() {
let n = COUNT_MAX + 1;
let result = serde_json::from_value::<Count>(json!(n));
assert!(result.is_err());
}
#[test]
fn rejects_negative_count() {
let n = -1;
let result = serde_json::from_value::<Count>(json!(n));
assert!(result.is_err());
}
#[test]
fn rejects_free_text_in_a_class() {
let json = with(startup(), "startupTime", json!("2.3 seconds"));
let result = serde_json::from_value::<UsageReport>(json);
assert!(result.is_err());
}
#[test]
fn rejects_a_missing_sender_field() {
let mut json = startup();
json.as_object_mut().unwrap().remove("client");
let result = serde_json::from_value::<UsageReport>(json);
assert!(result.is_err());
}
#[test]
fn rejects_unknown_kind() {
let json = with(startup(), "kind", json!("pageView"));
let result = serde_json::from_value::<UsageReport>(json);
assert!(result.is_err());
}
}