@infaris/flags 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Infaris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,105 @@
-# Temporary Holding Version
+# @infaris/flags
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Edge Config and feature flags for **Hosting by Infaris**: the EU alternative to Vercel Edge Config and Flags, and a
+light LaunchDarkly. Bundled shared error contract; Node 18+, Bun, Deno, Cloudflare Workers and Vercel's edge runtime.
+
+- **Server** (`@infaris/flags`): the whole snapshot in memory, evaluated locally (no request per flag), refreshed when
+  Hosting pushes a new version and at most every 30 seconds otherwise.
+- **Browser** (`@infaris/flags/client`) and **React** (`@infaris/flags/react`): only flags and values marked
+  *client-visible*, already evaluated by Hosting. Targeting rules never reach the browser.
+- **Vercel flags SDK** (`@infaris/flags/adapter`): `flag({ key, adapter: infarisAdapter() })`.
+
+## Set up
+
+```bash
+infaris-guard hosting config enable --site shop.example.nl   # writes INFARIS_FLAGS_* on the site
+infaris-guard hosting flags set new-checkout --env production --on --rollout 10
+```
+
+Hosting sets four variables on the site (the next deploy has them):
+
+| Variable | Where | What |
+| --- | --- | --- |
+| `INFARIS_FLAGS_URL`, `INFARIS_FLAGS_SECRET_KEY` | server only | the snapshot, also server-only flags |
+| `NEXT_PUBLIC_INFARIS_FLAGS_URL`, `NEXT_PUBLIC_INFARIS_FLAGS_KEY` | browser | client-visible flags only |
+
+A site without environment variables (own server, Webbie) gets its keys once with
+`infaris-guard hosting config keys rotate`.
+
+## Server
+
+```ts
+import { createFlagsClient } from '@infaris/flags';
+
+const flags = createFlagsClient(); // reads INFARIS_FLAGS_URL and INFARIS_FLAGS_SECRET_KEY
+
+if (await flags.getFlag('new-checkout', { userId: user.id, email: user.email, org: user.orgId, role: user.role })) {
+  // ...
+}
+const banner = await flags.getConfig('banner', { text: '' });
+```
+
+The environment comes from `INFARIS_ENV`, `VERCEL_ENV` or `NODE_ENV` (`production`, `preview`, `development`).
+
+## Browser and React
+
+```tsx
+import { createBrowserFlags } from '@infaris/flags/client';
+import { FlagsProvider, useFlag } from '@infaris/flags/react';
+
+const flags = createBrowserFlags({ getAccessToken: () => session?.access_token });
+
+export function App() {
+  return <FlagsProvider client={flags}><Checkout /></FlagsProvider>;
+}
+
+function Checkout() {
+  return useFlag('new-checkout') ? <NewCheckout /> : <OldCheckout />;
+}
+```
+
+Targeting on Infaris Auth claims (e-mail address, `app_metadata.org`, `app_metadata.role`) needs the access token;
+Hosting verifies it. Without a token only the percentage rollout applies, on `anonymousId`.
+
+## Vercel flags SDK
+
+```ts
+import { flag } from 'flags/next';
+import { infarisAdapter } from '@infaris/flags/adapter';
+
+export const newCheckout = flag<boolean>({
+  key: 'new-checkout',
+  adapter: infarisAdapter(),
+  identify: async () => ({ user: { id: session.user.id, email: session.user.email } }),
+});
+```
+
+## How a flag is evaluated
+
+1. Kill switch on: `false` everywhere.
+2. Off in this environment: `false`.
+3. Rules, in order (the first match wins): `userId`, `email`, `emailDomain`, `org`, `role` with `in`, `not_in` or
+   `ends_with`.
+4. Rollout: `null` or 100% is everyone; otherwise that share of users, sticky per user id
+   (`fnv1a32("<flag>:<userId>") % 10000`). Someone in at 10% stays in at 25%.
+
+The same code runs in Hosting and in this package, so the server, the browser and the Guard app agree.
+
+## Runtime and modules
+
+Node.js 22.12 or newer, Bun, modern browsers and edge runtimes with `fetch`. ES modules and CommonJS are both supported. Server credentials must stay on the server.
+
+Licensed under MIT. See [LICENSE](./LICENSE).
+
+All API errors extend `InfarisError` (also exported here), with `code`, `status` and `message`. Existing error classes remain supported.
+
+## Client factory
+
+Every Hosting SDK exports `createClient(options)`. Existing named factories and positional Auth/Data arguments remain available.
+
+```ts
+import { createClient } from '@infaris/flags';
+const client = createClient();
+```
+
+The common error implementation is bundled; installing this SDK does not require a private workspace package.

package/dist/adapter.cjs

@@ -0,0 +1,388 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../hosting-sdk/dist/index.cjs
+var require_dist = __commonJS({
+  "../hosting-sdk/dist/index.cjs"(exports2, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      InfarisError: () => InfarisError2
+    });
+    module2.exports = __toCommonJS2(index_exports);
+    var errorBrand = /* @__PURE__ */ Symbol.for("@infaris/hosting-sdk/error");
+    var InfarisError2 = class _InfarisError extends Error {
+      // SDK bundles contain separate copies; catch the shared base across bundles and module formats.
+      static [Symbol.hasInstance](value) {
+        if (this !== _InfarisError) return Function.prototype[Symbol.hasInstance].call(this, value);
+        return value instanceof Error && errorBrand in value && value[errorBrand] === true;
+      }
+      code;
+      status;
+      constructor(message, code = "sdk_error", status = null) {
+        super(message);
+        Object.defineProperty(this, errorBrand, { value: true });
+        this.name = "InfarisError";
+        this.code = code;
+        this.status = status;
+      }
+    };
+  }
+});
+
+// src/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  contextFromEntities: () => contextFromEntities,
+  createInfarisAdapter: () => createInfarisAdapter,
+  infarisAdapter: () => infarisAdapter
+});
+module.exports = __toCommonJS(adapter_exports);
+
+// src/evaluate.ts
+function fnv1a32(input) {
+  const bytes = new TextEncoder().encode(input);
+  let hash = 2166136261;
+  for (const byte of bytes) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash >>> 0;
+}
+function rolloutBucket(flagKey, userId) {
+  return fnv1a32(`${flagKey}:${userId}`) % 1e4;
+}
+function attributeOf(ctx, attribute) {
+  switch (attribute) {
+    case "email":
+      return ctx.email ? ctx.email.trim().toLowerCase() : void 0;
+    case "emailDomain": {
+      const at = ctx.email ? ctx.email.lastIndexOf("@") : -1;
+      return at >= 0 ? ctx.email.slice(at + 1).trim().toLowerCase() : void 0;
+    }
+    case "userId":
+      return ctx.userId || void 0;
+    case "org":
+      return ctx.org || void 0;
+    case "role":
+      return ctx.role || void 0;
+  }
+}
+var caseless = (attribute) => attribute === "email" || attribute === "emailDomain";
+function ruleMatches(rule, ctx) {
+  const actual = attributeOf(ctx, rule.attribute);
+  if (actual === void 0) return false;
+  const values = caseless(rule.attribute) ? rule.values.map((v) => v.trim().toLowerCase()) : rule.values;
+  switch (rule.operator) {
+    case "in":
+      return values.includes(actual);
+    case "not_in":
+      return !values.includes(actual);
+    case "ends_with":
+      return values.some((v) => v.length > 0 && actual.endsWith(v));
+  }
+}
+function evaluateFlag(flag, environment, ctx) {
+  if (flag.killed) return { value: false, reason: "killed" };
+  const env = flag.environments[environment];
+  if (!env || !env.enabled) return { value: false, reason: "off" };
+  for (const rule of env.rules) {
+    if (ruleMatches(rule, ctx)) return { value: rule.serve, reason: "rule" };
+  }
+  if (env.rollout === null || env.rollout >= 100) return { value: true, reason: "fallthrough" };
+  if (env.rollout <= 0) return { value: false, reason: "rollout" };
+  if (!ctx.userId) return { value: false, reason: "no_user" };
+  return { value: rolloutBucket(flag.key, ctx.userId) < Math.round(env.rollout * 100), reason: "rollout" };
+}
+
+// src/types.ts
+var import_hosting_sdk = __toESM(require_dist(), 1);
+var FlagsError = class extends import_hosting_sdk.InfarisError {
+  constructor(message, status, code) {
+    super(message, code, status);
+    this.status = status;
+    this.code = code;
+    this.name = "FlagsError";
+  }
+  status;
+  code;
+};
+function detectEnvironment(env = readEnv()) {
+  const raw = (env?.INFARIS_ENV ?? env?.VERCEL_ENV ?? env?.NODE_ENV ?? "production").toLowerCase();
+  if (raw === "preview") return "preview";
+  if (raw === "development" || raw === "dev" || raw === "test" || raw === "local") return "development";
+  return "production";
+}
+function readEnv() {
+  const p = globalThis.process;
+  return p?.env;
+}
+function parseSseVersions(buffer) {
+  const versions = [];
+  const events = buffer.split(/\r?\n\r?\n/);
+  const rest = events.pop() ?? "";
+  for (const event of events) {
+    let name = "message";
+    let data = "";
+    for (const line of event.split(/\r?\n/)) {
+      if (line.startsWith("event:")) name = line.slice(6).trim();
+      else if (line.startsWith("data:")) data += line.slice(5).trim();
+    }
+    if (name !== "version" || !data) continue;
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed.version === "number") versions.push(parsed.version);
+    } catch {
+    }
+  }
+  return { versions, rest };
+}
+function trimSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+
+// src/server.ts
+var FlagsClient = class {
+  environment;
+  url;
+  key;
+  fetchImpl;
+  refreshMs;
+  onError;
+  snapshot = null;
+  etag = null;
+  checkedAt = 0;
+  loading = null;
+  streamAbort = null;
+  streaming = false;
+  closed = false;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    const env = readEnv();
+    const url = options.url ?? env?.INFARIS_FLAGS_URL;
+    const key = options.secretKey ?? env?.INFARIS_FLAGS_SECRET_KEY;
+    if (!url) throw new FlagsError("Missing url (set INFARIS_FLAGS_URL)", null, "missing_url");
+    if (!key) throw new FlagsError("Missing secret key (set INFARIS_FLAGS_SECRET_KEY)", null, "missing_key");
+    if (!key.startsWith("ifr_fsk_")) throw new FlagsError("The server client needs the secret key (ifr_fsk_\u2026)", null, "wrong_key");
+    this.url = trimSlash(url);
+    this.key = key;
+    this.environment = options.environment ?? detectEnvironment(env);
+    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    this.refreshMs = options.refreshIntervalMs ?? 3e4;
+    this.onError = options.onError ?? (() => void 0);
+    if (options.stream ?? true) this.streaming = true;
+  }
+  /** The version in memory (0 before the first load). */
+  get version() {
+    return this.snapshot?.version ?? 0;
+  }
+  /** Loads the first snapshot (and opens the stream). Every getter calls it, so calling it yourself is optional. */
+  async ready() {
+    if (this.snapshot) {
+      if (Date.now() - this.checkedAt > this.refreshMs && !this.loading) void this.refresh().catch(this.onError);
+      return;
+    }
+    await this.refresh();
+    if (this.streaming && !this.streamAbort) this.openStream();
+  }
+  /** Fetches the snapshot when it changed (`If-None-Match`). */
+  async refresh() {
+    if (this.loading) return this.loading;
+    this.loading = (async () => {
+      try {
+        const res = await this.fetchImpl(`${this.url}/snapshot`, {
+          headers: { authorization: `Bearer ${this.key}`, ...this.etag ? { "if-none-match": this.etag } : {} }
+        });
+        this.checkedAt = Date.now();
+        if (res.status === 304 && this.snapshot) return;
+        if (!res.ok) throw new FlagsError(`Flags snapshot failed (HTTP ${res.status})`, res.status, "http_error");
+        const next = await res.json();
+        const changed = next.version !== this.snapshot?.version;
+        this.snapshot = next;
+        this.etag = res.headers.get("etag");
+        if (changed) for (const listener of this.listeners) listener(next.version);
+      } finally {
+        this.loading = null;
+      }
+    })();
+    return this.loading;
+  }
+  /** The value of a flag for this user; `defaultValue` for an unknown flag or before Hosting answered once. */
+  async getFlag(key, context = {}, defaultValue = false) {
+    try {
+      await this.ready();
+    } catch (error) {
+      this.onError(error);
+      if (!this.snapshot) return defaultValue;
+    }
+    return this.getFlagSync(key, context, defaultValue);
+  }
+  /** From memory only (no request): for hot paths once `ready()` resolved. */
+  getFlagSync(key, context = {}, defaultValue = false) {
+    const result = this.evaluate(key, context);
+    return result ? result.value : defaultValue;
+  }
+  /** Value and reason, or null for an unknown flag. */
+  evaluate(key, context = {}) {
+    const flag = this.snapshot?.flags.find((f) => f.key === key);
+    return flag ? evaluateFlag(flag, this.environment, context) : null;
+  }
+  /** Every flag for this user. */
+  async getAll(context = {}) {
+    await this.ready().catch(this.onError);
+    const out = {};
+    for (const flag of this.snapshot?.flags ?? []) out[flag.key] = evaluateFlag(flag, this.environment, context).value;
+    return out;
+  }
+  /** An Edge Config value. */
+  async getConfig(key, defaultValue) {
+    await this.ready().catch(this.onError);
+    const items = this.snapshot?.items ?? {};
+    return Object.prototype.hasOwnProperty.call(items, key) ? items[key] : defaultValue;
+  }
+  /** Called with the new version after every change that reached this process. */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  close() {
+    this.closed = true;
+    this.streamAbort?.abort();
+    this.streamAbort = null;
+  }
+  openStream() {
+    if (this.closed) return;
+    const abort = new AbortController();
+    this.streamAbort = abort;
+    void (async () => {
+      let delay = 1e3;
+      while (!abort.signal.aborted) {
+        try {
+          const res = await this.fetchImpl(`${this.url}/stream`, {
+            headers: { authorization: `Bearer ${this.key}`, accept: "text/event-stream" },
+            signal: abort.signal
+          });
+          if (!res.ok || !res.body) throw new FlagsError(`Flags stream failed (HTTP ${res.status})`, res.status, "stream_failed");
+          delay = 1e3;
+          const reader = res.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+          for (; ; ) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const parsed = parseSseVersions(buffer);
+            buffer = parsed.rest;
+            if (parsed.versions.some((v) => v > this.version)) await this.refresh().catch(this.onError);
+            else this.checkedAt = Date.now();
+          }
+        } catch (error) {
+          if (abort.signal.aborted) return;
+          this.onError(error);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, 3e4);
+      }
+    })();
+  }
+};
+function createFlagsClient(options = {}) {
+  return new FlagsClient(options);
+}
+
+// src/adapter.ts
+var pick = (source, name) => {
+  if (!source || typeof source !== "object") return void 0;
+  const value = source[name];
+  return typeof value === "string" && value ? value : void 0;
+};
+function contextFromEntities(entities) {
+  const user = entities && typeof entities === "object" ? entities.user ?? entities : void 0;
+  const context = {};
+  const userId = pick(user, "userId") ?? pick(user, "id") ?? pick(user, "sub");
+  const email = pick(user, "email");
+  const org = pick(user, "org") ?? pick(user, "organizationId") ?? pick(entities, "org");
+  const role = pick(user, "role");
+  if (userId) context.userId = userId;
+  if (email) context.email = email;
+  if (org) context.org = org;
+  if (role) context.role = role;
+  return context;
+}
+var shared = null;
+function createInfarisAdapter(options = {}) {
+  const client = options.client ?? createFlagsClient(options);
+  return function adapter() {
+    return {
+      ...options.origin ? { origin: options.origin } : {},
+      async decide({ key, entities, defaultValue }) {
+        await client.ready().catch(() => void 0);
+        const context = contextFromEntities(entities);
+        const evaluated = client.evaluate(key, context);
+        if (evaluated) return evaluated.value;
+        const value = await client.getConfig(key);
+        return value === void 0 ? defaultValue : value;
+      }
+    };
+  };
+}
+function infarisAdapter() {
+  shared ??= createFlagsClient();
+  return createInfarisAdapter({ client: shared })();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  contextFromEntities,
+  createInfarisAdapter,
+  infarisAdapter
+});

package/dist/adapter.d.cts

@@ -0,0 +1,38 @@
+import { FlagsClientOptions, FlagsClient } from './index.cjs';
+import { F as FlagContext } from './types-DMIusvFt.cjs';
+
+/**
+ * An adapter for the Vercel `flags` SDK (`flags/next`, `flags/sveltekit`): `@infaris/flags/adapter`.
+ *
+ *   import { flag } from 'flags/next';
+ *   import { infarisAdapter } from '@infaris/flags/adapter';
+ *
+ *   export const newCheckout = flag({ key: 'new-checkout', adapter: infarisAdapter(), identify: ... });
+ *
+ * The adapter evaluates on the server with the in-memory `FlagsClient` (secret key). `identify` returns the entities;
+ * `userId`, `email`, `org` and `role` (top level or under `user`) are used for targeting and the rollout. A key that is
+ * not a flag reads an Edge Config value. This file does not import `flags`: the shape is structural, so any version
+ * of the SDK with `decide({ key, entities, defaultValue })` works.
+ */
+
+interface InfarisFlagsAdapter<ValueType, EntitiesType> {
+    origin?: string | ((key: string) => string | undefined);
+    decide(params: {
+        key: string;
+        entities?: EntitiesType;
+        defaultValue?: ValueType;
+        headers?: unknown;
+        cookies?: unknown;
+    }): Promise<ValueType>;
+}
+/** Reads `userId`/`id`/`sub`, `email`, `org`/`organizationId` and `role` from the entities (or `entities.user`). */
+declare function contextFromEntities(entities: unknown): FlagContext;
+/** Makes adapters that share one client (create it once per process). */
+declare function createInfarisAdapter(options?: FlagsClientOptions & {
+    client?: FlagsClient;
+    origin?: string;
+}): <ValueType = boolean, EntitiesType = unknown>() => InfarisFlagsAdapter<ValueType, EntitiesType>;
+/** The adapter with the client from `INFARIS_FLAGS_URL` and `INFARIS_FLAGS_SECRET_KEY`. */
+declare function infarisAdapter<ValueType = boolean, EntitiesType = unknown>(): InfarisFlagsAdapter<ValueType, EntitiesType>;
+
+export { type InfarisFlagsAdapter, contextFromEntities, createInfarisAdapter, infarisAdapter };

package/dist/adapter.d.ts

@@ -0,0 +1,38 @@
+import { FlagsClientOptions, FlagsClient } from './index.js';
+import { F as FlagContext } from './types-DMIusvFt.js';
+
+/**
+ * An adapter for the Vercel `flags` SDK (`flags/next`, `flags/sveltekit`): `@infaris/flags/adapter`.
+ *
+ *   import { flag } from 'flags/next';
+ *   import { infarisAdapter } from '@infaris/flags/adapter';
+ *
+ *   export const newCheckout = flag({ key: 'new-checkout', adapter: infarisAdapter(), identify: ... });
+ *
+ * The adapter evaluates on the server with the in-memory `FlagsClient` (secret key). `identify` returns the entities;
+ * `userId`, `email`, `org` and `role` (top level or under `user`) are used for targeting and the rollout. A key that is
+ * not a flag reads an Edge Config value. This file does not import `flags`: the shape is structural, so any version
+ * of the SDK with `decide({ key, entities, defaultValue })` works.
+ */
+
+interface InfarisFlagsAdapter<ValueType, EntitiesType> {
+    origin?: string | ((key: string) => string | undefined);
+    decide(params: {
+        key: string;
+        entities?: EntitiesType;
+        defaultValue?: ValueType;
+        headers?: unknown;
+        cookies?: unknown;
+    }): Promise<ValueType>;
+}
+/** Reads `userId`/`id`/`sub`, `email`, `org`/`organizationId` and `role` from the entities (or `entities.user`). */
+declare function contextFromEntities(entities: unknown): FlagContext;
+/** Makes adapters that share one client (create it once per process). */
+declare function createInfarisAdapter(options?: FlagsClientOptions & {
+    client?: FlagsClient;
+    origin?: string;
+}): <ValueType = boolean, EntitiesType = unknown>() => InfarisFlagsAdapter<ValueType, EntitiesType>;
+/** The adapter with the client from `INFARIS_FLAGS_URL` and `INFARIS_FLAGS_SECRET_KEY`. */
+declare function infarisAdapter<ValueType = boolean, EntitiesType = unknown>(): InfarisFlagsAdapter<ValueType, EntitiesType>;
+
+export { type InfarisFlagsAdapter, contextFromEntities, createInfarisAdapter, infarisAdapter };

package/dist/adapter.js

@@ -0,0 +1,51 @@
+import {
+  createFlagsClient
+} from "./chunk-RZ6DL2QZ.js";
+import "./chunk-LLGINDZS.js";
+import "./chunk-TRTQSARU.js";
+
+// src/adapter.ts
+var pick = (source, name) => {
+  if (!source || typeof source !== "object") return void 0;
+  const value = source[name];
+  return typeof value === "string" && value ? value : void 0;
+};
+function contextFromEntities(entities) {
+  const user = entities && typeof entities === "object" ? entities.user ?? entities : void 0;
+  const context = {};
+  const userId = pick(user, "userId") ?? pick(user, "id") ?? pick(user, "sub");
+  const email = pick(user, "email");
+  const org = pick(user, "org") ?? pick(user, "organizationId") ?? pick(entities, "org");
+  const role = pick(user, "role");
+  if (userId) context.userId = userId;
+  if (email) context.email = email;
+  if (org) context.org = org;
+  if (role) context.role = role;
+  return context;
+}
+var shared = null;
+function createInfarisAdapter(options = {}) {
+  const client = options.client ?? createFlagsClient(options);
+  return function adapter() {
+    return {
+      ...options.origin ? { origin: options.origin } : {},
+      async decide({ key, entities, defaultValue }) {
+        await client.ready().catch(() => void 0);
+        const context = contextFromEntities(entities);
+        const evaluated = client.evaluate(key, context);
+        if (evaluated) return evaluated.value;
+        const value = await client.getConfig(key);
+        return value === void 0 ? defaultValue : value;
+      }
+    };
+  };
+}
+function infarisAdapter() {
+  shared ??= createFlagsClient();
+  return createInfarisAdapter({ client: shared })();
+}
+export {
+  contextFromEntities,
+  createInfarisAdapter,
+  infarisAdapter
+};