feat(gen): implicits

Author: rvagg

lib/gen/rust.js

@@ -35,7 +35,7 @@ export function generateRust (schema) {
         derive.push('Deserialize_tuple', 'Serialize_tuple')
       } else {
         // Default representation is map, add regular Serialize/Deserialize
-        derive.push('Deserialize', 'Serialize')
+        derive.push('Clone', 'Debug', 'PartialEq', 'Deserialize', 'Serialize')
       }
       /** @type { { [k in string]: string }[]} */
       let annotations = []
@@ -53,6 +53,9 @@ export function generateRust (schema) {
       }
       typesrc += `pub struct ${typeName} {\n`
 
+      // Collect implicit fields for generating default functions
+      const implicitFields = []
+
       for (let [fieldName, fieldDefn] of Object.entries(typeDefn.struct.fields)) {
         /** @type { { [k in string]: string }[]} */
         let annotations = []
@@ -141,7 +144,24 @@ export function generateRust (schema) {
         const isMapRepr = !typeDefn.struct.representation || 'map' in typeDefn.struct.representation
         const isTupleRepr = typeDefn.struct.representation && 'tuple' in typeDefn.struct.representation
 
-        if (fieldDefn.optional && fieldDefn.nullable) {
+        // Check for implicit field value
+        let hasImplicit = false
+        let implicitValue = null
+        const origFieldName = Object.keys(typeDefn.struct.fields)[Object.values(typeDefn.struct.fields).indexOf(fieldDefn)]
+        if (isMapRepr && typeDefn.struct.representation && 'map' in typeDefn.struct.representation &&
+            typeDefn.struct.representation.map.fields &&
+            origFieldName in typeDefn.struct.representation.map.fields &&
+            'implicit' in typeDefn.struct.representation.map.fields[origFieldName]) {
+          hasImplicit = true
+          implicitValue = typeDefn.struct.representation.map.fields[origFieldName].implicit
+        }
+
+        if (hasImplicit) {
+          // Field with implicit value
+          const defaultFnName = `default_${typeName.toLowerCase()}_${fieldName.toLowerCase()}`
+          typesrc += `    #[serde(default = "${defaultFnName}")]\n`
+          implicitFields.push({ fieldName, fieldType, implicitValue, defaultFnName })
+        } else if (fieldDefn.optional && fieldDefn.nullable) {
           // Optional + nullable: Option<Option<T>>
           fieldType = `Option<Option<${fieldType}>>`
           if (isMapRepr) {
@@ -166,6 +186,19 @@ export function generateRust (schema) {
       }
 
       typesrc += '}\n\n'
+
+      // Generate default functions for implicit fields
+      for (const { fieldType, implicitValue, defaultFnName } of implicitFields) {
+        typesrc += `fn ${defaultFnName}() -> ${fieldType} {\n`
+        if (typeof implicitValue === 'string') {
+          typesrc += `    "${implicitValue}".to_string()\n`
+        } else if (typeof implicitValue === 'boolean') {
+          typesrc += `    ${implicitValue}\n`
+        } else if (typeof implicitValue === 'number') {
+          typesrc += `    ${implicitValue}\n`
+        }
+        typesrc += '}\n\n'
+      }
     } else if ('list' in typeDefn) {
       // Handle top-level list type definitions
       if (typeof typeDefn.list.valueType !== 'string') {

lib/gen/typescript.js

@@ -37,8 +37,18 @@ export function generateTypeScript (schema) {
       /** @type {string[]} */
       const fieldValidators = []
       let requiredFieldCount = 0
+      const isMapRepr = !typeDefn.struct.representation || 'map' in typeDefn.struct.representation
       for (let [fieldName, fieldDefn] of Object.entries(typeDefn.struct.fields)) {
-        if (!fieldDefn.optional) {
+        // Check if field has implicit value
+        let hasImplicit = false
+        if (isMapRepr && typeDefn.struct.representation && 'map' in typeDefn.struct.representation &&
+            typeDefn.struct.representation.map.fields &&
+            fieldName in typeDefn.struct.representation.map.fields &&
+            'implicit' in typeDefn.struct.representation.map.fields[fieldName]) {
+          hasImplicit = true
+        }
+
+        if (!fieldDefn.optional && !hasImplicit) {
           requiredFieldCount++
         }
         /** @type { { [k in string]: string }[]} */
@@ -118,12 +128,23 @@ export function generateTypeScript (schema) {
           }
         }
         fieldName = fixTypeScriptName(annotations, fieldName)
-        // Handle optional and nullable fields
-        if (fieldDefn.optional && fieldDefn.nullable) {
+
+        // Check for implicit field value (reuse hasImplicit from above)
+        hasImplicit = false
+        const origFieldName = Object.keys(typeDefn.struct.fields)[Object.values(typeDefn.struct.fields).indexOf(fieldDefn)]
+        if (isMapRepr && typeDefn.struct.representation && 'map' in typeDefn.struct.representation &&
+            typeDefn.struct.representation.map.fields &&
+            origFieldName in typeDefn.struct.representation.map.fields &&
+            'implicit' in typeDefn.struct.representation.map.fields[origFieldName]) {
+          hasImplicit = true
+        }
+
+        // Handle optional and nullable fields (implicit fields are also optional)
+        if ((fieldDefn.optional || hasImplicit) && fieldDefn.nullable) {
           // Both optional and nullable
           typesrc += `  ${fieldName}?: ${fieldType} | null${linecomment}\n`
-        } else if (fieldDefn.optional) {
-          // Just optional
+        } else if (fieldDefn.optional || hasImplicit) {
+          // Just optional (or has implicit value)
           typesrc += `  ${fieldName}?: ${fieldType}${linecomment}\n`
         } else if (fieldDefn.nullable) {
           // Just nullable - field is required but can be null
@@ -132,7 +153,7 @@ export function generateTypeScript (schema) {
           // Required field
           typesrc += `  ${fieldName}: ${fieldType}${linecomment}\n`
         }
-        const inCheck = !fieldDefn.optional ? `'${fieldName}' in value &&` : `!('${fieldName}' in value) ||`
+        const inCheck = !fieldDefn.optional && !hasImplicit ? `'${fieldName}' in value &&` : `!('${fieldName}' in value) ||`
         if (isMap) {
           const kind = fixTypeScriptType(imports, '@ipld/schema/schema-schema.js#KindMap', false)
           let valueType = getTypeScriptType([], mapValueType)
@@ -157,7 +178,7 @@ export function generateTypeScript (schema) {
             fieldValidators.push(`      (${inCheck} (${fieldDefn.nullable ? `value.${fieldName} === null || ` : ''}(Array.isArray(value.${fieldName}) && value.${fieldName}.every(${elementType}.is${elementType}))))`)
           }
         } else {
-          fieldValidators.push(`      (${inCheck} (${fieldDefn.nullable ? `value.${fieldName} === null || ` : ''}(${fieldType}.is${fieldType}(value.${fieldName}))))`)
+          fieldValidators.push(`      (${inCheck} ${fieldDefn.nullable ? `value.${fieldName} === null || ` : ''}(${fieldType}.is${fieldType}(value.${fieldName})))`)
         }
       }
 

test/fixtures/gen/filecoin_miner_types.md

@@ -211,9 +211,9 @@ export namespace RecoveryDeclaration {
     }
     const keyCount = Object.keys(value).length
     return keyCount === 3 &&
-      ('Deadline' in value && ((KindInt.isKindInt(value.Deadline)))) &&
-      ('Partition' in value && ((KindInt.isKindInt(value.Partition)))) &&
-      ('Sectors' in value && ((KindBytes.isKindBytes(value.Sectors))))
+      ('Deadline' in value && (KindInt.isKindInt(value.Deadline))) &&
+      ('Partition' in value && (KindInt.isKindInt(value.Partition))) &&
+      ('Sectors' in value && (KindBytes.isKindBytes(value.Sectors)))
   }
 }
 
@@ -248,9 +248,9 @@ export namespace FaultDeclaration {
     }
     const keyCount = Object.keys(value).length
     return keyCount === 3 &&
-      ('Deadline' in value && ((KindInt.isKindInt(value.Deadline)))) &&
-      ('Partition' in value && ((KindInt.isKindInt(value.Partition)))) &&
-      ('Sectors' in value && ((KindBytes.isKindBytes(value.Sectors))))
+      ('Deadline' in value && (KindInt.isKindInt(value.Deadline))) &&
+      ('Partition' in value && (KindInt.isKindInt(value.Partition))) &&
+      ('Sectors' in value && (KindBytes.isKindBytes(value.Sectors)))
   }
 }
 
@@ -286,13 +286,13 @@ export namespace ReplicaUpdate {
     }
     const keyCount = Object.keys(value).length
     return keyCount === 7 &&
-      ('SectorNumber' in value && ((KindInt.isKindInt(value.SectorNumber)))) &&
-      ('Deadline' in value && ((KindInt.isKindInt(value.Deadline)))) &&
-      ('Partition' in value && ((KindInt.isKindInt(value.Partition)))) &&
-      ('NewSealedSectorCID' in value && ((KindLink.isKindLink(value.NewSealedSectorCID)))) &&
+      ('SectorNumber' in value && (KindInt.isKindInt(value.SectorNumber))) &&
+      ('Deadline' in value && (KindInt.isKindInt(value.Deadline))) &&
+      ('Partition' in value && (KindInt.isKindInt(value.Partition))) &&
+      ('NewSealedSectorCID' in value && (KindLink.isKindLink(value.NewSealedSectorCID))) &&
       ('Deals' in value && ((Array.isArray(value.Deals) && value.Deals.every(KindInt.isKindInt)))) &&
-      ('UpdateProofType' in value && ((KindInt.isKindInt(value.UpdateProofType)))) &&
-      ('ReplicaProof' in value && ((KindBytes.isKindBytes(value.ReplicaProof))))
+      ('UpdateProofType' in value && (KindInt.isKindInt(value.UpdateProofType))) &&
+      ('ReplicaProof' in value && (KindBytes.isKindBytes(value.ReplicaProof)))
   }
 }
 ```

test/fixtures/gen/implicits.md

@@ -0,0 +1,200 @@
+# Implicit Field Values
+
+Testing implicit field values in map representation structs.
+
+[testmark]:# (test/schema)
+```ipldsch
+type Config struct {
+  version Int (implicit 1)
+  enabled Bool (implicit false)
+  name String
+  timeout Int (implicit 30)
+  debug Bool
+} representation map
+
+type ServerConfig struct {
+  host String (implicit "localhost")
+  port Int (implicit 8080)
+  secure Bool (implicit true)
+  path String
+} representation map
+
+type Defaults struct {
+  stringVal String (implicit "default")
+  intVal Int (implicit 42)
+  boolVal Bool (implicit true)
+} representation map
+```
+
+[testmark]:# (test/golang)
+```go
+package main
+
+type Config struct {
+	version int64
+	enabled bool
+	name string
+	timeout int64
+	debug bool
+}
+
+type ServerConfig struct {
+	host string
+	port int64
+	secure bool
+	path string
+}
+
+type Defaults struct {
+	stringVal string
+	intVal int64
+	boolVal bool
+}
+```
+
+[testmark]:# (test/rust)
+```rust
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct Config {
+    #[serde(default = "default_config_version")]
+    pub version: i64,
+    #[serde(default = "default_config_enabled")]
+    pub enabled: bool,
+    pub name: String,
+    #[serde(default = "default_config_timeout")]
+    pub timeout: i64,
+    pub debug: bool,
+}
+
+fn default_config_version() -> i64 {
+    1
+}
+
+fn default_config_enabled() -> bool {
+    false
+}
+
+fn default_config_timeout() -> i64 {
+    30
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct ServerConfig {
+    #[serde(default = "default_serverconfig_host")]
+    pub host: String,
+    #[serde(default = "default_serverconfig_port")]
+    pub port: i64,
+    #[serde(default = "default_serverconfig_secure")]
+    pub secure: bool,
+    pub path: String,
+}
+
+fn default_serverconfig_host() -> String {
+    "localhost".to_string()
+}
+
+fn default_serverconfig_port() -> i64 {
+    8080
+}
+
+fn default_serverconfig_secure() -> bool {
+    true
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct Defaults {
+    #[serde(default = "default_defaults_string_val")]
+    pub string_val: String,
+    #[serde(default = "default_defaults_int_val")]
+    pub int_val: i64,
+    #[serde(default = "default_defaults_bool_val")]
+    pub bool_val: bool,
+}
+
+fn default_defaults_string_val() -> String {
+    "default".to_string()
+}
+
+fn default_defaults_int_val() -> i64 {
+    42
+}
+
+fn default_defaults_bool_val() -> bool {
+    true
+}
+```
+
+[testmark]:# (test/typescript)
+```typescript
+import {
+  KindBool,
+  KindInt,
+  KindMap,
+  KindString,
+} from '@ipld/schema/schema-schema.js'
+
+export type Config = {
+  version?: KindInt
+  enabled?: KindBool
+  name: KindString
+  timeout?: KindInt
+  debug: KindBool
+}
+
+export namespace Config {
+  export function isConfig(value: any): value is Config {
+    if (!KindMap.isKindMap(value)) {
+      return false
+    }
+    const keyCount = Object.keys(value).length
+    return keyCount >= 2 && keyCount <= 5 &&
+      (!('version' in value) || (KindInt.isKindInt(value.version))) &&
+      (!('enabled' in value) || (KindBool.isKindBool(value.enabled))) &&
+      ('name' in value && (KindString.isKindString(value.name))) &&
+      (!('timeout' in value) || (KindInt.isKindInt(value.timeout))) &&
+      ('debug' in value && (KindBool.isKindBool(value.debug)))
+  }
+}
+
+export type ServerConfig = {
+  host?: KindString
+  port?: KindInt
+  secure?: KindBool
+  path: KindString
+}
+
+export namespace ServerConfig {
+  export function isServerConfig(value: any): value is ServerConfig {
+    if (!KindMap.isKindMap(value)) {
+      return false
+    }
+    const keyCount = Object.keys(value).length
+    return keyCount >= 1 && keyCount <= 4 &&
+      (!('host' in value) || (KindString.isKindString(value.host))) &&
+      (!('port' in value) || (KindInt.isKindInt(value.port))) &&
+      (!('secure' in value) || (KindBool.isKindBool(value.secure))) &&
+      ('path' in value && (KindString.isKindString(value.path)))
+  }
+}
+
+export type Defaults = {
+  stringVal?: KindString
+  intVal?: KindInt
+  boolVal?: KindBool
+}
+
+export namespace Defaults {
+  export function isDefaults(value: any): value is Defaults {
+    if (!KindMap.isKindMap(value)) {
+      return false
+    }
+    const keyCount = Object.keys(value).length
+    return keyCount >= 0 && keyCount <= 3 &&
+      (!('stringVal' in value) || (KindString.isKindString(value.stringVal))) &&
+      (!('intVal' in value) || (KindInt.isKindInt(value.intVal))) &&
+      (!('boolVal' in value) || (KindBool.isKindBool(value.boolVal)))
+  }
+}
+```