@indiscale/linkahead-webui-ext-map 0.5.0

package/src/utils/GenerateQueryString.test.js

@@ -0,0 +1,304 @@
+import { generateQueryString } from "./GenerateQueryString";
+
+// Mock the logger used inside generateQueryString
+jest.mock("../logging", () => ({
+  logger: {
+    error: jest.fn(),
+    warn: jest.fn(), // kept for compatibility, but should not be used in strict mode
+    info: jest.fn(),
+  },
+}));
+
+import { logger } from "../logging";
+
+describe("generateQueryString (strict + optional blocks)", () => {
+  const originalLocation = window.location;
+
+  beforeEach(() => {
+    // Mock window.location.search
+    delete window.location;
+    window.location = {
+      ...originalLocation,
+      search: "",
+    };
+
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    // Restore original window.location
+    window.location = originalLocation;
+  });
+
+  test("throws when iframeSettings is missing", () => {
+    expect(() => generateQueryString(undefined)).toThrow(
+      /formatString is required/i
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("throws when formatString is missing", () => {
+    expect(() => generateQueryString({})).toThrow(/formatString is required/i);
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("replaces a single placeholder with a single URL param (simple case)", () => {
+    window.location.search = "?authorId=14104";
+
+    const iframeSettings = {
+      formatString: "SELECT id FROM Dataset HAS AN authors=${authorId}",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    expect(out).toBe("SELECT id FROM Dataset HAS AN authors=14104");
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("supports repeated params (no CSV) and consumes them in order", () => {
+    window.location.search = "?authorId=14104&authorId=999";
+
+    const iframeSettings = {
+      formatString:
+        "SELECT id FROM Dataset HAS AN authors=${authorId} OR authors=${authorId}",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    expect(out).toBe(
+      "SELECT id FROM Dataset HAS AN authors=14104 OR authors=999"
+    );
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  // ---------------------------------------------------------------------------
+  // Optional blocks [[ ... ]]
+  //
+  // Rules (as requested):
+  // - Missing values that are ONLY needed inside optional blocks are OK.
+  // - Too many URL values (unused after processing) => throw.
+  // - Missing values for non-optional placeholders => throw.
+  //
+  // Additional rule:
+  // - If the template contains EXACTLY ONE optional block, it is repeatable and
+  //   will be emitted as many times as possible to consume all matching values.
+  // ---------------------------------------------------------------------------
+
+  test("optional block is removed when only one value is provided", () => {
+    window.location.search = "?authorId=13967";
+
+    const iframeSettings = {
+      formatString:
+        "SELECT id FROM Dataset WITH AN authors=${authorId} [[ OR authors=${authorId} ]]",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    // Optional part is removed; allow trailing whitespace differences.
+    expect(out.trim()).toBe("SELECT id FROM Dataset WITH AN authors=13967");
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("optional block is kept when two values are provided (CSV)", () => {
+    window.location.search = "?authorId=13967,14104";
+
+    const iframeSettings = {
+      formatString:
+        "SELECT id FROM Dataset WITH AN authors=${authorId} [[ OR authors=${authorId} ]]",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    // Keep optional part and fill second authorId.
+    expect(out.trim()).toBe(
+      "SELECT id FROM Dataset WITH AN authors=13967 OR authors=14104"
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("optional block is kept when two values are provided (repeated params)", () => {
+    window.location.search = "?authorId=13967&authorId=14104";
+
+    const iframeSettings = {
+      formatString:
+        "SELECT id FROM Dataset WITH AN authors=${authorId} [[ OR authors=${authorId} ]]",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    expect(out.trim()).toBe(
+      "SELECT id FROM Dataset WITH AN authors=13967 OR authors=14104"
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("repeats a single optional block to consume all provided values (strict)", () => {
+    // With the repeatable single optional block, this template can consume ALL authorIds.
+    window.location.search = "?authorId=13967,14104,14124";
+
+    const iframeSettings = {
+      formatString:
+        "SELECT id FROM Dataset WITH AN authors=${authorId} [[ OR authors=${authorId} ]]",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    expect(out.trim()).toBe(
+      "SELECT id FROM Dataset WITH AN authors=13967 OR authors=14104 OR authors=14124"
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  // ---------------------------------------------------------------------------
+  // Strict unused values behavior (non-optional templates)
+  // ---------------------------------------------------------------------------
+
+  test("supports CSV values and fills multiple occurrences in order (unused => throw)", () => {
+    window.location.search = "?authorId=14104,999,123";
+
+    const iframeSettings = {
+      formatString:
+        "SELECT id FROM Dataset HAS AN authors=${authorId} OR authors=${authorId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      'Unused values for "authorId": 123'
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("parses CSV with whitespace and semicolons (unused => throw)", () => {
+    // "14104, 999; 123" -> ["14104","999","123"] => unused => throw
+    window.location.search = "?authorId=14104,%20999;%20123";
+
+    const iframeSettings = {
+      formatString: "authors=${authorId} OR authors=${authorId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      'Unused values for "authorId": 123'
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("supports a mix of repeated params AND CSV (unused => throw)", () => {
+    window.location.search = "?authorId=14104,999&authorId=123";
+
+    const iframeSettings = {
+      formatString: "authors=${authorId} OR authors=${authorId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      'Unused values for "authorId": 123'
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("fills projectId once and repeats the single optional authorId block to consume all authorIds (CSV)", () => {
+    window.location.search = "?projectId=abc&authorId=1,2,3,4";
+
+    const iframeSettings = {
+      formatString:
+        "SELECT id, name, parent, Event.latitude, Event.longitude FROM Dataset WITH AN projectID=${projectId} AND authors=${authorId} [[ OR authors=${authorId} ]]",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    expect(out).toBe(
+      "SELECT id, name, parent, Event.latitude, Event.longitude FROM Dataset WITH AN projectID=abc AND authors=1 OR authors=2 OR authors=3 OR authors=4"
+    );
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("trims placeholder keys like ${ authorId }", () => {
+    window.location.search = "?authorId=14104&authorId=999";
+
+    const iframeSettings = {
+      formatString: "authors=${ authorId } OR authors=${authorId }",
+    };
+
+    const out = generateQueryString(iframeSettings);
+
+    expect(out).toBe("authors=14104 OR authors=999");
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("throws when not enough values are provided for repeated placeholders", () => {
+    window.location.search = "?authorId=14104";
+
+    const iframeSettings = {
+      formatString: "authors=${authorId} OR authors=${authorId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      "Missing value for placeholder ${authorId} in URL parameters"
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("keeps queues separate for different placeholder keys (authorId vs projectId)", () => {
+    window.location.search = "?authorId=1,2&projectId=abc";
+
+    const iframeSettings = {
+      formatString: "A=${authorId} B=${projectId} C=${authorId} D=${projectId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      "Missing value for placeholder ${projectId} in URL parameters"
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("throws when a placeholder key is not present in the URL at all", () => {
+    window.location.search = "?authorId=14104";
+
+    const iframeSettings = {
+      formatString: "authors=${authorId} AND project=${projectId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      "Missing value for placeholder ${projectId} in URL parameters"
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("throws when URL has no params at all", () => {
+    window.location.search = "";
+
+    const iframeSettings = {
+      formatString: "authors=${authorId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      "Missing value for placeholder ${authorId} in URL parameters"
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+
+  test("throws when there are unused values even if all placeholders were filled", () => {
+    window.location.search = "?authorId=14104,999";
+
+    const iframeSettings = {
+      formatString: "authors=${authorId}",
+    };
+
+    expect(() => generateQueryString(iframeSettings)).toThrow(
+      'Unused values for "authorId": 999'
+    );
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+});

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export const isStandaloneMode = (): boolean => {
+  return String(process.env.STANDALONE_MODE) === "true";
+};

package/standalone.config.js

@@ -0,0 +1,5 @@
+export const standaloneConfig = {
+  hidePathSwitch: true,
+  hideLayerSwitch: true,
+  hideQuerySelector: true,
+};

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["DOM", "ES2020"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+
+    "jsx": "react-jsx",
+
+    "strict": false,
+    "noImplicitAny": false,
+
+    "allowJs": true,
+    "checkJs": false,
+
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src", "types"]
+}

package/webpack.config.js

@@ -0,0 +1,193 @@
+const path = require("path");
+const HTMLWebpackPlugin = require("html-webpack-plugin");
+const webpack = require("webpack");
+const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
+
+function getEnvVariables(mode) {
+  const isDev = mode === "development";
+
+  const envVars = {
+    "process.env.LINKAHEAD_URL": JSON.stringify(
+      process.env.LINKAHEAD_URL || (isDev ? "http://localhost:8081" : "")
+    ),
+    "process.env.GRPC_API_URI": JSON.stringify(
+      process.env.GRPC_API_URI || (isDev ? "http://localhost:8081/api" : "/api")
+    ),
+  };
+
+  if (isDev) {
+    envVars["process.env.DEVELOPMENT_MODE"] = JSON.stringify(true);
+  }
+
+  return envVars;
+}
+
+module.exports = function (env = {}, argv = {}) {
+  const mode = argv.mode || "production";
+
+  const config = {
+    mode,
+    entry: path.resolve(__dirname, "./src/index.js"), // JS/TS/TSX entry
+    devtool: "source-map",
+
+    module: {
+      rules: [
+        {
+          test: /\.svg$/,
+          use: [
+            {
+              loader: "svg-url-loader",
+              options: { limit: 1000 },
+            },
+          ],
+        },
+
+        // JS/JSX/TS/TSX via Babel
+        {
+          test: /\.(js|jsx|ts|tsx)$/,
+          exclude: /node_modules/,
+          use: [
+            {
+              loader: "babel-loader",
+              options: { sourceMap: true },
+            },
+          ],
+        },
+
+        {
+          test: /\.s[ac]ss$/i,
+          use: [
+            "style-loader",
+            { loader: "css-loader", options: { sourceMap: true } },
+            { loader: "sass-loader", options: { sourceMap: true, api: "modern" } },
+          ],
+        },
+
+        {
+          test: /\.module\.css$/,
+          use: [
+            "style-loader",
+            {
+              loader: "css-loader",
+              options: { sourceMap: true, modules: true },
+            },
+          ],
+        },
+
+        {
+          test: /\.css$/i,
+          exclude: /\.module\.css$/,
+          use: [
+            "style-loader",
+            { loader: "css-loader", options: { sourceMap: true } },
+          ],
+        },
+      ],
+    },
+
+    resolve: {
+      // TS extensions added
+      extensions: [".ts", ".tsx", ".js", ".jsx"],
+      alias: {
+        react: path.resolve(__dirname, "./node_modules/react"),
+      },
+    },
+
+    output: {
+      path: path.resolve(__dirname, "./dist"),
+      filename: "linkahead-webui-ext-map.js",
+      library: "LinkAheadExtMap",
+      libraryTarget: "umd",
+    },
+
+    devServer: {
+      port: 8082,
+      static: [
+        path.resolve(__dirname, "./dist"),
+        path.resolve(__dirname, "./static"),
+      ],
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods":
+          "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+        "Access-Control-Allow-Headers":
+          "X-Requested-With, content-type, Authorization",
+      },
+    },
+
+    externals: {
+      react: {
+        commonjs: "react",
+        commonjs2: "react",
+        amd: "React",
+        root: "React",
+      },
+      reactDom: {
+        commonjs: "react-dom",
+        commonjs2: "react-dom",
+        amd: "ReactDom",
+        root: "ReactDom",
+      },
+      "@indiscale/linkahead-webui-core-components": {
+        commonjs: "@indiscale/linkahead-webui-core-components",
+        commonjs2: "@indiscale/linkahead-webui-core-components",
+        amd: "LinkAheadCoreComponents",
+        root: "LinkAheadCoreComponents",
+      },
+    },
+
+    plugins: [
+      new HTMLWebpackPlugin({
+        favicon: false,
+        showErrors: true,
+        cache: true,
+        template: path.resolve(__dirname, "public/index.html"),
+      }),
+
+      // Typecheck parallel (Babel transpiles, TS checker checks)
+      new ForkTsCheckerWebpackPlugin(),
+    ],
+  };
+
+  let env_variables = getEnvVariables(mode);
+
+  if (env["include-peer-deps"]) {
+    config.externals = {};
+
+    console.log("ENV", env_variables);
+    config.plugins.push(new webpack.DefinePlugin(env_variables));
+    config.plugins.push(
+      new webpack.ProvidePlugin({
+        process: "process/browser",
+      })
+    );
+
+    // If you're mocking in dev mode
+    config.entry = path.resolve(__dirname, "./public/mock.js");
+  }
+
+  if (env["standalone"]) {
+    console.log("Package JSON Env", env);
+    config.externals = {};
+    env_variables = {
+      ...env_variables,
+      "process.env.STANDALONE_MODE": JSON.stringify(true),
+    };
+    console.log("process.env vars in App", env_variables);
+
+    config.plugins.push(new webpack.DefinePlugin(env_variables));
+    config.plugins.push(
+      new webpack.ProvidePlugin({
+        process: "process/browser",
+      })
+    );
+
+    config.entry = path.resolve(__dirname, "./public/mock.js");
+  }
+
+  if (!env["include-peer-deps"] && !env["standalone"]) {
+    config.plugins.push(new webpack.DefinePlugin(env_variables));
+  }
+
+  return config;
+};