@sanoma-ai/workflows 0.9.1 → 0.10.1

package/src/config.ts

@@ -1,3 +1,16 @@
+import { configuredSecrets } from "./credentials.ts";
+import { secretsForInput } from "./secret.ts";
+import { isRunControlError } from "./errors.ts";
+import { currentRun } from "./run.ts";
+import {
+  connectionCatalog,
+  ConnectionRegistry,
+  connectionDriver,
+  connectionOps,
+  type ConnectionDefinition,
+  type ConnectionRule,
+} from "./connection.ts";
+import { checkSecretConfiguration, type SecretConfiguration } from "./secret-store.ts";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -81,6 +94,10 @@ export interface SanomaConfig {
    * only, for tests.
    */
   ledger?: LedgerStore;
+  /** Credential storage and explicit bindings. Omitted: encrypted Postgres, no environment fallback. */
+  secrets?: SecretConfiguration;
+  connections?: readonly ConnectionDefinition[];
+  connectionRules?: readonly ConnectionRule[];
   /** Postgres for the runtime. Defaults to `SANOMA_DATABASE_URL`, then `DEFAULT_DATABASE_URL`. */
   databaseUrl?: string;
   /** The file that defined the config, absolute, when known. Set by `defineConfig` from its call site. */
@@ -118,6 +135,9 @@ export interface SanomaConfig {
 
 /** A config, checked, with everything a worker, client or app derives from it. */
 export interface ResolvedConfig {
+  secrets: SecretConfiguration;
+  connections: ConnectionRegistry;
+  connectionPool: LazyPool;
   /**
    * Scopes workflows, queues and versions in the system database: the `name` of
    * `<root>/package.json` when it names one, else "sanoma".
@@ -252,6 +272,7 @@ export function rootOf(config: Pick<SanomaConfig, "root" | "file">): string | un
  * `startApp`, the `sanoma` bin when it loads the config.
  */
 export function resolveConfig(config: SanomaConfig): ResolvedConfig {
+  checkSecretConfiguration(config.secrets ?? {});
   if (!Array.isArray(config.connectors)) {
     throw new Error("The config needs `connectors`: the connectors its workflows call, as their packages export them");
   }
@@ -280,6 +301,12 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
   const hostTyped = [...types.values()].some((type) => type.host);
   // Built-in: the collections' operations, `data.<name>.<op>`, on the config's database.
   const databaseUrl = resolveDatabaseUrl(config);
+  const connectionPool = lazyPool(databaseUrl, "connections");
+  const connections = new ConnectionRegistry(
+    connectionCatalog(config.connectors, config.connections, config.connectionRules),
+    () => connectionPool.db(),
+    configuredSecrets(config.secrets ?? {}, () => connectionPool.db()),
+  );
   const declared = [...collections.values()];
   const dataStore = declared.length ? lazyPool(databaseUrl, "data") : undefined;
   // Built-in, in every config: a change's operations, which the template's policy names
@@ -287,6 +314,7 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
   const ops = indexConnectors([
     ...running,
     changeOps,
+    connectionOps,
     appsListOps,
     ...(hostTyped ? [sourceOps] : []),
     ...(dataStore ? [collectionsConnector(declared)] : []),
@@ -299,11 +327,13 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
     [
       ...driversByVendor.values(),
       changeDriver(remotes),
+      connectionDriver(connections),
       appsListDriver,
       ...(hostTyped ? [sourceDriver] : []),
       ...(dataStore ? [collectionsDriver(declared, dataStore)] : []),
     ],
     ops,
+    { connections },
   );
   const fakes = makersOf(running, "fake");
   if (dataStore) fakes.set(DATA_VENDOR, () => collectionsFake(declared));
@@ -326,7 +356,7 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
   const connectors = connectorsOf(config);
   // The types the data files may declare: the vendors' and the people's, whose resources are left out.
   const declarable = resourceTypesOf(connectors);
-  const read = () => readDeclared(root, connectors, declarable, types);
+  const read = () => readDeclared(root, connectors, declarable, types, connections);
   if (types.size) {
     names.set(
       DRIFT_WORKFLOW,
@@ -343,6 +373,9 @@ export function resolveConfig(config: SanomaConfig): ResolvedConfig {
   if (call.uses.length) names.set(CALL_WORKFLOW, call);
   const { policy, policies, problems: policyProblems } = policyAt(root, { ops, workflows: names, collections });
   return {
+    secrets: config.secrets ?? {},
+    connections,
+    connectionPool,
     appName,
     databaseUrl,
     // The built-in's code and operations are part of the app's version, like the config's own.
@@ -495,9 +528,9 @@ export async function declaredWakeup(config: SanomaConfig): Promise<DeclaredWake
   const connectors = connectorsOf(config);
   const types = resourceTypesOf(connectors);
   if (![...types.values()].some((type) => type.wakeup)) return undefined;
-  // Loaded when it is needed, not with the worker: the reader parses with oxc-parser.
-  const { readDataFiles } = await import("./resources.ts");
-  const { resources } = readDataFiles(rootOf(config), connectors, types);
+  // Loaded when it is needed, not with the worker.
+  const { loadDataFiles } = await import("./resources.ts");
+  const { resources } = loadDataFiles(rootOf(config), connectors, types);
   const typeOf = (r: DeclaredResource) => types.get(`${r.vendor}.${r.type}`)!;
   const declared = resources.find((r) => typeOf(r).wakeup);
   if (!declared) return undefined;
@@ -523,15 +556,38 @@ async function readDeclared(
   connectors: readonly Connector<any, any>[],
   declarable: ReadonlyMap<string, Resource>,
   types: ReadonlyMap<string, Resource>,
+  connections: ConnectionRegistry,
 ): Promise<Omit<ApplyDeclared, "rebinds">> {
-  // Loaded when a run reads the files, not with the worker: the reader parses with oxc-parser.
-  const { readDataFiles } = await import("./resources.ts");
-  const { resources, bindings, orphans, problems } = readDataFiles(root, connectors, declarable);
+  // Loaded when a run reads the files, not with the worker.
+  const { loadDataFiles } = await import("./resources.ts");
+  const { resources, bindings, orphans, problems } = loadDataFiles(root, connectors, declarable);
+  // Read inside the data-file durable step: every operation of the plan uses one pinned account.
+  const run = currentRun.getStore();
+  if (run && !run.sandbox) {
+    for (const resource of resources.filter((r) => types.has(`${r.vendor}.${r.type}`))) {
+      try {
+        const selected = await connections.select(resource.vendor, resource.connection, run.actor.id);
+        if (selected) {
+          const pinned = { vendor: selected.vendor, $connection: selected.id, revision: selected.revision };
+          const locked = bindings[resource.id]?.connection;
+          if (locked && (locked.$connection !== pinned.$connection || locked.revision !== pinned.revision))
+            throw new Error("The bound resource's account changed; explicitly unbind before using a new account");
+          resource.connection = pinned;
+        }
+      } catch {
+        problems.push({
+          file: resource.file,
+          message: `${resource.id}: its connection is unavailable or changed; reconnect and explicitly rebind`,
+        });
+        resources.splice(resources.indexOf(resource), 1);
+      }
+    }
+  }
   return {
     // Only `types`' resources have a vendor object to check or apply: not the people's (vendorless).
     resources: resources
       .filter((r) => types.has(`${r.vendor}.${r.type}`))
-      .map(({ id, vendor, type, name, identity, binding, desired, refs }) => ({
+      .map(({ id, vendor, type, name, identity, binding, desired, refs, connection }) => ({
         id,
         vendor,
         type,
@@ -540,6 +596,7 @@ async function readDeclared(
         ...(binding !== undefined && { binding }),
         desired: withoutWriteOnly(types.get(`${vendor}.${type}`)!.fields, desired),
         refs,
+        ...(connection && { connection }),
       })),
     bindings,
     orphans,
@@ -563,11 +620,15 @@ function indexConnectors(list: Connector<any, any>[]) {
 }
 
 /**
- * The drivers' functions by operation id, refusing one no connector declares. A driver that
- * declares an `env` has each function guarded by it (`guarded`); a fake declares none, so a
- * sandbox run's calls are not.
+ * The drivers' functions by operation id, refusing one no connector declares. Named live
+ * calls resolve authentication here, after policy, inside the driver's execution boundary.
+ * Drivers without named authentication retain their declared environment guard.
  */
-export function indexDrivers(list: Driver[], ops: Map<string, Op>) {
+export function indexDrivers(
+  list: Driver[],
+  ops: Map<string, Op>,
+  options: { connections?: ConnectionRegistry; sandbox?: boolean } = {},
+) {
   const map = new Map<string, DriverFn>();
   for (const d of list) {
     for (const [key, fn] of Object.entries(d.ops)) {
@@ -575,7 +636,36 @@ export function indexDrivers(list: Driver[], ops: Map<string, Op>) {
       if (!ops.has(id)) {
         throw new Error(`Driver "${d.vendor}" implements ${id}, which no connector in \`connectors\` declares`);
       }
-      map.set(id, d.env ? guarded(d.vendor, d.env, fn) : fn);
+      const unselected = d.env ? guarded(d.vendor, d.env, fn) : fn;
+      map.set(id, async (input, call) => {
+        if (options.sandbox) return fn(input, call);
+        if (!call.connection) {
+          if (d.authentication?.length)
+            throw new DriverError("Select a named connection for this driver", { retryable: false });
+          return unselected(input, call);
+        }
+        if (!options.connections || !call.principal || !d.authentication?.includes(call.connection.method))
+          throw new DriverError("This driver does not support the selected connection", { retryable: false });
+        const authentication = await options.connections.authenticate(call.connection, call.principal.id);
+        try {
+          return await fn(input, {
+            ...call,
+            connection: structuredClone(call.connection),
+            authentication,
+            secrets: secretsForInput(input, call.secrets, ops.get(id)!.createsSecrets?.(input)),
+          });
+        } catch (error) {
+          if (isRunControlError(error)) throw error;
+          // SDK exceptions can contain the complete request, including authorization headers.
+          // Drivers may come from another installed copy of this package.
+          const failure = error as { code?: unknown; retryable?: unknown; status?: unknown } | null;
+          const status = failure?.code === "driver_failed" ? failure.status : undefined;
+          throw new DriverError(`${d.vendor} operation failed`, {
+            retryable: failure?.code === "driver_failed" && failure.retryable === true,
+            ...(typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599 && { status }),
+          });
+        }
+      });
     }
   }
   return map;
@@ -583,12 +673,10 @@ export function indexDrivers(list: Driver[], ops: Map<string, Op>) {
 
 /**
  * `fn`, refused while the environment leaves a variable `env` declares missing or invalid. The
- * worker started without it (`startWorker` only warns), and stored credentials load into the
- * environment as they are set, so the check is made when the function is called, inside the
- * driver step, and nowhere earlier: not at start, and not before the policy's decision or an
- * approval hold, so a credential set on the connector page while a call waits for approval is
- * used when the approver approves. The refusal is the call's own failure, final: recorded as
- * the call's, and never retried.
+ * worker started without it (`startWorker` only warns). This checks only explicitly supplied
+ * process environment; stored credentials are never copied there. The guard runs inside the
+ * driver step after policy and approval. Named connections never use this path. The refusal
+ * is the call's own failure, final: recorded as the call's, and never retried.
  */
 function guarded(vendor: string, env: DriverEnv, fn: DriverFn): DriverFn {
   return async (input, call) => {