servcraft 0.1.0

package/src/utils/response.ts

@@ -0,0 +1,63 @@
+import type { FastifyReply } from 'fastify';
+import type { ApiResponse } from '../types/index.js';
+
+export function success<T>(reply: FastifyReply, data: T, statusCode = 200): FastifyReply {
+  const response: ApiResponse<T> = {
+    success: true,
+    data,
+  };
+  return reply.status(statusCode).send(response);
+}
+
+export function created<T>(reply: FastifyReply, data: T): FastifyReply {
+  return success(reply, data, 201);
+}
+
+export function noContent(reply: FastifyReply): FastifyReply {
+  return reply.status(204).send();
+}
+
+export function error(
+  reply: FastifyReply,
+  message: string,
+  statusCode = 400,
+  errors?: Record<string, string[]>
+): FastifyReply {
+  const response: ApiResponse = {
+    success: false,
+    message,
+    errors,
+  };
+  return reply.status(statusCode).send(response);
+}
+
+export function notFound(reply: FastifyReply, message = 'Resource not found'): FastifyReply {
+  return error(reply, message, 404);
+}
+
+export function unauthorized(reply: FastifyReply, message = 'Unauthorized'): FastifyReply {
+  return error(reply, message, 401);
+}
+
+export function forbidden(reply: FastifyReply, message = 'Forbidden'): FastifyReply {
+  return error(reply, message, 403);
+}
+
+export function badRequest(
+  reply: FastifyReply,
+  message = 'Bad request',
+  errors?: Record<string, string[]>
+): FastifyReply {
+  return error(reply, message, 400, errors);
+}
+
+export function conflict(reply: FastifyReply, message = 'Resource already exists'): FastifyReply {
+  return error(reply, message, 409);
+}
+
+export function internalError(
+  reply: FastifyReply,
+  message = 'Internal server error'
+): FastifyReply {
+  return error(reply, message, 500);
+}

package/tests/integration/auth.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import Fastify from 'fastify';
+import type { FastifyInstance } from 'fastify';
+
+// Note: This is a placeholder for integration tests
+// In a real scenario, you would set up the full app with database connections
+
+describe('Auth Integration Tests', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = Fastify();
+
+    // Mock health endpoint for basic test
+    app.get('/health', async () => ({
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+    }));
+
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  describe('Health Check', () => {
+    it('should return health status', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/health',
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body.status).toBe('ok');
+      expect(body.timestamp).toBeDefined();
+    });
+  });
+
+  // Placeholder tests - would require full app setup
+  describe('Authentication Endpoints (Placeholder)', () => {
+    it.skip('POST /auth/register - should register a new user', async () => {
+      // This test would require the full app setup with database
+    });
+
+    it.skip('POST /auth/login - should login a user', async () => {
+      // This test would require the full app setup with database
+    });
+
+    it.skip('POST /auth/refresh - should refresh tokens', async () => {
+      // This test would require the full app setup with database
+    });
+
+    it.skip('POST /auth/logout - should logout a user', async () => {
+      // This test would require the full app setup with database
+    });
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,17 @@
+import { beforeAll, afterAll, afterEach } from 'vitest';
+
+// Set test environment
+process.env.NODE_ENV = 'test';
+process.env.LOG_LEVEL = 'error'; // Reduce log noise during tests
+
+beforeAll(async () => {
+  // Setup code that runs before all tests
+});
+
+afterAll(async () => {
+  // Cleanup code that runs after all tests
+});
+
+afterEach(async () => {
+  // Cleanup code that runs after each test
+});

package/tests/unit/modules/validation.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import {
+  validate,
+  validateBody,
+  validateQuery,
+  emailSchema,
+  passwordSchema,
+} from '../../../src/modules/validation/validator.js';
+import { ValidationError } from '../../../src/utils/errors.js';
+
+describe('Validation Module', () => {
+  describe('validate', () => {
+    const testSchema = z.object({
+      name: z.string().min(2),
+      age: z.number().positive(),
+    });
+
+    it('should return validated data for valid input', () => {
+      const input = { name: 'John', age: 25 };
+      const result = validate(testSchema, input);
+      expect(result).toEqual(input);
+    });
+
+    it('should throw ValidationError for invalid input', () => {
+      const input = { name: 'J', age: -1 };
+      expect(() => validate(testSchema, input)).toThrow(ValidationError);
+    });
+
+    it('should include field errors in ValidationError', () => {
+      const input = { name: 'J', age: -1 };
+      try {
+        validate(testSchema, input);
+      } catch (error) {
+        if (error instanceof ValidationError) {
+          expect(error.errors).toHaveProperty('name');
+          expect(error.errors).toHaveProperty('age');
+        }
+      }
+    });
+  });
+
+  describe('emailSchema', () => {
+    it('should accept valid emails', () => {
+      const validEmails = [
+        'test@example.com',
+        'user.name@domain.org',
+        'user+tag@example.co.uk',
+      ];
+
+      validEmails.forEach((email) => {
+        expect(() => emailSchema.parse(email)).not.toThrow();
+      });
+    });
+
+    it('should reject invalid emails', () => {
+      const invalidEmails = ['notanemail', '@example.com', 'test@', 'test@.com'];
+
+      invalidEmails.forEach((email) => {
+        expect(() => emailSchema.parse(email)).toThrow();
+      });
+    });
+  });
+
+  describe('passwordSchema', () => {
+    it('should accept strong passwords', () => {
+      const validPasswords = ['Password1!', 'Str0ng@Pass', 'MyP@ssw0rd'];
+
+      validPasswords.forEach((password) => {
+        expect(() => passwordSchema.parse(password)).not.toThrow();
+      });
+    });
+
+    it('should reject weak passwords', () => {
+      const invalidPasswords = [
+        'short',           // Too short
+        'nouppercase1!',   // No uppercase
+        'NOLOWERCASE1!',   // No lowercase
+        'NoNumbers!',      // No numbers
+        'NoSpecial1',      // No special chars
+      ];
+
+      invalidPasswords.forEach((password) => {
+        expect(() => passwordSchema.parse(password)).toThrow();
+      });
+    });
+  });
+});

package/tests/unit/utils/errors.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import {
+  AppError,
+  NotFoundError,
+  UnauthorizedError,
+  ForbiddenError,
+  BadRequestError,
+  ConflictError,
+  ValidationError,
+  TooManyRequestsError,
+  isAppError,
+} from '../../../src/utils/errors.js';
+
+describe('Error Classes', () => {
+  describe('AppError', () => {
+    it('should create error with default values', () => {
+      const error = new AppError('Test error');
+      expect(error.message).toBe('Test error');
+      expect(error.statusCode).toBe(500);
+      expect(error.isOperational).toBe(true);
+    });
+
+    it('should create error with custom status code', () => {
+      const error = new AppError('Custom error', 418);
+      expect(error.statusCode).toBe(418);
+    });
+
+    it('should include errors object', () => {
+      const errors = { field: ['error message'] };
+      const error = new AppError('Validation error', 400, true, errors);
+      expect(error.errors).toEqual(errors);
+    });
+  });
+
+  describe('NotFoundError', () => {
+    it('should have 404 status code', () => {
+      const error = new NotFoundError('User');
+      expect(error.statusCode).toBe(404);
+      expect(error.message).toBe('User not found');
+    });
+
+    it('should use default message', () => {
+      const error = new NotFoundError();
+      expect(error.message).toBe('Resource not found');
+    });
+  });
+
+  describe('UnauthorizedError', () => {
+    it('should have 401 status code', () => {
+      const error = new UnauthorizedError();
+      expect(error.statusCode).toBe(401);
+      expect(error.message).toBe('Unauthorized');
+    });
+  });
+
+  describe('ForbiddenError', () => {
+    it('should have 403 status code', () => {
+      const error = new ForbiddenError();
+      expect(error.statusCode).toBe(403);
+      expect(error.message).toBe('Forbidden');
+    });
+  });
+
+  describe('BadRequestError', () => {
+    it('should have 400 status code', () => {
+      const error = new BadRequestError();
+      expect(error.statusCode).toBe(400);
+    });
+
+    it('should include validation errors', () => {
+      const errors = { email: ['Invalid email'] };
+      const error = new BadRequestError('Invalid input', errors);
+      expect(error.errors).toEqual(errors);
+    });
+  });
+
+  describe('ConflictError', () => {
+    it('should have 409 status code', () => {
+      const error = new ConflictError();
+      expect(error.statusCode).toBe(409);
+    });
+  });
+
+  describe('ValidationError', () => {
+    it('should have 422 status code', () => {
+      const errors = { name: ['Required'] };
+      const error = new ValidationError(errors);
+      expect(error.statusCode).toBe(422);
+      expect(error.errors).toEqual(errors);
+    });
+  });
+
+  describe('TooManyRequestsError', () => {
+    it('should have 429 status code', () => {
+      const error = new TooManyRequestsError();
+      expect(error.statusCode).toBe(429);
+    });
+  });
+
+  describe('isAppError', () => {
+    it('should return true for AppError instances', () => {
+      expect(isAppError(new AppError('test'))).toBe(true);
+      expect(isAppError(new NotFoundError())).toBe(true);
+      expect(isAppError(new ValidationError({}))).toBe(true);
+    });
+
+    it('should return false for other errors', () => {
+      expect(isAppError(new Error('test'))).toBe(false);
+      expect(isAppError(null)).toBe(false);
+      expect(isAppError('error')).toBe(false);
+    });
+  });
+});

package/tests/unit/utils/pagination.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parsePaginationParams,
+  createPaginatedResult,
+  getSkip,
+  DEFAULT_PAGE,
+  DEFAULT_LIMIT,
+  MAX_LIMIT,
+} from '../../../src/utils/pagination.js';
+
+describe('Pagination Utils', () => {
+  describe('parsePaginationParams', () => {
+    it('should return default values when no params provided', () => {
+      const result = parsePaginationParams({});
+      expect(result.page).toBe(DEFAULT_PAGE);
+      expect(result.limit).toBe(DEFAULT_LIMIT);
+      expect(result.sortOrder).toBe('asc');
+    });
+
+    it('should parse page and limit from query', () => {
+      const result = parsePaginationParams({ page: '3', limit: '50' });
+      expect(result.page).toBe(3);
+      expect(result.limit).toBe(50);
+    });
+
+    it('should enforce minimum page of 1', () => {
+      const result = parsePaginationParams({ page: '-1' });
+      expect(result.page).toBe(1);
+    });
+
+    it('should enforce maximum limit', () => {
+      const result = parsePaginationParams({ limit: '500' });
+      expect(result.limit).toBe(MAX_LIMIT);
+    });
+
+    it('should parse sortBy and sortOrder', () => {
+      const result = parsePaginationParams({ sortBy: 'name', sortOrder: 'desc' });
+      expect(result.sortBy).toBe('name');
+      expect(result.sortOrder).toBe('desc');
+    });
+  });
+
+  describe('createPaginatedResult', () => {
+    it('should create correct metadata', () => {
+      const data = [1, 2, 3];
+      const result = createPaginatedResult(data, 10, { page: 1, limit: 3 });
+
+      expect(result.data).toEqual(data);
+      expect(result.meta.total).toBe(10);
+      expect(result.meta.page).toBe(1);
+      expect(result.meta.limit).toBe(3);
+      expect(result.meta.totalPages).toBe(4);
+      expect(result.meta.hasNextPage).toBe(true);
+      expect(result.meta.hasPrevPage).toBe(false);
+    });
+
+    it('should handle last page correctly', () => {
+      const result = createPaginatedResult([1], 10, { page: 4, limit: 3 });
+
+      expect(result.meta.hasNextPage).toBe(false);
+      expect(result.meta.hasPrevPage).toBe(true);
+    });
+
+    it('should handle empty results', () => {
+      const result = createPaginatedResult([], 0, { page: 1, limit: 10 });
+
+      expect(result.data).toEqual([]);
+      expect(result.meta.total).toBe(0);
+      expect(result.meta.totalPages).toBe(0);
+      expect(result.meta.hasNextPage).toBe(false);
+      expect(result.meta.hasPrevPage).toBe(false);
+    });
+  });
+
+  describe('getSkip', () => {
+    it('should calculate correct skip value', () => {
+      expect(getSkip({ page: 1, limit: 10 })).toBe(0);
+      expect(getSkip({ page: 2, limit: 10 })).toBe(10);
+      expect(getSkip({ page: 3, limit: 20 })).toBe(40);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "allowSyntheticDefaultImports": true,
+    "paths": {
+      "@/*": ["./src/*"],
+      "@core/*": ["./src/core/*"],
+      "@modules/*": ["./src/modules/*"],
+      "@config/*": ["./src/config/*"],
+      "@utils/*": ["./src/utils/*"]
+    },
+    "baseUrl": "."
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts', 'src/cli/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  minify: false,
+  target: 'node18',
+  outDir: 'dist',
+  shims: true,
+});

package/vitest.config.ts

@@ -0,0 +1,34 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts', 'tests/**/*.spec.ts'],
+    exclude: ['node_modules', 'dist'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules',
+        'dist',
+        'tests',
+        '**/*.d.ts',
+        '**/*.config.*',
+        '**/types.ts',
+      ],
+    },
+    testTimeout: 10000,
+    hookTimeout: 10000,
+    setupFiles: ['./tests/setup.ts'],
+  },
+  resolve: {
+    alias: {
+      '@': '/src',
+      '@core': '/src/core',
+      '@modules': '/src/modules',
+      '@config': '/src/config',
+      '@utils': '/src/utils',
+    },
+  },
+});