@dxos/plugin-space 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/types/types.ts

@@ -2,25 +2,29 @@
 // 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';
+
+export * as Settings from './Settings';
 
 export const SPACE_DIRECTORY_HANDLE = `${meta.id}.directory`;
 
 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 = {
   /**
    * Origin used for shareable links (object copy-link and invitation base).
@@ -92,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>;
@@ -119,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');
@@ -141,506 +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 = 'org.dxos.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),
-        targetNodeId: Schema.optional(
-          Schema.String.annotations({ description: 'Qualified graph node ID of the target collection.' }),
-        ),
-      }),
-      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),
-        targetNodeId: Schema.optional(
-          Schema.String.annotations({ description: 'Qualified graph node ID of the target collection.' }),
-        ),
-        // 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),
-  });
-
-  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

@@ -3,25 +3,19 @@
 //
 
 import { type Space, SpaceState } from '@dxos/client/echo';
-import { type Database, Obj, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { Expando } from '@dxos/schema';
-import { type Label } from '@dxos/ui-types';
+import { type Label } from '@dxos/ui-types/translations';
 
-import { meta } from './meta';
+import { meta } from '#meta';
 
 //
 // Constants
 //
 
-const META_NS: { ns: string } = { ns: meta.id };
-const PERSONAL_SPACE_LABEL: Label = ['personal space label', META_NS];
-const UNNAMED_SPACE_LABEL: Label = ['unnamed space label', META_NS];
+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 const COMPOSER_SPACE_LOCK = `${meta.id}.lock`;
-// TODO(wittjosiah): Remove.
-export const SHARED = 'shared-spaces';
+export { SHARED } from './types';
 
 //
 // Helpers
@@ -40,43 +34,3 @@ export const getSpaceDisplayName = (
         ? PERSONAL_SPACE_LABEL
         : UNNAMED_SPACE_LABEL;
 };
-
-//
-// Deprecated
-//
-
-/** @deprecated This is a temporary solution. */
-export const getNestedObjects = async (
-  object: Obj.Unknown,
-  resolve: (typename: string) => Record<string, any>,
-): Promise<Obj.Unknown[]> => {
-  const type = Obj.getTypename(object);
-  if (!type) {
-    return [];
-  }
-
-  const metadata = resolve(type);
-  const loadReferences = metadata?.loadReferences;
-  if (typeof loadReferences !== 'function') {
-    return [];
-  }
-
-  const objects: Obj.Unknown[] = await loadReferences(object);
-  const nested = await Promise.all(objects.map((object) => getNestedObjects(object, resolve)));
-  return [...objects, ...nested.flat()];
-};
-
-/** @deprecated Workaround for ECHO not supporting clone. */
-export const cloneObject = async (
-  object: Obj.Unknown,
-  resolve: (typename: string) => Record<string, any>,
-  newDb: Database.Database,
-): Promise<Obj.Unknown> => {
-  const schema = Obj.getSchema(object);
-  const typename = schema ? (Type.getTypename(schema) ?? Expando.Expando.typename) : Expando.Expando.typename;
-  const metadata = resolve(typename);
-  const serializer = metadata.serializer;
-  invariant(serializer, `No serializer for type: ${typename}`);
-  const content = await serializer.serialize({ object });
-  return serializer.deserialize({ content, db: newDb, newId: true });
-};