@spotify-confidence/openfeature-server-provider-local 0.0.0

package/dist/index.browser.d.ts

@@ -0,0 +1,236 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { EvaluationContext, JsonValue, Provider, ProviderMetadata, ProviderStatus, ResolutionDetails } from "@openfeature/server-sdk";
+
+//#region src/proto/api.d.ts
+declare enum ResolveReason {
+  /** RESOLVE_REASON_UNSPECIFIED - Unspecified enum. */
+  RESOLVE_REASON_UNSPECIFIED = 0,
+  /** RESOLVE_REASON_MATCH - The flag was successfully resolved because one rule matched. */
+  RESOLVE_REASON_MATCH = 1,
+  /** RESOLVE_REASON_NO_SEGMENT_MATCH - The flag could not be resolved because no rule matched. */
+  RESOLVE_REASON_NO_SEGMENT_MATCH = 2,
+  /**
+  * RESOLVE_REASON_NO_TREATMENT_MATCH - The flag could not be resolved because the matching rule had no variant
+  * that could be assigned.
+  *
+  * @deprecated
+  */
+  RESOLVE_REASON_NO_TREATMENT_MATCH = 3,
+  /** RESOLVE_REASON_FLAG_ARCHIVED - The flag could not be resolved because it was archived. */
+  RESOLVE_REASON_FLAG_ARCHIVED = 4,
+  /** RESOLVE_REASON_TARGETING_KEY_ERROR - The flag could not be resolved because the targeting key field was invalid */
+  RESOLVE_REASON_TARGETING_KEY_ERROR = 5,
+  /** RESOLVE_REASON_ERROR - Unknown error occurred during the resolve */
+  RESOLVE_REASON_ERROR = 6,
+  UNRECOGNIZED = -1,
+}
+interface ResolveFlagsRequest {
+  /**
+  * If non-empty, the specific flags are resolved, otherwise all flags
+  * available to the client will be resolved.
+  */
+  flags: string[];
+  /**
+  * An object that contains data used in the flag resolve. For example,
+  * the targeting key e.g. the id of the randomization unit, other attributes
+  * like country or version that are used for targeting.
+  */
+  evaluationContext?: {
+    [key: string]: any;
+  } | undefined;
+  /**
+  * Credentials for the client. It is used to identify the client and find
+  * the flags that are available to it.
+  */
+  clientSecret: string;
+  /**
+  * Determines whether the flags should be applied directly as part of the
+  * resolve, or delayed until `ApplyFlag` is called. A flag is typically
+  * applied when it is used, if this occurs much later than the resolve, then
+  * `apply` should likely be set to false.
+  */
+  apply: boolean;
+}
+interface ResolveFlagsResponse {
+  /**
+  * The list of all flags that could be resolved. Note: if any flag was
+  * archived it will not be included in this list.
+  */
+  resolvedFlags: ResolvedFlag[];
+  /**
+  * An opaque token that is used when `apply` is set to false in `ResolveFlags`.
+  * When `apply` is set to false, the token must be passed to `ApplyFlags`.
+  */
+  resolveToken: Uint8Array;
+  /** Unique identifier for this particular resolve request. */
+  resolveId: string;
+}
+interface ResolvedFlag {
+  /** The id of the flag that as resolved. */
+  flag: string;
+  /** The id of the resolved variant has the format `flags/abc/variants/xyz`. */
+  variant: string;
+  /**
+  * The value corresponding to the variant. It will always be a json object,
+  * for example `{ "color": "red", "size": 12 }`.
+  */
+  value?: {
+    [key: string]: any;
+  } | undefined;
+  /** The reason to why the flag could be resolved or not. */
+  reason: ResolveReason;
+}
+interface SetResolverStateRequest {
+  state: Uint8Array;
+  accountId: string;
+}
+/** Request for resolving flags with sticky (materialized) assignments */
+interface ResolveWithStickyRequest {
+  /** The standard resolve request */
+  resolveRequest?: ResolveFlagsRequest | undefined;
+  /**
+  * Context about the materialization required for the resolve
+  * Map of targeting key (unit) to their materialization data
+  */
+  materializationsPerUnit: {
+    [key: string]: MaterializationMap;
+  };
+  /** If a materialization info is missing, return to the caller immediately */
+  failFastOnSticky: boolean;
+}
+/** Map of materialization IDs to their info for a specific unit */
+interface MaterializationMap {
+  /** Map of materialization name to info */
+  infoMap: {
+    [key: string]: MaterializationInfo;
+  };
+}
+/** Information about a materialization for a specific unit */
+interface MaterializationInfo {
+  /** Whether the unit is in this materialization/rollout */
+  unitInInfo: boolean;
+  /** Map of rule name to variant name for this unit */
+  ruleToVariant: {
+    [key: string]: string;
+  };
+}
+/** Response from resolving with sticky assignments */
+interface ResolveWithStickyResponse {
+  success?: ResolveWithStickyResponse_Success | undefined;
+  missingMaterializations?: ResolveWithStickyResponse_MissingMaterializations | undefined;
+}
+/** Successful resolution with materialization updates */
+interface ResolveWithStickyResponse_Success {
+  /** The resolved flags response */
+  response?: ResolveFlagsResponse | undefined;
+  /** New assignments that should be stored */
+  updates: ResolveWithStickyResponse_MaterializationUpdate[];
+}
+/** Information about missing materializations */
+interface ResolveWithStickyResponse_MissingMaterializations {
+  items: ResolveWithStickyResponse_MissingMaterializationItem[];
+}
+/** A missing materialization item */
+interface ResolveWithStickyResponse_MissingMaterializationItem {
+  unit: string;
+  rule: string;
+  readMaterialization: string;
+}
+/** A materialization update to be stored */
+interface ResolveWithStickyResponse_MaterializationUpdate {
+  unit: string;
+  writeMaterialization: string;
+  rule: string;
+  variant: string;
+}
+declare const ResolveFlagsRequest: MessageFns<ResolveFlagsRequest>;
+declare const ResolveFlagsResponse: MessageFns<ResolveFlagsResponse>;
+declare const ResolvedFlag: MessageFns<ResolvedFlag>;
+declare const SetResolverStateRequest: MessageFns<SetResolverStateRequest>;
+declare const ResolveWithStickyRequest: MessageFns<ResolveWithStickyRequest>;
+declare const MaterializationMap: MessageFns<MaterializationMap>;
+declare const MaterializationInfo: MessageFns<MaterializationInfo>;
+declare const ResolveWithStickyResponse: MessageFns<ResolveWithStickyResponse>;
+declare const ResolveWithStickyResponse_Success: MessageFns<ResolveWithStickyResponse_Success>;
+declare const ResolveWithStickyResponse_MissingMaterializations: MessageFns<ResolveWithStickyResponse_MissingMaterializations>;
+declare const ResolveWithStickyResponse_MissingMaterializationItem: MessageFns<ResolveWithStickyResponse_MissingMaterializationItem>;
+declare const ResolveWithStickyResponse_MaterializationUpdate: MessageFns<ResolveWithStickyResponse_MaterializationUpdate>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> } : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/LocalResolver.d.ts
+interface LocalResolver {
+  resolveWithSticky(request: ResolveWithStickyRequest): ResolveWithStickyResponse;
+  setResolverState(request: SetResolverStateRequest): void;
+  flushLogs(): Uint8Array;
+}
+//#endregion
+//#region src/ConfidenceServerProviderLocal.d.ts
+interface ProviderOptions {
+  flagClientSecret: string;
+  apiClientId: string;
+  apiClientSecret: string;
+  initializeTimeout?: number;
+  flushInterval?: number;
+  fetch?: typeof fetch;
+}
+/**
+* OpenFeature Provider for Confidence Server SDK (Local Mode)
+* @public
+*/
+declare class ConfidenceServerProviderLocal implements Provider {
+  private resolver;
+  private options;
+  /** Static data about the provider */
+  readonly metadata: ProviderMetadata;
+  /** Current status of the provider. Can be READY, NOT_READY, ERROR, STALE and FATAL. */
+  status: ProviderStatus;
+  private readonly main;
+  private readonly fetch;
+  private readonly flushInterval;
+  private stateEtag;
+  constructor(resolver: LocalResolver, options: ProviderOptions);
+  initialize(context?: EvaluationContext): Promise<void>;
+  onClose(): Promise<void>;
+  evaluate<T>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
+  /**
+  * Internal recursive method for resolving with sticky assignments.
+  *
+  * @private
+  */
+  private resolveWithStickyInternal;
+  private remoteResolve;
+  /**
+  * Extract and validate the value from a resolved flag.
+  */
+  private extractValue;
+  updateState(signal?: AbortSignal): Promise<void>;
+  flush(signal?: AbortSignal): Promise<void>;
+  private fetchResolveStateUri;
+  private fetchToken;
+  private static convertReason;
+  private static convertEvaluationContext;
+  /** Resolves with an evaluation of a Boolean flag */
+  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext): Promise<ResolutionDetails<boolean>>;
+  /** Resolves with an evaluation of a Numbers flag */
+  resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext): Promise<ResolutionDetails<number>>;
+  /** Resolves with an evaluation of an Object flag */
+  resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
+  /** Resolves with an evaluation of a String flag */
+  resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext): Promise<ResolutionDetails<string>>;
+}
+//#endregion
+//#region src/index.browser.d.ts
+declare function createConfidenceServerProvider(options: ProviderOptions): ConfidenceServerProviderLocal;
+//#endregion
+export { createConfidenceServerProvider };