JavaScript (Official SDK)

async function renderHeader() {
  try {
    const headerFlag = await client.getFlag("new-header-design");

    if (headerFlag.enabled) {
      renderNewHeader(headerFlag.payload);
    } else {
      renderDefaultHeader();
    }
  } catch (error) {
    console.error("Error loading header flag:", error);
    // Always fallback to default
    renderDefaultHeader();
  }
}

// Clear entire cache
client.clearCache();

// Clear cache for a specific flag
client.clearFlagCache("header");

// Flags will be fetched fresh on next request
const freshFlag = await client.getFlag("header");

const previewResponse = await client.getPreviewFlags();

previewResponse.flags.forEach((previewFlag) => {
  console.log(previewFlag.slug);
  console.log(previewFlag.previewName);
  console.log(previewFlag.previewContent);
});

const feedback = await client.submitPreviewFeedback({
  flagKey: "landing-preview",
  mood: "HAPPY",
  rating: 4,
  description: "The preview looks good and reads clearly.",
  metadata: {
    page: "landing",
    source: "marketing-site",
  },
});

console.log(feedback.success);
console.log(feedback.feedbackId);

const authenticatedClient = new FlagsSDK({
  baseURL: "https://flags-api.basestack.co/v1",
  projectKey: "your-project-key",
  environmentKey: "your-environment-key",
  apiKey: "your-project-api-token",
});

const result = await authenticatedClient.submitCodeReferences({
  branch: "main",
  projectName: "acme-web",
  repositoryUrl: "https://github.com/acme/web",
  references: {
    "new-checkout": [
      {
        filePath: "src/features/checkout.tsx",
        lineNumber: 42,
        lineContent: "if (flags.newCheckout) {",
      },
    ],
  },
});

console.log(result.success);
console.log(result.message);

import fetch from "node-fetch";
import { FlagsSDK } from "@basestack/flags-js";

const client = new FlagsSDK({
  projectKey: "your-project-key",
  environmentKey: "your-environment-key",
  fetchImpl: fetch, // Use node-fetch or other implementation
});

async function getFlagSafely(slug, defaultValue = false) {
  try {
    const flag = await client.getFlag(slug);
    return flag.enabled;
  } catch (error) {
    console.error(`Failed to fetch flag "${slug}":`, error);
    // Return safe default value
    return defaultValue;
  }
}

// Usage with fallback
const isEnabled = await getFlagSafely("new-feature", false);

import { FlagsSDK, type Flag, type SDKConfig } from "@basestack/flags-js";

const config: SDKConfig = {
  projectKey: process.env.FEATURE_FLAGS_PROJECT_KEY!,
  environmentKey: process.env.FEATURE_FLAGS_ENVIRONMENT_KEY!,
};

const client = new FlagsSDK(config);

// Type-safe flag fetching
async function getTypedFlag(): Promise<Flag> {
  return await client.getFlag("header");
}

// Type-safe payload
interface HeaderPayload {
  variant: "light" | "dark";
  showLogo: boolean;
}

async function getHeaderConfig() {
  const flag = await client.getFlag("header");
  const payload = flag.payload as HeaderPayload;
  return payload;
}

// In your app initialization
const client = new FlagsSDK(config);
await client.init(); // Preload flags before rendering

const client = new FlagsSDK({
  // ... other config
  cache: {
    enabled: true,
    ttl: 5 * 60 * 1000, // 5 minutes
  },
});

async function getFeatureState(flagSlug, fallback = false) {
  try {
    const flag = await client.getFlag(flagSlug);
    return flag.enabled;
  } catch (error) {
    console.error(`Flag "${flagSlug}" failed:`, error);
    return fallback;
  }
}

const client = new FlagsSDK({
  // ... other config
  preloadFlags: ["header", "footer", "checkout"],
});

const isProduction = process.env.NODE_ENV === "production";

const client = new FlagsSDK({
  baseURL: isProduction
    ? "https://flags-api.basestack.co/v1"
    : "https://flags-dev.basestack.co/v1",
  projectKey: process.env.FEATURE_FLAGS_PROJECT_KEY,
  environmentKey: isProduction
    ? process.env.PROD_ENVIRONMENT_KEY
    : process.env.DEV_ENVIRONMENT_KEY,
});

import { FlagsSDK, type Flag, type SDKConfig } from "@basestack/flags-js";

const config: SDKConfig = {
  projectKey: "your-key",
  environmentKey: "your-env-key",
};

const client = new FlagsSDK(config);
const flag: Flag = await client.getFlag("header");

/** Configuration for caching mechanism */
export interface CacheConfig {
  /** Enable or disable caching (default: true) */
  enabled?: boolean;
  /** Time-to-Live for cache entries in milliseconds (default: 5 minutes) */
  ttl?: number;
  /** Maximum number of cache entries (default: 100) */
  maxSize?: number;
}

/** SDK Configuration Options */
export interface SDKConfig {
  /** Base URL for the Feature Flags API (optional; defaults to `https://flags-api.basestack.co/v1`) */
  baseURL?: string;
  /** Project identification key (required) */
  projectKey: string;
  /** Environment identification key (required) */
  environmentKey: string;
  /** Project API token for authenticated write endpoints such as `submitCodeReferences()` (optional; server-side only) */
  apiKey?: string;
  /** Caching configuration options */
  cache?: CacheConfig;
  /** Custom fetch implementation (optional) */
  fetchImpl?: typeof fetch;
  /** If set, `init()` preloads only these slugs; if omitted, `init()` preloads all flags */
  preloadFlags?: string[];
}

/** Feature flag data structure */
export interface Flag {
  slug: string;
  enabled: boolean;
  payload?: unknown;
  expiredAt?: Date | null;
  createdAt: Date;
  updatedAt: Date;
  description: string;
  error?: boolean;
}

await client.init();

const flag = await client.getFlag("header");
console.log(flag.enabled); // true or false
console.log(flag.payload); // Optional payload data

const { flags } = await client.getAllFlags();
flags.forEach(flag => {
  console.log(`${flag.slug}: ${flag.enabled}`);
});

client.clearCache();

client.clearFlagCache("header");