@dxos/echo 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/src/internal/{object → Obj}/json-serializer.ts

@@ -5,48 +5,64 @@
 import * as Schema from 'effect/Schema';
 
 import { raise } from '@dxos/debug';
-import { type EncodedReference, type ObjectMeta, isEncodedReference } from '@dxos/echo-protocol';
+import { type EncodedReference, ObjectStructure, isEncodedReference } from '@dxos/echo-protocol';
 import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
-import { defineHiddenProperty } from '@dxos/live-object';
 import { assumeType, deepMapValues, visitValues } from '@dxos/util';
 
-import { EntityKind } from '../ast';
-import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../ref';
-import { type AnyEchoObject } from '../types';
-
-import { setSchema } from './accessors';
-import { ObjectMetaSchema } from './meta';
+import type * as Database from '../../Database';
+import type * as Obj from '../../Obj';
+import { getTypeDXN, setTypename } from '../Annotation';
+import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../common/proxy';
 import {
-  ATTR_DELETED,
   ATTR_META,
+  ATTR_PARENT,
+  ATTR_TYPE,
+  type AnyEntity,
+  EntityKind,
+  KindId,
+  MetaId,
+  ObjectMetaSchema,
+  ParentId,
+  setSchema,
+} from '../common/types';
+import {
+  ATTR_DELETED,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
   ATTR_SELF_DXN,
-  ATTR_TYPE,
-  EntityKindId,
-  MetaId,
+  ObjectDatabaseId,
   type ObjectJSON,
   RelationSourceDXNId,
   RelationSourceId,
   RelationTargetDXNId,
   RelationTargetId,
   SelfDXNId,
-  TypeId,
-  assertObjectModelShape,
-} from './model';
-import { getType, setTypename } from './typename';
+  assertObjectModel,
+} from '../Entity';
+import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../Ref';
 
-type DeepReplaceRef<T> =
-  T extends Ref<any> ? EncodedReference : T extends object ? { [K in keyof T]: DeepReplaceRef<T[K]> } : T;
+// Re-export for backward compatibility.
+export { attachTypedJsonSerializer };
 
-type SerializedObject<T extends { id: string }> = { [K in keyof T]: DeepReplaceRef<T[K]> } & ObjectJSON;
+type DeepReplaceRef<T> =
+  T extends Ref<any>
+    ? EncodedReference
+    : T extends object
+      ? {
+          [K in keyof T]: DeepReplaceRef<T[K]>;
+        }
+      : T;
+
+type SerializedObject<T extends { id: string }> = {
+  [K in keyof T]: DeepReplaceRef<T[K]>;
+} & ObjectJSON;
 
 /**
  * Converts object to it's JSON representation.
  */
-export const objectToJSON = <T extends AnyEchoObject>(obj: T): SerializedObject<T> => {
-  const typename = getType(obj)?.toString();
+export const objectToJSON = <T extends AnyEntity>(obj: T): SerializedObject<T> => {
+  const typename = getTypeDXN(obj)?.toString();
   invariant(typename && typeof typename === 'string');
   return typedJsonSerializer.call(obj);
 };
@@ -55,13 +71,17 @@ export const objectToJSON = <T extends AnyEchoObject>(obj: T): SerializedObject<
  * Creates an object from it's json representation.
  * Performs schema validation.
  * References and schema will be resolvable if the `refResolver` is provided.
- *
  * The function need to be async to support resolving the schema as well as the relation endpoints.
+ *
+ * @param jsonData - JSON representation of the object.
+ * @param options.refResolver - Resolver for references.
+ * @param options.dxn - Override object DXN.
+ * @param options.database - Database to associate with the object.
  */
 export const objectFromJSON = async (
   jsonData: unknown,
-  { refResolver, dxn }: { refResolver?: RefResolver; dxn?: DXN } = {},
-): Promise<AnyEchoObject> => {
+  { refResolver, dxn, database }: { refResolver?: RefResolver; dxn?: DXN; database?: Database.Database } = {},
+): Promise<AnyEntity> => {
   assumeType<ObjectJSON>(jsonData);
   assertArgument(typeof jsonData === 'object' && jsonData !== null, 'jsonData', 'expect object');
   assertArgument(typeof jsonData[ATTR_TYPE] === 'string', 'jsonData[ATTR_TYPE]', 'expected object to have a type');
@@ -70,19 +90,19 @@ export const objectFromJSON = async (
   const type = DXN.parse(jsonData[ATTR_TYPE]);
   const schema = await refResolver?.resolveSchema(type);
   invariant(schema === undefined || Schema.isSchema(schema));
+  const decodedInput = stripInternalJsonKeys(jsonData);
 
   let obj: any;
   if (schema != null) {
-    obj = await schema.pipe(Schema.decodeUnknownPromise)(jsonData);
+    obj = await schema.pipe(Schema.decodeUnknownPromise)(decodedInput);
     if (refResolver) {
       setRefResolverOnData(obj, refResolver);
     }
   } else {
-    obj = decodeGeneric(jsonData, { refResolver });
+    obj = decodeGeneric(decodedInput, { refResolver });
   }
 
   invariant(ObjectId.isValid(obj.id), 'Invalid object id');
-
   setTypename(obj, type);
   if (schema) {
     setSchema(obj, schema);
@@ -94,132 +114,102 @@ export const objectFromJSON = async (
     const sourceDxn: DXN = DXN.parse(jsonData[ATTR_RELATION_SOURCE] ?? raise(new TypeError('Missing relation source')));
     const targetDxn: DXN = DXN.parse(jsonData[ATTR_RELATION_TARGET] ?? raise(new TypeError('Missing relation target')));
 
-    // TODO(dmaretskyi): Async!
-    const source = (await refResolver?.resolve(sourceDxn)) as AnyEchoObject | undefined;
-    const target = (await refResolver?.resolve(targetDxn)) as AnyEchoObject | undefined;
+    const source = (await refResolver?.resolve(sourceDxn)) as AnyEntity | undefined;
+    const target = (await refResolver?.resolve(targetDxn)) as AnyEntity | undefined;
 
-    defineHiddenProperty(obj, EntityKindId, EntityKind.Relation);
+    defineHiddenProperty(obj, KindId, EntityKind.Relation);
     defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
     defineHiddenProperty(obj, RelationTargetDXNId, targetDxn);
     defineHiddenProperty(obj, RelationSourceId, source);
     defineHiddenProperty(obj, RelationTargetId, target);
   } else {
-    defineHiddenProperty(obj, EntityKindId, EntityKind.Object);
+    defineHiddenProperty(obj, KindId, EntityKind.Object);
   }
 
   if (typeof jsonData[ATTR_META] === 'object') {
     const meta = await ObjectMetaSchema.pipe(Schema.decodeUnknownPromise)(jsonData[ATTR_META]);
-
-    // Defensive programming.
     invariant(Array.isArray(meta.keys));
-
     defineHiddenProperty(obj, MetaId, meta);
+  } else {
+    defineHiddenProperty(obj, MetaId, {
+      keys: [],
+    });
+  }
+
+  if (jsonData[ATTR_PARENT]) {
+    const parentDxn = DXN.parse(jsonData[ATTR_PARENT]);
+    const parent = (await refResolver?.resolve(parentDxn)) as Obj.Unknown | undefined;
+    defineHiddenProperty(obj, ParentId, parent);
   }
 
   if (dxn) {
     defineHiddenProperty(obj, SelfDXNId, dxn);
   }
 
-  assertObjectModelShape(obj);
+  if (database) {
+    defineHiddenProperty(obj, ObjectDatabaseId, database);
+  }
+
+  assertObjectModel(obj);
   invariant((obj as any)[ATTR_TYPE] === undefined, 'Invalid object model');
-  invariant((obj as any)[ATTR_SELF_DXN] === undefined, 'Invalid object model');
+  invariant((obj as any)[ATTR_META] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_DELETED] === undefined, 'Invalid object model');
+  invariant((obj as any)[ATTR_SELF_DXN] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_RELATION_SOURCE] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_RELATION_TARGET] === undefined, 'Invalid object model');
-  invariant((obj as any)[ATTR_META] === undefined, 'Invalid object model');
   return obj;
 };
 
 const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }) => {
+  const props = stripInternalJsonKeys(jsonData);
+
+  return deepMapValues(props, (value, visitor) => {
+    if (isEncodedReference(value)) {
+      return refFromEncodedReference(value, options.refResolver);
+    }
+
+    return visitor(value);
+  });
+};
+
+const stripInternalJsonKeys = (jsonData: unknown) => {
   const {
     [ATTR_TYPE]: _type,
     [ATTR_META]: _meta,
     [ATTR_DELETED]: _deleted,
+    [ATTR_SELF_DXN]: _selfDxn,
     [ATTR_RELATION_SOURCE]: _relationSource,
     [ATTR_RELATION_TARGET]: _relationTarget,
-    [ATTR_SELF_DXN]: _selfDxn,
     ...props
   } = jsonData as any;
 
-  return deepMapValues(props, (value, recurse) => {
-    if (isEncodedReference(value)) {
-      return refFromEncodedReference(value, options.refResolver);
-    }
-    return recurse(value);
-  });
+  return props;
 };
 
-export const setRefResolverOnData = (obj: AnyEchoObject, refResolver: RefResolver) => {
-  const go = (value: unknown) => {
+export const setRefResolverOnData = (obj: AnyEntity, refResolver: RefResolver) => {
+  const visitor = (value: unknown) => {
     if (Ref.isRef(value)) {
       setRefResolver(value, refResolver);
     } else {
-      visitValues(value, go);
+      visitValues(value, visitor);
     }
   };
 
-  go(obj);
-};
-
-export const attachTypedJsonSerializer = (obj: any) => {
-  const descriptor = Object.getOwnPropertyDescriptor(obj, 'toJSON');
-  if (descriptor) {
-    return;
-  }
-
-  Object.defineProperty(obj, 'toJSON', {
-    value: typedJsonSerializer,
-    writable: false,
-    enumerable: false,
-    // Setting `configurable` to false breaks proxy invariants, should be fixable.
-    configurable: true,
-  });
+  visitor(obj);
 };
 
-// NOTE: KEEP as function.
-const typedJsonSerializer = function (this: any) {
-  const { id, ...rest } = this;
-  const result: any = {
-    id,
+/**
+ * Convert ObjectStructure to JSON data for indexing.
+ * Different from {@link objectToJSON} as it takes the internal {@link ObjectStructure} representation directly
+ */
+export const objectStructureToJson = (objectId: string, structure: ObjectStructure): Obj.JSON => {
+  return {
+    ...structure.data,
+    id: objectId,
+    [ATTR_TYPE]: (ObjectStructure.getTypeReference(structure)?.['/'] ?? '') as DXN.String,
+    [ATTR_DELETED]: ObjectStructure.isDeleted(structure),
+    [ATTR_PARENT]: ObjectStructure.getParent(structure)?.['/'] as DXN.String | undefined,
+    [ATTR_RELATION_SOURCE]: ObjectStructure.getRelationSource(structure)?.['/'] as DXN.String | undefined,
+    [ATTR_RELATION_TARGET]: ObjectStructure.getRelationTarget(structure)?.['/'] as DXN.String | undefined,
   };
-
-  if (this[TypeId]) {
-    result[ATTR_TYPE] = this[TypeId].toString();
-  }
-
-  if (this[SelfDXNId]) {
-    result[ATTR_SELF_DXN] = this[SelfDXNId].toString();
-  }
-
-  if (this[RelationSourceDXNId]) {
-    const sourceDXN = this[RelationSourceDXNId];
-    invariant(sourceDXN instanceof DXN);
-    result[ATTR_RELATION_SOURCE] = sourceDXN.toString();
-  }
-  if (this[RelationTargetDXNId]) {
-    const targetDXN = this[RelationTargetDXNId];
-    invariant(targetDXN instanceof DXN);
-    result[ATTR_RELATION_TARGET] = targetDXN.toString();
-  }
-
-  if (this[MetaId]) {
-    result[ATTR_META] = serializeMeta(this[MetaId]);
-  }
-
-  Object.assign(result, serializeData(rest));
-  return result;
-};
-
-const serializeData = (data: unknown) => {
-  return deepMapValues(data, (value, recurse) => {
-    if (Ref.isRef(value)) {
-      // TODO(dmaretskyi): Should this be configurable?
-      return value.noInline().encode();
-    }
-    return recurse(value);
-  });
-};
-
-const serializeMeta = (meta: ObjectMeta) => {
-  return deepMapValues(meta, (value, recurse) => recurse(value));
 };

package/src/internal/{object → Obj}/schema-validator.test.ts

@@ -27,9 +27,7 @@ describe('schema-validator', () => {
       const TestSchema: Schema.Schema.AnyNoContext = Schema.Struct({
         name: Schema.String.annotations({ [annotationId]: annotationValue }),
         parent: Schema.optional(Schema.suspend(() => TestSchema.annotations({ [annotationId]: annotationValue }))),
-        friends: Schema.suspend(() =>
-          Schema.mutable(Schema.Array(TestSchema.annotations({ [annotationId]: annotationValue }))),
-        ),
+        friends: Schema.suspend(() => Schema.Array(TestSchema.annotations({ [annotationId]: annotationValue }))),
       });
       expect(SchemaValidator.hasTypeAnnotation(TestSchema, 'name', annotationId)).to.be.true;
       expect(SchemaValidator.hasTypeAnnotation(TestSchema, 'parent', annotationId)).to.be.true;
@@ -41,7 +39,7 @@ describe('schema-validator', () => {
       const Person: Schema.Schema.AnyNoContext = Schema.Struct({
         name: Schema.String,
         parent: Schema.optional(Schema.suspend(() => Person)),
-        friends: Schema.suspend(() => Schema.mutable(Schema.Array(Person))),
+        friends: Schema.suspend(() => Schema.Array(Person)),
       });
       expect(SchemaValidator.hasTypeAnnotation(Person, 'name', annotationId)).to.be.false;
       expect(SchemaValidator.hasTypeAnnotation(Person, 'parent', annotationId)).to.be.false;
@@ -87,9 +85,7 @@ describe('schema-validator', () => {
       const annotationValue = 'bar';
       const Person: Schema.Schema.AnyNoContext = Schema.Struct({
         parent: Schema.optional(Schema.suspend(() => Person.annotations({ [annotationId]: annotationValue }))),
-        friends: Schema.suspend(() =>
-          Schema.mutable(Schema.Array(Person.annotations({ [annotationId]: annotationValue }))),
-        ),
+        friends: Schema.suspend(() => Schema.Array(Person.annotations({ [annotationId]: annotationValue }))),
       });
       expect(SchemaValidator.getPropertySchema(Person, ['parent']).ast.annotations[annotationId]).to.eq(
         annotationValue,

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

@@ -0,0 +1,6 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// Re-export from proxy for backward compatibility.
+export { SchemaValidator, checkIdNotPresentOnSchema } from '../common/proxy';

package/src/internal/Obj/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, (obj) => Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => {
+      Obj.setValue(obj, ['items', 0, 'value'], 10);
+      Obj.setValue(obj, ['items', 1, 'value'], 20);
+      Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => {
+      result = Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => {
+      Obj.setValue(obj, ['values', 0, 0], 1);
+      Obj.setValue(obj, ['values', 0, 1], 2);
+      Obj.setValue(obj, ['values', 1, 0], 3);
+      Obj.setValue(obj, ['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, (obj) => {
+      expect(() => Obj.setValue(obj, [], '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, (obj) => Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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, (obj) => Obj.setValue(obj, ['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');
+  });
+});