@dxos/echo 0.8.4-main.ef1bc66f44 → 0.8.4-main.effb148878

package/src/internal/object/ids.ts

@@ -1,12 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { DXN, ObjectId, QueueSubspaceTags, SpaceId } from '@dxos/keys';
-
-/**
- * @deprecated Use `db.queues.create()`
- */
-// TODO(burdon): Move to @dxos/keys.
-export const createQueueDXN = (spaceId = SpaceId.random(), queueId = ObjectId.random()) =>
-  new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, spaceId, queueId]);

package/src/internal/object/json-serializer.test.ts

@@ -1,98 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, expect, test } from 'vitest';
-
-import { DXN } from '@dxos/keys';
-
-import * as Obj from '../../Obj';
-import { TestSchema } from '../../testing';
-import { getSchemaDXN, getSchemaTypename, getTypeDXN, getTypename } from '../annotations';
-import { getMetaChecked } from '../api';
-import { RelationSourceId, RelationTargetId, getObjectDXN } from '../entities';
-import { makeObject } from '../proxy';
-import { Ref, StaticRefResolver } from '../ref';
-import { ATTR_TYPE, EntityKind, KindId, MetaId, TypeId, getSchema } from '../types';
-
-import { createObject } from './create-object';
-import { objectFromJSON, objectToJSON } from './json-serializer';
-
-describe('Object JSON serializer', () => {
-  test('should serialize and deserialize object', async () => {
-    const contact = makeObject(TestSchema.Person, { name: 'Alice' });
-    Obj.change(contact, (c) => {
-      getMetaChecked(c).keys.push({ id: '12345', source: 'example.com' });
-    });
-
-    const task = createObject(TestSchema.Task, {
-      title: 'Fix the tests',
-      assignee: Ref.make(contact),
-    });
-
-    const contactJson = objectToJSON(contact);
-    const taskJson = objectToJSON(task);
-
-    expect(contactJson.id).toBe(contact.id);
-    expect(contactJson[ATTR_TYPE]).toEqual(getSchemaDXN(TestSchema.Person)!.toString());
-    expect(contactJson.name).toEqual('Alice');
-
-    expect(taskJson.id).toBe(task.id);
-    expect(taskJson[ATTR_TYPE]).toEqual(getSchemaDXN(TestSchema.Task)!.toString());
-    expect(taskJson.title).toEqual('Fix the tests');
-    expect(taskJson.assignee).toEqual({ '/': DXN.fromLocalObjectId(contact.id).toString() });
-
-    const refResolver = new StaticRefResolver()
-      .addSchema(TestSchema.Person)
-      .addSchema(TestSchema.Task)
-      .addObject(contact)
-      .addObject(task);
-
-    const contactFromJson = (await objectFromJSON(contactJson, { refResolver })) as TestSchema.Person;
-    const taskFromJson = (await objectFromJSON(taskJson, { refResolver })) as TestSchema.Task;
-
-    expect(contactFromJson.id).toBe(contact.id);
-    expect(contactFromJson.name).toBe('Alice');
-    expect((contactFromJson as any)[TypeId]).toEqual(getSchemaDXN(TestSchema.Person));
-    expect((contactFromJson as any)[KindId]).toBe(EntityKind.Object);
-    expect((contactFromJson as any)[RelationSourceId]).toBeUndefined();
-    expect((contactFromJson as any)[RelationTargetId]).toBeUndefined();
-    expect((contactFromJson as any)[MetaId]).toEqual({
-      keys: [
-        {
-          id: '12345',
-          source: 'example.com',
-        },
-      ],
-    });
-    expect(getTypeDXN(contactFromJson)?.toString()).toBe(getSchemaDXN(TestSchema.Person)!.toString());
-    expect(getTypename(contactFromJson)).toBe(getSchemaTypename(TestSchema.Person));
-    expect(getObjectDXN(contactFromJson)?.toString()).toEqual(getObjectDXN(contact)?.toString());
-    expect(getSchema(contactFromJson)).toEqual(TestSchema.Person);
-
-    expect(taskFromJson.id).toBe(task.id);
-    expect(taskFromJson.title).toBe('Fix the tests');
-    expect(taskFromJson.assignee!.dxn).toEqual(DXN.fromLocalObjectId(contact.id));
-    expect(taskFromJson.assignee!.target).toEqual(contact);
-    expect(await taskFromJson.assignee!.load()).toEqual(contact);
-    expect((taskFromJson as any)[TypeId]).toEqual(getSchemaDXN(TestSchema.Task));
-    expect((taskFromJson as any)[KindId]).toBe(EntityKind.Object);
-    expect((taskFromJson as any)[RelationSourceId]).toBeUndefined();
-    expect((taskFromJson as any)[RelationTargetId]).toBeUndefined();
-    expect((taskFromJson as any)[MetaId]).toEqual({ keys: [] });
-    expect(getSchema(taskFromJson)).toEqual(TestSchema.Task);
-  });
-
-  test('serialize with unresolved schema', async () => {
-    const contact = createObject(TestSchema.Person, { name: 'Alice' });
-    const contactJson = objectToJSON(contact);
-    const contactFromJson: any = await objectFromJSON(contactJson);
-
-    expect(contactFromJson.id).toBe(contact.id);
-    expect(contactFromJson.name).toBe('Alice');
-    expect(getSchema(contactFromJson)).toBeUndefined();
-    expect(getTypename(contactFromJson)).toEqual(getSchemaTypename(TestSchema.Person));
-    expect(getObjectDXN(contactFromJson)).toEqual(getObjectDXN(contact));
-    expect(getTypeDXN(contactFromJson)).toEqual(getSchemaDXN(TestSchema.Person));
-  });
-});

package/src/internal/object/typed-object.test.ts

@@ -1,34 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-import { describe, expect, test } from 'vitest';
-
-import { EchoObjectSchema } from '../entities';
-
-const Organization = Schema.Struct({
-  name: Schema.String,
-}).pipe(
-  EchoObjectSchema({
-    typename: 'example.com/type/Organization',
-    version: '0.1.0',
-  }),
-);
-
-interface Organization extends Schema.Schema.Type<typeof Organization> {}
-
-describe('EchoObjectSchema DSL', () => {
-  test('type is a valid schema', async () => {
-    expect(Schema.isSchema(Organization)).to.be.true;
-  });
-
-  test('static typename accessor', async () => {
-    expect(Organization.typename).to.eq('example.com/type/Organization');
-  });
-
-  test('expect schema', async () => {
-    expect(SchemaAST.isTypeLiteral(Organization.ast)).to.be.true;
-  });
-});

package/src/internal/proxy/schema.test.ts

@@ -1,145 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-import { describe, expect, test } from 'vitest';
-
-import { createEchoSchema } from '../../testing';
-import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../annotations';
-import { EchoObjectSchema } from '../entities';
-
-// TODO(dmaretskyi): Comment.
-const EmptySchemaType = Schema.Struct({}).pipe(
-  EchoObjectSchema({
-    typename: 'example.com/type/Empty',
-    version: '0.1.0',
-  }),
-);
-
-interface EmptySchemaType extends Schema.Schema.Type<typeof EmptySchemaType> {}
-
-describe('dynamic schema', () => {
-  test('getProperties filters out id and unwraps optionality', async () => {
-    const TestSchema = Schema.Struct({
-      field1: Schema.String,
-      field2: Schema.Boolean,
-    }).pipe(
-      EchoObjectSchema({
-        typename: 'example.com/type/Test',
-        version: '0.1.0',
-      }),
-    );
-
-    const registered = createEchoSchema(TestSchema);
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
-      ['field1', SchemaAST.stringKeyword],
-      ['field2', SchemaAST.booleanKeyword],
-    ]);
-  });
-
-  test('addColumns', async () => {
-    const TestSchema = Schema.Struct({
-      field1: Schema.String,
-    }).pipe(
-      EchoObjectSchema({
-        typename: 'example.com/type/Test',
-        version: '0.1.0',
-      }),
-    );
-
-    const registered = createEchoSchema(TestSchema);
-    registered.addFields({ field2: Schema.Boolean });
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
-      ['field1', SchemaAST.stringKeyword],
-      ['field2', SchemaAST.booleanKeyword],
-    ]);
-  });
-
-  test('updateColumns preserves order of existing and appends new fields', async () => {
-    const registered = createEchoSchema(EmptySchemaType);
-    registered.addFields({ field1: Schema.String });
-    registered.addFields({ field2: Schema.Boolean });
-    registered.addFields({ field3: Schema.Number });
-    registered.updateFields({ field4: Schema.Boolean, field2: Schema.String });
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
-      ['field1', SchemaAST.stringKeyword],
-      ['field2', SchemaAST.stringKeyword],
-      ['field3', SchemaAST.numberKeyword],
-      ['field4', SchemaAST.booleanKeyword],
-    ]);
-  });
-
-  test('removeColumns', async () => {
-    const registered = createEchoSchema(EmptySchemaType);
-    registered.addFields({ field1: Schema.String });
-    registered.addFields({ field2: Schema.Boolean });
-    registered.addFields({ field3: Schema.Number });
-    registered.removeFields(['field2']);
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
-      ['field1', SchemaAST.stringKeyword],
-      ['field3', SchemaAST.numberKeyword],
-    ]);
-  });
-
-  test('schema manipulations preserve annotations', async () => {
-    const metaNamespace = 'dxos.test';
-    const metaInfo = { maxLength: 10 };
-    const registered = createEchoSchema(EmptySchemaType);
-    registered.addFields({
-      field1: Schema.String.pipe(PropertyMeta(metaNamespace, metaInfo)),
-      field2: Schema.String,
-    });
-    registered.addFields({ field3: Schema.String });
-    registered.updateFields({ field3: Schema.Boolean });
-    registered.removeFields(['field2']);
-    expect(getTypeAnnotation(registered)).to.deep.contain({
-      typename: 'example.com/type/Empty',
-      version: '0.1.0',
-    });
-    expect(getPropertyMetaAnnotation(registered.getProperties()[0], metaNamespace)).to.deep.eq(metaInfo);
-  });
-
-  test('updates typename', async ({ expect }) => {
-    // Create schema with some fields and annotations.
-    const registered = createEchoSchema(EmptySchemaType);
-    const originalVersion = registered.persistentSchema.version;
-    registered.addFields({
-      name: Schema.String.pipe(PropertyMeta('test', { maxLength: 10 })),
-      age: Schema.Number,
-    });
-
-    // First update.
-    const newTypename1 = 'example.com/type/Individual';
-    registered.updateTypename(newTypename1);
-
-    // Basic typename update checks.
-    expect(registered.typename).toBe(newTypename1);
-    expect(registered.jsonSchema.$id).toBe(`dxn:type:${newTypename1}`);
-    expect(registered.jsonSchema.typename).toBe(newTypename1);
-
-    // Version preservation check.
-    expect(registered.persistentSchema.version).toBe(originalVersion);
-
-    // Field preservation check.
-    const properties = registered.getProperties();
-    expect(properties).toHaveLength(2);
-    expect(properties[0].name).toBe('name');
-
-    // Annotation preservation check.
-    const nameMeta = getPropertyMetaAnnotation(properties[0], 'test');
-    expect(nameMeta).toEqual({ maxLength: 10 });
-
-    // Second update to ensure multiple updates work.
-    const newTypename2 = 'example.com/type/Person';
-    registered.updateTypename(newTypename2);
-    expect(registered.typename).toBe(newTypename2);
-    expect(registered.jsonSchema.$id).toBe(`dxn:type:${newTypename2}`);
-    expect(registered.jsonSchema.typename).toBe(newTypename2);
-    expect(getTypeAnnotation(registered)).to.deep.contain({
-      typename: 'example.com/type/Person',
-      version: '0.1.0',
-    });
-  });
-});