@dxos/react-ui-table 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/model/table-model.ts

@@ -5,13 +5,12 @@
 import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { Resource } from '@dxos/context';
-import { type Database, Format, Obj, Order, Query, type QueryAST, Ref } from '@dxos/echo';
-import { type View } from '@dxos/echo';
-import { type JsonProp, type JsonSchemaType, type Mutable, toEffectSchema } from '@dxos/echo/internal';
-import { getSnapshot } from '@dxos/echo/internal';
-import { getValue, setValue } from '@dxos/effect';
+import { type Database, Format, Obj, Order, Query, type QueryAST, Ref, Type, type View } from '@dxos/echo';
+import { type JsonSchema as JsonSchemaType, toEffectSchema } from '@dxos/echo/JsonSchema';
+import { getSnapshot, type Mutable } from '@dxos/echo/Obj';
+import { SchemaEx } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
-import { ObjectId } from '@dxos/keys';
+import { EntityId } from '@dxos/keys';
 import { type Label } from '@dxos/react-ui';
 import { formatForEditing, parseValue } from '@dxos/react-ui-form';
 import {
@@ -38,7 +37,7 @@ export type FieldSortType = {
 import { type SelectionMode, SelectionModel } from './selection-model';
 
 /**
- * Callback type for wrapping mutations in Obj.change().
+ * Callback type for wrapping mutations in Obj.update().
  * Contains separate callbacks for table object and row mutations.
  */
 export type TableChangeCallback<T extends TableRow> = {
@@ -53,10 +52,10 @@ export type TableChangeCallback<T extends TableRow> = {
  * Use this when the table and rows are stored in the ECHO database.
  */
 export const createEchoChangeCallback = <T extends TableRow>(table: Table.Table): TableChangeCallback<T> => ({
-  table: (mutate) => Obj.change(table, (table) => mutate(table as unknown as Table.Table)),
+  table: (mutate) => Obj.update(table, (table) => mutate(table as unknown as Table.Table)),
   row: (row, mutate) => {
     if (Obj.isObject(row)) {
-      Obj.change(row, (row) => mutate(row as T));
+      Obj.update(row, (row) => mutate(row as T));
     } else {
       mutate(row);
     }
@@ -85,7 +84,7 @@ export type DraftRow<T extends TableRow = TableRow> = {
 };
 
 // TODO(burdon): Use schema types.
-export type TableRow = Record<JsonProp, any> & { id: string };
+export type TableRow = Record<SchemaEx.JsonProp, any> & { id: string };
 
 export type TableRowAction = {
   id: string;
@@ -112,7 +111,7 @@ export type TableModelProps<T extends TableRow = TableRow> = {
   projection: ProjectionModel;
   db?: Database.Database;
   /**
-   * Callbacks to wrap mutations in Obj.change().
+   * Callbacks to wrap mutations in Obj.update().
    * Use createEchoChangeCallback() for ECHO-backed objects or createDirectChangeCallback() for plain objects.
    */
   change?: TableChangeCallback<T>;
@@ -210,10 +209,15 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
     this._cellUpdateCounter = Atom.make<number>(0);
 
     // Create derived atom for persisted sort from view.query.ast.
-    this._persistedSort = Atom.make((_get) => {
-      // Note: This depends on the view being loaded and the projection being set.
-      // The view is loaded in _open().
-      const viewSnapshot = Obj.getSnapshot(this.view);
+    this._persistedSort = Atom.make((get) => {
+      // Subscribe to the view ref's atom so this recomputes once the reference resolves; the view
+      // is loaded asynchronously in _open() and is absent before then (and after disposal).
+      const view = get(this._object.view.atom);
+      if (!view) {
+        return undefined;
+      }
+
+      const viewSnapshot = Obj.getSnapshot(view);
       const ast = viewSnapshot.query.ast;
       const orders = extractOrder(ast);
 
@@ -258,8 +262,8 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       const fieldProjection = this._projection.getFieldProjection(field.id);
 
       const sorted = [...rows].sort((a, b) => {
-        const aValue = getValue(a, field.path);
-        const bValue = getValue(b, field.path);
+        const aValue = SchemaEx.getValue(a, field.path);
+        const bValue = SchemaEx.getValue(b, field.path);
         return compareValues(aValue, bValue, fieldProjection.props.format, sort.direction);
       });
 
@@ -300,7 +304,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
   }
 
   public get id(): string {
-    return Obj.getDXN(this._object).toString();
+    return Obj.getURI(this._object);
   }
 
   public get view(): View.View {
@@ -524,7 +528,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
     }
 
     // NOTE(ZaymonFC): This is initialized with id because it's required in all schemata?
-    const draftData = { id: ObjectId.random() } as any as T;
+    const draftData = { id: EntityId.random() } as any as T;
     const validationErrors = this.validateDraftRowData(draftData);
 
     const draftRow: DraftRow<T> = {
@@ -623,14 +627,14 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
     if (plane === 'frozenRowsEnd') {
       // Get data from draft row
       if (row >= 0 && row < this._registry.get(this._draftRows).length) {
-        value = getValue(this._registry.get(this._draftRows)[row].data, field.path);
+        value = SchemaEx.getValue(this._registry.get(this._draftRows)[row].data, field.path);
       } else {
         return undefined;
       }
     } else {
       // Get data from regular row (use sorted rows for display index)
       const sortedRows = this._registry.get(this._sortedRows);
-      value = getValue(sortedRows[row], field.path);
+      value = SchemaEx.getValue(sortedRows[row], field.path);
     }
 
     if (value == null) {
@@ -644,7 +648,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
           return ''; // TODO(burdon): Show error.
         }
 
-        return getValue(value.target, field.referencePath);
+        return SchemaEx.getValue(value.target, field.referencePath);
       }
 
       default: {
@@ -677,7 +681,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
 
       const draftRow = this._registry.get(this._draftRows)[row];
       const snapshot = { ...draftRow.data };
-      setValue(snapshot, field.path, transformedValue);
+      SchemaEx.setValue(snapshot, field.path, transformedValue);
 
       const validationErrors = this.validateDraftRowData(snapshot);
       // TODO(thure): These errors sometimes result in a useless message like “is missing” (what is missing?)
@@ -692,17 +696,20 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       const currentRow = this._registry.get(this._rows)[row];
       invariant(currentRow, 'Invalid row index');
 
-      const snapshot = { ...getSnapshot(currentRow) };
-      setValue(snapshot, field.path, transformedValue);
+      // TableRow is a generic type; cast to Obj.Unknown for Echo introspection APIs.
+      const snapshot = { ...getSnapshot(currentRow as unknown as Obj.Unknown) };
+      SchemaEx.setValue(snapshot, field.path, transformedValue);
 
-      const schema = Obj.getSchema(currentRow);
-      invariant(schema);
+      const type = Obj.getType(currentRow as unknown as Obj.Unknown);
+      invariant(type);
+      const schema = Type.getSchema(type);
 
       const validationResult = validateSchema(schema, snapshot);
       if (validationResult && validationResult.length > 0) {
-        const error = validationResult[0];
-        invariant(error.path === field.path);
-        return { valid: false, error: error.message };
+        const error = validationResult.find((err) => err.path === field.path);
+        if (error) {
+          return { valid: false, error: error.message };
+        }
       }
 
       return { valid: true };
@@ -728,7 +735,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
     if (plane === 'frozenRowsEnd') {
       // Update draft row data (draft rows are plain objects, not ECHO objects).
       if (row >= 0 && row < this._registry.get(this._draftRows).length) {
-        setValue(this._registry.get(this._draftRows)[row].data, field.path, transformedValue);
+        SchemaEx.setValue(this._registry.get(this._draftRows)[row].data, field.path, transformedValue);
         // Re-validate the draft row after the update
         this.validateDraftRow(row);
       }
@@ -737,7 +744,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       const sortedRows = this._registry.get(this._sortedRows);
       const rowData = sortedRows[row];
       this._change.row(rowData, (mutableRow) => {
-        setValue(mutableRow, field.path, transformedValue);
+        SchemaEx.setValue(mutableRow, field.path, transformedValue);
       });
     }
   };
@@ -753,10 +760,10 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
     const sortedRows = this._registry.get(this._sortedRows);
     const rowData = sortedRows[row];
 
-    const value = getValue(rowData, field.path);
+    const value = SchemaEx.getValue(rowData, field.path);
     const updatedValue = update(value);
     this._change.row(rowData, (mutableRow) => {
-      setValue(mutableRow, field.path, updatedValue);
+      SchemaEx.setValue(mutableRow, field.path, updatedValue);
     });
   }
 
@@ -894,13 +901,13 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       if (field) {
         // Persist sort to view.query.ast
         const newQuery = baseQuery.orderBy(Order.property<any>(field.path as string, inMemorySort.direction));
-        Obj.change(view, (view) => {
+        Obj.update(view, (view) => {
           view.query.ast = newQuery.ast as Mutable<typeof newQuery.ast>;
         });
       }
     } else {
       // Clear sort from view.query.ast
-      Obj.change(view, (view) => {
+      Obj.update(view, (view) => {
         view.query.ast = baseQuery.ast as Mutable<typeof baseQuery.ast>;
       });
     }

package/src/model/table-presentation.test.ts

@@ -6,7 +6,7 @@ import { Registry } from '@effect-atom/atom-react';
 import * as Schema from 'effect/Schema';
 import { beforeEach, describe, expect, it } from 'vitest';
 
-import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { DXN, Filter, JsonSchema, Query, Type } from '@dxos/echo';
 import { createEchoSchema } from '@dxos/echo/testing';
 import { ProjectionModel, ViewModel, createDirectChangeCallback } from '@dxos/schema';
 
@@ -89,15 +89,10 @@ describe('TablePresentation', () => {
 const Test = Schema.Struct({
   title: Schema.String,
   count: Schema.Number,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
 const createTableModel = (registry: Registry.Registry, props: Partial<TableModelProps> = {}): TableModel => {
-  const schema = createEchoSchema(Test);
+  const schema = createEchoSchema(Type.getSchema(Test));
   const view = ViewModel.make({
     query: Query.select(Filter.type(schema)),
     jsonSchema: schema.jsonSchema,
@@ -107,7 +102,7 @@ const createTableModel = (registry: Registry.Registry, props: Partial<TableModel
     registry,
     view,
     baseSchema: schema.jsonSchema,
-    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(schema)),
+    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(Type.getSchema(schema))),
   });
   projection.normalizeView();
   return new TableModel({ registry, object, projection, ...props });

package/src/model/table-presentation.ts

@@ -5,9 +5,9 @@
 import { Atom, type Registry } from '@effect-atom/atom-react';
 import * as Predicate from 'effect/Predicate';
 
-import { Obj } from '@dxos/echo';
-import { type View } from '@dxos/echo';
-import { Format, TypeEnum, getValue } from '@dxos/echo/internal';
+import { Obj, type View } from '@dxos/echo';
+import { Format, TypeEnum } from '@dxos/echo/Format';
+import { SchemaEx } from '@dxos/effect';
 import { cellClassesForFieldType, formatForDisplay } from '@dxos/react-ui-form';
 import {
   type DxGridCellValue,
@@ -115,7 +115,7 @@ export class TablePresentation<T extends TableRow = TableRow> {
 
     const cell: DxGridCellValue = {
       get value() {
-        const value = getValue(obj, field.path);
+        const value = SchemaEx.getValue(obj, field.path);
         if (value == null) {
           return '';
         }
@@ -135,7 +135,7 @@ export class TablePresentation<T extends TableRow = TableRow> {
               return ''; // TODO(burdon): Show error.
             }
 
-            return getValue(value.target, field.referencePath);
+            return SchemaEx.getValue(value.target, field.referencePath);
           }
 
           default: {
@@ -165,7 +165,7 @@ export class TablePresentation<T extends TableRow = TableRow> {
 
     // Arrays.
     if (props.type === TypeEnum.Array) {
-      const targetArray = getValue(obj, field.path);
+      const targetArray = SchemaEx.getValue(obj, field.path);
       if (targetArray && Array.isArray(targetArray)) {
         // TODO(ZaymonFC): For arrays of objects, objects should have a 'label' annotation on the field
         // that can be used to render tags.
@@ -201,22 +201,22 @@ export class TablePresentation<T extends TableRow = TableRow> {
           })
           .join('');
 
-        cell.accessoryHtml = `<div role='none' class="flex flex-row gap-1 overflow-x-auto">${tags}</div>`;
+        cell.accessoryHtml = `<div class="flex flex-row gap-1 overflow-x-auto">${tags}</div>`;
       }
     }
 
     // References.
     if (props.format === Format.TypeFormat.Ref && props.referenceSchema) {
-      const targetObj = getValue(obj, field.path)?.target;
+      const targetObj = SchemaEx.getValue(obj, field.path)?.target;
       if (targetObj) {
-        const dxn = Obj.getDXN(targetObj)?.toString();
-        cell.accessoryHtml = `<div role="none" class="absolute end-0 inset-y-0 p-(--dx-grid-cell-content-padding-block)"><dx-anchor dxn=${dxn} class="dx-button w-6 aspect-square min-h-0" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-anchor></div>`;
+        const uri = Obj.getURI(targetObj);
+        cell.accessoryHtml = `<div role="none" class="absolute end-0 inset-y-0 p-(--dx-grid-cell-content-padding-block)"><dx-anchor uri=${uri} class="dx-button w-6 aspect-square min-h-0" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-anchor></div>`;
       }
     }
 
     // Booleans.
     if (props.format === Format.TypeFormat.Boolean) {
-      const value = getValue(obj, field.path);
+      const value = SchemaEx.getValue(obj, field.path);
       cell.accessoryHtml = tableControls.switch.render({
         colIndex,
         rowIndex: displayIndex,
@@ -227,7 +227,7 @@ export class TablePresentation<T extends TableRow = TableRow> {
 
     // Single-Selects.
     if (props.format === Format.TypeFormat.SingleSelect) {
-      const value = getValue(obj, field.path);
+      const value = SchemaEx.getValue(obj, field.path);
       const options = this.model.projection.getFieldProjection(field.id).props.options;
       if (options) {
         const option = options.find((o) => o.id === value);
@@ -239,7 +239,7 @@ export class TablePresentation<T extends TableRow = TableRow> {
 
     // Multi-Selects.
     if (props.format === Format.TypeFormat.MultiSelect) {
-      const values = getValue(obj, field.path) as string[] | undefined;
+      const values = SchemaEx.getValue(obj, field.path) as string[] | undefined;
       const options = this.model.projection.getFieldProjection(field.id).props.options;
       if (options && values && values.length > 0) {
         const tags = values
@@ -473,8 +473,8 @@ export const cellClassesForRowSelection = (selected: boolean, selectionMode: Sel
 
   switch (selectionMode) {
     case 'single':
-      return ['dx-grid__cell--no-focus-unfurl !bg-current-surface hover:bg-hover-surface cursor-pointer!'];
+      return ['dx-grid__cell--no-focus-unfurl bg-current-surface! hover:bg-hover-surface cursor-pointer!'];
     case 'multiple':
-      return ['!bg-grid-cell-selected'];
+      return ['bg-grid-cell-selected!'];
   }
 };

package/src/testing/useTestTableModel.ts

@@ -5,13 +5,12 @@
 import { RegistryContext } from '@effect-atom/atom-react';
 import { type RefObject, useCallback, useContext, useMemo, useRef } from 'react';
 
-import { type Database, type Type } from '@dxos/echo';
-import { isMutable } from '@dxos/echo/internal';
+import { type Database, Filter, Type } from '@dxos/echo';
 import { random } from '@dxos/random';
-import { Filter, useQuery, useSchema } from '@dxos/react-client/echo';
+import { useQuery, useType } from '@dxos/react-client/echo';
 import { useClientStory } from '@dxos/react-client/testing';
 import { useGlobalFilteredObjects } from '@dxos/react-ui-search';
-import { type ProjectionModel, getTypenameFromQuery } from '@dxos/schema';
+import { type ProjectionModel, getTypeURIFromQuery } from '@dxos/schema';
 
 import { type TableController } from '../components';
 import { useAddRow, useProjectionModel, useTableModel } from '../hooks';
@@ -45,15 +44,15 @@ export const useTestTableModel = <T extends Type.AnyObj = Type.AnyObj>(): TestTa
 
   const tables = useQuery(space?.db, Filter.type(Table.Table));
   const table = tables.at(0);
-  const typename = table?.view.target?.query ? getTypenameFromQuery(table.view.target.query.ast) : undefined;
-  const schema = useSchema<T>(space?.db, typename);
+  const typeUri = table?.view.target?.query ? getTypeURIFromQuery(table.view.target.query.ast) : undefined;
+  const schema = useType<T>(space?.db, typeUri);
   const projection = useProjectionModel(schema, table, registry);
 
   const features = useMemo(
     () => ({
       selection: { enabled: true, mode: 'multiple' as const },
       dataEditable: true,
-      schemaEditable: schema && isMutable(schema),
+      schemaEditable: schema != null && Type.getDatabase(schema) != null,
     }),
     [schema],
   );

package/src/types/Table.ts

@@ -6,12 +6,17 @@ import * as Match from 'effect/Match';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';
-import { View } from '@dxos/echo';
-import { FormInputAnnotation, type JsonPath, type JsonSchemaType, LabelAnnotation } from '@dxos/echo/internal';
+// QueryAST is referenced indirectly through `Type.InstanceType<typeof TableSchema>`
+// (Ref.Ref(View.View) → View.View → QueryAST.Query) in the emitted .d.ts; the
+// namespace import keeps the inferred types portable.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { DXN, Annotation, JsonSchema, Obj, QueryAST, Ref, Type, View } from '@dxos/echo';
+import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/Annotation';
+import { type JsonSchema as JsonSchemaType } from '@dxos/echo/JsonSchema';
+import { SchemaEx } from '@dxos/effect';
 import { ViewAnnotation } from '@dxos/schema';
 
-export const Table = Schema.Struct({
+const TableSchema = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
 
   view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),
@@ -22,19 +27,15 @@ export const Table = Schema.Struct({
     value: Schema.Number,
   }).pipe(Schema.mutable, FormInputAnnotation.set(false)),
 }).pipe(
-  Type.object({
-    typename: 'org.dxos.type.table',
-    version: '0.1.0',
-  }),
   LabelAnnotation.set(['name']),
-  ViewAnnotation.set(true),
-  Annotation.IconAnnotation.set({
-    icon: 'ph--table--regular',
-    hue: 'green',
-  }),
+  ViewAnnotation.set(['view']),
+  Annotation.IconAnnotation.set({ icon: 'ph--table--regular', hue: 'green' }),
+  Type.makeObject(DXN.make('org.dxos.type.table', '0.1.0')),
 );
 
-export interface Table extends Schema.Schema.Type<typeof Table> {}
+// TODO(wittjosiah): Try to clean up this type inference.
+export interface Table extends Type.InstanceType<typeof TableSchema> {}
+export const Table = TableSchema;
 
 type MakeProps = {
   name?: string;
@@ -55,7 +56,7 @@ export const make = ({ name, sizes = {}, view, jsonSchema }: MakeProps): Table =
     const schema = JsonSchema.toEffectSchema(jsonSchema);
     const properties = SchemaAST.getPropertySignatures(schema.ast);
     for (const property of properties) {
-      const name = property.name.toString() as JsonPath;
+      const name = property.name.toString() as SchemaEx.JsonPath;
       if (sizes?.[name]) {
         table.sizes[name] = sizes[name];
         continue;

package/src/util/dynamic-table.test.ts

@@ -11,13 +11,14 @@ import { type TablePropertyDefinition, getBaseSchema, makeDynamicTable } from '.
 
 describe('makeDynamicTable', () => {
   /**
-   * Base case: plain jsonSchema (not from Echo / JsonSchema.toJsonSchema). Does not exercise the path
-   * where projection or schema are reactive, so this does not reproduce the Obj.change regression.
-   * Confirms makeDynamicTable + setProperties (title) works with plain objects.
+   * Builds the Type entity from a JSON schema, then makes the table.
+   * Confirms makeDynamicTable + setProperties (title) works for the jsonSchema path.
    */
-  test('makeDynamicTable with plain jsonSchema and properties with title does not throw', () => {
+  test('makeDynamicTable from a jsonSchema with properties with title does not throw', () => {
     const registry = Registry.make();
     const jsonSchema = {
+      typename: 'com.example.type.dynamicTablePlain',
+      version: '0.1.0',
       type: 'object' as const,
       properties: {
         id: { type: 'string' as const },
@@ -31,11 +32,8 @@ describe('makeDynamicTable', () => {
     ];
 
     expect(() => {
-      const { projection, object } = makeDynamicTable({
-        registry,
-        jsonSchema,
-        properties,
-      });
+      const { type } = getBaseSchema({ jsonSchema });
+      const { projection, object } = makeDynamicTable({ registry, type, properties });
       expect(projection).toBeDefined();
       expect(object).toBeDefined();
       expect(projection.getFields().length).toBeGreaterThan(0);
@@ -43,25 +41,20 @@ describe('makeDynamicTable', () => {
   });
 
   /**
-   * Regression test for the path where jsonSchema comes from getBaseSchema(typename, properties).
-   * That path uses Echo (ViewModel.make, JsonSchema.toJsonSchema); mutations must run inside Obj.change and on a
-   * cloned schema. This test ensures that flow does not throw.
+   * Builds the Type entity from property definitions, then makes the table.
+   * Confirms makeDynamicTable + setProperties (title) works for the property-definitions path.
    */
-  test('makeDynamicTable with jsonSchema from getBaseSchema(typename, properties) and properties with title does not throw', () => {
+  test('makeDynamicTable from getBaseSchema(typename, properties) with properties with title does not throw', () => {
     const registry = Registry.make();
-    const typename = 'com.example.type.dynamic-table-test';
+    const typename = 'com.example.type.dynamicTableTest';
     const properties: TablePropertyDefinition[] = [
       { name: 'id', format: Format.TypeFormat.String },
       { name: 'name', format: Format.TypeFormat.String, title: 'Name' },
     ];
-    const { jsonSchema } = getBaseSchema({ typename, properties });
 
     expect(() => {
-      const { projection, object } = makeDynamicTable({
-        registry,
-        jsonSchema,
-        properties,
-      });
+      const { type } = getBaseSchema({ typename, properties });
+      const { projection, object } = makeDynamicTable({ registry, type, properties });
       expect(projection).toBeDefined();
       expect(object).toBeDefined();
       expect(projection.getFields().length).toBeGreaterThan(0);

package/src/util/dynamic-table.ts

@@ -5,13 +5,13 @@
 import { type Registry } from '@effect-atom/atom-react';
 import type * as Types from 'effect/Types';
 
-import { Filter, JsonSchema, Obj, Order, Query, type QueryAST, Ref, Type } from '@dxos/echo';
-import { type View } from '@dxos/echo';
+import { Filter, type JsonSchema, Obj, Order, Query, type QueryAST, Ref, Type, type View } from '@dxos/echo';
 import {
   ProjectionModel,
   type SchemaPropertyDefinition,
   ViewModel,
   createEchoChangeCallback,
+  getSchemaFromJsonSchema,
   getSchemaFromPropertyDefinitions,
 } from '@dxos/schema';
 
@@ -31,40 +31,41 @@ export type TablePropertyDefinition = SchemaPropertyDefinition & Partial<Propert
  */
 // TODO(burdon): Remove variance.
 export const getBaseSchema = ({
-  schema,
+  type,
   typename,
   properties,
   jsonSchema,
 }: {
-  schema?: Type.AnyEntity;
+  type?: Type.AnyEntity;
   typename?: string;
   properties?: TablePropertyDefinition[];
   jsonSchema?: Types.DeepMutable<JsonSchema.JsonSchema>;
-}): { typename: string; jsonSchema: Types.DeepMutable<JsonSchema.JsonSchema> } => {
-  if (typename && properties) {
-    const schema = getSchemaFromPropertyDefinitions(typename, properties);
-    return { typename: schema.typename, jsonSchema: JsonSchema.toJsonSchema(schema) };
-  } else if (schema) {
-    return { typename: Type.getTypename(schema)!, jsonSchema: JsonSchema.toJsonSchema(schema) };
-  } else if (typename && jsonSchema) {
-    return { typename, jsonSchema };
-  } else {
+}): { typename: string; type: Type.AnyEntity } => {
+  const resolved =
+    typename && properties
+      ? getSchemaFromPropertyDefinitions(typename, properties)
+      : (type ?? (jsonSchema ? getSchemaFromJsonSchema(jsonSchema, typename) : undefined));
+  if (!resolved) {
     throw new Error('invalid properties');
   }
+
+  return { typename: Type.getTypename(resolved)!, type: resolved };
 };
 
 export const makeDynamicTable = ({
   registry,
-  jsonSchema,
+  type,
   properties,
 }: {
   registry: Registry.Registry;
-  jsonSchema: Types.DeepMutable<JsonSchema.JsonSchema>;
+  type: Type.AnyEntity;
   properties?: TablePropertyDefinition[];
 }): { projection: ProjectionModel; object: Table.Table } => {
+  const jsonSchema = type.jsonSchema;
   const view = ViewModel.make({
     query: Query.select(Filter.everything()),
     jsonSchema,
+    type,
     ...(properties && { fields: properties.map((property) => property.name) }),
   });
   const object = Obj.make(Table.Table, { view: Ref.make(view), sizes: {} });
@@ -73,7 +74,7 @@ export const makeDynamicTable = ({
     registry,
     view,
     baseSchema: jsonSchema,
-    change: createEchoChangeCallback(view, jsonSchema),
+    change: createEchoChangeCallback(view, type),
   });
   projection.normalizeView();
   if (properties && projection.getFields()) {
@@ -93,7 +94,7 @@ const setProperties = (
     const field = projection.getFields().find((field) => field.path === property.name);
     if (field) {
       if (property.size !== undefined) {
-        Obj.change(table, (table) => {
+        Obj.update(table, (table) => {
           table.sizes[field.path] = property.size!;
         });
       }
@@ -111,7 +112,7 @@ const setProperties = (
         const currentQuery = Query.fromAst(Obj.getSnapshot(view).query.ast);
         // Use any type parameter since we're working with dynamic field paths
         const newQuery = currentQuery.orderBy(Order.property<any>(field.path as string, property.sort));
-        Obj.change(view, (view) => {
+        Obj.update(view, (view) => {
           // Type assertion needed because Query AST types have some variance issues.
           view.query.ast = newQuery.ast as typeof view.query.ast;
         });

package/dist/lib/browser/chunk-BF54SSNL.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/Table.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';\nimport { View } from '@dxos/echo';\nimport { FormInputAnnotation, type JsonPath, type JsonSchemaType, LabelAnnotation } from '@dxos/echo/internal';\nimport { ViewAnnotation } from '@dxos/schema';\n\nexport const Table = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n\n  view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),\n\n  sizes: Schema.Record({\n    // TODO(wittjosiah): Should be JsonPath.\n    key: Schema.String,\n    value: Schema.Number,\n  }).pipe(Schema.mutable, FormInputAnnotation.set(false)),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.table',\n    version: '0.1.0',\n  }),\n  LabelAnnotation.set(['name']),\n  ViewAnnotation.set(true),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--table--regular',\n    hue: 'green',\n  }),\n);\n\nexport interface Table extends Schema.Schema.Type<typeof Table> {}\n\ntype MakeProps = {\n  name?: string;\n  sizes?: Record<string, number>;\n  view: View.View;\n  /** Required to auto-size columns. */\n  jsonSchema?: JsonSchemaType;\n};\n\n/**\n * Make a table as a view of a data set.\n */\nexport const make = ({ name, sizes = {}, view, jsonSchema }: MakeProps): Table => {\n  const table = Obj.make(Table, { name, view: Ref.make(view), sizes } as Obj.MakeProps<typeof Table>);\n\n  // Preset sizes.\n  if (jsonSchema) {\n    const schema = JsonSchema.toEffectSchema(jsonSchema);\n    const properties = SchemaAST.getPropertySignatures(schema.ast);\n    for (const property of properties) {\n      const name = property.name.toString() as JsonPath;\n      if (sizes?.[name]) {\n        table.sizes[name] = sizes[name];\n        continue;\n      }\n\n      Match.type<SchemaAST.AST>().pipe(\n        Match.when({ _tag: 'BooleanKeyword' }, () => {\n          table.sizes[name] = 100;\n        }),\n        Match.when({ _tag: 'NumberKeyword' }, () => {\n          table.sizes[name] = 100;\n        }),\n        Match.orElse(() => {\n          // Noop.\n        }),\n      )(property.type);\n    }\n  }\n\n  return table;\n};\n"],
-  "mappings": ";;;;;;;AAAA;;;;;AAIA,YAAYA,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,eAAe;AAE3B,SAASC,YAAYC,YAAYC,KAAKC,KAAKC,YAAY;AACvD,SAASC,YAAY;AACrB,SAASC,qBAAyDC,uBAAuB;AACzF,SAASC,sBAAsB;AAExB,IAAMC,QAAeC,cAAO;EACjCC,MAAaC,cAAOC,KAAYC,eAAQ;EAExCC,MAAMC,IAAIA,IAAIC,KAAKA,IAAI,EAAEJ,KAAKK,oBAAoBC,IAAI,KAAA,CAAA;EAEtDC,OAAcC,cAAO;;IAEnBC,KAAYV;IACZW,OAAcC;EAChB,CAAA,EAAGX,KAAYY,gBAASP,oBAAoBC,IAAI,KAAA,CAAA;AAClD,CAAA,EAAGN,KACDa,KAAKC,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACAC,gBAAgBX,IAAI;EAAC;CAAO,GAC5BY,eAAeZ,IAAI,IAAA,GACnBa,WAAWC,eAAed,IAAI;EAC5Be,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAgBK,IAAMC,OAAO,CAAC,EAAEzB,MAAMS,QAAQ,CAAC,GAAGL,MAAMsB,WAAU,MAAa;AACpE,QAAMC,QAAQC,IAAIH,KAAK3B,OAAO;IAAEE;IAAMI,MAAMC,IAAIoB,KAAKrB,IAAAA;IAAOK;EAAM,CAAA;AAGlE,MAAIiB,YAAY;AACd,UAAMG,SAASC,WAAWC,eAAeL,UAAAA;AACzC,UAAMM,aAAuBC,gCAAsBJ,OAAOK,GAAG;AAC7D,eAAWC,YAAYH,YAAY;AACjC,YAAMhC,QAAOmC,SAASnC,KAAKoC,SAAQ;AACnC,UAAI3B,QAAQT,KAAAA,GAAO;AACjB2B,cAAMlB,MAAMT,KAAAA,IAAQS,MAAMT,KAAAA;AAC1B;MACF;AAEAqC,MAAMC,WAAI,EAAkBpC,KACpBqC,WAAK;QAAEC,MAAM;MAAiB,GAAG,MAAA;AACrCb,cAAMlB,MAAMT,KAAAA,IAAQ;MACtB,CAAA,GACMuC,WAAK;QAAEC,MAAM;MAAgB,GAAG,MAAA;AACpCb,cAAMlB,MAAMT,KAAAA,IAAQ;MACtB,CAAA,GACMyC,aAAO,MAAA;MAEb,CAAA,CAAA,EACAN,SAASG,IAAI;IACjB;EACF;AAEA,SAAOX;AACT;",
-  "names": ["Match", "Schema", "SchemaAST", "Annotation", "JsonSchema", "Obj", "Ref", "Type", "View", "FormInputAnnotation", "LabelAnnotation", "ViewAnnotation", "Table", "Struct", "name", "String", "pipe", "optional", "view", "Ref", "View", "FormInputAnnotation", "set", "sizes", "Record", "key", "value", "Number", "mutable", "Type", "object", "typename", "version", "LabelAnnotation", "ViewAnnotation", "Annotation", "IconAnnotation", "icon", "hue", "make", "jsonSchema", "table", "Obj", "schema", "JsonSchema", "toEffectSchema", "properties", "getPropertySignatures", "ast", "property", "toString", "Match", "type", "when", "_tag", "orElse"]
-}