add 'found' property to getBy

Author: LeCarbonator

packages/form-core/src/FieldGroupApi.ts

@@ -232,14 +232,14 @@ export class FieldGroupApi<
         let values: TFieldGroupData
         if (typeof this.fieldsMap === 'string') {
           // all values live at that name, so we can directly fetch it
-          values = getBy(currFormStore.values, this.fieldsMap)
+          values = getBy(currFormStore.values, this.fieldsMap).value
         } else {
           // we need to fetch the values from all places where they were mapped from
           values = {} as never
           const fields: Record<keyof TFieldGroupData, string> = this
             .fieldsMap as never
           for (const key in fields) {
-            values[key] = getBy(currFormStore.values, fields[key])
+            values[key] = getBy(currFormStore.values, fields[key]).value
           }
         }
 

packages/form-core/src/FormApi.ts

@@ -1000,7 +1000,7 @@ export class FormApi<
           const prevFieldInfo =
             prevVal?.[fieldName as never as keyof typeof prevVal]
 
-          const curFieldVal = getBy(currBaseStore.values, fieldName)
+          const curFieldVal = getBy(currBaseStore.values, fieldName).value
 
           let fieldErrors = prevFieldInfo?.errors
           if (
@@ -1028,7 +1028,7 @@ export class FormApi<
           const isDefaultValue =
             evaluate(
               curFieldVal,
-              getBy(this.options.defaultValues, fieldName),
+              getBy(this.options.defaultValues, fieldName).value,
             ) ||
             evaluate(
               curFieldVal,
@@ -1995,7 +1995,7 @@ export class FormApi<
    */
   getFieldValue = <TField extends DeepKeys<TFormData>>(
     field: TField,
-  ): DeepValue<TFormData, TField> => getBy(this.state.values, field)
+  ): DeepValue<TFormData, TField> => getBy(this.state.values, field).value
 
   /**
    * Gets the metadata of the specified field.
@@ -2323,7 +2323,7 @@ export class FormApi<
           [field]: defaultFieldMeta,
         },
         values: this.options.defaultValues
-          ? setBy(prev.values, field, getBy(this.options.defaultValues, field))
+          ? setBy(prev.values, field, getBy(this.options.defaultValues, field).value)
           : prev.values,
       }
     })

packages/form-core/src/utils.ts

@@ -31,15 +31,21 @@ export function functionalUpdate<TInput, TOutput = TInput>(
  * Get a value from an object using a path, including dot notation.
  * @private
  */
-export function getBy(obj: any, path: any) {
+export function getBy(obj: unknown, path: string | (string | number)[]): { found: boolean; value: any } {
   const pathObj = makePathArray(path)
-  return pathObj.reduce((current: any, pathPart: any) => {
-    if (current === null) return null
-    if (typeof current !== 'undefined') {
-      return current[pathPart]
+  let current: unknown = obj
+  for (const pathPart of pathObj) {
+    // path is trying to access props of undefined/null, so it doesn't exist
+    if (typeof current === 'undefined' || current === null) {
+      return { found: false, value: undefined }
     }
-    return undefined
-  }, obj)
+    if (typeof current === 'object' && (pathPart in current)) {
+      current = current[pathPart as never]
+    } else {
+      return { found: false, value: undefined }
+    }
+  }
+  return { found: true, value: current };
 }
 
 /**

packages/form-core/tests/utils.spec.ts

@@ -21,25 +21,54 @@ describe('getBy', () => {
     mother: {
       name: 'Lisa',
     },
+    siblings: [{
+      name: undefined
+    }]
   }
 
   it('should get subfields by path', () => {
-    expect(getBy(structure, 'name')).toBe(structure.name)
-    expect(getBy(structure, 'mother.name')).toBe(structure.mother.name)
+    const name = getBy(structure, 'name');
+    expect(name.value).toBe(structure.name)
+    expect(name.found).toBe(true)
+
+    const motherName = getBy(structure, 'mother.name');
+    expect(motherName.value).toBe(structure.mother.name)
+    expect(motherName.found).toBe(true)
   })
 
   it('should get array subfields by path', () => {
-    expect(getBy(structure, 'kids[0].name')).toBe(structure.kids[0]!.name)
-    expect(getBy(structure, 'kids[0].age')).toBe(structure.kids[0]!.age)
+    const kidsName = getBy(structure, 'kids[0].name')
+    expect(kidsName.value).toBe(structure.kids[0]!.name)
+    expect(kidsName.found).toBe(true)
+
+    const kidsAge = getBy(structure, 'kids[0].age')
+    expect(kidsAge.value).toBe(structure.kids[0]!.age)
+    expect(kidsAge.found).toBe(true)
   })
 
   it('should get nested array subfields by path', () => {
-    expect(getBy(structure, 'kids[0].hobbies[0]')).toBe(
+    const hobbies0 = getBy(structure, 'kids[0].hobbies[0]');
+    expect(hobbies0.value).toBe(
       structure.kids[0]!.hobbies[0],
     )
-    expect(getBy(structure, 'kids[0].hobbies[1]')).toBe(
+    expect(hobbies0.found).toBe(true)
+
+    const hobbies1 = getBy(structure, 'kids[0].hobbies[1]');
+    expect(hobbies1.value).toBe(
       structure.kids[0]!.hobbies[1],
     )
+    expect(hobbies1.found).toBe(true)
+  })
+
+  it('should differentiate between explicit undefined vs. no path', () => {
+    const sibling0 = getBy(structure, 'siblings[0].name');
+    const sibling1 = getBy(structure, 'siblings[1].name');
+
+    expect(sibling0.value).toBeUndefined()
+    expect(sibling1.value).toBeUndefined()
+
+    expect(sibling0.found).toBe(true)
+    expect(sibling1.found).toBe(false)
   })
 })