@dxos/plugin-space 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/types/form.ts

@@ -2,68 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
-
-import { type Space } from '@dxos/client/echo';
-import { Type } from '@dxos/echo';
-import { EntityKind, SystemTypeAnnotation, createAnnotationHelper, getTypeAnnotation } from '@dxos/echo/internal';
-
-export const TypeInputOptions = Schema.Struct({
-  location: Schema.Array(Schema.Literal('database', 'runtime')),
-  kind: Schema.Array(Schema.Literal('system', 'user')),
-  registered: Schema.Array(Schema.Literal('registered', 'unregistered')),
-});
-
-export type TypeInputOptions = Schema.Schema.Type<typeof TypeInputOptions>;
-
-/**
- * Used in forms to identify the field representing an object's type and determine which types are shown as options.
- */
-export const TypeInputOptionsAnnotationId = Symbol.for('@dxos/schema/annotation/TypeInputOptions');
-export const TypeInputOptionsAnnotation = createAnnotationHelper<TypeInputOptions>(TypeInputOptionsAnnotationId);
-
-// TODO(wittjosiah): This is too complicated and needs to be simplified.
-export const getTypenames = ({ annotation, space }: { annotation: TypeInputOptions; space?: Space }) => {
-  const includeRuntime = annotation.location.includes('runtime');
-  const includeDatabase = annotation.location.includes('database');
-  const includeSystemType = annotation.kind.includes('system');
-  const includeUserType = annotation.kind.includes('user');
-  const includeRegistered = annotation.registered.includes('registered');
-  const includeUnregistered = annotation.registered.includes('unregistered');
-
-  const runtimeTypenames =
-    includeRuntime && space
-      ? space.db.schemaRegistry
-          .query({ location: ['runtime'] })
-          .runSync()
-          .filter((schema) => {
-            const relation = getTypeAnnotation(schema)?.kind === EntityKind.Relation;
-            if (relation) {
-              return includeSystemType;
-            }
-
-            const system = SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false));
-            if (system) {
-              return includeSystemType;
-            }
-
-            return includeUserType;
-          })
-          .filter((schema) => {
-            const registered = space?.properties.staticRecords?.includes(Type.getTypename(schema));
-            return registered ? includeRegistered : includeUnregistered;
-          })
-          .map((schema) => Type.getTypename(schema))
-      : [];
-
-  const databaseTypenames =
-    includeDatabase && includeRegistered && space
-      ? space.db.schemaRegistry
-          .query({ location: ['database'] })
-          .runSync()
-          .map((schema) => Type.getTypename(schema))
-      : [];
-
-  return Array.from(new Set<string>([...runtimeTypenames, ...databaseTypenames])).sort();
-};
+export {
+  getTypenames,
+  TypeInputOptions,
+  TypeInputOptionsAnnotation,
+  TypeInputOptionsAnnotationId,
+} from '@dxos/app-toolkit';

package/src/types/types.ts

@@ -2,35 +2,42 @@
 // 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, type Obj, QueryAST, Type } from '@dxos/echo';
+import { Database, Obj } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
 import { Operation } from '@dxos/operation';
-import { Collection, FieldSchema, View } from '@dxos/schema';
 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';
+
+/** Key for the Expando that stores cross-space ordering (must stay stable for persisted data). */
+export const SHARED = 'shared-spaces';
 
 export type SpacePluginOptions = {
   /**
-   * Base URL for the invitation link.
+   * Origin used for shareable links (object copy-link and invitation base).
+   * Defaults to window.location.origin.
+   */
+  shareableLinkOrigin?: string;
+
+  /**
+   * Path appended to shareableLinkOrigin to form the invitation base URL.
+   * Defaults to '/'.
    */
-  invitationUrl?: string;
+  invitationPath?: string;
 
   /**
-   * Query parameter for the invitation code.
+   * Query parameter name for the invitation code.
    */
   invitationProp?: string;
 
@@ -87,17 +94,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>;
@@ -114,16 +110,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');
@@ -136,526 +142,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: Type.Obj.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: Type.Obj,
-      }),
-    },
-  });
-
-  export const RemoveObjectsOutput = Schema.Struct({
-    objects: Schema.Array(Type.Obj).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(Type.Obj)).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(Type.Obj).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: 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: Type.Obj,
-        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: Type.Obj,
-        target: Type.Obj,
-        // 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: Type.Obj,
-        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: 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(Type.Obj).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(Type.Obj)).annotations({
-          description: 'Nested objects to restore.',
-        }),
-        wasActive: Schema.Array(Schema.String).annotations({
-          description: 'IDs of objects that were active before deletion.',
-        }),
-      }),
-      output: Schema.Void,
-    },
-  });
-}