TypeScript ETL 流程：通过类型安全提升数据集成

            async function fetchUsers(apiEndpoint) {
  const response = await fetch(apiEndpoint);
  const data = await response.json();
  // Potential error if data.users is not an array or if user objects
  // are missing properties like 'id' or 'email'
  return data.users.map(user => ({
    userId: user.id,
    userEmail: user.email
  }));
}

            

              
                Copy
              
            
          

            interface ApiUser {
  id: number;
  name: string;
  email: string;
  // other properties might exist but we only care about these for now
}

interface ApiResponse {
  users: ApiUser[];
  // other metadata from the API
}

async function fetchUsersTyped(apiEndpoint: string): Promise<ApiUser[]> {
  const response = await fetch(apiEndpoint);
  const data = await response.json() as ApiResponse; // Type assertion
  
  // The compiler will help ensure 'data' has a 'users' property
  // and each item in 'users' conforms to ApiUser.
  // We can even add runtime validation for extra safety.
  return data.users.map(user => ({
    userId: user.id,
    userEmail: user.email
  }));
}

            

              
                Copy
              
            
          

            interface DbProduct {
  productId: string;
  productName: string;
  price: number;
  inStock: boolean;
}

async function getProductsFromDb(): Promise<DbProduct[]> {
  // Assume a database client that returns data conforming to DbProduct
  const products = await dbClient.query('SELECT id AS productId, name AS productName, price, in_stock AS inStock FROM products');
  return products;
}

            

              
                Copy
              
            
          

            function transformUsers(users) {
  return users.map(user => {
    const fullName = `${user.firstName || ''} ${user.lastName || ''}`.trim();
    const age = user.birthDate ? new Date().getFullYear() - new Date(user.birthDate).getFullYear() : null;
    const status = (user.lastLogin && (new Date() - new Date(user.lastLogin)) < (30 * 24 * 60 * 60 * 1000)) ? 'Active' : 'Inactive';
    
    return {
      userId: user.id,
      fullName: fullName,
      userAge: age,
      accountStatus: status
    };
  });
}

            

              
                Copy
              
            
          

            interface ExtractedUser {
  id: number;
  firstName?: string; // Optional properties are explicitly marked
  lastName?: string;
  birthDate?: string; // Assume date comes as a string from API
  lastLogin?: string; // Assume date comes as a string from API
}

interface TransformedUser {
  userId: number;
  fullName: string;
  userAge: number | null;
  accountStatus: 'Active' | 'Inactive'; // Union type for specific states
}

function transformUsersTyped(users: ExtractedUser[]): TransformedUser[] {
  return users.map(user => {
    const fullName = `${user.firstName || ''} ${user.lastName || ''}`.trim();
    
    let userAge: number | null = null;
    if (user.birthDate) {
      const birthYear = new Date(user.birthDate).getFullYear();
      const currentYear = new Date().getFullYear();
      userAge = currentYear - birthYear;
    }

    let accountStatus: 'Active' | 'Inactive' = 'Inactive';
    if (user.lastLogin) {
      const lastLoginTimestamp = new Date(user.lastLogin).getTime();
      const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
      if (lastLoginTimestamp > thirtyDaysAgo) {
        accountStatus = 'Active';
      }
    }

    return {
      userId: user.id,
      fullName,
      userAge,
      accountStatus
    };
  });
}

            

              
                Copy
              
            
          

            interface SourceRecord {
  orderId: string;
  items: Array<{ productId: string; quantity: number; pricePerUnit?: number }>;
  discountCode?: string;
}

interface ProcessedOrder {
  orderIdentifier: string;
  totalAmount: number;
  hasDiscount: boolean;
}

function calculateOrderTotal(record: SourceRecord): ProcessedOrder {
  let total = 0;
  for (const item of record.items) {
    // Ensure pricePerUnit is a number before multiplying
    const price = typeof item.pricePerUnit === 'number' ? item.pricePerUnit : 0;
    total += item.quantity * price;
  }

  const hasDiscount = record.discountCode !== undefined;

  return {
    orderIdentifier: record.orderId,
    totalAmount: total,
    hasDiscount: hasDiscount
  };
}

            

              
                Copy
              
            
          

            async function loadUsersToWarehouse(users) {
  for (const user of users) {
    // Risk of passing incorrect data types or missing columns
    await warehouseClient.insert('users_dim', {
      user_id: user.userId,
      user_name: user.fullName,
      age: user.userAge,
      status: user.accountStatus
    });
  }
}

            

              
                Copy
              
            
          

            interface WarehouseUserDimension {
  user_id: number;
  user_name: string;
  age: number | null; // Nullable integer for age
  status: 'Active' | 'Inactive';
}

async function loadUsersToWarehouseTyped(users: TransformedUser[]): Promise<void> {
  for (const user of users) {
    // Map TransformedUser to WarehouseUserDimension
    const warehouseRecord: WarehouseUserDimension = {
      user_id: user.userId,
      user_name: user.fullName,
      age: user.userAge,
      status: user.accountStatus
    };
    
    // The warehouseClient might also have typed methods
    await warehouseClient.insert('users_dim', warehouseRecord);
  }
}

            

              
                Copy
              
            
          

            function mapData<TSource, TTarget>(data: TSource[], mapper: (item: TSource) => TTarget): TTarget[] {
  return data.map(mapper);
}

// Usage with our user example:
const transformedUsers = mapData(extractedUsers, (user) => ({
  userId: user.id,
  fullName: `${user.firstName} ${user.lastName}`
})); // transformedUsers will be inferred as { userId: number; fullName: string; }[]

            

              
                Copy
              
            
          

            function isValidDateString(value: any): value is string {
  if (typeof value !== 'string') {
    return false;
  }
  const date = new Date(value);
  return !isNaN(date.getTime());
}

function processDateValue(dateInput: any): string | null {
  if (isValidDateString(dateInput)) {
    // Inside this block, TypeScript knows dateInput is a string
    return new Date(dateInput).toISOString();
  } else {
    return null;
  }
}

            

              
                Copy
              
            
          

            interface OrderCreatedEvent {
  type: 'ORDER_CREATED';
  orderId: string;
  amount: number;
}

interface OrderShippedEvent {
  type: 'ORDER_SHIPPED';
  orderId: string;
  shippingDate: string;
}

type OrderEvent = OrderCreatedEvent | OrderShippedEvent;

function processOrderEvent(event: OrderEvent): void {
  switch (event.type) {
    case 'ORDER_CREATED':
      // TypeScript knows event is OrderCreatedEvent here
      console.log(`Order ${event.orderId} created with amount ${event.amount}`);
      break;
    case 'ORDER_SHIPPED':
      // TypeScript knows event is OrderShippedEvent here
      console.log(`Order ${event.orderId} shipped on ${event.shippingDate}`);
      break;
    default:
      // This 'never' type helps ensure all cases are handled
      const _exhaustiveCheck: never = event;
      console.error('Unknown event type:', _exhaustiveCheck);
  }
}

            

              
                Copy