Refactor Schema utility functions such as omit, pick, and partial to preserve the recursive capability of ObjectType, while adding a required utility function. (#198)

* refactor(farrow-schema): enhance Utilities with pick, omit, partial, and required functionalities with preserve the recursive capability of ObjectType

* test(farrow-schema): Based on the test results, some problematic code has been modified, and relevant tests for the required utility function have been added.

Author: AisonSu

packages/farrow-schema/__tests__/formatter.test.ts

@@ -19,10 +19,11 @@ import {
   ReadOnly,
   ReadOnlyDeep,
   Tuple,
+  Optional,
 } from '../src/schema'
 
 import { formatSchema } from '../src/formatter'
-import { partial } from '../src/helper'
+import { partial, required } from '../src/helper'
 
 describe('Formatter', () => {
   it('supports format Number', () => {
@@ -729,12 +730,11 @@ describe('Formatter', () => {
 
     const result0 = formatSchema(PartialUser)
     const result1 = formatSchema(PartialPerson)
-
     expect(result0).toEqual({
       typeId: 0,
       types: {
         '0': {
-          type: 'Struct',
+          type: 'Object',
           fields: {
             name: {
               typeId: 2,
@@ -782,7 +782,6 @@ describe('Formatter', () => {
         },
       },
     })
-
     expect(result1).toEqual({
       typeId: 0,
       types: {
@@ -822,4 +821,92 @@ describe('Formatter', () => {
       },
     })
   })
+  it('support format required struct/object', () => {
+    class User extends ObjectType {
+      name = String
+      friends = Optional(List(User))
+    }
+    const Person = Struct({
+      name: Optional(String),
+      age: Int,
+    })
+
+    const result0 = formatSchema(required(User))
+    const result1 = formatSchema(required(Person))
+    expect(result0).toEqual({
+      typeId: 0,
+      types: {
+        '0': {
+          type: 'Object',
+          fields: {
+            name: {
+              typeId: 1,
+              $ref: '#/types/1',
+            },
+            friends: {
+              typeId: 3,
+              $ref: '#/types/3',
+            },
+          },
+        },
+        '1': {
+          type: 'Scalar',
+          valueType: 'string',
+          valueName: 'String',
+        },
+        '2': {
+          type: 'Object',
+          name: 'User',
+          fields: {
+            name: {
+              typeId: 1,
+              $ref: '#/types/1',
+            },
+            friends: {
+              typeId: 4,
+              $ref: '#/types/4',
+            },
+          },
+        },
+        '3': {
+          type: 'List',
+          itemTypeId: 2,
+          $ref: '#/types/2',
+        },
+        '4': {
+          type: 'Optional',
+          itemTypeId: 3,
+          $ref: '#/types/3',
+        },
+      },
+    })
+    expect(result1).toEqual({
+      typeId: 0,
+      types: {
+        '0': {
+          type: 'Struct',
+          fields: {
+            name: {
+              typeId: 1,
+              $ref: '#/types/1',
+            },
+            age: {
+              typeId: 2,
+              $ref: '#/types/2',
+            },
+          },
+        },
+        '1': {
+          type: 'Scalar',
+          valueType: 'string',
+          valueName: 'String',
+        },
+        '2': {
+          type: 'Scalar',
+          valueType: 'number',
+          valueName: 'Int',
+        },
+      },
+    })
+  })
 })

packages/farrow-schema/__tests__/validator.test.ts

@@ -1,7 +1,15 @@
 import * as Schema from '../src/schema'
 import { ReadOnly, TypeOf, ReadOnlyDeep, Optional } from '../src/schema'
-import { createSchemaValidator, RegExp, ValidationError, ValidationResult, Validator, ValidatorType } from '../src/validator'
-import { pick, omit, keyof, partial } from '../src/helper'
+import {
+  createSchemaValidator,
+  RegExp,
+  ValidationError,
+  ValidationResult,
+  Validator,
+  ValidatorType,
+} from '../src/validator'
+import { pick, omit, keyof, partial, required } from '../src/helper'
+import { formatSchema } from '../src/formatter'
 
 const {
   Type,
@@ -271,28 +279,28 @@ describe('Validator', () => {
           b: '1',
           c: false,
           d: [1, 2, 3],
-          e: 'abc'
+          e: 'abc',
         }),
       ),
     ).toEqual({
       a: 1,
       b: '1',
       c: false,
       d: [1, 2, 3],
-      e: 'abc'
+      e: 'abc',
     })
 
-       // field e is not optional
-       expect(
-        assertErr(
-          validate({
-            a: 1,
-            b: '1',
-            c: false,
-            d: [1, 2, 3],
-          }),
-        ),
-      ).toEqual(true)
+    // field e is not optional
+    expect(
+      assertErr(
+        validate({
+          a: 1,
+          b: '1',
+          c: false,
+          d: [1, 2, 3],
+        }),
+      ),
+    ).toEqual(true)
 
     expect(
       assertOk(
@@ -1223,4 +1231,38 @@ describe('Validator', () => {
     expect(assertOk(Validator.validate(PartialPerson, { name: 'only-name' }))).toEqual({ name: 'only-name' })
     expect(assertOk(Validator.validate(PartialPerson, { name: 'name', age: 1 }))).toEqual({ name: 'name', age: 1 })
   })
+  it('support required operator', () => {
+    class User extends ObjectType {
+      name = String
+      friends = Optional(List(User))
+    }
+    const Person = Struct({
+      name: String,
+      age: Optional(Int),
+    })
+    const PersonRequired = required(Person)
+    const UserRequired = required(User)
+    expect(assertOk(Validator.validate(User, { name: 'optional' }))).toEqual({
+      name: 'optional',
+    })
+    expect(
+      assertOk(
+        Validator.validate(Person, {
+          name: 'optional',
+        }),
+      ),
+    ).toEqual({
+      name: 'optional',
+    })
+    expect(assertErr(Validator.validate(PersonRequired, { name: 'optional' }))).toBe(true)
+    expect(assertErr(Validator.validate(UserRequired, { name: 'optional' }))).toBe(true)
+    expect(assertOk(Validator.validate(PersonRequired, { name: 'required', age: 1 }))).toEqual({
+      name: 'required',
+      age: 1,
+    })
+    expect(assertOk(Validator.validate(UserRequired, { name: 'required', friends: [{ name: 'required' }] }))).toEqual({
+      name: 'required',
+      friends: [{ name: 'required' }],
+    })
+  })
 })

packages/farrow-schema/src/formatter.ts

@@ -441,7 +441,9 @@ Formatter.impl(S.ObjectType, (schema) => {
 
       return ctx.addType({
         type: 'Object',
-        name: Constructor.displayName ?? Constructor.name,
+        // if keep 'Constructor.displayName ?? Constructor.name', it will be 'PartialObject' or 'RequiredObject' with partial function, although we can name it with displayName like 'PartialUser' using Ctor.name in the function, However, in scenarios where tool functions are nested, the default naming might be confusing or troublesome.
+        // @ts-ignore
+        name: Constructor.displayName ?? (Constructor.name === 'PartialObject' || Constructor.name === 'RequiredObject' ? undefined : Constructor.name),
         namespace: Constructor.namespace,
         get fields() {
           return getFields()