@featurevisor/core 1.5.1 → 1.6.0

package/src/linter/featureSchema.ts

@@ -1,24 +1,24 @@
-import * as Joi from "joi";
+import { z } from "zod";
 
 import { ProjectConfig } from "../config";
 
 const tagRegex = /^[a-z0-9-]+$/;
 
-export function getFeatureJoiSchema(
+export function getFeatureZodSchema(
   projectConfig: ProjectConfig,
-  conditionsJoiSchema,
-  availableSegmentKeys: string[],
-  availableFeatureKeys: string[],
+  conditionsZodSchema,
+  availableAttributeKeys: [string, ...string[]],
+  availableSegmentKeys: [string, ...string[]],
+  availableFeatureKeys: [string, ...string[]],
 ) {
-  const variationValueJoiSchema = Joi.string().required();
-  const variableValueJoiSchema = Joi.alternatives()
-    .try(
-      // @TODO: make it stricter based on variableSchema.type
-      Joi.string(),
-      Joi.number(),
-      Joi.boolean(),
-      Joi.array().items(Joi.string()),
-      Joi.object().custom(function (value) {
+  const variationValueZodSchema = z.string().min(1);
+  const variableValueZodSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.string()),
+    z.record(z.unknown()).refine(
+      (value) => {
         let isFlat = true;
 
         Object.keys(value).forEach((key) => {
@@ -27,177 +27,241 @@ export function getFeatureJoiSchema(
           }
         });
 
-        if (!isFlat) {
-          throw new Error("object is not flat");
-        }
-
-        return value;
-      }),
-    )
-    .allow("");
-
-  const plainGroupSegment = Joi.string().valid("*", ...availableSegmentKeys);
-
-  const andOrNotGroupSegment = Joi.alternatives()
-    .try(
-      Joi.object({
-        and: Joi.array().items(Joi.link("#andOrNotGroupSegment"), plainGroupSegment),
-      }),
-      Joi.object({
-        or: Joi.array().items(Joi.link("#andOrNotGroupSegment"), plainGroupSegment),
-      }),
-      Joi.object({
-        // @TODO: allow plainGroupSegment as well?
-        not: Joi.array().items(Joi.link("#andOrNotGroupSegment"), plainGroupSegment),
-      }),
-    )
-    .id("andOrNotGroupSegment");
-
-  const groupSegment = Joi.alternatives().try(andOrNotGroupSegment, plainGroupSegment);
-
-  const groupSegmentsJoiSchema = Joi.alternatives().try(
-    Joi.array().items(groupSegment),
-    groupSegment,
+        return isFlat;
+      },
+      {
+        message: "object is not flat",
+      },
+    ),
+  ]);
+
+  const plainGroupSegment = z.string().refine(
+    (value) => value === "*" || availableSegmentKeys.includes(value),
+    (value) => ({
+      message: `Unknown segment key "${value}"`,
+    }),
   );
 
-  const environmentJoiSchema = Joi.object({
-    expose: Joi.alternatives().try(
-      Joi.boolean(),
-      Joi.array().items(Joi.string().valid(...projectConfig.tags)),
-    ),
-    rules: Joi.array()
-      .items(
-        Joi.object({
-          key: Joi.string().required(),
-          description: Joi.string().optional(),
-          segments: groupSegmentsJoiSchema.required(),
-          percentage: Joi.number().precision(3).min(0).max(100).required(),
-
-          enabled: Joi.boolean().optional(),
-          variation: variationValueJoiSchema.optional(), // @TODO: only allowed if feature.variations is present
-          variables: Joi.object().optional(), // @TODO: make it stricter
-        }),
-      )
-      .unique("key")
-      .required(),
-    force: Joi.array().items(
-      Joi.object({
-        // @TODO: either of the two below should be required
-        segments: groupSegmentsJoiSchema.optional(),
-        conditions: conditionsJoiSchema.optional(),
-
-        enabled: Joi.boolean().optional(),
-        variation: variationValueJoiSchema.optional(),
-        variables: Joi.object().optional(), // @TODO: make it stricter
-      }),
-    ),
-  });
+  const andOrNotGroupSegment = z.union([
+    z
+      .object({
+        and: z.array(z.lazy(() => groupSegmentZodSchema)),
+      })
+      .strict(),
+    z
+      .object({
+        or: z.array(z.lazy(() => groupSegmentZodSchema)),
+      })
+      .strict(),
+    z
+      .object({
+        not: z.array(z.lazy(() => groupSegmentZodSchema)),
+      })
+      .strict(),
+  ]);
+
+  const groupSegmentZodSchema = z.union([andOrNotGroupSegment, plainGroupSegment]);
+
+  const groupSegmentsZodSchema = z.union([z.array(groupSegmentZodSchema), groupSegmentZodSchema]);
+
+  const environmentZodSchema = z
+    .object({
+      expose: z
+        .union([
+          z.boolean(),
+          z.array(z.string().refine((value) => projectConfig.tags.includes(value))),
+        ])
+        .optional(),
+      rules: z
+        .array(
+          z
+            .object({
+              key: z.string(),
+              description: z.string().optional(),
+              segments: groupSegmentsZodSchema,
+              percentage: z.number().min(0).max(100),
+
+              enabled: z.boolean().optional(),
+              variation: variationValueZodSchema.optional(),
+              variables: z.record(variableValueZodSchema).optional(),
+            })
+            .strict(),
+        )
+        .refine(
+          (value) => {
+            const keys = value.map((v) => v.key);
+            return keys.length === new Set(keys).size;
+          },
+          (value) => ({
+            message: "Duplicate rule keys found: " + value.map((v) => v.key).join(", "),
+          }),
+        ),
+      force: z
+        .array(
+          z.union([
+            z
+              .object({
+                segments: groupSegmentsZodSchema,
+                enabled: z.boolean().optional(),
+                variation: variationValueZodSchema.optional(),
+                variables: z.record(variableValueZodSchema).optional(),
+              })
+              .strict(),
+            z
+              .object({
+                conditions: conditionsZodSchema,
+                enabled: z.boolean().optional(),
+                variation: variationValueZodSchema.optional(),
+                variables: z.record(variableValueZodSchema).optional(),
+              })
+              .strict(),
+          ]),
+        )
+        .optional(),
+    })
+    .strict();
 
   const allEnvironmentsSchema = {};
   projectConfig.environments.forEach((environmentKey) => {
-    allEnvironmentsSchema[environmentKey] = environmentJoiSchema.required();
+    allEnvironmentsSchema[environmentKey] = environmentZodSchema;
   });
-  const allEnvironmentsJoiSchema = Joi.object(allEnvironmentsSchema);
-
-  const featureJoiSchema = Joi.object({
-    archived: Joi.boolean().optional(),
-    deprecated: Joi.boolean().optional(),
-    description: Joi.string().required(),
-    tags: Joi.array()
-      .items(
-        Joi.string().custom((value) => {
-          if (!tagRegex.test(value)) {
-            throw new Error("tag must be lower cased and alphanumeric, and may contain hyphens.");
-          }
+  const allEnvironmentsZodSchema = z.object(allEnvironmentsSchema).strict();
+
+  const attributeKeyZodSchema = z.string().refine(
+    (value) => value === "*" || availableAttributeKeys.includes(value),
+    (value) => ({
+      message: `Unknown attribute "${value}"`,
+    }),
+  );
+
+  const featureKeyZodSchema = z.string().refine(
+    (value) => availableFeatureKeys.includes(value),
+    (value) => ({
+      message: `Unknown feature "${value}"`,
+    }),
+  );
 
-          return value;
-        }),
-      )
-      .required(),
-
-    required: Joi.array()
-      .items(
-        Joi.alternatives().try(
-          Joi.string()
-            .required()
-            .valid(...availableFeatureKeys),
-          Joi.object({
-            key: Joi.string()
-              .required()
-              .valid(...availableFeatureKeys),
-            variation: Joi.string().optional(), // @TODO: can be made stricter
+  const featureZodSchema = z
+    .object({
+      archived: z.boolean().optional(),
+      deprecated: z.boolean().optional(),
+      description: z.string(),
+      tags: z
+        .array(
+          z.string().refine(
+            (value) => tagRegex.test(value),
+            (value) => ({
+              message: `Tag "${value}" must be lower cased and alphanumeric, and may contain hyphens.`,
+            }),
+          ),
+        )
+        .refine(
+          (value) => {
+            return value.length === new Set(value).size;
+          },
+          (value) => ({
+            message: "Duplicate tags found: " + value.join(", "),
           }),
         ),
-      )
-      .optional(),
-
-    bucketBy: Joi.alternatives()
-      .try(
-        // plain
-        Joi.string(),
-
-        // and
-        Joi.array().items(Joi.string()),
-
-        // or
-        Joi.object({
-          or: Joi.array().items(Joi.string()),
-        }),
-      )
-      .required(),
-
-    variablesSchema: Joi.array()
-      .items(
-        Joi.object({
-          key: Joi.string().disallow("variation").required(),
-          type: Joi.string()
-            .valid("string", "integer", "boolean", "double", "array", "object", "json")
-            .required(),
-          description: Joi.string().optional(),
-          defaultValue: variableValueJoiSchema, // @TODO: make it stricter based on `type`
-        }),
-      )
-      .unique("key"),
-
-    variations: Joi.array()
-      .items(
-        Joi.object({
-          description: Joi.string(),
-          value: variationValueJoiSchema.required(),
-          weight: Joi.number().precision(3).min(0).max(100).required(),
-          variables: Joi.array()
-            .items(
-              Joi.object({
-                key: Joi.string(),
-                value: variableValueJoiSchema,
-                overrides: Joi.array().items(
-                  Joi.object({
-                    // @TODO: either segments or conditions prsent at a time
-                    segments: groupSegmentsJoiSchema,
-                    conditions: conditionsJoiSchema,
-
-                    // @TODO: make it stricter based on `type`
-                    value: variableValueJoiSchema,
-                  }),
-                ),
-              }),
-            )
-            .unique("key"),
-        }),
-      )
-      .custom((value) => {
-        const total = value.reduce((acc, v) => acc + v.weight, 0);
-
-        if (total !== 100) {
-          throw new Error(`Sum of all variation weights must be 100, got ${total}`);
-        }
-
-        return value;
-      })
-      .optional(),
-
-    environments: allEnvironmentsJoiSchema.required(),
-  });
+      required: z
+        .array(
+          z.union([
+            featureKeyZodSchema,
+            z
+              .object({
+                key: featureKeyZodSchema,
+                variation: z.string().optional(),
+              })
+              .strict(),
+          ]),
+        )
+        .optional(),
+      bucketBy: z.union([
+        attributeKeyZodSchema,
+        z.array(attributeKeyZodSchema),
+        z
+          .object({
+            or: z.array(attributeKeyZodSchema),
+          })
+          .strict(),
+      ]),
+      variablesSchema: z
+        .array(
+          z
+            .object({
+              key: z
+                .string()
+                .min(1)
+                .refine((value) => value !== "variation", {
+                  message: `variable key cannot be "variation"`,
+                }),
+              type: z.enum(["string", "integer", "boolean", "double", "array", "object", "json"]),
+              description: z.string().optional(),
+              defaultValue: variableValueZodSchema,
+            })
+            .strict(),
+        )
+        .refine(
+          (value) => {
+            const keys = value.map((v) => v.key);
+            return keys.length === new Set(keys).size;
+          },
+          (value) => ({
+            message: "Duplicate variable keys found: " + value.map((v) => v.key).join(", "),
+          }),
+        )
+        .optional(),
+      variations: z
+        .array(
+          z
+            .object({
+              description: z.string().optional(),
+              value: variationValueZodSchema,
+              weight: z.number().min(0).max(100),
+              variables: z
+                .array(
+                  z
+                    .object({
+                      key: z.string().min(1),
+                      value: variableValueZodSchema,
+                      overrides: z
+                        .array(
+                          z.union([
+                            z
+                              .object({
+                                conditions: conditionsZodSchema,
+                                value: variableValueZodSchema,
+                              })
+                              .strict(),
+                            z
+                              .object({
+                                segments: groupSegmentsZodSchema,
+                                value: variableValueZodSchema,
+                              })
+                              .strict(),
+                          ]),
+                        )
+                        .optional(),
+                    })
+                    .strict(),
+                )
+                .optional(),
+            })
+            .strict(),
+        )
+        .refine(
+          (value) => {
+            const variationValues = value.map((v) => v.value);
+            return variationValues.length === new Set(variationValues).size;
+          },
+          (value) => ({
+            message: "Duplicate variation values found: " + value.map((v) => v.value).join(", "),
+          }),
+        )
+        .optional(),
+      environments: allEnvironmentsZodSchema,
+    })
+    .strict();
 
-  return featureJoiSchema;
+  return featureZodSchema;
 }

package/src/linter/groupSchema.ts

@@ -1,63 +1,47 @@
-import * as Joi from "joi";
+import { z } from "zod";
 
 import { ProjectConfig } from "../config";
 import { Datasource } from "../datasource";
 
-export function getGroupJoiSchema(
+export function getGroupZodSchema(
   projectConfig: ProjectConfig,
   datasource: Datasource,
   availableFeatureKeys: string[],
 ) {
-  const groupJoiSchema = Joi.object({
-    description: Joi.string().required(),
-    slots: Joi.array()
-      .items(
-        Joi.object({
-          feature: Joi.string().valid(...availableFeatureKeys),
-          percentage: Joi.number().precision(3).min(0).max(100).required(),
-        }),
-      )
-      .custom(async function (value) {
-        const totalPercentage = value.reduce((acc, slot) => acc + slot.percentage, 0);
-
-        if (totalPercentage !== 100) {
-          throw new Error("total percentage is not 100");
-        }
-
-        for (const slot of value) {
-          const maxPercentageForRule = slot.percentage;
-
-          if (slot.feature) {
-            const featureKey = slot.feature;
-            const featureExists = availableFeatureKeys.indexOf(featureKey) > -1;
-
-            if (!featureExists) {
-              throw new Error(`feature ${featureKey} not found`);
-            }
-
-            const parsedFeature = await datasource.readFeature(featureKey);
-
-            const environmentKeys = Object.keys(parsedFeature.environments);
-            for (const environmentKey of environmentKeys) {
-              const environment = parsedFeature.environments[environmentKey];
-              const rules = environment.rules;
-
-              for (const rule of rules) {
-                if (rule.percentage > maxPercentageForRule) {
-                  // @TODO: this does not help with same feature belonging to multiple slots. fix that.
-                  throw new Error(
-                    `Feature ${featureKey}'s rule ${rule.key} in ${environmentKey} has a percentage of ${rule.percentage} which is greater than the maximum percentage of ${maxPercentageForRule} for the slot`,
-                  );
-                }
-              }
-            }
-          }
-        }
-
-        return value;
-      })
-      .required(),
-  });
-
-  return groupJoiSchema;
+  const groupZodSchema = z
+    .object({
+      description: z.string(),
+      slots: z
+        .array(
+          z
+            .object({
+              feature: z
+                .string()
+                .optional()
+                .refine(
+                  (value) => {
+                    if (value && availableFeatureKeys.indexOf(value) === -1) {
+                      return false;
+                    }
+
+                    return true;
+                  },
+                  (value) => ({ message: `Unknown feature "${value}"` }),
+                ),
+              percentage: z.number().min(0).max(100),
+            })
+            .strict(),
+        )
+        .refine(
+          (value) => {
+            const totalPercentage = value.reduce((acc, slot) => acc + slot.percentage, 0);
+
+            return totalPercentage === 100;
+          },
+          { message: "Total percentage of all slots is not 100" },
+        ),
+    })
+    .strict();
+
+  return groupZodSchema;
 }