@cerios/openapi-to-zod 0.3.0 → 0.5.0

package/dist/cli.mjs

@@ -6291,13 +6291,153 @@ var init_property_generator = __esm({
   }
 });
 
-// src/generator.ts
+// src/utils/operation-filters.ts
+import { minimatch } from "minimatch";
+function createFilterStatistics() {
+  return {
+    totalOperations: 0,
+    includedOperations: 0,
+    filteredByTags: 0,
+    filteredByPaths: 0,
+    filteredByMethods: 0,
+    filteredByOperationIds: 0,
+    filteredByDeprecated: 0
+  };
+}
+function matchesAnyPattern(value, patterns) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  if (!value) {
+    return false;
+  }
+  return patterns.some((pattern) => minimatch(value, pattern));
+}
+function containsAny(arr, values) {
+  if (!values || values.length === 0) {
+    return false;
+  }
+  if (!arr || arr.length === 0) {
+    return false;
+  }
+  return values.some((value) => arr.includes(value));
+}
+function shouldIncludeOperation(operation, path2, method, filters, stats) {
+  if (!filters) {
+    return true;
+  }
+  const methodLower = method.toLowerCase();
+  const operationId = operation == null ? void 0 : operation.operationId;
+  const tags = (operation == null ? void 0 : operation.tags) || [];
+  const deprecated = (operation == null ? void 0 : operation.deprecated) === true;
+  if (filters.includeTags && filters.includeTags.length > 0) {
+    if (!containsAny(tags, filters.includeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.includePaths && filters.includePaths.length > 0) {
+    if (!matchesAnyPattern(path2, filters.includePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.includeMethods && filters.includeMethods.length > 0) {
+    const methodsLower = filters.includeMethods.map((m) => m.toLowerCase());
+    if (!methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.includeOperationIds && filters.includeOperationIds.length > 0) {
+    if (!matchesAnyPattern(operationId, filters.includeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  if (filters.excludeDeprecated === true && deprecated) {
+    if (stats) stats.filteredByDeprecated++;
+    return false;
+  }
+  if (filters.excludeTags && filters.excludeTags.length > 0) {
+    if (containsAny(tags, filters.excludeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.excludePaths && filters.excludePaths.length > 0) {
+    if (matchesAnyPattern(path2, filters.excludePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.excludeMethods && filters.excludeMethods.length > 0) {
+    const methodsLower = filters.excludeMethods.map((m) => m.toLowerCase());
+    if (methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.excludeOperationIds && filters.excludeOperationIds.length > 0) {
+    if (matchesAnyPattern(operationId, filters.excludeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  return true;
+}
+function validateFilters(stats, filters) {
+  if (!filters || stats.totalOperations === 0) {
+    return;
+  }
+  if (stats.includedOperations === 0) {
+    console.warn(
+      `\u26A0\uFE0F  Warning: All ${stats.totalOperations} operations were filtered out. Check your operationFilters configuration.`
+    );
+    const filterBreakdown = [];
+    if (stats.filteredByTags > 0) filterBreakdown.push(`${stats.filteredByTags} by tags`);
+    if (stats.filteredByPaths > 0) filterBreakdown.push(`${stats.filteredByPaths} by paths`);
+    if (stats.filteredByMethods > 0) filterBreakdown.push(`${stats.filteredByMethods} by methods`);
+    if (stats.filteredByOperationIds > 0) filterBreakdown.push(`${stats.filteredByOperationIds} by operationIds`);
+    if (stats.filteredByDeprecated > 0) filterBreakdown.push(`${stats.filteredByDeprecated} by deprecated flag`);
+    if (filterBreakdown.length > 0) {
+      console.warn(`   Filtered: ${filterBreakdown.join(", ")}`);
+    }
+  }
+}
+function formatFilterStatistics(stats) {
+  if (stats.totalOperations === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("Operation Filtering:");
+  lines.push(`  Total operations: ${stats.totalOperations}`);
+  lines.push(`  Included operations: ${stats.includedOperations}`);
+  const filteredCount = stats.filteredByTags + stats.filteredByPaths + stats.filteredByMethods + stats.filteredByOperationIds + stats.filteredByDeprecated;
+  if (filteredCount > 0) {
+    lines.push(`  Filtered operations: ${filteredCount}`);
+    if (stats.filteredByTags > 0) lines.push(`    - By tags: ${stats.filteredByTags}`);
+    if (stats.filteredByPaths > 0) lines.push(`    - By paths: ${stats.filteredByPaths}`);
+    if (stats.filteredByMethods > 0) lines.push(`    - By methods: ${stats.filteredByMethods}`);
+    if (stats.filteredByOperationIds > 0) lines.push(`    - By operationIds: ${stats.filteredByOperationIds}`);
+    if (stats.filteredByDeprecated > 0) lines.push(`    - By deprecated: ${stats.filteredByDeprecated}`);
+  }
+  return lines.join("\n");
+}
+var init_operation_filters = __esm({
+  "src/utils/operation-filters.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/openapi-generator.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, normalize } from "path";
 import { parse } from "yaml";
-var ZodSchemaGenerator;
-var init_generator = __esm({
-  "src/generator.ts"() {
+var OpenApiGenerator;
+var init_openapi_generator = __esm({
+  "src/openapi-generator.ts"() {
     "use strict";
     init_esm_shims();
     init_errors();
@@ -6305,7 +6445,8 @@ var init_generator = __esm({
     init_jsdoc_generator();
     init_property_generator();
     init_name_utils();
-    ZodSchemaGenerator = class {
+    init_operation_filters();
+    OpenApiGenerator = class {
       constructor(options) {
         this.schemas = /* @__PURE__ */ new Map();
         this.types = /* @__PURE__ */ new Map();
@@ -6315,6 +6456,7 @@ var init_generator = __esm({
         this.schemaUsageMap = /* @__PURE__ */ new Map();
         this.schemaTypeModeMap = /* @__PURE__ */ new Map();
         this.needsZodImport = false;
+        this.filterStats = createFilterStatistics();
         var _a, _b, _c;
         if (!options.input) {
           throw new ConfigurationError("Input path is required", { providedOptions: options });
@@ -6332,7 +6474,8 @@ var init_generator = __esm({
           showStats: (_c = options.showStats) != null ? _c : true,
           nativeEnumType: options.nativeEnumType || "union",
           request: options.request,
-          response: options.response
+          response: options.response,
+          operationFilters: options.operationFilters
         };
         try {
           const fs = __require("fs");
@@ -6345,19 +6488,41 @@ var init_generator = __esm({
           }
         }
         try {
-          const yamlContent = readFileSync(this.options.input, "utf-8");
-          this.spec = parse(yamlContent);
+          const content = readFileSync(this.options.input, "utf-8");
+          try {
+            this.spec = parse(content);
+          } catch (yamlError) {
+            try {
+              this.spec = JSON.parse(content);
+            } catch {
+              if (yamlError instanceof Error) {
+                const errorMessage = [
+                  `Failed to parse OpenAPI specification from: ${this.options.input}`,
+                  "",
+                  `Error: ${yamlError.message}`,
+                  "",
+                  "Please ensure:",
+                  "  - The file exists and is readable",
+                  "  - The file contains valid YAML or JSON syntax",
+                  "  - The file is a valid OpenAPI 3.x specification"
+                ].join("\n");
+                throw new SpecValidationError(errorMessage, {
+                  filePath: this.options.input,
+                  originalError: yamlError.message
+                });
+              }
+              throw yamlError;
+            }
+          }
         } catch (error) {
+          if (error instanceof SpecValidationError) {
+            throw error;
+          }
           if (error instanceof Error) {
             const errorMessage = [
-              `Failed to parse OpenAPI specification from: ${this.options.input}`,
-              "",
-              `Error: ${error.message}`,
+              `Failed to read OpenAPI specification from: ${this.options.input}`,
               "",
-              "Please ensure:",
-              "  - The file exists and is readable",
-              "  - The file contains valid YAML syntax",
-              "  - The file is a valid OpenAPI 3.x specification"
+              `Error: ${error.message}`
             ].join("\n");
             throw new SpecValidationError(errorMessage, { filePath: this.options.input, originalError: error.message });
           }
@@ -6415,6 +6580,8 @@ var init_generator = __esm({
           this.generateComponentSchema(name, schema);
         }
         this.generateQueryParameterSchemas();
+        this.generateHeaderParameterSchemas();
+        validateFilters(this.filterStats, this.options.operationFilters);
         const orderedSchemaNames = this.topologicalSort();
         const output = ["// Auto-generated by @cerios/openapi-to-zod", "// Do not edit this file manually", ""];
         if (this.options.showStats === true) {
@@ -6508,9 +6675,16 @@ var init_generator = __esm({
         const requestSchemas = /* @__PURE__ */ new Set();
         const responseSchemas = /* @__PURE__ */ new Set();
         if (this.spec.paths) {
-          for (const [, pathItem] of Object.entries(this.spec.paths)) {
-            for (const [, operation] of Object.entries(pathItem)) {
+          for (const [path2, pathItem] of Object.entries(this.spec.paths)) {
+            const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+            for (const method of methods) {
+              const operation = pathItem[method];
               if (typeof operation !== "object" || !operation) continue;
+              this.filterStats.totalOperations++;
+              if (!shouldIncludeOperation(operation, path2, method, this.options.operationFilters, this.filterStats)) {
+                continue;
+              }
+              this.filterStats.includedOperations++;
               if ("requestBody" in operation && operation.requestBody && typeof operation.requestBody === "object" && "content" in operation.requestBody && operation.requestBody.content) {
                 for (const mediaType of Object.values(operation.requestBody.content)) {
                   if (mediaType && typeof mediaType === "object" && "schema" in mediaType && mediaType.schema) {
@@ -6860,12 +7034,15 @@ ${typeCode}`;
         if (!this.spec.paths) {
           return;
         }
-        for (const [_path, pathItem] of Object.entries(this.spec.paths)) {
+        for (const [path2, pathItem] of Object.entries(this.spec.paths)) {
           if (!pathItem || typeof pathItem !== "object") continue;
           const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
           for (const method of methods) {
             const operation = pathItem[method];
             if (!operation) continue;
+            if (!shouldIncludeOperation(operation, path2, method, this.options.operationFilters)) {
+              continue;
+            }
             if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
               continue;
             }
@@ -6926,6 +7103,80 @@ ${propsCode}
             const jsdoc = `/**
  * Query parameters for ${operation.operationId}
  */
+`;
+            const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
+            this.schemas.set(schemaName, fullSchemaCode);
+            this.needsZodImport = true;
+          }
+        }
+      }
+      /**
+       * Generate header parameter schemas for each operation
+       * Header parameters are always string type (HTTP header semantics)
+       */
+      generateHeaderParameterSchemas() {
+        var _a;
+        if (!this.spec.paths) {
+          return;
+        }
+        for (const [path2, pathItem] of Object.entries(this.spec.paths)) {
+          if (!pathItem || typeof pathItem !== "object") continue;
+          const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+          for (const method of methods) {
+            const operation = pathItem[method];
+            if (!operation) continue;
+            if (!shouldIncludeOperation(operation, path2, method, this.options.operationFilters)) {
+              continue;
+            }
+            if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
+              continue;
+            }
+            const headerParams = operation.parameters.filter(
+              (param) => param && typeof param === "object" && param.in === "header"
+            );
+            if (headerParams.length === 0) {
+              continue;
+            }
+            const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+            const schemaName = `${pascalOperationId}HeaderParams`;
+            if (!this.schemaDependencies.has(schemaName)) {
+              this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
+            }
+            const properties = {};
+            for (const param of headerParams) {
+              const paramName = param.name;
+              const paramSchema = param.schema;
+              if (!paramSchema) continue;
+              let zodType = "z.string()";
+              if (param.description && this.requestOptions.includeDescriptions) {
+                if (this.requestOptions.useDescribe) {
+                  zodType = `${zodType}.describe(${JSON.stringify(param.description)})`;
+                }
+              }
+              zodType = `${zodType}.optional()`;
+              properties[paramName] = zodType;
+              if (paramSchema.$ref) {
+                const refName = resolveRef(paramSchema.$ref);
+                (_a = this.schemaDependencies.get(schemaName)) == null ? void 0 : _a.add(refName);
+              }
+            }
+            const objectMode = this.requestOptions.mode;
+            const zodMethod = objectMode === "strict" ? "strictObject" : objectMode === "loose" ? "looseObject" : "object";
+            const propsCode = Object.entries(properties).map(([key, value]) => {
+              const needsQuotes = !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+              const quotedKey = needsQuotes ? `"${key}"` : key;
+              return `  ${quotedKey}: ${value}`;
+            }).join(",\n");
+            const schemaCode = `z.${zodMethod}({
+${propsCode}
+})`;
+            const operationName = pascalOperationId;
+            const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
+            const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
+            const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}HeaderParamsSchema`;
+            const jsdoc = `/**
+ * Header parameters for ${operation.operationId}
+ */
 `;
             const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
             this.schemas.set(schemaName, fullSchemaCode);
@@ -7203,15 +7454,23 @@ ${props.join("\n")}
             stats.withConstraints++;
           }
         }
-        return [
+        const output = [
           "// Generation Statistics:",
           `//   Total schemas: ${stats.totalSchemas}`,
           `//   Enums: ${stats.enums}`,
           `//   Circular references: ${stats.withCircularRefs}`,
           `//   Discriminated unions: ${stats.withDiscriminators}`,
-          `//   With constraints: ${stats.withConstraints}`,
-          `//   Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`
+          `//   With constraints: ${stats.withConstraints}`
         ];
+        if (this.options.operationFilters && this.filterStats.totalOperations > 0) {
+          output.push("//");
+          const filterStatsStr = formatFilterStatistics(this.filterStats);
+          for (const line of filterStatsStr.split("\n")) {
+            output.push(`//   ${line}`);
+          }
+        }
+        output.push(`//   Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+        return output;
       }
     };
   }
@@ -7221,7 +7480,7 @@ ${props.join("\n")}
 async function processSpec(spec, index, total) {
   console.log(`Processing [${index + 1}/${total}] ${spec.input}...`);
   try {
-    const generator = new ZodSchemaGenerator(spec);
+    const generator = new OpenApiGenerator(spec);
     generator.generate();
     console.log(`\u2713 Successfully generated ${spec.output}`);
     return {
@@ -7322,7 +7581,7 @@ var init_batch_executor = __esm({
     "use strict";
     init_esm_shims();
     init_errors();
-    init_generator();
+    init_openapi_generator();
   }
 });
 
@@ -7397,7 +7656,7 @@ function mergeConfigWithDefaults(config) {
     return merged;
   });
 }
-var TypeModeSchema, NativeEnumTypeSchema, RequestResponseOptionsSchema, GeneratorOptionsSchema, ConfigFileSchema, createTypeScriptLoader;
+var TypeModeSchema, NativeEnumTypeSchema, RequestResponseOptionsSchema, OperationFiltersSchema, OpenApiGeneratorOptionsSchema, ConfigFileSchema, createTypeScriptLoader;
 var init_config_loader = __esm({
   "src/utils/config-loader.ts"() {
     "use strict";
@@ -7412,7 +7671,18 @@ var init_config_loader = __esm({
       typeMode: TypeModeSchema.optional(),
       nativeEnumType: NativeEnumTypeSchema.optional()
     });
-    GeneratorOptionsSchema = z.strictObject({
+    OperationFiltersSchema = z.strictObject({
+      includeTags: z.array(z.string()).optional(),
+      excludeTags: z.array(z.string()).optional(),
+      includePaths: z.array(z.string()).optional(),
+      excludePaths: z.array(z.string()).optional(),
+      includeMethods: z.array(z.string()).optional(),
+      excludeMethods: z.array(z.string()).optional(),
+      includeOperationIds: z.array(z.string()).optional(),
+      excludeOperationIds: z.array(z.string()).optional(),
+      excludeDeprecated: z.boolean().optional()
+    });
+    OpenApiGeneratorOptionsSchema = z.strictObject({
       mode: z.enum(["strict", "normal", "loose"]).optional(),
       input: z.string(),
       output: z.string(),
@@ -7426,7 +7696,8 @@ var init_config_loader = __esm({
       nativeEnumType: NativeEnumTypeSchema.optional(),
       request: RequestResponseOptionsSchema.optional(),
       response: RequestResponseOptionsSchema.optional(),
-      name: z.string().optional()
+      name: z.string().optional(),
+      operationFilters: OperationFiltersSchema.optional()
     });
     ConfigFileSchema = z.strictObject({
       defaults: z.strictObject({
@@ -7440,9 +7711,10 @@ var init_config_loader = __esm({
         showStats: z.boolean().optional(),
         nativeEnumType: NativeEnumTypeSchema.optional(),
         request: RequestResponseOptionsSchema.optional(),
-        response: RequestResponseOptionsSchema.optional()
+        response: RequestResponseOptionsSchema.optional(),
+        operationFilters: OperationFiltersSchema.optional()
       }).optional(),
-      specs: z.array(GeneratorOptionsSchema).min(1, "At least one spec is required"),
+      specs: z.array(OpenApiGeneratorOptionsSchema).min(1, "At least one spec is required"),
       executionMode: z.enum(["parallel", "sequential"]).optional()
     });
     createTypeScriptLoader = () => {
@@ -7481,7 +7753,8 @@ var init_config_loader = __esm({
 });
 
 // src/cli.ts
-import { existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join } from "path";
 import { Command } from "commander";
 var require_cli = __commonJS({
   "src/cli.ts"() {
@@ -7532,6 +7805,36 @@ Breaking Changes (v2.0):
       }
     });
     program.parse();
+    function findSpecFiles() {
+      const specFolders = ["spec", "specs"];
+      const validExtensions = [".yaml", ".yml", ".json"];
+      const excludePatterns = ["node_modules", ".git", "dist", "build", "coverage"];
+      const allFiles = [];
+      for (const folder of specFolders) {
+        if (!existsSync2(folder)) continue;
+        try {
+          const entries = readdirSync(folder, { recursive: true, encoding: "utf-8" });
+          for (const entry of entries) {
+            const fullPath = join(folder, entry);
+            if (excludePatterns.some((pattern) => fullPath.includes(pattern))) continue;
+            try {
+              const stats = statSync(fullPath);
+              if (!stats.isFile()) continue;
+              const hasValidExt = validExtensions.some((ext) => fullPath.endsWith(ext));
+              if (!hasValidExt) continue;
+              const sizeKB = (stats.size / 1024).toFixed(2);
+              allFiles.push({ path: fullPath.replace(/\\/g, "/"), size: `${sizeKB} KB` });
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      allFiles.sort((a, b) => a.path.localeCompare(b.path));
+      const totalCount = allFiles.length;
+      const files = allFiles.slice(0, 20);
+      return { files, totalCount };
+    }
     async function executeConfigMode(options) {
       let config;
       try {
@@ -7565,14 +7868,66 @@ Breaking Changes (v2.0):
           return;
         }
       }
-      const response = await (0, import_prompts.default)([
-        {
+      const { files, totalCount } = findSpecFiles();
+      if (totalCount > 20) {
+        console.log(`Showing first 20 of ${totalCount} files found. Use manual entry to specify others.
+`);
+      }
+      let inputPath;
+      if (files.length > 0) {
+        const choices = [
+          ...files.map((f) => ({ title: `${f.path} (${f.size})`, value: f.path })),
+          { title: "\u2192 Enter manually...", value: "__MANUAL__" }
+        ];
+        const inputResponse = await (0, import_prompts.default)({
+          type: "select",
+          name: "input",
+          message: "Select OpenAPI spec file (YAML or JSON):",
+          choices
+        });
+        if (!inputResponse.input) {
+          console.log("\nInitialization cancelled.");
+          return;
+        }
+        if (inputResponse.input === "__MANUAL__") {
+          const manualResponse = await (0, import_prompts.default)({
+            type: "text",
+            name: "input",
+            message: "Input OpenAPI file path (YAML or JSON):",
+            initial: "openapi.{yaml,yml,json}",
+            validate: (value) => {
+              if (value.length === 0) return "Input path is required";
+              if (!existsSync2(value)) return "\u26A0\uFE0F  File does not exist. Continue anyway?";
+              return true;
+            }
+          });
+          if (!manualResponse.input) {
+            console.log("\nInitialization cancelled.");
+            return;
+          }
+          inputPath = manualResponse.input;
+        } else {
+          inputPath = inputResponse.input;
+        }
+      } else {
+        const manualResponse = await (0, import_prompts.default)({
           type: "text",
           name: "input",
-          message: "Input OpenAPI file path:",
-          initial: "openapi.yaml",
-          validate: (value) => value.length > 0 || "Input path is required"
-        },
+          message: "Input OpenAPI file path (YAML or JSON):",
+          initial: "openapi.{yaml,yml,json}",
+          validate: (value) => {
+            if (value.length === 0) return "Input path is required";
+            if (!existsSync2(value)) return "\u26A0\uFE0F  File does not exist. Continue anyway?";
+            return true;
+          }
+        });
+        if (!manualResponse.input) {
+          console.log("\nInitialization cancelled.");
+          return;
+        }
+        inputPath = manualResponse.input;
+      }
+      const response = await (0, import_prompts.default)([
         {
           type: "text",
           name: "output",
@@ -7597,11 +7952,12 @@ Breaking Changes (v2.0):
           initial: true
         }
       ]);
-      if (!response.input || !response.output || !response.format) {
+      if (!response.output || !response.format) {
         console.log("\nInitialization cancelled.");
         return;
       }
-      const { input, output, format, includeDefaults } = response;
+      const { output, format, includeDefaults } = response;
+      const input = inputPath;
       let configContent;
       let configFilename;
       if (format === "ts") {
@@ -7662,7 +8018,21 @@ export default defineConfig({
       console.log("\nNext steps:");
       console.log("  1. Review and customize your config file if needed");
       console.log("  2. Run 'openapi-to-zod' to generate schemas\n");
-      console.log("Things just got Cerios...\n");
+      const ceriosMessages = [
+        "Things just got Cerios!",
+        "Getting Cerios about schemas!",
+        "Cerios business ahead!",
+        "Don't take it too Cerios-ly!",
+        "Time to get Cerios!",
+        "We're dead Cerios about types!",
+        "This is Cerios-ly awesome!",
+        "Cerios-ly, you're all set!",
+        "You are Cerios right now!",
+        "Cerios vibes only!"
+      ];
+      const randomMessage = ceriosMessages[Math.floor(Math.random() * ceriosMessages.length)];
+      console.log(`${randomMessage}
+`);
     }
   }
 });