From 3f8d2cba5748a47a92eb85e6b8c96fc35b74fdd3 Mon Sep 17 00:00:00 2001
From: Davide Bassi <davide.bassi314@gmail.com>
Date: Sun, 10 Aug 2025 11:45:02 +0200
Subject: [PATCH 1/2] feat: anonymous fields dictionary for Schema constructor

---
 src/factories.ts | 15 ++++++++++++++-
 src/schema.ts    | 19 +++++++++++++++++--
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/src/factories.ts b/src/factories.ts
index 657ae1b9..fbbc3eba 100644
--- a/src/factories.ts
+++ b/src/factories.ts
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-import { Field, Schema } from './schema.js';
+import { AnonymousField, Field, Schema } from './schema.js';
 import * as dtypes from './type.js';
 import { Data, DataProps } from './data.js';
 import { BuilderType, JavaScriptDataType } from './interfaces.js';
@@ -270,3 +270,16 @@ export function builderThroughAsyncIterable<T extends dtypes.DataType = any, TNu
         }
     } as ThroughAsyncIterable<T, TNull>;
 }
+
+/**
+ * Helper factory to create a type-safe anonymous field.
+ * @param type The type of the field
+ * @param nullable Whether the field is nullable
+ * @param metadata Optional metadata for the field
+ * @returns An anonymous field to be used in a [FieldDictionary]{@link FieldDictionary}
+ */
+export const anonymousField = <T extends dtypes.DataType>(
+    type: T,
+    nullable?: boolean,
+    metadata?: Map<string, string>
+) => ({ type, nullable, metadata }) as AnonymousField<T>;
diff --git a/src/schema.ts b/src/schema.ts
index 2eb33b78..3a1d5e7a 100644
--- a/src/schema.ts
+++ b/src/schema.ts
@@ -26,11 +26,16 @@ export class Schema<T extends TypeMap = any> {
     public readonly metadataVersion: MetadataVersion;
 
     constructor(
-        fields: Field<T[keyof T]>[] = [],
+        fields: Field<T[keyof T]>[] | FieldDictionary<T> = [],
         metadata?: Map<string, string> | null,
         dictionaries?: Map<number, DataType> | null,
         metadataVersion = MetadataVersion.V5) {
-        this.fields = (fields || []) as Field<T[keyof T]>[];
+        if (Array.isArray(fields)) {
+            this.fields = fields as Field<T[keyof T]>[];
+        } else {
+            const entries = Object.entries(fields);
+            this.fields = entries.map(([name, field]) => new Field(name, field.type, field.nullable, field.metadata));
+        }
         this.metadata = metadata || new Map();
         if (!dictionaries) {
             dictionaries = generateDictionaryMap(this.fields);
@@ -177,3 +182,13 @@ function generateDictionaryMap(fields: Field[], dictionaries = new Map<number, D
 
     return dictionaries;
 }
+
+export type AnonymousField<T extends DataType> = {
+    readonly type: T;
+    readonly nullable?: boolean;
+    readonly metadata?: Map<string, string>;
+}
+
+export type FieldDictionary<T extends TypeMap> = {
+    [name in keyof T]: AnonymousField<T[name]>;
+}

From b20df1ffc1b4d55abfbfc066b6e4c9818cd2349d Mon Sep 17 00:00:00 2001
From: Davide Bassi <davide.bassi314@gmail.com>
Date: Sun, 10 Aug 2025 11:59:48 +0200
Subject: [PATCH 2/2] fix: default Schema fields arg to empty object

This should help with the "objectification" of fields.
---
 src/schema.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/schema.ts b/src/schema.ts
index 3a1d5e7a..ddfb48e9 100644
--- a/src/schema.ts
+++ b/src/schema.ts
@@ -26,7 +26,7 @@ export class Schema<T extends TypeMap = any> {
     public readonly metadataVersion: MetadataVersion;
 
     constructor(
-        fields: Field<T[keyof T]>[] | FieldDictionary<T> = [],
+        fields: Field<T[keyof T]>[] | FieldDictionary<T> = {} as FieldDictionary<T>,
         metadata?: Map<string, string> | null,
         dictionaries?: Map<number, DataType> | null,
         metadataVersion = MetadataVersion.V5) {