@dxos/client-services 0.5.9-main.cb71230 → 0.5.9-main.d63ef8d

package/src/packlets/spaces/epoch-migrations.ts

@@ -0,0 +1,135 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { asyncTimeout } from '@dxos/async';
+import { next as am } from '@dxos/automerge/automerge';
+import type { Repo, AutomergeUrl } from '@dxos/automerge/automerge-repo';
+import { cancelWithContext, type Context } from '@dxos/context';
+import {
+  convertLegacyReferences,
+  convertLegacySpaceRootDoc,
+  findInlineObjectOfType,
+  migrateDocument,
+} from '@dxos/echo-db';
+import { AutomergeDocumentLoaderImpl } from '@dxos/echo-pipeline';
+import type { SpaceDoc } from '@dxos/echo-protocol';
+import { TYPE_PROPERTIES } from '@dxos/echo-schema';
+import { invariant } from '@dxos/invariant';
+import type { PublicKey, SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { CreateEpochRequest } from '@dxos/protocols/proto/dxos/client/services';
+import { assignDeep } from '@dxos/util';
+
+export type MigrationContext = {
+  repo: Repo;
+  spaceId: SpaceId;
+  /**
+   * @deprecated Remove.
+   */
+  spaceKey: PublicKey;
+  migration: CreateEpochRequest.Migration;
+  currentRoot: string | null;
+
+  /**
+   * For set automerge root migration type.
+   */
+  newAutomergeRoot?: string;
+};
+
+export type MigrationResult = {
+  newRoot?: string;
+};
+
+export const runEpochMigration = async (ctx: Context, context: MigrationContext): Promise<MigrationResult> => {
+  switch (context.migration) {
+    case CreateEpochRequest.Migration.INIT_AUTOMERGE: {
+      const document = context.repo.create();
+      await context.repo.flush();
+      return { newRoot: document.url };
+    }
+    case CreateEpochRequest.Migration.PRUNE_AUTOMERGE_ROOT_HISTORY: {
+      if (!context.currentRoot) {
+        throw new Error('Space does not have an automerge root');
+      }
+      const rootHandle = context.repo.find(context.currentRoot as AutomergeUrl);
+      await cancelWithContext(ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
+
+      const newRoot = context.repo.create(rootHandle.docSync());
+      await context.repo.flush();
+      return { newRoot: newRoot.url };
+    }
+    case CreateEpochRequest.Migration.FRAGMENT_AUTOMERGE_ROOT: {
+      log.info('Fragmenting');
+
+      const currentRootUrl = context.currentRoot;
+      const rootHandle = context.repo.find<SpaceDoc>(currentRootUrl as any);
+      await cancelWithContext(ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
+
+      // Find properties object.
+      const objects = Object.entries((rootHandle.docSync() as SpaceDoc).objects!);
+      const properties = findInlineObjectOfType(rootHandle.docSync() as SpaceDoc, TYPE_PROPERTIES);
+      const otherObjects = objects.filter(([key]) => key !== properties?.[0]);
+      invariant(properties, 'Properties not found');
+
+      // Create a new space doc with the properties object.
+      const newSpaceDoc: SpaceDoc = { ...rootHandle.docSync(), objects: Object.fromEntries([properties]) };
+      const newRoot = context.repo.create(newSpaceDoc);
+      invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
+
+      // Create new automerge documents for all objects.
+      const docLoader = new AutomergeDocumentLoaderImpl(context.spaceId, context.repo, context.spaceKey);
+      await docLoader.loadSpaceRootDocHandle(ctx, { rootUrl: newRoot.url });
+
+      otherObjects.forEach(([key, value]) => {
+        const handle = docLoader.createDocumentForObject(key);
+        handle.change((doc: any) => {
+          assignDeep(doc, ['objects', key], value);
+        });
+      });
+
+      await context.repo.flush();
+      return {
+        newRoot: newRoot.url,
+      };
+    }
+    case CreateEpochRequest.Migration.MIGRATE_REFERENCES_TO_DXN: {
+      const currentRootUrl = context.currentRoot;
+      const rootHandle = context.repo.find<SpaceDoc>(currentRootUrl as any);
+      await cancelWithContext(ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
+      invariant(rootHandle.docSync(), 'Root doc not found');
+
+      const newRootContent = await convertLegacySpaceRootDoc(structuredClone(rootHandle.docSync()!));
+
+      for (const [id, url] of Object.entries(newRootContent.links ?? {})) {
+        const handle = context.repo.find(url as any);
+        await cancelWithContext(ctx, asyncTimeout(handle.whenReady(), 10_000));
+        invariant(handle.docSync(), 'Doc not found');
+        const newDoc = await convertLegacyReferences(structuredClone(handle.docSync()!));
+        const migratedDoc = migrateDocument(handle.docSync(), newDoc);
+        const newHandle = context.repo.import(am.save(migratedDoc));
+        newRootContent.links![id] = newHandle.url;
+      }
+
+      const migratedRoot = migrateDocument(rootHandle.docSync(), newRootContent);
+      const newRoot = context.repo.import(am.save(migratedRoot));
+
+      await context.repo.flush();
+      return {
+        newRoot: newRoot.url,
+      };
+    }
+    // TODO(dmaretskyi): This path doesn't seem to fit here. This is not a migration.
+    case CreateEpochRequest.Migration.REPLACE_AUTOMERGE_ROOT: {
+      invariant(context.newAutomergeRoot);
+
+      // Defensive programming - it should be the responsibility of the caller to flush the new root.
+      await context.repo.flush();
+      return {
+        newRoot: context.newAutomergeRoot,
+      };
+    }
+  }
+
+  return {};
+};

package/src/packlets/spaces/spaces-service.ts

@@ -30,6 +30,7 @@ import {
   type UpdateSpaceRequest,
   type WriteCredentialsRequest,
   type UpdateMemberRoleRequest,
+  type CreateEpochResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
@@ -208,10 +209,11 @@ export class SpacesServiceImpl implements SpacesService {
     }
   }
 
-  async createEpoch({ spaceKey, migration, automergeRootUrl }: CreateEpochRequest) {
+  async createEpoch({ spaceKey, migration, automergeRootUrl }: CreateEpochRequest): Promise<CreateEpochResponse> {
     const dataSpaceManager = await this._getDataSpaceManager();
     const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
-    await space.createEpoch({ migration, newAutomergeRoot: automergeRootUrl });
+    const credential = await space.createEpoch({ migration, newAutomergeRoot: automergeRootUrl });
+    return { epochCredential: credential ?? undefined };
   }
 
   private _serializeSpace(space: DataSpace): Space {

package/src/packlets/testing/test-builder.ts

@@ -19,8 +19,8 @@ import { createStorage, StorageType, type Storage } from '@dxos/random-access-st
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
 
 import { InvitationsHandler, InvitationsManager, SpaceInvitationProtocol } from '../invitations';
-import { ClientServicesHost, ServiceContext } from '../services';
-import { DataSpaceManager, type SigningContext } from '../spaces';
+import { ClientServicesHost, ServiceContext, type ServiceContextRuntimeParams } from '../services';
+import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
 //
 // TODO(burdon): Replace with test builder.
@@ -37,9 +37,11 @@ export const createServiceHost = (config: Config, signalManagerContext: MemorySi
 export const createServiceContext = async ({
   signalContext = new MemorySignalManagerContext(),
   storage = createStorage({ type: StorageType.RAM }),
+  runtimeParams,
 }: {
   signalContext?: MemorySignalManagerContext;
   storage?: Storage;
+  runtimeParams?: ServiceContextRuntimeParams;
 } = {}) => {
   const signalManager = new MemorySignalManager(signalContext);
   const networkManager = new SwarmNetworkManager({
@@ -51,6 +53,7 @@ export const createServiceContext = async ({
 
   return new ServiceContext(storage, level, networkManager, signalManager, {
     invitationConnectionDefaultParams: { controlHeartbeatInterval: 200 },
+    ...runtimeParams,
   });
 };
 
@@ -88,6 +91,7 @@ export class TestBuilder {
 
 export type TestPeerOpts = {
   dataStore?: StorageType;
+  dataSpaceParams?: DataSpaceManagerRuntimeParams;
 };
 
 export type TestPeerProps = {
@@ -110,8 +114,8 @@ export class TestPeer {
   private _props: TestPeerProps = {};
 
   constructor(
-    private readonly signalContext: MemorySignalManagerContext,
-    private readonly opts: TestPeerOpts = { dataStore: StorageType.RAM },
+    private readonly _signalContext: MemorySignalManagerContext,
+    private readonly _opts: TestPeerOpts = { dataStore: StorageType.RAM },
   ) {}
 
   get props() {
@@ -119,7 +123,7 @@ export class TestPeer {
   }
 
   get storage() {
-    return (this._props.storage ??= createStorage({ type: this.opts.dataStore }));
+    return (this._props.storage ??= createStorage({ type: this._opts.dataStore }));
   }
 
   get keyring() {
@@ -156,7 +160,7 @@ export class TestPeer {
 
   get networkManager() {
     return (this._props.networkManager ??= new SwarmNetworkManager({
-      signalManager: new MemorySignalManager(this.signalContext),
+      signalManager: new MemorySignalManager(this._signalContext),
       transportFactory: MemoryTransportFactory,
     }));
   }
@@ -176,10 +180,7 @@ export class TestPeer {
   }
 
   get echoHost() {
-    return (this._props.echoHost ??= new EchoHost({
-      kv: this.level,
-      storage: this.storage,
-    }));
+    return (this._props.echoHost ??= new EchoHost({ kv: this.level }));
   }
 
   get dataSpaceManager(): DataSpaceManager {
@@ -191,6 +192,7 @@ export class TestPeer {
       this.feedStore,
       this.echoHost,
       this.invitationsManager,
+      this._opts.dataSpaceParams,
     ));
   }
 

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.5.9-main.cb71230";
+export const DXOS_VERSION = "0.5.9-main.d63ef8d";