@dxos/plugin-space 0.8.4-main.67995b8 → 0.8.4-main.72ec0f3

package/src/helpers/query.ts

@@ -0,0 +1,158 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Array from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as EffectFunction from 'effect/Function';
+import * as Match from 'effect/Match';
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { DXN, Filter, Query, type QueryAST } from '@dxos/echo';
+import {
+  ReferenceAnnotationId,
+  type ReferenceAnnotationValue,
+  getTypeAnnotation,
+  unwrapOptional,
+} from '@dxos/echo/internal';
+import { log } from '@dxos/log';
+import { type Client } from '@dxos/react-client';
+import { type Space } from '@dxos/react-client/echo';
+import { Person } from '@dxos/types';
+
+// TODO(wittjosiah): Factor out and add tests.
+// TODO(wittjosiah): Support arbitrary type imports.
+export const evalQuery = (queryString: string): Query.Any => {
+  const globals = { Query, Filter, Person };
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    return new Function(...Object.keys(globals), `return ${queryString}`)(...Object.values(globals));
+  } catch (err) {
+    log.catch(err);
+    return Query.select(Filter.nothing());
+  }
+};
+
+export const resolveSchemaWithClientAndSpace = (client: Client, space: Space, query: QueryAST.Query) => {
+  const resolve = Effect.fn(function* (dxn: string) {
+    const typename = DXN.parse(dxn).asTypeDXN()?.type;
+    if (!typename) {
+      return Option.none();
+    }
+
+    const staticSchema = client.graph.schemaRegistry.getSchema(typename);
+    if (staticSchema) {
+      return Option.some(staticSchema);
+    }
+
+    const query = space.db.schemaRegistry.query({ typename });
+    const schemas = yield* Effect.promise(() => query.run());
+    return Array.head(schemas).pipe(Option.map((schema) => schema.snapshot));
+  });
+
+  return resolveSchema(query, resolve).pipe(
+    Effect.map((schema) => Option.getOrUndefined(schema)),
+    Effect.runPromise,
+  );
+};
+
+const resolveSchema = (
+  query: QueryAST.Query,
+  resolve: (dxn: string) => Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>>,
+): Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>> => {
+  return Match.value(query).pipe(
+    Match.withReturnType<Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>>>(),
+    // TODO(wittjosiah): Reconcile with filter match?
+    Match.when({ type: 'select' }, ({ filter }) =>
+      typenameFromFilter(filter).pipe(
+        Option.map((typename) => resolve(typename)),
+        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),
+      ),
+    ),
+    Match.when({ type: 'filter' }, ({ filter }) =>
+      typenameFromFilter(filter).pipe(
+        Option.map((typename) => resolve(typename)),
+        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),
+      ),
+    ),
+    Match.when({ type: 'reference-traversal' }, ({ anchor, property }) =>
+      resolveSchema(anchor, resolve).pipe(
+        Effect.map((base) =>
+          base.pipe(
+            Option.map((schema) => SchemaAST.getPropertySignatures(schema.ast)),
+            Option.flatMap((properties) => Array.findFirst(properties, (p) => p.name === property)),
+            Option.flatMap((property) =>
+              SchemaAST.getAnnotation<ReferenceAnnotationValue>(ReferenceAnnotationId)(unwrapOptional(property)),
+            ),
+            Option.map((annotation) => annotation.typename),
+          ),
+        ),
+        Effect.flatMap(
+          Option.match({
+            onNone: () => Effect.succeed(Option.none()),
+            onSome: (typename) => resolve(DXN.fromTypename(typename).toString()),
+          }),
+        ),
+      ),
+    ),
+    Match.when({ type: 'relation', filter: Match.defined }, ({ filter }) =>
+      typenameFromFilter(filter).pipe(
+        Option.map((typename) => resolve(typename)),
+        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),
+      ),
+    ),
+    Match.when({ type: 'relation-traversal' }, ({ anchor, direction }) =>
+      resolveSchema(anchor, resolve).pipe(
+        Effect.map((base) =>
+          base.pipe(
+            Option.map((schema) => getTypeAnnotation(schema)),
+            Option.flatMap((annotation) =>
+              Option.fromNullable(direction === 'source' ? annotation?.sourceSchema : annotation?.targetSchema),
+            ),
+          ),
+        ),
+        Effect.flatMap(
+          Option.match({
+            onNone: () => Effect.succeed(Option.none()),
+            onSome: (typename) => resolve(typename),
+          }),
+        ),
+      ),
+    ),
+    Match.when({ type: 'options' }, ({ query }) => resolveSchema(query, resolve)),
+    Match.orElse((_q) => {
+      // TODO(wittjosiah): Implement other cases.
+      return Effect.succeed(Option.none());
+    }),
+  );
+};
+
+const typenameFromFilter = (filter: QueryAST.Filter): Option.Option<string> =>
+  Match.value(filter).pipe(
+    Match.withReturnType<Option.Option<string>>(),
+    Match.when({ type: 'object' }, ({ typename }) => Option.fromNullable(typename)),
+    Match.when({ type: 'and' }, ({ filters }) =>
+      EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten),
+    ),
+    Match.when({ type: 'or' }, ({ filters }) =>
+      EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten),
+    ),
+    Match.orElse(() => Option.none()),
+  );
+
+// TODO(wittjosiah): Currently assumes options is at the top-level of the ast.
+export const getQueryTarget = (query: QueryAST.Query, space?: Space) => {
+  return Match.value(query).pipe(
+    Match.when({ type: 'options' }, ({ options }) => {
+      return Option.fromNullable(options.queues).pipe(
+        Option.flatMap((queues) => Array.head(queues)),
+        Option.flatMap((queueDxn) => Option.fromNullable(DXN.tryParse(queueDxn))),
+        Option.flatMap((queueDxn) => Option.fromNullable(space?.queues.get(queueDxn))),
+        Option.getOrElse(() => space),
+      );
+    }),
+    Match.orElse(() => space),
+  );
+};

package/src/hooks/index.ts

@@ -5,3 +5,4 @@
 export * from './useActiveSpace';
 export * from './useInputSurfaceLookup';
 export * from './usePath';
+export * from './useTypeOptions';

package/src/hooks/useActiveSpace.ts

@@ -2,13 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, useLayout, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, type PluginContext } from '@dxos/app-framework';
+import { useLayout } from '@dxos/app-framework/react';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { parseId, useSpace } from '@dxos/react-client/echo';
 
 export const getActiveSpace = (context: PluginContext) => {
-  const layout = context.getCapability(Capabilities.Layout);
   const client = context.getCapability(ClientCapabilities.Client);
+  const layout = context.getCapability(Capabilities.Layout);
   const { spaceId } = parseId(layout.workspace);
   return spaceId ? client.spaces.get(spaceId) : undefined;
 };

package/src/hooks/useInputSurfaceLookup.tsx

@@ -2,10 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import type * as Schema from 'effect/Schema';
 import React, { useCallback } from 'react';
 
-import { usePluginManager, isSurfaceAvailable, Surface } from '@dxos/app-framework';
+import { Surface, isSurfaceAvailable, usePluginManager } from '@dxos/app-framework/react';
 import { type InputProps } from '@dxos/react-ui-form';
 
 // TODO(ZaymonFC): Move this if you find yourself needing it elsewhere.
@@ -20,7 +20,12 @@ export const useInputSurfaceLookup = (baseData?: Record<string, any>) => {
   return useCallback(
     ({ prop, schema, inputProps }: { prop: string; schema: Schema.Schema<any>; inputProps: InputProps }) => {
       const composedData = { prop, schema, ...baseData };
-      if (!isSurfaceAvailable(pluginManager.context, { role: 'form-input', data: composedData })) {
+      if (
+        !isSurfaceAvailable(pluginManager.context, {
+          role: 'form-input',
+          data: composedData,
+        })
+      ) {
         return undefined;
       }
 

package/src/hooks/usePath.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Option } from 'effect';
+import * as Option from 'effect/Option';
 import { useEffect, useState } from 'react';
 
 import { type ReadableGraph } from '@dxos/plugin-graph';

package/src/hooks/useTypeOptions.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { useCapabilities } from '@dxos/app-framework/react';
+import { Type } from '@dxos/echo';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { useClient } from '@dxos/react-client';
+import { type Space } from '@dxos/react-client/echo';
+import { useTranslation } from '@dxos/react-ui';
+import { Collection, type TypenameAnnotation, getTypenames } from '@dxos/schema';
+
+import { SpaceCapabilities } from '../capabilities';
+
+const OMIT = [Collection.Collection.typename, Type.getTypename(Collection.QueryCollection)];
+
+export const useTypeOptions = ({ space, annotation }: { space?: Space; annotation: TypenameAnnotation[] }) => {
+  const { t } = useTranslation();
+  const client = useClient();
+
+  const schemaWhitelists = useCapabilities(ClientCapabilities.SchemaWhiteList);
+  const whitelistedTypenames = useMemo(
+    () => new Set(schemaWhitelists.flatMap((typeArray) => typeArray.map((type) => Type.getTypename(type)))),
+    [schemaWhitelists],
+  );
+
+  const objectForms = useCapabilities(SpaceCapabilities.ObjectForm);
+  const objectFormTypenames = useMemo(
+    () =>
+      new Set(
+        objectForms
+          .map((form) => Type.getTypename(form.objectSchema))
+          // TODO(wittjosiah): Remove.
+          .filter((typename) => !OMIT.includes(typename) && !typename.endsWith('View')),
+      ),
+    [objectForms],
+  );
+
+  const typenames = getTypenames({
+    annotation,
+    whitelistedTypenames,
+    objectFormTypenames,
+    space,
+    client,
+  });
+
+  return useMemo(
+    () =>
+      typenames
+        .map((typename) => ({
+          value: typename,
+          label: t('typename label', { ns: typename, defaultValue: typename }),
+        }))
+        .toSorted((a, b) => a.label.localeCompare(b.label)),
+    [t, typenames],
+  );
+};

package/src/index.ts

@@ -6,6 +6,7 @@ export { SpaceCapabilities } from './capabilities';
 export { SpaceEvents } from './events';
 
 export * from './components';
+export * from './helpers';
 export * from './hooks';
 export * from './meta';
 export * from './SpacePlugin';

package/src/meta.ts

@@ -3,11 +3,14 @@
 //
 
 import { type PluginMeta } from '@dxos/app-framework';
-
-export const SPACE_PLUGIN = 'dxos.org/plugin/space';
+import { trim } from '@dxos/util';
 
 export const meta: PluginMeta = {
-  id: SPACE_PLUGIN,
+  id: 'dxos.org/plugin/space',
   name: 'Spaces',
+  description: trim`
+    Core workspace container system for organizing and sharing collaborative environments.
+    Create, manage, and share spaces with granular access control and invitation management.
+  `,
   icon: 'ph--planet--regular',
 };

package/src/translations.ts

@@ -2,9 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { StoredSchema } from '@dxos/echo-schema';
+import { Type } from '@dxos/echo';
+import { StoredSchema } from '@dxos/echo/internal';
 import { type Resource } from '@dxos/react-ui';
-import { DataType } from '@dxos/schema';
+import { Collection, View } from '@dxos/schema';
+import { Event, Organization, Person, Project, Task } from '@dxos/types';
 
 import { meta } from './meta';
 
@@ -12,7 +14,7 @@ import { meta } from './meta';
 export const translations = [
   {
     'en-US': {
-      [DataType.Collection.typename]: {
+      [Collection.Collection.typename]: {
         'typename label': 'Collection',
         'typename label_zero': 'Collections',
         'typename label_one': 'Collection',
@@ -21,7 +23,7 @@ export const translations = [
         'rename object label': 'Rename collection',
         'delete object label': 'Delete collection',
       },
-      [DataType.QueryCollection.typename]: {
+      [Type.getTypename(Collection.QueryCollection)]: {
         'typename label': 'Smart Collection',
         'typename label_zero': 'Smart Collections',
         'typename label_one': 'Smart Collection',
@@ -39,7 +41,7 @@ export const translations = [
         'rename object label': 'Rename record type',
         'delete object label': 'Delete record type',
       },
-      [DataType.View.typename]: {
+      [Type.getTypename(View.View)]: {
         'typename label': 'View',
         'typename label_zero': 'Views',
         'typename label_one': 'View',
@@ -48,35 +50,35 @@ export const translations = [
         'rename object label': 'Rename view',
         'delete object label': 'Delete view',
       },
-      [DataType.Event.typename]: {
+      [Event.Event.typename]: {
         'typename label': 'Event',
         'typename label_zero': 'Events',
         'typename label_one': 'Event',
         'typename label_other': 'Events',
         'object name placeholder': 'New event',
       },
-      [DataType.Organization.typename]: {
+      [Organization.Organization.typename]: {
         'typename label': 'Organization',
         'typename label_zero': 'Organizations',
         'typename label_one': 'Organization',
         'typename label_other': 'Organizations',
         'object name placeholder': 'New organization',
       },
-      [DataType.Person.typename]: {
+      [Person.Person.typename]: {
         'typename label': 'Person',
         'typename label_zero': 'People',
         'typename label_one': 'Person',
         'typename label_other': 'People',
         'object name placeholder': 'New person',
       },
-      [DataType.Project.typename]: {
+      [Project.Project.typename]: {
         'typename label': 'Project',
         'typename label_zero': 'Projects',
         'typename label_one': 'Project',
         'typename label_other': 'Projects',
         'object name placeholder': 'New project',
       },
-      [DataType.Task.typename]: {
+      [Task.Task.typename]: {
         'typename label': 'Task',
         'typename label_zero': 'Tasks',
         'typename label_one': 'Task',
@@ -189,10 +191,12 @@ export const translations = [
         'creating in collection label': 'In Collection',
         'clear input label': 'Clear',
         'expose object label': 'Expose in navtree',
+        'add tag label': 'Add tag',
         'advanced settings label': 'Advanced',
         'foreign keys': 'Foreign Keys',
         'add key': 'Add Key',
         'open space settings label': 'Open settings',
+        'related objects label': 'Related Items',
 
         'row details no selection label': 'No objects selected',
         'companion selected objects label': 'Selected',
@@ -214,10 +218,10 @@ export const translations = [
         'space settings properties label': 'General settings',
         'space properties settings verbose label': 'Manage space properties',
         'space properties settings description': 'You can configure how this space is displayed in the app here.',
-        'space settings schema label': 'Schema',
-        'schema verbose label': 'Manage schema',
-        'schema description': 'You can manage all of the schema stored within this space here.',
-        'no schemas found message': 'No schemas found',
+        'space settings schema label': 'Record types',
+        'schema verbose label': 'Manage record types',
+        'schema description': 'You can manage all of the record types stored within this space here.',
+        'no schemas found message': 'No record types found',
         'display name input placeholder': 'Space name',
         'display name description': 'Name of the space as it appears in the app.',
         'icon description': 'Icon used to represent the space in the app.',
@@ -227,7 +231,18 @@ export const translations = [
         'archive space description':
           'Archiving a space will remove it from the sidebar and stop replicating updates, but will not delete the data. You can unarchive it by enabling archived spaces in the app settings.',
         'archive space label': 'Archive',
+        'backup space label': 'Backup',
+        'backup space description':
+          'Download a backup of the space. Contains all data in the space in an unencrypted format.',
+        'download backup': 'Download backup',
         'unarchive space label': 'Unarchive',
+
+        'sync edge connected label': 'Edge connected',
+        'sync edge disconnected label': 'Edge disconnected',
+        'sync no connection label': 'No connection to edge service',
+        'sync latency label': 'Latency',
+        'sync upload label': 'Upload',
+        'sync download label': 'Download',
       },
     },
   },

package/src/types/types.ts

@@ -2,21 +2,22 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { type AnyIntentChain } from '@dxos/app-framework';
 import { type Obj, Type } from '@dxos/echo';
-import { EchoSchema, StoredSchema, type TypedObject, type BaseObject } from '@dxos/echo-schema';
+import { type BaseObject, EchoSchema, StoredSchema } from '@dxos/echo/internal';
 import { type PublicKey } from '@dxos/react-client';
 // TODO(wittjosiah): This pulls in full client.
 import { EchoObjectSchema, ReactiveObjectSchema, type Space, SpaceSchema } from '@dxos/react-client/echo';
 import { CancellableInvitationObservable, Invitation } from '@dxos/react-client/invitations';
-import { DataType, FieldSchema, TypenameAnnotationId } from '@dxos/schema';
+import { Collection, FieldSchema, TypenameAnnotationId, View } from '@dxos/schema';
 import { type ComplexMap } from '@dxos/util';
 
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
+
+export const SPACE_DIRECTORY_HANDLE = `${meta.id}/directory`;
 
-export const SPACE_DIRECTORY_HANDLE = 'dxos.org/plugin/space/directory';
 export const SPACE_TYPE = 'dxos.org/type/Space';
 
 export type ObjectViewerProps = {
@@ -105,8 +106,7 @@ export const SpaceForm = Schema.Struct({
 });
 
 export type ObjectForm<T extends BaseObject = BaseObject> = {
-  // TODO(dmaretskyi): Change to Schema.Schema.AnyNoContext
-  objectSchema: TypedObject;
+  objectSchema: Schema.Schema.AnyNoContext;
   formSchema?: Schema.Schema<T, any>;
   hidden?: boolean;
   getIntent: (props: T, options: { space: Space }) => AnyIntentChain;
@@ -114,7 +114,7 @@ export type ObjectForm<T extends BaseObject = BaseObject> = {
 
 export const defineObjectForm = <T extends BaseObject>(form: ObjectForm<T>) => form;
 
-export const SPACE_ACTION = `${SPACE_PLUGIN}/action`;
+export const SPACE_ACTION = `${meta.id}/action`;
 
 export namespace SpaceAction {
   export class OpenCreateSpace extends Schema.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
@@ -230,6 +230,8 @@ export namespace SpaceAction {
     input: Schema.Struct({
       space: SpaceSchema,
       typename: Schema.String,
+      // TODO(wittjosiah): This is leaky.
+      show: Schema.optional(Schema.Boolean),
     }),
     output: Schema.Struct({}),
   }) {}
@@ -238,8 +240,13 @@ export namespace SpaceAction {
     input: Schema.Struct({
       space: SpaceSchema,
       name: Schema.optional(Schema.String),
+      typename: Schema.optional(Schema.String),
+      // TODO(wittjosiah): Semantic version format.
+      version: Schema.optional(Schema.String),
       // TODO(wittjosiah): Schema for schema?
       schema: Schema.Any,
+      // TODO(wittjosiah): This is leaky.
+      show: Schema.optional(Schema.Boolean),
     }),
     output: Schema.Struct({
       // TODO(wittjosiah): ObjectId.
@@ -251,7 +258,7 @@ export namespace SpaceAction {
 
   export class DeleteField extends Schema.TaggedClass<DeleteField>()(`${SPACE_ACTION}/delete-field`, {
     input: Schema.Struct({
-      view: DataType.View,
+      view: View.View,
       fieldId: Schema.String,
       // TODO(wittjosiah): Separate fields for undo data?
       deletionData: Schema.optional(
@@ -269,8 +276,10 @@ export namespace SpaceAction {
 
   export class OpenCreateObject extends Schema.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
     input: Schema.Struct({
-      target: Schema.Union(SpaceSchema, DataType.Collection),
+      target: Schema.Union(SpaceSchema, Collection.Collection),
+      views: Schema.optional(Schema.Boolean),
       typename: Schema.optional(Schema.String),
+      initialFormValues: Schema.optional(Schema.Any),
       navigable: Schema.optional(Schema.Boolean),
       // TODO(wittjosiah): This is a function, is there a better way to handle this?
       onCreateObject: Schema.optional(Schema.Any),
@@ -281,7 +290,7 @@ export namespace SpaceAction {
   export class AddObject extends Schema.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
     input: Schema.Struct({
       object: ReactiveObjectSchema,
-      target: Schema.Union(SpaceSchema, DataType.Collection),
+      target: Schema.Union(SpaceSchema, Collection.Collection),
       hidden: Schema.optional(Schema.Boolean),
     }),
     output: Schema.Struct({
@@ -309,7 +318,7 @@ export namespace SpaceAction {
 
   export const DeletionData = Schema.Struct({
     objects: Schema.Array(EchoObjectSchema),
-    parentCollection: DataType.Collection,
+    parentCollection: Collection.Collection,
     indices: Schema.Array(Schema.Number),
     nestedObjectsList: Schema.Array(Schema.Array(EchoObjectSchema)),
     wasActive: Schema.Array(Schema.String),
@@ -319,8 +328,9 @@ export namespace SpaceAction {
 
   export class RemoveObjects extends Schema.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
     input: Schema.Struct({
-      objects: Schema.Array(EchoObjectSchema),
-      target: Schema.optional(DataType.Collection),
+      // TODO(wittjosiah): Should be Schema.Union(Type.Obj, Type.Relation).
+      objects: Schema.Array(ReactiveObjectSchema),
+      target: Schema.optional(Collection.Collection),
       deletionData: Schema.optional(DeletionData),
     }),
     output: Schema.Void,
@@ -337,7 +347,7 @@ export namespace SpaceAction {
   export class DuplicateObject extends Schema.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
     input: Schema.Struct({
       object: EchoObjectSchema,
-      target: Schema.Union(SpaceSchema, DataType.Collection),
+      target: Schema.Union(SpaceSchema, Collection.Collection),
     }),
     output: Schema.Void,
   }) {}
@@ -356,17 +366,15 @@ export namespace CollectionAction {
       name: Schema.optional(Schema.String),
     }),
     output: Schema.Struct({
-      object: DataType.Collection,
+      object: Collection.Collection,
     }),
   }) {}
 
   export const QueryCollectionForm = Schema.Struct({
     name: Schema.optional(Schema.String),
-    typename: Schema.optional(
-      Schema.String.annotations({
-        [TypenameAnnotationId]: ['object-form'],
-      }),
-    ),
+    typename: Schema.String.annotations({
+      [TypenameAnnotationId]: ['object-form'],
+    }),
   });
 
   export class CreateQueryCollection extends Schema.TaggedClass<CreateQueryCollection>()(
@@ -374,7 +382,8 @@ export namespace CollectionAction {
     {
       input: QueryCollectionForm,
       output: Schema.Struct({
-        object: DataType.QueryCollection,
+        // TODO(wittjosiah): Remove cast.
+        object: EchoObjectSchema, // Collection.QueryCollection,
       }),
     },
   ) {}