@dxos/echo 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

package/src/testing/test-schema.ts

@@ -0,0 +1,240 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import * as Obj from '../Obj';
+import * as Ref from '../Ref';
+import * as Type from '../Type';
+
+export namespace TestSchema {
+  //
+  // Expando
+  //
+
+  /**
+   * Expando object is an object with an arbitrary set of properties.
+   * This is the test variant with example.com namespace.
+   */
+  export const Expando = Schema.Struct({}, { key: Schema.String, value: Schema.Any }).pipe(
+    Type.object({
+      typename: 'com.example.type.expando',
+      version: '0.1.0',
+    }),
+  );
+
+  export interface Expando extends Schema.Schema.Type<typeof Expando> {}
+
+  //
+  // Example
+  //
+
+  const Nested = Schema.Struct({
+    field: Schema.String,
+  });
+
+  export class TestClass {
+    field = 'value';
+    toJSON() {
+      return { field: this.field };
+    }
+  }
+
+  /** @deprecated Use another test schema or create a specific local test schema. */
+  export const ExampleSchema = Schema.Struct({
+    string: Schema.String,
+    number: Schema.Number,
+    boolean: Schema.Boolean,
+    null: Schema.Null,
+    undefined: Schema.Undefined,
+    stringArray: Schema.Array(Schema.String),
+    twoDimNumberArray: Schema.Array(Schema.Array(Schema.Number)),
+    nested: Nested,
+    nestedArray: Schema.Array(Nested),
+    nestedNullableArray: Schema.Array(Schema.Union(Nested, Schema.Null)),
+    reference: Schema.suspend((): Ref.RefSchema<Example> => Ref.Ref(Example)),
+    referenceArray: Schema.Array(Schema.suspend((): Ref.RefSchema<Example> => Ref.Ref(Example))),
+    classInstance: Schema.instanceOf(TestClass),
+    other: Schema.Any,
+  }).pipe(Schema.partial);
+
+  /** @deprecated Use another test schema or create a specific local test schema. */
+  export interface ExampleSchema extends Schema.Schema.Type<typeof ExampleSchema> {}
+
+  /** @deprecated Use another test schema or create a specific local test schema. */
+  export const Example = ExampleSchema.pipe(
+    Type.object({
+      typename: 'com.example.type.example',
+      version: '0.1.0',
+    }),
+  );
+
+  /** @deprecated Use another test schema or create a specific local test schema. */
+  export interface Example extends Schema.Schema.Type<typeof Example> {}
+
+  //
+  // Message
+  //
+
+  // TODO(burdon): Support defaults directly on Type: `make` is erased by `pipe(Type.Obj)`.
+  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.object({
+      typename: 'com.example.type.message',
+      version: '0.1.0',
+    }),
+  );
+
+  export interface Message extends Schema.Schema.Type<typeof Message> {}
+
+  //
+  // Organization
+  //
+
+  export const Organization = Schema.Struct({
+    name: Schema.String,
+    properties: Schema.optional(
+      Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+      }),
+    ),
+  }).pipe(
+    Type.object({
+      typename: 'com.example.type.organization',
+      version: '0.1.0',
+    }),
+  );
+
+  export interface Organization extends Schema.Schema.Type<typeof Organization> {}
+
+  //
+  // Person
+  //
+
+  export const Person = Schema.Struct({
+    name: Schema.String,
+    username: Schema.String,
+    email: Schema.String,
+    age: Schema.Number.pipe(Schema.optional),
+    tasks: Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
+    employer: Schema.optional(Ref.Ref(Organization)),
+    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),
+      }),
+    }),
+    fields: Schema.Struct({
+      label: Schema.String,
+      value: Schema.String,
+    }).pipe(Schema.Array, Schema.optional),
+  }).pipe(
+    Schema.partial,
+    Type.object({
+      typename: 'com.example.type.person',
+      version: '0.1.0',
+    }),
+  );
+
+  export interface Person extends Schema.Schema.Type<typeof Person> {}
+
+  //
+  // Task
+  //
+
+  export const Task = Schema.Struct({
+    title: Schema.optional(Schema.String),
+    deadline: Schema.optional(Schema.String),
+    completed: Schema.optional(Schema.Boolean),
+    assignee: Schema.optional(Ref.Ref(Person)),
+    previous: Schema.optional(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
+    subTasks: Schema.optional(Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task)))),
+    description: Schema.optional(Schema.String),
+  }).pipe(
+    Schema.partial,
+    Type.object({
+      typename: 'com.example.type.task',
+      version: '0.1.0',
+    }),
+  );
+
+  export interface Task extends Schema.Schema.Type<typeof Task> {}
+
+  //
+  // HasManager
+  //
+
+  export const HasManager = Schema.Struct({}).pipe(
+    Type.relation({
+      typename: 'com.example.type.has-manager',
+      version: '0.1.0',
+      source: Person,
+      target: Person,
+    }),
+  );
+
+  export interface HasManager extends Schema.Schema.Type<typeof HasManager> {}
+
+  //
+  // EmployedBy
+  //
+
+  export const EmployedBy = Schema.Struct({
+    role: Schema.String,
+    since: Schema.optional(Schema.String),
+  }).pipe(
+    Type.relation({
+      typename: 'com.example.type.employed-by',
+      version: '0.1.0',
+      source: Person,
+      target: Organization,
+    }),
+  );
+
+  export interface EmployedBy extends Schema.Schema.Type<typeof EmployedBy> {}
+
+  //
+  // RecordType
+  //
+
+  export enum RecordType {
+    UNDEFINED = 0,
+    PERSONAL = 1,
+    WORK = 2,
+  }
+
+  export const Container = Schema.Struct({
+    objects: Schema.Array(Ref.Ref(Obj.Unknown)),
+    records: Schema.Array(
+      Schema.partial(
+        Schema.Struct({
+          title: Schema.String,
+          description: Schema.String,
+          contacts: Schema.Array(Ref.Ref(Person)),
+          type: Schema.Enums(RecordType),
+        }),
+      ),
+    ),
+  }).pipe(
+    Schema.partial,
+    Type.object({
+      typename: 'com.example.type.container',
+      version: '0.1.0',
+    }),
+  );
+
+  export interface Container extends Schema.Schema.Type<typeof Container> {}
+}

package/src/testing/util.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type * as Schema from 'effect/Schema';
+import type * as SchemaAST from 'effect/SchemaAST';
+
+import { assertArgument } from '@dxos/invariant';
+import { deepMapValues } from '@dxos/util';
+
+import { EchoSchema, PersistentSchema, getSchemaTypename, makeObject, subscribe, toJsonSchema } from '../internal';
+
+/**
+ * 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, version = '0.1.0'): EchoSchema => {
+  const jsonSchema = toJsonSchema(schema);
+  const typename = getSchemaTypename(schema);
+  assertArgument(typename, 'typename', 'Schema does not have a typename.');
+  const echoSchema = new EchoSchema(makeObject(PersistentSchema, { typename, version, jsonSchema }));
+
+  // TODO(burdon): Unsubscribe is never called.
+  subscribe(echoSchema.persistentSchema, () => {
+    echoSchema._invalidate();
+  });
+
+  return echoSchema;
+};
+
+/**
+ * Converts AST to a format that can be compared with test matchers.
+ */
+export const prepareAstForCompare = (obj: SchemaAST.AST): any =>
+  deepMapValues(obj, (value: any, recurse: any) => {
+    if (typeof value === 'function') {
+      return null;
+    }
+
+    if (value instanceof RegExp) {
+      return value;
+    }
+
+    // Convert symbols to strings.
+    if (typeof value === 'object') {
+      const clone = { ...value };
+      for (const sym of Object.getOwnPropertySymbols(clone as any)) {
+        clone[sym.toString()] = clone[sym];
+        delete clone[sym];
+      }
+
+      return recurse(clone);
+    }
+
+    return recurse(value);
+  });
+
+/**
+ * Creates an update counter that tracks changes to reactive objects.
+ * @param objects - Reactive objects to subscribe to.
+ * @returns An object with a count property and Symbol.dispose for cleanup.
+ */
+export const updateCounter = (...objects: object[]) => {
+  let updateCount = 0;
+
+  const unsubscribes = objects.map((obj) =>
+    subscribe(obj, () => {
+      updateCount++;
+    }),
+  );
+
+  const unsubscribeAll = () => {
+    for (const unsub of unsubscribes) {
+      unsub();
+    }
+  };
+
+  return {
+    // https://github.com/tc39/proposal-explicit-resource-management
+    [Symbol.dispose]: unsubscribeAll,
+    get count() {
+      return updateCount;
+    },
+  };
+};