forge-fsql 1.0.4 → 1.1.0

package/README.md

@@ -4,49 +4,33 @@ Interactive command-line interface for querying Atlassian Forge SQL databases vi
 
 ## Features
 
-- 🎨 Beautiful table formatting with colors
-- 📝 Multi-line SQL support
-- ⌨️ Command history (↑/↓ arrows)
+- 🎨 Table formatting with colors
 - ⚡ Special commands (.tables, .describe, .schema)
-- ⏱️ Query timing
+- ⌨️ Command history (↑/↓ arrows)
 - 💾 Persistent history across sessions
+- ⏱️ Query timing
+- 📝 Multi-line SQL support
 
 ## Installation
 
 ### In Your Forge Project
 
 ```sh
-npm install -D forge-fsql
+npm install -g forge-fsql
 
-# add webtrigger to manifest.yml and a wrapper module for the corresponding function
-node_modules/.bin/fsql-setup
-
-# deploy with the webtrigger
-forge deploy
-
-# get trigger url:
-forge webtrigger create --product Confluence --site <site>.atlassian.net --functionKey execute-sql
+fsql-setup
 ```
 
-Add to your `package.json` scripts:
+Notes:
 
-```json
-{
-  "scripts": {
-    "fsql": "fsql"
-  }
-}
-```
+- creates a webtrigger in your manifest.yml
+- creates a module at src/fsql.ts for the webtrigger function
+- deploys the project with the new manifest
+- creates the webtrigger with `forge webtrigger create`
+- adds the webtrigger URL to a FORGE_SQL_WEBTRIGGER environment variable in .env
 
 ## Run
 
 ```sh
-# set URL using value from previous step
-export FORGE_SQL_URL=https://your-trigger-url.com
-
-# run fsql!
-npm run fsql
-
-# or
-npm run fsql --url https://your-trigger-url.com
+fsql
 ```

package/bin/setup.js

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkgRoot = path.join(__dirname, "..");
+const templatesDir = path.join(pkgRoot, "templates");
+
+// Support both ESM and CJS imports for js-yaml
+const require = createRequire(import.meta.url);
+const YAML = require("yaml");
+
+const projectRoot = process.cwd();
+
+async function main() {
+  console.log(chalk.bold.blue("\n🚀 Forge SQL CLI Setup\n"));
+
+  // Detect consumer project type
+  let isEsm = false;
+  let isTypeScript = fs.existsSync(path.join(projectRoot, "tsconfig.json"));
+
+  try {
+    const pkgPath = path.join(projectRoot, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.type === "module") {
+        isEsm = true;
+      }
+
+      // Check for @forge/sql dependency
+      const hasForgeSql =
+        (pkg.dependencies && pkg.dependencies["@forge/sql"]) ||
+        (pkg.devDependencies && pkg.devDependencies["@forge/sql"]);
+
+      if (!hasForgeSql) {
+        console.error(chalk.red("\n❌ Error: @forge/sql is not installed."));
+        console.log(
+          chalk.yellow(
+            "This tool requires @forge/sql to be present in your project.",
+          ),
+        );
+        console.log("Please install it by running:");
+        console.log(chalk.blue("\n  npm install @forge/sql"));
+        console.log("  # or");
+        console.log(chalk.blue("  yarn add @forge/sql\n"));
+        process.exit(1);
+      }
+    } else {
+      console.error(chalk.red("\n❌ Error: package.json not found."));
+      console.log(
+        chalk.yellow(
+          "This tool requires a valid Node.js project with @forge/sql installed.",
+        ),
+      );
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk.yellow("Warning: Could not read package.json:"), error);
+  }
+
+  // 1. Detect manifest.yaml or manifest.yml
+  let manifestPath = path.join(projectRoot, "manifest.yml");
+  if (!fs.existsSync(manifestPath)) {
+    manifestPath = path.join(projectRoot, "manifest.yaml");
+  }
+
+  if (!fs.existsSync(manifestPath)) {
+    console.error(
+      chalk.red(
+        "Error: Could not find manifest.yml or manifest.yaml in the current directory.",
+      ),
+    );
+    process.exit(1);
+  }
+
+  // 2. Prompt for fsql execution function path
+  const extension = isTypeScript ? "ts" : isEsm ? "js" : "js";
+  const defaultPath = `src/fsql.${extension}`;
+
+  const response = await prompts({
+    type: "text",
+    name: "fsqlPath",
+    message: "Where should the SQL execution function be created?",
+    initial: defaultPath,
+  });
+
+  if (!response.fsqlPath) {
+    console.log(chalk.yellow("Setup cancelled."));
+    process.exit(0);
+  }
+
+  const fsqlRelPath = response.fsqlPath;
+  const fsqlAbsPath = path.resolve(projectRoot, fsqlRelPath);
+  const srcSameDir = path.dirname(fsqlAbsPath);
+
+  // Spinner for file creation
+  const spinner = ora("Creating function file...").start();
+
+  if (!fs.existsSync(srcSameDir)) {
+    fs.mkdirSync(srcSameDir, { recursive: true });
+  }
+
+  let templateFile = "";
+  if (isTypeScript) {
+    templateFile = "execute-sql.ts";
+  } else if (isEsm) {
+    templateFile = "execute-sql.js";
+  } else {
+    templateFile = "execute-sql.cjs";
+  }
+
+  const fsqlContent = fs.readFileSync(
+    path.join(templatesDir, templateFile),
+    "utf8",
+  );
+
+  fs.writeFileSync(fsqlAbsPath, fsqlContent);
+  spinner.succeed(`Created ${fsqlRelPath}`);
+
+  // 3. Update manifest
+  spinner.start("Updating manifest.yml...");
+
+  let doc;
+  try {
+    const fileContents = fs.readFileSync(manifestPath, "utf8");
+    doc = YAML.parseDocument(fileContents);
+  } catch (e) {
+    spinner.fail("Error reading manifest");
+    console.error(e);
+    process.exit(1);
+  }
+
+  if (!doc.contents) {
+    doc.contents = doc.createNode({});
+  }
+
+  if (!doc.has("modules")) {
+    doc.set("modules", doc.createNode({}));
+  }
+
+  const modules = doc.get("modules");
+
+  const functionKey = "executeSql";
+  if (!modules.has("function")) {
+    modules.set("function", doc.createNode([]));
+  }
+
+  let functions = modules.get("function");
+
+  if (!YAML.isSeq(functions)) {
+    const obj = functions.toJSON();
+    functions = doc.createNode(
+      Object.entries(obj).map(([key, val]) => ({ key, ...val })),
+    );
+    modules.set("function", functions);
+  }
+
+  // Determine handler path
+  // Standard Forge pattern: filename without extension + .functionName
+  // We need to be careful with paths.
+  // If user chooses src/foo/bar.ts, handler is src/foo/bar.executeSql
+  // If user chooses modules/bar.js, handler is modules/bar.executeSql
+
+  // 145. Determine handler path
+  let handlerPath = fsqlRelPath.replace(/\.(ts|js|cjs|mjs)$/, "");
+  // Ensure we use forward slashes for handler paths
+  handlerPath = handlerPath.split(path.sep).join("/");
+
+  // Logic to detect if we should strip 'src/' from the handler path
+  // This happens if the project uses 'src' as the root for handlers (common in Forge)
+  // We check if 'src/index.ts' exists but 'index.ts' does not, AND if there is a handler 'index.handler'
+  // Or simply, if the user created the file in 'src/' but 'src/' path is redundant for handlers.
+
+  // Heuristic: Check existing function handlers
+  let srcIsRoot = false;
+  try {
+    if (functions && functions.items && functions.items.length > 0) {
+      for (const f of functions.items) {
+        const fJson = f.toJSON();
+        if (fJson && fJson.handler) {
+          const h = fJson.handler.split(".")[0]; // e.g. "index" or "consumers/ingestion-consumer"
+          const possibleSrcPath = path.join(projectRoot, "src", h + ".ts"); // simple check for .ts
+          const possibleRootPath = path.join(projectRoot, h + ".ts");
+
+          if (
+            fs.existsSync(possibleSrcPath) &&
+            !fs.existsSync(possibleRootPath)
+          ) {
+            srcIsRoot = true;
+            break;
+          }
+        }
+      }
+    } else {
+      // Fallback: if index.ts is in src but not root
+      if (
+        fs.existsSync(path.join(projectRoot, "src", "index.ts")) &&
+        !fs.existsSync(path.join(projectRoot, "index.ts"))
+      ) {
+        srcIsRoot = true;
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  if (srcIsRoot && handlerPath.startsWith("src/")) {
+    handlerPath = handlerPath.substring(4); // remove "src/"
+  }
+
+  const handlerName = `${handlerPath}.executeSql`;
+
+  let functionExists = functions.items.find((f) => {
+    const js = f.toJSON();
+    return js && js.key === functionKey;
+  });
+
+  if (!functionExists) {
+    functions.add(
+      doc.createNode({
+        key: functionKey,
+        handler: handlerName,
+      }),
+    );
+  } else {
+    if (YAML.isMap(functionExists)) {
+      functionExists.set("handler", handlerName);
+    } else {
+      const idx = functions.items.indexOf(functionExists);
+      functions.set(
+        idx,
+        doc.createNode({ key: functionKey, handler: handlerName }),
+      );
+    }
+  }
+
+  const webtriggerKey = "execute-sql";
+  if (!modules.has("webtrigger")) {
+    modules.set("webtrigger", doc.createNode([]));
+  }
+
+  let webtriggers = modules.get("webtrigger");
+  if (!YAML.isSeq(webtriggers)) {
+    const obj = webtriggers.toJSON();
+    webtriggers = doc.createNode(
+      Object.entries(obj).map(([key, val]) => ({ key, ...val })),
+    );
+    modules.set("webtrigger", webtriggers);
+  }
+
+  let webtriggerExists = webtriggers.items.find((w) => {
+    const js = w.toJSON();
+    return js && js.key === webtriggerKey;
+  });
+
+  if (!webtriggerExists) {
+    webtriggers.add(
+      doc.createNode({
+        key: webtriggerKey,
+        function: functionKey,
+      }),
+    );
+  } else {
+    if (YAML.isMap(webtriggerExists)) {
+      webtriggerExists.set("function", functionKey);
+    } else {
+      const idx = webtriggers.items.indexOf(webtriggerExists);
+      webtriggers.set(
+        idx,
+        doc.createNode({ key: webtriggerKey, function: functionKey }),
+      );
+    }
+  }
+
+  try {
+    fs.writeFileSync(manifestPath, doc.toString());
+    spinner.succeed("Updated manifest file");
+  } catch (e) {
+    spinner.fail("Error writing manifest");
+    console.error(e);
+    process.exit(1);
+  }
+
+  // 4. Prompt for deployment
+  console.log(); // Add newline for better UX
+  const deployResponse = await prompts({
+    type: "text",
+    name: "cmd",
+    message:
+      "Command to deploy your app (required before creating webtrigger):",
+    initial: "forge deploy",
+  });
+
+  if (!deployResponse.cmd) {
+    console.log(chalk.yellow("Deployment cancelled."));
+    process.exit(0);
+  }
+
+  const deployCmd = deployResponse.cmd;
+
+  console.log(chalk.bold.blue(`\nRunning ${deployCmd}...\n`));
+
+  await new Promise((resolve) => {
+    const child = spawn(deployCmd, {
+      stdio: "inherit",
+      shell: true,
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        console.error(chalk.red(`\nDeploy failed with exit code ${code}.`));
+        process.exit(code);
+      }
+      resolve();
+    });
+  });
+
+  // 5. Run forge webtrigger create
+  let webtriggerArgs = ["webtrigger", "create", "--functionKey", "execute-sql"];
+
+  // Try to detect existing installation
+  try {
+    const listProc = spawn("forge", ["install", "list", "--json"], {
+      shell: true,
+    });
+    let listOutput = "";
+    await new Promise((resolve) => {
+      listProc.stdout.on("data", (d) => (listOutput += d.toString()));
+      listProc.on("close", resolve);
+    });
+
+    // Attempt to extract JSON
+    const jsonStart = listOutput.indexOf("[");
+    const jsonEnd = listOutput.lastIndexOf("]");
+    if (jsonStart !== -1 && jsonEnd !== -1) {
+      const installations = JSON.parse(
+        listOutput.substring(jsonStart, jsonEnd + 1),
+      );
+      const devInst = installations.find(
+        (i) => i.environment === "development",
+      );
+
+      if (devInst) {
+        console.log();
+        const useInst = await prompts({
+          type: "confirm",
+          name: "value",
+          message: `Found existing installation for ${chalk.cyan(devInst.product)} at ${chalk.cyan(devInst.site)}. Use this?`,
+          initial: true,
+        });
+
+        if (useInst.value) {
+          webtriggerArgs.push("--site", devInst.site);
+          webtriggerArgs.push("--product", devInst.product);
+        }
+      }
+    }
+  } catch {
+    // Ignore errors in auto-detection
+  }
+
+  console.log(
+    chalk.bold.blue(
+      "\nCreating webtrigger... (Please follow prompts if asked)\n",
+    ),
+  );
+
+  const separator = chalk.gray(
+    "==================================================",
+  );
+  console.log(separator);
+
+  const forgeCmd = spawn("forge", webtriggerArgs, {
+    stdio: ["inherit", "pipe", "inherit"],
+    shell: true,
+  });
+
+  let stdoutData = "";
+
+  forgeCmd.stdout.on("data", (data) => {
+    process.stdout.write(data);
+    stdoutData += data.toString();
+  });
+
+  forgeCmd.on("close", (code) => {
+    console.log(separator);
+
+    if (code !== 0) {
+      console.log(
+        chalk.yellow(
+          `\nForge command exited with code ${code}. If you cancelled or it failed, you may need to run it manually.`,
+        ),
+      );
+    }
+
+    // Capture URL
+    const urlRegex =
+      /https:\/\/[a-zA-Z0-9-.]+\.atlassian-dev\.net\/[a-zA-Z0-9/-]+/;
+    const matches = stdoutData.match(urlRegex);
+
+    if (matches) {
+      const url = matches[0];
+      console.log(chalk.green(`\nFound Webtrigger URL: ${url}`));
+      updateEnv(url);
+    } else {
+      console.log(
+        chalk.yellow(
+          "\nCould not automatically find Webtrigger URL in output.",
+        ),
+      );
+      console.log(
+        "If created, please add the URL to your .env file as FORGE_SQL_WEBTRIGGER=<url>",
+      );
+      finish();
+    }
+  });
+}
+
+function updateEnv(url) {
+  console.log();
+  const spinner = ora("Updating .env file...").start();
+  const envPath = path.join(projectRoot, ".env");
+  const envVar = `FORGE_SQL_WEBTRIGGER=${url}`;
+
+  let envContent = "";
+  if (fs.existsSync(envPath)) {
+    envContent = fs.readFileSync(envPath, "utf8");
+    if (!envContent.endsWith("\n") && envContent.length > 0) {
+      envContent += "\n";
+    }
+  }
+
+  // Check if already exists
+  if (envContent.includes("FORGE_SQL_WEBTRIGGER=")) {
+    envContent = envContent.replace(
+      /FORGE_SQL_WEBTRIGGER=.*(\n|$)/,
+      `${envVar}\n`,
+    );
+  } else {
+    envContent += `${envVar}\n`;
+  }
+
+  fs.writeFileSync(envPath, envContent);
+  spinner.succeed("Updated .env with Webtrigger URL");
+  finish();
+}
+
+function finish() {
+  const msg = "  ✔  Setup completed successfully!     ";
+  const line = "─".repeat(msg.length + 1);
+  console.log(chalk.bold.green(`\n┌${line}┐`));
+  console.log(chalk.bold.green(`│${msg}│`));
+  console.log(chalk.bold.green(`└${line}┘\n`));
+  console.log(`Run ${chalk.cyan("'fsql'")} to start.\n`);
+}
+
+main().catch((err) => {
+  console.error(chalk.red("Unexpected error:"), err);
+  process.exit(1);
+});

package/dist/cjs/index.js

@@ -53,9 +53,9 @@ class ForgeSqlCli {
     constructor(config) {
         this.multilineBuffer = "";
         this.isMultiline = false;
-        const url = config.url || process.env.FORGE_SQL_URL;
+        const url = config.url || process.env.FORGE_SQL_WEBTRIGGER;
         if (!url) {
-            console.error(chalk_1.default.red("Error: FORGE_SQL_URL not configured"));
+            console.error(chalk_1.default.red("Error: FORGE_SQL_WEBTRIGGER not configured"));
             console.error(chalk_1.default.yellow("Set it via environment variable or .env file"));
             process.exit(1);
         }
@@ -167,7 +167,7 @@ class ForgeSqlCli {
         }
         else {
             console.log(chalk_1.default.red("✗ Connection failed"));
-            console.log(chalk_1.default.yellow("Check your FORGE_SQL_URL configuration"));
+            console.log(chalk_1.default.yellow("Check your FORGE_SQL_WEBTRIGGER configuration"));
         }
         console.log("");
         this.rl.prompt();

package/dist/index.js

@@ -12,9 +12,9 @@ export class ForgeSqlCli {
     constructor(config) {
         this.multilineBuffer = "";
         this.isMultiline = false;
-        const url = config.url || process.env.FORGE_SQL_URL;
+        const url = config.url || process.env.FORGE_SQL_WEBTRIGGER;
         if (!url) {
-            console.error(chalk.red("Error: FORGE_SQL_URL not configured"));
+            console.error(chalk.red("Error: FORGE_SQL_WEBTRIGGER not configured"));
             console.error(chalk.yellow("Set it via environment variable or .env file"));
             process.exit(1);
         }
@@ -126,7 +126,7 @@ export class ForgeSqlCli {
         }
         else {
             console.log(chalk.red("✗ Connection failed"));
-            console.log(chalk.yellow("Check your FORGE_SQL_URL configuration"));
+            console.log(chalk.yellow("Check your FORGE_SQL_WEBTRIGGER configuration"));
         }
         console.log("");
         this.rl.prompt();

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "forge-fsql",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "type": "module",
   "description": "Interactive SQL CLI for Atlassian Forge SQL via web triggers",
   "main": "dist/cjs/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "fsql": "bin/fsql",
-    "fsql-setup": "bin/setup"
+    "fsql": "bin/fsql.js",
+    "fsql-setup": "bin/setup.js"
   },
   "exports": {
     ".": {
@@ -25,6 +25,7 @@
   "files": [
     "dist",
     "bin",
+    "templates",
     "README.md"
   ],
   "lint-staged": {
@@ -46,6 +47,8 @@
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.3",
     "dotenv": "^16.0.3",
+    "ora": "^9.0.0",
+    "prompts": "^2.4.2",
     "yaml": "^2.8.2"
   },
   "devDependencies": {
@@ -69,7 +72,7 @@
     "build": "tsc && tsc -p tsconfig.cjs.json && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
     "dev": "ts-node src/index.ts",
     "start": "node dist/index.js",
-    "fsql": "node ./bin/fsql",
+    "fsql": "node ./bin/fsql.js",
     "lint": "pnpm lint:eslint && pnpm lint:prettier",
     "lint:eslint": "eslint '**/*.{ts,tsx,js,jsx}' --ignore-pattern '**/eslint.config.js'",
     "lint:prettier": "prettier '**/*.{ts,tsx,js,jsx,json,md,yaml,yml}' --check || echo '⚠️  Warning: Prettier formatting issues found. Run \"pnpm fixstyle\" to fix them.'",

package/templates/execute-sql.cjs

@@ -0,0 +1,64 @@
+const { sql } = require("@forge/sql");
+
+const executeSql = async (req) => {
+  console.log("\n=== Executing Custom SQL Query ===");
+
+  const payload = req.body;
+  let sqlRequest = null;
+  let query;
+
+  try {
+    sqlRequest = JSON.parse(payload);
+    query = sqlRequest?.query;
+
+    if (!query) {
+      return getHttpResponse(400, {
+        success: false,
+        error: "No SQL query provided",
+      });
+    }
+
+    console.log("Executing query:", query);
+
+    const result = await sql.executeRaw(query);
+
+    console.log("Query result:", result);
+
+    return getHttpResponse(200, {
+      success: true,
+      rows: result.rows || [],
+      rowCount: result.rows?.length || 0,
+      query,
+    });
+  } catch (error) {
+    console.error(error);
+    console.error("Error while executing sql", { error });
+
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    return getHttpResponse(500, {
+      success: false,
+      error: errorMessage,
+      ...(query && { query }),
+    });
+  }
+};
+
+function getHttpResponse(statusCode, body) {
+  const statusTexts = {
+    200: "OK",
+    400: "Bad Request",
+    404: "Not Found",
+    500: "Internal Server Error",
+  };
+  const statusText = statusTexts[statusCode] || "Bad Request";
+
+  return {
+    headers: { "Content-Type": ["application/json"] },
+    statusCode,
+    statusText,
+    body: JSON.stringify(body),
+  };
+}
+
+module.exports = { executeSql };

package/templates/execute-sql.js

@@ -0,0 +1,64 @@
+import { sql } from "@forge/sql";
+
+const executeSql = async (req) => {
+  console.log("\n=== Executing Custom SQL Query ===");
+
+  const payload = req.body;
+  let sqlRequest = null;
+  let query;
+
+  try {
+    sqlRequest = JSON.parse(payload);
+    query = sqlRequest?.query;
+
+    if (!query) {
+      return getHttpResponse(400, {
+        success: false,
+        error: "No SQL query provided",
+      });
+    }
+
+    console.log("Executing query:", query);
+
+    const result = await sql.executeRaw(query);
+
+    console.log("Query result:", result);
+
+    return getHttpResponse(200, {
+      success: true,
+      rows: result.rows || [],
+      rowCount: result.rows?.length || 0,
+      query,
+    });
+  } catch (error) {
+    console.error(error);
+    console.error("Error while executing sql", { error });
+
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    return getHttpResponse(500, {
+      success: false,
+      error: errorMessage,
+      ...(query && { query }),
+    });
+  }
+};
+
+function getHttpResponse(statusCode, body) {
+  const statusTexts = {
+    200: "OK",
+    400: "Bad Request",
+    404: "Not Found",
+    500: "Internal Server Error",
+  };
+  const statusText = statusTexts[statusCode] || "Bad Request";
+
+  return {
+    headers: { "Content-Type": ["application/json"] },
+    statusCode,
+    statusText,
+    body: JSON.stringify(body),
+  };
+}
+
+export { executeSql };

package/templates/execute-sql.ts

@@ -0,0 +1,75 @@
+import { sql } from "@forge/sql";
+
+const executeSql = async (req: {
+  body: string;
+}): Promise<ReturnType<typeof getHttpResponse>> => {
+  console.log("\n=== Executing Custom SQL Query ===");
+
+  const payload = req.body;
+  let sqlRequest: { query?: string } | null = null;
+  let query: string | undefined;
+
+  try {
+    sqlRequest = JSON.parse(payload);
+    query = sqlRequest?.query;
+
+    if (!query) {
+      return getHttpResponse(400, {
+        success: false,
+        error: "No SQL query provided",
+      });
+    }
+
+    console.log("Executing query:", query);
+
+    // Import sql directly for custom queries
+    const result = await sql.executeRaw(query);
+
+    console.log("Query result:", result);
+
+    return getHttpResponse(200, {
+      success: true,
+      rows: result.rows || [],
+      rowCount: result.rows?.length || 0,
+      query,
+    });
+  } catch (error: unknown) {
+    console.error(error);
+    console.error("Error while executing sql", { error });
+
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    return getHttpResponse(500, {
+      success: false,
+      error: errorMessage,
+      ...(query && { query }),
+    });
+  }
+};
+
+function getHttpResponse(
+  statusCode: number,
+  body: Record<string, unknown>,
+): {
+  headers: { "Content-Type": string[] };
+  statusCode: number;
+  statusText: string;
+  body: string;
+} {
+  const statusTexts: Record<number, string> = {
+    200: "OK",
+    400: "Bad Request",
+    404: "Not Found",
+    500: "Internal Server Error",
+  };
+  const statusText = statusTexts[statusCode] || "Bad Request";
+
+  return {
+    headers: { "Content-Type": ["application/json"] },
+    statusCode,
+    statusText,
+    body: JSON.stringify(body),
+  };
+}
+
+export { executeSql };

package/bin/setup

@@ -1,193 +0,0 @@
-#!/usr/bin/env node
-
-import fs from "fs";
-import path from "path";
-import { createRequire } from "module";
-
-// Support both ESM and CJS imports for js-yaml
-const require = createRequire(import.meta.url);
-const YAML = require("yaml");
-
-const projectRoot = process.cwd();
-
-console.log("Setting up Forge SQL CLI in this project...");
-
-// Detect consumer project type
-let isEsm = false;
-let isTypeScript = fs.existsSync(path.join(projectRoot, "tsconfig.json"));
-
-try {
-  const pkgPath = path.join(projectRoot, "package.json");
-  if (fs.existsSync(pkgPath)) {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-    if (pkg.type === "module") {
-      isEsm = true;
-    }
-  }
-} catch (e) {
-  // Ignore errors reading package.json
-}
-
-// 1. Create src/fsql file
-const srcDir = path.join(projectRoot, "src");
-if (!fs.existsSync(srcDir)) {
-  fs.mkdirSync(srcDir, { recursive: true });
-}
-
-const extension = isTypeScript ? "ts" : isEsm ? "js" : "js";
-// If it's CJS, we still use .js but different content
-const fsqlPath = path.join(srcDir, `fsql.${extension}`);
-
-let fsqlContent = "";
-if (isEsm || isTypeScript) {
-  fsqlContent = `import { executeSql } from 'forge-fsql';
-
-export { executeSql };
-`;
-} else {
-  fsqlContent = `const { executeSql } = require('forge-fsql');
-
-module.exports = { executeSql };
-`;
-}
-
-fs.writeFileSync(fsqlPath, fsqlContent);
-console.log(`✓ Created src/fsql.${extension}`);
-
-// 2. Update manifest.yaml or manifest.yml
-let manifestPath = path.join(projectRoot, "manifest.yml");
-if (!fs.existsSync(manifestPath)) {
-  manifestPath = path.join(projectRoot, "manifest.yaml");
-}
-
-if (!fs.existsSync(manifestPath)) {
-  console.error(
-    "Error: Could not find manifest.yml or manifest.yaml in the current directory.",
-  );
-  process.exit(1);
-}
-
-let doc;
-try {
-  const fileContents = fs.readFileSync(manifestPath, "utf8");
-  doc = YAML.parseDocument(fileContents);
-} catch (e) {
-  console.error("Error reading manifest:", e);
-  process.exit(1);
-}
-
-if (!doc.contents) {
-  doc.contents = doc.createNode({});
-}
-
-if (!doc.has("modules")) {
-  doc.set("modules", doc.createNode({}));
-}
-
-const modules = doc.get("modules");
-
-// Ensure function is an array
-const functionKey = "executeSql";
-if (!modules.has("function")) {
-  modules.set("function", doc.createNode([]));
-}
-
-let functions = modules.get("function");
-
-// If it's somehow not a sequence, convert it (though unlikely in Forge)
-if (!YAML.isSeq(functions)) {
-  const obj = functions.toJSON();
-  functions = doc.createNode(
-    Object.entries(obj).map(([key, val]) => ({ key, ...val })),
-  );
-  modules.set("function", functions);
-}
-
-const handlerName = "fsql.executeSql";
-let functionExists = functions.items.find((f) => {
-  const js = f.toJSON();
-  return js && js.key === functionKey;
-});
-
-if (!functionExists) {
-  functions.add(
-    doc.createNode({
-      key: functionKey,
-      handler: handlerName,
-    }),
-  );
-  console.log(
-    `✓ Added function:${functionKey} with handler ${handlerName} to manifest`,
-  );
-} else {
-  // If it's a Pair (map item) or just a Map in the sequence
-  if (YAML.isMap(functionExists)) {
-    functionExists.set("handler", handlerName);
-  } else {
-    // Should not happen with doc.createNode above, but for safety:
-    const idx = functions.items.indexOf(functionExists);
-    functions.set(
-      idx,
-      doc.createNode({ key: functionKey, handler: handlerName }),
-    );
-  }
-  console.log(
-    `✓ Updated function:${functionKey} handler to ${handlerName} in manifest`,
-  );
-}
-
-// Ensure webtrigger is an array
-const webtriggerKey = "execute-sql";
-if (!modules.has("webtrigger")) {
-  modules.set("webtrigger", doc.createNode([]));
-}
-
-let webtriggers = modules.get("webtrigger");
-if (!YAML.isSeq(webtriggers)) {
-  const obj = webtriggers.toJSON();
-  webtriggers = doc.createNode(
-    Object.entries(obj).map(([key, val]) => ({ key, ...val })),
-  );
-  modules.set("webtrigger", webtriggers);
-}
-
-let webtriggerExists = webtriggers.items.find((w) => {
-  const js = w.toJSON();
-  return js && js.key === webtriggerKey;
-});
-
-if (!webtriggerExists) {
-  webtriggers.add(
-    doc.createNode({
-      key: webtriggerKey,
-      function: functionKey,
-    }),
-  );
-  console.log(`✓ Added webtrigger:${webtriggerKey} to manifest`);
-} else {
-  if (YAML.isMap(webtriggerExists)) {
-    webtriggerExists.set("function", functionKey);
-  } else {
-    const idx = webtriggers.items.indexOf(webtriggerExists);
-    webtriggers.set(
-      idx,
-      doc.createNode({ key: webtriggerKey, function: functionKey }),
-    );
-  }
-  console.log(
-    `✓ Ensured webtrigger:${webtriggerKey} points to function ${functionKey}`,
-  );
-}
-
-try {
-  fs.writeFileSync(manifestPath, doc.toString());
-  console.log("✓ Updated manifest file successfully");
-} catch (e) {
-  console.error("Error writing manifest:", e);
-  process.exit(1);
-}
-
-console.log("\nSetup completed successfully!");
-console.log(
-  "You can now use the forge-fsql CLI to interact with your Forge SQL database.",
-);