Feat node server side

.github/workflows/tests.yaml

@@ -11,14 +11,12 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-
     steps:
       - uses: actions/checkout@v3
       - name: Use Node.js
         uses: actions/setup-node@v3
         with:
           node-version: "16.19.0"
-
       - uses: pnpm/action-setup@v2
         name: Install pnpm
         id: pnpm-install

.vscode/settings.json

@@ -6,6 +6,9 @@
   "[typescript][typescriptreact][typescriptangular]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode"
   },
-  "eslint.workingDirectories": ["apps", "packages"],
+  "eslint.workingDirectories": [
+    "apps",
+    "packages"
+  ],
   "prettier.enable": true
-}
+}

packages/core/src/index.ts

@@ -48,6 +48,11 @@ interface PersistentStorage {
   set: (key: string, value: string) => void;
 }
 
+type flagCacheConfig = {
+  refetchFlags: boolean;
+  timeToLive: number;
+};
+
 export type AbbyConfig<
   FlagName extends string = string,
   Tests extends Record<string, ABConfig> = Record<string, ABConfig>,
@@ -60,6 +65,7 @@ export type AbbyConfig<
   flags?: Flags;
   settings?: Settings<F.NoInfer<FlagName>, Flags>;
   debug?: boolean;
+  flagCacheConfig?: flagCacheConfig;
 };
 
 export class Abby<
@@ -71,6 +77,13 @@ export class Abby<
   private log = (...args: any[]) =>
     this.config.debug ? console.log(`core.Abby`, ...args) : () => {};
 
+  private testDevtoolOverrides: Map<keyof Tests, Tests[keyof Tests]["variants"][number]> =
+    new Map();
+
+  private flagDevtoolOverrides: Map<FlagName, boolean> = new Map();
+
+  #flagTimeoutMap: Map<string, Date> = new Map();
+
   #data: LocalData<FlagName, TestName> = {
     tests: {} as any,
     flags: {} as any,
@@ -152,6 +165,10 @@ export class Abby<
         return acc;
       }, (this.config.tests ?? {}) as any),
       flags: data.flags.reduce((acc, { name, value }) => {
+        const validUntil = new Date(
+          new Date().getTime() + 1000 * 60 * (this.config.flagCacheConfig?.timeToLive ?? 1)
+        ); // flagdefault timeout is 1 minute
+        this.#flagTimeoutMap.set(name, validUntil);
         acc[name] = value;
         return acc;
       }, {} as Record<string, FlagValue>),
@@ -201,6 +218,37 @@ export class Abby<
     return this.getProjectData();
   }
 
+  /**
+   * Helper function to retrieve the time a flag is valid
+   * @param key
+   * @returns
+   */
+  getFeatureFlagTimeout<F extends FlagName>(key: F) {
+    return this.#flagTimeoutMap.get(key);
+  }
+
+  /**
+   * Helper function to check if a featureflag should be refetched
+   * @param key name of the featureflag
+   * @returns value of flag
+   */
+  getValidFlag<F extends FlagName>(key: F) {
+    const flagTime = this.#flagTimeoutMap.get(key);
+    if (!flagTime) return this.#data.flags[key];
+    const now = new Date();
+    if (flagTime.getTime() <= now.getTime()) {
+      this.refetchFlags();
+    }
+    return this.#data.flags[key];
+  }
+
+  /**
+   * helper function to make testing easier
+   */
+  refetchFlags() {
+    this.loadProjectData();
+  }
+
   /**
    * Function to get the value of a feature flag. This includes
    * the overrides from the dev tools and the local overrides if in development mode
@@ -213,7 +261,9 @@ export class Abby<
   ): FlagValueStringToType<CurrentFlag> {
     this.log(`getFeatureFlag()`, key);
 
-    const storedValue = this.#data.flags[key as unknown as FlagName];
+    const storedValue = this.config.flagCacheConfig?.refetchFlags
+      ? this.getValidFlag(key as unknown as FlagName)
+      : this.#data.flags[key as unknown as FlagName];
 
     const localOverride = this.flagOverrides?.get(key as unknown as FlagName);
 

packages/core/src/shared/http.ts

@@ -1,5 +1,6 @@
 import { ABBY_BASE_URL } from "./constants";
 import type { AbbyEventType, AbbyEvent, AbbyDataResponse } from "./index";
+
 export abstract class HttpService {
   static async getProjectData({
     projectId,
@@ -21,6 +22,7 @@ export abstract class HttpService {
       const data = (await res.json()) as AbbyDataResponse;
       return data;
     } catch (err) {
+      console.log(err);
       console.error("[ABBY]: failed to load project data, falling back to defaults");
       return null;
     }

packages/core/tests/base.test.ts

@@ -121,8 +121,146 @@ describe("Abby", () => {
 
     expect(abby.getFeatureFlag("flag1")).toBe(false);
   });
+
+  it("refetches an expired flag", async () =>{
+    const date = new Date() //current date
+    vi.setSystemTime(date)
+    const abby = new Abby({
+      projectId: "expired",
+      flags: ["flag1", "flag2"],
+      flagCacheConfig: {
+        refetchFlags: true,
+        timeToLive: 2
+      }
+    });
+    await abby.loadProjectData()
+    const expiredDate = new Date(new Date().getTime() + 1000 * 60  * 10) //date in 100 minutes
+    vi.setSystemTime(expiredDate)
+    const spy = vi.spyOn(abby, "refetchFlags")
+
+   expect(abby.getFeatureFlag("flag1")).toBeTruthy();
+    expect(abby.getFeatureFlag("flag2")).toBeFalsy();
+    expect(spy).toBeCalled()
+  })
+
+  it("non expired flag does not get refetched", async () => {
+    const date = new Date() //current date
+    vi.setSystemTime(date)
+    const abby = new Abby({
+      projectId: "expired",
+      flags: ["flag1", "flag2"],
+      flagCacheConfig: {
+        refetchFlags: true,
+        timeToLive: 2
+      }
+    });
+
+    await abby.loadProjectData();
+
+    const spy = vi.spyOn(abby, "refetchFlags")
+
+    expect(abby.getFeatureFlag("flag1")).toBeTruthy();
+    expect(abby.getFeatureFlag("flag2")).toBeFalsy();
+    expect(spy).not.toBeCalled()
+  })
+
+  it("respects the featureFlagCacheConfig refetchFlags value set to false", async () => {
+    const date = new Date() //current date
+    vi.setSystemTime(date)
+    const abby = new Abby({
+      projectId: "expired",
+      flags: ["flag1", "flag2"],
+      flagCacheConfig: {
+        refetchFlags: false,
+        timeToLive: 2
+      }
+    });
+
+    await abby.loadProjectData();
+
+    const spy = vi.spyOn(abby, "refetchFlags")
+
+    expect(abby.getFeatureFlag("flag1")).toBeTruthy();
+    expect(abby.getFeatureFlag("flag2")).toBeFalsy();
+    expect(spy).not.toBeCalled()    
+  })
+
+  it("", async () => {
+    const date = new Date() //current date
+    vi.setSystemTime(date)
+    const abby = new Abby({
+      projectId: "expired",
+      flags: ["flag1", "flag2"],
+      flagCacheConfig: {
+        refetchFlags: true,
+        timeToLive: 2
+      }
+    });
+
+    await abby.loadProjectData();
+
+    const spy = vi.spyOn(abby, "refetchFlags")
+
+    //set date to 5 Minutes in the future
+    const dateIn3Minutes = new Date(new Date().getTime() + 1000 * 60 * 5);
+    vi.setSystemTime(dateIn3Minutes)
+
+    expect(abby.getFeatureFlag("flag1")).toBeTruthy();
+    expect(abby.getFeatureFlag("flag2")).toBeFalsy();
+    expect(spy).toBeCalled()
+  })
+
+  it("respects the featureFlagCacheCOnfig expiration time", async () => {
+    const date = new Date() //current date
+    vi.setSystemTime(date)
+    const abby = new Abby({
+      projectId: "expired",
+      flags: ["flag1", "flag2"],
+      flagCacheConfig: {
+        refetchFlags: true,
+        timeToLive: 2
+      }
+    });
+
+    await abby.loadProjectData();
+
+    const spy = vi.spyOn(abby, "refetchFlags")
+
+    expect(abby.getFeatureFlag("flag1")).toBeTruthy();
+    expect(abby.getFeatureFlag("flag2")).toBeFalsy();
+    expect(spy).not.toBeCalled()
+
+    //set date to 5 Minutes in the future
+    const dateIn3Minutes = new Date(new Date().getTime() + 1000 * 60 * 5);
+    vi.setSystemTime(dateIn3Minutes)
+    expect(abby.getFeatureFlag("flag1")).toBeTruthy();
+    expect(abby.getFeatureFlag("flag2")).toBeFalsy();
+    expect(spy).toBeCalled()
+  })
+
 });
 
+it("respects the default behaviour", async () => {
+  const date = new Date() //current date
+  vi.setSystemTime(date)
+  const abby = new Abby({
+    projectId: "expired",
+    flags: ["flag1", "flag2"],
+  });
+
+  await abby.loadProjectData();
+
+  const spy = vi.spyOn(abby, "refetchFlags")
+
+    //set date to 5 Minutes in the future
+    const dateIn3Minutes = new Date(new Date().getTime() + 1000 * 60 * 5);
+    vi.setSystemTime(dateIn3Minutes)
+
+  expect(abby.getFeatureFlag("flag1")).toBeTruthy();
+  expect(abby.getFeatureFlag("flag2")).toBeFalsy();
+  expect(spy).not.toBeCalled()
+})
+
 describe("Math helpers", () => {
   it("validates weight", () => {
     const variants = ["variant1", "variant2"];

packages/core/tsup.config.ts

@@ -7,5 +7,6 @@ export default defineConfig({
   clean: true,
   sourcemap: true,
   treeshake: true,
+
   format: ["cjs", "esm"],
 });

packages/nodejs/.gitignore

@@ -0,0 +1 @@
+dist

packages/nodejs/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@tryabby/nodejs",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+    "test": "vitest ",
+    "build": "tsup src/index.ts",
+    "dev": "tsnd --respawn --transpile-only ./src/index.ts",
+    "dev:fastify": "tsnd --respawn --transpile-only ./src/fastify/index.ts",
+    "dev:debugger": "nodemon ./src/index.ts --inspect"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./express": {
+      "import": "./dist/express/abbyMiddlewareFactory.js",
+      "require": "./dist/express/abbyMiddlewareFactory.cjs",
+      "types": "./dist/abbyMiddlewareFactory.d.ts"
+    },
+    "./node": {
+      "import": "./dist/abby/createAbby.js",
+      "require": "./dist/abby/createAbby.cjs",
+      "types": "./dist/createAbby.d.ts"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@fastify/cookie": "^8.3.0",
+    "@tryabby/core": "workspace:^",
+    "express": "^4.18.2",
+    "fastify": "^4.19.2",
+    "ts-toolbelt": "^9.6.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/jest": "^29.5.1",
+    "@types/node": "^20.2.5",
+    "@types/supertest": "^2.0.12",
+    "flush-promises": "^1.0.2",
+    "install": "^0.13.0",
+    "msw": "^0.49.1",
+    "node-fetch": "^3.3.1",
+    "nodemon": "^2.0.22",
+    "supertest": "^6.3.3",
+    "ts-node": "^10.9.1",
+    "ts-node-dev": "^2.0.0",
+    "tsconfig": "workspace:*",
+    "tsup": "^6.5.0",
+    "typescript": "^5.0.4",
+    "vite": "^4.3.9",
+    "vitest": "^0.31.4"
+  }
+}

packages/nodejs/src/abby/abby.ts

@@ -0,0 +1,22 @@
+import { createAbby } from "./createAbby";
+
+export const { getFeatureFlagValue, getABTestValue } = createAbby({
+  projectId: "clfn3hs1t0002kx08x3kidi80",
+  currentEnvironment: process.env.NODE_ENV,
+  tests: {
+    "New Test3": {
+      variants: ["A", "B"],
+    },
+  },
+  flags: {
+    lol: "Boolean",
+    test3: "Boolean",
+    testAbby: "Boolean",
+  },
+  flagCacheConfig: {
+    refetchFlags: true,
+    timeToLive: 1,
+  },
+});
+
+export const abby = { getFeatureFlagValue, getABTestValue };

packages/nodejs/src/abby/contexts/requestContext.ts

@@ -0,0 +1,15 @@
+// hacky way to get request object in storage service without passing it
+import { Request } from "express";
+import { FastifyRequest } from "fastify";
+
+// type RequestType<T> = T extends Request ? Request : FastifyRequest;
+type RequestType = Request | FastifyRequest | null;
+let req: RequestType = null;
+
+export function setRequest(request: RequestType) {
+  req = request;
+}
+
+export function getRequest(): RequestType | null {
+  return req;
+}