@dxos/edge-client 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/service/edge-service.test.ts

@@ -0,0 +1,151 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { EffectEx } from '@dxos/effect';
+
+import { EdgeServiceClient, EdgeServiceError } from './edge-service';
+import * as Image from './Image';
+
+const Echo = Schema.Struct({ value: Schema.String });
+
+// Minimal Response stub so tests stay free of a real fetch implementation.
+type StubResponse = {
+  ok: boolean;
+  status: number;
+  json?: () => Promise<unknown>;
+  text?: () => Promise<string>;
+};
+
+type Captured = { url: string; init: RequestInit };
+
+const stubFetch = (
+  handler: (captured: Captured) => StubResponse | Promise<StubResponse>,
+): { fetch: typeof globalThis.fetch; calls: Captured[] } => {
+  const calls: Captured[] = [];
+  const fetch = (async (input: any, init: any) => {
+    const captured: Captured = { url: input.toString(), init: init ?? {} };
+    calls.push(captured);
+    return (await handler(captured)) as unknown as Response;
+  }) as typeof globalThis.fetch;
+  return { fetch, calls };
+};
+
+const json = (body: unknown, status = 200): StubResponse => ({
+  ok: status >= 200 && status < 300,
+  status,
+  json: () => Promise.resolve(body),
+  text: () => Promise.resolve(JSON.stringify(body)),
+});
+
+describe('EdgeServiceClient', () => {
+  test('postJson resolves and decodes the response', async ({ expect }) => {
+    const { fetch, calls } = stubFetch(() => json({ value: 'pong' }));
+    const client = new EdgeServiceClient({ baseUrl: 'https://edge.test', fetch });
+
+    const result = await EffectEx.runPromise(client.postJson('/ping', { ping: true }, Echo));
+    expect(result).toEqual({ value: 'pong' });
+    expect(calls[0].url).toBe('https://edge.test/ping');
+    expect((calls[0].init.headers as Headers).get('Content-Type')).toBe('application/json');
+  });
+
+  test('sets the client-tag header when configured', async ({ expect }) => {
+    const { fetch, calls } = stubFetch(() => json({ value: 'ok' }));
+    const client = new EdgeServiceClient({ baseUrl: 'https://edge.test', clientTag: 'ci-e2e', fetch });
+
+    await EffectEx.runPromise(client.postJson('/ping', {}, Echo));
+    expect((calls[0].init.headers as Headers).get('X-DXOS-Client-Tag')).toBe('ci-e2e');
+  });
+
+  test('merges authHeaders when provided', async ({ expect }) => {
+    const { fetch, calls } = stubFetch(() => json({ value: 'ok' }));
+    const client = new EdgeServiceClient({
+      baseUrl: 'https://edge.test',
+      fetch,
+      authHeaders: () => Effect.succeed({ Authorization: 'Bearer xyz' }),
+    });
+
+    await EffectEx.runPromise(client.postJson('/ping', {}, Echo));
+    expect((calls[0].init.headers as Headers).get('Authorization')).toBe('Bearer xyz');
+  });
+
+  test('non-2xx fails with EdgeServiceError carrying the status', async ({ expect }) => {
+    const { fetch } = stubFetch(() => ({ ok: false, status: 422, text: () => Promise.resolve('bad image') }));
+    const client = new EdgeServiceClient({ baseUrl: 'https://edge.test', fetch });
+
+    const error = await EffectEx.runPromise(Effect.flip(client.postForm('/upload', new FormData(), Echo)));
+    expect(error).toBeInstanceOf(EdgeServiceError);
+    expect(error.status).toBe(422);
+    expect(error.message).toContain('bad image');
+  });
+
+  test('malformed JSON fails with EdgeServiceError', async ({ expect }) => {
+    const { fetch } = stubFetch(() => ({
+      ok: true,
+      status: 200,
+      json: () => Promise.reject(new Error('Unexpected token')),
+    }));
+    const client = new EdgeServiceClient({ baseUrl: 'https://edge.test', fetch });
+
+    const error = await EffectEx.runPromise(Effect.flip(client.postJson('/ping', {}, Echo)));
+    expect(error).toBeInstanceOf(EdgeServiceError);
+    expect(error.message).toContain('parse JSON');
+  });
+
+  test('schema mismatch fails with EdgeServiceError', async ({ expect }) => {
+    const { fetch } = stubFetch(() => json({ wrong: 'shape' }));
+    const client = new EdgeServiceClient({ baseUrl: 'https://edge.test', fetch });
+
+    const error = await EffectEx.runPromise(Effect.flip(client.postJson('/ping', {}, Echo)));
+    expect(error).toBeInstanceOf(EdgeServiceError);
+    expect(error.message).toContain('schema');
+  });
+
+  test('non-serializable body fails with EdgeServiceError, not a synchronous throw', async ({ expect }) => {
+    const { fetch } = stubFetch(() => json({ value: 'ok' }));
+    const client = new EdgeServiceClient({ baseUrl: 'https://edge.test', fetch });
+    const circular: Record<string, unknown> = {};
+    circular.self = circular;
+
+    const error = await EffectEx.runPromise(Effect.flip(client.postJson('/ping', circular, Echo)));
+    expect(error).toBeInstanceOf(EdgeServiceError);
+    expect(error.message).toContain('serialize');
+  });
+
+  test('transport rejection fails with EdgeServiceError', async ({ expect }) => {
+    const { fetch } = stubFetch(() => Promise.reject(new Error('ECONNREFUSED')));
+    const client = new EdgeServiceClient({ baseUrl: 'https://edge.test', fetch });
+
+    const error = await EffectEx.runPromise(Effect.flip(client.postJson('/ping', {}, Echo)));
+    expect(error).toBeInstanceOf(EdgeServiceError);
+    expect(error.cause).toBeInstanceOf(Error);
+  });
+});
+
+describe('Image', () => {
+  test('upload posts file field to /upload and returns the hosted URL', async ({ expect }) => {
+    const { fetch, calls } = stubFetch(() => json({ id: 'abc', url: 'https://cdn.test/abc/public' }));
+    const client = new EdgeServiceClient({ baseUrl: Image.DEFAULT_IMAGE_SERVICE_URL, fetch });
+    const blob = new Blob([new Uint8Array([1, 2, 3])], { type: 'image/png' });
+
+    const result = await EffectEx.runPromise(Image.upload(client, blob, { filename: 'pic.png' }));
+    expect(result).toEqual({ id: 'abc', url: 'https://cdn.test/abc/public' });
+    expect(calls[0].url).toBe(`${Image.DEFAULT_IMAGE_SERVICE_URL}/upload`);
+    const form = calls[0].init.body as FormData;
+    expect(form.get('file')).toBeInstanceOf(Blob);
+  });
+
+  test('thumbnail posts to /thumbnail', async ({ expect }) => {
+    const { fetch, calls } = stubFetch(() => json({ url: 'https://cdn.test/x/public' }));
+    const client = new EdgeServiceClient({ baseUrl: Image.DEFAULT_IMAGE_SERVICE_URL, fetch });
+    const blob = new Blob([new Uint8Array([1])], { type: 'image/png' });
+
+    const result = await EffectEx.runPromise(Image.thumbnail(client, blob));
+    expect(result.url).toBe('https://cdn.test/x/public');
+    expect(calls[0].url).toBe(`${Image.DEFAULT_IMAGE_SERVICE_URL}/thumbnail`);
+  });
+});

package/src/service/edge-service.ts

@@ -0,0 +1,139 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// Lightweight client for EDGE-hosted HTTP services — intentionally free of the
+// heavy transitive dependencies (`@dxos/context`, `@dxos/protocols`) that
+// `BaseHttpClient` pulls in, so it bundles cleanly into browser / workerd. The
+// only runtime dependencies are `effect` and `@dxos/log`.
+
+import * as Data from 'effect/Data';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+// Matches EDGE_CLIENT_TAG_HEADER from @dxos/protocols. Duplicated here (as in
+// `cors-proxy`) to avoid importing the heavy protocols bundle.
+const EDGE_CLIENT_TAG_HEADER = 'X-DXOS-Client-Tag';
+
+const DEFAULT_TIMEOUT = Duration.seconds(15);
+
+/** Number of body characters retained for the error message on a non-2xx response. */
+const ERROR_BODY_LIMIT = 512;
+
+export type EdgeServiceClientOptions = {
+  /** Base URL the service is hosted at; request paths resolve against it. */
+  baseUrl: string;
+  /** Tag included in the {@link EDGE_CLIENT_TAG_HEADER} header for metering. */
+  clientTag?: string;
+  /** Per-request timeout. */
+  timeout?: Duration.DurationInput;
+  /** Injectable for deterministic tests; defaults to `globalThis.fetch`. */
+  fetch?: typeof globalThis.fetch;
+  /** Auth seam invoked per request; unused by the image service today. */
+  authHeaders?: () => Effect.Effect<Record<string, string>>;
+};
+
+/** Single failure type for every transport, status, and decode error. */
+export class EdgeServiceError extends Data.TaggedError('EdgeServiceError')<{
+  message: string;
+  status?: number;
+  cause?: unknown;
+}> {}
+
+export class EdgeServiceClient {
+  readonly #baseUrl: string;
+  readonly #clientTag: string | undefined;
+  readonly #timeout: Duration.Duration;
+  readonly #fetch: typeof globalThis.fetch;
+  readonly #authHeaders: (() => Effect.Effect<Record<string, string>>) | undefined;
+
+  constructor(options: EdgeServiceClientOptions) {
+    this.#baseUrl = options.baseUrl;
+    this.#clientTag = options.clientTag;
+    this.#timeout = Duration.decode(options.timeout ?? DEFAULT_TIMEOUT);
+    // Bind so `fetch` keeps its expected `this` when injected as a method reference.
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    this.#fetch = fetchImpl.bind(globalThis);
+    this.#authHeaders = options.authHeaders;
+  }
+
+  get baseUrl(): string {
+    return this.#baseUrl;
+  }
+
+  /** POST a `FormData` (multipart) body and decode the JSON response. */
+  postForm<A>(path: string, form: FormData, schema: Schema.Schema<A>): Effect.Effect<A, EdgeServiceError> {
+    // The runtime sets `Content-Type: multipart/form-data` with the boundary;
+    // setting it manually here would omit the boundary and break parsing.
+    return this.#request(path, schema, { method: 'POST', body: form });
+  }
+
+  /** POST a JSON body and decode the JSON response. */
+  postJson<A>(path: string, body: unknown, schema: Schema.Schema<A>): Effect.Effect<A, EdgeServiceError> {
+    // Serialize inside the Effect so a circular/non-serializable body surfaces as
+    // EdgeServiceError rather than throwing synchronously from the call site.
+    return Effect.try({
+      try: () => JSON.stringify(body),
+      catch: (cause) => new EdgeServiceError({ message: 'Failed to serialize JSON request body', cause }),
+    }).pipe(
+      Effect.flatMap((json) =>
+        this.#request(path, schema, {
+          method: 'POST',
+          body: json,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      ),
+    );
+  }
+
+  #request<A>(path: string, schema: Schema.Schema<A>, init: RequestInit): Effect.Effect<A, EdgeServiceError> {
+    return Effect.gen(this, function* () {
+      const url = new URL(path, this.#baseUrl);
+      const headers = new Headers(init.headers ?? undefined);
+      if (this.#clientTag) {
+        headers.set(EDGE_CLIENT_TAG_HEADER, this.#clientTag);
+      }
+      if (this.#authHeaders) {
+        const auth = yield* this.#authHeaders();
+        for (const [key, value] of Object.entries(auth)) {
+          headers.set(key, value);
+        }
+      }
+
+      const response = yield* Effect.tryPromise({
+        try: (signal) => this.#fetch(url, { ...init, headers, signal }),
+        catch: (cause) => new EdgeServiceError({ message: `Request to ${url.pathname} failed`, cause }),
+      });
+
+      if (!response.ok) {
+        // Body text aids debugging but may be large; truncate and never throw on read.
+        const detail = yield* Effect.promise(() => response.text().catch(() => '')).pipe(
+          Effect.map((text) => text.slice(0, ERROR_BODY_LIMIT)),
+        );
+        return yield* new EdgeServiceError({
+          message: `Service responded ${response.status}${detail ? `: ${detail}` : ''}`,
+          status: response.status,
+        });
+      }
+
+      const json = yield* Effect.tryPromise({
+        try: () => response.json(),
+        catch: (cause) =>
+          new EdgeServiceError({ message: 'Failed to parse JSON response', status: response.status, cause }),
+      });
+
+      return yield* Schema.decodeUnknown(schema)(json).pipe(
+        Effect.mapError(
+          (cause) =>
+            new EdgeServiceError({ message: 'Response did not match expected schema', status: response.status, cause }),
+        ),
+      );
+    }).pipe(
+      Effect.timeoutFail({
+        duration: this.#timeout,
+        onTimeout: () => new EdgeServiceError({ message: `Request to ${path} timed out` }),
+      }),
+    );
+  }
+}

package/src/service/image-service.e2e.test.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { EffectEx } from '@dxos/effect';
+
+import { EdgeServiceClient } from './edge-service';
+import * as Image from './Image';
+
+// Live end-to-end checks against the shared Composer image service (the Cloudflare
+// Worker at DEFAULT_IMAGE_SERVICE_URL). These hit the public network, so they are
+// gated behind DX_RUN_IMAGE_SERVICE_E2E and skipped in CI by default.
+//
+//   DX_RUN_IMAGE_SERVICE_E2E=1 moon run edge-client:test -- image-service.e2e.test.ts
+//
+// Override the target with DX_IMAGE_SERVICE_URL to point at a staging worker.
+
+// Require an explicit opt-in value so `DX_RUN_IMAGE_SERVICE_E2E=0` doesn't run live tests.
+const ENABLED = /^(1|true)$/i.test(process.env.DX_RUN_IMAGE_SERVICE_E2E ?? '');
+const SERVICE_URL = process.env.DX_IMAGE_SERVICE_URL ?? Image.DEFAULT_IMAGE_SERVICE_URL;
+
+// 32x32 RGB gradient PNG. The worker decodes + resizes the upload, so it rejects
+// degenerate inputs (a 1x1 PNG yields a 422); a real raster of modest dimensions
+// is the smallest payload it reliably accepts.
+const PNG_32X32_BASE64 =
+  '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';
+
+const pngBlob = (): Blob => {
+  const binary = atob(PNG_32X32_BASE64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new Blob([bytes], { type: 'image/png' });
+};
+
+const isAbsoluteHttpUrl = (value: string): boolean => /^https?:\/\//.test(value);
+
+describe.skipIf(!ENABLED)('image service (live)', () => {
+  const client = new EdgeServiceClient({ baseUrl: SERVICE_URL });
+
+  test('Image.upload stores an image and returns a hosted URL', async ({ expect }) => {
+    const result = await EffectEx.runPromise(Image.upload(client, pngBlob(), { filename: `e2e-${Date.now()}.png` }));
+    expect(isAbsoluteHttpUrl(result.url)).toBe(true);
+  });
+
+  test('Image.thumbnail stores an image and returns a hosted URL', async ({ expect }) => {
+    const result = await EffectEx.runPromise(Image.thumbnail(client, pngBlob(), { filename: `e2e-${Date.now()}.png` }));
+    expect(isAbsoluteHttpUrl(result.url)).toBe(true);
+  });
+});

package/src/service/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './edge-service';
+
+export * as Image from './Image';

package/src/testing/test-utils.ts

@@ -106,7 +106,7 @@ const createResponseSender = (connection: () => WebSocketMuxer) => {
     void connection().send(
       buf.create(MessageSchema, {
         source: {
-          identityKey: recipient.identityKey,
+          identityDid: recipient.identityDid,
           peerKey: recipient.peerKey,
         },
         serviceId: request.serviceId!,