@ogcio/building-blocks-sdk 0.0.12 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogcio/building-blocks-sdk",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/client/clients/featureFlags/index.test.ts

@@ -28,13 +28,6 @@ t.test("FeatureFlags", async (t) => {
     featureFlags = new FeatureFlags({ baseUrl, getTokenFn });
   });
 
-  t.test(
-    "should initialize unleash client with correct parameters",
-    async (t) => {
-      t.ok(featureFlags.isConnected);
-    },
-  );
-
   t.test("should return false if flag is not enabled", async (t) => {
     isEnabled = false;
     const result = await featureFlags.isFlagEnabled("test-flag");

package/src/client/clients/featureFlags/index.ts

@@ -1,45 +1,48 @@
 import type createClient from "openapi-fetch";
-import {
-  type Context,
-  InMemStorageProvider,
-  type Unleash,
-  initialize,
-} from "unleash-client";
 import type { BaseApiClientParams } from "../../../types/index.js";
 import { FEATURE_FLAGS } from "../../../types/index.js";
 import BaseClient from "../../base-client.js";
 import { DEFAULT_PROJECT_ID } from "./const.js";
 import type { components, paths } from "./schema.js";
-import { waitForConnection } from "./utils.js";
 
 class FeatureFlags extends BaseClient<paths> {
   declare client: ReturnType<typeof createClient<paths>>;
   protected serviceName = FEATURE_FLAGS;
 
-  private unleashClient: Unleash | null = null;
-  public isConnected = false;
+  private unleashConnectionOptions: {
+    url: string | undefined;
+    token: string;
+  };
 
   constructor({ baseUrl, getTokenFn }: BaseApiClientParams) {
     super({ baseUrl, getTokenFn });
     const token = getTokenFn ? (getTokenFn(FEATURE_FLAGS) as string) : "";
-    this.unleashClient = initialize({
-      appName: this.serviceName,
-      url: `${baseUrl}/api`,
-      refreshInterval: 1000,
-      customHeaders: {
-        Authorization: token,
-      },
-      storageProvider: new InMemStorageProvider(),
-    });
-    this.unleashClient.on("error", console.error);
-    this.unleashClient.on("synchronized", () => {
-      this.isConnected = true;
-    });
+    this.unleashConnectionOptions = { url: baseUrl, token };
   }
 
-  async isFlagEnabled(name: string, context?: Context) {
-    await this.waitForConnection();
-    return this.unleashClient?.isEnabled(name, context, () => false) ?? false;
+  // biome-ignore lint/suspicious/noExplicitAny: We cannot import the types from the unleash-client package
+  async isFlagEnabled(name: string, context?: any) {
+    try {
+      const { InMemStorageProvider, startUnleash } = await import(
+        "unleash-client"
+      );
+      type Context = import("unleash-client").Context;
+
+      const client = await startUnleash({
+        appName: this.serviceName,
+        url: `${this.unleashConnectionOptions.url}/api`,
+        refreshInterval: 1000,
+        customHeaders: {
+          Authorization: this.unleashConnectionOptions.token,
+        },
+        storageProvider: new InMemStorageProvider(),
+      });
+      return client.isEnabled(name, context satisfies Context, () => false);
+    } catch {
+      throw new Error(
+        "unleash-client is not installed or not configured correctly",
+      );
+    }
   }
 
   async getFeatureFlags(projectId = DEFAULT_PROJECT_ID) {
@@ -64,11 +67,6 @@ class FeatureFlags extends BaseClient<paths> {
         (reason) => this.formatError(reason),
       );
   }
-
-  private async waitForConnection(everyMs = 10) {
-    return waitForConnection(this, everyMs);
-  }
 }
 
 export default FeatureFlags;
-export type { Context as FeatureFlagsEvaluationContext };

package/src/client/clients/featureFlags/utils.test.ts

@@ -1,51 +0,0 @@
-import t from "tap";
-import { FEATURE_FLAGS } from "../../../types/index.js";
-import type FeatureFlags from "./index.js";
-import { waitForConnection } from "./utils.js";
-
-t.test("waitForConnection", async (t) => {
-  t.test("should resolve when featureFlags is connected", async (t) => {
-    const mockFeatureFlags = {
-      isConnected: false,
-    } as FeatureFlags;
-
-    // Simulate connection after 50ms
-    setTimeout(() => {
-      mockFeatureFlags.isConnected = true;
-    }, 50);
-
-    const consoles = t.capture(console, "log");
-
-    const startTime = Date.now();
-    await waitForConnection(mockFeatureFlags, 10);
-    const elapsedTime = Date.now() - startTime;
-
-    t.ok(elapsedTime >= 50);
-    t.match(consoles(), [
-      { args: [`[${FEATURE_FLAGS}] Connecting...`] },
-      { args: [/Connected in \d+ms/] },
-    ]);
-
-    t.end();
-  });
-
-  t.test("should throw an error if connection times out", async (t) => {
-    const mockFeatureFlags = {
-      isConnected: false,
-    } as FeatureFlags;
-
-    const consoleLogSpy = t.capture(console, "log");
-
-    const startTime = Date.now();
-    await t.rejects(
-      waitForConnection(mockFeatureFlags, 10, 30),
-      `[${FEATURE_FLAGS}] Connection timed out after 30ms`,
-    );
-    const elapsedTime = Date.now() - startTime;
-
-    t.ok(elapsedTime >= 30);
-    t.match(consoleLogSpy(), [{ args: [`[${FEATURE_FLAGS}] Connecting...`] }]);
-
-    t.end();
-  });
-});

package/src/client/clients/featureFlags/utils.ts

@@ -1,42 +0,0 @@
-import { FEATURE_FLAGS } from "../../../types/index.js";
-import type FeatureFlags from "./index.js";
-
-const waitForConnection = (
-  featureFlags: FeatureFlags,
-  everyMs = 10,
-  timeoutMs = 5000, // Default timeout of 5 seconds
-): Promise<void> => {
-  const fn = (
-    interval: NodeJS.Timeout,
-    timeout: NodeJS.Timeout,
-    resolve: () => void,
-    startTime: number,
-  ) => {
-    if (featureFlags.isConnected) {
-      const elapsedTime = Date.now() - startTime;
-      console.log(`[${FEATURE_FLAGS}] Connected in ${elapsedTime}ms`);
-      clearInterval(interval);
-      clearTimeout(timeout);
-      resolve();
-    }
-  };
-
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-    console.log(`[${FEATURE_FLAGS}] Connecting...`);
-    const interval = setInterval(() => {
-      fn(interval, timeout, resolve, startTime);
-    }, everyMs);
-
-    const timeout = setTimeout(() => {
-      clearInterval(interval);
-      const message = `[${FEATURE_FLAGS}] Connection timed out after ${timeoutMs}ms`;
-      console.error(message);
-      reject(new Error(message));
-    }, timeoutMs);
-
-    fn(interval, timeout, resolve, startTime);
-  });
-};
-
-export { waitForConnection };