@sheet2db/sdk 1.0.5 → 1.0.7

package/README.md

@@ -28,7 +28,7 @@ npm install @sheet2db/sdk
 ### Import and Initialize
 
 ```typescript
-import Sheet2DB, { Sheet2DBOptions } from 'sheet2db';
+import { Sheet2DB,Sheet2DBOptions } from 'sheet2db';
 
 const options: Sheet2DBOptions = {
     mode: 'apikey',

package/dist/index.d.ts

@@ -22,8 +22,12 @@ export type ReadOptions = {
     offset?: number;
     sheet?: string;
     format?: 'records' | 'dict' | 'series' | 'split' | 'index' | 'raw';
-    cast_numbers?: string;
+    cast_numbers?: string[] | string;
     value_render?: "FORMATTED_VALUE" | "UNFORMATTED_VALUE" | "FORMULA";
+    columns?: string[] | string;
+    sort?: string;
+    sort_method?: 'date';
+    sort_date_format?: string;
 };
 export type GetKeysOptions = {
     sheet?: string;
@@ -112,7 +116,13 @@ export declare class Sheet2DB {
     DeleteWithQuery(options: DeleteWithQueryOptions): Promise<{
         deleted: number;
     }>;
-    Clear(options: ClearSheetOptions): Promise<unknown>;
-    CreateSheet(options: CreateSheetOptions): Promise<unknown>;
-    DeleteSheet(options: DeleteSheetOptions): Promise<unknown>;
+    Clear(options: ClearSheetOptions): Promise<{
+        success: boolean;
+    }>;
+    CreateSheet(options: CreateSheetOptions): Promise<{
+        success: boolean;
+    }>;
+    DeleteSheet(options: DeleteSheetOptions): Promise<{
+        success: boolean;
+    }>;
 }

package/dist/index.js

@@ -49,7 +49,7 @@ class Sheet2DB {
                 }
             }
         }
-        const response = await this.fetchFn(endpoint.toString(), {
+        const response = await this.fetchFn(endpoint.href, {
             headers,
             method,
             body: body ? JSON.stringify(body) : undefined
@@ -62,6 +62,12 @@ class Sheet2DB {
         }
     }
     ReadContent(options) {
+        if (options.columns && options.columns.constructor == Array) {
+            options.columns = options.columns.join(',');
+        }
+        if (options.cast_numbers && options.cast_numbers.constructor == Array) {
+            options.cast_numbers = options.cast_numbers.join(',');
+        }
         const query = new URLSearchParams(options);
         return this.fetch('', "GET", query);
     }
@@ -89,7 +95,7 @@ class Sheet2DB {
     Insert(options) {
         const { data, ...queryParams } = options;
         const query = new URLSearchParams(queryParams);
-        return this.fetch('/', "POST", query, data);
+        return this.fetch('', "POST", query, data);
     }
     UpdateRow(options) {
         const { row, data, ...queryParams } = options;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@sheet2db/sdk",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "test": "jest",
     "build":"tsc",
-    "prepublish": "tsc"
+    "prepublish": "tsc && npm run test"
   },
   "exports":{
     ".":{

package/src/index.ts

@@ -7,15 +7,15 @@ if (typeof window !== 'undefined' && typeof window.fetch !== 'undefined') {
     // We are in a Node.js environment
     fetchFunction = async (...args) => {
         const fetch = global.fetch;
-        return fetch.apply(null,args)
+        return fetch.apply(null, args)
     };
 }
 
 export type Sheet2DBOptions = {
     mode: 'apikey';
-    apiKey: string; // API to access public spreadsheets https://sheet2db.com/docs/public-spreadsheet
-    spreadsheetId: string; // ID of the google spreadsheet
-    version: "v1"; // Always v1
+    apiKey: string;
+    spreadsheetId: string;
+    version: "v1";
     fetchFn?: typeof fetch;
 } | {
     mode: 'connectionId';
@@ -27,7 +27,7 @@ export type Sheet2DBOptions = {
     jwtAuth?: {
         bearerToken: string;
     };
-    version: "v1"; // Always v1
+    version: "v1";
     fetchFn?: typeof fetch;
 };
 
@@ -36,8 +36,12 @@ export type ReadOptions = {
     offset?: number;
     sheet?: string;
     format?: 'records' | 'dict' | 'series' | 'split' | 'index' | 'raw';
-    cast_numbers?: string;
+    cast_numbers?: string[] | string;
     value_render?: "FORMATTED_VALUE" | "UNFORMATTED_VALUE" | "FORMULA";
+    columns?: string[] | string;
+    sort?: string;
+    sort_method?: 'date',
+    sort_date_format?: string;
 };
 
 export type GetKeysOptions = {
@@ -105,7 +109,6 @@ export type DeleteSheetOptions = {
 export class Sheet2DB {
 
     private apiEndpoint: string = "https://api.sheet2db.com";
-    // private apiEndpoint: string = "http://localhost:8787";
     private fetchFn: typeof fetch;
 
     constructor(private readonly options: Sheet2DBOptions) {
@@ -136,12 +139,12 @@ export class Sheet2DB {
                 });
             } else {
                 endpoint.search = queryParams
-                if(this.options.mode == 'apikey'){
+                if (this.options.mode == 'apikey') {
                     endpoint.searchParams.set("__id", this.options.spreadsheetId);
                 }
             }
         }
-        const response = await this.fetchFn(endpoint.toString(), {
+        const response = await this.fetchFn(endpoint.href, {
             headers,
             method,
             body: body ? JSON.stringify(body) : undefined
@@ -153,7 +156,14 @@ export class Sheet2DB {
         }
     }
 
+
     ReadContent<T>(options?: ReadOptions) {
+        if (options.columns && options.columns.constructor == Array) {
+            options.columns = options.columns.join(',');
+        }
+        if (options.cast_numbers && options.cast_numbers.constructor == Array) {
+            options.cast_numbers = options.cast_numbers.join(',');
+        }
         const query = new URLSearchParams(options as Record<string, string>);
         return this.fetch<T>('', "GET", query);
     }
@@ -187,7 +197,7 @@ export class Sheet2DB {
     Insert(options: InsertOptions) {
         const { data, ...queryParams } = options;
         const query = new URLSearchParams(queryParams as Record<string, string>);
-        return this.fetch<{ inserted: number }>('/', "POST", query, data);
+        return this.fetch<{ inserted: number }>('', "POST", query, data);
     }
 
     UpdateRow(options: UpdateRowOptions) {
@@ -231,16 +241,16 @@ export class Sheet2DB {
 
     Clear(options: ClearSheetOptions) {
         const path = `/clear/${options.sheet}`;
-        return this.fetch(path, "DELETE");
+        return this.fetch<{success: boolean}>(path, "DELETE");
     }
 
     CreateSheet(options: CreateSheetOptions) {
         const query = new URLSearchParams(options as Record<string, string>);
-        return this.fetch('/sheet', "POST", query);
+        return this.fetch<{success: boolean}>('/sheet', "POST", query);
     }
 
     DeleteSheet(options: DeleteSheetOptions) {
         const path = `/sheet/${options.sheet}`;
-        return this.fetch(path, "DELETE");
+        return this.fetch<{success: boolean}>(path, "DELETE");
     }
 }

package/tests/index.test.ts

@@ -1,217 +1,334 @@
-import { describe, expect, test } from '@jest/globals';
-import {
-    Sheet2DB,
-    Sheet2DBOptions,
-    ReadOptions,
-    GetKeysOptions,
-    GetCountOptions,
-    GetRangeOptions,
-    SearchOptions,
-    InsertOptions,
-    UpdateRowOptions,
-    UpdateWithQueryOptions,
-    BatchUpdateOptions,
-    DeleteRowOptions,
-    DeleteWithQueryOptions,
-    ClearSheetOptions,
-    CreateSheetOptions,
-    DeleteSheetOptions,
-} from "../src";
-
-describe("Sheet2DB Class Tests", () => {
-
-    describe("Tests with Connection ID", () => {
-        const connectionIdOptions: Sheet2DBOptions = {
-            connectionId: "608ae724-5285-42fd-a1d9-2e9fad3b22ee",
-            // connectionId:"e90b9b28-64dd-4fcd-9be7-0c94edc9d897",
-            version: "v1",
-            mode: "connectionId"
-        };
-        const sheet2db = new Sheet2DB(connectionIdOptions);
-
-        test("Read Content", async () => {
-            let res = await sheet2db.ReadContent();
-            expect(res).toBeDefined();
-            // Add more specific checks based on known data structure
-        });
-
-        test("Get Keys", async () => {
-            let res = await sheet2db.Keys();
-            expect(res).toBeDefined();
-            expect(res?.length).toBeGreaterThan(0);
-            // Add more specific checks based on known data structure
-        });
-
-        test("Count", async () => {
-            let res = await sheet2db.Count();
-            expect(res).toBeDefined();
-            expect(res?.count).toBeGreaterThanOrEqual(0);
-        });
-
-        test("Title", async () => {
-            let res = await sheet2db.Title();
-            expect(res).toBeDefined();
-            expect(res?.spreadsheet_title).toBeTruthy();
-            expect(res?.api_name).toBeTruthy();
-        });
-
-        test("Range", async () => {
-            const rangeOptions: GetRangeOptions = {
-                range: "A1:B2"
-            };
-            let res = await sheet2db.Range(rangeOptions);
-            expect(res).toBeDefined();
-            expect(res?.length).toBe(2);
-            expect(res?.[0].length).toBe(2);
-        });
-
-        test("Search", async () => {
-            const searchOptions: SearchOptions = {
-                query: "Student Name=S*"
-            };
-            let res = await sheet2db.Search(searchOptions);
-            expect(res.length).toBeGreaterThanOrEqual(1);
-            // Add more specific checks based on known data structure
-        });
-
-        test("Insert", async () => {
-            const insertOptions: InsertOptions = {
-                data: { "Student Name": "Test" }
-            };
-            let res = await sheet2db.Insert(insertOptions);
-            expect(res).toBeDefined();
-            expect(res?.inserted).toBe(1);
-        });
-
-        test("UpdateRow", async () => {
-            const updateRowOptions: UpdateRowOptions = {
-                row: 31,
-                data: { "Student Name": "Test0" }
-            };
-            let res = await sheet2db.UpdateRow(updateRowOptions);
-            expect(res).toBeDefined();
-            expect(res?.updated).toBe(1);
-        });
-
-        test("UpdateWithQuery", async () => {
-            const updateWithQueryOptions: UpdateWithQueryOptions = {
-                query: "Student Name=Test0",
-                data: { "Age": 27 }
-            };
-            let res = await sheet2db.UpdateWithQuery(updateWithQueryOptions);
-            expect(res).toBeDefined();
-            expect(res?.updated).toBe(1);
-        });
-
-        test("BatchUpdate", async () => {
-            const batchUpdateOptions: BatchUpdateOptions = {
-                batches: [{ query: "Student Name=Test0", record: { Major: "updated value" } },{ query: "Student Name=Test0", record: { "Class Level": "3. Junior" } }]
-            };
-            let res = await sheet2db.BatchUpdate(batchUpdateOptions);
-            expect(res).toBeDefined();
-            expect(res?.updated).toBe(1);
-        });
-
-        test("DeleteRow", async () => {
-            const deleteRowOptions: DeleteRowOptions = {
-                row: 31
-            };
-            let res = await sheet2db.DeleteRow(deleteRowOptions);
-            expect(res).toBeDefined();
-            expect(res?.deleted).toBe(1);
-        });
-
-        test("DeleteWithQuery", async () => {
-            const deleteWithQueryOptions: DeleteWithQueryOptions = {
-                query: "Student Name=Test0"
-            };
-            let res = await sheet2db.DeleteWithQuery(deleteWithQueryOptions);
-            expect(res).toBeDefined();
-            expect(res?.deleted).toBe(0);
-        });
-
-        test("CreateSheet", async () => {
-            const createSheetOptions: CreateSheetOptions = {
-                title: "TestSheet"
-            };
-            let res = await sheet2db.CreateSheet(createSheetOptions);
-            expect(res).toBeDefined();
-            // Add specific assertions if return value is known
-        });
-
-        test("Clear", async () => {
-            const clearOptions: ClearSheetOptions = {
-                sheet: "TestSheet"
-            };
-            let res = await sheet2db.Clear(clearOptions);
-            expect(res).toBeDefined();
-            // Add specific assertions if return value is known
-        });
-
-        test("DeleteSheet", async () => {
-            const deleteSheetOptions: DeleteSheetOptions = {
-                sheet: "TestSheet"
-            };
-            let res = await sheet2db.DeleteSheet(deleteSheetOptions);
-            expect(res).toBeDefined();
-            // Add specific assertions if return value is known
-        });
-
-    });
-
-    describe("Tests with API Key", () => {
-        const apiKeyOptions: Sheet2DBOptions = {
-            apiKey: "BmJrnOlf",
-            spreadsheetId: "1H8t1vJkKTZzLkvVZwJZ5LlA0Fw6Hw2QY7kV1pLIJYo4",
-            version: "v1",
-            mode: "apikey"
-        };
-        const sheet2db = new Sheet2DB(apiKeyOptions);
-
-        test("Read Content", async () => {
-            let res = await sheet2db.ReadContent();
-            expect(res).toBeDefined();
-            // Add more specific checks based on known data structure
-        });
-
-        test("Get Keys", async () => {
-            let res = await sheet2db.Keys();
-            expect(res).toBeDefined();
-            expect(res?.length).toBeGreaterThan(0);
-            // Add more specific checks based on known data structure
-        });
-
-        test("Count", async () => {
-            let res = await sheet2db.Count();
-            expect(res).toBeDefined();
-            expect(res?.count).toBeGreaterThanOrEqual(0);
-        });
-
-        test("Title", async () => {
-            let res = await sheet2db.Title();
-            expect(res).toBeDefined();
-            expect(res?.spreadsheet_title).toBeTruthy();
-            expect(res?.api_name).toBeTruthy();
-        });
-
-        test("Range", async () => {
-            const rangeOptions: GetRangeOptions = {
-                range: "A1:B2"
-            };
-            let res = await sheet2db.Range(rangeOptions);
-            expect(res).toBeDefined();
-            expect(res?.length).toBe(2);
-            expect(res?.[0].length).toBe(2);
-        });
-
-        test("Search", async () => {
-            const searchOptions: SearchOptions = {
-                query: "search query"
-            };
-            let res = await sheet2db.Search(searchOptions);
-            expect(res).toBeDefined();
-            // Add more specific checks based on known data structure
-        });
-
-    })
-})
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { Sheet2DB, Sheet2DBOptions, ReadOptions } from '../dist'; // Adjust the import path
+
+const mockFetch = jest.fn(async () => {
+  return {
+    ok: true,
+    json: () => Promise.resolve({}),
+    text: () => Promise.resolve(''),
+  }
+}) as jest.Mock<any>;
+
+const apiKeyOptions: Sheet2DBOptions = {
+  mode: 'connectionId',
+  connectionId: 'test-spreadsheet-id',
+  version: 'v1',
+  //@ts-ignore
+  fetchFn: mockFetch
+};
+
+describe('Sheet2DB', () => {
+  let sheet2DB: Sheet2DB;
+
+  beforeEach(() => {
+    sheet2DB = new Sheet2DB(apiKeyOptions); // Create a new instance of Sheet2DB
+    jest.clearAllMocks(); // Reset mocks before each test
+  });
+
+  it('ReadContent', async () => {
+    // Arrange
+    const readOptions = {
+      limit: 10,
+      offset: 5,
+      sheet: 'Sheet1',
+      format: 'records' as const,
+      cast_numbers: ['col1'],
+      columns: ['col1', 'col2'],
+      value_render: 'FORMATTED_VALUE' as const,
+    }
+
+    // Act
+    await sheet2DB.ReadContent(readOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe('/v1/test-spreadsheet-id');
+    expect(calledUrl.searchParams.get('limit')).toBe(readOptions.limit?.toString());
+    expect(calledUrl.searchParams.get('offset')).toBe(readOptions.offset?.toString());
+    expect(calledUrl.searchParams.get('sheet')).toBe(readOptions.sheet);
+    expect(calledUrl.searchParams.get('format')).toBe(readOptions.format);
+    expect(calledUrl.searchParams.get('columns')).toBe(readOptions.columns);
+    expect(calledUrl.searchParams.get('cast_numbers')).toBe(readOptions.cast_numbers);
+    expect(calledUrl.searchParams.get('value_render')).toBe(readOptions.value_render);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('GET');
+  });
+
+  it('Keys', async () => {
+    // Arrange
+    const keysOptions = {
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.Keys(keysOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe('/v1/test-spreadsheet-id/keys');
+    expect(calledUrl.searchParams.get('sheet')).toBe(keysOptions.sheet);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('GET');
+  })
+
+  it('Count', async () => {
+    // Arrange
+    const countOptions = {
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.Count(countOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe('/v1/test-spreadsheet-id/count');
+    expect(calledUrl.searchParams.get('sheet')).toBe(countOptions.sheet);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('GET');
+  })
+
+  it('Title', async () => {
+    // Act
+    await sheet2DB.Title();
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe('/v1/test-spreadsheet-id/title');
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('GET');
+  })
+
+  it('Range', async () => {
+    // Arrange
+    const rangeOptions = {
+      range: 'A1:B2',
+    }
+
+    // Act
+    await sheet2DB.Range(rangeOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/range/${rangeOptions.range}`);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('GET');
+  })
+
+  it('Search', async () => {
+    // Arrange
+    const searchOptions = {
+      sheet: 'Sheet1',
+      query: 'name=John',
+      or: true,
+    };
+
+    // Act
+    await sheet2DB.Search(searchOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/search_or/${searchOptions.sheet}`);
+    expect(decodeURIComponent(calledUrl.search)).toBe(`?${searchOptions.query}`);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('GET');
+  });
+
+  it('Insert', async () => {
+    // Arrange
+    const insertOptions = {
+      data: { name: 'John', age: 30 },
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.Insert(insertOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe('/v1/test-spreadsheet-id');
+    expect(calledUrl.searchParams.get('sheet')).toBe(insertOptions.sheet);
+    const otherOptions = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(otherOptions.body).toBe(JSON.stringify(insertOptions.data))
+    expect(otherOptions.method).toBe('POST');
+  });
+
+  it('UpdateRow', async () => {
+    // Arrange
+    const updateRowOptions = {
+      data: { name: 'John', age: 30 },
+      row: 4,
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.UpdateRow(updateRowOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/row/${updateRowOptions.row}`);
+    expect(calledUrl.searchParams.get('sheet')).toBe(updateRowOptions.sheet);
+    const otherOptions = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(otherOptions.body).toBe(JSON.stringify(updateRowOptions.data))
+    expect(otherOptions.method).toBe('PATCH');
+  });
+
+  it('UpdateWithQuery', async () => {
+    // Arrange
+    const updateWithQueryOptions = {
+      sheet: 'Sheet1',
+      query: 'name=John',
+      data: { name: 'John Doe' },
+    };
+
+    // Act
+    await sheet2DB.UpdateWithQuery(updateWithQueryOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/${updateWithQueryOptions.sheet}`);
+    expect(decodeURIComponent(calledUrl.search)).toBe(`?${updateWithQueryOptions.query}`);
+    const otherOptions = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(otherOptions.body).toBe(JSON.stringify(updateWithQueryOptions.data))
+    expect(otherOptions.method).toBe('PATCH');
+  });
+
+  it('BatchUpdate', async () => {
+    // Arrange
+    const batchUpdateOptions = {
+      sheet: 'Sheet1',
+      batches: [
+        { query: "name=John", record: { age: 21 } },
+        { query: "age>24", record: { name: "Jane Doe" } }
+      ],
+    };
+
+    // Act
+    await sheet2DB.BatchUpdate(batchUpdateOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/batch/${batchUpdateOptions.sheet}`);
+    const otherOptions = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(otherOptions.body).toBe(JSON.stringify(batchUpdateOptions.batches))
+    expect(otherOptions.method).toBe('PATCH');
+  })
+
+  it('DeleteRow', async () => {
+    // Arrange
+    const deleteRowOptions = {
+      row: 4,
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.DeleteRow(deleteRowOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe('/v1/test-spreadsheet-id/row/4');
+    expect(calledUrl.searchParams.get('sheet')).toBe('Sheet1');
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('DELETE');
+  });
+
+  it('DeleteWithQuery', async () => {
+    // Arrange
+    const deleteWithQueryOptions = {
+      query: "id=0",
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.DeleteWithQuery(deleteWithQueryOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/${deleteWithQueryOptions.sheet}`);
+    expect(decodeURIComponent(calledUrl.search)).toBe(`?${deleteWithQueryOptions.query}`);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('DELETE');
+  })
+
+  it('Clear', async () => {
+    // Arrange
+    const clearOptions = {
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.Clear(clearOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/clear/${clearOptions.sheet}`);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('DELETE');
+  })
+
+  it('Create Sheet', async () => {
+    // Arrange
+    const createSheetOptions = {
+      title: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.CreateSheet(createSheetOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/sheet`);
+    expect(calledUrl.searchParams.get('title')).toBe(createSheetOptions.title);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('POST');
+  })
+
+  it('Delete Sheet', async ()=>{
+    // Arrange
+    const deleteSheetOptions = {
+      sheet: 'Sheet1',
+    };
+
+    // Act
+    await sheet2DB.DeleteSheet(deleteSheetOptions);
+
+    // Assert
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const calledUrl = new URL(mockFetch.mock.calls[0][0] as string);
+    expect(calledUrl.origin).toBe('https://api.sheet2db.com');
+    expect(calledUrl.pathname).toBe(`/v1/test-spreadsheet-id/sheet/${deleteSheetOptions.sheet}`);
+    const options = mockFetch.mock.calls[0][1] as RequestInit;
+    expect(options.method).toBe('DELETE');
+  })
+
+
+});
+