Schema Adapters

interface SchemaAdapter<TOutput, TInput = TOutput> {
  validate(data: unknown): ValidationResult<TOutput>;
  toJsonSchema(options?: JsonSchemaOptions): JsonSchema;
  _output: TOutput;  // Phantom type for inference
  _input: TInput;    // Phantom type for inference
}

type ValidationResult<T> =
  | { success: true; data: T }
  | { success: false; issues: ValidationIssue[] };

import { zodSchema, z } from '@cosmneo/onion-lasagna/http/schema/zod';

// Create a schema adapter
const userSchema = zodSchema(
  z.object({
    id: z.string().uuid(),
    email: z.string().email(),
    name: z.string().min(1).max(100),
    age: z.number().int().min(0).optional(),
  }),
);

// Use in route definition
import { defineRoute } from '@cosmneo/onion-lasagna/http/route';

export const getUserRoute = defineRoute({
  method: 'GET',
  path: '/api/users/:userId',
  responses: {
    200: {
      description: 'User found',
      schema: userSchema,
    },
  },
});

import { typeboxSchema, Type } from '@cosmneo/onion-lasagna/http/schema/typebox';

// Create a schema adapter
const userSchema = typeboxSchema(
  Type.Object({
    id: Type.String({ format: 'uuid' }),
    email: Type.String({ format: 'email' }),
    name: Type.String({ minLength: 1, maxLength: 100 }),
    age: Type.Optional(Type.Integer({ minimum: 0 })),
  }),
);

// Use in route definition
export const getUserRoute = defineRoute({
  method: 'GET',
  path: '/api/users/:userId',
  responses: {
    200: {
      description: 'User found',
      schema: userSchema,
    },
  },
});

import { defineRoute } from '@cosmneo/onion-lasagna/http/route';
import { zodSchema, z } from '@cosmneo/onion-lasagna/http/schema/zod';

export const createUserRoute = defineRoute({
  method: 'POST',
  path: '/api/users',
  request: {
    // Request body validation
    body: {
      schema: zodSchema(
        z.object({
          email: z.string().email(),
          name: z.string().min(1),
          password: z.string().min(8),
        }),
      ),
    },
    // Query parameter validation
    query: {
      schema: zodSchema(
        z.object({
          sendWelcomeEmail: z.coerce.boolean().optional(),
        }),
      ),
    },
    // Path parameter validation
    params: {
      schema: zodSchema(
        z.object({
          orgId: z.string().uuid(),
        }),
      ),
    },
    // Context validation (from middleware)
    context: {
      schema: zodSchema(
        z.object({
          userId: z.string(),
        }),
      ),
    },
  },
  responses: {
    201: {
      description: 'User created',
      schema: zodSchema(
        z.object({
          userId: z.string().uuid(),
        }),
      ),
    },
    400: {
      description: 'Validation error',
    },
  },
});

import { serverRoutes } from '@cosmneo/onion-lasagna/http/server';

const routes = serverRoutes(userRouter)
  .handle('users.create', {
    // req.body, req.query, req.pathParams are already validated and typed
    requestMapper: (req, ctx) => ({
      email: req.body.email,      // string (validated)
      name: req.body.name,        // string (validated)
      createdBy: ctx.userId,      // string (from context schema)
    }),
    useCase: createUserUseCase,
    responseMapper: (output) => ({
      status: 201 as const,
      body: { userId: output.userId },
    }),
  })
  .build();

{
  "errorCode": "VALIDATION_ERROR",
  "message": "Request validation failed",
  "details": [
    { "path": ["body", "email"], "message": "Invalid email" }
  ]
}

const userSchema = zodSchema(
  z.object({
    name: z.string().describe('User full name'),
    email: z.string().email().describe('User email address'),
  }),
);

// Get JSON Schema
const jsonSchema = userSchema.toJsonSchema();
// {
//   type: 'object',
//   properties: {
//     name: { type: 'string', description: 'User full name' },
//     email: { type: 'string', format: 'email', description: 'User email address' },
//   },
//   required: ['name', 'email'],
// }

import { generateOpenAPI } from '@cosmneo/onion-lasagna/http/openapi';

const spec = generateOpenAPI(userRouter, {
  info: { title: 'User API', version: '1.0.0' },
  servers: [{ url: 'https://api.example.com' }],
});

import type { InferOutput, InferInput } from '@cosmneo/onion-lasagna/http';

const userSchema = zodSchema(
  z.object({
    name: z.string(),
    age: z.number(),
  }),
);

// Infer types from schema
type User = InferOutput<typeof userSchema>;
// { name: string; age: number }

.handle('users.create', {
  requestMapper: (req, ctx) => {
    // req.body is typed based on the route's body schema
    const email: string = req.body.email;  // TypeScript knows this is string
    return { email, createdBy: ctx.userId };
  },
  // ...
})

// Route definition with schema validation
const createUserRoute = defineRoute({
  request: {
    body: { schema: zodSchema(z.object({ email: z.string().email() })) },
  },
});

// Domain validation with business rules
class Email extends BaseValueObject<string> {
  static create(value: string): Email {
    if (!Email.isValidEmail(value)) {
      throw new InvariantViolationError({ message: 'Invalid email' });
    }
    return new Email(value);
  }
}