@forwardimpact/librpc 0.1.106 → 0.1.108

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/librpc",
-  "version": "0.1.106",
+  "version": "0.1.108",
   "description": "gRPC server and client framework — ship service endpoints without reimplementing transport.",
   "keywords": [
     "grpc",
@@ -31,6 +31,7 @@
   "main": "./src/index.js",
   "exports": {
     ".": "./src/index.js",
+    "./bin/fit-unary.js": "./bin/fit-unary.js",
     "./client.js": "./src/client.js",
     "./base.js": "./src/base.js",
     "./package.json": "./package.json"
@@ -44,6 +45,8 @@
     "README.md"
   ],
   "scripts": {
+    "prepack": "node -e \"const fs=require('node:fs');fs.rmSync('src/generated',{recursive:true,force:true});fs.cpSync('../../generated','src/generated',{recursive:true})\"",
+    "postpack": "node -e \"const fs=require('node:fs');fs.rmSync('src/generated',{recursive:true,force:true});fs.symlinkSync('../../../generated','src/generated','dir')\"",
     "test": "bun test test/*.test.js"
   },
   "dependencies": {

package/src/generated/definitions/bridge.js

@@ -0,0 +1,260 @@
+import { bridge, common } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Bridge
+ * Generated at build time
+ */
+export const BridgeServiceDefinition = {
+  LoadDiscussion: {
+    path: '/bridge.Bridge/LoadDiscussion',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.LoadDiscussionRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.LoadDiscussionRequest.toObject(
+        bridge.LoadDiscussionRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.Discussion.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.Discussion.toObject(
+        bridge.Discussion.decode(value)
+      );
+    },
+  },
+  LoadDiscussionByCorrelation: {
+    path: '/bridge.Bridge/LoadDiscussionByCorrelation',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.LoadByCorrelationRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.LoadByCorrelationRequest.toObject(
+        bridge.LoadByCorrelationRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.Discussion.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.Discussion.toObject(
+        bridge.Discussion.decode(value)
+      );
+    },
+  },
+  ListOpenRecesses: {
+    path: '/bridge.Bridge/ListOpenRecesses',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.ListOpenRecessesRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.ListOpenRecessesRequest.toObject(
+        bridge.ListOpenRecessesRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.OpenRecessList.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.OpenRecessList.toObject(
+        bridge.OpenRecessList.decode(value)
+      );
+    },
+  },
+  SaveDiscussion: {
+    path: '/bridge.Bridge/SaveDiscussion',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.Discussion.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.Discussion.toObject(
+        bridge.Discussion.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  HasOrigin: {
+    path: '/bridge.Bridge/HasOrigin',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.OriginKey.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.OriginKey.toObject(
+        bridge.OriginKey.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.HasOriginResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.HasOriginResponse.toObject(
+        bridge.HasOriginResponse.decode(value)
+      );
+    },
+  },
+  RecordOrigin: {
+    path: '/bridge.Bridge/RecordOrigin',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.Origin.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.Origin.toObject(
+        bridge.Origin.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  Sweep: {
+    path: '/bridge.Bridge/Sweep',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.SweepRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.SweepRequest.toObject(
+        bridge.SweepRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.SweepResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.SweepResponse.toObject(
+        bridge.SweepResponse.decode(value)
+      );
+    },
+  },
+  PutPendingDispatch: {
+    path: '/bridge.Bridge/PutPendingDispatch',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.PutPendingDispatchRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.PutPendingDispatchRequest.toObject(
+        bridge.PutPendingDispatchRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  ResolvePendingDispatch: {
+    path: '/bridge.Bridge/ResolvePendingDispatch',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.ResolvePendingDispatchRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.ResolvePendingDispatchRequest.toObject(
+        bridge.ResolvePendingDispatchRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.PendingDispatch.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.PendingDispatch.toObject(
+        bridge.PendingDispatch.decode(value)
+      );
+    },
+  },
+  VerifyPendingDispatch: {
+    path: '/bridge.Bridge/VerifyPendingDispatch',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.VerifyPendingDispatchRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.VerifyPendingDispatchRequest.toObject(
+        bridge.VerifyPendingDispatchRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  EnqueueInbox: {
+    path: '/bridge.Bridge/EnqueueInbox',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.EnqueueInboxRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.EnqueueInboxRequest.toObject(
+        bridge.EnqueueInboxRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  DrainInbox: {
+    path: '/bridge.Bridge/DrainInbox',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.DrainInboxRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.DrainInboxRequest.toObject(
+        bridge.DrainInboxRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.InboxMessages.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.InboxMessages.toObject(
+        bridge.InboxMessages.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/embedding.js

@@ -0,0 +1,29 @@
+import { embedding } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Embedding
+ * Generated at build time
+ */
+export const EmbeddingServiceDefinition = {
+  CreateEmbeddings: {
+    path: '/embedding.Embedding/CreateEmbeddings',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(embedding.EmbeddingsRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return embedding.EmbeddingsRequest.toObject(
+        embedding.EmbeddingsRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(embedding.EmbeddingsResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return embedding.EmbeddingsResponse.toObject(
+        embedding.EmbeddingsResponse.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/exports.js

@@ -0,0 +1,43 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Generated by scripts/codegen.js
+
+// Service Definitions
+export { BridgeServiceDefinition } from "./bridge.js";
+export { EmbeddingServiceDefinition } from "./embedding.js";
+export { GhserverServiceDefinition } from "./ghserver.js";
+export { GhuserServiceDefinition } from "./ghuser.js";
+export { GraphServiceDefinition } from "./graph.js";
+export { MapServiceDefinition } from "./map.js";
+export { PathwayServiceDefinition } from "./pathway.js";
+export { TenancyServiceDefinition } from "./tenancy.js";
+export { TraceServiceDefinition } from "./trace.js";
+export { VectorServiceDefinition } from "./vector.js";
+
+// Import service definitions to make them available for aggregation
+import { BridgeServiceDefinition } from "./bridge.js";
+import { EmbeddingServiceDefinition } from "./embedding.js";
+import { GhserverServiceDefinition } from "./ghserver.js";
+import { GhuserServiceDefinition } from "./ghuser.js";
+import { GraphServiceDefinition } from "./graph.js";
+import { MapServiceDefinition } from "./map.js";
+import { PathwayServiceDefinition } from "./pathway.js";
+import { TenancyServiceDefinition } from "./tenancy.js";
+import { TraceServiceDefinition } from "./trace.js";
+import { VectorServiceDefinition } from "./vector.js";
+
+// Aggregate exports for convenience
+export const definitions = {
+  bridge: BridgeServiceDefinition,
+  embedding: EmbeddingServiceDefinition,
+  ghserver: GhserverServiceDefinition,
+  ghuser: GhuserServiceDefinition,
+  graph: GraphServiceDefinition,
+  map: MapServiceDefinition,
+  pathway: PathwayServiceDefinition,
+  tenancy: TenancyServiceDefinition,
+  trace: TraceServiceDefinition,
+  vector: VectorServiceDefinition,
+};
+
+// Re-export as default for dynamic importing
+export default definitions;

package/src/generated/definitions/ghserver.js

@@ -0,0 +1,29 @@
+import { ghserver } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Ghserver
+ * Generated at build time
+ */
+export const GhserverServiceDefinition = {
+  MintInstallationToken: {
+    path: '/ghserver.Ghserver/MintInstallationToken',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghserver.MintRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghserver.MintRequest.toObject(
+        ghserver.MintRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghserver.MintResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghserver.MintResponse.toObject(
+        ghserver.MintResponse.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/ghuser.js

@@ -0,0 +1,113 @@
+import { ghuser, common } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Ghuser
+ * Generated at build time
+ */
+export const GhuserServiceDefinition = {
+  Begin: {
+    path: '/ghuser.Ghuser/Begin',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.BeginRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.BeginRequest.toObject(
+        ghuser.BeginRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.BeginResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.BeginResponse.toObject(
+        ghuser.BeginResponse.decode(value)
+      );
+    },
+  },
+  Complete: {
+    path: '/ghuser.Ghuser/Complete',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.CompleteRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.CompleteRequest.toObject(
+        ghuser.CompleteRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.CompleteResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.CompleteResponse.toObject(
+        ghuser.CompleteResponse.decode(value)
+      );
+    },
+  },
+  Redeem: {
+    path: '/ghuser.Ghuser/Redeem',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.RedeemRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.RedeemRequest.toObject(
+        ghuser.RedeemRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.RedeemResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.RedeemResponse.toObject(
+        ghuser.RedeemResponse.decode(value)
+      );
+    },
+  },
+  GetToken: {
+    path: '/ghuser.Ghuser/GetToken',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.GetTokenRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.GetTokenRequest.toObject(
+        ghuser.GetTokenRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.GetTokenResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.GetTokenResponse.toObject(
+        ghuser.GetTokenResponse.decode(value)
+      );
+    },
+  },
+  Revoke: {
+    path: '/ghuser.Ghuser/Revoke',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.RevokeRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.RevokeRequest.toObject(
+        ghuser.RevokeRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/graph.js

@@ -0,0 +1,71 @@
+import { graph, tool, common } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Graph
+ * Generated at build time
+ */
+export const GraphServiceDefinition = {
+  QueryByPattern: {
+    path: '/graph.Graph/QueryByPattern',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(graph.PatternQuery.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return graph.PatternQuery.toObject(
+        graph.PatternQuery.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  GetOntology: {
+    path: '/graph.Graph/GetOntology',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  GetSubjects: {
+    path: '/graph.Graph/GetSubjects',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(graph.SubjectsQuery.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return graph.SubjectsQuery.toObject(
+        graph.SubjectsQuery.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/map.js

@@ -0,0 +1,92 @@
+import { map, tool } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Map
+ * Generated at build time
+ */
+export const MapServiceDefinition = {
+  GetUnscoredArtifacts: {
+    path: '/map.Map/GetUnscoredArtifacts',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(map.GetUnscoredArtifactsRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return map.GetUnscoredArtifactsRequest.toObject(
+        map.GetUnscoredArtifactsRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  GetArtifact: {
+    path: '/map.Map/GetArtifact',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(map.GetArtifactRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return map.GetArtifactRequest.toObject(
+        map.GetArtifactRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  WriteEvidence: {
+    path: '/map.Map/WriteEvidence',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(map.WriteEvidenceRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return map.WriteEvidenceRequest.toObject(
+        map.WriteEvidenceRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  GetPerson: {
+    path: '/map.Map/GetPerson',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(map.GetPersonRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return map.GetPersonRequest.toObject(
+        map.GetPersonRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+};