@matdata/yasqe 5.5.0 → 5.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@matdata/yasqe",
   "description": "Yet Another SPARQL Query Editor",
-  "version": "5.5.0",
+  "version": "5.6.0",
   "main": "build/yasqe.min.js",
   "types": "build/ts/src/index.d.ts",
   "license": "MIT",

package/src/__tests__/auth-test.ts

@@ -0,0 +1,452 @@
+/**
+ * Authentication Tests
+ * Tests for Basic Auth, Bearer Token, and API Key authentication
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+
+describe("Authentication", () => {
+  describe("Basic Authentication", () => {
+    describe("Base64 Encoding", () => {
+      it("should encode credentials correctly", () => {
+        const username = "testuser";
+        const password = "testpass";
+        const credentials = `${username}:${password}`;
+        const encoded = btoa(credentials);
+        const expected = "dGVzdHVzZXI6dGVzdHBhc3M=";
+
+        expect(encoded).to.equal(expected);
+      });
+
+      it("should handle special characters", () => {
+        const username = "user@example.com";
+        const password = "p@ss:word!";
+        const credentials = `${username}:${password}`;
+        const encoded = btoa(credentials);
+
+        // Verify it can be decoded back
+        const decoded = atob(encoded);
+        expect(decoded).to.equal(credentials);
+      });
+    });
+
+    describe("Authorization Header Format", () => {
+      it("should create proper Basic auth header", () => {
+        const username = "admin";
+        const password = "secret";
+        const credentials = `${username}:${password}`;
+        const encoded = btoa(credentials);
+        const header = `Basic ${encoded}`;
+
+        expect(header).to.equal("Basic YWRtaW46c2VjcmV0");
+        expect(header).to.match(/^Basic [A-Za-z0-9+/=]+$/);
+      });
+    });
+
+    describe("Empty Credentials", () => {
+      it("should handle empty username", () => {
+        const username = "";
+        const password = "password";
+        const credentials = `${username}:${password}`;
+        const encoded = btoa(credentials);
+
+        expect(encoded).to.be.a("string");
+        expect(encoded.length).to.be.greaterThan(0);
+      });
+
+      it("should handle empty password", () => {
+        const username = "user";
+        const password = "";
+        const credentials = `${username}:${password}`;
+        const encoded = btoa(credentials);
+
+        expect(encoded).to.be.a("string");
+        expect(encoded.length).to.be.greaterThan(0);
+      });
+    });
+  });
+
+  describe("Bearer Token Authentication", () => {
+    describe("Authorization Header Format", () => {
+      it("should create proper Bearer auth header", () => {
+        const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
+        const header = `Bearer ${token}`;
+
+        expect(header).to.equal(`Bearer ${token}`);
+        expect(header).to.match(/^Bearer .+$/);
+      });
+
+      it("should handle various token formats", () => {
+        const tokens = [
+          "simple-token-123",
+          "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0",
+          "ghp_1234567890abcdefghijklmnopqrstuv",
+          "Bearer_prefix_should_not_be_duplicated",
+        ];
+
+        tokens.forEach((token) => {
+          const header = `Bearer ${token}`;
+          expect(header).to.match(/^Bearer .+$/);
+          expect(header).to.equal(`Bearer ${token}`);
+        });
+      });
+    });
+
+    describe("Token Validation", () => {
+      it("should accept non-empty tokens", () => {
+        const validTokens = [
+          "abc123",
+          "very-long-token-with-many-characters-1234567890",
+          "token.with.dots",
+          "token_with_underscores",
+        ];
+
+        validTokens.forEach((token) => {
+          expect(token).to.be.a("string");
+          expect(token.length).to.be.greaterThan(0);
+        });
+      });
+    });
+  });
+
+  describe("API Key Authentication", () => {
+    describe("Custom Header Format", () => {
+      it("should create proper X-API-Key header", () => {
+        const headerName = "X-API-Key";
+        const apiKey = "abcdef123456";
+
+        expect(headerName).to.be.a("string");
+        expect(apiKey).to.be.a("string");
+        expect(headerName.length).to.be.greaterThan(0);
+        expect(apiKey.length).to.be.greaterThan(0);
+      });
+
+      it("should support various header names", () => {
+        const headers = [
+          { name: "X-API-Key", value: "key123" },
+          { name: "X-Auth-Token", value: "token456" },
+          { name: "API-Key", value: "apikey789" },
+          { name: "Authorization", value: "ApiKey xyz" },
+          { name: "X-Custom-Auth", value: "custom-value" },
+        ];
+
+        headers.forEach((header) => {
+          expect(header.name).to.be.a("string");
+          expect(header.value).to.be.a("string");
+          expect(header.name.length).to.be.greaterThan(0);
+          expect(header.value.length).to.be.greaterThan(0);
+        });
+      });
+    });
+
+    describe("API Key Validation", () => {
+      it("should accept alphanumeric keys", () => {
+        const validKeys = ["abc123", "API-KEY-12345", "key_with_underscores", "key.with.dots", "UPPERCASE_KEY"];
+
+        validKeys.forEach((key) => {
+          expect(key).to.be.a("string");
+          expect(key.length).to.be.greaterThan(0);
+        });
+      });
+    });
+  });
+
+  describe("Authentication Priority", () => {
+    it("should prioritize Bearer token over Basic auth", () => {
+      // When both are present, Bearer should be used (tested in implementation)
+      const basicAuthHeader = "Basic dGVzdDp0ZXN0";
+      const bearerAuthHeader = "Bearer token123";
+
+      expect(bearerAuthHeader).to.not.equal(basicAuthHeader);
+      expect(bearerAuthHeader).to.match(/^Bearer .+$/);
+    });
+
+    it("should allow API Key to coexist with Authorization header", () => {
+      // API Key uses custom header, so it doesn't conflict
+      const authHeader = "Authorization";
+      const apiKeyHeader = "X-API-Key";
+
+      expect(authHeader).to.not.equal(apiKeyHeader);
+    });
+  });
+
+  describe("Authentication Implementation Tests", () => {
+    describe("Bearer Token Authentication", () => {
+      it("should create correct header format with token", () => {
+        const token = "test-token-123";
+        const header = `Bearer ${token}`;
+
+        expect(header).to.equal("Bearer test-token-123");
+        expect(header).to.match(/^Bearer .+$/);
+      });
+
+      it("should handle whitespace trimming in token", () => {
+        const token = "  test-token-456  ";
+        const trimmedToken = token.trim();
+        const header = `Bearer ${trimmedToken}`;
+
+        expect(header).to.equal("Bearer test-token-456");
+        expect(header).to.not.include("  ");
+        expect(trimmedToken).to.equal("test-token-456");
+      });
+
+      it("should validate empty token", () => {
+        const token = "";
+        const trimmedToken = token.trim();
+        const isValid = trimmedToken.length > 0;
+
+        expect(isValid).to.be.false;
+      });
+
+      it("should validate whitespace-only token", () => {
+        const token = "   ";
+        const trimmedToken = token.trim();
+        const isValid = trimmedToken.length > 0;
+
+        expect(isValid).to.be.false;
+      });
+
+      it("should validate non-empty token", () => {
+        const token = "valid-token";
+        const trimmedToken = token.trim();
+        const isValid = trimmedToken.length > 0;
+
+        expect(isValid).to.be.true;
+      });
+    });
+
+    describe("API Key Authentication", () => {
+      it("should create correct custom header with API key", () => {
+        const headerName = "X-API-Key";
+        const apiKey = "my-api-key-123";
+        const headers: Record<string, string> = {};
+        headers[headerName] = apiKey;
+
+        expect(headers["X-API-Key"]).to.equal("my-api-key-123");
+      });
+
+      it("should handle whitespace trimming in header name and API key", () => {
+        const headerName = "  X-Custom-Key  ";
+        const apiKey = "  key-value  ";
+        const trimmedHeaderName = headerName.trim();
+        const trimmedApiKey = apiKey.trim();
+
+        const headers: Record<string, string> = {};
+        headers[trimmedHeaderName] = trimmedApiKey;
+
+        expect(headers["X-Custom-Key"]).to.equal("key-value");
+        expect(trimmedHeaderName).to.equal("X-Custom-Key");
+        expect(trimmedApiKey).to.equal("key-value");
+      });
+
+      it("should validate empty API key", () => {
+        const apiKey = "";
+        const trimmedApiKey = apiKey.trim();
+        const isValid = trimmedApiKey.length > 0;
+
+        expect(isValid).to.be.false;
+      });
+
+      it("should validate empty header name", () => {
+        const headerName = "";
+        const trimmedHeaderName = headerName.trim();
+        const isValid = trimmedHeaderName.length > 0;
+
+        expect(isValid).to.be.false;
+      });
+
+      it("should validate whitespace-only header name and key", () => {
+        const headerName = "   ";
+        const apiKey = "  ";
+        const isHeaderNameValid = headerName.trim().length > 0;
+        const isApiKeyValid = apiKey.trim().length > 0;
+
+        expect(isHeaderNameValid).to.be.false;
+        expect(isApiKeyValid).to.be.false;
+      });
+
+      it("should support various header names", () => {
+        const headerNames = ["X-API-Key", "X-Auth-Token", "API-Key", "X-Custom-Auth"];
+
+        headerNames.forEach((headerName) => {
+          const headers: Record<string, string> = {};
+          headers[headerName] = "test-key";
+          expect(headers[headerName]).to.equal("test-key");
+        });
+      });
+    });
+
+    describe("Basic Authentication", () => {
+      it("should create correct Basic auth header format", () => {
+        const username = "testuser";
+        const password = "testpass";
+        const credentials = `${username}:${password}`;
+        const encoded = btoa(credentials);
+        const header = `Basic ${encoded}`;
+
+        expect(header).to.match(/^Basic [A-Za-z0-9+/=]+$/);
+        expect(header).to.equal("Basic dGVzdHVzZXI6dGVzdHBhc3M=");
+      });
+
+      it("should validate credentials are provided", () => {
+        const username = "user";
+        const password = "pass";
+        const hasCredentials = !!(username && password);
+
+        expect(hasCredentials).to.be.true;
+      });
+
+      it("should detect missing credentials", () => {
+        const username = "";
+        const password = "pass";
+        const hasCredentials = !!(username && password);
+
+        expect(hasCredentials).to.be.false;
+      });
+    });
+
+    describe("Authentication Priority and Collision Detection", () => {
+      it("should verify Bearer takes priority over Basic by checking Authorization header usage", () => {
+        // Both Bearer and Basic use Authorization header, so only one can be used
+        const bearerToken = "bearer-token";
+        const bearerHeader = `Bearer ${bearerToken}`;
+        const basicHeader = "Basic " + btoa("user:pass");
+
+        // Verify they're different formats
+        expect(bearerHeader).to.not.equal(basicHeader);
+        expect(bearerHeader).to.include("Bearer");
+        expect(basicHeader).to.include("Basic");
+
+        // In implementation, Bearer is checked first and sets Authorization
+        // If Authorization exists, Basic won't overwrite it
+      });
+
+      it("should verify API Key can coexist with Bearer token using different headers", () => {
+        // API Key uses custom header, Bearer uses Authorization
+        const authorizationHeader = "Authorization";
+        const apiKeyHeader = "X-API-Key";
+
+        expect(authorizationHeader).to.not.equal(apiKeyHeader);
+        // These are different headers, so they can both be set
+      });
+
+      it("should verify API Key can coexist with Basic auth using different headers", () => {
+        // API Key uses custom header, Basic uses Authorization
+        const authorizationHeader = "Authorization";
+        const apiKeyHeader = "X-API-Key";
+
+        expect(authorizationHeader).to.not.equal(apiKeyHeader);
+        // These are different headers, so they can both be set
+      });
+
+      it("should validate header collision detection logic", () => {
+        const headers: Record<string, string> = { Authorization: "existing-value" };
+        const headerExists = headers["Authorization"] !== undefined;
+
+        expect(headerExists).to.be.true;
+
+        // Implementation should skip setting auth if header already exists
+        if (headerExists) {
+          // Don't overwrite
+          expect(headers["Authorization"]).to.equal("existing-value");
+        }
+      });
+
+      it("should validate custom header collision detection", () => {
+        const headers: Record<string, string> = { "X-API-Key": "existing-key" };
+        const headerExists = headers["X-API-Key"] !== undefined;
+
+        expect(headerExists).to.be.true;
+
+        // Implementation should skip setting API Key if header already exists
+        if (headerExists) {
+          // Don't overwrite
+          expect(headers["X-API-Key"]).to.equal("existing-key");
+        }
+      });
+    });
+
+    describe("Error Handling and Edge Cases", () => {
+      it("should validate undefined auth config handling", () => {
+        const bearerAuth = undefined;
+        const apiKeyAuth = undefined;
+
+        expect(bearerAuth).to.be.undefined;
+        expect(apiKeyAuth).to.be.undefined;
+
+        // Implementation should handle undefined gracefully
+      });
+
+      it("should validate null token handling", () => {
+        const token: any = null;
+        const isValid = !!(token && token.trim && token.trim().length > 0);
+
+        expect(isValid).to.be.false;
+      });
+
+      it("should validate function-based config pattern", () => {
+        // Verify that function returning config works
+        const getBearerConfig = () => ({ token: "dynamic-token" });
+        const getApiKeyConfig = () => ({ headerName: "X-Key", apiKey: "dynamic-key" });
+
+        const bearerConfig = getBearerConfig();
+        const apiKeyConfig = getApiKeyConfig();
+
+        expect(bearerConfig.token).to.equal("dynamic-token");
+        expect(apiKeyConfig.headerName).to.equal("X-Key");
+        expect(apiKeyConfig.apiKey).to.equal("dynamic-key");
+      });
+
+      it("should validate error handling in function-based config", () => {
+        const getAuthConfigWithError = () => {
+          throw new Error("Config error");
+        };
+
+        try {
+          getAuthConfigWithError();
+          // Should not reach here
+          expect.fail("Should have thrown error");
+        } catch (error) {
+          // Implementation should catch and handle this gracefully
+          expect(error).to.be.instanceOf(Error);
+        }
+      });
+    });
+
+    describe("Trimming Behavior Verification", () => {
+      it("should verify trimmed values are used in headers not originals", () => {
+        const originalToken = "  token-with-spaces  ";
+        const trimmedToken = originalToken.trim();
+
+        // The implementation should use trimmed token
+        const header = `Bearer ${trimmedToken}`;
+
+        expect(header).to.equal("Bearer token-with-spaces");
+        expect(header).to.not.include("  ");
+      });
+
+      it("should verify trimmed header name is used not original", () => {
+        const originalHeaderName = "  X-API-Key  ";
+        const trimmedHeaderName = originalHeaderName.trim();
+
+        const headers: Record<string, string> = {};
+        headers[trimmedHeaderName] = "value";
+
+        expect(headers["X-API-Key"]).to.equal("value");
+        expect(headers["  X-API-Key  "]).to.be.undefined;
+      });
+
+      it("should verify trimmed API key is used not original", () => {
+        const originalKey = "  key-value  ";
+        const trimmedKey = originalKey.trim();
+
+        const headers: Record<string, string> = {};
+        headers["X-API-Key"] = trimmedKey;
+
+        expect(headers["X-API-Key"]).to.equal("key-value");
+        expect(headers["X-API-Key"]).to.not.include("  ");
+      });
+    });
+  });
+});

package/src/defaults.ts

@@ -175,6 +175,8 @@ SELECT * WHERE {
     withCredentials: false,
     adjustQueryBeforeRequest: false,
     basicAuth: undefined,
+    bearerAuth: undefined,
+    apiKeyAuth: undefined,
   };
   return { ...config, requestConfig };
 }

package/src/index.ts

@@ -442,11 +442,8 @@ export class Yasqe extends CodeMirror {
   }
 
   private drawSnippetsBar() {
-    // Check if snippets bar should be shown
-    const shouldShow =
-      this.config.showSnippetsBar &&
-      (this.persistentConfig?.showSnippetsBar === undefined || this.persistentConfig.showSnippetsBar) &&
-      this.config.snippets.length > 0;
+    // Check if snippets bar should be shown (now using global config only)
+    const shouldShow = this.config.showSnippetsBar && this.config.snippets.length > 0;
 
     if (!shouldShow) {
       // Remove existing bar if present
@@ -1126,25 +1123,17 @@ export class Yasqe extends CodeMirror {
    * Snippets management
    */
   public setSnippetsBarVisible(visible: boolean) {
-    if (!this.persistentConfig) {
-      this.persistentConfig = {
-        query: this.getValue(),
-        editorHeight: this.config.editorHeight,
-        showSnippetsBar: visible,
-      };
-    } else {
-      this.persistentConfig.showSnippetsBar = visible;
-    }
-    this.saveQuery();
+    // Update config and redraw
+    this.config.showSnippetsBar = visible;
     this.drawSnippetsBar();
   }
 
   public getSnippetsBarVisible(): boolean {
-    return (
-      this.config.showSnippetsBar &&
-      (this.persistentConfig?.showSnippetsBar === undefined || this.persistentConfig.showSnippetsBar) &&
-      this.config.snippets.length > 0
-    );
+    return this.config.showSnippetsBar && this.config.snippets.length > 0;
+  }
+
+  public refreshSnippetsBar() {
+    this.drawSnippetsBar();
   }
 
   /**
@@ -1365,6 +1354,14 @@ export interface BasicAuthConfig {
   username: string;
   password: string;
 }
+export interface BearerAuthConfig {
+  token: string;
+}
+export interface ApiKeyAuthConfig {
+  headerName: string;
+  apiKey: string;
+}
+export type AuthConfig = BasicAuthConfig | BearerAuthConfig | ApiKeyAuthConfig;
 export interface RequestConfig<Y> {
   queryArgument: string | ((yasqe: Y) => string) | undefined;
   endpoint: string | ((yasqe: Y) => string);
@@ -1379,6 +1376,8 @@ export interface RequestConfig<Y> {
   withCredentials: boolean | ((yasqe: Y) => boolean);
   adjustQueryBeforeRequest: ((yasqe: Y) => string) | false;
   basicAuth: BasicAuthConfig | ((yasqe: Y) => BasicAuthConfig | undefined) | undefined;
+  bearerAuth: BearerAuthConfig | ((yasqe: Y) => BearerAuthConfig | undefined) | undefined;
+  apiKeyAuth: ApiKeyAuthConfig | ((yasqe: Y) => ApiKeyAuthConfig | undefined) | undefined;
 }
 export type PlainRequestConfig = {
   [K in keyof RequestConfig<any>]: Exclude<RequestConfig<any>[K], Function>;
@@ -1439,7 +1438,6 @@ export interface PersistentConfig {
   editorHeight: string;
   formatterType?: "sparql-formatter" | "legacy"; // Which formatter to use
   autoformatOnQuery?: boolean; // Auto-format query on execution
-  showSnippetsBar?: boolean; // User preference for snippets bar visibility
 }
 // export var _Yasqe = _Yasqe;