Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.7 KB
Raw Blame
import { useAnalytics } from '@app/lib/analytics/analytics-context';
import type { RemoteFlag } from '@core/constant/featureFlags';
import { createAssertedContextProvider } from '@core/context/createContext';
import { Telemetry } from '@macro-inc/observability';
import type { JsonType } from 'posthog-js';
import {
  type Accessor,
  createMemo,
  createSignal,
  type JSX,
  onCleanup,
  Show,
  startTransition,
} from 'solid-js';

export const [PosthogProvider, usePosthog] = createAssertedContextProvider(
  'PosthogProvider',
  () => {
    const analytics = useAnalytics();

    // PostHog only reports flags once `/flags` answers, but it already serves
    // the flags it cached on the previous visit. Starting from that cache means
    // returning users paint flagged UI once, not flags-off first and then again
    // when the answer lands (e.g. soup lists reloading on a transport swap).
    const cachedFlags = analytics.posthog.featureFlags?.getFlags() ?? [];
    const [featureFlags, setFeatureFlags] = createSignal<string[]>(
      cachedFlags,
      { equals: false }
    );
    // Distinguishes "flags not fetched yet" from "no flags enabled": both
    // leave featureFlags empty, but destructive flag-off fallbacks (e.g.
    // RedirectSplit) must not fire before the answer arrives. Set even on
    // errorsLoading so a PostHog outage degrades to flags-off, not a hang.
    const [flagsLoaded, setFlagsLoaded] = createSignal(cachedFlags.length > 0);
    // Whether the last fetch got no answer at all (blocked, offline, PostHog
    // down), as opposed to an answer that says a flag is off.
    const [flagsUnreachable, setFlagsUnreachable] = createSignal(false);

    const unsub = analytics.posthog.onFeatureFlags((flags, _, ctx) => {
      // Flags usually arrive after first paint and swap flagged subtrees,
      // often to lazy views. A transition keeps the painted UI until the new
      // one is ready instead of flashing Suspense fallbacks in between.
      startTransition(() => {
        // Order matters: signals propagate synchronously, so flagsLoaded must
        // only flip after the flag values are in place — the other way around,
        // flag-off fallbacks fire against the still-empty flag list.
        if (!ctx?.errorsLoading) {
          setFeatureFlags(flags);
        }
        setFlagsUnreachable(ctx?.errorsLoading === true);
        setFlagsLoaded(true);
      }).catch((error) => Telemetry.error(error, { surface: 'feature-flags' }));
    });

    onCleanup(unsub);

    return {
      instance: analytics.posthog,
      featureFlags,
      flagsLoaded,
      flagsUnreachable,
    };
  }
);

type FeatureFlagResult<T> = {
  enabled: boolean;
  payload: T;
  loading: boolean;
};

type FeatureFlagOpts<T> = {
  fallbackPayload?: T;
  enabledOverride?: boolean;
  /**
   * Treat the flag as on when PostHog could not be reached and holds no
   * earlier answer for it; an answer of "off" still wins. For pages anonymous
   * visitors depend on, which a blocked flag request must not take down.
   */
  enabledWhenUnreachable?: boolean;
};

function readFeatureFlag<T extends JsonType>(
  flagOrKey: RemoteFlag | string,
  opts?: FeatureFlagOpts<T>
): Accessor<FeatureFlagResult<T | undefined>> {
  const posthog = usePosthog();

  return createMemo(
    () => {
      const fallbackPayload = opts?.fallbackPayload;
      const remote = typeof flagOrKey === 'string' ? undefined : flagOrKey;
      const key = typeof flagOrKey === 'string' ? flagOrKey : flagOrKey.key;
      const override = remote?.override ?? opts?.enabledOverride;

      if (override !== undefined) {
        return { enabled: override, payload: fallbackPayload, loading: false };
      }

      if (!posthog.flagsLoaded()) {
        return { enabled: false, payload: fallbackPayload, loading: true };
      }

      // The SDK is not reactive. Re-read on each successful refresh, including
      // payload changes that leave the enabled flag list unchanged.
      posthog.featureFlags();
      const result = posthog.instance.getFeatureFlagResult(key);
      const unreachableDefault =
        opts?.enabledWhenUnreachable === true && posthog.flagsUnreachable();

      return {
        enabled: result?.enabled ?? unreachableDefault,
        payload: (result?.payload as T) ?? fallbackPayload,
        loading: false,
      };
    },
    undefined,
    {
      equals: (prev, next) =>
        prev.enabled === next.enabled &&
        prev.payload === next.payload &&
        prev.loading === next.loading,
    }
  );
}

export function useFeatureFlag<T extends JsonType>(
  flag: RemoteFlag,
  opts?: Pick<FeatureFlagOpts<T>, 'fallbackPayload' | 'enabledWhenUnreachable'>
): Accessor<FeatureFlagResult<T | undefined>>;
export function useFeatureFlag<T extends JsonType>(
  key: string,
  opts?: FeatureFlagOpts<T>
): Accessor<FeatureFlagResult<T | undefined>>;
export function useFeatureFlag<T extends JsonType>(
  flagOrKey: RemoteFlag | string,
  opts?: FeatureFlagOpts<T>
): Accessor<FeatureFlagResult<T | undefined>> {
  return readFeatureFlag(flagOrKey, opts);
}

type ShowFeatureFlagProps<T> = {
  fallback?: JSX.Element;
  fallbackPayload?: T;
  children: JSX.Element;
} & ({ flag: RemoteFlag } | { key: string; enabledOverride?: boolean });

function showFlagTarget<T>(
  props: ShowFeatureFlagProps<T>
): RemoteFlag | string {
  if ('flag' in props) {
    return props.flag;
  }
  return props.key;
}

export const ShowFeatureFlag = <T extends JsonType>(
  props: ShowFeatureFlagProps<T>
) => {
  const flag = readFeatureFlag(showFlagTarget(props), {
    fallbackPayload: props.fallbackPayload,
    enabledOverride: 'flag' in props ? undefined : props.enabledOverride,
  });

  return (
    <Show when={flag().enabled} fallback={props.fallback}>
      {props.children}
    </Show>
  );
};