unify regex and update rules

Author: blva

src/tools/args.ts

@@ -1,17 +1,29 @@
 import { z, type ZodString } from "zod";
 
-// Shared validation constants
-const NO_SLASH_REGEX = /^[^/]*$/;
-const NO_SLASH_ERROR = "String cannot contain '/'";
+const NO_UNICODE_REGEX = /^[\x20-\x7E]*$/;
+const NO_UNICODE_ERROR = "String cannot contain special characters or Unicode symbols";
 
+const ALLOWED_NAME_CHARACTERS_REGEX = /^[a-zA-Z0-9._-]+$/;
+export const ALLOWED_CHARACTERS_ERROR = " can only contain letters, numbers, dots, hyphens, and underscores";
+
+const ALLLOWED_REGION_CHARACTERS_REGEX = /^[a-zA-Z0-9_-]+$/;
+export const ALLOWED_REGION_CHARACTERS_ERROR = "Region can only contain letters, numbers, hyphens, and underscores";
+
+const ALLOWED_CLUSTER_NAME_CHARACTERS_REGEX = /^[a-zA-Z0-9_-]+$/;
+export const ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR =
+    "Cluster names can only contain ASCII letters, numbers, and hyphens.";
+
+const ALLOWED_PROJECT_NAME_CHARACTERS_REGEX = /^[a-zA-Z0-9\s()@&+:._',-]+$/;
+export const ALLOWED_PROJECT_NAME_CHARACTERS_ERROR =
+    "Project names can't be longer than 64 characters and can only contain letters, numbers, spaces, and the following symbols: ( ) @ & + : . _ - ' ,";
 export const CommonArgs = {
-    string: (): ZodString =>
-        z.string().regex(/^[\x20-\x7E]*$/, "String cannot contain special characters or Unicode symbols"),
+    string: (): ZodString => z.string().regex(NO_UNICODE_REGEX, NO_UNICODE_ERROR),
 };
 
 export const AtlasArgs = {
     objectId: (fieldName: string): z.ZodString =>
-        CommonArgs.string()
+        z
+            .string()
             .min(1, `${fieldName} is required`)
             .regex(/^[0-9a-fA-F]{24}$/, `${fieldName} must be a valid 24-character hexadecimal string`),
 
@@ -20,40 +32,37 @@ export const AtlasArgs = {
     organizationId: (): z.ZodString => AtlasArgs.objectId("organizationId"),
 
     clusterName: (): z.ZodString =>
-        CommonArgs.string()
+        z
+            .string()
             .min(1, "Cluster name is required")
             .max(64, "Cluster name must be 64 characters or less")
-            .regex(NO_SLASH_REGEX, NO_SLASH_ERROR)
-            .regex(/^[a-zA-Z0-9_-]+$/, "Cluster name can only contain letters, numbers, hyphens, and underscores"),
+            .regex(ALLOWED_CLUSTER_NAME_CHARACTERS_REGEX, "Cluster name " + ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR),
 
     projectName: (): z.ZodString =>
-        CommonArgs.string()
+        z
+            .string()
             .min(1, "Project name is required")
             .max(64, "Project name must be 64 characters or less")
-            .regex(NO_SLASH_REGEX, NO_SLASH_ERROR)
-            .regex(/^[a-zA-Z0-9_-]+$/, "Project name can only contain letters, numbers, hyphens, and underscores"),
+            .regex(ALLOWED_PROJECT_NAME_CHARACTERS_REGEX, ALLOWED_PROJECT_NAME_CHARACTERS_ERROR),
 
     username: (): z.ZodString =>
-        CommonArgs.string()
+        z
+            .string()
             .min(1, "Username is required")
             .max(100, "Username must be 100 characters or less")
-            .regex(NO_SLASH_REGEX, NO_SLASH_ERROR)
-            .regex(/^[a-zA-Z0-9._-]+$/, "Username can only contain letters, numbers, dots, hyphens, and underscores"),
+            .regex(ALLOWED_NAME_CHARACTERS_REGEX, "Username " + ALLOWED_CHARACTERS_ERROR),
 
-    ipAddress: (): z.ZodString => CommonArgs.string().ip({ version: "v4" }),
+    ipAddress: (): z.ZodString => z.string().ip({ version: "v4" }),
 
-    cidrBlock: (): z.ZodString => CommonArgs.string().cidr(),
+    cidrBlock: (): z.ZodString => z.string().cidr(),
 
     region: (): z.ZodString =>
-        CommonArgs.string()
+        z
+            .string()
             .min(1, "Region is required")
             .max(50, "Region must be 50 characters or less")
-            .regex(/^[a-zA-Z0-9_-]+$/, "Region can only contain letters, numbers, hyphens, and underscores"),
+            .regex(ALLLOWED_REGION_CHARACTERS_REGEX, ALLOWED_REGION_CHARACTERS_ERROR),
 
     password: (): z.ZodString =>
-        CommonArgs.string()
-            .min(1, "Password is required")
-            .max(100, "Password must be 100 characters or less")
-            .regex(NO_SLASH_REGEX, NO_SLASH_ERROR)
-            .regex(/^[a-zA-Z0-9._-]+$/, "Password can only contain letters, numbers, dots, hyphens, and underscores"),
+        z.string().min(1, "Password is required").max(100, "Password must be 100 characters or less"),
 };

tests/unit/args.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, it } from "vitest";
-import { AtlasArgs, CommonArgs } from "../../src/tools/args.js";
+import {
+    AtlasArgs,
+    CommonArgs,
+    ALLOWED_PROJECT_NAME_CHARACTERS_ERROR,
+    ALLOWED_CHARACTERS_ERROR,
+    ALLOWED_REGION_CHARACTERS_ERROR,
+    ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR,
+} from "../../src/tools/args.js";
 
 describe("Tool args", () => {
     describe("CommonArgs", () => {
@@ -104,6 +111,13 @@ describe("Tool args", () => {
                 expect(() => schema.parse("invalid")).toThrow(
                     "projectId must be a valid 24-character hexadecimal string"
                 );
+                expect(() => schema.parse("507f1f77bc*86cd79943901")).toThrow(
+                    "projectId must be a valid 24-character hexadecimal string"
+                );
+                expect(() => schema.parse("")).toThrow("projectId is required");
+                expect(() => schema.parse("507f1f77/bcf86cd799439011")).toThrow(
+                    "projectId must be a valid 24-character hexadecimal string"
+                );
             });
         });
 
@@ -144,13 +158,17 @@ describe("Tool args", () => {
 
                 // Invalid characters
                 expect(() => schema.parse("cluster@name")).toThrow(
-                    "Cluster name can only contain letters, numbers, hyphens, and underscores"
+                    "Cluster name " + ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR
                 );
                 expect(() => schema.parse("cluster name")).toThrow(
-                    "Cluster name can only contain letters, numbers, hyphens, and underscores"
+                    "Cluster name " + ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR
                 );
                 expect(() => schema.parse("cluster.name")).toThrow(
-                    "Cluster name can only contain letters, numbers, hyphens, and underscores"
+                    "Cluster name " + ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR
+                );
+
+                expect(() => schema.parse("cluster/name")).toThrow(
+                    "Cluster name " + ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR
                 );
             });
 
@@ -182,12 +200,8 @@ describe("Tool args", () => {
                 expect(() => schema.parse(longUsername)).toThrow("Username must be 100 characters or less");
 
                 // Invalid characters
-                expect(() => schema.parse("user@name")).toThrow(
-                    "Username can only contain letters, numbers, dots, hyphens, and underscores"
-                );
-                expect(() => schema.parse("user name")).toThrow(
-                    "Username can only contain letters, numbers, dots, hyphens, and underscores"
-                );
+                expect(() => schema.parse("user@name")).toThrow("Username " + ALLOWED_CHARACTERS_ERROR);
+                expect(() => schema.parse("user name")).toThrow("Username " + ALLOWED_CHARACTERS_ERROR);
             });
 
             it("should accept exactly 100 characters", () => {
@@ -278,22 +292,32 @@ describe("Tool args", () => {
                 expect(() => schema.parse(longRegion)).toThrow("Region must be 50 characters or less");
 
                 // Invalid characters
-                expect(() => schema.parse("US EAST 1")).toThrow(
-                    "Region can only contain letters, numbers, hyphens, and underscores"
-                );
-                expect(() => schema.parse("US.EAST.1")).toThrow(
-                    "Region can only contain letters, numbers, hyphens, and underscores"
-                );
-                expect(() => schema.parse("US@EAST#1")).toThrow(
-                    "Region can only contain letters, numbers, hyphens, and underscores"
-                );
+                expect(() => schema.parse("US EAST 1")).toThrow(ALLOWED_REGION_CHARACTERS_ERROR);
+                expect(() => schema.parse("US.EAST.1")).toThrow(ALLOWED_REGION_CHARACTERS_ERROR);
+                expect(() => schema.parse("US@EAST#1")).toThrow(ALLOWED_REGION_CHARACTERS_ERROR);
             });
         });
 
         describe("projectName", () => {
             it("should validate valid project names", () => {
                 const schema = AtlasArgs.projectName();
-                const validNames = ["my-project", "project_1", "Project123", "test-project-2", "my_project_name"];
+                const validNames = [
+                    "my-project",
+                    "project_1",
+                    "Project123",
+                    "test-project-2",
+                    "my_project_name",
+                    "project with spaces",
+                    "project(with)parentheses",
+                    "project@with@at",
+                    "project&with&ampersand",
+                    "project+with+plus",
+                    "project:with:colon",
+                    "project.with.dots",
+                    "project'with'apostrophe",
+                    "project,with,comma",
+                    "complex project (with) @all &symbols+here:test.name'value,",
+                ];
 
                 validNames.forEach((name) => {
                     expect(schema.parse(name)).toBe(name);
@@ -302,11 +326,24 @@ describe("Tool args", () => {
 
             it("should reject invalid project names", () => {
                 const schema = AtlasArgs.projectName();
+
+                // Empty string
                 expect(() => schema.parse("")).toThrow("Project name is required");
+
+                // Too long (over 64 characters)
                 expect(() => schema.parse("a".repeat(65))).toThrow("Project name must be 64 characters or less");
-                expect(() => schema.parse("invalid@name")).toThrow(
-                    "Project name can only contain letters, numbers, hyphens, and underscores"
-                );
+
+                // Invalid characters not in the allowed set
+                expect(() => schema.parse("project#with#hash")).toThrow(ALLOWED_PROJECT_NAME_CHARACTERS_ERROR);
+                expect(() => schema.parse("project$with$dollar")).toThrow(ALLOWED_PROJECT_NAME_CHARACTERS_ERROR);
+                expect(() => schema.parse("project!with!exclamation")).toThrow(ALLOWED_PROJECT_NAME_CHARACTERS_ERROR);
+                expect(() => schema.parse("project[with]brackets")).toThrow(ALLOWED_PROJECT_NAME_CHARACTERS_ERROR);
+            });
+
+            it("should accept exactly 64 characters", () => {
+                const schema = AtlasArgs.projectName();
+                const maxLengthName = "a".repeat(64);
+                expect(schema.parse(maxLengthName)).toBe(maxLengthName);
             });
         });
 
@@ -324,9 +361,6 @@ describe("Tool args", () => {
                 const schema = AtlasArgs.password();
                 expect(() => schema.parse("")).toThrow("Password is required");
                 expect(() => schema.parse("a".repeat(101))).toThrow("Password must be 100 characters or less");
-                expect(() => schema.parse("invalid password")).toThrow(
-                    "Password can only contain letters, numbers, dots, hyphens, and underscores"
-                );
             });
         });
     });
@@ -366,16 +400,14 @@ describe("Tool args", () => {
                 "Cluster name must be 64 characters or less"
             );
             expect(() => AtlasArgs.clusterName().parse("invalid@name")).toThrow(
-                "Cluster name can only contain letters, numbers, hyphens, and underscores"
+                "Cluster name " + ALLOWED_CLUSTER_NAME_CHARACTERS_ERROR
             );
 
             expect(() => AtlasArgs.username().parse("")).toThrow("Username is required");
             expect(() => AtlasArgs.username().parse("a".repeat(101))).toThrow(
                 "Username must be 100 characters or less"
             );
-            expect(() => AtlasArgs.username().parse("invalid name")).toThrow(
-                "Username can only contain letters, numbers, dots, hyphens, and underscores"
-            );
+            expect(() => AtlasArgs.username().parse("invalid name")).toThrow("Username " + ALLOWED_CHARACTERS_ERROR);
         });
     });
 });