@dxos/echo 0.8.4-main.548089c → 0.8.4-main.59c2e9b

package/src/test/api.test.ts

@@ -1,180 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import { describe, test } from 'vitest';
-
-import { raise } from '@dxos/debug';
-import { FormatAnnotation, FormatEnum } from '@dxos/echo/internal';
-
-import { type Live, Obj, Ref, Relation, Type } from '../index';
-
-namespace Testing {
-  export const Organization = Schema.Struct({
-    id: Type.ObjectId,
-    name: Schema.String,
-  }).pipe(
-    Type.Obj({
-      typename: 'example.com/type/Organization',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Organization extends Schema.Schema.Type<typeof Organization> {}
-
-  export const Person = Schema.Struct({
-    name: Schema.String,
-    dob: Schema.optional(Schema.String),
-    email: Schema.optional(Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email))),
-    organization: Schema.optional(Type.Ref(Organization)),
-  }).pipe(
-    Type.Obj({
-      typename: 'example.com/type/Person',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Person extends Schema.Schema.Type<typeof Person> {}
-
-  // export const WorksFor = S.Struct({
-  //   id: Type.ObjectId,
-  //   since: S.String,
-  //   jobTitle: S.String,
-  //   ...Range({ from, to }),
-  //   ...Provenance({ source: 'duckduckgo.com', confidence: 0.9 }), // keys
-  //   ...Relation.make({ source: Contact, target: Organization }),
-  // }).pipe(
-  //   Type.Relation({
-  //     typename: 'example.com/relation/WorksFor',
-  //     version: '0.1.0',
-  //   }),
-  // );
-
-  // {
-  //   const contact = db.add(create(Contact, { name: 'Test' }));
-  //   const organization = db.add(create(Organization, { name: 'DXOS' }));
-  //   db.add(create(WorksFor, { source: contact, target: organization }));
-  // }
-
-  export const WorksFor = Schema.Struct({
-    // id: Type.ObjectId,
-    role: Schema.String,
-  }).pipe(
-    Type.Relation({
-      typename: 'example.com/relation/WorksFor',
-      version: '0.1.0',
-      source: Person,
-      target: Organization,
-    }),
-  );
-
-  export interface WorksFor extends Schema.Schema.Type<typeof WorksFor> {}
-
-  // TODO(burdon): Fix (Type.Obj currently removes TypeLiteral that implements the `make` function).
-  //  Property 'make' does not exist on type 'EchoObjectSchema<Struct<{ timestamp: PropertySignature<":", string, never, ":", string, true, never>; }>>'.ts(2339)
-  export const MessageStruct = Schema.Struct({
-    // TODO(burdon): Support S.Date; Custom Timestamp (with defaults).
-    // TODO(burdon): Support defaults (update create and create).
-    timestamp: Schema.String.pipe(
-      Schema.propertySignature,
-      Schema.withConstructorDefault(() => new Date().toISOString()),
-    ),
-  });
-
-  export const Message = MessageStruct.pipe(
-    Type.Obj({
-      typename: 'example.com/type/Message',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Message extends Schema.Schema.Type<typeof Message> {}
-}
-
-describe('Experimental API review', () => {
-  test('type checks', ({ expect }) => {
-    const contact = Obj.make(Testing.Person, { name: 'Test' });
-    const type: Schema.Schema<Testing.Person> = Obj.getSchema(contact) ?? raise(new Error('No schema found'));
-
-    expect(Type.getDXN(type)?.typename).to.eq(Testing.Person.typename);
-    expect(Type.getTypename(type)).to.eq('example.com/type/Person');
-    expect(Type.getVersion(type)).to.eq('0.1.0');
-    expect(Type.getMeta(type)).to.deep.eq({
-      kind: Type.Kind.Object,
-      typename: 'example.com/type/Person',
-      version: '0.1.0',
-    });
-  });
-
-  test('instance checks', ({ expect }) => {
-    const organization: Live<Testing.Organization> = Obj.make(Testing.Organization, { name: 'DXOS' });
-    const contact: Live<Testing.Person> = Obj.make(Testing.Person, {
-      name: 'Test',
-      organization: Ref.make(organization),
-    });
-
-    expect(Schema.is(Testing.Person)(contact)).to.be.true;
-    expect(Obj.instanceOf(Testing.Person, contact)).to.be.true;
-    expect(Obj.instanceOf(Testing.Organization, organization)).to.be.true;
-
-    const isPerson = Obj.instanceOf(Testing.Person);
-    const x: any = {};
-    if (isPerson(x)) {
-      x.name;
-    }
-  });
-
-  test('default props', ({ expect }) => {
-    const message = Obj.make(Testing.Message, Testing.MessageStruct.make({}));
-    expect(message.timestamp).to.exist;
-  });
-
-  test('Obj.isObject', ({ expect }) => {
-    const guy = Obj.make(Testing.Person, { name: 'Test' });
-    expect(Obj.isObject(guy)).to.be.true;
-    expect(Obj.isObject(null)).to.be.false;
-    expect(Obj.isObject(undefined)).to.be.false;
-    expect(Obj.isObject(1)).to.be.false;
-    expect(Obj.isObject('string')).to.be.false;
-  });
-
-  test('create relation', ({ expect }) => {
-    const person = Obj.make(Testing.Person, { name: 'Test' });
-    const organization = Obj.make(Testing.Organization, { name: 'DXOS' });
-    const worksFor = Relation.make(Testing.WorksFor, {
-      [Relation.Source]: person,
-      [Relation.Target]: organization,
-      role: 'CEO',
-    });
-    expect(Relation.getSource(worksFor)).to.eq(person);
-    expect(Relation.getTarget(worksFor)).to.eq(organization);
-  });
-
-  test('version', ({ expect }) => {
-    const person = Obj.make(Testing.Person, { name: 'Test' });
-    const version = Obj.version(person);
-    expect(Obj.isVersion(version)).to.be.true;
-    expect(Obj.versionValid(version)).to.be.false;
-  });
-
-  test.skip('type narrowing', () => {
-    const any: Obj.Any | Relation.Any = null as any;
-
-    {
-      if (Obj.isObject(any)) {
-        any;
-      } else {
-        any;
-      }
-    }
-
-    {
-      if (Relation.isRelation(any)) {
-        any;
-      } else {
-        any;
-      }
-    }
-  });
-});

package/src/testing/echo-schema.ts

@@ -1,39 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { effect } from '@preact/signals-core';
-import type * as Schema from 'effect/Schema';
-
-import { registerSignalsRuntime } from '@dxos/echo-signals';
-import { assertArgument } from '@dxos/invariant';
-
-import { EchoSchema, StoredSchema, getSchemaTypename, live, toJsonSchema } from '../internal';
-
-// NOTE: Registration is done here is this is the module that calls out to `effect`.
-registerSignalsRuntime();
-
-/**
- * Create a reactive mutable schema that updates when the JSON schema is updated.
- */
-// TODO(dmaretskyi): Should be replaced by registration of typed object.
-export const createEchoSchema = (schema: Schema.Schema.AnyNoContext): EchoSchema => {
-  const typename = getSchemaTypename(schema);
-  assertArgument(typename, 'typename', 'Schema does not have a typename.');
-
-  const echoSchema = new EchoSchema(
-    live(StoredSchema, {
-      typename,
-      version: '0.1.0',
-      jsonSchema: toJsonSchema(schema),
-    }),
-  );
-
-  // TODO(burdon): Unsubscribe is never called.
-  effect(() => {
-    const _ = echoSchema.jsonSchema;
-    echoSchema._invalidate();
-  });
-
-  return echoSchema;
-};

package/src/testing/types.ts

@@ -1,108 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { Type } from '..';
-
-/**
- * @deprecated
- */
-// TOOD(burdon): Reconcile with @dxos/schema.
-export namespace Testing {
-  export const Person = Schema.Struct({
-    name: Schema.String,
-    username: Schema.String,
-    email: Schema.String,
-    tasks: Schema.mutable(Schema.Array(Schema.suspend((): Type.Ref<Task> => Type.Ref(Task)))),
-    address: Schema.Struct({
-      city: Schema.optional(Schema.String),
-      state: Schema.optional(Schema.String),
-      zip: Schema.optional(Schema.String),
-      coordinates: Schema.Struct({
-        lat: Schema.optional(Schema.Number),
-        lng: Schema.optional(Schema.Number),
-      }),
-    }),
-  }).pipe(
-    Schema.partial,
-    Type.Obj({
-      typename: 'example.com/type/Person',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Person extends Schema.Schema.Type<typeof Person> {}
-
-  export const Task = Schema.Struct({
-    title: Schema.optional(Schema.String),
-    completed: Schema.optional(Schema.Boolean),
-    assignee: Schema.optional(Type.Ref(Person)),
-    previous: Schema.optional(Schema.suspend((): Type.Ref<Task> => Type.Ref(Task))),
-    subTasks: Schema.optional(Schema.mutable(Schema.Array(Schema.suspend((): Type.Ref<Task> => Type.Ref(Task))))),
-    description: Schema.optional(Schema.String),
-  }).pipe(
-    Schema.partial,
-    Type.Obj({
-      typename: 'example.com/type/Task',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Task extends Schema.Schema.Type<typeof Task> {}
-
-  export const WorksFor = Schema.Struct({
-    since: Schema.optional(Schema.String),
-  }).pipe(
-    Type.Relation({
-      typename: 'example.com/type/WorksFor',
-      version: '0.1.0',
-      source: Person,
-      target: Person,
-    }),
-  );
-
-  export interface WorksFor extends Schema.Schema.Type<typeof WorksFor> {}
-
-  export const HasManager = Schema.Struct({
-    since: Schema.optional(Schema.String),
-  }).pipe(
-    Type.Relation({
-      typename: 'example.com/type/HasManager',
-      version: '0.1.0',
-      source: Person,
-      target: Person,
-    }),
-  );
-
-  export interface HasManager extends Schema.Schema.Type<typeof HasManager> {}
-
-  export enum RecordType {
-    UNDEFINED = 0,
-    PERSONAL = 1,
-    WORK = 2,
-  }
-
-  export const Container = Schema.Struct({
-    objects: Schema.mutable(Schema.Array(Type.Ref(Type.Expando))),
-    records: Schema.mutable(
-      Schema.Array(
-        Schema.partial(
-          Schema.Struct({
-            title: Schema.String,
-            description: Schema.String,
-            contacts: Schema.mutable(Schema.Array(Type.Ref(Person))),
-            type: Schema.Enums(RecordType),
-          }),
-        ),
-      ),
-    ),
-  }).pipe(
-    Schema.partial,
-    Type.Obj({
-      typename: 'example.com/type/Container',
-      version: '0.1.0',
-    }),
-  );
-}