@mamund/grail 0.0.0-stage → 0.1.0

package/bindings/httpBinding.js

@@ -0,0 +1,173 @@
+// httpBinding.js
+// Generic HTTP binding executor.
+// Maps resolved GRAIL inputs to HTTP path, query, header, and body locations.
+// Returns captured request/response facts to the GRAIL runtime.
+
+export async function executeHttpBinding(binding, inputs) {
+  const parameters = binding.parameters;
+
+  if (!parameters) {
+    return executeRequest(binding, {
+      url: binding.url,
+      headers: {},
+      body: { ...inputs }
+    });
+  }
+
+  let url = binding.url;
+  const headers = {};
+  const body = {};
+  const query = new URLSearchParams();
+
+  for (const [inputName, parameter] of Object.entries(parameters)) {
+    if (!(inputName in inputs)) {
+      throw new Error(`Missing binding input: ${inputName}`);
+    }
+
+    const value = inputs[inputName];
+    const httpName = parameter.name || inputName;
+
+    switch (parameter.in) {
+      case "path": {
+        const token = `{${httpName}}`;
+
+        if (!url.includes(token)) {
+          throw new Error(
+            `Path parameter '${inputName}' expects placeholder '${token}' in binding URL`
+          );
+        }
+
+        url = url.replaceAll(token, encodeURIComponent(String(value)));
+        break;
+      }
+
+      case "query":
+        appendQueryValue(query, httpName, value);
+        break;
+
+      case "header":
+        headers[httpName] = String(value);
+        break;
+
+      case "body":
+        body[httpName] = value;
+        break;
+
+      default:
+        throw new Error(
+          `Unsupported HTTP parameter location '${parameter.in}' for input '${inputName}'`
+        );
+    }
+  }
+
+  const queryString = query.toString();
+  if (queryString) {
+    url += `${url.includes("?") ? "&" : "?"}${queryString}`;
+  }
+
+  return executeRequest(binding, {
+    url,
+    headers,
+    body
+  });
+}
+
+function appendQueryValue(query, name, value) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      query.append(name, String(item));
+    }
+    return;
+  }
+
+  query.append(name, String(value));
+}
+
+async function executeRequest(binding, request) {
+  const contentType = binding.contentType || "application/json";
+  const headers = { ...request.headers };
+  const hasBody = Object.keys(request.body).length > 0;
+  let requestBody;
+
+  if (hasBody) {
+    headers["Content-Type"] = contentType;
+
+    if (contentType === "application/x-www-form-urlencoded") {
+      requestBody = new URLSearchParams(request.body).toString();
+    } else {
+      requestBody = JSON.stringify(request.body);
+    }
+  }
+
+  const options = {
+    method: binding.method,
+    headers
+  };
+
+  if (hasBody) {
+    options.body = requestBody;
+  }
+
+  // const response = await fetch(request.url, options);
+  let response;
+
+  try {
+    response = await fetch(request.url, options);
+  } catch (error) {
+    return {
+      request: {
+        method: binding.method,
+        url: request.url,
+        headers,
+        body: hasBody ? request.body : null
+      },
+      response: {
+        ok: false,
+        status: null,
+        headers: {},
+        body: null,
+        error: {
+          type: "network",
+          message: error.message
+        }
+      }
+    };
+  }
+  
+  const responseHeaders = Object.fromEntries(response.headers.entries());
+  const responseBody = await readResponseBody(response);
+
+  return {
+    request: {
+      method: binding.method,
+      url: request.url,
+      headers,
+      body: hasBody ? request.body : null
+    },
+    response: {
+      ok: response.ok,
+      status: response.status,
+      headers: responseHeaders,
+      body: responseBody
+    }
+  };
+}
+
+async function readResponseBody(response) {
+  const contentType = response.headers.get("content-type") || "";
+  const text = await response.text();
+
+  if (text === "") {
+    return null;
+  }
+
+  if (contentType.includes("application/json")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+
+  return text;
+}

package/bindings/nodeBinding.js

@@ -0,0 +1,25 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+export async function executeNodeBinding(binding, inputs, baseDir = process.cwd()) {
+  const modulePath = path.resolve(baseDir, binding.module);
+  const moduleUrl = pathToFileURL(modulePath).href;
+
+  const loaded = await import(moduleUrl);
+  const fn = loaded[binding.function];
+
+  if (typeof fn !== "function") {
+    throw new Error(
+      `Node binding function not found: ${binding.function} in ${binding.module}`
+    );
+  }
+
+  const result = await fn(inputs);
+
+  return {
+    module: binding.module,
+    function: binding.function,
+    inputs,
+    result
+  };
+}

package/bindings/stdioBinding.js

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+
+export function executeStdioBinding(binding, inputs, baseDir = process.cwd()) {
+  return new Promise((resolve, reject) => {
+    const args = binding.args || [];
+
+    const child = spawn(binding.command, args, {
+      cwd: baseDir,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("error", (error) => {
+      reject(error);
+    });
+
+    child.on("close", (exitCode) => {
+      let parsedStdout = null;
+      let parseError = null;
+
+      if (stdout.trim()) {
+        try {
+          parsedStdout = JSON.parse(stdout);
+        } catch (error) {
+          parseError = `Invalid JSON on stdout: ${error.message}`;
+        }
+      } else {
+        parseError = "No JSON returned on stdout";
+      }
+
+      resolve({
+        command: binding.command,
+        args,
+        inputs,
+        exitCode,
+        stdout: parsedStdout ?? stdout,
+        stderr,
+        error:
+          exitCode !== 0
+            ? stderr.trim() || `Process exited with code ${exitCode}`
+            : parseError
+      });
+    });
+
+    child.stdin.write(JSON.stringify(inputs));
+    child.stdin.end();
+  });
+}