@sequenceholdings/managed-functions 0.4.5 → 0.5.1

package/dist/platform-client.d.ts

@@ -0,0 +1,27 @@
+import { type FunctionPlatformDomains } from "./platform-domains";
+import { type FunctionServiceDirectoryClient } from "./service-directory";
+import { type FunctionServiceProcessesClient } from "./processes";
+import { type FunctionLatticeClient } from "./lattice-provenance";
+import { type FunctionInvocationClient } from "./invocation";
+import type { FunctionInvocationClientOptions } from "./invocation-client";
+export type FunctionPlatformClientOptions = FunctionInvocationClientOptions;
+export interface FunctionPlatformClient extends Omit<FunctionPlatformDomains, "callerDirectory"> {
+    directory: FunctionServiceDirectoryClient & {
+        caller: FunctionPlatformDomains["callerDirectory"];
+    };
+    lattice: {
+        runs: {
+            get: FunctionServiceProcessesClient["getRun"];
+            listPage: FunctionServiceProcessesClient["listRunsPage"];
+        };
+        completedNodes: {
+            get: FunctionServiceProcessesClient["getCompletedNode"];
+        };
+        getCompletedAgentReference: FunctionServiceProcessesClient["getCompletedAgentReference"];
+        execution: Omit<FunctionLatticeClient, "getExecutionContext"> & {
+            getContext: FunctionLatticeClient["getExecutionContext"];
+        };
+    };
+    invocation: FunctionInvocationClient;
+}
+export declare function createFunctionPlatformClient(options: FunctionPlatformClientOptions): FunctionPlatformClient;

package/dist/platform-client.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFunctionPlatformClient = createFunctionPlatformClient;
+const platform_domains_1 = require("./platform-domains");
+const browser_1 = require("@sequenceholdings/platform/browser");
+const service_directory_1 = require("./service-directory");
+const directory_contract_1 = require("./directory-contract");
+const processes_1 = require("./processes");
+const agents_contract_1 = require("./agents-contract");
+const lattice_provenance_1 = require("./lattice-provenance");
+const invocation_1 = require("./invocation");
+function lazy(create) {
+    let value;
+    return () => (value ??= create());
+}
+function createFunctionPlatformClient(options) {
+    const baseUrl = (0, browser_1.trustedPlatformOrigin)({ baseUrl: options.baseUrl });
+    const allowed = new Set([
+        directory_contract_1.FUNCTION_DIRECTORY_TOKEN_HEADER,
+        processes_1.FUNCTION_PROCESS_TOKEN_HEADER,
+        agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER,
+        lattice_provenance_1.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER,
+        invocation_1.FUNCTION_INVOCATION_IDENTITY_TOKEN_HEADER,
+        ...platform_domains_1.FUNCTION_PLATFORM_DOMAIN_HEADERS,
+    ]);
+    const source = options.request.headers;
+    const headers = {};
+    if (typeof source.get === "function") {
+        for (const name of allowed) {
+            const value = source.get(name);
+            if (value !== null)
+                headers[name] = value;
+        }
+    }
+    else {
+        for (const [name, value] of Object.entries(source))
+            if (allowed.has(name.toLowerCase()))
+                headers[name] = Array.isArray(value) ? [...value] : value;
+    }
+    const context = {
+        request: { headers },
+        baseUrl,
+        fetchImpl: options.fetchImpl,
+    };
+    const directory = lazy(() => (0, service_directory_1.createFunctionServiceDirectoryClient)(context));
+    const processes = lazy(() => (0, processes_1.createFunctionServiceProcessesClient)(context));
+    const execution = lazy(() => (0, lattice_provenance_1.createFunctionLatticeClient)(context));
+    const invocation = lazy(() => (0, invocation_1.createFunctionInvocationClient)(context));
+    const { callerDirectory, ...domains } = (0, platform_domains_1.createFunctionPlatformDomains)(context);
+    return {
+        ...domains,
+        directory: {
+            caller: callerDirectory,
+            resolve: async (query) => directory().resolve(query),
+            listGroupMembers: async (query) => directory().listGroupMembers(query),
+        },
+        lattice: {
+            runs: {
+                get: async (query) => processes().getRun(query),
+                listPage: async (query) => processes().listRunsPage(query),
+            },
+            completedNodes: {
+                get: async (query) => processes().getCompletedNode(query),
+            },
+            getCompletedAgentReference: async (query) => processes().getCompletedAgentReference(query),
+            execution: {
+                getContext: async () => execution().getExecutionContext(),
+                getRunCreatorAccess: async () => execution().getRunCreatorAccess(),
+                getHumanCompletion: async (query) => execution().getHumanCompletion(query),
+                getHumanCompletions: async (query) => execution().getHumanCompletions(query),
+                getParallelSnapshot: async (query) => execution().getParallelSnapshot(query),
+            },
+        },
+        invocation: {
+            getInvocationContext: async () => invocation().getInvocationContext(),
+            getCallerCapabilities: async () => invocation().getCallerCapabilities(),
+        },
+    };
+}