google-sheets-mapper 1.0.1 → 2.1.0

package/src/utils.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   MapperOptions,
   MapperState,
   ApiResponse,
@@ -6,83 +6,90 @@ import {
   SheetsResponse,
   SheetFromResponse,
   ValueRangesResponse,
-} from './types';
+  SheetsOption,
+} from "./types";
 
-const GOOGLE_API_URL = 'https://sheets.googleapis.com/v4/spreadsheets';
+const GOOGLE_API_URL = "https://sheets.googleapis.com/v4/spreadsheets";
 
-const getRanges = (sheetNames: MapperOptions['sheetsNames'] = []): string => {
+const getRanges = (sheetNames: string[] = []): string => {
   // ranges=Sheet1&ranges=Sheet2
-  return sheetNames.map((sheetName) => `ranges=${sheetName}`).join('&');
+  return sheetNames.map((sheetName) => `ranges=${sheetName}`).join("&");
 };
 
 const getSheetsTitleUrl = (sheetId: string, apiKey: string): string => {
   return `${GOOGLE_API_URL}/${sheetId}?fields=sheets%2Fproperties%2Ftitle&key=${apiKey}`;
 };
 
-const getBatchUrl = (
-  sheetId: string,
-  ranges: Array<string>,
-  apiKey: string,
-): string => {
+const getBatchUrl = (sheetId: string, ranges: Array<string>, apiKey: string): string => {
   const rangesQueryString = getRanges(ranges);
 
-  return `${GOOGLE_API_URL}/${sheetId}/values:batchGet?${rangesQueryString}&key=${apiKey}`;
+  return `${GOOGLE_API_URL}/${sheetId}?${rangesQueryString}&key=${apiKey}&includeGridData=true`;
 };
 
 class ApiResponseError extends Error {
-  constructor(message: string, public readonly response: ApiResponse) {
+  response: ApiResponse;
+  constructor(message: string, response: ApiResponse) {
     super(message);
     Object.setPrototypeOf(this, ApiResponseError.prototype);
     this.response = response;
-    Error.captureStackTrace(this, ApiResponseError);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ApiResponseError);
+    }
   }
 }
 
-const makeFetch = async (url: string, config = {}): Promise<any> => {
-  try {
-    const response = await fetch(url, config);
-
-    if (!response.ok) {
-      throw new ApiResponseError(
-        `Request to '${url}' failed with ${response.status}${
-          response.statusText ? `: ${response.statusText}` : ''
-        }`,
-        {
-          status: response.status,
-          statusText: response.statusText,
-          url: response.url,
-        },
-      );
-    }
-
-    return await response.json();
-  } catch (error) {
-    console.error(error);
-    throw error;
+const makeFetch = async <T>(url: string, config = {}): Promise<T> => {
+  const response = await fetch(url, config);
+
+  if (!response.ok) {
+    throw new ApiResponseError(
+      `Request to '${url}' failed with ${response.status}${
+        response.statusText ? `: ${response.statusText}` : ""
+      }`,
+      {
+        status: response.status,
+        statusText: response.statusText,
+        url: response.url,
+      },
+    );
   }
+
+  return await response.json();
 };
 
 const mapRecords = (
-  records: ValueRange['values'],
-  headerData: Array<string>,
-) => {
+  records: ValueRange["values"],
+  headerData: string[],
+): Record<string, string>[] => {
   return records
-    .filter((record: Array<string>) => record.length > 0)
-    .map((record: Array<string>) => {
-      return record.reduce((obj: any, item: string, index: number) => {
-        obj[headerData[index]] = item;
+    .filter((record: string[]) => record.length > 0)
+    .map((record: string[]) =>
+      record.reduce((obj: Record<string, string>, item: string, index: number) => {
+        const key = headerData[index];
+        if (key !== undefined) {
+          obj[key] = item;
+        }
         return obj;
-      }, {});
-    });
+      }, {}),
+    );
 };
 
-export const mapData = (sheets: ValueRange[]): MapperState[] => {
+export const mapData = ({
+  sheets,
+  sheetsOptions = [],
+}: {
+  sheets: ValueRange[];
+  sheetsOptions?: SheetsOption[];
+}): MapperState[] => {
   return sheets.map((sheet: ValueRange) => {
-    const id = sheet.range.split('!')[0].replace(/'/g, '');
+    const id = sheet.range.split("!")[0].replace(/'/g, "");
     const rows = sheet.values || [];
 
     if (rows.length > 0) {
-      const [header, ...records] = rows;
+      const sheetsOptionsSheet = sheetsOptions.find((option: SheetsOption) => option.id === id);
+      const headerRowIndex = sheetsOptionsSheet?.headerRowIndex ?? 0;
+      const header = rows[headerRowIndex];
+      const records = rows.filter((_, index: number) => index > headerRowIndex);
       const recordsData = mapRecords(records, header);
 
       return {
@@ -101,8 +108,9 @@ export const mapData = (sheets: ValueRange[]): MapperState[] => {
 export const fetchBatchData = async ({
   apiKey,
   sheetId,
-  sheetsNames = [],
+  sheetsOptions = [],
 }: MapperOptions): Promise<ValueRangesResponse> => {
+  const sheetsNames = sheetsOptions.map((option: SheetsOption) => option.id);
   const url = getBatchUrl(sheetId, sheetsNames, apiKey);
 
   return await makeFetch(url);
@@ -114,9 +122,9 @@ export const fetchAllSheetsData = async ({
 }: MapperOptions): Promise<ValueRangesResponse> => {
   const urlTitles = getSheetsTitleUrl(sheetId, apiKey);
   const { sheets }: SheetsResponse = await makeFetch(urlTitles);
-  const sheetsNames = sheets.map(
-    (sheet: SheetFromResponse) => sheet.properties.title,
-  );
+  const sheetsOptions = sheets.map((sheet: SheetFromResponse) => ({
+    id: sheet.properties.title,
+  }));
 
-  return await fetchBatchData({ sheetId, sheetsNames, apiKey });
+  return await fetchBatchData({ apiKey, sheetId, sheetsOptions });
 };