Merge pull request #66 from IntersectMBO/fix/tschema-field-order

fix/tschema field order

Author: solidsnakedev

.changeset/chilly-brooms-end.md

@@ -0,0 +1,64 @@
+---
+"@evolution-sdk/evolution": patch
+---
+
+Fixed field ordering bug in TSchema.Struct encode function that caused fields to be swapped during CBOR encoding when using NullOr/UndefinedOr.
+
+**Before:**
+```typescript
+const CredentialSchema = TSchema.Union(
+  TSchema.Struct({ pubKeyHash: TSchema.ByteArray }, { flatFields: true }),
+  TSchema.Struct({ scriptHash: TSchema.ByteArray }, { flatFields: true })
+)
+
+const AddressSchema = TSchema.Struct({
+  paymentCredential: CredentialSchema,
+  stakeCredential: TSchema.NullOr(TSchema.Integer)
+})
+
+const Foo = TSchema.Union(
+  TSchema.Struct({ foo: AddressSchema }, { flatFields: true })
+)
+
+const input = {
+  foo: {
+    paymentCredential: { pubKeyHash: fromHex("deadbeef") },
+    stakeCredential: null
+  }
+}
+
+const encoded = Data.withSchema(Foo).toData(input)
+// BUG: Fields were swapped in innerStruct!
+// innerStruct.fields[0] = Constr(1, [])      // stakeCredential (null) - WRONG!
+// innerStruct.fields[1] = Constr(0, [...])   // paymentCredential - WRONG!
+```
+
+**After:**
+```typescript
+const CredentialSchema = TSchema.Union(
+  TSchema.Struct({ pubKeyHash: TSchema.ByteArray }, { flatFields: true }),
+  TSchema.Struct({ scriptHash: TSchema.ByteArray }, { flatFields: true })
+)
+
+const AddressSchema = TSchema.Struct({
+  paymentCredential: CredentialSchema,
+  stakeCredential: TSchema.NullOr(TSchema.Integer)
+})
+
+const Foo = TSchema.Union(
+  TSchema.Struct({ foo: AddressSchema }, { flatFields: true })
+)
+
+const input = {
+  foo: {
+    paymentCredential: { pubKeyHash: fromHex("deadbeef") },
+    stakeCredential: null
+  }
+}
+
+const encoded = Data.withSchema(Foo).toData(input)
+// FIXED: Fields now in correct order matching schema!
+// innerStruct.fields[0] = Constr(0, [...])   // paymentCredential - CORRECT!
+// innerStruct.fields[1] = Constr(1, [])      // stakeCredential (null) - CORRECT!
+```
+

docs/content/docs/modules/core/TSchema.mdx

@@ -100,9 +100,9 @@ while maintaining single-level CBOR encoding compatible with Aiken.
 **Signature**
 
 ```ts
-export declare const Variant: <Variants extends Record<string, Schema.Struct.Fields>>(
+export declare const Variant: <const Variants extends Record<PropertyKey, Schema.Struct.Fields>>(
   variants: Variants
-) => Schema.Schema<VariantType<Variants>, Data.Data, never>
+) => Union<ReadonlyArray<{ [K in keyof Variants]: Struct<{ readonly [P in K]: Struct<Variants[K]> }> }[keyof Variants]>>
 ```
 
 Added in v2.0.0

docs/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./out/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

packages/evolution/docs/modules/core/TSchema.ts.md

@@ -100,15 +100,9 @@ while maintaining single-level CBOR encoding compatible with Aiken.
 **Signature**
 
 ```ts
-export declare function Variant<const Variants extends Record<PropertyKey, Schema.Struct.Fields>>(
+export declare const Variant: <const Variants extends Record<PropertyKey, Schema.Struct.Fields>>(
   variants: Variants
-): Union<
-  ReadonlyArray<
-    {
-      [K in keyof Variants]: Struct<{ readonly [P in K]: Struct<Variants[K]> }>
-    }[keyof Variants]
-  >
->
+) => Union<ReadonlyArray<{ [K in keyof Variants]: Struct<{ readonly [P in K]: Struct<Variants[K]> }> }[keyof Variants]>>
 ```
 
 Added in v2.0.0
@@ -303,10 +297,10 @@ Objects are represented as a constructor with index (default 0) and fields as an
 **Signature**
 
 ```ts
-export declare function Struct<Fields extends Schema.Struct.Fields>(
+export declare const Struct: <Fields extends Schema.Struct.Fields>(
   fields: Fields,
-  options: StructOptions = {}
-): Struct<Fields>
+  options?: StructOptions
+) => Struct<Fields>
 ```
 
 Added in v2.0.0

packages/evolution/src/core/TSchema.ts

@@ -280,10 +280,10 @@ export interface StructOptions {
  *
  * @since 2.0.0
  */
-export function Struct<Fields extends Schema.Struct.Fields>(
+export const Struct = <Fields extends Schema.Struct.Fields>(
   fields: Fields,
   options: StructOptions = {}
-): Struct<Fields> {
+): Struct<Fields> => {
   const { flatFields, flatInUnion, index = 0, tagField } = options
 
   // flatInUnion defaults to true when index is specified
@@ -325,9 +325,10 @@ export function Struct<Fields extends Schema.Struct.Fields>(
     encode: (encodedStruct) => {
       // encodedStruct is the result of Schema.Struct(fields), which has already transformed all fields
 
-      // Filter out the tag field if detected (it's metadata, not data)
-      const fieldEntries = Object.entries(encodedStruct).filter(([key]) => key !== detectedTagField)
-      const fieldValues = fieldEntries.map(([_, value]) => value) as ReadonlyArray<Data.Data>
+      // Use Object.keys(fields) to preserve schema definition order
+      // rather than Object.entries(encodedStruct) which would use runtime object order
+      const orderedKeys = Object.keys(fields).filter((key) => key !== detectedTagField)
+      const fieldValues = orderedKeys.map((key) => encodedStruct[key as keyof typeof encodedStruct]) as ReadonlyArray<Data.Data>
 
       // Check if any field values are Constrs with flatFields:true
       // If so, spread their fields into this Struct's field array
@@ -793,24 +794,24 @@ export const Tuple = <Elements extends Schema.TupleType.Elements>(element: [...E
  * @since 2.0.0
  * @category constructors
  */
-export function Variant<const Variants extends Record<PropertyKey, Schema.Struct.Fields>>(
+export const Variant = <const Variants extends Record<PropertyKey, Schema.Struct.Fields>>(
   variants: Variants
 ): Union<
   ReadonlyArray<
     {
       [K in keyof Variants]: Struct<{ readonly [P in K]: Struct<Variants[K]> }>
     }[keyof Variants]
   >
-> {
+> => {
   return Union(
-    ...Object.entries(variants).map(([name, fields], index) =>
+    ...(Object.entries(variants).map(([name, fields], index) =>
       Struct(
         {
           [name]: Struct(fields, { flatFields: true })
         } as any,
         { flatInUnion: true, index }
       )
-    ) as any
+    ) as any)
   )
 }
 

packages/evolution/test/TSchema.test.ts

@@ -291,6 +291,43 @@ describe("TypeTaggedSchema Tests", () => {
         expect(encoded).toEqual("d87a80")
         expect(decoded).toBeNull()
       })
+
+      it("should preserve field order in structs with NullOr fields (regression test)", () => {
+        // Regression test for field ordering bug with NullOr/UndefinedOr
+        const CredentialSchema = TSchema.Union(
+          TSchema.Struct({ pubKeyHash: TSchema.ByteArray }, { flatFields: true }),
+          TSchema.Struct({ scriptHash: TSchema.ByteArray }, { flatFields: true })
+        )
+
+        const AddressSchema = TSchema.Struct({
+          paymentCredential: CredentialSchema,
+          stakeCredential: TSchema.NullOr(TSchema.Integer)
+        })
+
+        const Foo = TSchema.Union(
+          TSchema.Struct({ foo: AddressSchema }, { flatFields: true })
+        )
+
+        const input = {
+          foo: {
+            paymentCredential: { pubKeyHash: fromHex("deadbeef") },
+            stakeCredential: null
+          }
+        }
+
+        const encoded = Data.withSchema(Foo).toData(input)
+        const decoded = Data.withSchema(Foo).fromData(encoded)
+
+        // Verify roundtrip
+        expect(decoded).toEqual(input)
+
+        // Verify field order in CBOR: paymentCredential should be field 0, stakeCredential field 1
+        const innerStruct = (encoded.fields[0] as Data.Constr).fields[0] as Data.Constr
+        expect(innerStruct.fields.length).toBe(2)
+        expect(innerStruct.fields[0]).toBeInstanceOf(Data.Constr) // paymentCredential
+        expect(innerStruct.fields[1]).toBeInstanceOf(Data.Constr) // stakeCredential (null)
+        expect((innerStruct.fields[1] as Data.Constr).index).toBe(1n) // null is Constr(1, [])
+      })
     })
 
     describe("Literal Schema", () => {