@forwardimpact/librpc 0.1.106 → 0.1.107

package/src/generated/services/bridge/service.js

@@ -0,0 +1,244 @@
+/* eslint no-unused-vars: "off" */
+
+import { bridge, common } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Bridge service implementation
+ */
+export class BridgeBase {
+  config;
+
+  /**
+   * Creates a new Bridge service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.LoadDiscussionRequest } req - Request parameters
+   * @returns { Promise<bridge.Discussion> } Response object
+   */
+  async LoadDiscussion(req) {
+    throw new Error("LoadDiscussion not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.LoadByCorrelationRequest } req - Request parameters
+   * @returns { Promise<bridge.Discussion> } Response object
+   */
+  async LoadDiscussionByCorrelation(req) {
+    throw new Error("LoadDiscussionByCorrelation not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.ListOpenRecessesRequest } req - Request parameters
+   * @returns { Promise<bridge.OpenRecessList> } Response object
+   */
+  async ListOpenRecesses(req) {
+    throw new Error("ListOpenRecesses not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.Discussion } req - Request parameters
+   * @returns { Promise<common.Empty> } Response object
+   */
+  async SaveDiscussion(req) {
+    throw new Error("SaveDiscussion not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.OriginKey } req - Request parameters
+   * @returns { Promise<bridge.HasOriginResponse> } Response object
+   */
+  async HasOrigin(req) {
+    throw new Error("HasOrigin not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.Origin } req - Request parameters
+   * @returns { Promise<common.Empty> } Response object
+   */
+  async RecordOrigin(req) {
+    throw new Error("RecordOrigin not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.SweepRequest } req - Request parameters
+   * @returns { Promise<bridge.SweepResponse> } Response object
+   */
+  async Sweep(req) {
+    throw new Error("Sweep not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.PutPendingDispatchRequest } req - Request parameters
+   * @returns { Promise<common.Empty> } Response object
+   */
+  async PutPendingDispatch(req) {
+    throw new Error("PutPendingDispatch not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.ResolvePendingDispatchRequest } req - Request parameters
+   * @returns { Promise<bridge.PendingDispatch> } Response object
+   */
+  async ResolvePendingDispatch(req) {
+    throw new Error("ResolvePendingDispatch not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.VerifyPendingDispatchRequest } req - Request parameters
+   * @returns { Promise<common.Empty> } Response object
+   */
+  async VerifyPendingDispatch(req) {
+    throw new Error("VerifyPendingDispatch not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.EnqueueInboxRequest } req - Request parameters
+   * @returns { Promise<common.Empty> } Response object
+   */
+  async EnqueueInbox(req) {
+    throw new Error("EnqueueInbox not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { bridge.DrainInboxRequest } req - Request parameters
+   * @returns { Promise<bridge.InboxMessages> } Response object
+   */
+  async DrainInbox(req) {
+    throw new Error("DrainInbox not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      LoadDiscussion: async (call) => {
+        // Validate and convert request
+        const error = bridge.LoadDiscussionRequest.verify(call.request);
+        if (error) throw new Error(`LoadDiscussion: ${error}`);
+        const req = bridge.LoadDiscussionRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.LoadDiscussion(req);
+      },
+      LoadDiscussionByCorrelation: async (call) => {
+        // Validate and convert request
+        const error = bridge.LoadByCorrelationRequest.verify(call.request);
+        if (error) throw new Error(`LoadDiscussionByCorrelation: ${error}`);
+        const req = bridge.LoadByCorrelationRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.LoadDiscussionByCorrelation(req);
+      },
+      ListOpenRecesses: async (call) => {
+        // Validate and convert request
+        const error = bridge.ListOpenRecessesRequest.verify(call.request);
+        if (error) throw new Error(`ListOpenRecesses: ${error}`);
+        const req = bridge.ListOpenRecessesRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ListOpenRecesses(req);
+      },
+      SaveDiscussion: async (call) => {
+        // Validate and convert request
+        const error = bridge.Discussion.verify(call.request);
+        if (error) throw new Error(`SaveDiscussion: ${error}`);
+        const req = bridge.Discussion.fromObject(call.request);
+        
+        // Call implementation
+        return await this.SaveDiscussion(req);
+      },
+      HasOrigin: async (call) => {
+        // Validate and convert request
+        const error = bridge.OriginKey.verify(call.request);
+        if (error) throw new Error(`HasOrigin: ${error}`);
+        const req = bridge.OriginKey.fromObject(call.request);
+        
+        // Call implementation
+        return await this.HasOrigin(req);
+      },
+      RecordOrigin: async (call) => {
+        // Validate and convert request
+        const error = bridge.Origin.verify(call.request);
+        if (error) throw new Error(`RecordOrigin: ${error}`);
+        const req = bridge.Origin.fromObject(call.request);
+        
+        // Call implementation
+        return await this.RecordOrigin(req);
+      },
+      Sweep: async (call) => {
+        // Validate and convert request
+        const error = bridge.SweepRequest.verify(call.request);
+        if (error) throw new Error(`Sweep: ${error}`);
+        const req = bridge.SweepRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.Sweep(req);
+      },
+      PutPendingDispatch: async (call) => {
+        // Validate and convert request
+        const error = bridge.PutPendingDispatchRequest.verify(call.request);
+        if (error) throw new Error(`PutPendingDispatch: ${error}`);
+        const req = bridge.PutPendingDispatchRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.PutPendingDispatch(req);
+      },
+      ResolvePendingDispatch: async (call) => {
+        // Validate and convert request
+        const error = bridge.ResolvePendingDispatchRequest.verify(call.request);
+        if (error) throw new Error(`ResolvePendingDispatch: ${error}`);
+        const req = bridge.ResolvePendingDispatchRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ResolvePendingDispatch(req);
+      },
+      VerifyPendingDispatch: async (call) => {
+        // Validate and convert request
+        const error = bridge.VerifyPendingDispatchRequest.verify(call.request);
+        if (error) throw new Error(`VerifyPendingDispatch: ${error}`);
+        const req = bridge.VerifyPendingDispatchRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.VerifyPendingDispatch(req);
+      },
+      EnqueueInbox: async (call) => {
+        // Validate and convert request
+        const error = bridge.EnqueueInboxRequest.verify(call.request);
+        if (error) throw new Error(`EnqueueInbox: ${error}`);
+        const req = bridge.EnqueueInboxRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.EnqueueInbox(req);
+      },
+      DrainInbox: async (call) => {
+        // Validate and convert request
+        const error = bridge.DrainInboxRequest.verify(call.request);
+        if (error) throw new Error(`DrainInbox: ${error}`);
+        const req = bridge.DrainInboxRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.DrainInbox(req);
+      },
+    };
+  }
+}

package/src/generated/services/embedding/client.js

@@ -0,0 +1,44 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { embedding } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Embedding gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class EmbeddingClient extends Client {
+  /**
+   * Creates a new Embedding client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `CreateEmbeddings` RPC with request/response type conversion.
+   * @param { embedding.EmbeddingsRequest } req - Typed request message.
+   * @returns { Promise<embedding.EmbeddingsResponse> } Typed response message.
+   */
+  async CreateEmbeddings(req) {
+    // Type validation
+    if (!(req instanceof embedding.EmbeddingsRequest)) {
+      throw new TypeError(
+        `CreateEmbeddings: Expected parameter to be instanceof embedding.EmbeddingsRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = embedding.EmbeddingsRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("CreateEmbeddings", request, (res) => embedding.EmbeddingsResponse.fromObject(res));
+  }
+}

package/src/generated/services/embedding/service.js

@@ -0,0 +1,46 @@
+/* eslint no-unused-vars: "off" */
+
+import { embedding } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Embedding service implementation
+ */
+export class EmbeddingBase {
+  config;
+
+  /**
+   * Creates a new Embedding service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { embedding.EmbeddingsRequest } req - Request parameters
+   * @returns { Promise<embedding.EmbeddingsResponse> } Response object
+   */
+  async CreateEmbeddings(req) {
+    throw new Error("CreateEmbeddings not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      CreateEmbeddings: async (call) => {
+        // Validate and convert request
+        const error = embedding.EmbeddingsRequest.verify(call.request);
+        if (error) throw new Error(`CreateEmbeddings: ${error}`);
+        const req = embedding.EmbeddingsRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.CreateEmbeddings(req);
+      },
+    };
+  }
+}

package/src/generated/services/exports.js

@@ -0,0 +1,103 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Generated by scripts/codegen.js
+
+// Service Base Classes
+export { BridgeBase } from "./bridge/service.js";
+export { EmbeddingBase } from "./embedding/service.js";
+export { GhserverBase } from "./ghserver/service.js";
+export { GhuserBase } from "./ghuser/service.js";
+export { GraphBase } from "./graph/service.js";
+export { MapBase } from "./map/service.js";
+export { PathwayBase } from "./pathway/service.js";
+export { TenancyBase } from "./tenancy/service.js";
+export { TraceBase } from "./trace/service.js";
+export { VectorBase } from "./vector/service.js";
+
+// Client Classes
+export { BridgeClient } from "./bridge/client.js";
+export { EmbeddingClient } from "./embedding/client.js";
+export { GhserverClient } from "./ghserver/client.js";
+export { GhuserClient } from "./ghuser/client.js";
+export { GraphClient } from "./graph/client.js";
+export { MapClient } from "./map/client.js";
+export { PathwayClient } from "./pathway/client.js";
+export { TenancyClient } from "./tenancy/client.js";
+export { TraceClient } from "./trace/client.js";
+export { VectorClient } from "./vector/client.js";
+
+// Import service base classes to make them available for aggregation
+import { BridgeBase } from "./bridge/service.js";
+import { EmbeddingBase } from "./embedding/service.js";
+import { GhserverBase } from "./ghserver/service.js";
+import { GhuserBase } from "./ghuser/service.js";
+import { GraphBase } from "./graph/service.js";
+import { MapBase } from "./map/service.js";
+import { PathwayBase } from "./pathway/service.js";
+import { TenancyBase } from "./tenancy/service.js";
+import { TraceBase } from "./trace/service.js";
+import { VectorBase } from "./vector/service.js";
+
+// Import client classes to make them available for aggregation
+import { BridgeClient } from "./bridge/client.js";
+import { EmbeddingClient } from "./embedding/client.js";
+import { GhserverClient } from "./ghserver/client.js";
+import { GhuserClient } from "./ghuser/client.js";
+import { GraphClient } from "./graph/client.js";
+import { MapClient } from "./map/client.js";
+import { PathwayClient } from "./pathway/client.js";
+import { TenancyClient } from "./tenancy/client.js";
+import { TraceClient } from "./trace/client.js";
+import { VectorClient } from "./vector/client.js";
+
+// Aggregate exports for convenience
+export const services = {
+  BridgeBase,
+  EmbeddingBase,
+  GhserverBase,
+  GhuserBase,
+  GraphBase,
+  MapBase,
+  PathwayBase,
+  TenancyBase,
+  TraceBase,
+  VectorBase,
+};
+
+export const clients = {
+  BridgeClient,
+  EmbeddingClient,
+  GhserverClient,
+  GhuserClient,
+  GraphClient,
+  MapClient,
+  PathwayClient,
+  TenancyClient,
+  TraceClient,
+  VectorClient,
+};
+
+// Re-export everything as default for dynamic importing
+export default {
+  services,
+  clients,
+  BridgeBase,
+  EmbeddingBase,
+  GhserverBase,
+  GhuserBase,
+  GraphBase,
+  MapBase,
+  PathwayBase,
+  TenancyBase,
+  TraceBase,
+  VectorBase,
+  BridgeClient,
+  EmbeddingClient,
+  GhserverClient,
+  GhuserClient,
+  GraphClient,
+  MapClient,
+  PathwayClient,
+  TenancyClient,
+  TraceClient,
+  VectorClient,
+};

package/src/generated/services/ghserver/client.js

@@ -0,0 +1,44 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { ghserver } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Ghserver gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class GhserverClient extends Client {
+  /**
+   * Creates a new Ghserver client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `MintInstallationToken` RPC with request/response type conversion.
+   * @param { ghserver.MintRequest } req - Typed request message.
+   * @returns { Promise<ghserver.MintResponse> } Typed response message.
+   */
+  async MintInstallationToken(req) {
+    // Type validation
+    if (!(req instanceof ghserver.MintRequest)) {
+      throw new TypeError(
+        `MintInstallationToken: Expected parameter to be instanceof ghserver.MintRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = ghserver.MintRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("MintInstallationToken", request, (res) => ghserver.MintResponse.fromObject(res));
+  }
+}

package/src/generated/services/ghserver/service.js

@@ -0,0 +1,46 @@
+/* eslint no-unused-vars: "off" */
+
+import { ghserver } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Ghserver service implementation
+ */
+export class GhserverBase {
+  config;
+
+  /**
+   * Creates a new Ghserver service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { ghserver.MintRequest } req - Request parameters
+   * @returns { Promise<ghserver.MintResponse> } Response object
+   */
+  async MintInstallationToken(req) {
+    throw new Error("MintInstallationToken not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      MintInstallationToken: async (call) => {
+        // Validate and convert request
+        const error = ghserver.MintRequest.verify(call.request);
+        if (error) throw new Error(`MintInstallationToken: ${error}`);
+        const req = ghserver.MintRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.MintInstallationToken(req);
+      },
+    };
+  }
+}

package/src/generated/services/ghuser/client.js

@@ -0,0 +1,124 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { ghuser, common } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Ghuser gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class GhuserClient extends Client {
+  /**
+   * Creates a new Ghuser client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `Begin` RPC with request/response type conversion.
+   * @param { ghuser.BeginRequest } req - Typed request message.
+   * @returns { Promise<ghuser.BeginResponse> } Typed response message.
+   */
+  async Begin(req) {
+    // Type validation
+    if (!(req instanceof ghuser.BeginRequest)) {
+      throw new TypeError(
+        `Begin: Expected parameter to be instanceof ghuser.BeginRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = ghuser.BeginRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("Begin", request, (res) => ghuser.BeginResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `Complete` RPC with request/response type conversion.
+   * @param { ghuser.CompleteRequest } req - Typed request message.
+   * @returns { Promise<ghuser.CompleteResponse> } Typed response message.
+   */
+  async Complete(req) {
+    // Type validation
+    if (!(req instanceof ghuser.CompleteRequest)) {
+      throw new TypeError(
+        `Complete: Expected parameter to be instanceof ghuser.CompleteRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = ghuser.CompleteRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("Complete", request, (res) => ghuser.CompleteResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `Redeem` RPC with request/response type conversion.
+   * @param { ghuser.RedeemRequest } req - Typed request message.
+   * @returns { Promise<ghuser.RedeemResponse> } Typed response message.
+   */
+  async Redeem(req) {
+    // Type validation
+    if (!(req instanceof ghuser.RedeemRequest)) {
+      throw new TypeError(
+        `Redeem: Expected parameter to be instanceof ghuser.RedeemRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = ghuser.RedeemRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("Redeem", request, (res) => ghuser.RedeemResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `GetToken` RPC with request/response type conversion.
+   * @param { ghuser.GetTokenRequest } req - Typed request message.
+   * @returns { Promise<ghuser.GetTokenResponse> } Typed response message.
+   */
+  async GetToken(req) {
+    // Type validation
+    if (!(req instanceof ghuser.GetTokenRequest)) {
+      throw new TypeError(
+        `GetToken: Expected parameter to be instanceof ghuser.GetTokenRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = ghuser.GetTokenRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetToken", request, (res) => ghuser.GetTokenResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `Revoke` RPC with request/response type conversion.
+   * @param { ghuser.RevokeRequest } req - Typed request message.
+   * @returns { Promise<common.Empty> } Typed response message.
+   */
+  async Revoke(req) {
+    // Type validation
+    if (!(req instanceof ghuser.RevokeRequest)) {
+      throw new TypeError(
+        `Revoke: Expected parameter to be instanceof ghuser.RevokeRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = ghuser.RevokeRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("Revoke", request, (res) => common.Empty.fromObject(res));
+  }
+}