feat: experiment with codegen

parakeet-lexgen/src/codegen.rs

···
+use crate::types::*;
+use std::collections::{BTreeMap, BTreeSet};
+use std::fmt::Write as FmtWrite;
+use std::io::{self, Write};
+
+pub struct CodeGenerator {
+    lexicons: BTreeMap<String, Lexicon>,
+    output: Box<dyn Write>,
+    generated_types: BTreeSet<String>,
+    generated_enums: BTreeSet<String>,
+    pending_enums: Vec<(String, Vec<String>)>, // (enum_name, values)
+    imports: BTreeSet<String>,
+}
+
+impl CodeGenerator {
+    pub fn new(lexicons: BTreeMap<String, Lexicon>, output: Box<dyn Write>) -> Self {
+        let mut imports = BTreeSet::new();
+        // Always include these basic imports
+        imports.insert("serde::{Deserialize, Serialize}".to_string());
+
+        Self {
+            lexicons,
+            output,
+            generated_types: BTreeSet::new(),
+            generated_enums: BTreeSet::new(),
+            pending_enums: Vec::new(),
+            imports,
+        }
+    }
+
+    pub fn generate(&mut self) -> io::Result<()> {
+        // Write header
+        self.write_header()?;
+
+        // Group lexicons by namespace
+        let namespaces = self.group_by_namespace();
+
+        // Generate code for each namespace
+        for (ns, lexicon_ids) in namespaces {
+            self.generate_namespace(&ns, &lexicon_ids)?;
+        }
+
+        Ok(())
+    }
+
+    fn write_header(&mut self) -> io::Result<()> {
+        let header = r#"// THIS FILE IS AUTO-GENERATED. DO NOT EDIT.
+// Generated from AT Protocol lexicons
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::BTreeMap;
+
+"#;
+        self.output.write_all(header.as_bytes())
+    }
+
+    fn group_by_namespace(&self) -> BTreeMap<String, Vec<String>> {
+        let mut namespaces: BTreeMap<String, Vec<String>> = BTreeMap::new();
+
+        for id in self.lexicons.keys() {
+            let parts: Vec<&str> = id.split('.').collect();
+            if parts.len() >= 3 {
+                // Group by first 3 parts (e.g., app.bsky.actor)
+                let namespace = parts[0..3].join(".");
+                namespaces.entry(namespace).or_default().push(id.clone());
+            }
+        }
+
+        namespaces
+    }
+
+    fn generate_namespace(&mut self, namespace: &str, lexicon_ids: &[String]) -> io::Result<()> {
+        // Convert namespace to module name (e.g., app.bsky.actor -> actor)
+        let module_name = namespace.split('.').last().unwrap_or(namespace);
+        writeln!(self.output, "pub mod {} {{", module_name)?;
+        writeln!(self.output, "    use super::*;")?;
+        writeln!(self.output)?;
+
+        // Clear pending enums for this namespace
+        self.pending_enums.clear();
+
+        for id in lexicon_ids {
+            // Clone to avoid borrow issues
+            let lexicon = self.lexicons.get(id).cloned();
+            if let Some(lexicon) = lexicon {
+                self.generate_lexicon(&lexicon)?;
+            }
+        }
+
+        // Generate any enums that were collected
+        let enums_to_generate = self.pending_enums.clone();
+        for (enum_name, values) in enums_to_generate {
+            self.generate_enum(&enum_name, &values)?;
+        }
+
+        writeln!(self.output, "}}")?;
+        writeln!(self.output)?;
+        Ok(())
+    }
+
+    fn generate_enum(&mut self, name: &str, values: &[String]) -> io::Result<()> {
+        let mut code = String::new();
+
+        // Determine if this is a simple enum (all lowercase) or complex
+        let is_simple = values.iter().all(|v| v.chars().all(|c| c.is_lowercase() || c == '-'));
+
+        // Add derives
+        if is_simple {
+            writeln!(&mut code, "    #[derive(Copy, Clone, Debug, Serialize, Deserialize)]").unwrap();
+            writeln!(&mut code, "    #[serde(rename_all = \"lowercase\")]").unwrap();
+        } else {
+            writeln!(&mut code, "    #[derive(Clone, Debug, Serialize, Deserialize)]").unwrap();
+        }
+        writeln!(&mut code, "    pub enum {} {{", name).unwrap();
+
+        // Generate variants
+        for value in values {
+            if value.contains('.') || value.contains('#') {
+                // Complex value, use explicit rename
+                let variant_name = to_pascal_case(value.split('#').last().unwrap_or(value));
+                writeln!(&mut code, "        #[serde(rename = \"{}\")]", value).unwrap();
+                writeln!(&mut code, "        {},", variant_name).unwrap();
+            } else {
+                // Simple value
+                let variant_name = to_pascal_case(value);
+                writeln!(&mut code, "        {},", variant_name).unwrap();
+            }
+        }
+
+        writeln!(&mut code, "    }}").unwrap();
+        writeln!(&mut code).unwrap();
+
+        self.output.write_all(code.as_bytes())
+    }
+
+    fn generate_lexicon(&mut self, lexicon: &Lexicon) -> io::Result<()> {
+        // Generate types for each definition in the lexicon
+        for (name, def) in &lexicon.defs {
+            // Better type naming: use the definition name directly for non-main items
+            let type_name = if name == "main" {
+                to_type_name(&lexicon.id)
+            } else {
+                to_pascal_case(name)
+            };
+
+            if self.generated_types.contains(&type_name) {
+                continue;
+            }
+
+            match def {
+                LexiconDef::Object(obj) => {
+                    self.generate_object(&type_name, obj)?;
+                    self.generated_types.insert(type_name);
+                }
+                LexiconDef::Record(record) => {
+                    self.generate_record_object(&type_name, &record.record)?;
+                    self.generated_types.insert(type_name);
+                }
+                LexiconDef::Query(query) => {
+                    self.generate_query(&lexicon.id, query)?;
+                }
+                LexiconDef::Procedure(procedure) => {
+                    self.generate_procedure(&lexicon.id, procedure)?;
+                }
+                LexiconDef::String(string_def) => {
+                    self.generate_string_type(&type_name, string_def)?;
+                    self.generated_types.insert(type_name);
+                }
+                LexiconDef::Array(array_def) => {
+                    self.generate_array_type(&type_name, array_def)?;
+                    self.generated_types.insert(type_name);
+                }
+                LexiconDef::Token { .. } | LexiconDef::PermissionSet { .. } | LexiconDef::Subscription(_) => {
+                    // Skip these for now
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn generate_object(&mut self, name: &str, obj: &LexiconObject) -> io::Result<()> {
+        let mut code = String::new();
+
+        // Add description as doc comment if available
+        if let Some(desc) = &obj.description {
+            for line in desc.lines() {
+                writeln!(&mut code, "    /// {}", line).unwrap();
+            }
+        }
+
+        // Check if we should add Default derive
+        let has_all_optional = obj.required.as_ref()
+            .map(|r| r.is_empty())
+            .unwrap_or(true);
+
+        // Add derives
+        if has_all_optional {
+            writeln!(&mut code, "    #[derive(Clone, Default, Debug, Serialize, Deserialize)]").unwrap();
+        } else {
+            writeln!(&mut code, "    #[derive(Clone, Debug, Serialize, Deserialize)]").unwrap();
+        }
+        writeln!(&mut code, "    #[serde(rename_all = \"camelCase\")]").unwrap();
+        writeln!(&mut code, "    pub struct {} {{", name).unwrap();
+
+        // Generate fields
+        for (field_name, field_schema) in &obj.properties {
+            let rust_field = to_field_name(field_name);
+
+            // Check if this field is an enum and generate it
+            let rust_type = if let LexiconSchema::String(s) = field_schema {
+                if let Some(known_values) = &s.known_values {
+                    if !known_values.is_empty() {
+                        // Generate enum name from struct name and field name
+                        let enum_name = format!("{}{}", name, to_pascal_case(field_name));
+                        if !self.generated_enums.contains(&enum_name) {
+                            self.pending_enums.push((enum_name.clone(), known_values.clone()));
+                            self.generated_enums.insert(enum_name.clone());
+                        }
+                        enum_name
+                    } else {
+                        self.schema_to_rust_type(field_schema)
+                    }
+                } else {
+                    self.schema_to_rust_type(field_schema)
+                }
+            } else {
+                self.schema_to_rust_type(field_schema)
+            };
+
+            // Add field description if available
+            if let Some(desc) = self.get_schema_description(field_schema) {
+                for line in desc.lines() {
+                    writeln!(&mut code, "        /// {}", line).unwrap();
+                }
+            }
+
+            let is_required = obj.required.as_ref()
+                .map(|r| r.contains(field_name))
+                .unwrap_or(false);
+
+            if !is_required {
+                writeln!(&mut code, "        #[serde(skip_serializing_if = \"Option::is_none\")]").unwrap();
+                writeln!(&mut code, "        pub {}: Option<{}>,", rust_field, rust_type).unwrap();
+            } else {
+                writeln!(&mut code, "        pub {}: {},", rust_field, rust_type).unwrap();
+            }
+        }
+
+        writeln!(&mut code, "    }}").unwrap();
+        writeln!(&mut code).unwrap();
+
+        self.output.write_all(code.as_bytes())
+    }
+
+    fn generate_record_object(&mut self, name: &str, obj: &LexiconObject) -> io::Result<()> {
+        self.generate_object(name, obj)
+    }
+
+    fn generate_query(&mut self, id: &str, query: &LexiconQuery) -> io::Result<()> {
+        let name = to_type_name(id);
+
+        // Generate params struct if exists
+        if let Some(params) = &query.parameters {
+            let params_name = format!("{}Params", name);
+            self.generate_params_struct(&params_name, params, query.description.as_deref())?;
+        }
+
+        // Generate output struct if exists
+        if let Some(output) = &query.output {
+            if let Some(schema) = &output.schema {
+                let output_name = format!("{}Response", name);
+                match schema {
+                    LexiconSchema::Object(obj) => {
+                        self.generate_object(&output_name, obj)?;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn generate_procedure(&mut self, id: &str, procedure: &LexiconProcedure) -> io::Result<()> {
+        let name = to_type_name(id);
+
+        // Generate input struct if exists
+        if let Some(input) = &procedure.input {
+            if let Some(schema) = &input.schema {
+                let input_name = format!("{}Input", name);
+                match schema {
+                    LexiconSchema::Object(obj) => {
+                        self.generate_object(&input_name, obj)?;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        // Generate output struct if exists
+        if let Some(output) = &procedure.output {
+            if let Some(schema) = &output.schema {
+                let output_name = format!("{}Output", name);
+                match schema {
+                    LexiconSchema::Object(obj) => {
+                        self.generate_object(&output_name, obj)?;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn generate_params_struct(&mut self, name: &str, params: &LexiconParams, description: Option<&str>) -> io::Result<()> {
+        let mut code = String::new();
+
+        // Add description if available
+        if let Some(desc) = description.or(params.description.as_deref()) {
+            for line in desc.lines() {
+                writeln!(&mut code, "    /// {}", line).unwrap();
+            }
+        }
+
+        writeln!(&mut code, "    #[derive(Clone, Debug, Deserialize)]").unwrap();
+        writeln!(&mut code, "    #[serde(rename_all = \"camelCase\")]").unwrap();
+        writeln!(&mut code, "    pub struct {} {{", name).unwrap();
+
+        for (param_name, param_schema) in &params.properties {
+            let rust_field = to_field_name(param_name);
+            let rust_type = self.schema_to_rust_type(param_schema);
+
+            // Add field description if available
+            if let Some(desc) = self.get_schema_description(param_schema) {
+                for line in desc.lines() {
+                    writeln!(&mut code, "        /// {}", line).unwrap();
+                }
+            }
+
+            // Parameters are typically optional in query strings
+            let is_required = false;
+
+            if !is_required {
+                writeln!(&mut code, "        pub {}: Option<{}>,", rust_field, rust_type).unwrap();
+            } else {
+                writeln!(&mut code, "        pub {}: {},", rust_field, rust_type).unwrap();
+            }
+        }
+
+        writeln!(&mut code, "    }}").unwrap();
+        writeln!(&mut code).unwrap();
+
+        self.output.write_all(code.as_bytes())
+    }
+
+    fn generate_string_type(&mut self, name: &str, _string_def: &LexiconString) -> io::Result<()> {
+        // For now, just create a type alias
+        let mut code = String::new();
+        writeln!(&mut code, "    pub type {} = String;", name).unwrap();
+        writeln!(&mut code).unwrap();
+        self.output.write_all(code.as_bytes())
+    }
+
+    fn generate_array_type(&mut self, name: &str, array_def: &LexiconArray) -> io::Result<()> {
+        let inner_type = self.schema_to_rust_type(&array_def.items);
+        let mut code = String::new();
+        writeln!(&mut code, "    pub type {} = Vec<{}>;", name, inner_type).unwrap();
+        writeln!(&mut code).unwrap();
+        self.output.write_all(code.as_bytes())
+    }
+
+    fn get_schema_description<'a>(&self, schema: &'a LexiconSchema) -> Option<&'a String> {
+        match schema {
+            LexiconSchema::Null { description } |
+            LexiconSchema::Boolean { description, .. } |
+            LexiconSchema::Bytes { description, .. } |
+            LexiconSchema::CidLink { description } |
+            LexiconSchema::Blob { description, .. } |
+            LexiconSchema::Ref { description, .. } |
+            LexiconSchema::Unknown { description } => description.as_ref(),
+            LexiconSchema::Integer(i) => i.description.as_ref(),
+            LexiconSchema::String(s) => s.description.as_ref(),
+            LexiconSchema::Array(a) => a.description.as_ref(),
+            LexiconSchema::Object(o) => o.description.as_ref(),
+            LexiconSchema::Union(u) => u.description.as_ref(),
+        }
+    }
+
+    fn schema_to_rust_type(&self, schema: &LexiconSchema) -> String {
+        match schema {
+            LexiconSchema::Boolean { .. } => "bool".to_string(),
+            LexiconSchema::Integer(_) => "i64".to_string(),
+            LexiconSchema::String(s) => {
+                // Check for special formats
+                if let Some(format) = &s.format {
+                    match format {
+                        StringFormats::Datetime => return "DateTime<Utc>".to_string(),
+                        StringFormats::Uri | StringFormats::AtUri => return "String".to_string(),
+                        StringFormats::Did => return "String".to_string(),
+                        StringFormats::Handle => return "String".to_string(),
+                        StringFormats::Cid => return "String".to_string(),
+                        _ => {}
+                    }
+                }
+                // Check if this is an enum
+                if let Some(known_values) = &s.known_values {
+                    if !known_values.is_empty() {
+                        // Generate an enum name based on context (will need to track this)
+                        return "String".to_string(); // For now, will improve this
+                    }
+                }
+                "String".to_string()
+            }
+            LexiconSchema::Bytes { .. } => "Vec<u8>".to_string(),
+            LexiconSchema::CidLink { .. } => "String".to_string(),
+            LexiconSchema::Array(arr) => {
+                format!("Vec<{}>", self.schema_to_rust_type(&arr.items))
+            }
+            LexiconSchema::Object(_) => "Value".to_string(),
+            LexiconSchema::Blob { .. } => "Blob".to_string(),
+            LexiconSchema::Ref { ref_to, .. } => {
+                // Handle cross-module references
+                if ref_to.contains('.') && !ref_to.starts_with('#') {
+                    // This is a cross-module reference
+                    // For now, just use the type name, will add imports later
+                    to_type_name(ref_to)
+                } else {
+                    to_type_name(ref_to)
+                }
+            }
+            LexiconSchema::Union(_) => "Value".to_string(), // Will handle later
+            LexiconSchema::Unknown { .. } => "Value".to_string(),
+            LexiconSchema::Null { .. } => "()".to_string(),
+        }
+    }
+}
+
+// Helper functions to convert names to Rust conventions
+fn to_type_name(s: &str) -> String {
+    // Handle references like "app.bsky.actor.defs#profileView"
+    let (base, fragment) = if s.contains('#') {
+        let parts: Vec<&str> = s.split('#').collect();
+        (parts[0], Some(parts[1]))
+    } else {
+        (s, None)
+    };
+
+    // If we have a fragment and it's not "main", use that as the primary name
+    if let Some(frag) = fragment {
+        if frag != "main" {
+            return to_pascal_case(frag);
+        }
+    }
+
+    // Otherwise use the last part of the base
+    let base_parts: Vec<&str> = base.split('.').collect();
+    let base_name = base_parts.last().unwrap_or(&base);
+    to_pascal_case(base_name)
+}
+
+fn to_pascal_case(s: &str) -> String {
+    let mut result = String::new();
+    let mut capitalize = true;
+
+    for ch in s.chars() {
+        if ch == '_' || ch == '-' {
+            capitalize = true;
+        } else if capitalize {
+            result.push(ch.to_uppercase().next().unwrap_or(ch));
+            capitalize = false;
+        } else {
+            result.push(ch);
+        }
+    }
+
+    result
+}
+
+fn to_field_name(s: &str) -> String {
+    // Convert to snake_case
+    let mut result = String::new();
+    let mut prev_upper = false;
+
+    for (i, ch) in s.chars().enumerate() {
+        if ch.is_uppercase() && i > 0 && !prev_upper {
+            result.push('_');
+        }
+        result.push(ch.to_lowercase().next().unwrap_or(ch));
+        prev_upper = ch.is_uppercase();
+    }
+
+    // Handle special cases
+    match result.as_str() {
+        "type" => "r#type".to_string(),
+        "ref" => "r#ref".to_string(),
+        other => other.to_string(),
+    }
+}

parakeet-lexgen/src/main.rs

···
 use std::collections::BTreeMap;
 use walkdir::WalkDir;
 
+mod codegen;
 mod types;
 mod validate;
 
···
             eprintln!("Lexicon {fail_nsid} failed validation: {fail_err:?}");
         }
     }
+
+    // Generate code
+    let output_file = std::fs::File::create(&args.out)?;
+    let mut generator = codegen::CodeGenerator::new(parsed, Box::new(output_file));
+    generator.generate()?;
+
+    println!("Generated code written to: {}", args.out);
 
     Ok(())
 }

parakeet-lexgen/src/types.rs

···
 use std::collections::BTreeMap;
 
 #[expect(dead_code, reason = "Lexicon type used for parsing AT Protocol lexicon schemas")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct Lexicon {
-    /// Lexicon language version
     pub lexicon: i32,
-    // Lexicon NSID
     pub id: String,
     pub revision: Option<i32>,
     pub description: Option<String>,
···
 }
 
 #[expect(dead_code, reason = "Enum variants used for lexicon definition deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(tag = "type")]
-#[serde(rename_all = "lowercase")]
+#[serde(rename_all = "kebab-case")]
 pub enum LexiconDef {
     Query(LexiconQuery),
     Procedure(Box<LexiconProcedure>),
···
     Array(LexiconArray),
     Object(LexiconObject),
     Token { description: Option<String> },
+    #[serde(rename = "permission-set")]
+    PermissionSet {
+        description: Option<String>,
+        permissions: Option<Vec<String>>,
+    },
 }
 
 #[expect(dead_code, reason = "Schema variants used for AT Protocol type definitions")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(tag = "type")]
 #[serde(rename_all = "kebab-case")]
 pub enum LexiconSchema {
···
     },
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum RKey {
     Tid,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(untagged)]
 pub enum RecordKey {
     Typed(RKey),
     Other(String),
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum StringFormats {
     AtIdentifier,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct HttpApiExchange {
     pub description: Option<String>,
     pub encoding: String,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LexiconError {
     pub name: String,
     pub description: Option<String>,
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LexiconSubMessage {
     pub description: Option<String>,
     pub schema: Option<LexiconUnion>,
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LexiconRecord {
     pub description: Option<String>,
     pub key: RecordKey,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LexiconQuery {
     pub description: Option<String>,
     pub parameters: Option<LexiconParams>,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LexiconProcedure {
     pub description: Option<String>,
     pub parameters: Option<LexiconParams>,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LexiconSubscription {
     pub description: Option<String>,
     pub parameters: Option<LexiconParams>,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LexiconInteger {
     pub description: Option<String>,
 
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LexiconString {
     pub description: Option<String>,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LexiconArray {
     pub description: Option<String>,
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(tag = "type")]
 #[serde(rename = "object")]
 pub struct LexiconObject {
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(tag = "type")]
 #[serde(rename = "params")]
 pub struct LexiconParams {
···
 }
 
 #[expect(dead_code, reason = "Used for AT Protocol lexicon schema deserialization")]
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(tag = "type")]
 #[serde(rename = "union")]
 pub struct LexiconUnion {

parakeet-lexgen/src/validate.rs

···
                 LexiconDef::String(lex_str) => validate_string(lex_str, lexica, lexicon_id),
                 LexiconDef::Array(array) => validate_schema(&array.items, lexica, lexicon_id),
                 LexiconDef::Object(obj) => validate_object(obj, lexica, lexicon_id),
-                LexiconDef::Token { .. } => continue,
+                LexiconDef::Token { .. } | LexiconDef::PermissionSet { .. } => continue,
             };
 
             if let Some(err) = pass {