@code-pushup/utils 0.8.10 → 0.8.11

package/index.js

@@ -38,6 +38,46 @@ function errorItems(items, transform = (items2) => items2.join(", ")) {
 function exists(value) {
   return value != null;
 }
+function getMissingRefsForCategories(categories, plugins) {
+  const missingRefs = [];
+  const auditRefsFromCategory = categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
+  );
+  const auditRefsFromPlugins = plugins.flatMap(
+    ({ audits, slug: pluginSlug }) => {
+      return audits.map(({ slug }) => `${pluginSlug}/${slug}`);
+    }
+  );
+  const missingAuditRefs = hasMissingStrings(
+    auditRefsFromCategory,
+    auditRefsFromPlugins
+  );
+  if (Array.isArray(missingAuditRefs) && missingAuditRefs.length > 0) {
+    missingRefs.push(...missingAuditRefs);
+  }
+  const groupRefsFromCategory = categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
+  );
+  const groupRefsFromPlugins = plugins.flatMap(
+    ({ groups, slug: pluginSlug }) => {
+      return Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : [];
+    }
+  );
+  const missingGroupRefs = hasMissingStrings(
+    groupRefsFromCategory,
+    groupRefsFromPlugins
+  );
+  if (Array.isArray(missingGroupRefs) && missingGroupRefs.length > 0) {
+    missingRefs.push(...missingGroupRefs);
+  }
+  return missingRefs.length ? missingRefs : false;
+}
+function missingRefsForCategoriesErrorMsg(categories, plugins) {
+  const missingRefs = getMissingRefsForCategories(categories, plugins);
+  return `The following category references need to point to an audit or group: ${errorItems(
+    missingRefs
+  )}`;
+}
 
 // packages/models/src/lib/implementation/schemas.ts
 function executionMetaSchema(options = {
@@ -96,15 +136,13 @@ function positiveIntSchema(description) {
   return z.number({ description }).int().nonnegative();
 }
 function packageVersionSchema(options) {
-  let { versionDescription, optional } = options || {};
-  versionDescription = versionDescription || "NPM version of the package";
-  optional = !!optional;
+  const { versionDescription = "NPM version of the package", required } = options ?? {};
   const packageSchema = z.string({ description: "NPM package name" });
   const versionSchema = z.string({ description: versionDescription });
   return z.object(
     {
-      packageName: optional ? packageSchema.optional() : packageSchema,
-      version: optional ? versionSchema.optional() : versionSchema
+      packageName: required ? packageSchema : packageSchema.optional(),
+      version: required ? versionSchema : versionSchema.optional()
     },
     { description: "NPM package name and version of a published package" }
   );
@@ -166,7 +204,7 @@ var pluginAuditsSchema = z2.array(auditSchema, {
 );
 function duplicateSlugsInAuditsErrorMsg(audits) {
   const duplicateRefs = getDuplicateSlugsInAudits(audits);
-  return `In plugin audits the slugs are not unique: ${errorItems(
+  return `In plugin audits the following slugs are not unique: ${errorItems(
     duplicateRefs
   )}`;
 }
@@ -355,7 +393,9 @@ function getDuplicateRefsInGroups(groups) {
 }
 function duplicateSlugsInGroupsErrorMsg(groups) {
   const duplicateRefs = getDuplicateSlugsInGroups(groups);
-  return `In groups the slugs are not unique: ${errorItems(duplicateRefs)}`;
+  return `In groups the following slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
 }
 function getDuplicateSlugsInGroups(groups) {
   return Array.isArray(groups) ? hasDuplicateStrings(groups.map(({ slug }) => slug)) : false;
@@ -381,9 +421,7 @@ var onProgressSchema = z8.function().args(z8.unknown()).returns(z8.void());
 var runnerFunctionSchema = z8.function().args(onProgressSchema.optional()).returns(z8.union([auditOutputsSchema, z8.promise(auditOutputsSchema)]));
 
 // packages/models/src/lib/plugin-config.ts
-var pluginMetaSchema = packageVersionSchema({
-  optional: true
-}).merge(
+var pluginMetaSchema = packageVersionSchema().merge(
   metaSchema({
     titleDescription: "Descriptive name",
     descriptionDescription: "Description (markdown)",
@@ -392,7 +430,7 @@ var pluginMetaSchema = packageVersionSchema({
   })
 ).merge(
   z9.object({
-    slug: slugSchema("References plugin. ID (unique within core config)"),
+    slug: slugSchema("Unique plugin slug within core config"),
     icon: materialIconSchema
   })
 );
@@ -409,20 +447,17 @@ var pluginConfigSchema = pluginMetaSchema.merge(pluginDataSchema).refine(
 );
 function missingRefsFromGroupsErrorMsg(pluginCfg) {
   const missingRefs = getMissingRefsFromGroups(pluginCfg);
-  return `In the groups, the following audit ref's needs to point to a audit in this plugin config: ${errorItems(
+  return `The following group references need to point to an existing audit in this plugin config: ${errorItems(
     missingRefs
   )}`;
 }
 function getMissingRefsFromGroups(pluginCfg) {
-  if (pluginCfg?.groups?.length && pluginCfg?.audits?.length) {
-    const groups = pluginCfg?.groups || [];
-    const audits = pluginCfg?.audits || [];
-    return hasMissingStrings(
-      groups.flatMap(({ refs: audits2 }) => audits2.map(({ slug: ref }) => ref)),
-      audits.map(({ slug }) => slug)
-    );
-  }
-  return false;
+  return hasMissingStrings(
+    pluginCfg.groups?.flatMap(
+      ({ refs: audits }) => audits.map(({ slug: ref }) => ref)
+    ) ?? [],
+    pluginCfg.audits.map(({ slug }) => slug)
+  );
 }
 
 // packages/models/src/lib/upload-config.ts
@@ -432,19 +467,15 @@ var uploadConfigSchema = z10.object({
   apiKey: z10.string({
     description: "API key with write access to portal (use `process.env` for security)"
   }),
-  organization: z10.string({
-    description: "Organization in code versioning system"
-  }),
-  project: z10.string({
-    description: "Project in code versioning system"
-  })
+  organization: slugSchema("Organization slug from Code PushUp portal"),
+  project: slugSchema("Project slug from Code PushUp portal")
 });
 
 // packages/models/src/lib/core-config.ts
 var unrefinedCoreConfigSchema = z11.object({
   plugins: z11.array(pluginConfigSchema, {
     description: "List of plugins to be used (official, community-provided, or custom)"
-  }),
+  }).min(1),
   /** portal configuration for persisting results */
   persist: persistConfigSchema.optional(),
   /** portal configuration for uploading results */
@@ -454,52 +485,15 @@ var unrefinedCoreConfigSchema = z11.object({
 var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
 function refineCoreConfig(schema) {
   return schema.refine(
-    (coreCfg) => !getMissingRefsForCategories(coreCfg),
+    (coreCfg) => !getMissingRefsForCategories(coreCfg.categories, coreCfg.plugins),
     (coreCfg) => ({
-      message: missingRefsForCategoriesErrorMsg(coreCfg)
+      message: missingRefsForCategoriesErrorMsg(
+        coreCfg.categories,
+        coreCfg.plugins
+      )
     })
   );
 }
-function missingRefsForCategoriesErrorMsg(coreCfg) {
-  const missingRefs = getMissingRefsForCategories(coreCfg);
-  return `In the categories, the following plugin refs do not exist in the provided plugins: ${errorItems(
-    missingRefs
-  )}`;
-}
-function getMissingRefsForCategories(coreCfg) {
-  const missingRefs = [];
-  const auditRefsFromCategory = coreCfg.categories.flatMap(
-    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
-  );
-  const auditRefsFromPlugins = coreCfg.plugins.flatMap(
-    ({ audits, slug: pluginSlug }) => {
-      return audits.map(({ slug }) => `${pluginSlug}/${slug}`);
-    }
-  );
-  const missingAuditRefs = hasMissingStrings(
-    auditRefsFromCategory,
-    auditRefsFromPlugins
-  );
-  if (Array.isArray(missingAuditRefs) && missingAuditRefs.length > 0) {
-    missingRefs.push(...missingAuditRefs);
-  }
-  const groupRefsFromCategory = coreCfg.categories.flatMap(
-    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
-  );
-  const groupRefsFromPlugins = coreCfg.plugins.flatMap(
-    ({ groups, slug: pluginSlug }) => {
-      return Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : [];
-    }
-  );
-  const missingGroupRefs = hasMissingStrings(
-    groupRefsFromCategory,
-    groupRefsFromPlugins
-  );
-  if (Array.isArray(missingGroupRefs) && missingGroupRefs.length > 0) {
-    missingRefs.push(...missingGroupRefs);
-  }
-  return missingRefs.length ? missingRefs : false;
-}
 
 // packages/models/src/lib/report.ts
 import { z as z12 } from "zod";
@@ -514,9 +508,32 @@ var pluginReportSchema = pluginMetaSchema.merge(
     audits: z12.array(auditReportSchema),
     groups: z12.array(groupSchema).optional()
   })
+).refine(
+  (pluginReport) => !getMissingRefsFromGroups2(pluginReport.audits, pluginReport.groups ?? []),
+  (pluginReport) => ({
+    message: missingRefsFromGroupsErrorMsg2(
+      pluginReport.audits,
+      pluginReport.groups ?? []
+    )
+  })
 );
+function missingRefsFromGroupsErrorMsg2(audits, groups) {
+  const missingRefs = getMissingRefsFromGroups2(audits, groups);
+  return `group references need to point to an existing audit in this plugin report: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsFromGroups2(audits, groups) {
+  return hasMissingStrings(
+    groups.flatMap(
+      ({ refs: auditRefs }) => auditRefs.map(({ slug: ref }) => ref)
+    ),
+    audits.map(({ slug }) => slug)
+  );
+}
 var reportSchema = packageVersionSchema({
-  versionDescription: "NPM version of the CLI"
+  versionDescription: "NPM version of the CLI",
+  required: true
 }).merge(
   executionMetaSchema({
     descriptionDate: "Start date and time of the collect run",
@@ -526,10 +543,18 @@ var reportSchema = packageVersionSchema({
   z12.object(
     {
       categories: z12.array(categoryConfigSchema),
-      plugins: z12.array(pluginReportSchema)
+      plugins: z12.array(pluginReportSchema).min(1)
     },
     { description: "Collect output data" }
   )
+).refine(
+  (report) => !getMissingRefsForCategories(report.categories, report.plugins),
+  (report) => ({
+    message: missingRefsForCategoriesErrorMsg(
+      report.categories,
+      report.plugins
+    )
+  })
 );
 
 // packages/utils/src/lib/constants.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-pushup/utils",
-  "version": "0.8.10",
+  "version": "0.8.11",
   "dependencies": {
     "@code-pushup/models": "*",
     "bundle-require": "^4.0.1",