@dxos/client-services 0.8.0 → 0.8.1-main.81238a8

package/src/packlets/spaces/data-space-manager.ts

@@ -4,9 +4,14 @@
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { type Doc } from '@dxos/automerge/automerge';
-import { type AutomergeUrl, type DocHandle } from '@dxos/automerge/automerge-repo';
+import {
+  interpretAsDocumentId,
+  type AutomergeUrl,
+  type DocHandle,
+  type DocumentId,
+} from '@dxos/automerge/automerge-repo';
 import { PropertiesType, TYPE_PROPERTIES } from '@dxos/client-protocol';
-import { LifecycleState, Resource, cancelWithContext } from '@dxos/context';
+import { Context, LifecycleState, Resource, cancelWithContext } from '@dxos/context';
 import {
   createAdmissionCredentials,
   getCredentialAssertion,
@@ -15,6 +20,7 @@ import {
   type MemberInfo,
 } from '@dxos/credentials';
 import {
+  DatabaseRoot,
   findInlineObjectOfType,
   type EchoEdgeReplicator,
   type EchoHost,
@@ -27,13 +33,19 @@ import {
   type SpaceProtocol,
   type SpaceProtocolSession,
 } from '@dxos/echo-pipeline';
-import { SpaceDocVersion, encodeReference, type ObjectStructure, type SpaceDoc } from '@dxos/echo-protocol';
+import {
+  SpaceDocVersion,
+  createIdFromSpaceKey,
+  encodeReference,
+  type ObjectStructure,
+  type SpaceDoc,
+} from '@dxos/echo-protocol';
 import { createObjectId, getTypeReference } from '@dxos/echo-schema';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { writeMessages, type FeedStore } from '@dxos/feed-store';
-import { invariant } from '@dxos/invariant';
+import { assertArgument, assertState, failedInvariant, invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
-import { PublicKey } from '@dxos/keys';
+import { PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { AlreadyJoinedError, trace as Trace } from '@dxos/protocols';
 import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
@@ -117,6 +129,11 @@ export type DataSpaceManagerRuntimeParams = {
   disableP2pReplication?: boolean;
 };
 
+export type CreateSpaceOptions = {
+  rootUrl?: AutomergeUrl;
+  documents?: Record<DocumentId, Uint8Array>;
+};
+
 @trackLeaks('open', 'close')
 export class DataSpaceManager extends Resource {
   public readonly updated = new Event();
@@ -187,6 +204,10 @@ export class DataSpaceManager extends Resource {
     return this._spaces;
   }
 
+  getSpaceById(spaceId: SpaceId): DataSpace | undefined {
+    return [...this._spaces.values()].find((space) => space.id === spaceId);
+  }
+
   @synchronized
   protected override async _open() {
     log('open');
@@ -220,11 +241,16 @@ export class DataSpaceManager extends Resource {
    * Creates a new space writing the genesis credentials to the control feed.
    */
   @synchronized
-  async createSpace() {
-    invariant(this._lifecycleState === LifecycleState.OPEN, 'Not open.');
+  async createSpace(options: CreateSpaceOptions = {}) {
+    assertArgument(!!options.rootUrl === !!options.documents, 'root url must be required when providing documents');
+
+    assertState(this._lifecycleState === LifecycleState.OPEN, 'Not open.');
     const spaceKey = await this._keyring.createKey();
     const controlFeedKey = await this._keyring.createKey();
     const dataFeedKey = await this._keyring.createKey();
+
+    const spaceId = await createIdFromSpaceKey(spaceKey);
+
     const metadata: SpaceMetadata = {
       key: spaceKey,
       genesisFeedKey: controlFeedKey,
@@ -233,12 +259,45 @@ export class DataSpaceManager extends Resource {
       state: SpaceState.SPACE_ACTIVE,
     };
 
-    log('creating space...', { spaceKey });
+    log.info('creating space...', { spaceId, spaceKey });
+
+    // New document IDs for the space.
+    const documentIdMapping: Record<DocumentId, DocumentId> = {};
+    if (options.documents) {
+      invariant(
+        Object.keys(options.documents).every((documentId) => /^[a-zA-Z0-9]+$/.test(documentId)),
+        'Invalid document IDs',
+      );
+
+      await Promise.all(
+        Object.entries(options.documents).map(async ([documentId, data]) => {
+          log('creating document...', { documentId });
+          const newDoc = await this._echoHost.createDoc(data, { preserveHistory: true });
+          documentIdMapping[documentId as DocumentId] = newDoc.documentId;
+        }),
+      );
+    }
+
+    log('opening space...', { spaceKey });
+
+    let root: DatabaseRoot;
+    if (options.rootUrl) {
+      const newRootDocId = documentIdMapping[interpretAsDocumentId(options.rootUrl)] ?? failedInvariant();
+      const rootDocHandle = await this._echoHost.loadDoc<SpaceDoc>(Context.default(), newRootDocId);
+      DatabaseRoot.mapLinks(rootDocHandle, documentIdMapping);
+
+      root = await this._echoHost.openSpaceRoot(spaceId, `automerge:${newRootDocId}` as AutomergeUrl);
+    } else {
+      root = await this._echoHost.createSpaceRoot(spaceKey);
+    }
+
+    log('constructing space...', { spaceKey });
 
-    const root = await this._echoHost.createSpaceRoot(spaceKey);
     const space = await this._constructSpace(metadata);
     await space.open();
 
+    log('adding space...', { spaceKey });
+
     const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, root.url);
     await this._metadataStore.addSpace(metadata);
 
@@ -248,6 +307,8 @@ export class DataSpaceManager extends Resource {
 
     await space.initializeDataPipeline();
 
+    log('space ready.', { spaceId, spaceKey });
+
     this.updated.emit();
     return space;
   }

package/src/packlets/spaces/data-space.ts

@@ -3,6 +3,7 @@
 //
 
 import { Event, Mutex, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
+import { save } from '@dxos/automerge/automerge';
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
 import type { SpecificCredential } from '@dxos/credentials';
@@ -17,7 +18,7 @@ import {
 import { SpaceDocVersion, type SpaceDoc } from '@dxos/echo-protocol';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';
-import { failedInvariant } from '@dxos/invariant';
+import { failedInvariant, invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -349,6 +350,18 @@ export class DataSpace {
     log('space is ready');
   }
 
+  async *getAllDocuments(): AsyncIterable<[string, Uint8Array]> {
+    invariant(this._databaseRoot, 'Space is not ready');
+    const doc = this._databaseRoot.docSync() ?? failedInvariant();
+    const root = save(doc);
+    yield [this._databaseRoot.documentId, root];
+
+    for (const documentUrl of this._databaseRoot.getAllLinkedDocuments()) {
+      const data = await this._echoHost.exportDoc(Context.default(), documentUrl);
+      yield [documentUrl.replace(/^automerge:/, ''), data];
+    }
+  }
+
   private async _enterReadyState() {
     await this._callbacks.beforeReady?.();
 

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

@@ -3,6 +3,7 @@
 //
 
 import { EventSubscriptions, UpdateScheduler, scheduleTask } from '@dxos/async';
+import type { AutomergeUrl } from '@dxos/automerge/automerge-repo';
 import { Stream } from '@dxos/codec-protobuf/stream';
 import {
   createAdmissionCredentials,
@@ -13,7 +14,8 @@ import {
 import { raise } from '@dxos/debug';
 import { type SpaceManager } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
-import { invariant } from '@dxos/invariant';
+import { assertArgument, assertState, invariant } from '@dxos/invariant';
+import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
   ApiError,
@@ -40,6 +42,10 @@ import {
   type JoinSpaceResponse,
   type JoinBySpaceKeyRequest,
   type CreateEpochResponse,
+  type ExportSpaceResponse,
+  type ExportSpaceRequest,
+  type ImportSpaceRequest,
+  type ImportSpaceResponse,
 } 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';
@@ -49,6 +55,7 @@ import { type Provider } from '@dxos/util';
 import { type DataSpace } from './data-space';
 import { type DataSpaceManager } from './data-space-manager';
 import { type IdentityManager } from '../identity';
+import { extractSpaceArchive, SpaceArchiveWriter } from '../space-export';
 
 export class SpacesServiceImpl implements SpacesService {
   constructor(
@@ -256,6 +263,37 @@ export class SpacesServiceImpl implements SpacesService {
     return this._joinByAdmission({ credential });
   }
 
+  async exportSpace(request: ExportSpaceRequest): Promise<ExportSpaceResponse> {
+    await using writer = await new SpaceArchiveWriter().open();
+    assertArgument(SpaceId.isValid(request.spaceId), 'Invalid space ID');
+
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const space = dataSpaceManager.getSpaceById(request.spaceId) ?? raise(new Error('Space not found'));
+    await writer.begin({ spaceId: space.id });
+    const rootUrl = space.automergeSpaceState.lastEpoch?.subject.assertion.automergeRoot;
+    assertState(rootUrl, 'Space does not have a root URL');
+    await writer.setCurrentRootUrl(rootUrl);
+
+    for await (const [documentId, data] of space.getAllDocuments()) {
+      await writer.writeDocument(documentId, data);
+    }
+
+    const archive = await writer.finish();
+    return { archive };
+  }
+
+  async importSpace(request: ImportSpaceRequest): Promise<ImportSpaceResponse> {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const extracted = await extractSpaceArchive(request.archive);
+    invariant(extracted.metadata.echo?.currentRootUrl, 'Space archive does not contain a root URL');
+    const space = await dataSpaceManager.createSpace({
+      documents: extracted.documents,
+      rootUrl: extracted.metadata.echo?.currentRootUrl as AutomergeUrl,
+    });
+    await this._updateMetrics();
+    return { newSpaceId: space.id };
+  }
+
   private async _joinByAdmission({ credential }: ContactAdmission): Promise<JoinSpaceResponse> {
     const assertion = getCredentialAssertion(credential);
     invariant(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');

package/src/version.ts

@@ -1,5 +1 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export const DXOS_VERSION = '0.8.0'; // {x-release-please-version}
+export const DXOS_VERSION = "0.8.1-main.81238a8";