@forwardimpact/librpc 0.1.105 → 0.1.107

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

@@ -0,0 +1,154 @@
+/* eslint no-unused-vars: "off" */
+
+import { tenancy } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Tenancy service implementation
+ */
+export class TenancyBase {
+  config;
+
+  /**
+   * Creates a new Tenancy 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 { tenancy.ChannelTenantKey } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async ResolveByChannelKey(req) {
+    throw new Error("ResolveByChannelKey not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.RepoKey } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async ResolveByRepo(req) {
+    throw new Error("ResolveByRepo not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.TenantIdKey } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async ResolveByTenantId(req) {
+    throw new Error("ResolveByTenantId not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.UpsertChannelKeyRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async UpsertByChannelKey(req) {
+    throw new Error("UpsertByChannelKey not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.UpsertPairRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async UpsertByPair(req) {
+    throw new Error("UpsertByPair not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.SetStateRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async SetState(req) {
+    throw new Error("SetState not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.SetRepoRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async SetRepo(req) {
+    throw new Error("SetRepo not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      ResolveByChannelKey: async (call) => {
+        // Validate and convert request
+        const error = tenancy.ChannelTenantKey.verify(call.request);
+        if (error) throw new Error(`ResolveByChannelKey: ${error}`);
+        const req = tenancy.ChannelTenantKey.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ResolveByChannelKey(req);
+      },
+      ResolveByRepo: async (call) => {
+        // Validate and convert request
+        const error = tenancy.RepoKey.verify(call.request);
+        if (error) throw new Error(`ResolveByRepo: ${error}`);
+        const req = tenancy.RepoKey.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ResolveByRepo(req);
+      },
+      ResolveByTenantId: async (call) => {
+        // Validate and convert request
+        const error = tenancy.TenantIdKey.verify(call.request);
+        if (error) throw new Error(`ResolveByTenantId: ${error}`);
+        const req = tenancy.TenantIdKey.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ResolveByTenantId(req);
+      },
+      UpsertByChannelKey: async (call) => {
+        // Validate and convert request
+        const error = tenancy.UpsertChannelKeyRequest.verify(call.request);
+        if (error) throw new Error(`UpsertByChannelKey: ${error}`);
+        const req = tenancy.UpsertChannelKeyRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.UpsertByChannelKey(req);
+      },
+      UpsertByPair: async (call) => {
+        // Validate and convert request
+        const error = tenancy.UpsertPairRequest.verify(call.request);
+        if (error) throw new Error(`UpsertByPair: ${error}`);
+        const req = tenancy.UpsertPairRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.UpsertByPair(req);
+      },
+      SetState: async (call) => {
+        // Validate and convert request
+        const error = tenancy.SetStateRequest.verify(call.request);
+        if (error) throw new Error(`SetState: ${error}`);
+        const req = tenancy.SetStateRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.SetState(req);
+      },
+      SetRepo: async (call) => {
+        // Validate and convert request
+        const error = tenancy.SetRepoRequest.verify(call.request);
+        if (error) throw new Error(`SetRepo: ${error}`);
+        const req = tenancy.SetRepoRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.SetRepo(req);
+      },
+    };
+  }
+}

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

@@ -0,0 +1,64 @@
+/* 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 { trace } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Trace gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class TraceClient extends Client {
+  /**
+   * Creates a new Trace 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 `RecordSpan` RPC with request/response type conversion.
+   * @param { trace.Span } req - Typed request message.
+   * @returns { Promise<trace.RecordResponse> } Typed response message.
+   */
+  async RecordSpan(req) {
+    // Type validation
+    if (!(req instanceof trace.Span)) {
+      throw new TypeError(
+        `RecordSpan: Expected parameter to be instanceof trace.Span`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = trace.Span.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("RecordSpan", request, (res) => trace.RecordResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `QuerySpans` RPC with request/response type conversion.
+   * @param { trace.QueryRequest } req - Typed request message.
+   * @returns { Promise<trace.QueryResponse> } Typed response message.
+   */
+  async QuerySpans(req) {
+    // Type validation
+    if (!(req instanceof trace.QueryRequest)) {
+      throw new TypeError(
+        `QuerySpans: Expected parameter to be instanceof trace.QueryRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = trace.QueryRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("QuerySpans", request, (res) => trace.QueryResponse.fromObject(res));
+  }
+}

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

@@ -0,0 +1,64 @@
+/* eslint no-unused-vars: "off" */
+
+import { trace } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Trace service implementation
+ */
+export class TraceBase {
+  config;
+
+  /**
+   * Creates a new Trace 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 { trace.Span } req - Request parameters
+   * @returns { Promise<trace.RecordResponse> } Response object
+   */
+  async RecordSpan(req) {
+    throw new Error("RecordSpan not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { trace.QueryRequest } req - Request parameters
+   * @returns { Promise<trace.QueryResponse> } Response object
+   */
+  async QuerySpans(req) {
+    throw new Error("QuerySpans not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      RecordSpan: async (call) => {
+        // Validate and convert request
+        const error = trace.Span.verify(call.request);
+        if (error) throw new Error(`RecordSpan: ${error}`);
+        const req = trace.Span.fromObject(call.request);
+        
+        // Call implementation
+        return await this.RecordSpan(req);
+      },
+      QuerySpans: async (call) => {
+        // Validate and convert request
+        const error = trace.QueryRequest.verify(call.request);
+        if (error) throw new Error(`QuerySpans: ${error}`);
+        const req = trace.QueryRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.QuerySpans(req);
+      },
+    };
+  }
+}

package/src/generated/services/vector/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 { vector, tool } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Vector gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class VectorClient extends Client {
+  /**
+   * Creates a new Vector 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 `SearchContent` RPC with request/response type conversion.
+   * @param { vector.TextQuery } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async SearchContent(req) {
+    // Type validation
+    if (!(req instanceof vector.TextQuery)) {
+      throw new TypeError(
+        `SearchContent: Expected parameter to be instanceof vector.TextQuery`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = vector.TextQuery.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("SearchContent", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+}

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

@@ -0,0 +1,46 @@
+/* eslint no-unused-vars: "off" */
+
+import { vector, tool } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Vector service implementation
+ */
+export class VectorBase {
+  config;
+
+  /**
+   * Creates a new Vector 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 { vector.TextQuery } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async SearchContent(req) {
+    throw new Error("SearchContent not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      SearchContent: async (call) => {
+        // Validate and convert request
+        const error = vector.TextQuery.verify(call.request);
+        if (error) throw new Error(`SearchContent: ${error}`);
+        const req = vector.TextQuery.fromObject(call.request);
+        
+        // Call implementation
+        return await this.SearchContent(req);
+      },
+    };
+  }
+}