fix(gen): kinded unions

Author: rvagg

lib/gen/go.js

@@ -121,6 +121,10 @@ 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) {
+          fieldType = '*' + fieldType
+        }
         typesrc += `\t${fieldName} ${fieldType}${gotag}${linecomment}\n`
       }
 
@@ -129,7 +133,7 @@ export function generateGo (schema, options = {}) {
       // Add union methods for this struct if it's a union member
       if (unionMethods.has(typeName)) {
         for (const unionType of unionMethods.get(typeName) || []) {
-          typesrc += `func (${typeName}) is${unionType}() {}\n\n`
+          typesrc += `func (${typeName}) ${unionType.charAt(0).toLowerCase() + unionType.slice(1)}() {}\n\n`
         }
       }
     } else if ('list' in typeDefn) {
@@ -219,15 +223,34 @@ export function generateGo (schema, options = {}) {
         typesrc += ')\n\n'
       }
     } else if ('union' in typeDefn) {
-      if (!typeDefn.union.representation || !('keyed' in typeDefn.union.representation)) {
-        // For now, only support keyed unions
+      if (!typeDefn.union.representation) {
         continue
       }
 
-      // Generate interface for the union
-      typesrc += `type ${typeName} interface {\n`
-      typesrc += `\tis${typeName}()\n`
-      typesrc += '}\n\n'
+      if ('keyed' in typeDefn.union.representation) {
+        // Generate interface for the union
+        typesrc += `type ${typeName} interface {\n`
+        typesrc += `\t${typeName.charAt(0).toLowerCase() + typeName.slice(1)}()\n`
+        typesrc += '}\n\n'
+      } else if ('kinded' in typeDefn.union.representation) {
+        // Generate interface for the union
+        typesrc += `type ${typeName} interface {\n`
+        typesrc += `\t${typeName.charAt(0).toLowerCase() + typeName.slice(1)}()\n`
+        typesrc += '}\n\n'
+
+        // Generate wrapper types for each kind
+        for (const [, memberType] of Object.entries(typeDefn.union.representation.kinded)) {
+          // Generate wrapper type
+          let goType = memberType
+          // Check if memberType is a basic IPLD type
+          if (['Bool', 'Int', 'Float', 'String', 'Bytes', 'Link'].includes(memberType)) {
+            goType = getGoType([], memberType)
+            goType = fixGoType(imports, goType, false)
+          }
+          typesrc += `type ${typeName}_${memberType} ${goType}\n`
+          typesrc += `func (${typeName}_${memberType}) ${typeName.charAt(0).toLowerCase() + typeName.slice(1)}() {}\n\n`
+        }
+      }
     }
   }
 

lib/gen/rust.js

@@ -122,6 +122,10 @@ export function generateRust (schema) {
           }
         }
         fieldName = fixRustName(annotations, fieldName)
+        // Handle nullable fields
+        if (fieldDefn.nullable) {
+          fieldType = `Option<${fieldType}>`
+        }
         typesrc += `    pub ${fieldName}: ${fieldType},${linecomment}\n`
       }
 
@@ -219,23 +223,44 @@ export function generateRust (schema) {
         typesrc += '}\n\n'
       }
     } else if ('union' in typeDefn) {
-      if (!typeDefn.union.representation || !('keyed' in typeDefn.union.representation)) {
-        // For now, only support keyed unions
+      if (!typeDefn.union.representation) {
         continue
       }
 
-      // Generate Rust enum for keyed union
-      typesrc += '#[derive(Deserialize, Serialize)]\n'
-      typesrc += '#[serde(tag = "type")]\n'
-      typesrc += `pub enum ${typeName} {\n`
+      if ('keyed' in typeDefn.union.representation) {
+        // Generate Rust enum for keyed union
+        typesrc += '#[derive(Deserialize, Serialize)]\n'
+        typesrc += '#[serde(tag = "type")]\n'
+        typesrc += `pub enum ${typeName} {\n`
 
-      // Generate enum variants
-      for (const [discriminant, memberType] of Object.entries(typeDefn.union.representation.keyed)) {
-        typesrc += `    #[serde(rename = "${discriminant}")]\n`
-        typesrc += `    ${memberType}(${memberType}),\n`
-      }
+        // Generate enum variants
+        for (const [discriminant, memberType] of Object.entries(typeDefn.union.representation.keyed)) {
+          typesrc += `    #[serde(rename = "${discriminant}")]\n`
+          typesrc += `    ${memberType}(${memberType}),\n`
+        }
 
-      typesrc += '}\n\n'
+        typesrc += '}\n\n'
+      } else if ('kinded' in typeDefn.union.representation) {
+        // Generate Rust enum for kinded union
+        typesrc += '#[derive(Deserialize, Serialize)]\n'
+        typesrc += '#[serde(untagged)]\n'
+        typesrc += `pub enum ${typeName} {\n`
+
+        // Generate enum variants based on kind
+        for (const [, memberType] of Object.entries(typeDefn.union.representation.kinded)) {
+          if (typeof memberType === 'string') {
+            let rustType = memberType
+            // Check if memberType is a basic IPLD type
+            if (['Bool', 'Int', 'Float', 'String', 'Bytes', 'Link'].includes(memberType)) {
+              rustType = getRustType([], memberType)
+              rustType = fixRustType(imports, rustType, false)
+            }
+            typesrc += `    ${memberType}(${rustType}),\n`
+          }
+        }
+
+        typesrc += '}\n\n'
+      }
     }
   }
 

lib/gen/typescript.js

@@ -24,7 +24,7 @@ export function generateTypeScript (schema) {
       const fieldValidators = []
       let requiredFieldCount = 0
       for (let [fieldName, fieldDefn] of Object.entries(typeDefn.struct.fields)) {
-        if (!fieldDefn.optional && !fieldDefn.optional) {
+        if (!fieldDefn.optional && !fieldDefn.nullable) {
           requiredFieldCount++
         }
         /** @type { { [k in string]: string }[]} */
@@ -104,8 +104,13 @@ export function generateTypeScript (schema) {
           }
         }
         fieldName = fixTypeScriptName(annotations, fieldName)
-        typesrc += `  ${fieldName}${fieldDefn.optional ? '?' : ''}: ${fieldType}${linecomment}\n`
-        const inCheck = !fieldDefn.optional && !fieldDefn.optional ? `'${fieldName}' in value &&` : `!('${fieldName}' in value) ||`
+        // Handle nullable fields - they become optional with | null
+        if (fieldDefn.nullable) {
+          typesrc += `  ${fieldName}?: ${fieldType} | null${linecomment}\n`
+        } else {
+          typesrc += `  ${fieldName}${fieldDefn.optional ? '?' : ''}: ${fieldType}${linecomment}\n`
+        }
+        const inCheck = !fieldDefn.optional && !fieldDefn.nullable ? `'${fieldName}' in value &&` : `!('${fieldName}' in value) ||`
         if (isMap) {
           const kind = fixTypeScriptType(imports, '@ipld/schema/schema-schema.js#KindMap', false)
           let valueType = getTypeScriptType([], mapValueType)
@@ -253,16 +258,22 @@ export function generateTypeScript (schema) {
         typesrc += '  }\n'
         typesrc += '}\n\n'
       } else if ('kinded' in typeDefn.union.representation) {
-        if (typeDefn.union.members.some((member) => typeof member !== 'string')) {
-          throw new Error('Unhandled union member type(s): ' + JSON.stringify(typeDefn.union.members))
+        // Generate union types based on kinded representation
+        const unionTypes = []
+        const typeChecks = []
+
+        for (const [, memberType] of Object.entries(typeDefn.union.representation.kinded)) {
+          if (typeof memberType === 'string') {
+            const tsType = fixTypeScriptType(imports, getTypeScriptType([], memberType), false)
+            unionTypes.push(tsType)
+            typeChecks.push(`${tsType}.is${tsType}(value)`)
+          }
         }
-        const kinds = typeDefn.union.members.map((member) => {
-          return fixTypeScriptType(imports, getTypeScriptType([], String(member)), false)
-        })
-        typesrc += `export type ${typeName} = ${kinds.join(' | ')}\n\n`
+
+        typesrc += `export type ${typeName} = ${unionTypes.join(' | ')}\n\n`
         typesrc += `export namespace ${typeName} {\n`
         typesrc += `  export function is${typeName}(value: any): value is ${typeName} {\n`
-        typesrc += `    return ${kinds.map((kind) => `${kind}.is${kind}(value)`).join(' || ')}\n`
+        typesrc += `    return ${typeChecks.join(' || ')}\n`
         typesrc += '  }\n'
         typesrc += '}\n\n'
       } else {

test/fixtures/gen/unions-keyed.md

@@ -79,39 +79,39 @@ type DeleteResult struct {
 package main
 
 type SimpleResult interface {
-	isSimpleResult()
+	simpleResult()
 }
 
 type Success struct {
 	value string
 	code int64
 }
 
-func (Success) isSimpleResult() {}
+func (Success) simpleResult() {}
 
 type Error struct {
 	message string
 	code int64
 }
 
-func (Error) isSimpleResult() {}
+func (Error) simpleResult() {}
 
 type ProveCommitResult interface {
-	isProveCommitResult()
+	proveCommitResult()
 }
 
 type ProveCommitSectors3Return struct {
 	results []PoStProof
 }
 
-func (ProveCommitSectors3Return) isProveCommitResult() {}
+func (ProveCommitSectors3Return) proveCommitResult() {}
 
 type ProveCommitAggregateReturn struct {
 	aggregateProof []byte
 	sectorNumbers []int64
 }
 
-func (ProveCommitAggregateReturn) isProveCommitResult() {}
+func (ProveCommitAggregateReturn) proveCommitResult() {}
 
 type PoStProof struct {
 	postProof int64
@@ -125,29 +125,29 @@ type Transaction struct {
 }
 
 type OperationResult interface {
-	isOperationResult()
+	operationResult()
 }
 
 type CreateResult struct {
 	id string
 	resource SimpleResult
 }
 
-func (CreateResult) isOperationResult() {}
+func (CreateResult) operationResult() {}
 
 type UpdateResult struct {
 	id string
 	changes int64
 }
 
-func (UpdateResult) isOperationResult() {}
+func (UpdateResult) operationResult() {}
 
 type DeleteResult struct {
 	id string
 	confirmed bool
 }
 
-func (DeleteResult) isOperationResult() {}
+func (DeleteResult) operationResult() {}
 ```
 
 ## Expected Rust output