@dxos/echo 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/src/internal/object/schema-validator.ts

@@ -2,241 +2,5 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-import { invariant } from '@dxos/invariant';
-
-import { SchemaId } from '../types';
-
-// TODO(burdon): Reconcile with @dxos/effect visit().
-
-export class SchemaValidator {
-  /**
-   * Recursively check that schema specifies constructions we can handle.
-   * Validates there are no ambiguous discriminated union types.
-   */
-  public static validateSchema(schema: Schema.Schema.AnyNoContext): void {
-    const visitAll = (nodes: SchemaAST.AST[]) => nodes.forEach((node) => this.validateSchema(Schema.make(node)));
-    if (SchemaAST.isUnion(schema.ast)) {
-      const typeAstList = schema.ast.types.filter((type) => SchemaAST.isTypeLiteral(type)) as SchemaAST.TypeLiteral[];
-      // Check we can handle a discriminated union.
-      if (typeAstList.length > 1) {
-        getTypeDiscriminators(typeAstList);
-      }
-      visitAll(typeAstList);
-    } else if (SchemaAST.isTupleType(schema.ast)) {
-      const positionalTypes = schema.ast.elements.map((t) => t.type);
-      const allTypes = positionalTypes.concat(schema.ast.rest.map((t) => t.type));
-      visitAll(allTypes);
-    } else if (SchemaAST.isTypeLiteral(schema.ast)) {
-      visitAll(SchemaAST.getPropertySignatures(schema.ast).map((p) => p.type));
-    }
-  }
-
-  public static hasTypeAnnotation(
-    rootObjectSchema: Schema.Schema.AnyNoContext,
-    property: string,
-    annotation: symbol,
-  ): boolean {
-    try {
-      let type = this.getPropertySchema(rootObjectSchema, [property]);
-      if (SchemaAST.isTupleType(type.ast)) {
-        type = this.getPropertySchema(rootObjectSchema, [property, '0']);
-      }
-
-      return type.ast.annotations[annotation] != null;
-    } catch {
-      return false;
-    }
-  }
-
-  public static getPropertySchema(
-    rootObjectSchema: Schema.Schema.AnyNoContext,
-    propertyPath: KeyPath,
-    getProperty: (path: KeyPath) => any = () => null,
-  ): Schema.Schema.AnyNoContext {
-    let schema: Schema.Schema.AnyNoContext = rootObjectSchema;
-    for (let i = 0; i < propertyPath.length; i++) {
-      const propertyName = propertyPath[i];
-      const tupleAst = unwrapArray(schema.ast);
-      if (tupleAst != null) {
-        schema = getArrayElementSchema(tupleAst, propertyName);
-      } else {
-        const propertyType = getPropertyType(schema.ast, propertyName.toString(), (propertyName) =>
-          getProperty([...propertyPath.slice(0, i), propertyName]),
-        );
-        if (propertyType == null) {
-          throw new TypeError(`unknown property: ${String(propertyName)} on object. Path: ${propertyPath}`);
-        }
-
-        schema = Schema.make(propertyType).annotations(propertyType.annotations);
-      }
-    }
-
-    return schema;
-  }
-
-  public static getTargetPropertySchema(target: any, prop: string | symbol): Schema.Schema.AnyNoContext {
-    const schema: Schema.Schema.AnyNoContext | undefined = (target as any)[SchemaId];
-    invariant(schema, 'target has no schema');
-    const arrayAst = unwrapArray(schema.ast);
-    if (arrayAst != null) {
-      return getArrayElementSchema(arrayAst, prop);
-    }
-
-    const propertyType = getPropertyType(schema.ast, prop.toString(), (prop) => target[prop]);
-    if (propertyType == null) {
-      return Schema.Any; // TODO(burdon): HACK.
-    }
-
-    invariant(propertyType, `invalid property: ${prop.toString()}`);
-    return Schema.make(propertyType);
-  }
-}
-
-/**
- * Tuple AST is used both for:
- * fixed-length tuples ([string, number]) in which case AST will be { elements: [Schema.String, Schema.Number] }
- * variable-length arrays (Array<string | number>) in which case AST will be { rest: [Schema.Union(Schema.String, Schema.Number)] }
- */
-const getArrayElementSchema = (
-  tupleAst: SchemaAST.TupleType,
-  property: string | symbol | number,
-): Schema.Schema.AnyNoContext => {
-  const elementIndex = typeof property === 'string' ? parseInt(property, 10) : Number.NaN;
-  if (Number.isNaN(elementIndex)) {
-    invariant(property === 'length', `invalid array property: ${String(property)}`);
-    return Schema.Number;
-  }
-  if (elementIndex < tupleAst.elements.length) {
-    const elementType = tupleAst.elements[elementIndex].type;
-    return Schema.make(elementType).annotations(elementType.annotations);
-  }
-
-  const restType = tupleAst.rest;
-  return Schema.make(restType[0].type).annotations(restType[0].annotations);
-};
-
-const flattenUnion = (typeAst: SchemaAST.AST): SchemaAST.AST[] =>
-  SchemaAST.isUnion(typeAst) ? typeAst.types.flatMap(flattenUnion) : [typeAst];
-
-const getProperties = (
-  typeAst: SchemaAST.AST,
-  getTargetPropertyFn: (propertyName: string) => any,
-): SchemaAST.PropertySignature[] => {
-  const astCandidates = flattenUnion(typeAst);
-  const typeAstList = astCandidates.filter((type) => SchemaAST.isTypeLiteral(type)) as SchemaAST.TypeLiteral[];
-  if (typeAstList.length === 0) {
-    return [];
-  }
-  if (typeAstList.length === 1) {
-    return SchemaAST.getPropertySignatures(typeAstList[0]);
-  }
-
-  const typeDiscriminators = getTypeDiscriminators(typeAstList);
-  const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
-  const typeIndex = typeDiscriminators.findIndex((p) => targetPropertyValue === (p.type as SchemaAST.Literal).literal);
-  invariant(typeIndex !== -1, 'discriminator field not set on target');
-  return SchemaAST.getPropertySignatures(typeAstList[typeIndex]);
-};
-
-const getPropertyType = (
-  ast: SchemaAST.AST,
-  propertyName: string,
-  getTargetPropertyFn: (propertyName: string) => any,
-): SchemaAST.AST | null => {
-  const anyOrObject = unwrapAst(
-    ast,
-    (candidate) => SchemaAST.isAnyKeyword(candidate) || SchemaAST.isObjectKeyword(candidate),
-  );
-  if (anyOrObject != null) {
-    return ast;
-  }
-
-  const typeOrDiscriminatedUnion = unwrapAst(ast, (t) => {
-    return SchemaAST.isTypeLiteral(t) || (SchemaAST.isUnion(t) && t.types.some((t) => SchemaAST.isTypeLiteral(t)));
-  });
-  if (typeOrDiscriminatedUnion == null) {
-    return null;
-  }
-
-  const targetProperty = getProperties(typeOrDiscriminatedUnion, getTargetPropertyFn).find(
-    (p) => p.name === propertyName,
-  );
-  if (targetProperty != null) {
-    return unwrapAst(targetProperty.type);
-  }
-
-  const indexSignatureType = unwrapAst(ast, SchemaAST.isTypeLiteral);
-  if (
-    indexSignatureType &&
-    SchemaAST.isTypeLiteral(indexSignatureType) &&
-    indexSignatureType.indexSignatures.length > 0
-  ) {
-    return unwrapAst(indexSignatureType.indexSignatures[0].type);
-  }
-
-  return null;
-};
-
-const getTypeDiscriminators = (typeAstList: SchemaAST.TypeLiteral[]): SchemaAST.PropertySignature[] => {
-  const discriminatorPropCandidates = typeAstList
-    .flatMap(SchemaAST.getPropertySignatures)
-    .filter((p) => SchemaAST.isLiteral(p.type));
-  const propertyName = discriminatorPropCandidates[0].name;
-  const isValidDiscriminator = discriminatorPropCandidates.every((p) => p.name === propertyName && !p.isOptional);
-  const everyTypeHasDiscriminator = discriminatorPropCandidates.length === typeAstList.length;
-  const isDiscriminatedUnion = isValidDiscriminator && everyTypeHasDiscriminator;
-  invariant(isDiscriminatedUnion, 'type ambiguity: every type in a union must have a single unique-literal field');
-  return discriminatorPropCandidates;
-};
-
-/**
- * Used to check that rootAst is for a type matching the provided predicate.
- * That's not always straightforward because types of optionality and recursive types.
- * const Task = Schema.Struct({
- *   ...,
- *   previous?: Schema.optional(Schema.suspend(() => Task)),
- * });
- * Here the AST for `previous` field is going to be Union(Suspend(Type), Undefined).
- * SchemaAST.isTypeLiteral(field) will return false, but unwrapAst(field, (ast) => SchemaAST.isTypeLiteral(ast))
- * will return true.
- */
-const unwrapAst = (rootAst: SchemaAST.AST, predicate?: (ast: SchemaAST.AST) => boolean): SchemaAST.AST | null => {
-  let ast: SchemaAST.AST | undefined = rootAst;
-  while (ast != null) {
-    if (predicate?.(ast)) {
-      return ast;
-    }
-
-    if (SchemaAST.isUnion(ast)) {
-      const next: any = ast.types.find((t) => (predicate != null && predicate(t)) || SchemaAST.isSuspend(t));
-      if (next != null) {
-        ast = next;
-        continue;
-      }
-    }
-
-    if (SchemaAST.isSuspend(ast)) {
-      ast = ast.f();
-    } else {
-      return predicate == null ? ast : null;
-    }
-  }
-
-  return null;
-};
-
-const unwrapArray = (ast: SchemaAST.AST) => unwrapAst(ast, SchemaAST.isTupleType) as SchemaAST.TupleType | null;
-
-export const checkIdNotPresentOnSchema = (schema: Schema.Schema<any, any, any>) => {
-  invariant(SchemaAST.isTypeLiteral(schema.ast));
-  const idProperty = SchemaAST.getPropertySignatures(schema.ast).find((prop) => prop.name === 'id');
-  if (idProperty != null) {
-    throw new Error('"id" property name is reserved');
-  }
-};
-
-// TODO(burdon): Reconcile with JsonPath.
-type KeyPath = readonly (string | number)[];
+// Re-export from proxy for backward compatibility.
+export { SchemaValidator, checkIdNotPresentOnSchema } from '../proxy';

package/src/internal/object/set-value.test.ts

@@ -0,0 +1,281 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import * as Obj from '../../Obj';
+import { TestSchema } from '../../testing';
+import * as Type from '../../Type';
+
+describe('Obj.setValue', () => {
+  test('sets simple nested object property', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+
+    expect(person.address).toBeDefined();
+    expect(person.address?.city).toBe('NYC');
+  });
+
+  test('sets array element by initializing array', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['fields', 0, 'label'], 'Phone'));
+
+    expect(Array.isArray(person.fields)).toBe(true);
+    expect(person.fields?.[0].label).toBe('Phone');
+    // The 'value' field is required, so it should be initialized with default.
+    expect(person.fields?.[0].value).toBe('');
+  });
+
+  test('sets deeply nested array in object', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['address', 'coordinates', 'lat'], 40.7128));
+
+    expect(person.address).toBeDefined();
+    expect(person.address?.coordinates).toBeDefined();
+    expect(person.address?.coordinates?.lat).toBe(40.7128);
+  });
+
+  test('sets multiple nested array elements', ({ expect }) => {
+    const Item = Schema.Struct({
+      value: Schema.optional(Schema.Number),
+    });
+
+    const Container = Schema.Struct({
+      name: Schema.String,
+      items: Schema.optional(Schema.Array(Item)),
+    }).pipe(
+      Type.object({
+        typename: 'test.com/Container',
+        version: '0.1.0',
+      }),
+    );
+
+    const container = Obj.make(Container, { name: 'box' });
+
+    Obj.change(container, (c) => {
+      Obj.setValue(c, ['items', 0, 'value'], 10);
+      Obj.setValue(c, ['items', 1, 'value'], 20);
+      Obj.setValue(c, ['items', 2, 'value'], 30);
+    });
+
+    expect(container.items).toHaveLength(3);
+    expect(container.items?.[0].value).toBe(10);
+    expect(container.items?.[1].value).toBe(20);
+    expect(container.items?.[2].value).toBe(30);
+  });
+
+  test('handles optional fields', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['age'], 25));
+
+    expect(person.age).toBe(25);
+  });
+
+  test('handles nested optional objects', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+
+    expect(person.address).toBeDefined();
+    expect(person.address?.city).toBe('NYC');
+  });
+
+  test('returns the set value', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    let result: any;
+    Obj.change(person, (p) => {
+      result = Obj.setValue(p, ['age'], 30);
+    });
+
+    expect(result).toBe(30);
+  });
+
+  test('overwrites existing values', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+      age: 25,
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['age'], 30));
+
+    expect(person.age).toBe(30);
+  });
+
+  test('sets nested value in existing object', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+      address: { city: 'Boston', state: 'MA', coordinates: {} },
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+
+    expect(person.address?.city).toBe('NYC');
+    expect(person.address?.state).toBe('MA');
+  });
+
+  test('handles two-dimensional arrays', ({ expect }) => {
+    const Matrix = Schema.Struct({
+      values: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
+    }).pipe(
+      Type.object({
+        typename: 'test.com/Matrix',
+        version: '0.1.0',
+      }),
+    );
+
+    const matrix = Obj.make(Matrix, {});
+
+    Obj.change(matrix, (m) => {
+      Obj.setValue(m, ['values', 0, 0], 1);
+      Obj.setValue(m, ['values', 0, 1], 2);
+      Obj.setValue(m, ['values', 1, 0], 3);
+      Obj.setValue(m, ['values', 1, 1], 4);
+    });
+
+    expect(matrix.values?.[0][0]).toBe(1);
+    expect(matrix.values?.[0][1]).toBe(2);
+    expect(matrix.values?.[1][0]).toBe(3);
+    expect(matrix.values?.[1][1]).toBe(4);
+  });
+
+  test('throws error for empty path', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    Obj.change(person, (p) => {
+      expect(() => Obj.setValue(p, [], 'value')).toThrow('Path must not be empty');
+    });
+  });
+
+  test('sets value with single-element path', ({ expect }) => {
+    const person = Obj.make(TestSchema.Person, {
+      name: 'John',
+      username: 'john',
+      email: 'john@example.com',
+    });
+
+    Obj.change(person, (p) => Obj.setValue(p, ['age'], 30));
+
+    expect(person.age).toBe(30);
+  });
+
+  test('handles numeric keys as strings', ({ expect }) => {
+    const Item = Schema.Struct({
+      value: Schema.optional(Schema.Number),
+    });
+
+    const Container = Schema.Struct({
+      name: Schema.String,
+      items: Schema.optional(Schema.Array(Item)),
+    }).pipe(
+      Type.object({
+        typename: 'test.com/Container',
+        version: '0.1.0',
+      }),
+    );
+
+    const container = Obj.make(Container, { name: 'box' });
+
+    // Using string '0' for array index.
+    Obj.change(container, (c) => Obj.setValue(c, ['items', '0', 'value'], 42));
+
+    expect(container.items?.[0].value).toBe(42);
+  });
+
+  test('handles array with object with required field', ({ expect }) => {
+    // This test demonstrates the problematic scenario:
+    // An array containing objects that have required fields.
+    const Task = Schema.Struct({
+      id: Schema.String, // Required field.
+      title: Schema.optional(Schema.String),
+      completed: Schema.optional(Schema.Boolean),
+    });
+
+    const TodoList = Schema.Struct({
+      name: Schema.String,
+      tasks: Schema.optional(Schema.Array(Task)),
+    }).pipe(
+      Type.object({
+        typename: 'test.com/TodoList',
+        version: '0.1.0',
+      }),
+    );
+
+    const todoList = Obj.make(TodoList, { name: 'My Tasks' });
+
+    // This should work: setting a nested property on an array element.
+    // The required 'id' field should be initialized with a default value.
+    Obj.change(todoList, (t) => Obj.setValue(t, ['tasks', 0, 'title'], 'Buy groceries'));
+
+    expect(todoList.tasks?.[0].id).toBe(''); // Default value for required String
+    expect(todoList.tasks?.[0].title).toBe('Buy groceries');
+    expect(todoList.tasks?.[0].completed).toBeUndefined(); // Optional field not set
+  });
+
+  test('initializes multiple required primitive fields with defaults', ({ expect }) => {
+    const Item = Schema.Struct({
+      id: Schema.String, // Required - should default to ""
+      count: Schema.Number, // Required - should default to 0
+      active: Schema.Boolean, // Required - should default to false
+      label: Schema.optional(Schema.String), // Optional - should not be initialized
+    });
+
+    const Container = Schema.Struct({
+      name: Schema.String,
+      items: Schema.optional(Schema.Array(Item)),
+    }).pipe(
+      Type.object({
+        typename: 'test.com/Container',
+        version: '0.1.0',
+      }),
+    );
+
+    const container = Obj.make(Container, { name: 'box' });
+
+    Obj.change(container, (c) => Obj.setValue(c, ['items', 0, 'label'], 'First Item'));
+
+    // All required primitive fields should have default values.
+    expect(container.items?.[0].id).toBe('');
+    expect(container.items?.[0].count).toBe(0);
+    expect(container.items?.[0].active).toBe(false);
+    expect(container.items?.[0].label).toBe('First Item');
+  });
+});

package/src/internal/object/set-value.ts

@@ -0,0 +1,165 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Match from 'effect/Match';
+import * as Option from 'effect/Option';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import {
+  type SchemaProperty,
+  getArrayElementType,
+  getBaseType,
+  getProperties,
+  isArrayType,
+  isNestedType,
+} from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+
+import { type Mutable } from '../proxy';
+import { getSchema } from '../types';
+
+/**
+ * Set a deeply nested property on an object.
+ * Must be called within an Obj.change or Relation.change callback.
+ */
+export const setValue = (obj: Mutable<any>, path: readonly (string | number)[], value: any): void => {
+  invariant(path.length > 0, 'Path must not be empty');
+
+  const schema = getSchema(obj);
+  invariant(schema != null, 'Object must have a schema');
+
+  let parent = obj;
+  let currentAST: SchemaAST.AST | undefined = schema.ast;
+
+  // Navigate to the parent of the target property.
+  for (let i = 0; i < path.length - 1; i++) {
+    const part = path[i];
+    const key = typeof part === 'number' ? part : String(part);
+    if (parent[key] === undefined) {
+      const propertyAST = getPropertyAST(currentAST, String(part));
+      const shouldBeArray = propertyAST ? isArrayType(propertyAST) : false;
+
+      if (shouldBeArray) {
+        // Create array.
+        parent[key] = [];
+      } else {
+        // TODO(wittjosiah): Is there a better way to handle this than creating an object with defaults?
+        //   Perhaps properties on objects should be optional by default?
+        // Create object with defaults for required fields.
+        const objWithDefaults = createObjectWithDefaults(propertyAST);
+        parent[key] = objWithDefaults;
+      }
+    }
+
+    parent = parent[key];
+    currentAST = getPropertyAST(currentAST, String(part));
+  }
+
+  const finalKey = path[path.length - 1];
+  parent[finalKey] = value;
+
+  return value;
+};
+
+/**
+ * Helper to get the AST of a nested property.
+ * @param ast - Current schema AST.
+ * @param propertyName - Name of the property to get.
+ * @returns The AST of the nested property, or undefined if not found.
+ */
+const getPropertyAST = (ast: SchemaAST.AST | undefined, propertyName: string): SchemaAST.AST | undefined => {
+  if (!ast) {
+    return undefined;
+  }
+
+  if (isNestedType(ast)) {
+    const properties = getProperties(ast);
+    const property = properties.find((p) => p.name.toString() === propertyName);
+    if (property) {
+      return getBaseType(property).type;
+    }
+  }
+
+  if (isArrayType(ast)) {
+    const elementType = getArrayElementType(ast);
+    return elementType;
+  }
+
+  return undefined;
+};
+
+/**
+ * Get all required properties from a schema AST.
+ * A property is required if it's not optional.
+ *
+ * @param ast - Schema AST to inspect.
+ * @returns Array of required properties with their types.
+ */
+const getRequiredProperties = (ast: SchemaAST.AST | undefined): SchemaProperty[] => {
+  if (!ast) {
+    return [];
+  }
+
+  // Only objects/structs have properties with optional/required distinction.
+  if (!isNestedType(ast)) {
+    return [];
+  }
+
+  const properties = getProperties(ast);
+
+  // Filter to only required properties (where isOptional === false).
+  return properties.filter((p) => !p.isOptional);
+};
+
+/**
+ * Get the default value for a primitive type.
+ * Returns undefined for non-primitive or unsupported types.
+ *
+ * @param ast - Type AST.
+ * @returns Default value for the type, or undefined.
+ */
+const getDefaultValueForType = (ast: SchemaAST.AST | undefined): any => {
+  if (!ast) {
+    return undefined;
+  }
+
+  const defaultValue = SchemaAST.getDefaultAnnotation(ast);
+  if (Option.isSome(defaultValue)) {
+    return defaultValue.value;
+  }
+
+  return Match.value(ast).pipe(
+    Match.when({ _tag: 'StringKeyword' }, () => ''),
+    Match.when({ _tag: 'NumberKeyword' }, () => 0),
+    Match.when({ _tag: 'BooleanKeyword' }, () => false),
+    Match.orElse(() => undefined),
+  );
+};
+
+/**
+ * Create an object with default values for all required properties.
+ * Handles primitive types (String, Number, Boolean) and recursively initializes required nested objects.
+ *
+ * @param ast - Schema AST describing the object structure.
+ * @returns Object with required fields populated with defaults.
+ */
+const createObjectWithDefaults = (ast: SchemaAST.AST | undefined): any => {
+  if (!ast) {
+    return {};
+  }
+
+  const requiredProps = getRequiredProperties(ast);
+  const obj: any = {};
+
+  for (const prop of requiredProps) {
+    const defaultValue = getDefaultValueForType(prop.type);
+    if (defaultValue !== undefined) {
+      obj[prop.name] = defaultValue;
+    } else if (isNestedType(prop.type)) {
+      obj[prop.name] = createObjectWithDefaults(prop.type);
+    }
+  }
+
+  return obj;
+};