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

package/dist/lib/node-esm/operation-resolver-IRQ2NVUQ.mjs

@@ -1,832 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  CREATE_OBJECT_DIALOG,
-  CREATE_SPACE_DIALOG,
-  JOIN_DIALOG,
-  OBJECT_RENAME_POPOVER,
-  SPACE_RENAME_POPOVER
-} from "./chunk-CVXULIYC.mjs";
-import {
-  COMPOSER_SPACE_LOCK,
-  cloneObject,
-  getNestedObjects
-} from "./chunk-WW6YYBRG.mjs";
-import {
-  SpaceCapabilities,
-  SpaceEvents,
-  SpaceOperation
-} from "./chunk-3DWZCVVQ.mjs";
-import {
-  meta
-} from "./chunk-SL4BJSUG.mjs";
-
-// src/capabilities/operation-resolver/operation-resolver.ts
-import * as Effect from "effect/Effect";
-import { Capabilities, Capability, Plugin, UndoMapping } from "@dxos/app-framework";
-import { AppCapabilities, LayoutOperation } from "@dxos/app-toolkit";
-import { SpaceState, getSpace } from "@dxos/client/echo";
-import { Database, Obj, Query, Ref, Relation, Type } from "@dxos/echo";
-import { Collection } from "@dxos/echo";
-import { EchoDatabaseImpl, Serializer } from "@dxos/echo-db";
-import { invariant } from "@dxos/invariant";
-import { Migrations } from "@dxos/migrations";
-import { OperationResolver } from "@dxos/operation";
-import { Operation } from "@dxos/operation";
-import { ClientCapabilities } from "@dxos/plugin-client/types";
-import { ObservabilityOperation } from "@dxos/plugin-observability/types";
-import { EdgeReplicationSetting } from "@dxos/protocols/proto/dxos/echo/metadata";
-import { ATTENDABLE_PATH_SEPARATOR } from "@dxos/react-ui-attention/types";
-import { iconValues } from "@dxos/react-ui-pickers/icons";
-import { CollectionModel, ManagedCollection, ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from "@dxos/schema";
-import { hues } from "@dxos/ui-theme";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/capabilities/operation-resolver/operation-resolver.ts";
-var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(function* ({ createInvitationUrl, observability }) {
-  const capabilityManager = yield* Capability.Service;
-  const resolve = (typename) => capabilityManager.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
-  return [
-    Capability.contributes(Capabilities.UndoMapping, [
-      UndoMapping.make({
-        operation: SpaceOperation.DeleteField,
-        inverse: SpaceOperation.RestoreField,
-        deriveContext: (input, output) => ({
-          view: input.view,
-          field: output.field,
-          props: output.props,
-          index: output.index
-        }),
-        message: [
-          "field deleted label",
-          {
-            ns: meta.id
-          }
-        ]
-      }),
-      UndoMapping.make({
-        operation: SpaceOperation.RemoveObjects,
-        inverse: SpaceOperation.RestoreObjects,
-        deriveContext: (_input, output) => ({
-          objects: output.objects,
-          parentCollection: output.parentCollection,
-          indices: output.indices,
-          nestedObjectsList: output.nestedObjectsList,
-          wasActive: output.wasActive
-        }),
-        message: (input, _output) => {
-          const ns = Obj.getTypename(input.objects[0]);
-          return ns && input.objects.length === 1 ? [
-            "object deleted label",
-            {
-              ns: meta.id
-            }
-          ] : [
-            "objects deleted label",
-            {
-              ns: meta.id
-            }
-          ];
-        }
-      })
-    ]),
-    Capability.contributes(Capabilities.OperationResolver, [
-      //
-      // Open
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Open,
-        handler: (input) => Effect.promise(async () => {
-          await input.space.open();
-        })
-      }),
-      //
-      // Close
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Close,
-        handler: (input) => Effect.promise(async () => {
-          await input.space.close();
-        })
-      }),
-      //
-      // Join
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Join,
-        handler: Effect.fnUntraced(function* (input) {
-          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
-            subject: JOIN_DIALOG,
-            blockAlign: "start",
-            props: {
-              initialInvitationCode: input.invitationCode,
-              onDone: input.onDone
-            }
-          });
-        })
-      }),
-      //
-      // WaitForObject
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.WaitForObject,
-        handler: Effect.fnUntraced(function* (input) {
-          yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
-            ...current,
-            awaiting: input.id
-          }));
-        })
-      }),
-      //
-      // OpenSettings
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.OpenSettings,
-        handler: Effect.fnUntraced(function* (input) {
-          yield* Operation.invoke(LayoutOperation.Open, {
-            subject: [
-              `properties-settings${ATTENDABLE_PATH_SEPARATOR}${input.space.id}`
-            ],
-            workspace: input.space.id
-          });
-        })
-      }),
-      //
-      // RemoveObjects
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.RemoveObjects,
-        handler: Effect.fnUntraced(function* (input) {
-          const layout = yield* Capabilities.getAtomValue(AppCapabilities.Layout);
-          const objects = input.objects;
-          const space = getSpace(objects[0]);
-          invariant(space && objects.every((obj) => Obj.isObject(obj) && getSpace(obj) === space), void 0, {
-            F: __dxlog_file,
-            L: 165,
-            S: this,
-            A: [
-              "space && objects.every((obj) => Obj.isObject(obj) && getSpace(obj) === space)",
-              ""
-            ]
-          });
-          const openObjectIds = new Set(layout.active);
-          const parentCollection = input.target ?? space.properties[Collection.Collection.typename]?.target;
-          const nestedObjectsList = yield* Effect.promise(() => Promise.all(objects.map((obj) => getNestedObjects(obj, resolve))));
-          const indices = objects.map((obj) => Obj.instanceOf(Collection.Collection, parentCollection) ? parentCollection.objects.findIndex((ref) => ref.target === obj) : -1);
-          const wasActive = objects.flatMap((obj, i) => [
-            obj,
-            ...nestedObjectsList[i]
-          ]).filter((obj) => Obj.isObject(obj) && openObjectIds.has(Obj.getDXN(obj).toString())).map((obj) => Obj.getDXN(obj).toString());
-          for (let i = 0; i < objects.length; i++) {
-            const obj = objects[i];
-            const nestedObjects = nestedObjectsList[i];
-            const index = parentCollection.objects.findIndex((ref) => ref.target === obj);
-            if (index !== -1) {
-              Obj.change(parentCollection, (c) => {
-                c.objects.splice(index, 1);
-              });
-            }
-            for (const nestedObject of nestedObjects) {
-              if (Obj.isObject(nestedObject)) {
-                Obj.getDatabase(nestedObject)?.remove(nestedObject);
-              } else if (Relation.isRelation(nestedObject)) {
-                const db2 = Obj.getDatabase(Relation.getSource(nestedObject));
-                db2?.remove(nestedObject);
-              }
-            }
-            const db = Obj.getDatabase(obj);
-            db?.remove(obj);
-          }
-          if (wasActive.length > 0) {
-            yield* Operation.invoke(LayoutOperation.Close, {
-              subject: wasActive
-            });
-          }
-          return {
-            objects,
-            parentCollection,
-            indices,
-            nestedObjectsList,
-            wasActive
-          };
-        })
-      }),
-      //
-      // DeleteField
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.DeleteField,
-        handler: Effect.fnUntraced(function* (input) {
-          const registry = yield* Capability.get(Capabilities.AtomRegistry);
-          const view = input.view;
-          const db = Obj.getDatabase(view);
-          invariant(db, void 0, {
-            F: __dxlog_file,
-            L: 239,
-            S: this,
-            A: [
-              "db",
-              ""
-            ]
-          });
-          const typename = getTypenameFromQuery(view.query.ast);
-          invariant(typename, void 0, {
-            F: __dxlog_file,
-            L: 241,
-            S: this,
-            A: [
-              "typename",
-              ""
-            ]
-          });
-          const schema = yield* Effect.promise(() => db.schemaRegistry.query({
-            typename
-          }).firstOrUndefined());
-          invariant(schema, void 0, {
-            F: __dxlog_file,
-            L: 243,
-            S: this,
-            A: [
-              "schema",
-              ""
-            ]
-          });
-          const projection = new ProjectionModel({
-            registry,
-            view,
-            baseSchema: schema.jsonSchema,
-            change: createEchoChangeCallback(view, schema)
-          });
-          const result = projection.deleteFieldProjection(input.fieldId);
-          return {
-            field: result.deleted.field,
-            props: result.deleted.props,
-            index: result.index
-          };
-        })
-      }),
-      //
-      // OpenCreateObject
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.OpenCreateObject,
-        handler: Effect.fnUntraced(function* (input) {
-          const ephemeralState = yield* Capabilities.getAtomValue(SpaceCapabilities.EphemeralState);
-          const navigable = input.navigable ?? true;
-          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
-            subject: CREATE_OBJECT_DIALOG,
-            blockAlign: "start",
-            props: {
-              target: input.target,
-              views: input.views,
-              typename: input.typename,
-              initialFormValues: input.initialFormValues,
-              onCreateObject: input.onCreateObject,
-              shouldNavigate: navigable ? (object) => {
-                const isCollection = Obj.instanceOf(Collection.Collection, object);
-                const isSystemCollection = Obj.instanceOf(ManagedCollection.ManagedCollection, object);
-                return !isCollection && !isSystemCollection || ephemeralState.navigableCollections;
-              } : () => false
-            }
-          });
-        })
-      }),
-      //
-      // AddObject
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.AddObject,
-        handler: Effect.fnUntraced(function* (input) {
-          const target = input.target;
-          const object = input.object;
-          const db = Database.isDatabase(target) ? target : Obj.getDatabase(target);
-          invariant(db, "Database not found.", {
-            F: __dxlog_file,
-            L: 302,
-            S: this,
-            A: [
-              "db",
-              "'Database not found.'"
-            ]
-          });
-          yield* CollectionModel.add({
-            object,
-            target: Database.isDatabase(target) ? void 0 : target,
-            hidden: input.hidden
-          }).pipe(Effect.provide(Database.layer(db)));
-          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-            name: "space.object.add",
-            properties: {
-              spaceId: db.spaceId,
-              objectId: object.id,
-              typename: Obj.getTypename(object)
-            }
-          });
-          return {
-            id: Obj.getDXN(object).toString(),
-            subject: [
-              Obj.getDXN(object).toString()
-            ],
-            object
-          };
-        })
-      }),
-      //
-      // Share
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Share,
-        handler: Effect.fnUntraced(function* (input) {
-          const { space, type, authMethod, multiUse, target } = input;
-          const invitation = space.share({
-            type,
-            authMethod,
-            multiUse,
-            target
-          });
-          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-            name: "space.share",
-            properties: {
-              spaceId: space.id
-            }
-          });
-          return invitation;
-        })
-      }),
-      //
-      // Lock
-      // TODO(wittjosiah): This appears to be unused.
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Lock,
-        handler: Effect.fnUntraced(function* ({ space }) {
-          Obj.change(space.properties, (p) => {
-            p[COMPOSER_SPACE_LOCK] = true;
-          });
-          if (observability) {
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: "space.lock",
-              properties: {
-                spaceId: space.id
-              }
-            });
-          }
-        })
-      }),
-      //
-      // Unlock
-      // TODO(wittjosiah): This appears to be unused.
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Unlock,
-        handler: Effect.fnUntraced(function* ({ space }) {
-          Obj.change(space.properties, (p) => {
-            p[COMPOSER_SPACE_LOCK] = false;
-          });
-          if (observability) {
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: "space.unlock",
-              properties: {
-                spaceId: space.id
-              }
-            });
-          }
-        })
-      }),
-      //
-      // OpenCreateSpace
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.OpenCreateSpace,
-        handler: Effect.fnUntraced(function* () {
-          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
-            subject: CREATE_SPACE_DIALOG,
-            blockAlign: "start"
-          });
-        })
-      }),
-      //
-      // Create
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Create,
-        handler: Effect.fnUntraced(function* ({ name, hue: hue_, icon: icon_, edgeReplication }) {
-          const client = yield* Capability.get(ClientCapabilities.Client);
-          const hue = hue_ ?? hues[Math.floor(Math.random() * hues.length)];
-          const icon = icon_ ?? iconValues[Math.floor(Math.random() * iconValues.length)];
-          const space = yield* Effect.promise(() => client.spaces.create({
-            name,
-            hue,
-            icon
-          }));
-          if (edgeReplication) {
-            yield* Effect.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
-          }
-          yield* Effect.promise(() => space.waitUntilReady());
-          const collection = Obj.make(Collection.Collection, {
-            objects: []
-          });
-          Obj.change(space.properties, (p) => {
-            p[Collection.Collection.typename] = Ref.make(collection);
-            if (Migrations.versionProperty) {
-              p[Migrations.versionProperty] = Migrations.targetVersion;
-            }
-          });
-          Obj.change(collection, (c) => {
-            c.objects.push(Ref.make(ManagedCollection.makeManagedCollection({
-              key: Type.getTypename(Type.PersistentType)
-            })));
-          });
-          yield* Plugin.activate(SpaceEvents.SpaceCreated);
-          const onCreateSpaceCallbacks = yield* Capability.getAll(SpaceCapabilities.OnCreateSpace);
-          yield* Effect.all(onCreateSpaceCallbacks.map((onCreateSpace) => onCreateSpace({
-            space,
-            isDefault: false,
-            rootCollection: collection
-          })));
-          if (observability) {
-            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-              name: "space.create",
-              properties: {
-                spaceId: space.id
-              }
-            });
-          }
-          return {
-            id: space.id,
-            subject: [
-              space.id
-            ],
-            space
-          };
-        })
-      }),
-      //
-      // Migrate
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Migrate,
-        handler: Effect.fnUntraced(function* (input) {
-          const { space, version: targetVersion } = input;
-          if (space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
-            yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
-              ...current,
-              sdkMigrationRunning: {
-                ...current.sdkMigrationRunning,
-                [space.id]: true
-              }
-            }));
-            yield* Effect.promise(() => space.internal.migrate());
-            yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
-              ...current,
-              sdkMigrationRunning: {
-                ...current.sdkMigrationRunning,
-                [space.id]: false
-              }
-            }));
-          }
-          const result = yield* Effect.promise(() => Migrations.migrate(space, targetVersion));
-          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-            name: "space.migrate",
-            properties: {
-              spaceId: space.id,
-              targetVersion,
-              version: Migrations.versionProperty ? space.properties[Migrations.versionProperty] : void 0
-            }
-          });
-          return result;
-        })
-      }),
-      //
-      // Snapshot
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Snapshot,
-        handler: (input) => Effect.promise(async () => {
-          const db = input.db;
-          invariant(db instanceof EchoDatabaseImpl, "Database must be an instance of EchoDatabaseImpl", {
-            F: __dxlog_file,
-            L: 494,
-            S: this,
-            A: [
-              "db instanceof EchoDatabaseImpl",
-              "'Database must be an instance of EchoDatabaseImpl'"
-            ]
-          });
-          const backup = await new Serializer().export(db, input.query && Query.fromAst(input.query));
-          return {
-            snapshot: new Blob([
-              JSON.stringify(backup, null, 2)
-            ], {
-              type: "application/json"
-            })
-          };
-        })
-      }),
-      //
-      // Rename
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.Rename,
-        handler: Effect.fnUntraced(function* (input) {
-          yield* Operation.invoke(LayoutOperation.UpdatePopover, {
-            subject: SPACE_RENAME_POPOVER,
-            anchorId: `dxos.org/ui/${input.caller}/${input.space.id}`,
-            props: input.space
-          });
-        })
-      }),
-      //
-      // RenameObject
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.RenameObject,
-        handler: Effect.fnUntraced(function* (input) {
-          const object = input.object;
-          yield* Operation.invoke(LayoutOperation.UpdatePopover, {
-            subject: OBJECT_RENAME_POPOVER,
-            anchorId: `dxos.org/ui/${input.caller}/${Obj.getDXN(object).toString()}`,
-            props: object
-          });
-        })
-      }),
-      //
-      // OpenMembers
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.OpenMembers,
-        handler: Effect.fnUntraced(function* (input) {
-          yield* Operation.invoke(LayoutOperation.Open, {
-            subject: [
-              `members-settings${ATTENDABLE_PATH_SEPARATOR}${input.space.id}`
-            ],
-            workspace: input.space.id
-          });
-        })
-      }),
-      //
-      // GetShareLink
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.GetShareLink,
-        handler: Effect.fnUntraced(function* (input) {
-          const { Invitation, InvitationEncoder } = yield* Effect.promise(() => import("@dxos/react-client/invitations"));
-          const invitation = yield* Operation.invoke(SpaceOperation.Share, {
-            space: input.space,
-            type: Invitation.Type.DELEGATED,
-            authMethod: Invitation.AuthMethod.KNOWN_PUBLIC_KEY,
-            multiUse: true,
-            target: input.target
-          });
-          const invitationCode = yield* Effect.tryPromise(() => new Promise((resolve2) => {
-            invitation.subscribe((inv) => {
-              if (inv.state === Invitation.State.CONNECTING) {
-                resolve2(InvitationEncoder.encode(inv));
-              }
-            });
-          }));
-          const url = createInvitationUrl(invitationCode);
-          if (input.copyToClipboard) {
-            yield* Effect.tryPromise(() => navigator.clipboard.writeText(url));
-          }
-          return url;
-        })
-      }),
-      //
-      // UseStaticSchema
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.UseStaticSchema,
-        handler: Effect.fnUntraced(function* (input) {
-          const db = input.db;
-          const client = yield* Capability.get(ClientCapabilities.Client);
-          const schema = yield* Effect.promise(() => client.graph.schemaRegistry.query({
-            typename: input.typename,
-            location: [
-              "runtime"
-            ]
-          }).first());
-          const space = client.spaces.get(db.spaceId);
-          invariant(space, "Space not found", {
-            F: __dxlog_file,
-            L: 593,
-            S: this,
-            A: [
-              "space",
-              "'Space not found'"
-            ]
-          });
-          Obj.change(space.properties, (p) => {
-            if (!p.staticRecords) {
-              p.staticRecords = [];
-            }
-            if (!p.staticRecords.includes(input.typename)) {
-              p.staticRecords.push(input.typename);
-            }
-          });
-          yield* Plugin.activate(SpaceEvents.SchemaAdded);
-          const onSchemaAdded = yield* Capability.getAll(SpaceCapabilities.OnSchemaAdded);
-          yield* Effect.all(onSchemaAdded.map((callback) => callback({
-            db,
-            schema,
-            show: input.show
-          })), {
-            concurrency: "unbounded"
-          });
-          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-            name: "space.schema.use",
-            properties: {
-              spaceId: space.id,
-              typename: Type.getTypename(schema)
-            }
-          });
-          return {};
-        })
-      }),
-      //
-      // AddSchema
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.AddSchema,
-        handler: Effect.fnUntraced(function* (input) {
-          const db = input.db;
-          const schemas = yield* Effect.promise(() => db.schemaRegistry.register([
-            input.schema
-          ]));
-          const schema = schemas[0];
-          Obj.change(schema.persistentSchema, (s) => {
-            if (input.name) {
-              s.name = input.name;
-            }
-            if (input.typename) {
-              s.typename = input.typename;
-            }
-            if (input.version) {
-              s.version = input.version;
-            }
-          });
-          yield* Plugin.activate(SpaceEvents.SchemaAdded);
-          const onSchemaAdded = yield* Capability.getAll(SpaceCapabilities.OnSchemaAdded);
-          yield* Effect.all(onSchemaAdded.map((callback) => callback({
-            db,
-            schema,
-            show: input.show
-          })), {
-            concurrency: "unbounded"
-          });
-          yield* Operation.schedule(ObservabilityOperation.SendEvent, {
-            name: "space.schema.add",
-            properties: {
-              spaceId: db.spaceId,
-              objectId: schema.id,
-              typename: schema.typename
-            }
-          });
-          return {
-            id: schema.id,
-            object: schema.persistentSchema,
-            schema
-          };
-        })
-      }),
-      //
-      // AddRelation
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.AddRelation,
-        handler: (input) => Effect.sync(() => {
-          const db = input.db;
-          const relation = db.add(Relation.make(input.schema, {
-            [Relation.Source]: input.source,
-            [Relation.Target]: input.target,
-            ...input.fields
-          }));
-          return {
-            relation
-          };
-        })
-      }),
-      //
-      // DuplicateObject
-      // TODO(wittjosiah): This appears to be unused.
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.DuplicateObject,
-        handler: Effect.fnUntraced(function* (input) {
-          const object = input.object;
-          const db = Obj.getDatabase(object);
-          invariant(db, "Database not found.", {
-            F: __dxlog_file,
-            L: 692,
-            S: this,
-            A: [
-              "db",
-              "'Database not found.'"
-            ]
-          });
-          const newObject = yield* Effect.promise(() => cloneObject(object, resolve, db));
-          yield* Operation.invoke(SpaceOperation.AddObject, {
-            object: newObject,
-            target: db
-          });
-        })
-      }),
-      //
-      // RestoreField (inverse of DeleteField)
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.RestoreField,
-        handler: Effect.fnUntraced(function* (input) {
-          const registry = yield* Capability.get(Capabilities.AtomRegistry);
-          const view = input.view;
-          const db = Obj.getDatabase(view);
-          invariant(db, void 0, {
-            F: __dxlog_file,
-            L: 707,
-            S: this,
-            A: [
-              "db",
-              ""
-            ]
-          });
-          const typename = getTypenameFromQuery(view.query.ast);
-          invariant(typename, void 0, {
-            F: __dxlog_file,
-            L: 709,
-            S: this,
-            A: [
-              "typename",
-              ""
-            ]
-          });
-          const schema = yield* Effect.promise(() => db.schemaRegistry.query({
-            typename
-          }).firstOrUndefined());
-          invariant(schema, void 0, {
-            F: __dxlog_file,
-            L: 711,
-            S: this,
-            A: [
-              "schema",
-              ""
-            ]
-          });
-          const projection = new ProjectionModel({
-            registry,
-            view,
-            baseSchema: schema.jsonSchema,
-            change: createEchoChangeCallback(view, schema)
-          });
-          projection.setFieldProjection({
-            field: input.field,
-            props: input.props
-          }, input.index);
-        })
-      }),
-      //
-      // RestoreObjects (inverse of RemoveObjects)
-      //
-      OperationResolver.make({
-        operation: SpaceOperation.RestoreObjects,
-        handler: Effect.fnUntraced(function* (input) {
-          const objects = input.objects;
-          const parentCollection = input.parentCollection;
-          const indices = input.indices;
-          const nestedObjectsList = input.nestedObjectsList;
-          const wasActive = input.wasActive;
-          const space = getSpace(objects[0]);
-          invariant(space, void 0, {
-            F: __dxlog_file,
-            L: 739,
-            S: this,
-            A: [
-              "space",
-              ""
-            ]
-          });
-          const restoredObjects = objects.map((obj) => space.db.add(obj));
-          nestedObjectsList.flat().forEach((obj) => {
-            if (Obj.isObject(obj)) {
-              space.db.add(obj);
-            } else if (Relation.isRelation(obj)) {
-              space.db.add(obj);
-            }
-          });
-          Obj.change(parentCollection, (c) => {
-            indices.forEach((index, i) => {
-              if (index !== -1) {
-                c.objects.splice(index, 0, Ref.make(restoredObjects[i]));
-              }
-            });
-          });
-          if (wasActive.length > 0) {
-            yield* Operation.invoke(LayoutOperation.Open, {
-              subject: wasActive
-            });
-          }
-        })
-      })
-    ])
-  ];
-}));
-export {
-  operation_resolver_default as default
-};
-//# sourceMappingURL=operation-resolver-IRQ2NVUQ.mjs.map