@dxos/edge-client 0.8.3 → 0.8.4-main.84f28bd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/edge-client",
-  "version": "0.8.3",
+  "version": "0.8.4-main.84f28bd",
   "description": "EDGE Client",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -39,23 +39,27 @@
     "README.md"
   ],
   "dependencies": {
+    "@effect/platform": "^0.87.12",
     "isomorphic-ws": "^5.0.0",
     "ws": "^8.14.2",
-    "@dxos/async": "0.8.3",
-    "@dxos/context": "0.8.3",
-    "@dxos/credentials": "0.8.3",
-    "@dxos/debug": "0.8.3",
-    "@dxos/invariant": "0.8.3",
-    "@dxos/keys": "0.8.3",
-    "@dxos/keyring": "0.8.3",
-    "@dxos/log": "0.8.3",
-    "@dxos/crypto": "0.8.3",
-    "@dxos/node-std": "0.8.3",
-    "@dxos/protocols": "0.8.3",
-    "@dxos/util": "0.8.3"
+    "@dxos/async": "0.8.4-main.84f28bd",
+    "@dxos/context": "0.8.4-main.84f28bd",
+    "@dxos/credentials": "0.8.4-main.84f28bd",
+    "@dxos/debug": "0.8.4-main.84f28bd",
+    "@dxos/crypto": "0.8.4-main.84f28bd",
+    "@dxos/invariant": "0.8.4-main.84f28bd",
+    "@dxos/keyring": "0.8.4-main.84f28bd",
+    "@dxos/keys": "0.8.4-main.84f28bd",
+    "@dxos/log": "0.8.4-main.84f28bd",
+    "@dxos/node-std": "0.8.4-main.84f28bd",
+    "@dxos/protocols": "0.8.4-main.84f28bd",
+    "@dxos/util": "0.8.4-main.84f28bd"
   },
   "devDependencies": {
-    "@dxos/test-utils": "0.8.3"
+    "@dxos/test-utils": "0.8.4-main.84f28bd"
+  },
+  "peerDependencies": {
+    "effect": "^3.13.3"
   },
   "publishConfig": {
     "access": "public"

package/src/edge-http-client.test.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from 'vitest';
+
+import { createEphemeralEdgeIdentity } from './auth';
+import { EdgeHttpClient } from './edge-http-client';
+
+// TODO(burdon): Factor out config.
+const DEV_SERVER = 'https://edge.dxos.workers.dev';
+
+describe.skipIf(process.env.CI)('EdgeHttpClient', () => {
+  it.only('should get status', async ({ expect }) => {
+    const client = new EdgeHttpClient(DEV_SERVER);
+    const identity = await createEphemeralEdgeIdentity();
+    client.setIdentity(identity);
+
+    const result = await client.getStatus();
+    expect(result).toBeDefined();
+  });
+});

package/src/edge-http-client.ts

@@ -2,42 +2,73 @@
 // Copyright 2024 DXOS.org
 //
 
+import { FetchHttpClient, HttpClient } from '@effect/platform';
+import { Effect, pipe } from 'effect';
+
 import { sleep } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { type PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
+  type CreateAgentResponseBody,
+  type CreateAgentRequestBody,
+  type CreateSpaceRequest,
+  type CreateSpaceResponseBody,
+  EdgeAuthChallengeError,
   EdgeCallFailedError,
   type EdgeHttpResponse,
+  type ExecuteWorkflowResponseBody,
+  type GetAgentStatusResponseBody,
   type GetNotarizationResponseBody,
-  type PostNotarizationRequestBody,
+  type InitiateOAuthFlowRequest,
+  type InitiateOAuthFlowResponse,
   type JoinSpaceRequest,
   type JoinSpaceResponseBody,
-  EdgeAuthChallengeError,
-  type CreateAgentResponseBody,
-  type CreateAgentRequestBody,
-  type GetAgentStatusResponseBody,
   type RecoverIdentityRequest,
   type RecoverIdentityResponseBody,
-  type UploadFunctionRequest,
-  type UploadFunctionResponseBody,
   type ObjectId,
-  type ExecuteWorkflowResponseBody,
+  type PostNotarizationRequestBody,
   type QueueQuery,
   type QueryResult,
-  type InitiateOAuthFlowRequest,
-  type InitiateOAuthFlowResponse,
-  type CreateSpaceRequest,
-  type CreateSpaceResponseBody,
+  type UploadFunctionRequest,
+  type UploadFunctionResponseBody,
+  type EdgeStatus,
 } from '@dxos/protocols';
+import { createUrl } from '@dxos/util';
 
 import { type EdgeIdentity, handleAuthChallenge } from './edge-identity';
+import { encodeAuthHeader, HttpConfig, withLogging, withRetryConfig } from './http-client';
 import { getEdgeUrlWithProtocol } from './utils';
 
 const DEFAULT_RETRY_TIMEOUT = 1500;
 const DEFAULT_RETRY_JITTER = 500;
 const DEFAULT_MAX_RETRIES_COUNT = 3;
 
+export type RetryConfig = {
+  /**
+   * A number of call retries, not counting the initial request.
+   */
+  count: number;
+  /**
+   * Delay before retries in ms.
+   */
+  timeout?: number;
+  /**
+   * A random amount of time before retrying to help prevent large bursts of requests.
+   */
+  jitter?: number;
+};
+
+type EdgeHttpRequestArgs = {
+  method: string;
+  context?: Context;
+  retry?: RetryConfig;
+  body?: any;
+};
+
+export type EdgeHttpGetArgs = Pick<EdgeHttpRequestArgs, 'context' | 'retry'>;
+export type EdgeHttpPostArgs = Pick<EdgeHttpRequestArgs, 'context' | 'retry' | 'body'>;
+
 export class EdgeHttpClient {
   private readonly _baseUrl: string;
 
@@ -64,19 +95,38 @@ export class EdgeHttpClient {
     }
   }
 
+  //
+  // Status
+  //
+
+  public async getStatus(args?: EdgeHttpGetArgs): Promise<EdgeStatus> {
+    return this._call(new URL('/status', this.baseUrl), { ...args, method: 'GET' });
+  }
+
+  //
+  // Agents
+  //
+
   public createAgent(body: CreateAgentRequestBody, args?: EdgeHttpGetArgs): Promise<CreateAgentResponseBody> {
-    return this._call('/agents/create', { ...args, method: 'POST', body });
+    return this._call(new URL('/agents/create', this.baseUrl), { ...args, method: 'POST', body });
   }
 
   public getAgentStatus(
     request: { ownerIdentityKey: PublicKey },
     args?: EdgeHttpGetArgs,
   ): Promise<GetAgentStatusResponseBody> {
-    return this._call(`/users/${request.ownerIdentityKey.toHex()}/agent/status`, { ...args, method: 'GET' });
+    return this._call(new URL(`/users/${request.ownerIdentityKey.toHex()}/agent/status`, this.baseUrl), {
+      ...args,
+      method: 'GET',
+    });
   }
 
+  //
+  // Credentials
+  //
+
   public getCredentialsForNotarization(spaceId: SpaceId, args?: EdgeHttpGetArgs): Promise<GetNotarizationResponseBody> {
-    return this._call(`/spaces/${spaceId}/notarization`, { ...args, method: 'GET' });
+    return this._call(new URL(`/spaces/${spaceId}/notarization`, this.baseUrl), { ...args, method: 'GET' });
   }
 
   public async notarizeCredentials(
@@ -84,49 +134,55 @@ export class EdgeHttpClient {
     body: PostNotarizationRequestBody,
     args?: EdgeHttpGetArgs,
   ): Promise<void> {
-    await this._call(`/spaces/${spaceId}/notarization`, { ...args, body, method: 'POST' });
+    await this._call(new URL(`/spaces/${spaceId}/notarization`, this.baseUrl), { ...args, body, method: 'POST' });
   }
 
-  public async joinSpaceByInvitation(
-    spaceId: SpaceId,
-    body: JoinSpaceRequest,
-    args?: EdgeHttpGetArgs,
-  ): Promise<JoinSpaceResponseBody> {
-    return this._call(`/spaces/${spaceId}/join`, { ...args, body, method: 'POST' });
-  }
+  //
+  // Identity
+  //
 
   public async recoverIdentity(
     body: RecoverIdentityRequest,
     args?: EdgeHttpGetArgs,
   ): Promise<RecoverIdentityResponseBody> {
-    return this._call('/identity/recover', { ...args, body, method: 'POST' });
+    return this._call(new URL('/identity/recover', this.baseUrl), { ...args, body, method: 'POST' });
   }
 
-  public async executeWorkflow(
+  //
+  // Invitations
+  //
+
+  public async joinSpaceByInvitation(
     spaceId: SpaceId,
-    graphId: ObjectId,
-    input: any,
+    body: JoinSpaceRequest,
     args?: EdgeHttpGetArgs,
-  ): Promise<ExecuteWorkflowResponseBody> {
-    return this._call(`/workflows/${spaceId}/${graphId}`, { ...args, body: input, method: 'POST' });
+  ): Promise<JoinSpaceResponseBody> {
+    return this._call(new URL(`/spaces/${spaceId}/join`, this.baseUrl), { ...args, body, method: 'POST' });
   }
 
-  public async uploadFunction(
-    pathParts: { functionId?: string },
-    body: UploadFunctionRequest,
-    args?: EdgeHttpGetArgs,
-  ): Promise<UploadFunctionResponseBody> {
-    const path = ['functions', ...(pathParts.functionId ? [pathParts.functionId] : [])].join('/');
-    return this._call(path, { ...args, body, method: 'PUT' });
-  }
+  //
+  // OAuth and credentials
+  //
 
   public async initiateOAuthFlow(
     body: InitiateOAuthFlowRequest,
     args?: EdgeHttpGetArgs,
   ): Promise<InitiateOAuthFlowResponse> {
-    return this._call('/oauth/initiate', { ...args, body, method: 'POST' });
+    return this._call(new URL('/oauth/initiate', this.baseUrl), { ...args, body, method: 'POST' });
   }
 
+  //
+  // Spaces
+  //
+
+  async createSpace(body: CreateSpaceRequest, args?: EdgeHttpGetArgs): Promise<CreateSpaceResponseBody> {
+    return this._call(new URL('/spaces/create', this.baseUrl), { ...args, body, method: 'POST' });
+  }
+
+  //
+  // Queues
+  //
+
   public async queryQueue(
     subspaceTag: string,
     spaceId: SpaceId,
@@ -134,26 +190,19 @@ export class EdgeHttpClient {
     args?: EdgeHttpGetArgs,
   ): Promise<QueryResult> {
     const { queueId } = query;
-    const queryParams = new URLSearchParams();
-    if (query.after != null) {
-      queryParams.set('after', query.after);
-    }
-    if (query.before != null) {
-      queryParams.set('before', query.before);
-    }
-    if (query.limit != null) {
-      queryParams.set('limit', query.limit.toString());
-    }
-    if (query.reverse != null) {
-      queryParams.set('reverse', query.reverse.toString());
-    }
-    if (query.objectIds != null) {
-      queryParams.set('objectIds', query.objectIds.join(','));
-    }
-    return this._call(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}/query?${queryParams.toString()}`, {
-      ...args,
-      method: 'GET',
-    });
+    return this._call(
+      createUrl(new URL(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}/query`, this.baseUrl), {
+        after: query.after,
+        before: query.before,
+        limit: query.limit,
+        reverse: query.reverse,
+        objectIds: query.objectIds?.join(','),
+      }),
+      {
+        ...args,
+        method: 'GET',
+      },
+    );
   }
 
   public async insertIntoQueue(
@@ -163,72 +212,105 @@ export class EdgeHttpClient {
     objects: unknown[],
     args?: EdgeHttpGetArgs,
   ): Promise<void> {
-    return this._call(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}`, {
+    return this._call(new URL(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}`, this.baseUrl), {
       ...args,
       body: { objects },
       method: 'POST',
     });
   }
 
-  async deleteFromQueue(
+  public async deleteFromQueue(
     subspaceTag: string,
     spaceId: SpaceId,
     queueId: ObjectId,
     objectIds: ObjectId[],
     args?: EdgeHttpGetArgs,
   ): Promise<void> {
-    return this._call(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}`, {
+    return this._call(
+      createUrl(new URL(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}`, this.baseUrl), {
+        ids: objectIds.join(','),
+      }),
+      {
+        ...args,
+        method: 'DELETE',
+      },
+    );
+  }
+
+  //
+  // Functions
+  //
+
+  public async uploadFunction(
+    pathParts: { functionId?: string },
+    body: UploadFunctionRequest,
+    args?: EdgeHttpGetArgs,
+  ): Promise<UploadFunctionResponseBody> {
+    const path = ['functions', ...(pathParts.functionId ? [pathParts.functionId] : [])].join('/');
+    return this._call(new URL(path, this.baseUrl), { ...args, body, method: 'PUT' });
+  }
+
+  //
+  // Workflows
+  //
+
+  public async executeWorkflow(
+    spaceId: SpaceId,
+    graphId: ObjectId,
+    input: any,
+    args?: EdgeHttpGetArgs,
+  ): Promise<ExecuteWorkflowResponseBody> {
+    return this._call(new URL(`/workflows/${spaceId}/${graphId}`, this.baseUrl), {
       ...args,
-      query: { ids: objectIds.join(',') },
-      method: 'DELETE',
+      body: input,
+      method: 'POST',
     });
   }
 
-  async createSpace(body: CreateSpaceRequest, args?: EdgeHttpGetArgs): Promise<CreateSpaceResponseBody> {
-    return this._call('/spaces/create', { ...args, body, method: 'POST' });
+  //
+  // Internal
+  //
+
+  private async _fetch<T>(url: URL, args: EdgeHttpRequestArgs): Promise<T> {
+    return pipe(
+      HttpClient.get(url),
+      withLogging,
+      withRetryConfig,
+      Effect.provide(FetchHttpClient.layer),
+      Effect.provide(HttpConfig.default),
+      Effect.withSpan('EdgeHttpClient'),
+      Effect.runPromise,
+    ) as T;
   }
 
-  private async _call<T>(path: string, args: EdgeHttpCallArgs): Promise<T> {
-    const requestContext = args.context ?? new Context();
+  // TODO(burdon): Refactor with effect (see edge-http-client.test.ts).
+  private async _call<T>(url: URL, args: EdgeHttpRequestArgs): Promise<T> {
     const shouldRetry = createRetryHandler(args);
-    let url = `${this._baseUrl}${path.startsWith('/') ? path.slice(1) : path}`;
-
-    if (args.query) {
-      const queryParams = new URLSearchParams();
-      for (const [key, value] of Object.entries(args.query)) {
-        queryParams.set(key, value.toString());
-      }
-      url += `?${queryParams.toString()}`;
-    }
-
-    log('call', { method: args.method, path, request: args.body });
+    const requestContext = args.context ?? new Context();
+    log('fetch', { url, request: args.body });
 
     let handledAuth = false;
-    let authHeader = this._authHeader;
     while (true) {
       let processingError: EdgeCallFailedError;
       let retryAfterHeaderValue: number = Number.NaN;
       try {
-        const request = createRequest(args, authHeader);
+        const request = createRequest(args, this._authHeader);
         const response = await fetch(url, request);
-
         retryAfterHeaderValue = Number(response.headers.get('Retry-After'));
-
         if (response.ok) {
           const body = (await response.json()) as EdgeHttpResponse<T>;
           if (body.success) {
             return body.data;
           }
 
-          log('unsuccessful edge response', { path, body });
-
+          log.warn('unsuccessful edge response', { url, body });
           if (body.errorData?.type === 'auth_challenge' && typeof body.errorData?.challenge === 'string') {
             processingError = new EdgeAuthChallengeError(body.errorData.challenge, body.errorData);
           } else {
             processingError = EdgeCallFailedError.fromUnsuccessfulResponse(response, body);
           }
         } else if (response.status === 401 && !handledAuth) {
-          authHeader = await this._handleUnauthorized(response);
+          this._authHeader = await this._handleUnauthorized(response);
           handledAuth = true;
           continue;
         } else {
@@ -239,7 +321,7 @@ export class EdgeHttpClient {
       }
 
       if (processingError.isRetryable && (await shouldRetry(requestContext, retryAfterHeaderValue))) {
-        log('retrying edge request', { path, processingError });
+        log('retrying edge request', { url, processingError });
       } else {
         throw processingError;
       }
@@ -248,24 +330,35 @@ export class EdgeHttpClient {
 
   private async _handleUnauthorized(response: Response): Promise<string> {
     if (!this._edgeIdentity) {
-      log.warn('edge unauthorized response received before identity was set');
+      log.warn('unauthorized response received before identity was set');
       throw EdgeCallFailedError.fromHttpFailure(response);
     }
+
     const challenge = await handleAuthChallenge(response, this._edgeIdentity);
-    this._authHeader = encodeAuthHeader(challenge);
-    log('auth header updated');
-    return this._authHeader;
+    return encodeAuthHeader(challenge);
   }
 }
 
-const createRetryHandler = (args: EdgeHttpCallArgs) => {
-  if (!args.retry || args.retry.count < 1) {
+const createRequest = ({ method, body }: EdgeHttpRequestArgs, authHeader: string | undefined): RequestInit => {
+  return {
+    method,
+    body: body && JSON.stringify(body),
+    headers: authHeader ? { Authorization: authHeader } : undefined,
+  };
+};
+
+/**
+ * @deprecated
+ */
+const createRetryHandler = ({ retry }: EdgeHttpRequestArgs) => {
+  if (!retry || retry.count < 1) {
     return async () => false;
   }
+
   let retries = 0;
-  const maxRetries = args.retry.count ?? DEFAULT_MAX_RETRIES_COUNT;
-  const baseTimeout = args.retry.timeout ?? DEFAULT_RETRY_TIMEOUT;
-  const jitter = args.retry.jitter ?? DEFAULT_RETRY_JITTER;
+  const maxRetries = retry.count ?? DEFAULT_MAX_RETRIES_COUNT;
+  const baseTimeout = retry.timeout ?? DEFAULT_RETRY_TIMEOUT;
+  const jitter = retry.jitter ?? DEFAULT_RETRY_JITTER;
   return async (ctx: Context, retryAfter: number) => {
     if (++retries > maxRetries || ctx.disposed) {
       return false;
@@ -281,43 +374,3 @@ const createRetryHandler = (args: EdgeHttpCallArgs) => {
     return true;
   };
 };
-
-export type RetryConfig = {
-  /**
-   * A number of call retries, not counting the initial request.
-   */
-  count: number;
-  /**
-   * Delay before retries in ms.
-   */
-  timeout?: number;
-  /**
-   * A random amount of time before retrying to help prevent large bursts of requests.
-   */
-  jitter?: number;
-};
-
-export type EdgeHttpGetArgs = { context?: Context; retry?: RetryConfig };
-
-export type EdgeHttpPostArgs = { context?: Context; body?: any; retry?: RetryConfig };
-
-type EdgeHttpCallArgs = {
-  method: string;
-  body?: any;
-  context?: Context;
-  retry?: RetryConfig;
-  query?: Record<string, string>;
-};
-
-const createRequest = (args: EdgeHttpCallArgs, authHeader: string | undefined): RequestInit => {
-  return {
-    method: args.method,
-    body: args.body && JSON.stringify(args.body),
-    headers: authHeader ? { Authorization: authHeader } : undefined,
-  };
-};
-
-const encodeAuthHeader = (challenge: Uint8Array) => {
-  const encodedChallenge = Buffer.from(challenge).toString('base64');
-  return `VerifiablePresentation pb;base64,${encodedChallenge}`;
-};

package/src/http-client.test.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { FetchHttpClient, HttpClient } from '@effect/platform';
+import { Effect, pipe } from 'effect';
+import { afterEach, beforeEach, describe, it } from 'vitest';
+
+import { invariant } from '@dxos/invariant';
+
+import { HttpConfig, withLogging, withRetry, withRetryConfig } from './http-client';
+import { type TestServer, createTestServer, responseHandler } from './testing';
+
+describe('HttpClient', () => {
+  let server: TestServer | undefined;
+
+  beforeEach(async () => {
+    server = await createTestServer(responseHandler((attempt) => (attempt > 2 ? { value: 100 } : false)));
+  });
+
+  // eslint-disable-next-line mocha/no-top-level-hooks
+  afterEach(() => {
+    server?.close();
+    server = undefined;
+  });
+
+  // TODO(burdon): Auth headers.
+  // TODO(burdon): Add request/response schema type checking.
+  it.skipIf(process.env.CI)('should retry', async ({ expect }) => {
+    invariant(server);
+
+    {
+      const result = await pipe(
+        withRetry(HttpClient.get(server.url)),
+        Effect.provide(FetchHttpClient.layer),
+        Effect.withSpan('EdgeHttpClient'),
+        Effect.runPromise,
+      );
+      expect(result).toMatchObject({ success: true, data: { value: 100 } });
+    }
+
+    {
+      const result = await pipe(
+        HttpClient.get(server.url),
+        withLogging,
+        withRetryConfig,
+        Effect.provide(FetchHttpClient.layer),
+        Effect.provide(HttpConfig.default), // TODO(burdon): Swap out to mock.
+        Effect.withSpan('EdgeHttpClient'), // TODO(burdon): OTEL.
+        Effect.runPromise,
+      );
+      expect(result).toMatchObject({ success: true, data: { value: 100 } });
+    }
+  });
+});

package/src/http-client.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type HttpClient } from '@effect/platform';
+import { type HttpClientError } from '@effect/platform/HttpClientError';
+import { type HttpClientResponse } from '@effect/platform/HttpClientResponse';
+import { Context, Duration, Effect, Layer, Schedule } from 'effect';
+
+import { log } from '@dxos/log';
+
+// TODO(burdon): Factor out.
+
+export type RetryOptions = {
+  timeout: Duration.Duration;
+  retryTimes: number;
+  retryBaseDelay: Duration.Duration;
+};
+
+// Layer pattern.
+export class HttpConfig extends Context.Tag('HttpConfig')<HttpConfig, RetryOptions>() {
+  static default = Layer.succeed(HttpConfig, {
+    timeout: Duration.millis(1_000),
+    retryTimes: 3,
+    retryBaseDelay: Duration.millis(1_000),
+  });
+}
+
+// HOC pattern.
+export const withRetry = (
+  effect: Effect.Effect<HttpClientResponse, HttpClientError, HttpClient.HttpClient>,
+  {
+    timeout = Duration.millis(1_000),
+    retryBaseDelay = Duration.millis(1_000),
+    retryTimes = 3,
+  }: Partial<RetryOptions> = {},
+) => {
+  return effect.pipe(
+    Effect.flatMap((res) =>
+      // Treat 500 errors as retryable?
+      res.status === 500 ? Effect.fail(new Error(res.status.toString())) : res.json,
+    ),
+    Effect.timeout(timeout),
+    Effect.retry({
+      schedule: Schedule.exponential(retryBaseDelay).pipe(Schedule.jittered),
+      times: retryTimes,
+    }),
+  );
+};
+
+export const withRetryConfig = (effect: Effect.Effect<HttpClientResponse, HttpClientError, HttpClient.HttpClient>) =>
+  Effect.gen(function* () {
+    const config = yield* HttpConfig;
+    return yield* withRetry(effect, config);
+  });
+
+export const withLogging = <A extends HttpClientResponse, E, R>(effect: Effect.Effect<A, E, R>) =>
+  effect.pipe(Effect.tap((res) => log.info('response', { status: res.status })));
+
+/**
+ *
+ */
+// TODO(burdon): Document.
+export const encodeAuthHeader = (challenge: Uint8Array) => {
+  const encodedChallenge = Buffer.from(challenge).toString('base64');
+  return `VerifiablePresentation pb;base64,${encodedChallenge}`;
+};

package/src/testing/index.ts

@@ -2,4 +2,5 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './test-server';
 export * from './test-utils';