@miradorlabs/parallax-web 1.0.0

package/rollup.config.mjs

@@ -0,0 +1,86 @@
+import typescript from '@rollup/plugin-typescript';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import dts from 'rollup-plugin-dts';
+
+export default [
+  // Bundle the JavaScript/TypeScript code for ES module
+  {
+    input: 'index.ts',
+    output: {
+      file: 'dist/index.esm.js',
+      format: 'es',
+      sourcemap: true,
+    },
+    plugins: [
+      resolve({
+        browser: true,
+        preferBuiltins: false,
+      }),
+      commonjs(),
+      typescript({
+        tsconfig: './tsconfig.build.json',
+        declaration: false,
+        sourceMap: true,
+      }),
+    ],
+    external: [
+      'google-protobuf',
+      'mirador-gateway-parallax-web',
+      /^mirador-gateway-parallax-web\/.*/,
+      'rxjs',
+      /^rxjs\/.*/,
+    ],
+  },
+  // Bundle the JavaScript/TypeScript code for UMD (browser global)
+  {
+    input: 'index.ts',
+    output: {
+      file: 'dist/index.umd.js',
+      format: 'umd',
+      name: 'ParallaxWeb',
+      sourcemap: true,
+      globals: {
+        'google-protobuf': 'googleProtobuf',
+        'mirador-gateway-parallax-web': 'miradorGatewayParallaxWeb',
+        'mirador-gateway-parallax-web/proto/gateway/parallax/v1/parallax_gateway': 'miradorGatewayParallaxWeb.parallaxGateway',
+        'rxjs': 'rxjs',
+      },
+    },
+    plugins: [
+      resolve({
+        browser: true,
+        preferBuiltins: false,
+      }),
+      commonjs(),
+      typescript({
+        tsconfig: './tsconfig.build.json',
+        declaration: false,
+        sourceMap: true,
+      }),
+    ],
+    external: [
+      'google-protobuf',
+      'mirador-gateway-parallax-web',
+      /^mirador-gateway-parallax-web\/.*/,
+      'rxjs',
+      /^rxjs\/.*/,
+    ],
+  },
+  // Bundle the TypeScript declarations
+  {
+    input: 'index.ts',
+    output: {
+      file: 'dist/index.d.ts',
+      format: 'es',
+    },
+    plugins: [dts()],
+    external: [
+      'google-protobuf',
+      'mirador-gateway-parallax-web',
+      /^mirador-gateway-parallax-web\/.*/,
+      'rxjs',
+      /^rxjs\/.*/,
+    ],
+  },
+];

package/src/grpc/index.ts

@@ -0,0 +1,155 @@
+import { Observable } from "rxjs";
+
+interface Metadata {
+  [key: string]: string;
+}
+
+interface Rpc {
+  request(
+    service: string,
+    method: string,
+    data: Uint8Array,
+    metadata?: Metadata
+  ): Promise<Uint8Array>;
+  clientStreamingRequest(
+    service: string,
+    method: string,
+    data: Observable<Uint8Array>
+  ): Promise<Uint8Array>;
+  serverStreamingRequest(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Observable<Uint8Array>;
+  bidirectionalStreamingRequest(
+    service: string,
+    method: string,
+    data: Observable<Uint8Array>
+  ): Observable<Uint8Array>;
+}
+
+export class GrpcWebRpc implements Rpc {
+  private url: string;
+  private apiKey?: string;
+
+  constructor(url: string, apiKey?: string) {
+    this.url = url;
+    this.apiKey = apiKey;
+  }
+
+  async request(
+    service: string,
+    method: string,
+    data: Uint8Array,
+    metadata?: Metadata
+  ): Promise<Uint8Array> {
+    console.log(`[gRPC-Web] Making request to ${this.url}/${service}/${method}`);
+
+    const headers: HeadersInit = {
+      'Content-Type': 'application/grpc-web+proto',
+      'X-Grpc-Web': '1',
+    };
+
+    // Add API key to headers if provided
+    if (this.apiKey) {
+      headers['x-api-key'] = this.apiKey;
+    }
+
+    // Add custom metadata
+    if (metadata) {
+      Object.entries(metadata).forEach(([key, value]) => {
+        headers[key] = value;
+      });
+    }
+
+    try {
+      const response = await fetch(`${this.url}/${service}/${method}`, {
+        method: 'POST',
+        headers,
+        body: data.buffer as ArrayBuffer,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`gRPC-Web error: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+
+      const arrayBuffer = await response.arrayBuffer();
+      console.log(`[gRPC-Web] Success from ${this.url}/${service}/${method}`);
+      return new Uint8Array(arrayBuffer);
+    } catch (error) {
+      console.error(
+        `[gRPC-Web] Error from ${this.url}/${service}/${method}:`,
+        error instanceof Error ? error.message : String(error)
+      );
+      throw error;
+    }
+  }
+
+  clientStreamingRequest(): Promise<Uint8Array> {
+    throw new Error("Client streaming not yet implemented for gRPC-Web");
+  }
+
+  serverStreamingRequest(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Observable<Uint8Array> {
+    return new Observable((subscriber) => {
+      const headers: HeadersInit = {
+        'Content-Type': 'application/grpc-web+proto',
+        'X-Grpc-Web': '1',
+      };
+
+      // Add API key to headers if provided
+      if (this.apiKey) {
+        headers['x-api-key'] = this.apiKey;
+      }
+
+      fetch(`${this.url}/${service}/${method}`, {
+        method: 'POST',
+        headers,
+        body: data.buffer as ArrayBuffer,
+      })
+        .then(async (response) => {
+          if (!response.ok) {
+            throw new Error(`gRPC-Web error: ${response.status} ${response.statusText}`);
+          }
+
+          if (!response.body) {
+            throw new Error('Response body is null');
+          }
+
+          const reader = response.body.getReader();
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+
+              if (done) {
+                subscriber.complete();
+                break;
+              }
+
+              if (value) {
+                subscriber.next(value);
+              }
+            }
+          } catch (error) {
+            subscriber.error(error);
+          }
+        })
+        .catch((error) => {
+          subscriber.error(error);
+        });
+
+      return () => {
+        // Cleanup logic if needed
+      };
+    });
+  }
+
+  bidirectionalStreamingRequest(): Observable<Uint8Array> {
+    throw new Error("Bidirectional streaming not yet implemented for gRPC-Web");
+  }
+}

package/src/helpers/index.ts

@@ -0,0 +1,13 @@
+// Helper serialization functions for browser environment
+function serialize(value: Uint8Array): Uint8Array {
+  return value;
+}
+
+function deserialize(bytes: Uint8Array): Uint8Array {
+  return bytes;
+}
+
+export {
+  deserialize,
+  serialize
+}

package/src/parallax/index.ts

@@ -0,0 +1,146 @@
+// Parallax SDK Web Client
+import type {
+  CreateTraceRequest,
+  StartSpanRequest,
+  FinishSpanRequest,
+  AddSpanEventRequest,
+  AddSpanErrorRequest,
+  AddSpanHintRequest,
+  AddSpanAttributesRequest
+} from "mirador-gateway-parallax-web/proto/gateway/parallax/v1/parallax_gateway";
+import * as apiGateway from "mirador-gateway-parallax-web/proto/gateway/parallax/v1/parallax_gateway";
+import { GrpcWebRpc } from "../grpc";
+
+const GRPC_GATEWAY_API_URL = "https://gateway-parallax-dev.platform.svc.cluster.local:50053";
+
+const debugIssue = (trace: string, error: Error) => {
+  // Handle our own debugging / logging here
+  console.error(`[ParallaxClient][${trace}] Error:`, error);
+}
+
+class ParallaxClient {
+  public apiUrl: string = GRPC_GATEWAY_API_URL;
+  private apiGatewayRpc: GrpcWebRpc;
+
+  constructor(public apiKey?: string, apiUrl?: string) {
+    if (apiUrl) {
+      this.apiUrl = apiUrl;
+    }
+    this.apiGatewayRpc = new GrpcWebRpc(this.apiUrl, apiKey);
+  }
+
+  /**
+   * Create a new trace
+   * @param params Parameters to create a new trace
+   * @returns Response from the create trace operation
+   */
+  async createTrace(params: CreateTraceRequest): Promise<apiGateway.CreateTraceResponse> {
+    try {
+      const apiGatewayClient = new apiGateway.ParallaxGatewayServiceClientImpl(
+        this.apiGatewayRpc
+      );
+      return await apiGatewayClient.CreateTrace(params);
+    } catch (_error) {
+      debugIssue("createTrace", new Error('Error creating trace'));
+      throw _error;
+    }
+  }
+
+  /**
+   * Start a new span within a trace
+   * @param params Parameters to start a new span
+   */
+  async startSpan(params: StartSpanRequest) {
+    try {
+      const apiGatewayClient = new apiGateway.ParallaxGatewayServiceClientImpl(
+        this.apiGatewayRpc
+      );
+      return await apiGatewayClient.StartSpan(params);
+    } catch (_error) {
+      debugIssue("startSpan", new Error('Error starting span'));
+      throw _error;
+    }
+  }
+
+  /**
+   * Finish a span within a trace
+   * @param params Parameters to finish a span
+   */
+  async finishSpan(params: FinishSpanRequest) {
+    try {
+      const apiGatewayClient = new apiGateway.ParallaxGatewayServiceClientImpl(
+        this.apiGatewayRpc
+      );
+      return await apiGatewayClient.FinishSpan(params);
+    } catch (_error) {
+      debugIssue("finishSpan", new Error('Error finishing span'));
+      throw _error;
+    }
+  }
+
+  /**
+   * Add attributes to a span
+   * @param params Parameters to add attributes to a span
+   */
+  async addSpanAttributes(params: AddSpanAttributesRequest) {
+    try {
+      const apiGatewayClient = new apiGateway.ParallaxGatewayServiceClientImpl(
+        this.apiGatewayRpc
+      );
+      return await apiGatewayClient.AddSpanAttributes(params);
+    } catch (_error) {
+      debugIssue("addSpanAttributes", new Error('Error adding span attributes'));
+      throw _error;
+    }
+  }
+
+  /**
+   * Add an event to a span
+   * @param params Parameters to add an event to a span
+   */
+  async addSpanEvent(params: AddSpanEventRequest) {
+    try {
+      const apiGatewayClient = new apiGateway.ParallaxGatewayServiceClientImpl(
+        this.apiGatewayRpc
+      );
+      return await apiGatewayClient.AddSpanEvent(params);
+    } catch (_error) {
+      debugIssue("addSpanEvent", new Error('Error adding span event'));
+      throw _error;
+    }
+  }
+
+  /**
+   * Add an error to a span
+   * @param params Parameters to add an error to a span
+   */
+  async addSpanError(params: AddSpanErrorRequest) {
+    try {
+      const apiGatewayClient = new apiGateway.ParallaxGatewayServiceClientImpl(
+        this.apiGatewayRpc
+      );
+      return await apiGatewayClient.AddSpanError(params);
+    } catch (_error) {
+      debugIssue("addSpanError", new Error('Error adding span error'));
+      throw _error;
+    }
+  }
+
+  /**
+   * Add a hint to a span
+   * @param params Parameters to add a hint to a span
+   */
+  async addSpanHint(params: AddSpanHintRequest) {
+    try {
+      const apiGatewayClient = new apiGateway.ParallaxGatewayServiceClientImpl(
+        this.apiGatewayRpc
+      );
+      return await apiGatewayClient.AddSpanHint(params);
+    } catch (_error) {
+      debugIssue("addSpanHint", new Error('Error adding span hint'));
+      throw _error;
+    }
+  }
+}
+
+export { ParallaxClient };