@revenexx/studio-integrations 3.2.0 → 3.3.0

package/dist/runtime/types/integrations.d.ts

@@ -282,7 +282,10 @@ export interface NodeManifestOutput {
 }
 export type ConfigFieldType = 'string' | 'number' | 'boolean' | 'select' | 'multiselect' | 'object' | 'array' | 'expression' | 'secret-ref' | 'credentials-ref'
 /** Names one of the workflow's declared state namespaces (PO-374). */
- | 'state-ref' | 'dynamic-schema';
+ | 'state-ref'
+/** A route of one of the tenant's VPN connections, or the public internet
+ *  (PO-831). Stored as `VpnRouteValue | null`. */
+ | 'vpn-route' | 'dynamic-schema';
 export interface ConfigFieldOption {
     value: string | number | boolean;
     label: LocalizedString;
@@ -335,6 +338,11 @@ export interface ConfigField {
      * the stored value is the namespace NAME.
      */
     stateRole?: WorkflowStateRole;
+    /**
+     * Only for `type: 'vpn-route'` (PO-831): which kind of route the picker offers.
+     * `http` where the node declares nothing, as the SDK defaults it.
+     */
+    routeKind?: VpnRouteKind;
     /** keys of other config fields this field's options/schema depend on. */
     dependsOn?: string[];
     /** When this setting applies at all (PO-410): another setting's key, an
@@ -471,6 +479,8 @@ export interface CredentialTypeField {
     type: 'string' | 'number' | 'boolean' | 'select' | 'secret';
     label: LocalizedString;
     required?: boolean;
+    /** What the system uses when the operator changes nothing; a new credential's form starts from it (IN-38). */
+    default?: string | number | boolean;
     options?: Array<{
         label: LocalizedString;
         value: string | number | boolean;
@@ -503,6 +513,27 @@ export interface CredentialType {
     images?: CredentialTypeImage[];
     auth_kind: AuthKind;
     fields: CredentialTypeField[];
+    /**
+     * Which of the type's fields a VPN route stands in for (PO-829, the SDK's
+     * `ICredentialDescription.network`). Absent: the type cannot be routed through a
+     * VPN, and the credential forms draw no Network section for it.
+     */
+    network?: CredentialNetworkDeclaration | null;
+}
+/** What a credential type declares a VPN route replaces. */
+export type CredentialNetworkDeclaration = {
+    kind: 'tcp';
+    hostField: string;
+    portField: string;
+} | {
+    kind: 'http';
+    urlField: string;
+};
+/** How a stored credential reaches its system, when not over the public internet. */
+export interface CredentialNetwork {
+    kind: 'vpn';
+    connection: string;
+    route: string;
 }
 export type CredentialStatus = 'active' | 'needs_reauth';
 /** A tenant's credential instance (secret fields never returned). */
@@ -517,9 +548,35 @@ export interface Credential {
     last_test_at?: string | null;
     last_test_ok?: boolean | null;
     last_test_message?: string | null;
+    /** The VPN route this credential is reached through; `null` or absent = public internet. */
+    network?: CredentialNetwork | null;
     created_at: string;
     updated_at: string;
 }
+export type VpnRouteKind = 'http' | 'tcp';
+/** Console's derived status of a connection; only `active` carries traffic. */
+export type VpnConnectionStatus = 'provisioning' | 'failed' | 'active' | 'down' | 'standby' | 'disabled' | 'unknown';
+export interface VpnRoute {
+    name: string;
+    kind: VpnRouteKind;
+    /** The target inside the tenant's network. */
+    host: string;
+    port: number;
+    proto?: string | null;
+    /** Where the gateway serves the route (http: a URL, tcp: `ip:port`). */
+    endpoint?: string | null;
+}
+export interface VpnConnection {
+    name: string;
+    display_name?: string | null;
+    status: VpnConnectionStatus | string;
+    routes: VpnRoute[];
+}
+/** What a `vpn-route` setting stores, and what a credential's `network` names. */
+export interface VpnRouteValue {
+    connection: string;
+    route: string;
+}
 export type ConnectionStatus = 'connected' | 'misconfigured' | 'unverified' | 'failing';
 export interface ConnectionTemplate {
     /** kebab-case slug (e.g. 'shopify'). */

package/dist/runtime/utils/configDefaults.d.ts

@@ -9,8 +9,11 @@ import type { ConfigField } from '../types/integrations.js';
  * applied never gets to apply it. An absent key is the absence the node's
  * default answers to.
  *
- * Used in the two places a fresh set of values is made: a node dropped on the
- * canvas (WorkflowEditor), and a row added to a list setting (NodeConfigField).
+ * Used wherever a fresh set of values is made: a node dropped on the canvas
+ * (WorkflowEditor), a row added to a list setting (NodeConfigField), and a
+ * credential's form — a new one in both create dialogs, and a stored one's
+ * missing fields in the detail view (IN-38), which also compares an edit against
+ * it. A change here changes all of them.
  * Flat on purpose — it reads `default` at the level it is given and does not
  * descend into `properties` or `items`, so what a newly inserted node carries
  * is exactly what it carried before this became shared.

package/dist/runtime/utils/vpnRoute.d.ts

@@ -0,0 +1,69 @@
+import type { CredentialNetwork, CredentialNetworkDeclaration, CredentialType, VpnConnection, VpnRoute, VpnRouteKind, VpnRouteValue } from '../types/integrations.js';
+/**
+ * What the studio makes of a VPN route reference — a credential's `network`, or the
+ * value of a `vpn-route` setting — against the tenant's connections
+ * (specs/credential-network.md). Pure, so the surfaces that draw it agree.
+ */
+/** The name a connection is shown under: its display name, else its own. */
+export declare function connectionLabel(c: Pick<VpnConnection, 'name' | 'display_name'>): string;
+/** The routes of a connection a picker filtered to `kind` offers. */
+export declare function routesOfKind(c: VpnConnection | undefined, kind: VpnRouteKind): VpnRoute[];
+/** Whether a stored value names a route at all, as opposed to the public internet. */
+export declare function isVpnRouteValue(v: unknown): v is VpnRouteValue;
+export type VpnReference = 
+/** The route exists; `active` says whether its connection carries traffic now. */
+{
+    state: 'ok';
+    connection: VpnConnection;
+    route: VpnRoute;
+    active: boolean;
+}
+/** The connection or the route is gone — a broken reference. */
+ | {
+    state: 'missing';
+    connection?: VpnConnection;
+};
+/**
+ * Resolve a reference against the tenant's connections. A connection that is still
+ * there but no longer has the route counts as missing, as the backend refuses it
+ * with `VPN_ROUTE_MISSING` either way.
+ */
+export declare function resolveVpnReference(connections: readonly VpnConnection[], ref: VpnRouteValue): VpnReference;
+/** The keys of a credential type's fields a VPN route stands in for. */
+export declare function replacedFieldKeys(decl: CredentialNetworkDeclaration | null | undefined): string[];
+/**
+ * What a replaced field reads while a route stands in for it: `host:port via
+ * <connection>` for a tcp route, the gateway's endpoint for an http one — the
+ * address the request is actually sent to.
+ */
+export declare function routeTargetText(route: VpnRoute, connection: VpnConnection): string;
+/**
+ * The read-only text of every field a chosen route replaces, keyed by field. Empty
+ * while the credential is reached over the public internet, or while the route
+ * cannot be resolved — then the fields keep their stored values on screen.
+ */
+export declare function replacedFieldTexts(type: Pick<CredentialType, 'network'> | null | undefined, value: VpnRouteValue | null, connections: readonly VpnConnection[]): Record<string, string>;
+/** Whether the gateway reaches the target over TLS it does not verify. */
+export declare function isHttpsTarget(route: VpnRoute | undefined): boolean;
+/** The credential's `network` as the service takes it, from what the form holds. */
+export declare function credentialNetworkPayload(value: VpnRouteValue | null): CredentialNetwork | null;
+/** The picker's value from what a credential stores. */
+export declare function fromCredentialNetwork(n: CredentialNetwork | null | undefined): VpnRouteValue | null;
+/** Whether two values name the same route (both public counts as the same). */
+export declare function sameVpnRoute(a: VpnRouteValue | null, b: VpnRouteValue | null): boolean;
+/** A connection's status in the reader's words; an unforeseen one reads as unknown. */
+export declare function connectionStatusLabel(status: string): string;
+/** Badge classes for a connection status: green only for one that carries traffic. */
+export declare function connectionStatusTone(status: string): string;
+/**
+ * The VPN badge a credential carries where it is picked or listed, or `null` for one
+ * reached over the public internet. `connections` loaded or not decides whether a
+ * reference nothing resolves is called broken: before the list arrives it is only
+ * named.
+ */
+export declare function credentialVpnBadge(network: CredentialNetwork | null | undefined, connections: readonly VpnConnection[], loaded: boolean): {
+    text: string;
+    broken: boolean;
+    active: boolean;
+    tone: string;
+} | null;

package/dist/runtime/utils/vpnRoute.js

@@ -0,0 +1,79 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
+export function connectionLabel(c) {
+  return c.display_name?.trim() || c.name;
+}
+export function routesOfKind(c, kind) {
+  return (c?.routes ?? []).filter((r) => r.kind === kind);
+}
+export function isVpnRouteValue(v) {
+  return !!v && typeof v === "object" && typeof v.connection === "string" && v.connection !== "" && typeof v.route === "string" && v.route !== "";
+}
+export function resolveVpnReference(connections, ref) {
+  const connection = connections.find((c) => c.name === ref.connection);
+  const route = connection?.routes.find((r) => r.name === ref.route);
+  if (!connection || !route) return { state: "missing", connection };
+  return { state: "ok", connection, route, active: connection.status === "active" };
+}
+export function replacedFieldKeys(decl) {
+  if (!decl) return [];
+  return decl.kind === "tcp" ? [decl.hostField, decl.portField] : [decl.urlField];
+}
+export function routeTargetText(route, connection) {
+  const t = useIntegrationsT();
+  const target = route.kind === "http" && route.endpoint ? route.endpoint : `${route.host}:${route.port}`;
+  return t("integration.vpn.target", { target, connection: connectionLabel(connection) });
+}
+export function replacedFieldTexts(type, value, connections) {
+  const keys = replacedFieldKeys(type?.network);
+  if (!keys.length || !value) return {};
+  const ref = resolveVpnReference(connections, value);
+  if (ref.state !== "ok") return {};
+  const text = routeTargetText(ref.route, ref.connection);
+  return Object.fromEntries(keys.map((k) => [k, text]));
+}
+export function isHttpsTarget(route) {
+  return (route?.proto ?? "").toLowerCase() === "https";
+}
+export function credentialNetworkPayload(value) {
+  return value ? { kind: "vpn", connection: value.connection, route: value.route } : null;
+}
+export function fromCredentialNetwork(n) {
+  return n && n.kind === "vpn" && n.connection && n.route ? { connection: n.connection, route: n.route } : null;
+}
+export function sameVpnRoute(a, b) {
+  if (!a || !b) return !a && !b;
+  return a.connection === b.connection && a.route === b.route;
+}
+const STATUS_KEYS = ["provisioning", "failed", "active", "down", "standby", "disabled", "unknown"];
+export function connectionStatusLabel(status) {
+  const key = STATUS_KEYS.includes(status) ? status : "unknown";
+  return useIntegrationsT()(`integration.vpn.status.${key}`);
+}
+export function connectionStatusTone(status) {
+  if (status === "active") return "bg-emerald-500/10 border-emerald-500/20 text-emerald-700";
+  if (status === "failed" || status === "down") return "bg-rose-500/10 border-rose-500/20 text-rose-700";
+  if (status === "provisioning" || status === "standby") return "bg-amber-500/10 border-amber-500/20 text-amber-700";
+  return "bg-slate-500/10 border-slate-500/20 text-slate-600";
+}
+export function credentialVpnBadge(network, connections, loaded) {
+  const value = fromCredentialNetwork(network);
+  if (!value) return null;
+  const t = useIntegrationsT();
+  if (!loaded) {
+    return { text: t("integration.vpn.badge.named", { connection: value.connection }), broken: false, active: true, tone: connectionStatusTone("unknown") };
+  }
+  const ref = resolveVpnReference(connections, value);
+  if (ref.state === "missing") {
+    return { text: t("integration.vpn.badge.missing"), broken: true, active: false, tone: connectionStatusTone("failed") };
+  }
+  const name = connectionLabel(ref.connection);
+  if (ref.active) {
+    return { text: t("integration.vpn.badge.named", { connection: name }), broken: false, active: true, tone: connectionStatusTone("active") };
+  }
+  return {
+    text: t("integration.vpn.badge.withState", { connection: name, status: connectionStatusLabel(String(ref.connection.status)) }),
+    broken: false,
+    active: false,
+    tone: connectionStatusTone(String(ref.connection.status))
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {