@sheet2db/sdk 1.0.0

package/dist/index.cjs.d.ts

@@ -0,0 +1,2 @@
+import Sheet2DB from "./index.js";
+export = Sheet2DB;

package/dist/index.cjs.js

@@ -0,0 +1,6 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const index_js_1 = __importDefault(require("./index.js"));
+module.exports = index_js_1.default;

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+export type Sheet2DBOptions = {
+    mode: 'apikey';
+    apiKey: string;
+    spreadsheetId: string;
+    version: "v1";
+    fetchFn?: typeof fetch;
+} | {
+    mode: 'connectionId';
+    connectionId: string;
+    basicAuth?: {
+        username: string;
+        password: string;
+    };
+    jwtAuth?: {
+        bearerToken: string;
+    };
+    version: "v1";
+    fetchFn?: typeof fetch;
+};
+export type ReadOptions = {
+    limit?: number;
+    offset?: number;
+    sheet?: string;
+    format?: 'records' | 'dict' | 'series' | 'split' | 'index' | 'raw';
+    cast_numbers?: string;
+    value_render?: "FORMATTED_VALUE" | "UNFORMATTED_VALUE" | "FORMULA";
+};
+export type GetKeysOptions = {
+    sheet?: string;
+};
+export type GetCountOptions = {
+    sheet?: string;
+};
+export type GetRangeOptions = {
+    range: string;
+};
+export type SearchOptions = {
+    sheet?: string;
+    or?: boolean;
+    query: string;
+};
+export type InsertOptions = {
+    data: Record<string, any> | Record<string, any>[];
+    sheet?: string;
+};
+export type UpdateRowOptions = {
+    row: number;
+    sheet?: string;
+    data: Record<string, any>;
+};
+export type UpdateWithQueryOptions = {
+    sheet?: string;
+    query: string;
+    data: Record<string, any>;
+};
+export type BatchUpdateOptions = {
+    sheet?: string;
+    batches: {
+        query: string;
+        record: Record<string, any>;
+    }[];
+};
+export type DeleteRowOptions = {
+    sheet?: string;
+    row: number;
+};
+export type DeleteWithQueryOptions = {
+    sheet?: string;
+    query: string;
+};
+export type ClearSheetOptions = {
+    sheet: string;
+};
+export type CreateSheetOptions = {
+    title?: string;
+};
+export type DeleteSheetOptions = {
+    sheet: string;
+};
+export default class Sheet2DB {
+    private readonly options;
+    private apiEndpoint;
+    private fetchFn;
+    constructor(options: Sheet2DBOptions);
+    private fetch;
+    ReadContent<T>(options?: ReadOptions): Promise<T>;
+    Keys(options?: GetKeysOptions): Promise<string[]>;
+    Count(options?: GetCountOptions): Promise<{
+        count: number;
+    }>;
+    Title(): Promise<{
+        spreadsheet_title: string;
+        api_name: string;
+    }>;
+    Range(options: GetRangeOptions): Promise<string[][]>;
+    Search(options: SearchOptions): Promise<Record<string, any>>;
+    Insert(options: InsertOptions): Promise<{
+        inserted: number;
+    }>;
+    UpdateRow(options: UpdateRowOptions): Promise<{
+        updated: number;
+    }>;
+    UpdateWithQuery(options: UpdateWithQueryOptions): Promise<{
+        updated: number;
+    }>;
+    BatchUpdate(options: BatchUpdateOptions): Promise<{
+        updated: number;
+    }>;
+    DeleteRow(options: DeleteRowOptions): Promise<{
+        deleted: number;
+    }>;
+    DeleteWithQuery(options: DeleteWithQueryOptions): Promise<{
+        deleted: number;
+    }>;
+    Clear(options: ClearSheetOptions): Promise<unknown>;
+    CreateSheet(options: CreateSheetOptions): Promise<unknown>;
+    DeleteSheet(options: DeleteSheetOptions): Promise<unknown>;
+}

package/dist/index.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+let fetchFunction;
+if (typeof window !== 'undefined' && typeof window.fetch !== 'undefined') {
+    // We are in a browser environment
+    fetchFunction = window.fetch.bind(window);
+}
+else {
+    // We are in a Node.js environment
+    //@ts-ignore
+    fetchFunction = (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const fetch = yield Promise.resolve().then(() => __importStar(require('node-fetch')));
+        //@ts-ignore
+        return fetch.default(...args);
+    });
+}
+class Sheet2DB {
+    constructor(options) {
+        this.options = options;
+        this.apiEndpoint = "https://api.sheet2db.com";
+        this.fetchFn = options.fetchFn || fetchFunction;
+    }
+    fetch(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, method = "GET", queryParams, body) {
+            let endpoint = new URL(this.options.version, this.apiEndpoint);
+            let headers = { "Content-Type": "application/json" };
+            if (this.options.mode === 'connectionId') {
+                endpoint.pathname = `/${this.options.connectionId}${path}`;
+                if (this.options.basicAuth) {
+                    let authorization = Buffer.from(`${this.options.basicAuth.username}:${this.options.basicAuth.password}`).toString('base64');
+                    headers["Authorization"] = `Basic ${authorization}`;
+                }
+                else if (this.options.jwtAuth) {
+                    headers["Authorization"] = `Bearer ${this.options.jwtAuth.bearerToken}`;
+                }
+            }
+            else {
+                endpoint.pathname = `/${this.options.apiKey}${path}`;
+                endpoint.searchParams.set("__id", this.options.spreadsheetId);
+            }
+            if (queryParams) {
+                queryParams.forEach((value, key) => {
+                    endpoint.searchParams.append(key, value);
+                });
+            }
+            const response = yield this.fetchFn(endpoint.toString(), {
+                headers,
+                method,
+                body: body ? JSON.stringify(body) : undefined
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            else {
+                throw new Error(yield response.text());
+            }
+        });
+    }
+    ReadContent(options) {
+        const query = new URLSearchParams(options);
+        return this.fetch('', "GET", query);
+    }
+    Keys(options) {
+        const query = new URLSearchParams(options);
+        return this.fetch('/keys', "GET", query);
+    }
+    Count(options) {
+        const query = new URLSearchParams(options);
+        return this.fetch('/count', "GET", query);
+    }
+    Title() {
+        return this.fetch('/title', "GET");
+    }
+    Range(options) {
+        return this.fetch(`/range/${options.range}`, "GET");
+    }
+    Search(options) {
+        let path = options.or ? "/search_or" : "/search";
+        if (options.sheet) {
+            path = `${path}/${options.sheet}`;
+        }
+        const query = new URLSearchParams({ query: options.query });
+        return this.fetch(path, "GET", query);
+    }
+    Insert(options) {
+        const { data } = options, queryParams = __rest(options, ["data"]);
+        const query = new URLSearchParams(queryParams);
+        return this.fetch('/', "POST", query, data);
+    }
+    UpdateRow(options) {
+        const { row, data } = options, queryParams = __rest(options, ["row", "data"]);
+        const query = new URLSearchParams(queryParams);
+        return this.fetch(`/row/${row}`, "PATCH", query, data);
+    }
+    UpdateWithQuery(options) {
+        const { sheet, data, query: q } = options;
+        let path = '';
+        if (sheet) {
+            path = `/${sheet}`;
+        }
+        const query = new URLSearchParams({ query: q });
+        return this.fetch(path, "PATCH", query, data);
+    }
+    BatchUpdate(options) {
+        const { batches, sheet } = options;
+        let path = '';
+        if (sheet) {
+            path = `/${sheet}`;
+        }
+        return this.fetch(path, "PATCH", undefined, batches);
+    }
+    DeleteRow(options) {
+        const { row } = options, queryParams = __rest(options, ["row"]);
+        const query = new URLSearchParams(queryParams);
+        return this.fetch(`/${row}`, "DELETE", query);
+    }
+    DeleteWithQuery(options) {
+        const { query: search, sheet } = options;
+        const query = new URLSearchParams({ query: search });
+        let path = '';
+        if (sheet) {
+            path = `/${sheet}`;
+        }
+        return this.fetch(path, "DELETE", query);
+    }
+    Clear(options) {
+        const path = `/clear/${options.sheet}`;
+        return this.fetch(path, "DELETE");
+    }
+    CreateSheet(options) {
+        const query = new URLSearchParams(options);
+        return this.fetch('/sheet', "POST", query);
+    }
+    DeleteSheet(options) {
+        const path = `/sheet/${options.sheet}`;
+        return this.fetch(path, "DELETE");
+    }
+}
+exports.default = Sheet2DB;

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@sheet2db/sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "jest",
+    "build":"tsc"
+  },
+  "exports":{
+    ".":{
+      "import":"./dist/index.js",
+      "require":"./dist/index.cjs"
+    }
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.4",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "private":false
+}

package/src/index.cjs.ts

@@ -0,0 +1,2 @@
+import Sheet2DB from "./index.js";
+export = Sheet2DB

package/src/index.ts

@@ -0,0 +1,246 @@
+let fetchFunction: typeof fetch;
+
+if (typeof window !== 'undefined' && typeof window.fetch !== 'undefined') {
+    // We are in a browser environment
+    fetchFunction = window.fetch.bind(window);
+} else {
+    // We are in a Node.js environment
+    fetchFunction = async (...args) => {
+        const fetch = global.fetch;
+        return fetch(...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
+    fetchFn?: typeof fetch;
+} | {
+    mode: 'connectionId';
+    connectionId: string;
+    basicAuth?: {
+        username: string;
+        password: string;
+    };
+    jwtAuth?: {
+        bearerToken: string;
+    };
+    version: "v1"; // Always v1
+    fetchFn?: typeof fetch;
+};
+
+export type ReadOptions = {
+    limit?: number;
+    offset?: number;
+    sheet?: string;
+    format?: 'records' | 'dict' | 'series' | 'split' | 'index' | 'raw';
+    cast_numbers?: string;
+    value_render?: "FORMATTED_VALUE" | "UNFORMATTED_VALUE" | "FORMULA";
+};
+
+export type GetKeysOptions = {
+    sheet?: string;
+};
+
+export type GetCountOptions = {
+    sheet?: string;
+};
+
+export type GetRangeOptions = {
+    range: string;
+};
+
+export type SearchOptions = {
+    sheet?: string;
+    or?: boolean;
+    query: string;
+};
+
+export type InsertOptions = {
+    data: Record<string, any> | Record<string, any>[];
+    sheet?: string;
+};
+
+export type UpdateRowOptions = {
+    row: number;
+    sheet?: string;
+    data: Record<string, any>;
+};
+
+export type UpdateWithQueryOptions = {
+    sheet?: string;
+    query: string;
+    data: Record<string, any>;
+};
+
+export type BatchUpdateOptions = {
+    sheet?: string;
+    batches: { query: string, record: Record<string, any> }[];
+};
+
+export type DeleteRowOptions = {
+    sheet?: string;
+    row: number;
+};
+
+export type DeleteWithQueryOptions = {
+    sheet?: string;
+    query: string;
+};
+
+export type ClearSheetOptions = {
+    sheet: string;
+};
+
+export type CreateSheetOptions = {
+    title?: string;
+};
+
+export type DeleteSheetOptions = {
+    sheet: string;
+};
+
+export default class Sheet2DB {
+
+    private apiEndpoint: string = "https://api.sheet2db.com";
+    // private apiEndpoint: string = "http://localhost:8787";
+    private fetchFn: typeof fetch;
+
+    constructor(private readonly options: Sheet2DBOptions) {
+        this.fetchFn = options.fetchFn || fetchFunction;
+    }
+
+    private async fetch<T>(path: string, method: "GET" | "POST" | "PATCH" | "DELETE" = "GET", queryParams?: URLSearchParams | string, body?: any): Promise<T> {
+        let endpoint = new URL(this.options.version, this.apiEndpoint);
+        let headers: Record<string, string> = { "Content-Type": "application/json" };
+
+        if (this.options.mode === 'connectionId') {
+            endpoint.pathname = `${endpoint.pathname}/${this.options.connectionId}${path}`;
+            if (this.options.basicAuth) {
+                let authorization = Buffer.from(`${this.options.basicAuth.username}:${this.options.basicAuth.password}`).toString('base64');
+                headers["Authorization"] = `Basic ${authorization}`;
+            } else if (this.options.jwtAuth) {
+                headers["Authorization"] = `Bearer ${this.options.jwtAuth.bearerToken}`;
+            }
+        } else {
+            endpoint.pathname = `${endpoint.pathname}/${this.options.apiKey}${path}`;
+            endpoint.searchParams.set("__id", this.options.spreadsheetId);
+        }
+
+        if (queryParams) {
+            if (typeof queryParams != 'string') {
+                queryParams.forEach((value, key) => {
+                    endpoint.searchParams.append(key, value);
+                });
+            } else {
+                endpoint.search = queryParams
+                if(this.options.mode == 'apikey'){
+                    endpoint.searchParams.set("__id", this.options.spreadsheetId);
+                }
+            }
+        }
+        const response = await this.fetchFn(endpoint.toString(), {
+            headers,
+            method,
+            body: body ? JSON.stringify(body) : undefined
+        });
+        if (response.ok) {
+            return response.json() as Promise<T>;
+        } else {
+            throw new Error(await response.text());
+        }
+    }
+
+    ReadContent<T>(options?: ReadOptions) {
+        const query = new URLSearchParams(options as Record<string, string>);
+        return this.fetch<T>('', "GET", query);
+    }
+
+    Keys(options?: GetKeysOptions) {
+        const query = new URLSearchParams(options as Record<string, string>);
+        return this.fetch<string[]>('/keys', "GET", query);
+    }
+
+    Count(options?: GetCountOptions) {
+        const query = new URLSearchParams(options as Record<string, string>);
+        return this.fetch<{ count: number }>('/count', "GET", query);
+    }
+
+    Title() {
+        return this.fetch<{ spreadsheet_title: string, api_name: string }>('/title', "GET");
+    }
+
+    Range(options: GetRangeOptions) {
+        return this.fetch<string[][]>(`/range/${options.range}`, "GET");
+    }
+
+    Search(options: SearchOptions) {
+        let path = options.or ? "/search_or" : "/search";
+        if (options.sheet) {
+            path = `${path}/${options.sheet}`;
+        }
+        return this.fetch<Record<string, any>>(path, "GET", encodeURIComponent(options.query));
+    }
+
+    Insert(options: InsertOptions) {
+        const { data, ...queryParams } = options;
+        const query = new URLSearchParams(queryParams as Record<string, string>);
+        return this.fetch<{ inserted: number }>('/', "POST", query, data);
+    }
+
+    UpdateRow(options: UpdateRowOptions) {
+        const { row, data, ...queryParams } = options;
+        const query = new URLSearchParams(queryParams as Record<string, string>);
+        return this.fetch<{ updated: number }>(`/row/${row}`, "PATCH", query, data);
+    }
+
+    UpdateWithQuery(options: UpdateWithQueryOptions) {
+        const { sheet, data, query } = options;
+        let path = '';
+        if (sheet) {
+            path = `/${sheet}`;
+        }
+        return this.fetch<{ updated: number }>(path, "PATCH", encodeURIComponent(query), data);
+    }
+
+    BatchUpdate(options: BatchUpdateOptions) {
+        const { batches, sheet } = options;
+        let path = '/batch';
+        if (sheet) {
+            path = path + '/' + sheet;
+        }
+        return this.fetch<{ updated: number }>(path, "PATCH", undefined, batches);
+    }
+
+    DeleteRow(options: DeleteRowOptions) {
+        const { row, ...queryParams } = options;
+        const query = new URLSearchParams(queryParams as Record<string, string>);
+        return this.fetch<{ deleted: number }>(`/row/${row}`, "DELETE", query);
+    }
+
+    DeleteWithQuery(options: DeleteWithQueryOptions) {
+        const { query, sheet } = options;
+        let path = '';
+        if (sheet) {
+            path = `/${sheet}`;
+        }
+        return this.fetch<{ deleted: number }>(path, "DELETE", encodeURIComponent(query));
+    }
+
+    Clear(options: ClearSheetOptions) {
+        const path = `/clear/${options.sheet}`;
+        return this.fetch(path, "DELETE");
+    }
+
+    CreateSheet(options: CreateSheetOptions) {
+        const query = new URLSearchParams(options as Record<string, string>);
+        return this.fetch('/sheet', "POST", query);
+    }
+
+    DeleteSheet(options: DeleteSheetOptions) {
+        const path = `/sheet/${options.sheet}`;
+        return this.fetch(path, "DELETE");
+    }
+}

package/tests/index.test.ts

@@ -0,0 +1,216 @@
+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
+        });
+
+    })
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+      "target": "ES6",
+      "module": "CommonJS",
+      "moduleResolution": "node",
+      "outDir": "./dist",
+      "rootDir": "./src",
+      "strict": true,
+      "esModuleInterop": true,
+      "skipLibCheck": true,
+      "declaration": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules"]
+  }
+