@dxos/echo 0.8.4-main.406dc2a → 0.8.4-main.59c2e9b

package/src/internal/types/types.ts

@@ -1,176 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-import { Reference } from '@dxos/echo-protocol';
-import { type JsonPath, splitJsonPath } from '@dxos/effect';
-import { DXN, type ObjectId } from '@dxos/keys';
-import { getDeep, setDeep } from '@dxos/util';
-
-import { getSchemaDXN } from '../ast';
-import { type EntityKindId, type ObjectMeta, getType, getTypename } from '../object';
-import { ATTR_META } from '../object/model';
-
-/**
- * Base type for all data objects (reactive, ECHO, and other raw objects).
- * NOTE: This describes the base type for all database objects.
- * It is stricter than `T extends {}` or `T extends object`.
- */
-// TODO(dmaretskyi): Rename AnyProperties.
-// TODO(dmaretskyi): Prefer `Record<string, unknown>` over `any`.
-/**
- * @deprecated use Obj.Any
- */
-export type BaseObject = Record<string, any>;
-
-/**
- * Marker interface for object with an `id`.
- */
-export interface HasId {
-  readonly id: ObjectId;
-}
-
-// TODO(dmaretskyi): Remove; this type effectively disables type safety due to `any`.
-export type WithId<T extends BaseObject = BaseObject> = T & HasId;
-
-export type ExcludeId<T extends BaseObject> = Omit<T, 'id'>;
-
-/**
- * Properties that are required for object creation.
- */
-// TODO(dmaretskyi): Rename `MakeProps`?
-export type CreationProps<T extends BaseObject> = Omit<T, 'id' | typeof EntityKindId>;
-
-export type PropertyKey<T extends BaseObject> = Extract<keyof ExcludeId<T>, string>;
-
-// TODO(dmaretskyi): Remove. This should be using the symbol type.
-export type WithMeta = { [ATTR_META]?: ObjectMeta };
-
-/**
- * The raw object should not include the ECHO id, but may include metadata.
- */
-export const RawObject = <S extends Schema.Schema.AnyNoContext>(
-  schema: S,
-): Schema.Schema<ExcludeId<Schema.Schema.Type<S>> & WithMeta, Schema.Schema.Encoded<S>> => {
-  return Schema.make(SchemaAST.omit(schema.ast, ['id']));
-};
-
-//
-// Utils
-//
-
-/**
- * Utility to split meta property from raw object.
- * @deprecated Bad API.
- */
-export const splitMeta = <T>(object: T & WithMeta): { object: T; meta?: ObjectMeta } => {
-  const meta = object[ATTR_META];
-  delete object[ATTR_META];
-  return { meta, object };
-};
-
-// TODO(burdon): Move to `@dxos/util`.
-export const getValue = <T extends object>(obj: T, path: JsonPath): any => {
-  return getDeep(
-    obj,
-    splitJsonPath(path).map((p) => p.replace(/[[\]]/g, '')),
-  );
-};
-
-// TODO(burdon): Move to `@dxos/util`.
-export const setValue = <T extends object>(obj: T, path: JsonPath, value: any): T => {
-  return setDeep(
-    obj,
-    splitJsonPath(path).map((p) => p.replace(/[[\]]/g, '')),
-    value,
-  );
-};
-
-/**
- * Returns a reference that will be used to point to a schema.
- * @deprecated Use {@link getSchemaDXN} instead.
- */
-export const getTypeReference = (schema: Schema.Schema.All | undefined): Reference | undefined => {
-  if (!schema) {
-    return undefined;
-  }
-
-  const schemaDXN = getSchemaDXN(schema);
-  if (!schemaDXN) {
-    return undefined;
-  }
-  return Reference.fromDXN(schemaDXN);
-};
-
-/**
- * Returns a reference that will be used to point to a schema.
- * @throws If it is not possible to reference this schema.
- *
- * @deprecated Use {@link getSchemaDXN} instead.
- */
-export const requireTypeReference = (schema: Schema.Schema.AnyNoContext): Reference => {
-  const typeReference = getTypeReference(schema);
-  if (typeReference == null) {
-    // TODO(burdon): Catalog user-facing errors (this is too verbose).
-    throw new Error('Schema must be defined via TypedObject.');
-  }
-
-  return typeReference;
-};
-
-// TODO(burdon): Can we use `Schema.is`?
-/**
- * Checks if the object is an instance of the schema.
- * Only typename is compared, the schema version is ignored.
- *
- * The following cases are considered to mean that the object is an instance of the schema:
- *  - Object was created with this exact schema.
- *  - Object was created with a different version of this schema.
- *  - Object was created with a different schema (maybe dynamic) that has the same typename.
- */
-export const isInstanceOf = <Schema extends Schema.Schema.AnyNoContext>(
-  schema: Schema,
-  object: any,
-): object is Schema.Schema.Type<Schema> => {
-  if (object == null) {
-    return false;
-  }
-
-  const schemaDXN = getSchemaDXN(schema);
-  if (!schemaDXN) {
-    throw new Error('Schema must have an object annotation.');
-  }
-
-  const type = getType(object);
-  if (type && DXN.equals(type, schemaDXN)) {
-    return true;
-  }
-
-  const typename = getTypename(object);
-  if (!typename) {
-    return false;
-  }
-
-  const typeDXN = schemaDXN.asTypeDXN();
-  if (!typeDXN) {
-    return false;
-  }
-
-  return typeDXN.type === typename;
-};
-
-/**
- * Object that has an associated typename.
- * The typename is retrievable using {@link getTypename}.
- * The object can be used with {@link isInstanceOf} to check if it is an instance of a schema.
- */
-export type HasTypename = {};
-
-/**
- * Canonical type for all ECHO objects.
- */
-// TODO(burdon): Reconcile with Obj.Any, Relation.Any.
-export interface AnyEchoObject extends HasId, HasTypename {}

package/src/internal/types/util.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type BaseObject } from './types';
-
-export type ToMutable<T> = T extends BaseObject
-  ? { -readonly [K in keyof T]: T[K] extends readonly (infer U)[] ? U[] : T[K] }
-  : T;

package/src/query/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './query';
-export * as Tag from './tag';

package/src/query/query.test.ts

@@ -1,401 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import { describe, expect, test } from 'vitest';
-
-import { QueryAST } from '@dxos/echo-protocol';
-import { DXN } from '@dxos/keys';
-import { log } from '@dxos/log';
-
-import * as Obj from '../Obj';
-import * as Ref from '../Ref';
-import * as Type from '../Type';
-
-import { Filter, Order, Query } from './query';
-
-//
-// Example schema
-//
-
-// TODO(dmaretskyi): Need common set of test types.
-const Person = Schema.Struct({
-  name: Schema.String,
-  email: Schema.optional(Schema.String),
-  age: Schema.optional(Schema.Number),
-  fields: Schema.Struct({
-    label: Schema.String,
-    value: Schema.String,
-  }).pipe(Schema.Array, Schema.optional),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Person',
-    version: '0.1.0',
-  }),
-);
-interface Person extends Schema.Schema.Type<typeof Person> {}
-
-const Organization = Schema.Struct({
-  name: Schema.String,
-  properties: Schema.optional(
-    Schema.Record({
-      key: Schema.String,
-      value: Schema.String,
-    }),
-  ),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Organization',
-    version: '0.1.0',
-  }),
-);
-interface Organization extends Schema.Schema.Type<typeof Organization> {}
-
-const WorksFor = Schema.Struct({
-  since: Schema.String,
-}).pipe(
-  Type.Relation({
-    typename: 'dxos.org/type/WorksFor',
-    version: '0.1.0',
-    source: Person,
-    target: Organization,
-  }),
-);
-interface WorksFor extends Schema.Schema.Type<typeof WorksFor> {}
-
-const Task = Schema.Struct({
-  title: Schema.String,
-  createdAt: Schema.String,
-  assignee: Schema.optional(Type.Ref(Person)),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/Task', version: '0.1.0' }));
-interface Task extends Schema.Schema.Type<typeof Task> {}
-
-//
-// Example queries
-//
-
-describe('query api', () => {
-  describe('Query', () => {
-    test('get all people', () => {
-      const getAllPeople = Query.type(Person);
-
-      log('query', { ast: getAllPeople.ast });
-      Schema.validateSync(QueryAST.Query)(getAllPeople.ast);
-      console.log('getAllPeople', JSON.stringify(getAllPeople.ast, null, 2));
-    });
-
-    test('get all people ordered by name', () => {
-      const getAllPeopleOrderedByName = Query.type(Person).orderBy(Order.property('name', 'asc'));
-
-      log('query', { ast: getAllPeopleOrderedByName.ast });
-      Schema.validateSync(QueryAST.Query)(getAllPeopleOrderedByName.ast);
-      console.log('getAllPeopleOrderedByName', JSON.stringify(getAllPeopleOrderedByName.ast, null, 2));
-    });
-
-    test('get all people named Fred', () => {
-      const PeopleNamedFred = Query.select(Filter.type(Person, { name: 'Fred' }));
-
-      log('query', { ast: PeopleNamedFred.ast });
-      Schema.validateSync(QueryAST.Query)(PeopleNamedFred.ast);
-      console.log('PeopleNamedFred', JSON.stringify(PeopleNamedFred.ast, null, 2));
-    });
-
-    test('get all people with field of "label" set to "Research"', () => {
-      const PeopleWithFieldLabelSetToResearch = Query.select(
-        Filter.type(Person, { fields: Filter.contains({ label: 'label', value: 'Research' }) }),
-      );
-
-      log('query', { ast: PeopleWithFieldLabelSetToResearch.ast });
-      Schema.validateSync(QueryAST.Query)(PeopleWithFieldLabelSetToResearch.ast);
-      console.log('PeopleWithFieldLabelSetToResearch', JSON.stringify(PeopleWithFieldLabelSetToResearch.ast, null, 2));
-    });
-
-    test('get all orgs with property "label" set to "Research"', () => {
-      const OrgsWithPropertyLabelSetToResearch = Query.select(
-        Filter.type(Organization, { properties: { label: 'Research' } }),
-      );
-
-      log('query', { ast: OrgsWithPropertyLabelSetToResearch.ast });
-      Schema.validateSync(QueryAST.Query)(OrgsWithPropertyLabelSetToResearch.ast);
-      console.log(
-        'OrgsWithPropertyLabelSetToResearch',
-        JSON.stringify(OrgsWithPropertyLabelSetToResearch.ast, null, 2),
-      );
-    });
-
-    test('get all orgs Fred worked for since 2020', () => {
-      const fred = Obj.make(Person, { name: 'Fred' });
-      const OrganizationsFredWorkedForSince2020 = Query.select(Filter.type(Person, { id: fred.id }))
-        .sourceOf(WorksFor, { since: Filter.gt('2020') })
-        .target();
-
-      log('query', { ast: OrganizationsFredWorkedForSince2020.ast });
-      Schema.validateSync(QueryAST.Query)(OrganizationsFredWorkedForSince2020.ast);
-      console.log(
-        'OrganizationsFredWorkedForSince2020',
-        JSON.stringify(OrganizationsFredWorkedForSince2020.ast, null, 2),
-      );
-    });
-
-    test('get all tasks for Fred', () => {
-      const fred = Obj.make(Person, { name: 'Fred' });
-      const TasksForFred = Query.select(Filter.type(Person, { id: fred.id })).referencedBy(Task, 'assignee');
-
-      log('query', { ast: TasksForFred.ast });
-      Schema.validateSync(QueryAST.Query)(TasksForFred.ast);
-      console.log('TasksForFred', JSON.stringify(TasksForFred.ast, null, 2));
-    });
-
-    test('get all tasks for employees of Cyberdyne', () => {
-      const TasksForEmployeesOfCyberdyne = Query.select(Filter.type(Organization, { name: 'Cyberdyne' }))
-        .targetOf(WorksFor)
-        .source()
-        .referencedBy(Task, 'assignee');
-
-      log('query', { ast: TasksForEmployeesOfCyberdyne.ast });
-      Schema.validateSync(QueryAST.Query)(TasksForEmployeesOfCyberdyne.ast);
-      console.log('TasksForEmployeesOfCyberdyne', JSON.stringify(TasksForEmployeesOfCyberdyne.ast, null, 2));
-    });
-
-    test('get all people or orgs', () => {
-      const PeopleOrOrganizations = Query.all(
-        Query.select(Filter.type(Person)),
-        Query.select(Filter.type(Organization)),
-      );
-
-      log('query', { ast: PeopleOrOrganizations.ast });
-      Schema.validateSync(QueryAST.Query)(PeopleOrOrganizations.ast);
-      console.log('PeopleOrOrganizations', JSON.stringify(PeopleOrOrganizations.ast, null, 2));
-    });
-
-    test('get all people not in orgs', () => {
-      const PeopleNotInOrganizations = Query.without(
-        Query.select(Filter.type(Person)),
-        Query.select(Filter.type(Person)).sourceOf(WorksFor).source(),
-      );
-
-      log('query', { ast: PeopleNotInOrganizations.ast });
-      Schema.validateSync(QueryAST.Query)(PeopleNotInOrganizations.ast);
-      console.log('PeopleNotInOrganizations', JSON.stringify(PeopleNotInOrganizations.ast, null, 2));
-    });
-
-    test('get assignees of all tasks created after 2020', () => {
-      const AssigneesOfAllTasksCreatedAfter2020 = Query.select(
-        Filter.type(Task, { createdAt: Filter.gt('2020') }),
-      ).reference('assignee');
-
-      log('query', { ast: AssigneesOfAllTasksCreatedAfter2020.ast });
-      Schema.validateSync(QueryAST.Query)(AssigneesOfAllTasksCreatedAfter2020.ast);
-      console.log(
-        'AssigneesOfAllTasksCreatedAfter2020',
-        JSON.stringify(AssigneesOfAllTasksCreatedAfter2020.ast, null, 2),
-      );
-    });
-
-    test('untyped full-text search', () => {
-      const contactFullTextSearch = Query.select(Filter.text('Bill'));
-
-      log('query', { ast: contactFullTextSearch.ast });
-      Schema.validateSync(QueryAST.Query)(contactFullTextSearch.ast);
-      expect(contactFullTextSearch.ast).toMatchInlineSnapshot(`
-      {
-        "filter": {
-          "searchKind": undefined,
-          "text": "Bill",
-          "type": "text-search",
-        },
-        "type": "select",
-      }
-    `);
-    });
-
-    test('typed full-text search', () => {
-      const contactFullTextSearch = Query.select(Filter.type(Person)).select(Filter.text('Bill'));
-
-      log('query', { ast: contactFullTextSearch.ast });
-      Schema.validateSync(QueryAST.Query)(contactFullTextSearch.ast);
-      expect(contactFullTextSearch.ast).toMatchInlineSnapshot(`
-      {
-        "filter": {
-          "searchKind": undefined,
-          "text": "Bill",
-          "type": "text-search",
-        },
-        "selection": {
-          "filter": {
-            "id": undefined,
-            "props": {},
-            "type": "object",
-            "typename": "dxn:type:dxos.org/type/Person:0.1.0",
-          },
-          "type": "select",
-        },
-        "type": "filter",
-      }
-    `);
-    });
-
-    test('filter by ref', () => {
-      const fred = Obj.make(Person, { name: 'Fred' });
-      const tasksByFred = Filter.type(Task, { assignee: Ref.make(fred) });
-      expect(tasksByFred.ast).toEqual({
-        props: {
-          assignee: {
-            operator: 'eq',
-            type: 'compare',
-            value: {
-              '/': DXN.fromLocalObjectId(fred.id).toString(),
-            },
-          },
-        },
-        type: 'object',
-        typename: 'dxn:type:dxos.org/type/Task:0.1.0',
-      });
-      console.log('tasksByFred', JSON.stringify(tasksByFred.ast, null, 2));
-    });
-
-    test('select orgs and people', () => {
-      const orgsAndPeople = Query.select(Filter.or(Filter.type(Organization), Filter.type(Person)));
-
-      Schema.validateSync(QueryAST.Query)(orgsAndPeople.ast);
-      expect(orgsAndPeople.ast).toMatchInlineSnapshot(`
-      {
-        "filter": {
-          "filters": [
-            {
-              "id": undefined,
-              "props": {},
-              "type": "object",
-              "typename": "dxn:type:dxos.org/type/Organization:0.1.0",
-            },
-            {
-              "id": undefined,
-              "props": {},
-              "type": "object",
-              "typename": "dxn:type:dxos.org/type/Person:0.1.0",
-            },
-          ],
-          "type": "or",
-        },
-        "type": "select",
-      }
-    `);
-    });
-
-    test('select everything but orgs and people', () => {
-      const everythingButOrgsAndPeople = Query.select(
-        Filter.not(Filter.or(Filter.type(Organization), Filter.type(Person))),
-      );
-
-      Schema.validateSync(QueryAST.Query)(everythingButOrgsAndPeople.ast);
-      expect(everythingButOrgsAndPeople.ast).toMatchInlineSnapshot(`
-      {
-        "filter": {
-          "filter": {
-            "filters": [
-              {
-                "id": undefined,
-                "props": {},
-                "type": "object",
-                "typename": "dxn:type:dxos.org/type/Organization:0.1.0",
-              },
-              {
-                "id": undefined,
-                "props": {},
-                "type": "object",
-                "typename": "dxn:type:dxos.org/type/Person:0.1.0",
-              },
-            ],
-            "type": "or",
-          },
-          "type": "not",
-        },
-        "type": "select",
-      }
-    `);
-    });
-
-    test('select deleted tasks', () => {
-      const deletedTasks = Query.select(Filter.type(Task)).options({
-        deleted: 'only',
-      });
-
-      Schema.validateSync(QueryAST.Query)(deletedTasks.ast);
-      expect(deletedTasks.ast).toMatchInlineSnapshot(`
-      {
-        "options": {
-          "deleted": "only",
-        },
-        "query": {
-          "filter": {
-            "id": undefined,
-            "props": {},
-            "type": "object",
-            "typename": "dxn:type:dxos.org/type/Task:0.1.0",
-          },
-          "type": "select",
-        },
-        "type": "options",
-      }
-    `);
-    });
-
-    test('filter by tags', () => {
-      const query = Query.select(Filter.type(Task)).select(Filter.tag('important'));
-      Schema.validateSync(QueryAST.Query)(query.ast);
-      expect(query.ast).toMatchInlineSnapshot(`
-        {
-          "filter": {
-            "tag": "important",
-            "type": "tag",
-          },
-          "selection": {
-            "filter": {
-              "id": undefined,
-              "props": {},
-              "type": "object",
-              "typename": "dxn:type:dxos.org/type/Task:0.1.0",
-            },
-            "type": "select",
-          },
-          "type": "filter",
-        }
-      `);
-    });
-
-    test.skip('chain', () => {
-      // NOTE: Can't support props without type since they can't be inferred.
-      // const f1: Filter<Person> = Filter.props({ name: 'Fred' });
-
-      // const x = Query.select(Filter.props({ id: '123' }));
-      const y = Query.select(Filter.type(Person));
-
-      const or = Filter.or(Filter.type(Person, { id: Filter.in('1', '2', '3') }), Filter.type(Organization));
-
-      const and = Filter.and(
-        Filter.type(Person, { id: Filter.in('1', '2', '3') }),
-        Filter.type(Person, { name: 'Fred' }),
-      );
-
-      const q = Query
-        //
-        // NOTE: Can't support functions since they can't be serialized (to server).
-        // .filter((object) => Math.random() > 0.5)
-        .select(Filter.type(Person))
-        .select(Filter.type(Person, { name: 'Fred' }))
-        .select({ age: Filter.between(20, 40) })
-        .select(Filter.and(Filter.type(Person), Filter.type(Person, { name: Filter.in('bob', 'bill') })));
-
-      log('stuff', { fOr: or, fAnd: and, q, y });
-    });
-  });
-
-  describe('Filter', () => {
-    test('Filter.or(Filter.typename(...))', () => {
-      const filter = Filter.or(Filter.typename('dxos.org/type/Person'));
-      // TODO(dmaretskyi): Give vitest type-tests a try.
-      const _isAssignable: Obj.Any = null as any as Filter.Type<typeof filter>;
-    });
-  });
-});