@spotify-confidence/openfeature-server-provider-local 0.6.0 → 0.8.0

package/dist/index.node.d.ts

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { EvaluationContext, JsonValue, Provider, ProviderMetadata, ProviderStatus, ResolutionDetails } from "@openfeature/server-sdk";
+import { EvaluationContext, JsonValue, Provider, ProviderMetadata, ProviderStatus } from "@openfeature/server-sdk";
 
 //#region src/proto/confidence/flags/types/v1/types.d.ts
 /** Schema for the value of a flag. */
@@ -173,6 +173,27 @@ interface ResolveFlagsResponse {
   /** Unique identifier for this particular resolve request. */
   resolveId: string;
 }
+interface ApplyFlagsRequest {
+  /** The flags to apply and information about when they were applied. */
+  flags: AppliedFlag[];
+  /** Credentials for the client. */
+  clientSecret: string;
+  /** An opaque token that was returned from `ResolveFlags`; it must be set. */
+  resolveToken: Uint8Array;
+  /**
+  * The client time when the this request was sent, used for correcting
+  * clock skew from the client.
+  */
+  sendTime?: Date | undefined;
+  /** Information about the SDK used to initiate the request. */
+  sdk?: Sdk | undefined;
+}
+interface AppliedFlag {
+  /** The id of the flag that should be applied, has the format `flags/*`. */
+  flag: string;
+  /** The client time when the flag was applied. */
+  applyTime?: Date | undefined;
+}
 interface ResolvedFlag {
   /** The id of the flag that as resolved. */
   flag: string;
@@ -189,9 +210,13 @@ interface ResolvedFlag {
   flagSchema?: FlagSchema_StructFlagSchema | undefined;
   /** The reason to why the flag could be resolved or not. */
   reason: ResolveReason;
+  /** Determines whether the flag should be applied in the clients */
+  shouldApply: boolean;
 }
 declare const ResolveFlagsRequest: MessageFns$3<ResolveFlagsRequest>;
 declare const ResolveFlagsResponse: MessageFns$3<ResolveFlagsResponse>;
+declare const ApplyFlagsRequest: MessageFns$3<ApplyFlagsRequest>;
+declare const AppliedFlag: MessageFns$3<AppliedFlag>;
 declare const ResolvedFlag: MessageFns$3<ResolvedFlag>;
 type Builtin$3 = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial$3<T> = T extends Builtin$3 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$3<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$3<U>> : T extends {} ? { [K in keyof T]?: DeepPartial$3<T[K]> } : Partial<T>;
@@ -322,6 +347,7 @@ interface LocalResolver {
   setResolverState(request: SetResolverStateRequest): void;
   flushLogs(): Uint8Array;
   flushAssigned(): Uint8Array;
+  applyFlags(request: ApplyFlagsRequest): void;
 }
 //#endregion
 //#region src/materialization.d.ts
@@ -398,7 +424,40 @@ interface MaterializationStore {
   writeMaterializations?(writeOps: MaterializationStore.WriteOp[]): Promise<void>;
 }
 //#endregion
+//#region src/types.d.ts
+type ResolutionReason = "ERROR" | "FLAG_ARCHIVED" | "MATCH" | "NO_SEGMENT_MATCH" | "TARGETING_KEY_ERROR" | "NO_TREATMENT_MATCH" | "UNSPECIFIED";
+declare enum ErrorCode {
+  PROVIDER_NOT_READY = "PROVIDER_NOT_READY",
+  PROVIDER_FATAL = "PROVIDER_FATAL",
+  FLAG_NOT_FOUND = "FLAG_NOT_FOUND",
+  TYPE_MISMATCH = "TYPE_MISMATCH",
+  GENERAL = "GENERAL",
+}
+interface ResolutionDetails<T> {
+  reason: ResolutionReason;
+  value: T;
+  variant?: string;
+  errorCode?: ErrorCode;
+  errorMessage?: string;
+  shouldApply: boolean;
+}
+type FlagPrimitive = null | boolean | string | number;
+type FlagObject = {
+  [key: string]: FlagValue;
+};
+type FlagValue = FlagPrimitive | FlagObject;
+//#endregion
+//#region src/flag-bundle.d.ts
+interface FlagBundle {
+  flags: Record<string, ResolutionDetails<FlagObject | null> | undefined>;
+  resolveId: string;
+  resolveToken: string;
+  errorCode?: ErrorCode;
+  errorMessage?: string;
+}
+//#endregion
 //#region src/ConfidenceServerProviderLocal.d.ts
+type FlagBundle$1 = FlagBundle;
 interface ProviderOptions {
   flagClientSecret: string;
   initializeTimeout?: number;
@@ -414,7 +473,7 @@ interface ProviderOptions {
 * @public
 */
 declare class ConfidenceServerProviderLocal implements Provider {
-  private resolver;
+  private resolverOrPromise;
   private options;
   /** Static data about the provider */
   readonly metadata: ProviderMetadata;
@@ -426,22 +485,19 @@ declare class ConfidenceServerProviderLocal implements Provider {
   private readonly flushInterval;
   private readonly materializationStore;
   private stateEtag;
-  constructor(resolver: LocalResolver, options: ProviderOptions);
+  private get resolver();
+  constructor(resolverOrPromise: LocalResolver | Promise<LocalResolver>, options: ProviderOptions);
   initialize(context?: EvaluationContext): Promise<void>;
   onClose(): Promise<void>;
-  evaluate<T>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
+  resolve(context: EvaluationContext, flagNames: string[], apply?: boolean): Promise<FlagBundle$1>;
+  evaluate<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
   private resolveWithSticky;
-  /**
-  * Extract and validate the value from a resolved flag.
-  */
-  private extractValue;
   updateState(signal?: AbortSignal): Promise<void>;
   flush(signal?: AbortSignal): Promise<void>;
   private flushAssigned;
   private sendFlagLogs;
   private readMaterializations;
   private writeMaterializations;
-  private static convertReason;
   private static convertEvaluationContext;
   /** Resolves with an evaluation of a Boolean flag */
   resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext): Promise<ResolutionDetails<boolean>>;
@@ -451,9 +507,22 @@ declare class ConfidenceServerProviderLocal implements Provider {
   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>>;
+  /**
+  * Applies a previously resolved flag, logging that it was used/exposed.
+  * Call this when a flag value is actually rendered or used in the client.
+  * @param resolveToken - Base64-encoded resolve token from the flag bundle
+  * @param flagName - Name of the flag to apply
+  */
+  applyFlag(resolveToken: string, flagName: string): void;
 }
 //#endregion
 //#region src/index.node.d.ts
-declare function createConfidenceServerProvider(options: ProviderOptions): ConfidenceServerProviderLocal;
+interface ProviderOptionsExt extends ProviderOptions {
+  wasmPath?: string;
+}
+declare function createConfidenceServerProvider({
+  wasmPath,
+  ...options
+}: ProviderOptionsExt): ConfidenceServerProviderLocal;
 //#endregion
-export { type MaterializationStore, createConfidenceServerProvider };
+export { type MaterializationStore, ProviderOptionsExt, createConfidenceServerProvider };