TypeScript API 设计：构建类型安全的接口架构

            
interface User {
  id: string;
  name: string;
  email: string;
  age?: number; // Optional property
  address: {
    street: string;
    city: string;
    country: string;
  };
}

type Product = {
  productId: string;
  productName: string;
  price: number;
  description?: string;
}

            

              
                Copy
              
            
          

            
enum OrderStatus {
  PENDING = "pending",
  PROCESSING = "processing",
  SHIPPED = "shipped",
  DELIVERED = "delivered",
  CANCELLED = "cancelled",
}

interface Order {
  orderId: string;
  userId: string;
  items: Product[];
  status: OrderStatus;
  createdAt: Date;
}

            

              
                Copy
              
            
          

            
interface ApiResponse<T> {
  success: boolean;
  data?: T;
  error?: string;
}

async function getUser(id: string): Promise<ApiResponse<User>> {
  // Simulate fetching user data from an API
  return new Promise((resolve) => {
    setTimeout(() => {
      const user: User = {
        id: id,
        name: "John Doe",
        email: "john.doe@example.com",
        address: {
            street: "123 Main St",
            city: "Anytown",
            country: "USA"
        }
      };
      resolve({ success: true, data: user });
    }, 1000);
  });
}

            

              
                Copy
              
            
          

            
import { z } from 'zod';

const UserSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(2).max(50),
  email: z.string().email(),
  age: z.number().min(0).max(150).optional(),
  address: z.object({
      street: z.string(),
      city: z.string(),
      country: z.string()
  })
});

type User = z.infer<typeof UserSchema>;

function validateUser(data: any): User {
  try {
    return UserSchema.parse(data);
  } catch (error: any) {
    console.error("Validation error:", error.errors);
    throw new Error("Invalid user data");
  }
}

// Example usage
try {
  const validUser = validateUser({
    id: "a1b2c3d4-e5f6-7890-1234-567890abcdef",
    name: "Alice",
    email: "alice@example.com",
    age: 30,
    address: {
        street: "456 Oak Ave",
        city: "Somewhere",
        country: "Canada"
    }
  });
  console.log("Valid user:", validUser);
} catch (error: any) {
  console.error("Error creating user:", error.message);
}

try {
  const invalidUser = validateUser({
    id: "invalid-id",
    name: "A",
    email: "invalid-email",
    age: -5,
    address: {
        street: "",
        city: "",
        country: ""
    }
  });
  console.log("Valid user:", invalidUser); // This line will not be reached
} catch (error: any) {
  console.error("Error creating user:", error.message);
}

            

              
                Copy
              
            
          

            
class ApiError extends Error {
  constructor(public statusCode: number, public message: string) {
    super(message);
    this.name = "ApiError";
  }
}

async function getUserFromDatabase(id: string): Promise<User> {
  // Simulate fetching user data from a database
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (id === "nonexistent-user") {
        reject(new ApiError(404, "User not found"));
      } else {
        const user: User = {
          id: id,
          name: "Jane Smith",
          email: "jane.smith@example.com",
          address: {
              street: "789 Pine Ln",
              city: "Hill Valley",
              country: "UK"
          }
        };
        resolve(user);
      }
    }, 500);
  });
}

async function handleGetUser(id: string) {
  try {
    const user = await getUserFromDatabase(id);
    console.log("User found:", user);
    return { success: true, data: user };
  } catch (error: any) {
    if (error instanceof ApiError) {
      console.error("API Error:", error.statusCode, error.message);
      return { success: false, error: error.message };
    } else {
      console.error("Unexpected error:", error);
      return { success: false, error: "Internal server error" };
    }
  }
}

// Example usage
handleGetUser("123").then(result => console.log(result));
handleGetUser("nonexistent-user").then(result => console.log(result));

            

              
                Copy
              
            
          

            
interface Product {
  productId: string;
  productName: string;
  description: string;
  price: number;
  imageUrl: string;
  category: string;
  stockQuantity: number;
}

interface Order {
  orderId: string;
  userId: string;
  items: { productId: string; quantity: number }[];
  totalAmount: number;
  shippingAddress: {
    street: string;
    city: string;
    country: string;
  };
  orderStatus: OrderStatus;
  createdAt: Date;
}

// API endpoint for creating a new product
async function createProduct(productData: Product): Promise<ApiResponse<Product>> {
  // Validate product data
  // Save product to database
  // Return success response
  return { success: true, data: productData };
}

            

              
                Copy
              
            
          

            
interface User {
  userId: string;
  username: string;
  fullName: string;
  profilePictureUrl: string;
  bio: string;
}

interface Post {
  postId: string;
  userId: string;
  content: string;
  createdAt: Date;
  likes: number;
  comments: Comment[];
}

interface Comment {
  commentId: string;
  userId: string;
  postId: string;
  content: string;
  createdAt: Date;
}

// API endpoint for creating a new post
async function createPost(postData: Omit<Post, 'postId' | 'createdAt' | 'likes' | 'comments'>): Promise<ApiResponse<Post>> {
  // Validate post data
  // Save post to database
  // Return success response
  return { success: true, data: {...postData, postId: "unique-post-id", createdAt: new Date(), likes: 0, comments: []} as Post };
}

            

              
                Copy