TypeScriptでインデックス型を使いAPIパラメータを動的に構築する方法

type MyObject = {
  [key: string]: number;
};

type ApiResponse = {
  [param: string]: string | number;
};

type FormFields = {
  [fieldName: string]: string;
};

type QueryParams = {
  [key: string]: string | number;
};

const buildParams = (params: QueryParams) => {
  return Object.keys(params)
    .map(key => `${key}=${encodeURIComponent(params[key])}`)
    .join('&');
};

type ApiParams = {
  [key: string]: string | number;
};

const buildApiParams = (params: ApiParams): string => {
  return Object.keys(params)
    .map(key => `${key}=${encodeURIComponent(params[key])}`)
    .join('&');
};

const params = {
  search: 'typescript',
  page: 2,
  limit: 10
};

const queryString = buildApiParams(params);
console.log(queryString);  // 出力: "search=typescript&page=2&limit=10"

type ApiParamsWithOptional = {
  [key: string]: string | number | undefined;
};

const buildApiParamsWithOptional = (params: ApiParamsWithOptional): string => {
  return Object.keys(params)
    .filter(key => params[key] !== undefined)
    .map(key => `${key}=${encodeURIComponent(params[key] as string | number)}`)
    .join('&');
};

const paramsWithOptional = {
  search: 'typescript',
  page: 2,
  limit: undefined  // このパラメータは無視されます
};

const queryStringOptional = buildApiParamsWithOptional(paramsWithOptional);
console.log(queryStringOptional);  // 出力: "search=typescript&page=2"

type SpecificApiParams = {
  search: string;
  page: number;
  limit?: number;  // Optionalパラメータ
};

const buildSpecificApiParams = (params: SpecificApiParams): string => {
  return Object.keys(params)
    .map(key => `${key}=${encodeURIComponent(params[key] as string | number)}`)
    .join('&');
};

const specificParams: SpecificApiParams = {
  search: 'TypeScript',
  page: 1,
  limit: 5
};

const specificQueryString = buildSpecificApiParams(specificParams);
console.log(specificQueryString);  // 出力: "search=TypeScript&page=1&limit=5"

type ApiParams = {
  search: string;
  page: number;
  limit: number;
};

const buildPartialApiParams = (params: Partial<ApiParams>): string => {
  return Object.keys(params)
    .filter(key => params[key] !== undefined)
    .map(key => `${key}=${encodeURIComponent(params[key] as string | number)}`)
    .join('&');
};

const partialParams: Partial<ApiParams> = {
  search: 'TypeScript',
  page: 1  // limitは指定されていない
};

const partialQueryString = buildPartialApiParams(partialParams);
console.log(partialQueryString);  // 出力: "search=TypeScript&page=1"

type ApiParams = {
  search: string;
  page: number;
  limit: number;
  sortBy: string;
};

const buildPickApiParams = (params: Pick<ApiParams, 'search' | 'page'>): string => {
  return Object.keys(params)
    .map(key => `${key}=${encodeURIComponent(params[key] as string | number)}`)
    .join('&');
};

const pickedParams: Pick<ApiParams, 'search' | 'page'> = {
  search: 'TypeScript',
  page: 1
};

const pickedQueryString = buildPickApiParams(pickedParams);
console.log(pickedQueryString);  // 出力: "search=TypeScript&page=1"

const buildOmitApiParams = (params: Omit<ApiParams, 'sortBy'>): string => {
  return Object.keys(params)
    .map(key => `${key}=${encodeURIComponent(params[key] as string | number)}`)
    .join('&');
};

const omittedParams: Omit<ApiParams, 'sortBy'> = {
  search: 'TypeScript',
  page: 1,
  limit: 10
};

const omittedQueryString = buildOmitApiParams(omittedParams);
console.log(omittedQueryString);  // 出力: "search=TypeScript&page=1&limit=10"

type StringParams = Record<string, string>;

const buildRecordParams = (params: StringParams): string => {
  return Object.keys(params)
    .map(key => `${key}=${encodeURIComponent(params[key])}`)
    .join('&');
};

const recordParams: StringParams = {
  search: 'TypeScript',
  sortBy: 'name'
};

const recordQueryString = buildRecordParams(recordParams);
console.log(recordQueryString);  // 出力: "search=TypeScript&sortBy=name"

type ProductSearchParams = {
  search: string;
  category?: string;
  minPrice?: number;
  maxPrice?: number;
  sortBy?: 'price' | 'name' | 'rating';
  page: number;
  limit: number;
};

const buildProductSearchParams = (params: Partial<ProductSearchParams>): string => {
  return Object.keys(params)
    .filter(key => params[key] !== undefined)
    .map(key => `${key}=${encodeURIComponent(params[key] as string | number)}`)
    .join('&');
};

const searchParams: Partial<ProductSearchParams> = {
  search: 'laptop',
  category: 'electronics',
  minPrice: 500,
  sortBy: 'price',
  page: 1,
  limit: 20
};

const apiUrl = `https://api.example.com/products?${buildProductSearchParams(searchParams)}`;
console.log(apiUrl);
// 出力: "https://api.example.com/products?search=laptop&category=electronics&minPrice=500&sortBy=price&page=1&limit=20"

type DynamicFilters = {
  [key: string]: string | number | undefined;
};

const buildDynamicFilters = (filters: DynamicFilters): string => {
  return Object.keys(filters)
    .filter(key => filters[key] !== undefined)
    .map(key => `${key}=${encodeURIComponent(filters[key] as string | number)}`)
    .join('&');
};

const dynamicFilters: DynamicFilters = {
  search: 'laptop',
  brand: 'Apple',
  minPrice: 1000,
  maxPrice: 3000
};

const apiUrlWithFilters = `https://api.example.com/products?${buildDynamicFilters(dynamicFilters)}`;
console.log(apiUrlWithFilters);
// 出力: "https://api.example.com/products?search=laptop&brand=Apple&minPrice=1000&maxPrice=3000"

type PaginationParams = {
  page: number;
  limit: number;
};

const buildPaginationParams = (params: PaginationParams): string => {
  return `page=${params.page}&limit=${params.limit}`;
};

const paginationParams: PaginationParams = {
  page: 2,
  limit: 10
};

const apiUrlWithPagination = `https://api.example.com/products?${buildPaginationParams(paginationParams)}`;
console.log(apiUrlWithPagination);
// 出力: "https://api.example.com/products?page=2&limit=10"

type ApiResponse = {
  [key: string]: string | number | boolean;
};

const processApiResponse = (response: ApiResponse): void => {
  console.log(`Response contains ${Object.keys(response).length} items.`);
};

const apiResponse: ApiResponse = {
  id: 1,
  name: 'Product A',
  available: true,
  price: 1500
};

processApiResponse(apiResponse);  // 型安全にアクセスできる

type UserProfile = {
  [key: string]: string | number;
};

const profile: UserProfile = {
  username: 'JohnDoe',
  age: 30,
  location: 'New York'
};

// 誤った型が使われている場合
// profile.age = 'thirty';  // これはコンパイル時にエラーになる

type DynamicObject<T> = {
  [key: string]: T;
};

const stringObject: DynamicObject<string> = {
  name: 'Alice',
  city: 'Tokyo'
};

const numberObject: DynamicObject<number> = {
  age: 25,
  score: 95
};

type ProductParams = {
  name: string;
  price: number;
  available?: boolean;
};

const validateProductParams = (params: ProductParams): boolean => {
  if (typeof params.name !== 'string' || typeof params.price !== 'number') {
    console.error('Invalid product parameters');
    return false;
  }
  return true;
};

const product: ProductParams = {
  name: 'Laptop',
  price: 1200
};

console.log(validateProductParams(product));  // 出力: true

type ApiParams = {
  search: string;
  page: number;
  limit: number;
};

const validateApiParams = (params: ApiParams): boolean => {
  if (typeof params.search !== 'string') {
    console.error('Invalid search parameter. Expected a string.');
    return false;
  }
  if (typeof params.page !== 'number' || params.page <= 0) {
    console.error('Invalid page number. Expected a positive number.');
    return false;
  }
  if (typeof params.limit !== 'number' || params.limit <= 0) {
    console.error('Invalid limit. Expected a positive number.');
    return false;
  }
  return true;
};

const params: ApiParams = {
  search: 'laptop',
  page: 1,
  limit: 20
};

if (validateApiParams(params)) {
  console.log('Valid parameters');
} else {
  console.log('Invalid parameters');
}

const handleError = (error: string): void => {
  console.error(`API Error: ${error}`);
};

const processApiRequest = (params: ApiParams): void => {
  if (!validateApiParams(params)) {
    handleError('Invalid API parameters');
    return;
  }

  // APIリクエストの実行処理（擬似的な例）
  try {
    // 実際のAPIリクエストコードはここに入ります
    console.log('API request successful.');
  } catch (error) {
    handleError(`Request failed: ${error.message}`);
  }
};

processApiRequest(params);

const logRequestDetails = (params: ApiParams): void => {
  console.log('Preparing API request with the following parameters:');
  console.table(params);
};

const logResponseDetails = (response: any): void => {
  console.log('API response received:');
  console.dir(response, { depth: null });
};

const sendApiRequest = (params: ApiParams): void => {
  logRequestDetails(params);

  try {
    // 実際のAPIリクエスト（擬似的に成功するケース）
    const mockResponse = { status: 200, data: { items: ['Item1', 'Item2'] } };
    logResponseDetails(mockResponse);
  } catch (error) {
    handleError(`API request failed: ${error.message}`);
  }
};

sendApiRequest(params);

type CommonParams = {
  apiKey: string;
  language: string;
  region?: string;
};

type SearchParams = CommonParams & {
  searchQuery: string;
  page?: number;
  limit?: number;
};

type ProductParams = CommonParams & {
  category: string;
  sortBy?: 'price' | 'popularity';
};

const buildSearchQuery = (params: SearchParams): string => {
  return Object.keys(params)
    .filter(key => params[key] !== undefined)
    .map(key => `${key}=${encodeURIComponent(params[key] as string | number)}`)
    .join('&');
};

const searchParams: SearchParams = {
  apiKey: '123abc',
  language: 'en',
  searchQuery: 'laptop',
  page: 1,
  limit: 10
};

const query = buildSearchQuery(searchParams);
console.log(query);
// 出力: "apiKey=123abc&language=en&searchQuery=laptop&page=1&limit=10"

type ApiRequest<T> = {
  endpoint: string;
  params: T;
};

const buildApiRequest = <T>(request: ApiRequest<T>): string => {
  const queryString = Object.keys(request.params)
    .map(key => `${key}=${encodeURIComponent(request.params[key] as string | number)}`)
    .join('&');
  return `${request.endpoint}?${queryString}`;
};

const productRequest: ApiRequest<ProductParams> = {
  endpoint: 'https://api.example.com/products',
  params: {
    apiKey: '123abc',
    language: 'en',
    category: 'electronics',
    sortBy: 'price'
  }
};

const apiUrl = buildApiRequest(productRequest);
console.log(apiUrl);
// 出力: "https://api.example.com/products?apiKey=123abc&language=en&category=electronics&sortBy=price"

type FullParams = {
  apiKey: string;
  language: string;
  region: string;
  searchQuery: string;
  page: number;
  limit: number;
};

type MinimalParams = Pick<FullParams, 'apiKey' | 'searchQuery'>;

const buildMinimalApiRequest = (params: MinimalParams): string => {
  return Object.keys(params)
    .map(key => `${key}=${encodeURIComponent(params[key])}`)
    .join('&');
};

const minimalParams: MinimalParams = {
  apiKey: '123abc',
  searchQuery: 'tablet'
};

const minimalApiUrl = buildMinimalApiRequest(minimalParams);
console.log(minimalApiUrl);
// 出力: "apiKey=123abc&searchQuery=tablet"

type ValidatedParams = {
  searchQuery: string;
  page?: number;
  limit?: number;
};

const validateParams = (params: ValidatedParams): string | null => {
  if (!params.searchQuery) {
    return 'Search query is required';
  }
  if (params.page && params.page <= 0) {
    return 'Page number must be greater than 0';
  }
  if (params.limit && params.limit <= 0) {
    return 'Limit must be greater than 0';
  }
  return null;
};

const validatedParams: ValidatedParams = {
  searchQuery: 'camera',
  page: -1,  // エラーを引き起こす例
  limit: 10
};

const validationError = validateParams(validatedParams);
if (validationError) {
  console.error(validationError);
} else {
  console.log('Parameters are valid');
}