atmn 0.0.23 → 0.0.24

package/dist/cli.cjs

@@ -603,68 +603,105 @@ export const ${idToVar({ id: feature.id, prefix: "feature" })} = feature({
 })`;
   return snippet;
 }
-var ProductItemIntervalEnum = v4.z.enum([
-  "minute",
-  "hour",
-  "day",
-  "week",
-  "month",
-  "quarter",
-  "semi_annual",
-  "year"
-]);
-var UsageModelEnum = v4.z.enum(["prepaid", "pay_per_use"]);
+var ProductItemIntervalEnum = v4.z.enum(
+  ["minute", "hour", "day", "week", "month", "quarter", "semi_annual", "year"],
+  {
+    message: "Interval must be 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'semi_annual', or 'year'"
+  }
+);
+var UsageModelEnum = v4.z.enum(["prepaid", "pay_per_use"], {
+  message: "Usage model must be 'prepaid' or 'pay_per_use'"
+});
 var ProductItemSchema = v4.z.object({
-  type: v4.z.enum(["feature", "priced_feature"]).nullish(),
-  feature_id: v4.z.string().nullish(),
-  included_usage: v4.z.union([v4.z.number(), v4.z.literal("inf")]).nullish(),
+  type: v4.z.enum(["feature", "priced_feature"], {
+    message: "Type must be 'feature' or 'priced_feature'"
+  }).nullish(),
+  feature_id: v4.z.string({
+    message: "Feature ID must be a string"
+  }).nullish(),
+  included_usage: v4.z.union([v4.z.number(), v4.z.literal("inf")], {
+    message: 'Included usage must be a number or "inf"'
+  }).nullish(),
   interval: ProductItemIntervalEnum.nullish(),
   usage_model: UsageModelEnum.nullish(),
-  price: v4.z.number().nullish(),
+  price: v4.z.number({
+    message: "Price must be a valid number"
+  }).nullish(),
   tiers: v4.z.array(
     v4.z.object({
-      amount: v4.z.number(),
-      to: v4.z.union([v4.z.number(), v4.z.literal("inf")])
+      amount: v4.z.number({
+        message: "Tier amount must be a valid number"
+      }),
+      to: v4.z.union([v4.z.number(), v4.z.literal("inf")], {
+        message: 'Tier "to" must be a number or "inf"'
+      })
     })
   ).nullish(),
-  billing_units: v4.z.number().nullish(),
-  // amount per billing unit (eg. $9 / 250 units)
-  reset_usage_when_enabled: v4.z.boolean().optional(),
-  entity_feature_id: v4.z.string().optional()
+  billing_units: v4.z.number({
+    message: "Billing units must be a valid number"
+  }).nullish(),
+  reset_usage_when_enabled: v4.z.boolean({
+    message: "Reset usage when enabled must be true or false"
+  }).optional(),
+  entity_feature_id: v4.z.string({
+    message: "Entity feature ID must be a string"
+  }).optional()
 });
 v4.z.object({
-  feature_id: v4.z.string(),
-  included_usage: v4.z.number().nullish(),
+  feature_id: v4.z.string({
+    message: "Feature ID is required and must be a string"
+  }),
+  included_usage: v4.z.number({
+    message: "Included usage must be a valid number"
+  }).nullish(),
   interval: ProductItemIntervalEnum.nullish()
 });
 v4.z.object({
-  price: v4.z.number().gt(0),
+  price: v4.z.number({
+    message: "Price must be a valid number"
+  }).gt(0, "Price must be greater than 0"),
   interval: ProductItemIntervalEnum.nullish()
 });
 
 // source/compose/models/composeModels.ts
 var FreeTrialSchema = v4.z.object({
-  duration: v4.z.enum(["day", "month", "year"]),
-  length: v4.z.number(),
-  unique_fingerprint: v4.z.boolean(),
-  card_required: v4.z.boolean()
+  duration: v4.z.enum(["day", "month", "year"], {
+    message: "Duration must be 'day', 'month', or 'year'"
+  }),
+  length: v4.z.number({
+    message: "Length must be a valid number"
+  }),
+  unique_fingerprint: v4.z.boolean({
+    message: "Unique fingerprint must be true or false"
+  }),
+  card_required: v4.z.boolean({
+    message: "Card required must be true or false"
+  })
 });
 var ProductSchema = v4.z.object({
-  id: v4.z.string().min(1),
-  name: v4.z.string().min(1),
+  id: v4.z.string().min(1, "Product ID is required and cannot be empty"),
+  name: v4.z.string().min(1, "Product name is required and cannot be empty"),
   is_add_on: v4.z.boolean().prefault(false).optional(),
   is_default: v4.z.boolean().prefault(false).optional(),
-  items: v4.z.array(ProductItemSchema),
+  items: v4.z.array(ProductItemSchema, {
+    message: "Items must be an array of product items"
+  }),
   free_trial: FreeTrialSchema.optional()
 });
 var FeatureSchema = v4.z.object({
-  id: v4.z.string().min(1),
+  id: v4.z.string().min(1, "Feature ID is required and cannot be empty"),
   name: v4.z.string().optional(),
-  type: v4.z.enum(["boolean", "single_use", "continuous_use", "credit_system"]),
+  type: v4.z.enum(["boolean", "single_use", "continuous_use", "credit_system"], {
+    message: "Type must be 'boolean', 'single_use', 'continuous_use', or 'credit_system'"
+  }),
   credit_schema: v4.z.array(
     v4.z.object({
-      metered_feature_id: v4.z.string(),
-      credit_cost: v4.z.number()
+      metered_feature_id: v4.z.string({
+        message: "Metered feature ID must be a string"
+      }),
+      credit_cost: v4.z.number({
+        message: "Credit cost must be a valid number"
+      })
     })
   ).optional(),
   archived: v4.z.boolean().optional()
@@ -721,7 +758,7 @@ function isProduct(value) {
   try {
     ProductSchema.parse(value);
     return true;
-  } catch {
+  } catch (error) {
     return false;
   }
 }
@@ -733,6 +770,41 @@ function isFeature(value) {
     return false;
   }
 }
+function detectObjectType(value) {
+  if (value && typeof value === "object") {
+    if (value.items && Array.isArray(value.items)) {
+      return "product";
+    }
+    if (value.type) {
+      return "feature";
+    }
+  }
+  return "unknown";
+}
+function getValidationError(schema, value) {
+  try {
+    schema.parse(value);
+    return "";
+  } catch (error) {
+    if (error.name === "ZodError" && error.issues) {
+      const formattedErrors = error.issues.map((issue) => {
+        const path2 = issue.path.length > 0 ? `${issue.path.join(".")}` : "root";
+        return `  \u2022 ${path2}: ${issue.message}`;
+      });
+      return `
+${formattedErrors.join("\n")}`;
+    }
+    if (error.errors && Array.isArray(error.errors)) {
+      const formattedErrors = error.errors.map((e) => {
+        const path2 = e.path && e.path.length > 0 ? `${e.path.join(".")}` : "root";
+        return `  \u2022 ${path2}: ${e.message}`;
+      });
+      return `
+${formattedErrors.join("\n")}`;
+    }
+    return error.message || "Unknown validation error";
+  }
+}
 async function loadAutumnConfigFile() {
   const configPath = path__default.default.join(process.cwd(), "autumn.config.ts");
   const absolutePath = path.resolve(configPath);
@@ -764,6 +836,28 @@ async function loadAutumnConfigFile() {
         products.push(value);
       } else if (isFeature(value)) {
         features.push(value);
+      } else {
+        const detectedType = detectObjectType(value);
+        if (detectedType === "product") {
+          const validationError = getValidationError(ProductSchema, value);
+          console.error("\n" + chalk8__default.default.red("\u274C Invalid product configuration"));
+          console.error(chalk8__default.default.yellow(`Product: "${key}"`));
+          console.error(chalk8__default.default.red("Validation errors:") + validationError);
+          process.exit(1);
+        } else if (detectedType === "feature") {
+          const validationError = getValidationError(FeatureSchema, value);
+          console.error("\n" + chalk8__default.default.red("\u274C Invalid feature configuration"));
+          console.error(chalk8__default.default.yellow(`Feature: "${key}"`));
+          console.error(chalk8__default.default.red("Validation errors:") + validationError);
+          process.exit(1);
+        } else {
+          console.error("\n" + chalk8__default.default.red("\u274C Invalid object configuration"));
+          console.error(chalk8__default.default.yellow(`Object: "${key}"`));
+          console.error(
+            chalk8__default.default.red("Error:") + " Object must be either a product (with 'items' field) or feature (with 'type' field)"
+          );
+          process.exit(1);
+        }
       }
     }
   }
@@ -987,7 +1081,9 @@ async function checkForDeletables(currentFeatures, currentProducts) {
   const featureIds = features.map((feature) => feature.id);
   const currentFeatureIds = currentFeatures.map((feature) => feature.id);
   const featuresToDelete = featureIds.filter(
-    (featureId) => !currentFeatureIds.includes(featureId) && !features.archived
+    (featureId) => !currentFeatureIds.includes(featureId) && !features.some(
+      (feature) => feature.id === featureId && feature.archived
+    )
   );
   const products = await getAllProducts();
   const productIds = products.map((product) => product.id);

package/dist/cli.js

@@ -586,68 +586,105 @@ export const ${idToVar({ id: feature.id, prefix: "feature" })} = feature({
 })`;
   return snippet;
 }
-var ProductItemIntervalEnum = z.enum([
-  "minute",
-  "hour",
-  "day",
-  "week",
-  "month",
-  "quarter",
-  "semi_annual",
-  "year"
-]);
-var UsageModelEnum = z.enum(["prepaid", "pay_per_use"]);
+var ProductItemIntervalEnum = z.enum(
+  ["minute", "hour", "day", "week", "month", "quarter", "semi_annual", "year"],
+  {
+    message: "Interval must be 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'semi_annual', or 'year'"
+  }
+);
+var UsageModelEnum = z.enum(["prepaid", "pay_per_use"], {
+  message: "Usage model must be 'prepaid' or 'pay_per_use'"
+});
 var ProductItemSchema = z.object({
-  type: z.enum(["feature", "priced_feature"]).nullish(),
-  feature_id: z.string().nullish(),
-  included_usage: z.union([z.number(), z.literal("inf")]).nullish(),
+  type: z.enum(["feature", "priced_feature"], {
+    message: "Type must be 'feature' or 'priced_feature'"
+  }).nullish(),
+  feature_id: z.string({
+    message: "Feature ID must be a string"
+  }).nullish(),
+  included_usage: z.union([z.number(), z.literal("inf")], {
+    message: 'Included usage must be a number or "inf"'
+  }).nullish(),
   interval: ProductItemIntervalEnum.nullish(),
   usage_model: UsageModelEnum.nullish(),
-  price: z.number().nullish(),
+  price: z.number({
+    message: "Price must be a valid number"
+  }).nullish(),
   tiers: z.array(
     z.object({
-      amount: z.number(),
-      to: z.union([z.number(), z.literal("inf")])
+      amount: z.number({
+        message: "Tier amount must be a valid number"
+      }),
+      to: z.union([z.number(), z.literal("inf")], {
+        message: 'Tier "to" must be a number or "inf"'
+      })
     })
   ).nullish(),
-  billing_units: z.number().nullish(),
-  // amount per billing unit (eg. $9 / 250 units)
-  reset_usage_when_enabled: z.boolean().optional(),
-  entity_feature_id: z.string().optional()
+  billing_units: z.number({
+    message: "Billing units must be a valid number"
+  }).nullish(),
+  reset_usage_when_enabled: z.boolean({
+    message: "Reset usage when enabled must be true or false"
+  }).optional(),
+  entity_feature_id: z.string({
+    message: "Entity feature ID must be a string"
+  }).optional()
 });
 z.object({
-  feature_id: z.string(),
-  included_usage: z.number().nullish(),
+  feature_id: z.string({
+    message: "Feature ID is required and must be a string"
+  }),
+  included_usage: z.number({
+    message: "Included usage must be a valid number"
+  }).nullish(),
   interval: ProductItemIntervalEnum.nullish()
 });
 z.object({
-  price: z.number().gt(0),
+  price: z.number({
+    message: "Price must be a valid number"
+  }).gt(0, "Price must be greater than 0"),
   interval: ProductItemIntervalEnum.nullish()
 });
 
 // source/compose/models/composeModels.ts
 var FreeTrialSchema = z.object({
-  duration: z.enum(["day", "month", "year"]),
-  length: z.number(),
-  unique_fingerprint: z.boolean(),
-  card_required: z.boolean()
+  duration: z.enum(["day", "month", "year"], {
+    message: "Duration must be 'day', 'month', or 'year'"
+  }),
+  length: z.number({
+    message: "Length must be a valid number"
+  }),
+  unique_fingerprint: z.boolean({
+    message: "Unique fingerprint must be true or false"
+  }),
+  card_required: z.boolean({
+    message: "Card required must be true or false"
+  })
 });
 var ProductSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
+  id: z.string().min(1, "Product ID is required and cannot be empty"),
+  name: z.string().min(1, "Product name is required and cannot be empty"),
   is_add_on: z.boolean().prefault(false).optional(),
   is_default: z.boolean().prefault(false).optional(),
-  items: z.array(ProductItemSchema),
+  items: z.array(ProductItemSchema, {
+    message: "Items must be an array of product items"
+  }),
   free_trial: FreeTrialSchema.optional()
 });
 var FeatureSchema = z.object({
-  id: z.string().min(1),
+  id: z.string().min(1, "Feature ID is required and cannot be empty"),
   name: z.string().optional(),
-  type: z.enum(["boolean", "single_use", "continuous_use", "credit_system"]),
+  type: z.enum(["boolean", "single_use", "continuous_use", "credit_system"], {
+    message: "Type must be 'boolean', 'single_use', 'continuous_use', or 'credit_system'"
+  }),
   credit_schema: z.array(
     z.object({
-      metered_feature_id: z.string(),
-      credit_cost: z.number()
+      metered_feature_id: z.string({
+        message: "Metered feature ID must be a string"
+      }),
+      credit_cost: z.number({
+        message: "Credit cost must be a valid number"
+      })
     })
   ).optional(),
   archived: z.boolean().optional()
@@ -704,7 +741,7 @@ function isProduct(value) {
   try {
     ProductSchema.parse(value);
     return true;
-  } catch {
+  } catch (error) {
     return false;
   }
 }
@@ -716,6 +753,41 @@ function isFeature(value) {
     return false;
   }
 }
+function detectObjectType(value) {
+  if (value && typeof value === "object") {
+    if (value.items && Array.isArray(value.items)) {
+      return "product";
+    }
+    if (value.type) {
+      return "feature";
+    }
+  }
+  return "unknown";
+}
+function getValidationError(schema, value) {
+  try {
+    schema.parse(value);
+    return "";
+  } catch (error) {
+    if (error.name === "ZodError" && error.issues) {
+      const formattedErrors = error.issues.map((issue) => {
+        const path2 = issue.path.length > 0 ? `${issue.path.join(".")}` : "root";
+        return `  \u2022 ${path2}: ${issue.message}`;
+      });
+      return `
+${formattedErrors.join("\n")}`;
+    }
+    if (error.errors && Array.isArray(error.errors)) {
+      const formattedErrors = error.errors.map((e) => {
+        const path2 = e.path && e.path.length > 0 ? `${e.path.join(".")}` : "root";
+        return `  \u2022 ${path2}: ${e.message}`;
+      });
+      return `
+${formattedErrors.join("\n")}`;
+    }
+    return error.message || "Unknown validation error";
+  }
+}
 async function loadAutumnConfigFile() {
   const configPath = path.join(process.cwd(), "autumn.config.ts");
   const absolutePath = resolve(configPath);
@@ -747,6 +819,28 @@ async function loadAutumnConfigFile() {
         products.push(value);
       } else if (isFeature(value)) {
         features.push(value);
+      } else {
+        const detectedType = detectObjectType(value);
+        if (detectedType === "product") {
+          const validationError = getValidationError(ProductSchema, value);
+          console.error("\n" + chalk8.red("\u274C Invalid product configuration"));
+          console.error(chalk8.yellow(`Product: "${key}"`));
+          console.error(chalk8.red("Validation errors:") + validationError);
+          process.exit(1);
+        } else if (detectedType === "feature") {
+          const validationError = getValidationError(FeatureSchema, value);
+          console.error("\n" + chalk8.red("\u274C Invalid feature configuration"));
+          console.error(chalk8.yellow(`Feature: "${key}"`));
+          console.error(chalk8.red("Validation errors:") + validationError);
+          process.exit(1);
+        } else {
+          console.error("\n" + chalk8.red("\u274C Invalid object configuration"));
+          console.error(chalk8.yellow(`Object: "${key}"`));
+          console.error(
+            chalk8.red("Error:") + " Object must be either a product (with 'items' field) or feature (with 'type' field)"
+          );
+          process.exit(1);
+        }
       }
     }
   }
@@ -970,7 +1064,9 @@ async function checkForDeletables(currentFeatures, currentProducts) {
   const featureIds = features.map((feature) => feature.id);
   const currentFeatureIds = currentFeatures.map((feature) => feature.id);
   const featuresToDelete = featureIds.filter(
-    (featureId) => !currentFeatureIds.includes(featureId) && !features.archived
+    (featureId) => !currentFeatureIds.includes(featureId) && !features.some(
+      (feature) => feature.id === featureId && feature.archived
+    )
   );
   const products = await getAllProducts();
   const productIds = products.map((product) => product.id);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "atmn",
-	"version": "0.0.23",
+	"version": "0.0.24",
 	"license": "MIT",
 	"bin": "dist/cli.js",
 	"main": "dist/index.js",