feat(gen): optionals

Author: rvagg

lib/gen/go.js

@@ -40,6 +40,20 @@ export function generateGo (schema, options = {}) {
   // Second pass: generate types with proper ordering
   for (const [typeName, typeDefn] of Object.entries(schema.types)) {
     if ('struct' in typeDefn) {
+      // Validate optional fields for tuple representation
+      if (typeDefn.struct.representation && 'tuple' in typeDefn.struct.representation) {
+        const fields = Object.entries(typeDefn.struct.fields)
+        let foundOptional = false
+        for (const [fieldName, fieldDefn] of fields) {
+          if (foundOptional && !fieldDefn.optional) {
+            throw new Error(`Struct "${typeName}": optional field must be at the end when using tuple representation, but field "${fieldName}" is required after optional fields`)
+          }
+          if (fieldDefn.optional) {
+            foundOptional = true
+          }
+        }
+      }
+
       typesrc += `type ${typeName} struct {\n`
 
       for (let [fieldName, fieldDefn] of Object.entries(typeDefn.struct.fields)) {
@@ -121,8 +135,8 @@ export function generateGo (schema, options = {}) {
         }
         fieldName = fixGoName(annotations, fieldName)
         const gotag = annotations.reduce((acc, a) => 'gotag' in a ? ' ' + a.gotag : acc, '')
-        // Handle nullable fields by making them pointers
-        if (fieldDefn.nullable) {
+        // Handle nullable and optional fields by making them pointers
+        if (fieldDefn.nullable || fieldDefn.optional) {
           fieldType = '*' + fieldType
         }
         typesrc += `\t${fieldName} ${fieldType}${gotag}${linecomment}\n`

lib/gen/rust.js

@@ -14,6 +14,20 @@ export function generateRust (schema) {
   let typesrc = ''
   for (const [typeName, typeDefn] of Object.entries(schema.types)) {
     if ('struct' in typeDefn) {
+      // Validate optional fields for tuple representation
+      if (typeDefn.struct.representation && 'tuple' in typeDefn.struct.representation) {
+        const fields = Object.entries(typeDefn.struct.fields)
+        let foundOptional = false
+        for (const [fieldName, fieldDefn] of fields) {
+          if (foundOptional && !fieldDefn.optional) {
+            throw new Error(`Struct "${typeName}": optional field must be at the end when using tuple representation, but field "${fieldName}" is required after optional fields`)
+          }
+          if (fieldDefn.optional) {
+            foundOptional = true
+          }
+        }
+      }
+
       /** @type {string[]} */
       const derive = []
       if ('representation' in typeDefn.struct && typeof typeDefn.struct.representation === 'object' && 'tuple' in typeDefn.struct.representation) {
@@ -122,10 +136,32 @@ export function generateRust (schema) {
           }
         }
         fieldName = fixRustName(annotations, fieldName)
-        // Handle nullable fields
-        if (fieldDefn.nullable) {
+
+        // Handle optional and nullable fields
+        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) {
+          // Optional + nullable: Option<Option<T>>
+          fieldType = `Option<Option<${fieldType}>>`
+          if (isMapRepr) {
+            typesrc += '    #[serde(skip_serializing_if = "Option::is_none")]\n'
+          } else if (isTupleRepr) {
+            typesrc += '    #[serde(default)]\n'
+          }
+        } else if (fieldDefn.optional) {
+          // Just optional: Option<T>
+          fieldType = `Option<${fieldType}>`
+          if (isMapRepr) {
+            typesrc += '    #[serde(skip_serializing_if = "Option::is_none")]\n'
+          } else if (isTupleRepr) {
+            typesrc += '    #[serde(default)]\n'
+          }
+        } else if (fieldDefn.nullable) {
+          // Just nullable: Option<T> but always serialize
           fieldType = `Option<${fieldType}>`
         }
+
         typesrc += `    pub ${fieldName}: ${fieldType},${linecomment}\n`
       }
 

lib/gen/typescript.js

@@ -18,13 +18,27 @@ export function generateTypeScript (schema) {
     }
     const typeKind = Object.keys(typeDefn)[0]
     if ('struct' in typeDefn) {
+      // Validate optional fields for tuple representation
+      if (typeDefn.struct.representation && 'tuple' in typeDefn.struct.representation) {
+        const fields = Object.entries(typeDefn.struct.fields)
+        let foundOptional = false
+        for (const [fieldName, fieldDefn] of fields) {
+          if (foundOptional && !fieldDefn.optional) {
+            throw new Error(`Struct "${typeName}": optional field must be at the end when using tuple representation, but field "${fieldName}" is required after optional fields`)
+          }
+          if (fieldDefn.optional) {
+            foundOptional = true
+          }
+        }
+      }
+
       typesrc += `export type ${typeName} = {\n`
 
       /** @type {string[]} */
       const fieldValidators = []
       let requiredFieldCount = 0
       for (let [fieldName, fieldDefn] of Object.entries(typeDefn.struct.fields)) {
-        if (!fieldDefn.optional && !fieldDefn.nullable) {
+        if (!fieldDefn.optional) {
           requiredFieldCount++
         }
         /** @type { { [k in string]: string }[]} */
@@ -104,13 +118,21 @@ export function generateTypeScript (schema) {
           }
         }
         fieldName = fixTypeScriptName(annotations, fieldName)
-        // Handle nullable fields - they become optional with | null
-        if (fieldDefn.nullable) {
+        // Handle optional and nullable fields
+        if (fieldDefn.optional && fieldDefn.nullable) {
+          // Both optional and nullable
           typesrc += `  ${fieldName}?: ${fieldType} | null${linecomment}\n`
+        } else if (fieldDefn.optional) {
+          // Just optional
+          typesrc += `  ${fieldName}?: ${fieldType}${linecomment}\n`
+        } else if (fieldDefn.nullable) {
+          // Just nullable - field is required but can be null
+          typesrc += `  ${fieldName}: ${fieldType} | null${linecomment}\n`
         } else {
-          typesrc += `  ${fieldName}${fieldDefn.optional ? '?' : ''}: ${fieldType}${linecomment}\n`
+          // Required field
+          typesrc += `  ${fieldName}: ${fieldType}${linecomment}\n`
         }
-        const inCheck = !fieldDefn.optional && !fieldDefn.nullable ? `'${fieldName}' in value &&` : `!('${fieldName}' in value) ||`
+        const inCheck = !fieldDefn.optional ? `'${fieldName}' in value &&` : `!('${fieldName}' in value) ||`
         if (isMap) {
           const kind = fixTypeScriptType(imports, '@ipld/schema/schema-schema.js#KindMap', false)
           let valueType = getTypeScriptType([], mapValueType)

test/fixtures/gen/optionals.md

@@ -0,0 +1,178 @@
+# Optional Fields Code Generation Tests
+
+This file tests optional field code generation for Go, Rust, and TypeScript.
+
+## Schema
+
+[testmark]:# (test/schema)
+```ipldsch
+# Struct with optional fields in map representation
+type User struct {
+  id String
+  name String
+  email optional String
+  age optional Int
+  verified Bool
+}
+
+# Struct with nullable and optional fields
+type Profile struct {
+  userId String
+  bio optional nullable String
+  avatar optional String
+  lastLogin nullable Int
+}
+
+# Struct with optional fields at end for tuple representation
+type TupleData struct {
+  required1 String
+  required2 Int
+  optional1 optional String
+  optional2 optional Bool
+} representation tuple
+```
+
+## Expected Go output
+
+[testmark]:# (test/golang)
+```go
+package main
+
+type User struct {
+	id string
+	name string
+	email *string
+	age *int64
+	verified bool
+}
+
+type Profile struct {
+	userId string
+	bio *string
+	avatar *string
+	lastLogin *int64
+}
+
+type TupleData struct {
+	required1 string
+	required2 int64
+	optional1 *string
+	optional2 *bool
+}
+```
+
+## Expected Rust output
+
+[testmark]:# (test/rust)
+```rust
+use serde::{Deserialize, Serialize};
+use serde_tuple::{Deserialize_tuple, Serialize_tuple};
+
+#[derive(Deserialize, Serialize)]
+pub struct User {
+    pub id: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub email: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub age: Option<i64>,
+    pub verified: bool,
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Profile {
+    pub user_id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bio: Option<Option<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub avatar: Option<String>,
+    pub last_login: Option<i64>,
+}
+
+#[derive(Deserialize_tuple, Serialize_tuple)]
+pub struct TupleData {
+    pub required1: String,
+    pub required2: i64,
+    #[serde(default)]
+    pub optional1: Option<String>,
+    #[serde(default)]
+    pub optional2: Option<bool>,
+}
+```
+
+## Expected TypeScript output
+
+[testmark]:# (test/typescript)
+```typescript
+import {
+  KindBool,
+  KindInt,
+  KindMap,
+  KindString,
+} from '@ipld/schema/schema-schema.js'
+
+export type User = {
+  id: KindString
+  name: KindString
+  email?: KindString
+  age?: KindInt
+  verified: KindBool
+}
+
+export namespace User {
+  export function isUser(value: any): value is User {
+    if (!KindMap.isKindMap(value)) {
+      return false
+    }
+    const keyCount = Object.keys(value).length
+    return keyCount >= 3 && keyCount <= 5 &&
+      ('id' in value && ((KindString.isKindString(value.id)))) &&
+      ('name' in value && ((KindString.isKindString(value.name)))) &&
+      (!('email' in value) || ((KindString.isKindString(value.email)))) &&
+      (!('age' in value) || ((KindInt.isKindInt(value.age)))) &&
+      ('verified' in value && ((KindBool.isKindBool(value.verified))))
+  }
+}
+
+export type Profile = {
+  userId: KindString
+  bio?: KindString | null
+  avatar?: KindString
+  lastLogin: KindInt | null
+}
+
+export namespace Profile {
+  export function isProfile(value: any): value is Profile {
+    if (!KindMap.isKindMap(value)) {
+      return false
+    }
+    const keyCount = Object.keys(value).length
+    return keyCount >= 2 && keyCount <= 4 &&
+      ('userId' in value && ((KindString.isKindString(value.userId)))) &&
+      (!('bio' in value) || (value.bio === null || (KindString.isKindString(value.bio)))) &&
+      (!('avatar' in value) || ((KindString.isKindString(value.avatar)))) &&
+      ('lastLogin' in value && (value.lastLogin === null || (KindInt.isKindInt(value.lastLogin))))
+  }
+}
+
+export type TupleData = {
+  required1: KindString
+  required2: KindInt
+  optional1?: KindString
+  optional2?: KindBool
+}
+
+export namespace TupleData {
+  export function isTupleData(value: any): value is TupleData {
+    if (!KindMap.isKindMap(value)) {
+      return false
+    }
+    const keyCount = Object.keys(value).length
+    return keyCount >= 2 && keyCount <= 4 &&
+      ('required1' in value && ((KindString.isKindString(value.required1)))) &&
+      ('required2' in value && ((KindInt.isKindInt(value.required2)))) &&
+      (!('optional1' in value) || ((KindString.isKindString(value.optional1)))) &&
+      (!('optional2' in value) || ((KindBool.isKindBool(value.optional2))))
+  }
+}
+```

test/fixtures/gen/unions-kinded.md

@@ -229,7 +229,7 @@ export namespace ListConfig {
 
 export type Settings = {
   name: KindString
-  config?: ConfigValue | null
+  config: ConfigValue | null
 }
 
 export namespace Settings {
@@ -238,9 +238,9 @@ export namespace Settings {
       return false
     }
     const keyCount = Object.keys(value).length
-    return keyCount >= 1 && keyCount <= 2 &&
+    return keyCount === 2 &&
       ('name' in value && ((KindString.isKindString(value.name)))) &&
-      (!('config' in value) || (value.config === null || (ConfigValue.isConfigValue(value.config))))
+      ('config' in value && (value.config === null || (ConfigValue.isConfigValue(value.config))))
   }
 }
 ```

test/test-gen.js

@@ -181,3 +181,32 @@ describe('Generate kinded union types', () => {
     assert.strictEqual(ts, expectedTypeScript)
   })
 })
+
+describe('Generate optional fields', () => {
+  let schema, expectedGo, expectedRust, expectedTypeScript
+
+  before(async () => {
+    const contents = await readFile(new URL('./fixtures/gen/optionals.md', import.meta.url), 'utf8')
+    const dirEnt = index(parse(contents))
+    const schemaText = dirEnt.children.get('test').children.get('schema').hunk.body
+    schema = fromDSL(schemaText, { includeComments: true, includeAnnotations: true })
+    expectedGo = dirEnt.children.get('test').children.get('golang').hunk.body
+    expectedRust = dirEnt.children.get('test').children.get('rust').hunk.body
+    expectedTypeScript = dirEnt.children.get('test').children.get('typescript').hunk.body
+  })
+
+  it('Go', async () => {
+    const go = generateGo(schema, { package: 'main' })
+    assert.strictEqual(go, expectedGo)
+  })
+
+  it('Rust', async () => {
+    const rust = generateRust(schema)
+    assert.strictEqual(rust, expectedRust)
+  })
+
+  it('TypeScript', async () => {
+    const ts = generateTypeScript(schema)
+    assert.strictEqual(ts, expectedTypeScript)
+  })
+})