@ogcio/building-blocks-sdk 0.0.10 → 0.0.11

package/README.md

@@ -162,3 +162,58 @@ To fix the formatting and linting errors run:
 npm run fix:formatting
 npm run fix:linting
 ```
+
+### Testing
+
+The project uses `vitest` for testing. To run the tests:
+
+```bash
+npm test
+```
+
+## Feature Flags
+
+### Pre-requisites
+For local development, you should have the Feature Flags service running.
+Refer to the [unleash](https://github.com/ogcio/unleash) repository for instructions on how to run the service.
+You can also find examples on how to run Unleash with different auth strategies in the [unleash-examples](https://github.com/ogcio/unleash-examples/tree/feat/oidc-auth) repository.
+
+### Usage
+
+To use the Feature Flags service you will need:
+
+- `baseUrl` A valid `Feature Flags` service URL. Use `http://localhost:4242` for local development.
+- `token` A valid `Feature Flags` service token. Refer to [Client Tokens](https://docs.getunleash.io/reference/api-tokens-and-client-keys#client-tokens)
+for instructions on how to generate a token.
+
+Initialize the SDK with the `featureFlags` service:
+
+```typescript
+const sdk = getBuildingBlockSDK({
+  services: {
+    featureFlags: {
+      baseUrl,
+    },
+  },
+  getTokenFn: () => token,
+});
+```
+
+Use the `featureFlags` service to check if a feature is enabled (without any context):
+
+```typescript
+const isEnabled = await sdk.featureFlags.isFlagEnabled("feature-name");
+```
+
+Use the `featureFlags` service to check if a feature is enabled with context:
+
+```typescript
+const isEnabled = await sdk.featureFlags.isFlagEnabled("feature-name", {
+  userId: "userId",
+  sessionId: "sessionId",
+});
+```
+
+*Note*: The `isFlagEnabled` is asynchronous because if the client is not connected yet,
+it will wait for the connection to be established before checking the flag.
+Once the client is connected, the flag will be checked synchronously.

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@ogcio/building-blocks-sdk",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "TAP_RCFILE=tap.yml tap --reporter junit --reporter-file results.xml",
+    "test:local": "TAP_RCFILE=tap.yml tap",
+    "test:e2e": "cd ./e2e && bru run --env local",
+    "test:smoke:e2e": "echo \"Error: no test specified\" && exit 0",
+    "test:regression:e2e": "cd ./e2e && mkdir -p test-results && bru run --env dev --output ./test-results/results.xml --format junit",
     "build": "rm -rf dist && tsc -p tsconfig.prod.json",
     "clients:update": "node --import=tsx src/cli/index.ts clients:update -c src/clients-configurations/clients-configuration.json",
     "clients:outdated": "node --import=tsx src/cli/index.ts clients:outdated -c src/clients-configurations/clients-configuration.json",
@@ -32,15 +36,22 @@
     "@types/http-errors": "^2.0.4",
     "commitlint": "^19.5.0",
     "husky": "^9.1.6",
+    "tap": "^21.0.1",
+    "testdouble": "^3.20.2",
+    "vitest": "^2.1.3",
     "tsx": "^4.19.2",
     "typescript": "^5.6.3"
   },
   "peerDependencies": {
-    "@logto/node": "2.5.5"
+    "@logto/node": "2.5.5",
+    "unleash-client": "^6.1.1"
   },
   "peerDependenciesMeta": {
     "@logto/node": {
       "optional": true
+    },
+    "unleash-client": {
+      "optional": true
     }
   },
   "keywords": [],

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

@@ -0,0 +1,3 @@
+const DEFAULT_PROJECT_ID = "default";
+
+export { DEFAULT_PROJECT_ID };

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

@@ -0,0 +1,63 @@
+import t from "tap";
+import * as td from "testdouble";
+import FeatureFlags from "./index.js";
+
+let isEnabled = true;
+
+await td.replaceEsm("unleash-client", {
+  initialize: td.func(),
+  InMemStorageProvider: td.func(),
+});
+
+let fetchResponse = {};
+
+global.fetch = async () =>
+  ({
+    ok: true,
+    status: 200,
+    json: async () => fetchResponse,
+    headers: new Headers(),
+  }) as Response;
+
+t.test("FeatureFlags", async (t) => {
+  const baseUrl = "http://fakehost";
+  const getTokenFn = () => "test-token";
+  let featureFlags: FeatureFlags;
+
+  t.beforeEach(async () => {
+    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");
+    t.equal(result, isEnabled);
+  });
+
+  t.test("should return true if flag is enabled", async (t) => {
+    isEnabled = true;
+    const result = await featureFlags.isFlagEnabled("test-flag");
+    t.equal(result, isEnabled);
+  });
+
+  t.test(
+    "should call GET method on client when getFeatureFlags is called",
+    async () => {
+      fetchResponse = { data: { features: [] }, metadata: {} };
+      const result = await featureFlags.getFeatureFlags();
+      t.ok(result);
+      t.same(result, {
+        data: [],
+        metadata: {},
+        error: null,
+      });
+    },
+  );
+});

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

@@ -0,0 +1,74 @@
+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;
+
+  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;
+    });
+  }
+
+  async isFlagEnabled(name: string, context?: Context) {
+    await this.waitForConnection();
+    return this.unleashClient?.isEnabled(name, context, () => false) ?? false;
+  }
+
+  async getFeatureFlags(projectId = DEFAULT_PROJECT_ID) {
+    return await this.client
+      .GET("/api/admin/projects/{projectId}/features", {
+        params: {
+          path: {
+            projectId,
+          },
+        },
+      })
+      .then(
+        (response) => {
+          // @ts-expect-error: TODO: fix me
+          const { data, metadata, error } = this.formatResponse(response);
+          return {
+            data: data?.features as components["schemas"]["projectFeatureSchema"][],
+            metadata,
+            error,
+          };
+        },
+        (reason) => this.formatError(reason),
+      );
+  }
+
+  private async waitForConnection(everyMs = 10) {
+    return waitForConnection(this, everyMs);
+  }
+}
+
+export default FeatureFlags;
+export type { Context as FeatureFlagsEvaluationContext };