@dxos/plugin-space 0.8.0 → 0.8.1-main.013e445

package/src/capabilities/intent-resolver.ts

@@ -318,7 +318,7 @@ export default ({ createInvitationUrl, context, observability }: IntentResolverO
     }),
     createResolver({
       intent: SpaceAction.AddObject,
-      resolve: async ({ target, object }) => {
+      resolve: async ({ target, object, hidden }) => {
         const space = isSpace(target) ? target : getSpace(target);
         invariant(space, 'Space not found.');
 
@@ -356,6 +356,8 @@ export default ({ createInvitationUrl, context, observability }: IntentResolverO
 
         if (target instanceof CollectionType) {
           target.objects.push(makeRef(object as HasId));
+        } else if (isSpace(target) && hidden) {
+          space.db.add(object);
         } else if (isSpace(target)) {
           const collection = space.properties[CollectionType.typename]?.target;
           if (collection instanceof CollectionType) {

package/src/capabilities/react-surface.tsx

@@ -5,6 +5,7 @@
 import React from 'react';
 
 import { Capabilities, contributes, createSurface, Surface, useCapability } from '@dxos/app-framework';
+import { isInstanceOf } from '@dxos/echo-schema';
 import { SettingsStore } from '@dxos/local-storage';
 import {
   getSpace,
@@ -74,7 +75,7 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       id: `${SPACE_PLUGIN}/collection-fallback`,
       role: 'article',
       position: 'fallback',
-      filter: (data): data is { subject: CollectionType } => data.subject instanceof CollectionType,
+      filter: (data): data is { subject: CollectionType } => isInstanceOf(CollectionType, data.subject),
       component: ({ data }) => <CollectionMain collection={data.subject} />,
     }),
     createSurface({
@@ -186,7 +187,7 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
     createSurface({
       id: `${SPACE_PLUGIN}/collection-section`,
       role: 'section',
-      filter: (data): data is { subject: CollectionType } => data.subject instanceof CollectionType,
+      filter: (data): data is { subject: CollectionType } => isInstanceOf(CollectionType, data.subject),
       component: ({ data }) => <CollectionSection collection={data.subject} />,
     }),
     createSurface({

package/src/capabilities/schema-tool.test.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it, expect } from 'vitest';
+
+import { S } from '@dxos/echo-schema';
+
+import { TypeNameSchema } from './schema-tools';
+
+describe('TypeNameSchema format', () => {
+  const valid = [
+    'example.com/usCities',
+    'dxos.org/Contact',
+    'dxos.org/Table',
+    'dxos.org/Table/Contact',
+    'dxos.org/PluginName/TypeName',
+    // Case variations
+    'DXOS.org/Table',
+    'dxos.ORG/table',
+  ];
+
+  const invalid = [
+    'http://dxos.org/Table', // No protocol allowed
+    'dxos.org/', // Must have type path
+    // TODO(dmaretskyi): Decide if we want to ban numbers.
+    // 'dxos.org/1Type', // Path segments must start with letter
+    'dxos.org/Type!', // Invalid character
+    '.org/Type', // Must have domain
+  ];
+
+  const validate = S.validateSync(TypeNameSchema);
+
+  valid.forEach((typename) => {
+    it(`should accept valid typename: ${typename}`, () => {
+      expect(() => validate(typename)).not.toThrow();
+    });
+  });
+
+  invalid.forEach((typename) => {
+    it(`should reject invalid typename: ${typename}`, () => {
+      expect(() => validate(typename)).toThrow();
+    });
+  });
+});

package/src/capabilities/schema-tools.ts

@@ -0,0 +1,124 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { DescriptionAnnotationId, ExamplesAnnotationId, TitleAnnotationId } from 'effect/SchemaAST';
+
+import { Capabilities, contributes, type PromiseIntentDispatcher } from '@dxos/app-framework';
+import { defineTool, ToolResult } from '@dxos/artifact';
+import { type Space } from '@dxos/client/echo';
+import { FormatEnum, FormatEnums, S, SelectOptionSchema, GeoPoint, toJsonSchema } from '@dxos/echo-schema';
+import { invariant } from '@dxos/invariant';
+import { hues } from '@dxos/react-ui-theme';
+import { echoSchemaFromPropertyDefinitions } from '@dxos/schema';
+
+// TODO(burdon): Factor out.
+declare global {
+  interface ToolContextExtensions {
+    space?: Space;
+    dispatch?: PromiseIntentDispatcher;
+  }
+}
+
+// TODO(ZaymonFC): Move this somewhere common.
+export const TypeNameSchema = S.String.pipe(
+  S.pattern(/^\w+\.\w{2,}\/[\w/]+$/i),
+  S.annotations({
+    [TitleAnnotationId]: 'TypeName',
+    [DescriptionAnnotationId]:
+      'Domain-style type name path. Dashes are not allowed. Use camel case for the final component of the type name.',
+    [ExamplesAnnotationId]: ['example.com/type/Document', 'example.com/type/FlightList'],
+  }),
+);
+
+const formatDescription = `The format of the property. Additional information:
+  ${FormatEnum.GeoPoint}: ${JSON.stringify(toJsonSchema(GeoPoint))}
+  This tuple is GeoJSON. You must specify \`${FormatEnum.GeoPoint}\` as [Longitude, Latitude]`;
+
+// TODO(ZaymonFC): All properties are default optional, but maybe we should allow for required properties.
+const PropertyDefinitionSchema = S.Struct({
+  name: S.String.annotations({ [DescriptionAnnotationId]: 'The name of the property.' }),
+  format: S.Union(...FormatEnums.map((format) => S.Literal(format))).annotations({
+    [DescriptionAnnotationId]: formatDescription,
+  }),
+  config: S.optional(
+    S.Struct({
+      options: S.optional(
+        S.Array(SelectOptionSchema)
+          .annotations({
+            description: `Options for SingleSelect/MultiSelect formats. Available colors: ${hues.join(', ')}`,
+          })
+          .pipe(S.mutable),
+      ),
+    }),
+  ),
+}).pipe(S.mutable);
+
+const SYSTEM_NAMESPACE = 'dxos.org/echo/schema';
+
+export default () =>
+  contributes(Capabilities.Tools, [
+    defineTool(SYSTEM_NAMESPACE, {
+      name: 'list',
+      description: 'List registered schemas in the space.',
+      caption: 'Listing registered schemas...',
+      schema: S.Struct({}),
+      execute: async (_input, { extensions }) => {
+        invariant(extensions?.space, 'No space.');
+        const space = extensions.space;
+
+        const schemas = await space.db.schemaRegistry.query({}).run();
+        return ToolResult.Success(
+          schemas.map((schema) => ({
+            typename: schema.typename,
+            version: schema.version,
+          })),
+        );
+      },
+    }),
+    defineTool(SYSTEM_NAMESPACE, {
+      name: 'get',
+      description: 'Get a specific schema by its typename.',
+      caption: 'Getting schema...',
+      schema: S.Struct({
+        typename: S.String.annotations({
+          description: 'The fully qualified typename of the schema.',
+        }),
+      }),
+      execute: async ({ typename }, { extensions }) => {
+        invariant(extensions?.space, 'No space.');
+        const space = extensions.space;
+
+        const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
+        if (!schema) {
+          return ToolResult.Error(`Schema not found: ${typename}`);
+        }
+
+        return ToolResult.Success(schema);
+      },
+    }),
+    defineTool(SYSTEM_NAMESPACE, {
+      name: 'create',
+      description: 'Create a new schema with the provided definition.',
+      caption: 'Creating schema...',
+      schema: S.Struct({
+        typename: TypeNameSchema.annotations({
+          description:
+            'The fully qualified schema typename. Must start with a domain, and then one or more path components (e.g., "example.com/type/TypeName").',
+        }),
+        properties: S.Array(PropertyDefinitionSchema).pipe(
+          S.annotations({ description: 'Array of property definitions for the schema.' }),
+          S.mutable,
+        ),
+      }),
+      execute: async ({ typename, properties }, { extensions }) => {
+        invariant(extensions?.space, 'No space.');
+        const space = extensions.space;
+
+        const schema = echoSchemaFromPropertyDefinitions(typename, properties);
+        const [registeredSchema] = await space.db.schemaRegistry.register([schema]);
+
+        return ToolResult.Success(registeredSchema);
+      },
+    }),
+  ]);

package/src/components/BaseObjectSettings.tsx

@@ -16,7 +16,9 @@ export type BaseObjectSettingsProps = {
 export const BaseObjectSettings = ({ object }: BaseObjectSettingsProps) => {
   const { t } = useTranslation(SPACE_PLUGIN);
   const inputRef = React.useRef<HTMLInputElement>(null);
-  // TODO(burdon): Standardize forms.
+  // TODO(wittjosiah): This should be a form based on the schema of the object.
+  //  The form should only include fields with a specific settings annotation.
+  //  Perhaps also including the field of the title annotation as well.
   return (
     <div role='form' className='flex flex-col w-full p-2 gap-1'>
       <Input.Root>

package/src/components/CreateDialog/CreateObjectDialog.tsx

@@ -22,7 +22,7 @@ import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
 import { CreateObjectPanel, type CreateObjectPanelProps } from './CreateObjectPanel';
 import { SpaceCapabilities } from '../../capabilities';
 import { SPACE_PLUGIN } from '../../meta';
-import { CollectionType, type ObjectForm, SpaceAction } from '../../types';
+import { type ObjectForm, SpaceAction } from '../../types';
 
 export const CREATE_OBJECT_DIALOG = `${SPACE_PLUGIN}/CreateObjectDialog`;
 
@@ -53,16 +53,13 @@ export const CreateObjectDialog = ({
   const handleCreateObject = useCallback(
     async ({
       form,
-      target: _target,
+      target,
       data = {},
     }: {
       form: ObjectForm;
       target: CreateObjectPanelProps['target'];
       data?: Record<string, any>;
     }) => {
-      const target = isSpace(_target)
-        ? (_target.properties[CollectionType.typename]?.target as CollectionType | undefined)
-        : _target;
       if (!target) {
         // TODO(wittjosiah): UI feedback.
         return;
@@ -76,7 +73,7 @@ export const CreateObjectDialog = ({
       const result = await dispatch(form.getIntent(data, { space }));
       const object = result.data?.object;
       if (isReactiveObject(object)) {
-        const addObjectIntent = createIntent(SpaceAction.AddObject, { target, object });
+        const addObjectIntent = createIntent(SpaceAction.AddObject, { target, object, hidden: form.hidden });
         const shouldNavigate = _shouldNavigate ?? (() => true);
         if (shouldNavigate(object)) {
           await dispatch(pipe(addObjectIntent, chain(LayoutAction.Open, { part: 'main' })));

package/src/components/PopoverRenameObject.tsx

@@ -38,7 +38,7 @@ export const PopoverRenameObject = ({ object: obj }: { object: ReactiveObject<an
         <Input.Root>
           <Input.Label srOnly>{t('object name label')}</Input.Label>
           <Input.TextInput
-            placeholder={t('object title placeholder')}
+            placeholder={t('object placeholder')}
             value={name}
             data-testid='spacePlugin.renameObject.input'
             onChange={({ target: { value } }) => setName(value)}

package/src/meta.ts

@@ -6,8 +6,8 @@ import { type PluginMeta } from '@dxos/app-framework';
 
 export const SPACE_PLUGIN = 'dxos.org/plugin/space';
 
-export const meta = {
+export const meta: PluginMeta = {
   id: SPACE_PLUGIN,
   name: 'Spaces',
   icon: 'ph--planet--regular',
-} satisfies PluginMeta;
+};

package/src/translations.ts

@@ -10,6 +10,7 @@ export default [
     'en-US': {
       [CollectionType.typename]: {
         'typename label': 'Collection',
+        'object name placeholder': 'New collection',
       },
       [SPACE_PLUGIN]: {
         'plugin name': 'Spaces',
@@ -39,7 +40,7 @@ export default [
         'confirm restore title': 'Overwrite files in this space?',
         'confirm restore body': 'Restoring from a backup will overwrite the contents of any documents that match.',
         'upload file message': 'Drag file here or click to browse',
-        'object title placeholder': 'Type a title here…',
+        'object placeholder': 'Type a title here…',
         'personal space label': 'Personal Space',
         'spaces label': 'Spaces',
         'show hidden spaces label': 'Show closed spaces',
@@ -64,9 +65,6 @@ export default [
         'missing object message': 'Object not available.',
         'missing object description':
           'The requested object has not been found yet. Ensure there are enough peers online in the space with an updated copy.',
-        'create collection label': 'Create collection',
-        'unnamed object label': 'New object',
-        'unnamed collection label': 'New collection',
         'create object in space label': 'Add to space',
         'create object in collection label': 'Add to collection',
         'share space label': 'Share',

package/src/types/thread.ts

@@ -2,66 +2,12 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Expando, Ref, S, TypedObject } from '@dxos/echo-schema';
+import { Ref, S, TypedObject } from '@dxos/echo-schema';
+import { MessageType } from '@dxos/schema';
 
 // TODO(wittjosiah): These types were placed here rather than in @dxos/plugin-thread
 //   in order to avoid a circular dependency between threads and other objects that use threads.
 
-// TODO(wittjosiah): Factor out to halo?
-export class ContactType extends TypedObject({ typename: 'dxos.org/type/Contact', version: '0.1.0' })({
-  name: S.optional(S.String),
-  identifiers: S.mutable(
-    S.Array(
-      S.Struct({
-        type: S.String,
-        value: S.String,
-      }),
-    ),
-  ),
-}) {}
-
-export const ActorSchema = S.mutable(
-  S.Struct({
-    contact: S.optional(Ref(ContactType)),
-    // TODO(wittjosiah): Should the below fields just be the contact schema?
-    //  i.e. it should either be a reference to an existing contact or an inline contact schema.
-    identityKey: S.optional(S.String),
-    // TODO(burdon): Generalize to handle/identifier?
-    email: S.optional(S.String),
-    name: S.optional(S.String),
-  }),
-);
-
-export type ActorType = S.Schema.Type<typeof ActorSchema>;
-
-export enum MessageState {
-  NONE = 0,
-  ARCHIVED = 1,
-  DELETED = 2,
-  SPAM = 3,
-}
-
-export class MessageType extends TypedObject({ typename: 'dxos.org/type/Message', version: '0.1.0' })({
-  /** ISO date string when the message was sent. */
-  timestamp: S.String,
-  /** Message state. */
-  state: S.optional(S.Enums(MessageState)),
-  /** Identity of the message sender. */
-  sender: ActorSchema,
-  /** Text content of the message. */
-  text: S.String,
-  /** Non-text content sent with a message (e.g., files, polls, etc.) */
-  parts: S.optional(S.mutable(S.Array(Ref(Expando)))),
-  /** Custom properties for specific message types (e.g. email subject or cc fields). */
-  properties: S.optional(S.mutable(S.Record({ key: S.String, value: S.Any }))),
-  // TODO(wittjosiah): Add read status:
-  //  - Read receipts need to be per space member.
-  //  - Read receipts don't need to be added to schema until they being implemented.
-  /** Context of the application when message was created. */
-  // TODO(burdon): Evolve "attention object" to be current UX state? E.g., of Deck?
-  context: S.optional(Ref(Expando)),
-}) {}
-
 export const ThreadStatus = S.Union(S.Literal('staged'), S.Literal('active'), S.Literal('resolved'));
 
 export class ThreadType extends TypedObject({ typename: 'dxos.org/type/Thread', version: '0.1.0' })({

package/src/types/types.ts

@@ -94,8 +94,10 @@ export const SpaceForm = S.Struct({
 });
 
 export type ObjectForm<T extends BaseObject = BaseObject> = {
+  // TODO(dmaretskyi): Change to S.Schema.AnyNoContext
   objectSchema: TypedObject;
   formSchema?: S.Schema<T, any>;
+  hidden?: boolean;
   getIntent: (props: T, options: { space: Space }) => AnyIntentChain;
 };
 
@@ -206,6 +208,7 @@ export namespace SpaceAction {
     input: S.Struct({
       object: ReactiveObjectSchema,
       target: S.Union(SpaceSchema, CollectionType),
+      hidden: S.optional(S.Boolean),
     }),
     output: S.Struct({
       id: S.String,

package/src/util.tsx

@@ -399,8 +399,7 @@ export const createObjectNode = ({
     properties: {
       ...partials,
       label: metadata.label?.(object) ||
-        object.name ||
-        metadata.placeholder || ['unnamed object label', { ns: SPACE_PLUGIN }],
+        object.name || ['object name placeholder', { ns: type, default: 'New object' }],
       icon: metadata.icon ?? 'ph--placeholder--regular',
       testId: 'spacePlugin.object',
       persistenceClass: 'echo',