stackql · yunchengyang515 · Dec 9, 2023 · Nov 11, 2023 · Nov 11, 2023 · Nov 11, 2023
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -0,0 +1,21 @@
+name: Test
+
+on:
+  push:
+
+jobs:
+  test:
+    name: Test on Multiple OS
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Set up Deno
+        uses: denoland/setup-deno@v1
+        with:
+          deno-version: v1.x
+      - name: Run tests
+        run: deno test --allow-net --allow-read --allow-write --allow-env --allow-run
diff --git a/.gitignore b/.gitignore
@@ -33,4 +33,5 @@ yarn-error.log*
 
 # typescript
 *.tsbuildinfo
-next-env.d.ts
+next-env.d.ts
+.stackql*
diff --git a/README.md b/README.md
@@ -18,4 +18,9 @@
     - `upgrade` - if in local mode, upgrade the local stackql binary from the latest release
     - `execute` - execute a query returns an array of rows (objects)
     - `executeStmt` - executes a statement and returns a string (like `REGISTRY PULL` or `INSERT ...`)
-    - `executeQueriesAsync` - executes a list of queries and returns an array of rows (objects) - queries need to return the same columns/schema
+    - `executeQueriesAsync` - executes a list of queries and returns an array of rows (objects) - queries need to return the same columns/schema
+
+## Test
+```
+ deno test --allow-net --allow-read --allow-write --allow-env --allow-run <test file path>
+```
diff --git a/deps.ts b/deps.ts
@@ -0,0 +1 @@
+export { bold } from "https://deno.land/std/fmt/colors.ts"
diff --git a/mod.ts b/mod.ts
@@ -1,5 +1,3 @@
-import { bold } from "./deps.ts";
+import { StackQL } from "./src/stackql.ts";
 
-export function getHelloWorld(): string {
-    return bold("Hello World");
-  }
+export { StackQL };
diff --git a/src/services/downloader.test.ts b/src/services/downloader.test.ts
@@ -0,0 +1,26 @@
+import { assertExists } from "https://deno.land/std@0.206.0/assert/assert_exists.ts";
+import { Downloader } from "./downloader.ts";
+import { removeStackQLDownload } from "../../tests/utils.ts";
+
+Deno.test("Downloader setupStackQL Integration Test", async () => {
+  // Arrange
+  await removeStackQLDownload();
+  const downloader = new Downloader();
+  let binaryPath: string;
+
+  // Act
+  try {
+    binaryPath = await downloader.setupStackQL();
+
+    // Assert
+    assertExists(binaryPath);
+    // Check if the binary exists after setupStackQL is called
+
+    console.log(
+      "Test passed: setupStackQL completed without errors and binary exists."
+    );
+  } catch (error) {
+    console.error("Test failed:", error);
+    throw error; // This will cause the test to fail
+  }
+});
diff --git a/src/services/downloader.ts b/src/services/downloader.ts
@@ -0,0 +1,153 @@
+import { join } from "https://deno.land/std@0.133.0/path/mod.ts";
+import { SupportedOs } from "../types/platforms.ts";
+import { darwinUnpack, unzip } from "./unpacker.ts";
+import { chomod } from "../utils.ts";
+
+export class Downloader {
+  private os: string;
+  private arch: string;
+  private urlMap: Record<string, string>;
+
+  constructor() {
+    this.os = Deno.build.os; // 'linux', 'darwin', or 'windows'
+    this.arch = Deno.build.arch; // 'x86_64', 'arm64', etc.
+
+    this.urlMap = {
+      [SupportedOs.Linux]:
+        "https://releases.stackql.io/stackql/latest/stackql_linux_amd64.zip",
+      [SupportedOs.Windows]:
+        "https://releases.stackql.io/stackql/latest/stackql_windows_amd64.zip",
+      [SupportedOs.Darwin]:
+        "https://storage.googleapis.com/stackql-public-releases/latest/stackql_darwin_multiarch.pkg",
+      // Additional OS-architecture combinations can be added here
+    };
+  }
+
+  private async downloadFile(url: string, downloadDir: string) {
+    const res = await fetch(url);
+    const file = await Deno.open(downloadDir, { create: true, write: true });
+
+    try {
+      await res.body?.pipeTo(file.writable).finally(
+        () => file.close() //TODO: fix bad resource id when closing file
+      );
+    } catch (error) {
+      console.error(`ERROR: [downloadFile] ${error.message}`);
+    }
+
+    console.log("Closed file");
+  }
+
+  private getUrl(): string {
+    const key = `${this.os}`;
+    const url = this.urlMap[key];
+
+    if (!url) {
+      throw new Error(`Unsupported OS type: ${this.os}`);
+    }
+
+    return url;
+  }
+
+  /**
+   * Gets binary name
+   * @returns  binrary name
+   */
+  private getBinaryName() {
+    const binaryMap: Record<SupportedOs, string> = {
+      [SupportedOs.Windows]: "stackql.exe",
+      [SupportedOs.Darwin]: "stackql/Payload/stackql",
+      [SupportedOs.Linux]: "stackql", // Default case for Linux and other platforms
+    };
+    const os = Deno.build.os.toLowerCase();
+
+    if (!Object.values(SupportedOs).includes(os as SupportedOs)) {
+      throw new Error(`Unsupported OS type: ${os}`);
+    }
+
+    const binaryOs = os as SupportedOs;
+    return binaryMap[binaryOs];
+  }
+
+  /**
+   * Gets download dir
+   * @returns download dir
+   */
+  private async getDownloadDir(): Promise<string> {
+    const projectDir = Deno.cwd();
+    console.log("Project dir:", projectDir);
+
+    if (!projectDir) {
+      throw new Error("Unable to determine the project directory.");
+    }
+
+    const downloadDir = join(projectDir, ".stackql");
+
+    try {
+      const stat = await Deno.stat(downloadDir);
+      if (!stat.isDirectory) {
+        await Deno.mkdir(downloadDir, { recursive: true });
+      }
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        await Deno.mkdir(downloadDir, { recursive: true });
+      } else {
+        throw error;
+      }
+    }
+
+    return downloadDir;
+  }
+
+  private binaryExists(binaryName: string, downloadDir: string): boolean {
+    const binPath = join(downloadDir, binaryName);
+    try {
+      Deno.statSync(binPath);
+      return true;
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  private async installStackQL(downloadDir: string) {
+    const url = this.getUrl();
+
+    const archiveFileName = `${downloadDir}/${url.split("/").pop()}`;
+    await this.downloadFile(url, archiveFileName);
+
+    console.log("Unpacking stackql binary");
+    const unpacker = Deno.build.os === "darwin" ? darwinUnpack : unzip;
+    await unpacker({ downloadDir, archiveFileName });
+  }
+  private async setExecutable(binaryPath: string) {
+    const allowExecOctal = 0o755;
+    await chomod(binaryPath, allowExecOctal);
+  }
+  /**
+   * Setup stackql binary, check if binary exists, if not download it
+   */
+  public async setupStackQL() {
+    console.log("Installing stackql...");
+
+    try {
+      const binaryName = this.getBinaryName();
+      const downloadDir = await this.getDownloadDir();
+      const binaryPath = join(downloadDir, binaryName);
+      if (this.binaryExists(binaryName, downloadDir)) {
+        console.log("stackql is already installed");
+        await this.setExecutable(binaryPath);
+        return binaryPath;
+      }
+
+      console.log("Downloading stackql binary");
+      await this.installStackQL(downloadDir);
+      await this.setExecutable(binaryPath);
+      return binaryPath;
+    } catch (error) {
+      console.error(`ERROR: [setup] ${error.message}`);
+      Deno.exit(1);
+    }
+  }
+}
diff --git a/src/services/unpacker.ts b/src/services/unpacker.ts
@@ -0,0 +1,37 @@
+import { decompress } from "https://deno.land/x/zip/mod.ts";
+
+type UnpackParams = {
+  downloadDir: string;
+  archiveFileName: string;
+};
+
+export const darwinUnpack = async (params: UnpackParams) => {
+  console.log("darwinUnpack");
+  const { downloadDir, archiveFileName } = params;
+  const unpackedFileName = `${downloadDir}/stackql`;
+  const commandPath = "pkgutil";
+  const commandArgs = ["--expand-full", archiveFileName, unpackedFileName];
+  const process = new Deno.Command(commandPath, {
+    args: commandArgs,
+    stdout: "piped",
+    stderr: "piped",
+  });
+
+  const { code, stdout, stderr } = await process.output();
+  if (code !== 0) {
+    const output = new TextDecoder().decode(stdout);
+    const errorOutput = new TextDecoder().decode(stderr);
+    console.error("Error executing pkgutil:", output, errorOutput);
+    throw new Error("Failed to unpack stackql");
+  }
+};
+
+export const unzip = async (params: UnpackParams) => {
+  console.log("unzip");
+  try {
+    await decompress(params.archiveFileName, params.downloadDir);
+  } catch (error) {
+    console.log("[unzip] error:", error);
+    throw new Error("Failed to unpack stackql");
+  }
+};
diff --git a/src/stackql.ts b/src/stackql.ts
@@ -0,0 +1,36 @@
+import { assertExists } from "https://deno.land/std@0.206.0/assert/assert_exists.ts";
+import { Downloader } from "./services/downloader.ts";
+
+export class StackQL {
+  private binaryPath?: string;
+  private downloader: Downloader = new Downloader();
+  constructor() {}
+  private async initialize() {
+    this.binaryPath = await this.downloader.setupStackQL();
+  }
+
+  public async runQuery(query: string) {
+    if (!this.binaryPath) {
+      await this.initialize();
+      assertExists(this.binaryPath);
+    }
+
+    const process = new Deno.Command(this.binaryPath, {
+      args: ["exec", query], // Ensure this command is correct
+      stdout: "piped",
+      stderr: "piped",
+    });
+
+    const { code, stdout, stderr } = await process.output();
+
+    if (code === 0) {
+      const output = stdout;
+      const result = new TextDecoder().decode(output);
+      return result;
+    } else {
+      const errorOutput = stderr;
+      const errorMessage = new TextDecoder().decode(errorOutput);
+      throw new Error(`StackQL query failed: ${errorMessage}`);
+    }
+  }
+}
diff --git a/src/types/platforms.ts b/src/types/platforms.ts
@@ -0,0 +1,5 @@
+export enum SupportedOs {
+    Linux = "linux",
+    Darwin = "darwin",
+    Windows = "windows",
+}
diff --git a/src/utils.ts b/src/utils.ts
@@ -0,0 +1,17 @@
+export const fileExists = (path: string) => {
+  try {
+    Deno.statSync(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Deno.errors.NotFound) {
+      return false;
+    }
+    throw error;
+  }
+};
+
+export const chomod = async (path: string, mode: number) => {
+  if (Deno.build.os !== "windows") {
+    await Deno.chmod(path, mode);
+  }
+};
diff --git a/tests/stackql.test.ts b/tests/stackql.test.ts
@@ -0,0 +1,20 @@
+import { assertStringIncludes } from "https://deno.land/std@0.206.0/assert/mod.ts";
+import { StackQL } from "../src/stackql.ts";
+import { removeStackQLDownload } from "./utils.ts";
+
+Deno.test("StackQL runQuery - Successful Execution", async () => {
+  // Arrange
+  await removeStackQLDownload();
+  const stackQL = new StackQL();
+  const pullQuery = "REGISTRY PULL okta;";
+  const testQuery = "SHOW PROVIDERS"; // Replace with a valid query for your context
+
+  // Act
+  await stackQL.runQuery(pullQuery);
+  const result = await stackQL.runQuery(testQuery);
+
+  // Assert
+  assertStringIncludes(result, "name");
+  assertStringIncludes(result, "version");
+  assertStringIncludes(result, "okta");
+});
diff --git a/tests/utils.ts b/tests/utils.ts
@@ -0,0 +1,13 @@
+import { existsSync } from "https://deno.land/std/fs/mod.ts";
+import { join } from "https://deno.land/std@0.133.0/path/mod.ts";
+
+export const removeStackQLDownload = async () => {
+  const projectDir = Deno.cwd();
+  const stackqlPath = join(projectDir, ".stackql");
+  console.log("stackqlPath", stackqlPath);
+  console.log("existsSync(stackqlPath)", existsSync(stackqlPath));
+  if (existsSync(stackqlPath)) {
+    console.log("Removing .stackql directory");
+    await Deno.remove(stackqlPath, { recursive: true });
+  }
+};
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		export { bold } from "https://deno.land/std/fmt/colors.ts"