@showwhat/core 2.0.0 → 2.1.0

package/README.md

@@ -25,12 +25,16 @@ const data = await MemoryData.fromObject({
 
 const def = await data.get("checkout_v2");
 
-const result = await resolve({
+const results = await resolve({
   definitions: { checkout_v2: def! },
   context: { env: "prod" },
   options: { evaluators: builtinEvaluators },
 });
-console.log(result.checkout_v2.value); // true
+
+const entry = results["checkout_v2"];
+if (entry.success) {
+  console.log(entry.value); // true
+}
 ```
 
 > **Note:** The resolver is strict — evaluators must be passed explicitly. There is no default evaluator set injected automatically.

package/dist/index.d.ts

@@ -38,6 +38,31 @@ declare class ConditionError extends ShowwhatError {
     readonly conditionType: string;
     constructor(conditionType: string, message: string, cause?: unknown);
 }
+declare class UnknownConditionTypeError extends ShowwhatError {
+    readonly conditionType: string;
+    readonly condition: unknown;
+    constructor(conditionType: string, condition: unknown);
+}
+
+declare const DataPrimitiveSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+/**
+ * Primitive values inferred from the schema — string | number | boolean.
+ */
+type DataPrimitive = z.infer<typeof DataPrimitiveSchema>;
+/**
+ * The set of value types that showwhat's data model understands.
+ *
+ * Used as the structural base for both `ContextValue` and `AnnotationValue`.
+ *
+ * **Why this isn't `z.infer`:** TypeScript cannot infer recursive types from
+ * self-referencing `const` declarations (TS7022). The schema below must be
+ * annotated with this type; `DataPrimitive` is still inferred from its schema,
+ * keeping the non-recursive portion derived from the single source of truth.
+ */
+type DataValue = DataPrimitive | DataPrimitive[] | {
+    [key: string]: DataValue;
+};
+declare const DataValueSchema: z.ZodType<DataValue>;
 
 declare const PRIMITIVE_CONDITION_TYPES: {
     readonly string: "string";
@@ -52,6 +77,7 @@ declare const CONDITION_TYPES: {
     readonly endAt: "endAt";
     readonly and: "and";
     readonly or: "or";
+    readonly checkAnnotations: "checkAnnotations";
     readonly string: "string";
     readonly number: "number";
     readonly bool: "bool";
@@ -66,9 +92,9 @@ declare const StringConditionSchema: z.ZodObject<{
     type: z.ZodLiteral<"string">;
     key: z.ZodString;
     op: z.ZodEnum<{
+        in: "in";
         eq: "eq";
         neq: "neq";
-        in: "in";
         nin: "nin";
         regex: "regex";
     }>;
@@ -80,9 +106,9 @@ declare const NumberConditionSchema: z.ZodObject<{
     type: z.ZodLiteral<"number">;
     key: z.ZodString;
     op: z.ZodEnum<{
+        in: "in";
         eq: "eq";
         neq: "neq";
-        in: "in";
         nin: "nin";
         gt: "gt";
         gte: "gte";
@@ -138,9 +164,9 @@ declare const BuiltinConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"string">;
     key: z.ZodString;
     op: z.ZodEnum<{
+        in: "in";
         eq: "eq";
         neq: "neq";
-        in: "in";
         nin: "nin";
         regex: "regex";
     }>;
@@ -150,9 +176,9 @@ declare const BuiltinConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"number">;
     key: z.ZodString;
     op: z.ZodEnum<{
+        in: "in";
         eq: "eq";
         neq: "neq";
-        in: "in";
         nin: "nin";
         gt: "gt";
         gte: "gte";
@@ -201,6 +227,10 @@ type Condition = BuiltinCondition | {
     id?: string;
     type: "or";
     conditions: Condition[];
+} | {
+    id?: string;
+    type: "checkAnnotations";
+    conditions: Condition[];
 } | {
     type: string;
     [key: string]: unknown;
@@ -215,19 +245,24 @@ declare const OrConditionSchema: z.ZodObject<{
     type: z.ZodLiteral<"or">;
     conditions: z.ZodArray<z.ZodLazy<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>>;
 }, z.core.$strip>;
+declare const CheckAnnotationsConditionSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"checkAnnotations">;
+    conditions: z.ZodArray<z.ZodLazy<z.ZodType<Condition, unknown, z.core.$ZodTypeInternals<Condition, unknown>>>>;
+}, z.core.$strip>;
 declare const ConditionSchema: z.ZodType<Condition>;
 type AndCondition = z.infer<typeof AndConditionSchema>;
 type OrCondition = z.infer<typeof OrConditionSchema>;
-type CompositeCondition = AndCondition | OrCondition;
+type CheckAnnotationsCondition = z.infer<typeof CheckAnnotationsConditionSchema>;
+type CompositeCondition = AndCondition | OrCondition | CheckAnnotationsCondition;
 declare function isAndCondition(c: Condition): c is AndCondition;
 declare function isOrCondition(c: Condition): c is OrCondition;
+declare function isCheckAnnotationsCondition(c: Condition): c is CheckAnnotationsCondition;
 
-declare const ContextSchema: z.ZodRecord<z.ZodString, z.ZodType<ContextValue, unknown, z.core.$ZodTypeInternals<ContextValue, unknown>>>;
-type ContextPrimitive = string | number | boolean;
-type ContextValue = ContextPrimitive | ContextPrimitive[] | {
-    [key: string]: ContextValue;
-};
-type Context<T extends Record<string, ContextValue> = Record<string, ContextValue>> = T;
+type ContextValue = DataValue;
+declare const ContextValueSchema: z.ZodType<DataValue, unknown, z.core.$ZodTypeInternals<DataValue, unknown>>;
+declare const ContextSchema: z.ZodRecord<z.ZodString, z.ZodType<DataValue, unknown, z.core.$ZodTypeInternals<DataValue, unknown>>>;
+type Context = Record<string, ContextValue>;
 
 type VariationValue = unknown;
 declare const VariationValueSchema: z.ZodType<VariationValue>;
@@ -289,7 +324,6 @@ type PresetDefinition = {
     overrides?: Record<string, unknown>;
 };
 type Presets = Record<string, PresetDefinition>;
-declare const PRIMITIVE_TYPES: Set<string>;
 declare const PresetsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
     type: z.ZodString;
     key: z.ZodOptional<z.ZodString>;
@@ -320,11 +354,28 @@ type ResolutionError = {
     error: ShowwhatError;
 };
 
-type Annotations<T extends Record<string, unknown> = Record<string, unknown>> = T;
-type Dependencies<T extends Record<string, unknown> = Record<string, unknown>> = T;
+interface Logger {
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+}
+declare const noopLogger: Logger;
+
+declare const AnnotationValueSchema: z.ZodType<DataValue, unknown, z.core.$ZodTypeInternals<DataValue, unknown>>;
+/**
+ * Semantic alias for `DataValue`. Annotations share the same structural base today,
+ * but may diverge in the future (e.g. restricted to flat records). Keeping the alias
+ * lets call sites express intent and makes a future split a non-breaking change.
+ */
+type AnnotationValue = DataValue;
+declare const AnnotationsSchema: z.ZodRecord<z.ZodString, z.ZodType<DataValue, unknown, z.core.$ZodTypeInternals<DataValue, unknown>>>;
+type Annotations = Record<string, AnnotationValue>;
+type Dependencies = Record<string, unknown>;
 type RegexFactory = (pattern: string) => {
     test: (input: string) => boolean;
 };
+type AnnotationsFactory = (definitionKey?: string) => Annotations;
 declare const defaultCreateRegex: RegexFactory;
 type ConditionEvaluatorArgs = {
     condition: unknown;
@@ -333,19 +384,16 @@ type ConditionEvaluatorArgs = {
     deps: Readonly<Dependencies>;
     depth: string;
     createRegex: RegexFactory;
+    evaluators: ConditionEvaluators;
+    logger?: Logger;
 };
 type ConditionEvaluator = (args: ConditionEvaluatorArgs) => Promise<boolean>;
-type ConditionEvaluators<T extends string = string> = Record<T, ConditionEvaluator>;
+declare const FALLBACK_EVALUATOR_KEY: unique symbol;
+type ConditionEvaluators = Record<string, ConditionEvaluator> & {
+    [FALLBACK_EVALUATOR_KEY]?: ConditionEvaluator;
+};
 declare const noConditionEvaluator: ConditionEvaluator;
 
-interface Logger {
-    debug(message: string, data?: Record<string, unknown>): void;
-    info(message: string, data?: Record<string, unknown>): void;
-    warn(message: string, data?: Record<string, unknown>): void;
-    error(message: string, data?: Record<string, unknown>): void;
-}
-declare const noopLogger: Logger;
-
 type EvaluateConditionArgs = {
     condition: Condition;
     context: Readonly<Context>;
@@ -354,24 +402,25 @@ type EvaluateConditionArgs = {
     deps?: Readonly<Dependencies>;
     depth?: string;
     logger?: Logger;
-    fallback?: ConditionEvaluator;
     createRegex?: RegexFactory;
 };
-declare function evaluateCondition({ condition, context, evaluators, annotations, deps, depth, logger, fallback, createRegex, }: EvaluateConditionArgs): Promise<boolean>;
+declare function evaluateCondition({ condition, context, evaluators, annotations, deps, depth, logger, createRegex, }: EvaluateConditionArgs): Promise<boolean>;
 
-declare const builtinEvaluators: ConditionEvaluators<BuiltinCondition["type"]>;
+declare const builtinEvaluators: ConditionEvaluators;
 
 type ResolverOptions = {
     evaluators?: ConditionEvaluators;
     fallback?: ConditionEvaluator;
     logger?: Logger;
     createRegex?: RegexFactory;
+    createAnnotations?: AnnotationsFactory;
 };
-declare function resolveVariation<T extends Record<string, ContextValue> = Record<string, ContextValue>, D extends Record<string, unknown> = Record<string, unknown>>({ variations, context, deps, options, }: {
+declare function resolveVariation({ variations, context, deps, options, definitionKey, }: {
     variations: Variation[];
-    context: Readonly<Context<T>>;
-    deps?: Dependencies<D>;
+    context: Readonly<Context>;
+    deps?: Dependencies;
     options?: ResolverOptions;
+    definitionKey?: string;
 }): Promise<{
     variation: Variation;
     variationIndex: number;
@@ -383,10 +432,10 @@ declare function resolveVariation<T extends Record<string, ContextValue> = Recor
  * Each key is resolved independently — a failure for one key does not
  * affect others. Failed keys are returned as `ResolutionError` entries.
  */
-declare function resolve<T extends Record<string, ContextValue> = Record<string, ContextValue>, D extends Record<string, unknown> = Record<string, unknown>>({ definitions, context, deps, options, }: {
+declare function resolve({ definitions, context, deps, options, }: {
     definitions: Definitions;
-    context: Readonly<Context<T>>;
-    deps?: Dependencies<D>;
+    context: Readonly<Context>;
+    deps?: Dependencies;
     options?: ResolverOptions;
 }): Promise<Record<string, Resolution | ResolutionError>>;
 
@@ -423,7 +472,7 @@ declare class MemoryData implements DefinitionReader, PresetReader {
     get(key: string): Promise<Definition | null>;
     getAll(): Promise<Definitions>;
     listKeys(): Promise<string[]>;
-    getPresets(): Promise<Presets>;
+    getPresets(_key?: string): Promise<Presets>;
 }
 
 declare function parseYaml(input: string): Promise<FileFormat>;
@@ -433,4 +482,4 @@ declare function parsePresetsYaml(input: string): Promise<Presets>;
 
 declare function createPresetConditions(presets: Presets): ConditionEvaluators;
 
-export { type AndCondition, type Annotations, type BoolCondition, BoolConditionSchema, type BuiltinCondition, BuiltinConditionSchema, CONDITION_TYPES, CONTEXT_KEYS, type CompositeCondition, type Condition, ConditionError, type ConditionEvaluator, type ConditionEvaluatorArgs, type ConditionEvaluators, ConditionSchema, type Context, ContextSchema, type ContextValue, DataError, type DatetimeCondition, DatetimeConditionSchema, type Definition, type DefinitionData, DefinitionInactiveError, DefinitionNotFoundError, type DefinitionReader, DefinitionSchema, type DefinitionWriter, type Definitions, DefinitionsSchema, type Dependencies, type EndAtCondition, EndAtConditionSchema, type EnvCondition, EnvConditionSchema, type EvaluateConditionArgs, type FileFormat, FileFormatSchema, InvalidContextError, type Logger, MemoryData, type NumberCondition, NumberConditionSchema, type OrCondition, PRIMITIVE_CONDITION_TYPES, PRIMITIVE_TYPES, ParseError, type PresetDefinition, type PresetReader, type Presets, PresetsSchema, type PrimitiveConditionType, type RegexFactory, type Resolution, type ResolutionError, ResolutionSchema, type ResolverOptions, SchemaValidationError, ShowwhatError, type StartAtCondition, StartAtConditionSchema, type StringCondition, StringConditionSchema, ValidationError, type Variation, VariationNotFoundError, VariationSchema, type VariationValue, VariationValueSchema, builtinEvaluators, createPresetConditions, defaultCreateRegex, evaluateCondition, isAndCondition, isOrCondition, isWritable, noConditionEvaluator, noopLogger, parseObject, parsePresetsObject, parsePresetsYaml, parseYaml, resolve, resolveVariation };
+export { type AndCondition, type AnnotationValue, AnnotationValueSchema, type Annotations, type AnnotationsFactory, AnnotationsSchema, type BoolCondition, BoolConditionSchema, type BuiltinCondition, BuiltinConditionSchema, CONDITION_TYPES, CONTEXT_KEYS, type CheckAnnotationsCondition, type CompositeCondition, type Condition, ConditionError, type ConditionEvaluator, type ConditionEvaluatorArgs, type ConditionEvaluators, ConditionSchema, type Context, ContextSchema, type ContextValue, ContextValueSchema, DataError, type DataValue, DataValueSchema, type DatetimeCondition, DatetimeConditionSchema, type Definition, type DefinitionData, DefinitionInactiveError, DefinitionNotFoundError, type DefinitionReader, DefinitionSchema, type DefinitionWriter, type Definitions, DefinitionsSchema, type Dependencies, type EndAtCondition, EndAtConditionSchema, type EnvCondition, EnvConditionSchema, type EvaluateConditionArgs, FALLBACK_EVALUATOR_KEY, type FileFormat, FileFormatSchema, InvalidContextError, type Logger, MemoryData, type NumberCondition, NumberConditionSchema, type OrCondition, PRIMITIVE_CONDITION_TYPES, ParseError, type PresetDefinition, type PresetReader, type Presets, PresetsSchema, type PrimitiveConditionType, type RegexFactory, type Resolution, type ResolutionError, ResolutionSchema, type ResolverOptions, SchemaValidationError, ShowwhatError, type StartAtCondition, StartAtConditionSchema, type StringCondition, StringConditionSchema, UnknownConditionTypeError, ValidationError, type Variation, VariationNotFoundError, VariationSchema, type VariationValue, VariationValueSchema, builtinEvaluators, createPresetConditions, defaultCreateRegex, evaluateCondition, isAndCondition, isCheckAnnotationsCondition, isOrCondition, isWritable, noConditionEvaluator, noopLogger, parseObject, parsePresetsObject, parsePresetsYaml, parseYaml, resolve, resolveVariation };