@valon-technologies/gestalt 0.0.1-alpha.1 → 0.0.1-alpha.9

package/src/target.ts

@@ -2,39 +2,39 @@ import { readFileSync } from "node:fs";
 import { isAbsolute, normalize, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
+import {
+  formatExternalProviderKind,
+  isExternalProviderKindToken,
+  parseExternalProviderKind,
+} from "./provider-kind.ts";
 import { slugName, type ProviderKind } from "./provider.ts";
 
+/**
+ * Relative module target with an optional named export.
+ */
 export type ModuleTarget = {
   modulePath: string;
   exportName?: string;
 };
 
+/**
+ * Provider target with an explicit Gestalt provider kind.
+ */
 export type ProviderTarget = ModuleTarget & {
   kind: ProviderKind;
 };
 
+/**
+ * Gestalt-specific package metadata read from `package.json`.
+ */
 export type PackageConfig = {
   name?: string;
   providerTarget?: ProviderTarget;
 };
 
-type PackageProviderConfig =
-  | string
-  | {
-      kind?: string;
-      target?: string;
-    };
-
-const EXTERNAL_PROVIDER_KIND_TOKENS = new Set<string>([
-  "plugin",
-  "integration",
-  "auth",
-  "cache",
-  "secrets",
-  "s3",
-  "telemetry",
-]);
-
+/**
+ * Parses a relative module target in the form `./file.ts#namedExport`.
+ */
 export function parseModuleTarget(target: string, label = "gestalt provider target"): ModuleTarget {
   const [modulePathRaw, exportNameRaw] = target.split("#", 2);
   const modulePath = modulePathRaw?.trim() ?? "";
@@ -59,7 +59,12 @@ export function parseModuleTarget(target: string, label = "gestalt provider targ
   return parsed;
 }
 
-export function parseProviderTarget(target: string | PackageProviderConfig): ProviderTarget {
+/**
+ * Parses either a string or object-form provider target from `package.json`.
+ */
+export function parseProviderTarget(
+  target: string | { kind?: string; target?: string },
+): ProviderTarget {
   if (typeof target === "string") {
     const prefixed = parseKindPrefixedTarget(target);
     if (prefixed) {
@@ -71,7 +76,7 @@ export function parseProviderTarget(target: string | PackageProviderConfig): Pro
     };
   }
 
-  const kind = parseProviderKind(target.kind ?? "integration");
+  const kind = parseExternalProviderKind(target.kind ?? "plugin");
   if (!target.target || typeof target.target !== "string") {
     throw new Error("gestalt.provider.target is required");
   }
@@ -81,8 +86,9 @@ export function parseProviderTarget(target: string | PackageProviderConfig): Pro
   };
 }
 
-export const parsePluginTarget = parseModuleTarget;
-
+/**
+ * Reads the Gestalt-specific provider metadata from a package directory.
+ */
 export function readPackageConfig(root: string): PackageConfig {
   const packagePath = resolve(root, "package.json");
   const raw = JSON.parse(readFileSync(packagePath, "utf8")) as Record<string, unknown>;
@@ -94,11 +100,6 @@ export function readPackageConfig(root: string): PackageConfig {
     providerTarget = parseProviderTarget(gestalt.provider);
   } else if (isProviderConfigObject(gestalt.provider)) {
     providerTarget = parseProviderTarget(gestalt.provider);
-  } else if (typeof gestalt.plugin === "string") {
-    providerTarget = {
-      kind: "integration",
-      ...parseModuleTarget(gestalt.plugin, "gestalt.plugin"),
-    };
   }
 
   const config: PackageConfig = {};
@@ -111,29 +112,28 @@ export function readPackageConfig(root: string): PackageConfig {
   return config;
 }
 
+/**
+ * Reads and validates the configured provider target from `package.json`.
+ */
 export function readPackageProviderTarget(root: string): ProviderTarget {
   const config = readPackageConfig(root);
   if (!config.providerTarget) {
-    throw new Error("package.json gestalt.provider or gestalt.plugin is required");
+    throw new Error("package.json gestalt.provider is required");
   }
   return config.providerTarget;
 }
 
-export function readPackagePluginTarget(root: string): string {
-  const target = readPackageProviderTarget(root);
-  if (target.kind !== "integration") {
-    throw new Error(`package.json provider kind ${JSON.stringify(target.kind)} is not an integration provider`);
-  }
-  return formatModuleTarget(target);
-}
-
+/**
+ * Computes a default provider slug from the package name.
+ */
 export function defaultProviderName(root: string): string {
   const config = readPackageConfig(root);
   return slugName(config.name ?? "");
 }
 
-export const defaultPluginName = defaultProviderName;
-
+/**
+ * Resolves a provider target to an absolute file path.
+ */
 export function resolveProviderModulePath(root: string, target: ProviderTarget | ModuleTarget): string {
   const absolute = resolve(root, target.modulePath);
   if (!isAbsolute(absolute)) {
@@ -142,49 +142,47 @@ export function resolveProviderModulePath(root: string, target: ProviderTarget |
   return normalize(absolute);
 }
 
-export const resolvePluginModulePath = resolveProviderModulePath;
-
+/**
+ * Resolves a provider target to an importable file URL.
+ */
 export function resolveProviderImportUrl(root: string, target: ProviderTarget | ModuleTarget): string {
   return pathToFileURL(resolveProviderModulePath(root, target)).href;
 }
 
-export const resolvePluginImportUrl = resolveProviderImportUrl;
-
+/**
+ * Formats a provider target using the public `kind:./path#export` syntax.
+ */
 export function formatProviderTarget(target: ProviderTarget): string {
   return `${formatProviderKind(target.kind)}:${formatModuleTarget(target)}`;
 }
 
+/**
+ * Formats a module target using the public `./path#export` syntax.
+ */
 export function formatModuleTarget(target: ModuleTarget): string {
   return `${target.modulePath}${target.exportName ? `#${target.exportName}` : ""}`;
 }
 
 function parseKindPrefixedTarget(target: string): ProviderTarget | undefined {
-  const match = target.match(/^(plugin|integration|auth|cache|secrets|s3|telemetry):(.*)$/);
-  if (!match) {
+  const separator = target.indexOf(":");
+  if (separator < 0) {
+    return undefined;
+  }
+  const kindToken = target.slice(0, separator);
+  if (!kindToken || !isExternalProviderKindToken(kindToken)) {
+    if (kindToken && !kindToken.startsWith(".") && !kindToken.startsWith("/")) {
+      parseExternalProviderKind(kindToken);
+    }
     return undefined;
   }
   return {
-    kind: parseProviderKind(match[1]!),
-    ...parseModuleTarget(match[2]!, "provider target"),
+    kind: parseExternalProviderKind(kindToken),
+    ...parseModuleTarget(target.slice(separator + 1), "provider target"),
   };
 }
 
-function parseProviderKind(value: string): ProviderKind {
-  const normalized = value.trim().toLowerCase();
-  if (!EXTERNAL_PROVIDER_KIND_TOKENS.has(normalized)) {
-    throw new Error(`unsupported provider kind ${JSON.stringify(value)}`);
-  }
-  if (normalized === "plugin") {
-    return "integration";
-  }
-  return normalized as ProviderKind;
-}
-
 function formatProviderKind(kind: ProviderKind): string {
-  if (kind === "integration") {
-    return "plugin";
-  }
-  return kind;
+  return formatExternalProviderKind(kind);
 }
 
 function isProviderConfigObject(value: unknown): value is { kind?: string; target?: string } {

package/src/workflow-manager.ts

@@ -0,0 +1,131 @@
+import { connect } from "node:net";
+
+import type { MessageInitShape } from "@bufbuild/protobuf";
+import { createClient, type Client } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+
+import {
+  WorkflowManagerCreateScheduleRequestSchema,
+  WorkflowManagerDeleteScheduleRequestSchema,
+  WorkflowManagerGetScheduleRequestSchema,
+  WorkflowManagerHost as WorkflowManagerHostService,
+  WorkflowManagerPauseScheduleRequestSchema,
+  WorkflowManagerResumeScheduleRequestSchema,
+  WorkflowManagerUpdateScheduleRequestSchema,
+  type ManagedWorkflowSchedule,
+} from "../gen/v1/workflow_pb.ts";
+import type { Request } from "./api.ts";
+
+export const ENV_WORKFLOW_MANAGER_SOCKET = "GESTALT_WORKFLOW_MANAGER_SOCKET";
+
+export type ManagedWorkflowScheduleMessage = ManagedWorkflowSchedule;
+export type WorkflowManagerCreateScheduleInput = MessageInitShape<
+  typeof WorkflowManagerCreateScheduleRequestSchema
+>;
+export type WorkflowManagerGetScheduleInput = MessageInitShape<
+  typeof WorkflowManagerGetScheduleRequestSchema
+>;
+export type WorkflowManagerUpdateScheduleInput = MessageInitShape<
+  typeof WorkflowManagerUpdateScheduleRequestSchema
+>;
+export type WorkflowManagerDeleteScheduleInput = MessageInitShape<
+  typeof WorkflowManagerDeleteScheduleRequestSchema
+>;
+export type WorkflowManagerPauseScheduleInput = MessageInitShape<
+  typeof WorkflowManagerPauseScheduleRequestSchema
+>;
+export type WorkflowManagerResumeScheduleInput = MessageInitShape<
+  typeof WorkflowManagerResumeScheduleRequestSchema
+>;
+
+export class WorkflowManager {
+  private readonly client: Client<typeof WorkflowManagerHostService>;
+  private readonly invocationToken: string;
+
+  constructor(request: Request);
+  constructor(invocationToken: string);
+  constructor(requestOrToken: Request | string) {
+    this.invocationToken = normalizeInvocationToken(requestOrToken);
+
+    const socketPath = process.env[ENV_WORKFLOW_MANAGER_SOCKET];
+    if (!socketPath) {
+      throw new Error(
+        `workflow manager: ${ENV_WORKFLOW_MANAGER_SOCKET} is not set`,
+      );
+    }
+
+    const transport = createGrpcTransport({
+      baseUrl: "http://localhost",
+      nodeOptions: {
+        createConnection: () => connect(socketPath),
+      },
+    });
+    this.client = createClient(WorkflowManagerHostService, transport);
+  }
+
+  async createSchedule(
+    request: WorkflowManagerCreateScheduleInput,
+  ): Promise<ManagedWorkflowScheduleMessage> {
+    return await this.client.createSchedule({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async getSchedule(
+    request: WorkflowManagerGetScheduleInput,
+  ): Promise<ManagedWorkflowScheduleMessage> {
+    return await this.client.getSchedule({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async updateSchedule(
+    request: WorkflowManagerUpdateScheduleInput,
+  ): Promise<ManagedWorkflowScheduleMessage> {
+    return await this.client.updateSchedule({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async deleteSchedule(
+    request: WorkflowManagerDeleteScheduleInput,
+  ): Promise<void> {
+    await this.client.deleteSchedule({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async pauseSchedule(
+    request: WorkflowManagerPauseScheduleInput,
+  ): Promise<ManagedWorkflowScheduleMessage> {
+    return await this.client.pauseSchedule({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+
+  async resumeSchedule(
+    request: WorkflowManagerResumeScheduleInput,
+  ): Promise<ManagedWorkflowScheduleMessage> {
+    return await this.client.resumeSchedule({
+      ...request,
+      invocationToken: this.invocationToken,
+    });
+  }
+}
+
+function normalizeInvocationToken(requestOrToken: Request | string): string {
+  const invocationToken =
+    typeof requestOrToken === "string"
+      ? requestOrToken
+      : requestOrToken.invocationToken;
+  const trimmed = invocationToken.trim();
+  if (!trimmed) {
+    throw new Error("workflow manager: invocation token is not available");
+  }
+  return trimmed;
+}