Fix remaining references to use new schema field names

Co-authored-by: streamich <[email protected]>

Author: Copilot

src/codegen/capacity/estimators.ts

@@ -142,7 +142,7 @@ export const map = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, t
   const rLen = codegen.var(`${rKeys}.length`);
   codegen.js(`size += ${MaxEncodingOverhead.ObjectElement} * ${rLen}`);
   const mapType = type as any; // MapType
-  const valueType = mapType.type;
+  const valueType = mapType.valueType;
   const fn = valueType.compileCapacityEstimator({
     system: ctx.options.system,
     name: ctx.options.name,

src/json-schema/converter.ts

@@ -204,7 +204,7 @@ function mapToJsonSchema(type: MapType<any>, ctx?: TypeExportContext): JsonSchem
   const result: JsonSchemaObject = {
     type: 'object',
     patternProperties: {
-      '.*': typeToJsonSchema((type as any).type, ctx),
+      '.*': typeToJsonSchema((type as any).valueType, ctx),
     },
   };
 

src/random/generators.ts

@@ -54,7 +54,7 @@ export const map = (type: MapType<any>): Record<string, unknown> => {
   const length = Math.round(Math.random() * 10);
   const res: Record<string, unknown> = {};
   for (let i = 0; i < length; i++) {
-    res[RandomJson.genString(length)] = (type as any).type.random();
+    res[RandomJson.genString(length)] = (type as any).valueType.random();
   }
   return res;
 };

src/schema/validate.ts

@@ -162,12 +162,15 @@ const validateFieldSchema = (schema: any, validateChildSchema: (schema: Schema)
   const {key, optional} = schema;
   if (typeof key !== 'string') throw new Error('KEY_TYPE');
   if (optional !== undefined && typeof optional !== 'boolean') throw new Error('OPTIONAL_TYPE');
-  validateChildSchema(schema.type);
+  validateChildSchema(schema.value);
 };
 
 const validateMapSchema = (schema: any, validateChildSchema: (schema: Schema) => void): void => {
   validateTType(schema, 'map');
-  validateChildSchema(schema.type);
+  validateChildSchema(schema.value);
+  if (schema.key) {
+    validateChildSchema(schema.key);
+  }
 };
 
 const validateRefSchema = (schema: any): void => {

src/type/__tests__/TypeBuilder.spec.ts

@@ -155,10 +155,10 @@ describe('import()', () => {
     expect(type.getSchema()).toStrictEqual({
       kind: 'obj',
       fields: [
-        {kind: 'field', key: 'id', type: {kind: 'str'}},
-        {kind: 'field', key: 'name', type: {kind: 'str'}, optional: true},
-        {kind: 'field', key: 'age', type: {kind: 'num'}, optional: true},
-        {kind: 'field', key: 'verified', type: {kind: 'bool'}},
+        {kind: 'field', key: 'id', value: {kind: 'str'}},
+        {kind: 'field', key: 'name', value: {kind: 'str'}, optional: true},
+        {kind: 'field', key: 'age', value: {kind: 'num'}, optional: true},
+        {kind: 'field', key: 'verified', value: {kind: 'bool'}},
       ],
     });
   });
@@ -253,7 +253,7 @@ describe('validateSchema()', () => {
         {
           kind: 'field',
           key: 'id',
-          type: {kind: 'str', ascii: 'bytes'} as any,
+          value: {kind: 'str', ascii: 'bytes'} as any,
         },
       ],
     });
@@ -269,7 +269,7 @@ describe('validateSchema()', () => {
           kind: 'field',
           key: 'id',
           optional: 123,
-          type: {kind: 'str'},
+          value: {kind: 'str'},
         } as any,
       ],
     });

src/type/classes/__tests__/BinType.spec.ts

@@ -2,28 +2,28 @@ import {t} from '../../..';
 
 test('can use convenience methods to define type schema fields', () => {
   const binary = t.bin;
-  expect(binary.getSchema()).toEqual({kind: 'bin', value: {kind: 'any'}});
+  expect(binary.getSchema()).toEqual({kind: 'bin', type: {kind: 'any'}});
   binary.title('My Binary');
-  expect(binary.getSchema()).toEqual({kind: 'bin', value: {kind: 'any'}, title: 'My Binary'});
+  expect(binary.getSchema()).toEqual({kind: 'bin', type: {kind: 'any'}, title: 'My Binary'});
   binary.intro('This is a binary type');
   expect(binary.getSchema()).toEqual({
     kind: 'bin',
-    value: {kind: 'any'},
+    type: {kind: 'any'},
     title: 'My Binary',
     intro: 'This is a binary type',
   });
   binary.description('A detailed description of the binary type');
   expect(binary.getSchema()).toEqual({
     kind: 'bin',
-    value: {kind: 'any'},
+    type: {kind: 'any'},
     title: 'My Binary',
     intro: 'This is a binary type',
     description: 'A detailed description of the binary type',
   });
   binary.format('json');
   expect(binary.getSchema()).toEqual({
     kind: 'bin',
-    value: {kind: 'any'},
+    type: {kind: 'any'},
     title: 'My Binary',
     intro: 'This is a binary type',
     description: 'A detailed description of the binary type',
@@ -32,7 +32,7 @@ test('can use convenience methods to define type schema fields', () => {
   binary.min(5);
   expect(binary.getSchema()).toEqual({
     kind: 'bin',
-    value: {kind: 'any'},
+    type: {kind: 'any'},
     title: 'My Binary',
     intro: 'This is a binary type',
     description: 'A detailed description of the binary type',
@@ -42,7 +42,7 @@ test('can use convenience methods to define type schema fields', () => {
   binary.max(10);
   expect(binary.getSchema()).toEqual({
     kind: 'bin',
-    value: {kind: 'any'},
+    type: {kind: 'any'},
     title: 'My Binary',
     intro: 'This is a binary type',
     description: 'A detailed description of the binary type',
@@ -53,7 +53,7 @@ test('can use convenience methods to define type schema fields', () => {
   binary.default(new Uint8Array([1, 2, 3]));
   expect(binary.getSchema()).toEqual({
     kind: 'bin',
-    value: {kind: 'any'},
+    type: {kind: 'any'},
     title: 'My Binary',
     intro: 'This is a binary type',
     description: 'A detailed description of the binary type',
@@ -65,7 +65,7 @@ test('can use convenience methods to define type schema fields', () => {
   binary.example(new Uint8Array([4, 5, 6]), 'Example Binary', {description: 'An example binary value'});
   expect(binary.getSchema()).toEqual({
     kind: 'bin',
-    value: {kind: 'any'},
+    type: {kind: 'any'},
     title: 'My Binary',
     intro: 'This is a binary type',
     description: 'A detailed description of the binary type',