test: 💍

feat: 🎸 rename "field" node to "key"

Author: streamich

README.md

@@ -206,15 +206,15 @@ interface NumberSchema {
   format?: 'i' | 'u' | 'f' | 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64' | 'f32' | 'f64';
   gt?: number;      // Greater than (exclusive)
   gte?: number;     // Greater than or equal to
-  lt?: number;      // Less than (exclusive) 
+  lt?: number;      // Less than (exclusive)
   lte?: number;     // Less than or equal to
   validator?: string | string[];
 }
 ```
 
 **Format options:**
 - `i*` - Signed integers (i8, i16, i32, i64)
-- `u*` - Unsigned integers (u8, u16, u32, u64)  
+- `u*` - Unsigned integers (u8, u16, u32, u64)
 - `f*` - Floating point (f32, f64)
 
 **Examples:**
@@ -234,7 +234,7 @@ interface StringSchema {
   ascii?: boolean;                   // @deprecated Use format: 'ascii'
   noJsonEscape?: boolean;            // Skip JSON escaping for performance
   min?: number;                      // Minimum length
-  max?: number;                      // Maximum length  
+  max?: number;                      // Maximum length
   validator?: string | string[];
 }
 ```
@@ -269,7 +269,7 @@ s.Binary(s.Object(), {format: 'cbor'})      // CBOR-encoded object
 
 ### Composite Types
 
-#### ArraySchema (`arr`)  
+#### ArraySchema (`arr`)
 Represents a JSON array with elements of a specific type.
 
 ```ts
@@ -310,9 +310,9 @@ Represents a JSON object with defined fields.
 ```ts
 interface ObjectSchema {
   kind: 'obj';
-  fields: ObjectFieldSchema[];       // Defined object fields
-  unknownFields?: boolean;           // @deprecated Allow undefined fields  
-  encodeUnknownFields?: boolean;     // Include unknown fields in output
+  keys: ObjectKeydSchema[];       // Defined object keys
+  decodeUnknownKeys?: boolean;
+  encodeUnknownKeys?: boolean;
   validator?: string | string[];
 }
 ```
@@ -325,12 +325,12 @@ s.Object([
 ])
 ```
 
-#### ObjectFieldSchema (`field`)
+#### ObjectKeySchema (`key`)
 Represents a single field in an object.
 
 ```ts
-interface ObjectFieldSchema {
-  kind: 'field';
+interface ObjectKeydSchema {
+  kind: 'key';
   key: string;                       // Field name
   type: TType;                       // Field value type
   optional?: boolean;                // Whether field is optional
@@ -340,7 +340,7 @@ interface ObjectFieldSchema {
 **Examples:**
 ```ts
 s.prop('id', s.String())             // Required field
-s.propOpt('description', s.String()) // Optional field  
+s.propOpt('description', s.String()) // Optional field
 ```
 
 #### MapSchema (`map`)
@@ -350,7 +350,7 @@ Represents an object treated as a map with string keys and uniform value types.
 interface MapSchema {
   kind: 'map';
   type: TType;                       // Type of all values
-  validator?: string | string[];  
+  validator?: string | string[];
 }
 ```
 
@@ -379,7 +379,7 @@ s.Const(42 as const)                 // Constant number
 s.Const(null)                        // Null constant
 ```
 
-#### RefSchema (`ref`)  
+#### RefSchema (`ref`)
 References another type by ID.
 
 ```ts
@@ -413,7 +413,7 @@ s.Or(s.String(), s.Number())         // String or number
 #### FunctionSchema (`fn`)
 Represents a function type with request and response.
 
-```ts  
+```ts
 interface FunctionSchema {
   kind: 'fn';
   req: TType;                        // Request type
@@ -432,7 +432,7 @@ Represents a streaming function type.
 ```ts
 interface FunctionStreamingSchema {
   kind: 'fn$';
-  req: TType;                        // Request stream type  
+  req: TType;                        // Request stream type
   res: TType;                        // Response stream type
 }
 ```
@@ -449,17 +449,17 @@ All node types extend the base `TType` interface with these common properties:
 ```ts
 interface TType {
   kind: string;                      // Node type identifier
-  
+
   // Display properties
   title?: string;                    // Human-readable title
   intro?: string;                    // Short description
   description?: string;              // Long description (may include Markdown)
-  
+
   // Metadata
   id?: string;                       // Unique identifier
   meta?: Record<string, unknown>;    // Custom metadata
   examples?: TExample[];             // Usage examples
-  
+
   // Deprecation
   deprecated?: {
     description?: string;            // Deprecation reason and alternative
@@ -475,7 +475,7 @@ Many types support custom validation through the `validator` property:
 // Single validator
 { validator: 'email' }
 
-// Multiple validators  
+// Multiple validators
 { validator: ['required', 'email'] }
 ```
 

SPECIFICATION.md

@@ -32,7 +32,7 @@ A simple user type:
 {
   "kind": "obj",
   "title": "User",
-  "fields": [
+  "keys": [
     { "kind": "field", "key": "id", "type": { "kind": "str" }, "title": "User ID" },
     { "kind": "field", "key": "name", "type": { "kind": "str" } },
     { "kind": "field", "key": "age", "type": { "kind": "num", "gte": 0 }, "optional": true }
@@ -246,9 +246,9 @@ Represents a fixed-length array, each position with its own type.
 Represents a JSON object with a defined set of fields. `obj` fields are ordered and can be required or optional. Optional fields are usually defined at the end of the `fields` array. Even if in many languages objects are unordered, the order of fields in the schema is a useful feature as the field order can be used in documentation, code generation, and serialization to binary formats.
 
 **Properties:**
-- `fields` (array): Array of field nodes (see below).
-- `unknownFields` (boolean, deprecated): Allow fields not listed.
-- `encodeUnknownFields` (boolean): Emit unknown fields during encoding.
+- `keys` (array): Array of field nodes (see below).
+- `decodeUnknownKeys` (boolean, deprecated): Allow fields not listed.
+- `encodeUnknownKeys` (boolean): Emit unknown fields during encoding.
 - `validator` (string or array): Custom validation.
 
 **Example:**
@@ -467,7 +467,7 @@ All nodes may contain the following metadata:
 - **Type inference:** Types can be mapped to language types using the structure.
 - **Optional and required fields:** Fields are required by default; set `optional: true` for optional fields.
 - **Type composition:** Types can be nested and composed arbitrarily.
-- **Unknown fields:** By default, unknown fields are rejected. Use `unknownFields: true` or `encodeUnknownFields: true` to allow or preserve them.
+- **Unknown fields:** By default, unknown fields are rejected. Use `decodeUnknownKeys: true` or `encodeUnknownKeys: true` to allow or preserve them.
 
 ---
 

src/__demos__/json-type.ts

@@ -119,7 +119,7 @@ console.log('Can compile a fast validator, which returns booleans as errors:');
 console.log();
 const validator = user.type.compileValidator({
   errors: 'boolean',
-  skipObjectExtraFieldsCheck: true,
+  skipObjectExtraKeysCheck: true,
 });
 console.log(validator.toString());
 
@@ -128,7 +128,7 @@ console.log('Can compile a fast validator, which returns JSON strings as errors:
 console.log();
 const validator2 = user.type.compileValidator({
   errors: 'string',
-  skipObjectExtraFieldsCheck: true,
+  skipObjectExtraKeysCheck: true,
 });
 console.log(validator2.toString());
 
@@ -137,6 +137,6 @@ console.log('Can compile a fast validator, which returns objects as errors:');
 console.log();
 const validator3 = user.type.compileValidator({
   errors: 'object',
-  skipObjectExtraFieldsCheck: true,
+  skipObjectExtraKeysCheck: true,
 });
 console.log(validator3.toString());

src/__demos__/samples.ts

@@ -43,7 +43,7 @@ export const types = {
       s.prop(
         'meta',
         s.Object([], {
-          unknownFields: true,
+          decodeUnknownKeys: true,
         }),
       ),
     ],

src/codegen/binary/__tests__/testBinaryCodegen.ts

@@ -289,7 +289,7 @@ export const testBinaryCodegen = (transcode: (system: TypeSystem, type: Type, va
       const t = system.t;
       const type = t
         .Object(t.prop('id', t.str), t.propOpt('name', t.str), t.prop('age', t.num), t.propOpt('address', t.str))
-        .options({encodeUnknownFields: true});
+        .options({encodeUnknownKeys: true});
       const value: any = {
         id: 'xxxxx',
         name: 'Go Lang',
@@ -313,7 +313,7 @@ export const testBinaryCodegen = (transcode: (system: TypeSystem, type: Type, va
             t.Object(t.propOpt('hobbies', t.Array(t.str)), t.propOpt('sports', t.Array(t.Tuple([t.num, t.str])))),
           ),
         )
-        .options({encodeUnknownFields: true});
+        .options({encodeUnknownKeys: true});
       const decoded = transcode(system, type, {
         id: 'xxxxx',
         name: 'Go Lang',
@@ -353,7 +353,7 @@ export const testBinaryCodegen = (transcode: (system: TypeSystem, type: Type, va
       const t = system.t;
       const type = t
         .Object(t.propOpt('id', t.str), t.propOpt('name', t.str), t.propOpt('address', t.str))
-        .options({encodeUnknownFields: true});
+        .options({encodeUnknownKeys: true});
       let value: any = {
         id: 'xxxxx',
         name: 'Go Lang',
@@ -380,7 +380,7 @@ export const testBinaryCodegen = (transcode: (system: TypeSystem, type: Type, va
       const t = system.t;
       const type = t
         .Object(t.propOpt('id', t.str), t.propOpt('name', t.str), t.propOpt('address', t.str))
-        .options({encodeUnknownFields: false});
+        .options({encodeUnknownKeys: false});
       let value: any = {
         id: 'xxxxx',
         name: 'Go Lang',
@@ -550,7 +550,7 @@ export const testBinaryCodegen = (transcode: (system: TypeSystem, type: Type, va
     test('supports "encodeUnknownFields" property', () => {
       const system = new TypeSystem();
       const t = system.t;
-      const type = t.Object(t.prop('a', t.Object().options({encodeUnknownFields: true})));
+      const type = t.Object(t.prop('a', t.Object().options({encodeUnknownKeys: true})));
       const value = {
         a: {
           foo: 123,

src/codegen/binary/cbor copy/CborCodegen.ts

@@ -0,0 +1,85 @@
+import {AbstractBinaryCodegen} from '../AbstractBinaryCodegen';
+import {writer} from '../writer';
+import {JsExpression} from '@jsonjoy.com/codegen/lib/util/JsExpression';
+import {CborEncoder} from '@jsonjoy.com/json-pack/lib/cbor/CborEncoder';
+import {lazyKeyedFactory} from '../../util';
+import {ObjKeyOptType, type MapType, type ObjType, type Type} from '../../../type';
+import type {CompiledBinaryEncoder, SchemaPath} from '../../types';
+import {normalizeAccessor} from '@jsonjoy.com/codegen/lib/util/normalizeAccessor';
+
+export class CborCodegen extends AbstractBinaryCodegen<CborEncoder> {
+  public static readonly get = lazyKeyedFactory((type: Type, name?: string) => {
+    const codegen = new CborCodegen(type, name);
+    const r = codegen.codegen.options.args[0];
+    const expression = new JsExpression(() => r);
+    codegen.onNode([], expression, type);
+    return codegen.compile();
+  });
+
+  protected encoder = new CborEncoder(writer);
+
+  protected onObj(path: SchemaPath, value: JsExpression, type: ObjType): void {
+    const codegen = this.codegen;
+    const r = codegen.r();
+    const fields = type.keys;
+    const length = fields.length;
+    const requiredFields = fields.filter((field) => !(field instanceof ObjKeyOptType));
+    const optionalFields = fields.filter((field) => field instanceof ObjKeyOptType);
+    const requiredLength = requiredFields.length;
+    const optionalLength = optionalFields.length;
+    const encodeUnknownFields = !!type.schema.encodeUnknownKeys;
+    const emitRequiredFields = () => {
+      for (let i = 0; i < requiredLength; i++) {
+        const field = requiredFields[i];
+        this.blob(this.gen((encoder) => encoder.writeStr(field.key)));
+        const accessor = normalizeAccessor(field.key);
+        this.onNode([...path, field.key], new JsExpression(() => `${r}${accessor}`), field.val);
+      }
+    };
+    const emitOptionalFields = () => {
+      for (let i = 0; i < optionalLength; i++) {
+        const field = optionalFields[i];
+        const accessor = normalizeAccessor(field.key);
+        codegen.js(`if (${JSON.stringify(field.key)} in ${r}) {`);
+        this.blob(this.gen((encoder) => encoder.writeStr(field.key)));
+        this.onNode([...path, field.key], new JsExpression(() => `${r}${accessor}`), field.val);
+        codegen.js(`}`);
+      }
+    };
+    const emitUnknownFields = () => {
+      const rKeys = codegen.r();
+      const rKey = codegen.r();
+      const ri = codegen.r();
+      const rLength = codegen.r();
+      const keys = fields.map((field) => JSON.stringify(field.key));
+      const rKnownFields = codegen.addConstant(`new Set([${keys.join(',')}])`);
+      codegen.js(`var ${rKeys} = Object.keys(${r}), ${rLength} = ${rKeys}.length, ${rKey};`);
+      codegen.js(`for (var ${ri} = 0; ${ri} < ${rLength}; ${ri}++) {`);
+      codegen.js(`${rKey} = ${rKeys}[${ri}];`);
+      codegen.js(`if (${rKnownFields}.has(${rKey})) continue;`);
+      codegen.js(`encoder.writeStr(${rKey});`);
+      codegen.js(`encoder.writeAny(${r}[${rKey}]);`);
+      codegen.js(`}`);
+    };
+    codegen.js(/* js */ `var ${r} = ${value.use()};`);
+    if (!encodeUnknownFields && !optionalLength) {
+      this.blob(this.gen((encoder) => encoder.writeObjHdr(length)));
+      emitRequiredFields();
+    } else if (!encodeUnknownFields) {
+      this.blob(this.gen((encoder) => encoder.writeStartObj()));
+      emitRequiredFields();
+      emitOptionalFields();
+      this.blob(this.gen((encoder) => encoder.writeEndObj()));
+    } else {
+      this.blob(this.gen((encoder) => encoder.writeStartObj()));
+      emitRequiredFields();
+      emitOptionalFields();
+      emitUnknownFields();
+      this.blob(this.gen((encoder) => encoder.writeEndObj()));
+    }
+  }
+
+  protected genEncoder(type: Type): CompiledBinaryEncoder {
+    return CborCodegen.get(type);
+  }
+}

src/codegen/binary/cbor/CborCodegen.ts

@@ -21,13 +21,13 @@ export class CborCodegen extends AbstractBinaryCodegen<CborEncoder> {
   protected onObj(path: SchemaPath, value: JsExpression, type: ObjType): void {
     const codegen = this.codegen;
     const r = codegen.r();
-    const fields = type.fields;
+    const fields = type.keys;
     const length = fields.length;
     const requiredFields = fields.filter((field) => !(field instanceof ObjKeyOptType));
     const optionalFields = fields.filter((field) => field instanceof ObjKeyOptType);
     const requiredLength = requiredFields.length;
     const optionalLength = optionalFields.length;
-    const encodeUnknownFields = !!type.schema.encodeUnknownFields;
+    const encodeUnknownFields = !!type.schema.encodeUnknownKeys;
     const emitRequiredFields = () => {
       for (let i = 0; i < requiredLength; i++) {
         const field = requiredFields[i];

src/codegen/binary/cbor/__tests__/fuzzing.spec.ts

@@ -9,7 +9,7 @@ const encoder = new CborEncoder(new Writer(16));
 const decoder = new CborDecoder();
 
 test('can encode random values', () => {
-  for (let i = 0; i < 100; i++) {
+  for (let i = 0; i < 10; i++) {
     const json = randomJson();
     const t = new TypeBuilder();
     const type = t.from(json);

src/codegen/binary/json/JsonCodegen.ts

@@ -97,12 +97,12 @@ export class JsonCodegen extends AbstractBinaryCodegen<JsonEncoder> {
   protected onObj(path: SchemaPath, value: JsExpression, type: ObjType): void {
     const codegen = this.codegen;
     const r = codegen.var(value.use());
-    const fields = type.fields;
+    const fields = type.keys;
     const requiredFields = fields.filter((field) => !(field instanceof ObjKeyOptType));
     const optionalFields = fields.filter((field) => field instanceof ObjKeyOptType);
     const requiredLength = requiredFields.length;
     const optionalLength = optionalFields.length;
-    const encodeUnknownFields = !!type.schema.encodeUnknownFields;
+    const encodeUnknownFields = !!type.schema.encodeUnknownKeys;
     const separatorBlob = this.gen((encoder) => encoder.writeObjSeparator());
     const keySeparatorBlob = this.gen((encoder) => encoder.writeObjKeySeparator());
     const endBlob = this.gen((encoder) => encoder.writeEndObj());

src/codegen/binary/msgpack/MsgPackCodegen.ts

@@ -21,15 +21,15 @@ export class MsgPackCodegen extends AbstractBinaryCodegen<MsgPackEncoder> {
   protected onObj(path: SchemaPath, value: JsExpression, type: ObjType): void {
     const codegen = this.codegen;
     const r = codegen.r();
-    const fields = type.fields;
+    const fields = type.keys;
     const length = fields.length;
     const requiredFields = fields.filter((field) => !(field instanceof ObjKeyOptType));
     const optionalFields = fields.filter((field) => field instanceof ObjKeyOptType);
     const requiredLength = requiredFields.length;
     const optionalLength = optionalFields.length;
     const totalMaxKnownFields = requiredLength + optionalLength;
     if (totalMaxKnownFields > 0xffff) throw new Error('Too many fields');
-    const encodeUnknownFields = !!type.schema.encodeUnknownFields;
+    const encodeUnknownFields = !!type.schema.encodeUnknownKeys;
     const rFieldCount = codegen.r();
     const emitRequiredFields = () => {
       for (let i = 0; i < requiredLength; i++) {