@forwardimpact/librpc 0.1.106 → 0.1.108

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

@@ -0,0 +1,118 @@
+/* eslint no-unused-vars: "off" */
+
+import { ghuser, common } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Ghuser service implementation
+ */
+export class GhuserBase {
+  config;
+
+  /**
+   * Creates a new Ghuser 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 { ghuser.BeginRequest } req - Request parameters
+   * @returns { Promise<ghuser.BeginResponse> } Response object
+   */
+  async Begin(req) {
+    throw new Error("Begin not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { ghuser.CompleteRequest } req - Request parameters
+   * @returns { Promise<ghuser.CompleteResponse> } Response object
+   */
+  async Complete(req) {
+    throw new Error("Complete not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { ghuser.RedeemRequest } req - Request parameters
+   * @returns { Promise<ghuser.RedeemResponse> } Response object
+   */
+  async Redeem(req) {
+    throw new Error("Redeem not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { ghuser.GetTokenRequest } req - Request parameters
+   * @returns { Promise<ghuser.GetTokenResponse> } Response object
+   */
+  async GetToken(req) {
+    throw new Error("GetToken not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { ghuser.RevokeRequest } req - Request parameters
+   * @returns { Promise<common.Empty> } Response object
+   */
+  async Revoke(req) {
+    throw new Error("Revoke not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      Begin: async (call) => {
+        // Validate and convert request
+        const error = ghuser.BeginRequest.verify(call.request);
+        if (error) throw new Error(`Begin: ${error}`);
+        const req = ghuser.BeginRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.Begin(req);
+      },
+      Complete: async (call) => {
+        // Validate and convert request
+        const error = ghuser.CompleteRequest.verify(call.request);
+        if (error) throw new Error(`Complete: ${error}`);
+        const req = ghuser.CompleteRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.Complete(req);
+      },
+      Redeem: async (call) => {
+        // Validate and convert request
+        const error = ghuser.RedeemRequest.verify(call.request);
+        if (error) throw new Error(`Redeem: ${error}`);
+        const req = ghuser.RedeemRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.Redeem(req);
+      },
+      GetToken: async (call) => {
+        // Validate and convert request
+        const error = ghuser.GetTokenRequest.verify(call.request);
+        if (error) throw new Error(`GetToken: ${error}`);
+        const req = ghuser.GetTokenRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetToken(req);
+      },
+      Revoke: async (call) => {
+        // Validate and convert request
+        const error = ghuser.RevokeRequest.verify(call.request);
+        if (error) throw new Error(`Revoke: ${error}`);
+        const req = ghuser.RevokeRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.Revoke(req);
+      },
+    };
+  }
+}

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

@@ -0,0 +1,84 @@
+/* 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 { graph, tool, common } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Graph gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class GraphClient extends Client {
+  /**
+   * Creates a new Graph 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 `QueryByPattern` RPC with request/response type conversion.
+   * @param { graph.PatternQuery } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async QueryByPattern(req) {
+    // Type validation
+    if (!(req instanceof graph.PatternQuery)) {
+      throw new TypeError(
+        `QueryByPattern: Expected parameter to be instanceof graph.PatternQuery`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = graph.PatternQuery.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("QueryByPattern", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetOntology` RPC with request/response type conversion.
+   * @param { common.Empty } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetOntology(req) {
+    // Type validation
+    if (!(req instanceof common.Empty)) {
+      throw new TypeError(
+        `GetOntology: Expected parameter to be instanceof common.Empty`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = common.Empty.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetOntology", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetSubjects` RPC with request/response type conversion.
+   * @param { graph.SubjectsQuery } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetSubjects(req) {
+    // Type validation
+    if (!(req instanceof graph.SubjectsQuery)) {
+      throw new TypeError(
+        `GetSubjects: Expected parameter to be instanceof graph.SubjectsQuery`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = graph.SubjectsQuery.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetSubjects", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+}

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

@@ -0,0 +1,82 @@
+/* eslint no-unused-vars: "off" */
+
+import { graph, tool, common } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Graph service implementation
+ */
+export class GraphBase {
+  config;
+
+  /**
+   * Creates a new Graph 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 { graph.PatternQuery } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async QueryByPattern(req) {
+    throw new Error("QueryByPattern not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { common.Empty } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetOntology(req) {
+    throw new Error("GetOntology not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { graph.SubjectsQuery } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetSubjects(req) {
+    throw new Error("GetSubjects not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      QueryByPattern: async (call) => {
+        // Validate and convert request
+        const error = graph.PatternQuery.verify(call.request);
+        if (error) throw new Error(`QueryByPattern: ${error}`);
+        const req = graph.PatternQuery.fromObject(call.request);
+        
+        // Call implementation
+        return await this.QueryByPattern(req);
+      },
+      GetOntology: async (call) => {
+        // Validate and convert request
+        const error = common.Empty.verify(call.request);
+        if (error) throw new Error(`GetOntology: ${error}`);
+        const req = common.Empty.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetOntology(req);
+      },
+      GetSubjects: async (call) => {
+        // Validate and convert request
+        const error = graph.SubjectsQuery.verify(call.request);
+        if (error) throw new Error(`GetSubjects: ${error}`);
+        const req = graph.SubjectsQuery.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetSubjects(req);
+      },
+    };
+  }
+}

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

@@ -0,0 +1,104 @@
+/* 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 { map, tool } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Map gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class MapClient extends Client {
+  /**
+   * Creates a new Map 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 `GetUnscoredArtifacts` RPC with request/response type conversion.
+   * @param { map.GetUnscoredArtifactsRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetUnscoredArtifacts(req) {
+    // Type validation
+    if (!(req instanceof map.GetUnscoredArtifactsRequest)) {
+      throw new TypeError(
+        `GetUnscoredArtifacts: Expected parameter to be instanceof map.GetUnscoredArtifactsRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.GetUnscoredArtifactsRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetUnscoredArtifacts", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetArtifact` RPC with request/response type conversion.
+   * @param { map.GetArtifactRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetArtifact(req) {
+    // Type validation
+    if (!(req instanceof map.GetArtifactRequest)) {
+      throw new TypeError(
+        `GetArtifact: Expected parameter to be instanceof map.GetArtifactRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.GetArtifactRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetArtifact", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `WriteEvidence` RPC with request/response type conversion.
+   * @param { map.WriteEvidenceRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async WriteEvidence(req) {
+    // Type validation
+    if (!(req instanceof map.WriteEvidenceRequest)) {
+      throw new TypeError(
+        `WriteEvidence: Expected parameter to be instanceof map.WriteEvidenceRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.WriteEvidenceRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("WriteEvidence", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetPerson` RPC with request/response type conversion.
+   * @param { map.GetPersonRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetPerson(req) {
+    // Type validation
+    if (!(req instanceof map.GetPersonRequest)) {
+      throw new TypeError(
+        `GetPerson: Expected parameter to be instanceof map.GetPersonRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.GetPersonRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetPerson", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+}

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

@@ -0,0 +1,100 @@
+/* eslint no-unused-vars: "off" */
+
+import { map, tool } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Map service implementation
+ */
+export class MapBase {
+  config;
+
+  /**
+   * Creates a new Map 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 { map.GetUnscoredArtifactsRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetUnscoredArtifacts(req) {
+    throw new Error("GetUnscoredArtifacts not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { map.GetArtifactRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetArtifact(req) {
+    throw new Error("GetArtifact not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { map.WriteEvidenceRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async WriteEvidence(req) {
+    throw new Error("WriteEvidence not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { map.GetPersonRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetPerson(req) {
+    throw new Error("GetPerson not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      GetUnscoredArtifacts: async (call) => {
+        // Validate and convert request
+        const error = map.GetUnscoredArtifactsRequest.verify(call.request);
+        if (error) throw new Error(`GetUnscoredArtifacts: ${error}`);
+        const req = map.GetUnscoredArtifactsRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetUnscoredArtifacts(req);
+      },
+      GetArtifact: async (call) => {
+        // Validate and convert request
+        const error = map.GetArtifactRequest.verify(call.request);
+        if (error) throw new Error(`GetArtifact: ${error}`);
+        const req = map.GetArtifactRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetArtifact(req);
+      },
+      WriteEvidence: async (call) => {
+        // Validate and convert request
+        const error = map.WriteEvidenceRequest.verify(call.request);
+        if (error) throw new Error(`WriteEvidence: ${error}`);
+        const req = map.WriteEvidenceRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.WriteEvidence(req);
+      },
+      GetPerson: async (call) => {
+        // Validate and convert request
+        const error = map.GetPersonRequest.verify(call.request);
+        if (error) throw new Error(`GetPerson: ${error}`);
+        const req = map.GetPersonRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetPerson(req);
+      },
+    };
+  }
+}

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

@@ -0,0 +1,164 @@
+/* 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 { pathway, tool } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Pathway gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class PathwayClient extends Client {
+  /**
+   * Creates a new Pathway 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 `ListJobs` RPC with request/response type conversion.
+   * @param { pathway.ListJobsRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async ListJobs(req) {
+    // Type validation
+    if (!(req instanceof pathway.ListJobsRequest)) {
+      throw new TypeError(
+        `ListJobs: Expected parameter to be instanceof pathway.ListJobsRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.ListJobsRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ListJobs", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `DescribeJob` RPC with request/response type conversion.
+   * @param { pathway.DescribeJobRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async DescribeJob(req) {
+    // Type validation
+    if (!(req instanceof pathway.DescribeJobRequest)) {
+      throw new TypeError(
+        `DescribeJob: Expected parameter to be instanceof pathway.DescribeJobRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.DescribeJobRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("DescribeJob", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `ListAgentProfiles` RPC with request/response type conversion.
+   * @param { pathway.ListAgentProfilesRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async ListAgentProfiles(req) {
+    // Type validation
+    if (!(req instanceof pathway.ListAgentProfilesRequest)) {
+      throw new TypeError(
+        `ListAgentProfiles: Expected parameter to be instanceof pathway.ListAgentProfilesRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.ListAgentProfilesRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ListAgentProfiles", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `DescribeAgentProfile` RPC with request/response type conversion.
+   * @param { pathway.DescribeAgentProfileRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async DescribeAgentProfile(req) {
+    // Type validation
+    if (!(req instanceof pathway.DescribeAgentProfileRequest)) {
+      throw new TypeError(
+        `DescribeAgentProfile: Expected parameter to be instanceof pathway.DescribeAgentProfileRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.DescribeAgentProfileRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("DescribeAgentProfile", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `DescribeProgression` RPC with request/response type conversion.
+   * @param { pathway.DescribeProgressionRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async DescribeProgression(req) {
+    // Type validation
+    if (!(req instanceof pathway.DescribeProgressionRequest)) {
+      throw new TypeError(
+        `DescribeProgression: Expected parameter to be instanceof pathway.DescribeProgressionRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.DescribeProgressionRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("DescribeProgression", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `ListJobSoftware` RPC with request/response type conversion.
+   * @param { pathway.ListJobSoftwareRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async ListJobSoftware(req) {
+    // Type validation
+    if (!(req instanceof pathway.ListJobSoftwareRequest)) {
+      throw new TypeError(
+        `ListJobSoftware: Expected parameter to be instanceof pathway.ListJobSoftwareRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.ListJobSoftwareRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ListJobSoftware", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetMarkersForProfile` RPC with request/response type conversion.
+   * @param { pathway.GetMarkersForProfileRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetMarkersForProfile(req) {
+    // Type validation
+    if (!(req instanceof pathway.GetMarkersForProfileRequest)) {
+      throw new TypeError(
+        `GetMarkersForProfile: Expected parameter to be instanceof pathway.GetMarkersForProfileRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.GetMarkersForProfileRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetMarkersForProfile", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+}