@solutionspool/node-micro-contracts 1.0.0

package/middleware/validate.js

@@ -0,0 +1,75 @@
+/**
+ * Zod Validation Middleware Factory
+ *
+ * Creates middleware to validate request body against Zod schemas
+ */
+
+function validateRequest(schema) {
+  return (req, res, next) => {
+    const result = schema.safeParse(req.body);
+
+    if (!result.success) {
+      return res.status(400).json({
+        error: "Validation failed",
+        details: result.error.errors.map((err) => ({
+          path: err.path.join("."),
+          message: err.message,
+        })),
+      });
+    }
+
+    // Attach validated data to request
+    req.validatedData = result.data;
+    next();
+  };
+}
+
+/**
+ * Validate query parameters
+ */
+function validateQuery(schema) {
+  return (req, res, next) => {
+    const result = schema.safeParse(req.query);
+
+    if (!result.success) {
+      return res.status(400).json({
+        error: "Query validation failed",
+        details: result.error.errors.map((err) => ({
+          path: err.path.join("."),
+          message: err.message,
+        })),
+      });
+    }
+
+    req.validatedQuery = result.data;
+    next();
+  };
+}
+
+/**
+ * Validate request parameters
+ */
+function validateParams(schema) {
+  return (req, res, next) => {
+    const result = schema.safeParse(req.params);
+
+    if (!result.success) {
+      return res.status(400).json({
+        error: "Parameter validation failed",
+        details: result.error.errors.map((err) => ({
+          path: err.path.join("."),
+          message: err.message,
+        })),
+      });
+    }
+
+    req.validatedParams = result.data;
+    next();
+  };
+}
+
+module.exports = {
+  validateRequest,
+  validateQuery,
+  validateParams,
+};

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@solutionspool/node-micro-contracts",
+  "version": "1.0.0",
+  "description": "Shared contracts and schemas for node-micro services",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "contracts",
+    "schemas",
+    "zod",
+    "microservices"
+  ],
+  "license": "ISC",
+  "dependencies": {
+    "zod": "^3.22.4"
+  }
+}

package/schemas/common.schema.js

@@ -0,0 +1,33 @@
+const { z } = require("zod");
+
+/**
+ * Param Validation Schemas
+ */
+
+// UUID parameter validation
+const UUIDParamSchema = z.object({
+  id: z.string().uuid("Invalid user ID"),
+});
+
+/**
+ * Query Validation Schemas
+ */
+
+// User search query validation
+const UserSearchQuerySchema = z.object({
+  name: z.string().trim().min(1, "Name must be a non-empty string").optional(),
+  email: z.string().email("Invalid email format").optional(),
+  mobile: z
+    .string()
+    .trim()
+    .min(1, "Mobile must be a non-empty string")
+    .optional(),
+});
+
+module.exports = {
+  // Param Schemas
+  UUIDParamSchema,
+
+  // Query Schemas
+  UserSearchQuerySchema,
+};

package/schemas/events.schema.js

@@ -0,0 +1,55 @@
+const { z } = require("zod");
+const { UserRole } = require("./user.schema");
+
+/**
+ * User Registered Event Schema
+ * Published by auth-service when a user registers
+ * Consumed by user-service to create user profile
+ */
+const UserRegisteredEventSchema = z.object({
+  userId: z.string().uuid(),
+  name: z.string(),
+  email: z.string().email(),
+  mobile: z.string().optional(),
+  role: UserRole,
+  createdAt: z.union([z.string(), z.date()]),
+});
+
+/**
+ * User Verified Event Schema
+ * Published when a user verifies their email
+ */
+const UserVerifiedEventSchema = z.object({
+  userId: z.string().uuid(),
+  email: z.string().email(),
+  verifiedAt: z.union([z.string(), z.date()]),
+});
+
+/**
+ * User Updated Event Schema
+ * Published when a user's profile is updated
+ */
+const UserUpdatedEventSchema = z.object({
+  userId: z.string().uuid(),
+  name: z.string().optional(),
+  email: z.string().email().optional(),
+  role: UserRole.optional(),
+  updatedAt: z.union([z.string(), z.date()]),
+});
+
+/**
+ * User Deleted Event Schema
+ * Published when a user account is deleted
+ */
+const UserDeletedEventSchema = z.object({
+  userId: z.string().uuid(),
+  email: z.string().email(),
+  deletedAt: z.union([z.string(), z.date()]),
+});
+
+module.exports = {
+  UserRegisteredEventSchema,
+  UserVerifiedEventSchema,
+  UserUpdatedEventSchema,
+  UserDeletedEventSchema,
+};

package/schemas/user.schema.js

@@ -0,0 +1,91 @@
+const { z } = require("zod");
+
+/**
+ * User Role Enum
+ */
+const UserRole = z.enum(["user", "provider", "admin"]);
+
+/**
+ * User Base Schema - Common fields
+ */
+const UserBaseSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1, "Name is required"),
+  email: z.string().email("Invalid email format"),
+  role: UserRole,
+  createdAt: z.union([z.string(), z.date()]).optional(),
+  updatedAt: z.union([z.string(), z.date()]).optional(),
+});
+
+/**
+ * User Registration Request Schema
+ */
+const UserRegistrationSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  email: z.string().email("Invalid email format"),
+  mobile: z.string().optional(),
+  password: z.string().min(6, "Password must be at least 6 characters"),
+  role: UserRole.optional().default("user"),
+});
+
+/**
+ * User Login Request Schema
+ */
+const UserLoginSchema = z.object({
+  email: z.string().email("Invalid email format"),
+  password: z.string().min(1, "Password is required"),
+});
+
+/**
+ * User Profile Update Schema
+ */
+const UserProfileUpdateSchema = z.object({
+  name: z.string().min(1, "Name is required").optional(),
+  email: z.string().email("Invalid email format").optional(),
+  role: UserRole.optional(),
+});
+
+/**
+ * User Response Schema (without password)
+ */
+const UserResponseSchema = UserBaseSchema.extend({
+  mobile: z.string().optional(),
+});
+
+/**
+ * JWT Token Payload Schema
+ */
+const JWTPayloadSchema = z.object({
+  iss: z.string(), // Issuer
+  sub: z.string().uuid(), // Subject (user ID)
+  id: z.string().uuid(),
+  email: z.string().email(),
+  role: UserRole,
+  iat: z.number().optional(), // Issued at
+  exp: z.number().optional(), // Expiration
+});
+
+/**
+ * Auth Response Schema
+ */
+const AuthResponseSchema = z.object({
+  message: z.string(),
+  token: z.string(),
+  user: UserResponseSchema,
+});
+
+module.exports = {
+  // Enums
+  UserRole,
+
+  // User Schemas
+  UserBaseSchema,
+  UserRegistrationSchema,
+  UserLoginSchema,
+  UserProfileUpdateSchema,
+  UserResponseSchema,
+
+  // JWT Schemas
+  JWTPayloadSchema,
+  AuthResponseSchema,
+};

package/test-contracts.js

@@ -0,0 +1,229 @@
+/**
+ * Test file to verify contracts are working correctly
+ * Run with: node test-contracts.js
+ */
+
+const {
+  // Schemas
+  UserRegistrationSchema,
+  UserLoginSchema,
+  UserProfileUpdateSchema,
+  UserRegisteredEventSchema,
+  UserRole,
+
+  // Middleware
+  validateRequest,
+} = require("./index");
+
+console.log("🧪 Testing @node-micro/contracts\n");
+
+// Test 1: Valid User Registration
+console.log("Test 1: Valid User Registration");
+try {
+  const validRegistration = {
+    name: "John Doe",
+    email: "john@example.com",
+    password: "password123",
+    role: "user",
+    mobile: "+1234567890",
+  };
+
+  const result = UserRegistrationSchema.safeParse(validRegistration);
+  if (result.success) {
+    console.log("✅ PASS - Valid registration data accepted");
+  } else {
+    console.log("❌ FAIL - Valid data rejected");
+    console.log(result.error.errors);
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 2: Invalid Email
+console.log("\nTest 2: Invalid Email");
+try {
+  const invalidEmail = {
+    name: "John Doe",
+    email: "not-an-email",
+    password: "password123",
+  };
+
+  const result = UserRegistrationSchema.safeParse(invalidEmail);
+  if (!result.success) {
+    console.log("✅ PASS - Invalid email rejected");
+    console.log("   Error:", result.error.errors[0].message);
+  } else {
+    console.log("❌ FAIL - Invalid email accepted");
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 3: Short Password
+console.log("\nTest 3: Short Password");
+try {
+  const shortPassword = {
+    name: "John Doe",
+    email: "john@example.com",
+    password: "123",
+  };
+
+  const result = UserRegistrationSchema.safeParse(shortPassword);
+  if (!result.success) {
+    console.log("✅ PASS - Short password rejected");
+    console.log("   Error:", result.error.errors[0].message);
+  } else {
+    console.log("❌ FAIL - Short password accepted");
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 4: Invalid Role
+console.log("\nTest 4: Invalid Role");
+try {
+  const invalidRole = {
+    name: "John Doe",
+    email: "john@example.com",
+    password: "password123",
+    role: "superadmin", // Not a valid role
+  };
+
+  const result = UserRegistrationSchema.safeParse(invalidRole);
+  if (!result.success) {
+    console.log("✅ PASS - Invalid role rejected");
+    console.log("   Error:", result.error.errors[0].message);
+  } else {
+    console.log("❌ FAIL - Invalid role accepted");
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 5: Valid Login
+console.log("\nTest 5: Valid Login");
+try {
+  const validLogin = {
+    email: "john@example.com",
+    password: "password123",
+  };
+
+  const result = UserLoginSchema.safeParse(validLogin);
+  if (result.success) {
+    console.log("✅ PASS - Valid login data accepted");
+  } else {
+    console.log("❌ FAIL - Valid login data rejected");
+    console.log(result.error.errors);
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 6: Valid Event Data
+console.log("\nTest 6: Valid Event Data");
+try {
+  const validEvent = {
+    userId: "123e4567-e89b-12d3-a456-426614174000",
+    name: "John Doe",
+    email: "john@example.com",
+    mobile: "+1234567890",
+    role: "user",
+    createdAt: new Date(),
+  };
+
+  const result = UserRegisteredEventSchema.safeParse(validEvent);
+  if (result.success) {
+    console.log("✅ PASS - Valid event data accepted");
+  } else {
+    console.log("❌ FAIL - Valid event data rejected");
+    console.log(result.error.errors);
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 7: Invalid UUID in Event
+console.log("\nTest 7: Invalid UUID in Event");
+try {
+  const invalidUUID = {
+    userId: "not-a-uuid",
+    name: "John Doe",
+    email: "john@example.com",
+    role: "user",
+    createdAt: new Date(),
+  };
+
+  const result = UserRegisteredEventSchema.safeParse(invalidUUID);
+  if (!result.success) {
+    console.log("✅ PASS - Invalid UUID rejected");
+    console.log("   Error:", result.error.errors[0].message);
+  } else {
+    console.log("❌ FAIL - Invalid UUID accepted");
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 8: Profile Update (Partial Data)
+console.log("\nTest 8: Profile Update (Partial Data)");
+try {
+  const partialUpdate = {
+    name: "Jane Doe", // Only updating name
+  };
+
+  const result = UserProfileUpdateSchema.safeParse(partialUpdate);
+  if (result.success) {
+    console.log("✅ PASS - Partial update accepted");
+  } else {
+    console.log("❌ FAIL - Partial update rejected");
+    console.log(result.error.errors);
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 9: Default Role
+console.log("\nTest 9: Default Role");
+try {
+  const noRole = {
+    name: "John Doe",
+    email: "john@example.com",
+    password: "password123",
+    // role not provided
+  };
+
+  const result = UserRegistrationSchema.safeParse(noRole);
+  if (result.success && result.data.role === "user") {
+    console.log("✅ PASS - Default role 'user' applied");
+  } else {
+    console.log("❌ FAIL - Default role not applied");
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+// Test 10: UserRole Enum
+console.log("\nTest 10: UserRole Enum");
+try {
+  const validRoles = ["user", "provider", "admin"];
+  const allValid = validRoles.every((role) => {
+    const result = UserRole.safeParse(role);
+    return result.success;
+  });
+
+  const invalidResult = UserRole.safeParse("invalid");
+
+  if (allValid && !invalidResult.success) {
+    console.log("✅ PASS - UserRole enum works correctly");
+  } else {
+    console.log("❌ FAIL - UserRole enum validation failed");
+  }
+} catch (error) {
+  console.log("❌ FAIL - Unexpected error:", error.message);
+}
+
+console.log("\n✨ Testing complete!");
+console.log("\nTo use in your services:");
+console.log(
+  '  const { UserRegistrationSchema, validateRequest } = require("@node-micro/contracts");',
+);