@dxos/plugin-space 0.8.4-main.4a85c3132b → 0.8.4-main.4f23b4e393

package/src/types/types.ts

@@ -2,26 +2,28 @@
 // Copyright 2023 DXOS.org
 //
 
-import type * as Effect from 'effect/Effect';
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { Capability, Plugin } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
 import { type PublicKey } from '@dxos/client';
-// TODO(wittjosiah): This pulls in full client.
-import { SpaceSchema } from '@dxos/client/echo';
-import { CancellableInvitationObservable, Invitation } from '@dxos/client/invitations';
-import { Database, Obj, QueryAST, Type } from '@dxos/echo';
-import { Collection, View } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
+import { Collection, Database, Obj } from '@dxos/echo';
 import { type ComplexMap } from '@dxos/util';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
-import { TypeInputOptionsAnnotation } from './form';
+export * as Settings from './Settings';
 
-export const SPACE_DIRECTORY_HANDLE = `${meta.id}/directory`;
+export const SPACE_DIRECTORY_HANDLE = `${meta.id}.directory`;
 
-export const SPACE_TYPE = 'dxos.org/type/Space';
+export const SPACE_TYPE = 'org.dxos.type.space';
+
+/** Type for the per-space virtual "Settings" section that groups settings panels. */
+export const SETTINGS_SECTION_TYPE = `${meta.id}.settings`;
+
+/** Key for the Expando that stores cross-space ordering (must stay stable for persisted data). */
+export const SHARED = 'shared-spaces';
 
 export type SpacePluginOptions = {
   /**
@@ -94,17 +96,6 @@ export type PluginState = {
   enabledEdgeReplication: boolean;
 };
 
-export const SpaceSettingsSchema = Schema.mutable(
-  Schema.Struct({
-    /**
-     * Show closed spaces.
-     */
-    showHidden: Schema.Boolean,
-  }),
-);
-
-export type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;
-
 // TODO(wittjosiah): Reconcile with graph export serializers.
 
 export type SerializerMap = Record<string, TypedObjectSerializer>;
@@ -121,16 +112,26 @@ export interface TypedObjectSerializer<T extends Obj.Unknown = Obj.Unknown> {
 }
 
 /**
- * Factory function that creates an object directly using Type.make().
- * Returns an Effect that resolves to the created object.
- *
- * Options include:
- * - `db`: The database to use for object creation.
+ * Result of creating and adding an object.
+ */
+export type CreateObjectResult = {
+  id: string;
+  subject: readonly string[];
+  object: Obj.Unknown;
+};
+
+/**
+ * Factory function that creates an object and adds it to a target (database or collection).
+ * Returns an Effect that resolves to the created object result with navigation subject.
  */
 export type CreateObject = (
   props: any,
-  options: { db: Database.Database },
-) => Effect.Effect<Obj.Unknown, Error, Capability.Service | Operation.Service>;
+  options: {
+    db: Database.Database;
+    target: Database.Database | Collection.Collection;
+    targetNodeId?: string;
+  },
+) => Effect.Effect<CreateObjectResult, Error, Capability.Service | Operation.Service>;
 
 // TODO(burdon): Move to FormatEnum or SDK.
 export const IconAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Icon');
@@ -143,526 +144,3 @@ export const SpaceForm = Schema.Struct({
   hue: Schema.optional(Schema.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
   edgeReplication: Schema.optional(Schema.Boolean.annotations({ title: 'Enable EDGE Replication' })),
 });
-
-const COLLECTION_OPERATION = 'dxos.org/plugin/collection/operation';
-
-export namespace CollectionOperation {
-  export const Create = Operation.make({
-    meta: { key: `${COLLECTION_OPERATION}/create`, name: 'Create Collection' },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        name: Schema.optional(Schema.String),
-      }),
-      output: Schema.Struct({
-        object: Collection.Collection,
-      }),
-    },
-  });
-}
-
-const SPACE_OPERATION = `${meta.id}/operation`;
-
-/**
- * Operations for the Space plugin.
- */
-export namespace SpaceOperation {
-  export const Create = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/create`,
-      name: 'Create Space',
-      description: 'Create a new space.',
-    },
-    services: [Capability.Service, Plugin.Service],
-    schema: {
-      input: SpaceForm,
-      output: Schema.Struct({
-        id: Schema.String,
-        subject: Schema.Array(Schema.String),
-        space: SpaceSchema,
-      }),
-    },
-  });
-
-  export const Join = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/join`,
-      name: 'Join Space',
-      description: 'Join a space via invitation.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        invitationCode: Schema.optional(Schema.String),
-        onDone: Schema.optional(Schema.Any),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const Open = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/open`,
-      name: 'Open Space',
-      description: 'Open a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const Close = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/close`,
-      name: 'Close Space',
-      description: 'Close a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const Share = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/share`,
-      name: 'Share Space',
-      description: 'Share a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-        type: Schema.Enums(Invitation.Type),
-        authMethod: Schema.Enums(Invitation.AuthMethod),
-        multiUse: Schema.Boolean,
-        target: Schema.optional(Schema.String),
-      }),
-      output: Schema.instanceOf(CancellableInvitationObservable),
-    },
-  });
-
-  // TODO(wittjosiah): This appears to be unused.
-  export const Lock = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/lock`,
-      name: 'Lock Space',
-      description: 'Lock a space to prevent modifications.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  // TODO(wittjosiah): This appears to be unused.
-  export const Unlock = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/unlock`,
-      name: 'Unlock Space',
-      description: 'Unlock a space to allow modifications.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const OpenSettings = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/open-settings`,
-      name: 'Open Space Settings',
-      description: 'Open space settings.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const WaitForObject = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/wait-for-object`,
-      name: 'Wait For Object',
-      description: 'Wait for an object to be available.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        id: Schema.optional(Schema.String),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const AddObject = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/add-object`,
-      name: 'Add Object',
-      description: 'Add an object to a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        object: Obj.Unknown.annotations({ description: 'The object to add.' }),
-        target: Schema.Union(Database.Database, Collection.Collection).annotations({
-          description: 'The database or collection to add to.',
-        }),
-        hidden: Schema.optional(Schema.Boolean),
-      }),
-      output: Schema.Struct({
-        id: Schema.String,
-        subject: Schema.Array(Schema.String),
-        object: Obj.Unknown,
-      }),
-    },
-  });
-
-  export const RemoveObjectsOutput = Schema.Struct({
-    objects: Schema.Array(Obj.Unknown).annotations({ description: 'The removed objects.' }),
-    parentCollection: Collection.Collection.annotations({ description: 'The collection removed from.' }),
-    indices: Schema.Array(Schema.Number).annotations({ description: 'The indices the objects were at.' }),
-    nestedObjectsList: Schema.Array(Schema.Array(Obj.Unknown)).annotations({
-      description: 'Nested objects that were removed.',
-    }),
-    wasActive: Schema.Array(Schema.String).annotations({
-      description: 'IDs of objects that were active before removal.',
-    }),
-  });
-
-  export type RemoveObjectsOutput = Schema.Schema.Type<typeof RemoveObjectsOutput>;
-
-  export const RemoveObjects = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/remove-objects`,
-      name: 'Remove Objects',
-      description: 'Remove objects from a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        objects: Schema.Array(Obj.Unknown).annotations({ description: 'The objects to remove.' }),
-        target: Schema.optional(Collection.Collection).annotations({ description: 'The collection to remove from.' }),
-      }),
-      output: RemoveObjectsOutput,
-    },
-  });
-
-  export const DeleteFieldOutput = Schema.Struct({
-    field: View.FieldSchema.annotations({ description: 'The deleted field schema.' }),
-    // TODO(wittjosiah): This creates a type error with PropertySchema.
-    props: Schema.Any.annotations({ description: 'The deleted field properties.' }),
-    index: Schema.Number.annotations({ description: 'The index the field was at.' }),
-  });
-
-  export type DeleteFieldOutput = Schema.Schema.Type<typeof DeleteFieldOutput>;
-
-  export const DeleteField = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/delete-field`,
-      name: 'Delete Field',
-      description: 'Delete a field from a view.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        view: View.View.annotations({ description: 'The view to delete the field from.' }),
-        fieldId: Schema.String,
-      }),
-      output: DeleteFieldOutput,
-    },
-  });
-
-  export const OpenCreateObject = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/open-create-object`,
-      name: 'Open Create Object Dialog',
-      description: 'Open the create object dialog.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        target: Schema.Union(Database.Database, Collection.Collection).annotations({
-          description: 'The database or collection to create in.',
-        }),
-        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),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const OpenCreateSpace = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/open-create-space`,
-      name: 'Open Create Space Dialog',
-      description: 'Open the create space dialog.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Void,
-      output: Schema.Void,
-    },
-  });
-
-  export const Migrate = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/migrate`,
-      name: 'Migrate Space',
-      description: 'Migrate a space to a new version.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-        version: Schema.optional(Schema.String),
-      }),
-      output: Schema.Boolean,
-    },
-  });
-
-  export const Snapshot = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/snapshot`,
-      name: 'Create Snapshot',
-      description: 'Create a snapshot of the space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        db: Database.Database,
-        query: QueryAST.Query.pipe(Schema.optional),
-      }),
-      output: Schema.Struct({
-        snapshot: Schema.instanceOf(Blob),
-      }),
-    },
-  });
-
-  export const Rename = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/rename`,
-      name: 'Rename Space',
-      description: 'Rename a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-        caller: Schema.optional(Schema.String),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const RenameObject = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/rename-object`,
-      name: 'Rename Object',
-      description: 'Rename an object.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        object: Obj.Unknown,
-        caller: Schema.optional(Schema.String),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const OpenMembers = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/open-members`,
-      name: 'Open Members',
-      description: 'Open the members panel for a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  export const GetShareLink = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/get-share-link`,
-      name: 'Get Share Link',
-      description: 'Get a shareable link for a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        space: SpaceSchema,
-        target: Schema.optional(Schema.String),
-        copyToClipboard: Schema.optional(Schema.Boolean),
-      }),
-      output: Schema.String,
-    },
-  });
-
-  export const StoredSchemaForm = Schema.Struct({
-    name: Schema.optional(Schema.String),
-    typename: Schema.String.pipe(
-      Schema.annotations({ title: 'Select type (leave blank to create a new type)' }),
-      TypeInputOptionsAnnotation.set({
-        location: ['runtime'],
-        kind: ['user'],
-        registered: ['unregistered'],
-      }),
-      Schema.optional,
-    ),
-  });
-
-  export const UseStaticSchema = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/use-static-schema`,
-      name: 'Use Static Schema',
-      description: 'Use a static schema in the space.',
-    },
-    services: [Capability.Service, Plugin.Service],
-    schema: {
-      input: Schema.Struct({
-        db: Database.Database,
-        typename: Schema.String,
-        show: Schema.optional(Schema.Boolean),
-      }),
-      output: Schema.Struct({}),
-    },
-  });
-
-  export const AddSchema = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/add-schema`,
-      name: 'Add Schema',
-      description: 'Add a schema to the space.',
-    },
-    services: [Capability.Service, Plugin.Service],
-    schema: {
-      input: Schema.Struct({
-        db: Database.Database,
-        name: Schema.optional(Schema.String),
-        typename: Schema.optional(Schema.String),
-        version: Schema.optional(Schema.String),
-        // TODO(wittjosiah): Schema for schema?
-        schema: Schema.Any,
-        show: Schema.optional(Schema.Boolean),
-      }),
-      output: Schema.Struct({
-        id: Schema.String,
-        object: Type.PersistentType,
-        schema: Schema.instanceOf(Type.RuntimeType),
-      }),
-    },
-  });
-
-  export const AddRelation = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/add-relation`,
-      name: 'Add Relation',
-      description: 'Add a relation between objects.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        db: Database.Database,
-        // TODO(wittjosiah): Relation schema.
-        schema: Schema.Any,
-        source: Obj.Unknown,
-        target: Obj.Unknown,
-        // TODO(wittjosiah): Type based on relation schema.
-        fields: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-      }),
-      output: Schema.Struct({
-        relation: Schema.Any,
-      }),
-    },
-  });
-
-  // TODO(wittjosiah): This appears to be unused.
-  export const DuplicateObject = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/duplicate-object`,
-      name: 'Duplicate Object',
-      description: 'Duplicate an object.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        object: Obj.Unknown,
-        target: Schema.Union(Database.Database, Collection.Collection),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  /**
-   * Restore a deleted field to a view (inverse of DeleteField).
-   */
-  export const RestoreField = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/restore-field`,
-      name: 'Restore Field',
-      description: 'Restore a deleted field to a view.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        view: View.View.annotations({ description: 'The view to restore the field to.' }),
-        field: View.FieldSchema.annotations({ description: 'The field schema to restore.' }),
-        // TODO(wittjosiah): This creates a type error with PropertySchema.
-        props: Schema.Any.annotations({ description: 'The field properties to restore.' }),
-        index: Schema.Number.annotations({ description: 'The index to restore the field at.' }),
-      }),
-      output: Schema.Void,
-    },
-  });
-
-  /**
-   * Restore deleted objects to a space (inverse of RemoveObjects).
-   */
-  export const RestoreObjects = Operation.make({
-    meta: {
-      key: `${SPACE_OPERATION}/restore-objects`,
-      name: 'Restore Objects',
-      description: 'Restore deleted objects to a space.',
-    },
-    services: [Capability.Service],
-    schema: {
-      input: Schema.Struct({
-        objects: Schema.Array(Obj.Unknown).annotations({ description: 'The objects to restore.' }),
-        parentCollection: Collection.Collection.annotations({ description: 'The collection to restore to.' }),
-        indices: Schema.Array(Schema.Number).annotations({ description: 'The indices to restore at.' }),
-        nestedObjectsList: Schema.Array(Schema.Array(Obj.Unknown)).annotations({
-          description: 'Nested objects to restore.',
-        }),
-        wasActive: Schema.Array(Schema.String).annotations({
-          description: 'IDs of objects that were active before deletion.',
-        }),
-      }),
-      output: Schema.Void,
-    },
-  });
-}

package/src/util.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Space, SpaceState } from '@dxos/client/echo';
+import { type Label } from '@dxos/ui-types/translations';
+
+import { meta } from '#meta';
+
+//
+// Constants
+//
+
+const PERSONAL_SPACE_LABEL: Label = ['personal-space.label', { ns: meta.id }];
+const UNNAMED_SPACE_LABEL: Label = ['unnamed-space.label', { ns: meta.id }];
+
+export const SPACES = `${meta.id}-spaces`;
+export { SHARED } from './types';
+
+//
+// Helpers
+//
+
+/** Returns the display label for a space (name, namesCache entry, or fallback). */
+export const getSpaceDisplayName = (
+  space: Space,
+  { personal, namesCache = {} }: { personal?: boolean; namesCache?: Record<string, string> } = {},
+): Label => {
+  return space.state.get() === SpaceState.SPACE_READY && (space.properties.name?.length ?? 0) > 0
+    ? space.properties.name!
+    : namesCache[space.id]
+      ? namesCache[space.id]
+      : personal
+        ? PERSONAL_SPACE_LABEL
+        : UNNAMED_SPACE_LABEL;
+};