forge-fsql 1.0.2 → 1.0.4

package/README.md

@@ -15,8 +15,17 @@ Interactive command-line interface for querying Atlassian Forge SQL databases vi
 
 ### In Your Forge Project
 
-```bash
-pnpm add -D forge-fsql
+```sh
+npm install -D 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
 ```
 
 Add to your `package.json` scripts:
@@ -24,37 +33,20 @@ Add to your `package.json` scripts:
 ```json
 {
   "scripts": {
-    "sql": "fsql"
+    "fsql": "fsql"
   }
 }
 ```
 
-### Global Installation
-
-```bash
-pnpm add -g forge-fsql
-```
-
-## Configuration
-
-Create a `.env` file in your project root:
-
-```bash
-FORGE_SQL_URL=https://your-trigger-url.forge.atlassian.com/sql
-```
-
-Or pass via command line:
-
-```bash
-fsql --url https://your-trigger-url.com
-```
+## Run
 
-## Usage
+```sh
+# set URL using value from previous step
+export FORGE_SQL_URL=https://your-trigger-url.com
 
-```bash
-# If installed in project
-pnpm sql
+# run fsql!
+npm run fsql
 
-# If installed globally
-fsql
+# or
+npm run fsql --url https://your-trigger-url.com
 ```

package/bin/setup

@@ -6,7 +6,7 @@ import { createRequire } from "module";
 
 // Support both ESM and CJS imports for js-yaml
 const require = createRequire(import.meta.url);
-const yaml = require("js-yaml");
+const YAML = require("yaml");
 
 const projectRoot = process.cwd();
 
@@ -67,45 +67,70 @@ if (!fs.existsSync(manifestPath)) {
   process.exit(1);
 }
 
-let manifest;
+let doc;
 try {
   const fileContents = fs.readFileSync(manifestPath, "utf8");
-  manifest = yaml.load(fileContents);
+  doc = YAML.parseDocument(fileContents);
 } catch (e) {
   console.error("Error reading manifest:", e);
   process.exit(1);
 }
 
-if (!manifest.modules) {
-  manifest.modules = {};
+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 (!manifest.modules.function) {
-  manifest.modules.function = [];
-} else if (!Array.isArray(manifest.modules.function)) {
-  // Handle case where it might be a map (unlikely in Forge but just in case)
-  manifest.modules.function = Object.entries(manifest.modules.function).map(
-    ([key, val]) => ({ key, ...val }),
+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 functionExists = manifest.modules.function.find(
-  (f) => f.key === functionKey,
-);
 const handlerName = "fsql.executeSql";
+let functionExists = functions.items.find((f) => {
+  const js = f.toJSON();
+  return js && js.key === functionKey;
+});
 
 if (!functionExists) {
-  manifest.modules.function.push({
-    key: functionKey,
-    handler: handlerName,
-  });
+  functions.add(
+    doc.createNode({
+      key: functionKey,
+      handler: handlerName,
+    }),
+  );
   console.log(
     `✓ Added function:${functionKey} with handler ${handlerName} to manifest`,
   );
 } else {
-  functionExists.handler = handlerName;
+  // 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`,
   );
@@ -113,38 +138,49 @@ if (!functionExists) {
 
 // Ensure webtrigger is an array
 const webtriggerKey = "execute-sql";
-if (!manifest.modules.webtrigger) {
-  manifest.modules.webtrigger = [];
-} else if (!Array.isArray(manifest.modules.webtrigger)) {
-  manifest.modules.webtrigger = Object.entries(manifest.modules.webtrigger).map(
-    ([key, val]) => ({ key, ...val }),
+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);
 }
 
-const webtriggerExists = manifest.modules.webtrigger.find(
-  (w) => w.key === webtriggerKey,
-);
+let webtriggerExists = webtriggers.items.find((w) => {
+  const js = w.toJSON();
+  return js && js.key === webtriggerKey;
+});
+
 if (!webtriggerExists) {
-  manifest.modules.webtrigger.push({
-    key: webtriggerKey,
-    function: functionKey,
-  });
+  webtriggers.add(
+    doc.createNode({
+      key: webtriggerKey,
+      function: functionKey,
+    }),
+  );
   console.log(`✓ Added webtrigger:${webtriggerKey} to manifest`);
 } else {
-  webtriggerExists.function = functionKey;
+  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 {
-  // Use a large enough lineWidth to prevent wrapping which can break Forge parsing sometimes
-  const newYaml = yaml.dump(manifest, {
-    indent: 2,
-    lineWidth: -1,
-    noRefs: true,
-  });
-  fs.writeFileSync(manifestPath, newYaml);
+  fs.writeFileSync(manifestPath, doc.toString());
   console.log("✓ Updated manifest file successfully");
 } catch (e) {
   console.error("Error writing manifest:", e);

package/dist/cjs/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/client.d.ts

@@ -0,0 +1,16 @@
+export interface SqlResult {
+    rows?: any[];
+    affectedRows?: number;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+export interface ClientConfig {
+    url: string;
+    timeout?: number;
+}
+export declare class ForgeClient {
+    private config;
+    constructor(config: ClientConfig);
+    execute(sql: string): Promise<SqlResult>;
+    testConnection(): Promise<boolean>;
+}

package/dist/cjs/client.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForgeClient = void 0;
-const node_fetch_1 = __importDefault(require("node-fetch"));
 class ForgeClient {
     constructor(config) {
         this.config = {
@@ -22,7 +18,7 @@ class ForgeClient {
             const headers = {
                 "Content-Type": "application/json",
             };
-            const response = await (0, node_fetch_1.default)(this.config.url, {
+            const response = await fetch(this.config.url, {
                 method: "POST",
                 headers,
                 body: JSON.stringify({ query: finalSql }),

package/dist/cjs/commands.d.ts

@@ -0,0 +1,12 @@
+import { ForgeClient } from "./client.js";
+export interface Command {
+    name: string;
+    description: string;
+    execute: (client: ForgeClient, args?: string) => Promise<string>;
+}
+export declare const specialCommands: Command[];
+export declare function parseCommand(input: string): {
+    command?: Command;
+    args?: string;
+    isSpecial: boolean;
+};

package/dist/cjs/execute-sql.d.ts

@@ -0,0 +1,12 @@
+declare const executeSql: (req: {
+    body: string;
+}) => Promise<ReturnType<typeof getHttpResponse>>;
+declare function getHttpResponse(statusCode: number, body: Record<string, unknown>): {
+    headers: {
+        "Content-Type": string[];
+    };
+    statusCode: number;
+    statusText: string;
+    body: string;
+};
+export { executeSql };

package/dist/cjs/formatter.d.ts

@@ -0,0 +1,9 @@
+import { SqlResult } from "./client.js";
+export declare class ResultFormatter {
+    static formatTable(rows: any[]): string;
+    static formatValue(value: any): string;
+    static formatError(error: string): string;
+    static formatSuccess(message: string): string;
+    static formatResult(result: SqlResult): string;
+    static formatQueryTime(ms: number): string;
+}

package/dist/cjs/history.d.ts

@@ -0,0 +1,10 @@
+export declare class History {
+    private historyFile;
+    private history;
+    private maxSize;
+    constructor(maxSize?: number);
+    private load;
+    save(): void;
+    add(command: string): void;
+    getAll(): string[];
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,18 @@
+export { ForgeClient } from "./client.js";
+export { executeSql } from "./execute-sql.js";
+interface CliConfig {
+    url?: string;
+}
+export declare class ForgeSqlCli {
+    private client;
+    private rl;
+    private history;
+    private multilineBuffer;
+    private isMultiline;
+    constructor(config: CliConfig);
+    private setupHandlers;
+    private handleLine;
+    private executeCommand;
+    private handleClose;
+    start(): Promise<void>;
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client.d.ts

@@ -0,0 +1,16 @@
+export interface SqlResult {
+    rows?: any[];
+    affectedRows?: number;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+export interface ClientConfig {
+    url: string;
+    timeout?: number;
+}
+export declare class ForgeClient {
+    private config;
+    constructor(config: ClientConfig);
+    execute(sql: string): Promise<SqlResult>;
+    testConnection(): Promise<boolean>;
+}

package/dist/client.js

@@ -1,4 +1,3 @@
-import fetch from "node-fetch";
 export class ForgeClient {
     constructor(config) {
         this.config = {

package/dist/commands.d.ts

@@ -0,0 +1,12 @@
+import { ForgeClient } from "./client.js";
+export interface Command {
+    name: string;
+    description: string;
+    execute: (client: ForgeClient, args?: string) => Promise<string>;
+}
+export declare const specialCommands: Command[];
+export declare function parseCommand(input: string): {
+    command?: Command;
+    args?: string;
+    isSpecial: boolean;
+};

package/dist/execute-sql.d.ts

@@ -0,0 +1,12 @@
+declare const executeSql: (req: {
+    body: string;
+}) => Promise<ReturnType<typeof getHttpResponse>>;
+declare function getHttpResponse(statusCode: number, body: Record<string, unknown>): {
+    headers: {
+        "Content-Type": string[];
+    };
+    statusCode: number;
+    statusText: string;
+    body: string;
+};
+export { executeSql };

package/dist/formatter.d.ts

@@ -0,0 +1,9 @@
+import { SqlResult } from "./client.js";
+export declare class ResultFormatter {
+    static formatTable(rows: any[]): string;
+    static formatValue(value: any): string;
+    static formatError(error: string): string;
+    static formatSuccess(message: string): string;
+    static formatResult(result: SqlResult): string;
+    static formatQueryTime(ms: number): string;
+}

package/dist/history.d.ts

@@ -0,0 +1,10 @@
+export declare class History {
+    private historyFile;
+    private history;
+    private maxSize;
+    constructor(maxSize?: number);
+    private load;
+    save(): void;
+    add(command: string): void;
+    getAll(): string[];
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { ForgeClient } from "./client.js";
+export { executeSql } from "./execute-sql.js";
+interface CliConfig {
+    url?: string;
+}
+export declare class ForgeSqlCli {
+    private client;
+    private rl;
+    private history;
+    private multilineBuffer;
+    private isMultiline;
+    constructor(config: CliConfig);
+    private setupHandlers;
+    private handleLine;
+    private executeCommand;
+    private handleClose;
+    start(): Promise<void>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-fsql",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "description": "Interactive SQL CLI for Atlassian Forge SQL via web triggers",
   "main": "dist/cjs/index.js",
@@ -12,9 +12,14 @@
   },
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/cjs/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
     }
   },
   "files": [
@@ -41,12 +46,11 @@
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.3",
     "dotenv": "^16.0.3",
-    "js-yaml": "^4.1.1"
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.3",
     "@eslint/js": "^9.39.1",
-    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.19.1",
     "@typescript-eslint/eslint-plugin": "^8.48.0",
     "@typescript-eslint/parser": "^8.48.0",