@sheet2db/sdk 1.0.8 → 2.0.0

package/dist/index.d.ts

@@ -1,128 +1,141 @@
-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[] | 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;
-};
-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 = {
+import { AxiosInstance } from 'axios';
+import { z } from 'zod';
+
+declare const DataAPIReadOptionsDTO: z.ZodObject<{
+    limit: z.ZodEffects<z.ZodOptional<z.ZodString>, number | undefined, string | undefined>;
+    offset: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, number, string | undefined>;
+    sortColumn: z.ZodOptional<z.ZodString>;
+    sortDirection: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+    sortColumnFormat: z.ZodOptional<z.ZodLiteral<"date">>;
+    filter: z.ZodOptional<z.ZodString>;
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["rows", "columns", "matrix"]>>>;
+    columns: z.ZodEffects<z.ZodOptional<z.ZodString>, string[] | undefined, string | undefined>;
+    castNumbers: z.ZodEffects<z.ZodOptional<z.ZodString>, string[] | undefined, string | undefined>;
+}, "strip", z.ZodTypeAny, {
+    offset: number;
+    sortDirection: "asc" | "desc";
+    format: "rows" | "columns" | "matrix";
+    limit?: number | undefined;
+    filter?: string | undefined;
+    sortColumn?: string | undefined;
+    sortColumnFormat?: "date" | undefined;
+    columns?: string[] | undefined;
+    castNumbers?: string[] | undefined;
+}, {
+    limit?: string | undefined;
+    filter?: string | undefined;
+    offset?: string | undefined;
+    sortColumn?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+    sortColumnFormat?: "date" | undefined;
+    columns?: string | undefined;
+    format?: "rows" | "columns" | "matrix" | undefined;
+    castNumbers?: string | undefined;
+}>;
+declare const DataAPIInsertOptionsDTO: z.ZodObject<{
+    data: z.ZodArray<z.ZodAny, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: any[];
+}, {
+    data: any[];
+}>;
+declare const DataAPIUpdateOptionsDTO: z.ZodUnion<[z.ZodObject<{
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+    row: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
+    type: z.ZodDefault<z.ZodLiteral<"row">>;
+}, "strip", z.ZodTypeAny, {
+    data: Record<string, any>;
+    type: "row";
     row: number;
-    sheet?: string;
+}, {
+    data: Record<string, any>;
+    row: string | number;
+    type?: "row" | undefined;
+}>, z.ZodObject<{
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+    filter: z.ZodString;
+    type: z.ZodDefault<z.ZodLiteral<"filter">>;
+}, "strip", z.ZodTypeAny, {
     data: Record<string, any>;
-};
-export type UpdateWithQueryOptions = {
-    sheet?: string;
-    query: string;
+    filter: string;
+    type: "filter";
+}, {
     data: Record<string, any>;
-};
-export type BatchUpdateOptions = {
-    sheet?: string;
-    batches: {
-        query: string;
-        record: Record<string, any>;
-    }[];
-};
-export type DeleteRowOptions = {
-    sheet?: string;
+    filter: string;
+    type?: "filter" | undefined;
+}>]>;
+declare const DataAPIDeleteOptionsDTO: z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
+    row: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
+}, "strip", z.ZodTypeAny, {
     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 declare 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<{
+}, {
+    row: string | number;
+}>, {
+    row: number;
+    type: "row";
+}, {
+    row: string | number;
+}>, z.ZodObject<{
+    filter: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    filter: string;
+}, {
+    filter: string;
+}>]>, {
+    row: number;
+    type: "row";
+} | {
+    filter: string;
+    type: "filter";
+}, {
+    row: string | number;
+} | {
+    filter: string;
+}>;
+declare const DataAPIAddSheetOptionsDTO: z.ZodObject<{
+    name: z.ZodString;
+    firstRow: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    copyColumnsFrom: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    firstRow?: string[] | undefined;
+    copyColumnsFrom?: string | undefined;
+}, {
+    name: string;
+    firstRow?: string[] | undefined;
+    copyColumnsFrom?: string | undefined;
+}>;
+
+type ReadOptions = z.infer<typeof DataAPIReadOptionsDTO>;
+type InsertOptions = z.infer<typeof DataAPIInsertOptionsDTO>;
+type UpdateOptions = z.infer<typeof DataAPIUpdateOptionsDTO>;
+type DeleteOptions = z.infer<typeof DataAPIDeleteOptionsDTO>;
+type AddSheetOptions = z.infer<typeof DataAPIAddSheetOptionsDTO>;
+
+declare class Sheet2DBClient {
+    authentication: string | null;
+    axios: AxiosInstance;
+    constructor(apiId: string, version?: "v1");
+    private endpoint;
+    useBasicAuthentication(username: string, password: string): void;
+    useJWTAuthentication(token: string): void;
+    useBearerTokenAuthentication(token: string): void;
+    Read<T = any>(options: ReadOptions, sheet?: string): Promise<T>;
+    Update(options: UpdateOptions, sheet?: string): Promise<{
         updated: number;
     }>;
-    DeleteRow(options: DeleteRowOptions): Promise<{
-        deleted: number;
+    Insert(options: InsertOptions, sheet?: string): Promise<{
+        inserted: number;
     }>;
-    DeleteWithQuery(options: DeleteWithQueryOptions): Promise<{
+    Delete(options: DeleteOptions, sheet?: string): Promise<{
         deleted: number;
     }>;
-    Clear(options: ClearSheetOptions): Promise<{
-        success: boolean;
-    }>;
-    CreateSheet(options: CreateSheetOptions): Promise<{
-        success: boolean;
+    AddSheet(options: AddSheetOptions): Promise<{
+        ok: true;
     }>;
-    DeleteSheet(options: DeleteSheetOptions): Promise<{
-        success: boolean;
+    DeleteSheet(sheet: string): Promise<{
+        ok: true;
     }>;
 }
+
+export { Sheet2DBClient };

package/dist/index.js

@@ -1,147 +1,127 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sheet2DB = void 0;
-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
-    fetchFunction = async (...args) => {
-        const fetch = global.fetch;
-        return fetch.apply(null, args);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
     };
-}
-class Sheet2DB {
-    constructor(options) {
-        this.options = options;
-        this.apiEndpoint = "https://api.sheet2db.com";
-        this.fetchFn = options.fetchFn || fetchFunction;
-    }
-    async fetch(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 = `${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.href, {
-            headers,
-            method,
-            body: body ? JSON.stringify(body) : undefined
-        });
-        if (response.ok) {
-            return response.json();
-        }
-        else {
-            throw new Error(await response.text());
-        }
-    }
-    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);
-    }
-    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}`;
-        }
-        return this.fetch(path, "GET", encodeURIComponent(options.query));
-    }
-    Insert(options) {
-        const { data, ...queryParams } = options;
-        const query = new URLSearchParams(queryParams);
-        return this.fetch('', "POST", query, data);
-    }
-    UpdateRow(options) {
-        const { row, data, ...queryParams } = options;
-        const query = new URLSearchParams(queryParams);
-        return this.fetch(`/row/${row}`, "PATCH", query, data);
-    }
-    UpdateWithQuery(options) {
-        const { sheet, data, query } = options;
-        let path = '';
-        if (sheet) {
-            path = `/${sheet}`;
-        }
-        return this.fetch(path, "PATCH", encodeURIComponent(query), data);
-    }
-    BatchUpdate(options) {
-        const { batches, sheet } = options;
-        let path = '/batch';
-        if (sheet) {
-            path = path + '/' + sheet;
-        }
-        return this.fetch(path, "PATCH", undefined, batches);
-    }
-    DeleteRow(options) {
-        const { row, ...queryParams } = options;
-        const query = new URLSearchParams(queryParams);
-        return this.fetch(`/row/${row}`, "DELETE", query);
-    }
-    DeleteWithQuery(options) {
-        const { query, sheet } = options;
-        let path = '';
-        if (sheet) {
-            path = `/${sheet}`;
-        }
-        return this.fetch(path, "DELETE", encodeURIComponent(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.Sheet2DB = Sheet2DB;
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Sheet2DBClient: () => Sheet2DBClient
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios = __toESM(require("axios"));
+var isNode = typeof window == "undefined";
+var Sheet2DBClient = class {
+  constructor(apiId, version = "v1") {
+    this.authentication = null;
+    if (!(apiId == null ? void 0 : apiId.trim())) throw new Error("apiId is required to create a Sheet2DBClient.");
+    this.axios = import_axios.default.create({
+      baseURL: process.env.SHEET2DB_BASE_URL || "https://api.sheet2db.io/" + version + "/data/" + apiId,
+      paramsSerializer: {
+        serialize: (params) => new URLSearchParams(params).toString()
+      }
+    });
+    this.axios.interceptors.request.use((config) => {
+      if (this.authentication) {
+        config.headers.Authorization = this.authentication;
+      }
+      return config;
+    });
+  }
+  endpoint(sheet) {
+    return sheet ? `/${sheet}` : "/";
+  }
+  useBasicAuthentication(username, password) {
+    const token = isNode ? Buffer.from(`${username}:${password}`).toString("base64") : btoa(`${username}:${password}`);
+    this.authentication = `Basic ${token}`;
+  }
+  useJWTAuthentication(token) {
+    this.authentication = "Bearer " + token;
+  }
+  useBearerTokenAuthentication(token) {
+    this.authentication = "Bearer " + token;
+  }
+  Read(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.get(this.endpoint(sheet), {
+        params: options
+      }).then((res) => res.data);
+    });
+  }
+  Update(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.patch(this.endpoint(sheet), options).then((res) => res.data);
+    });
+  }
+  Insert(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.post(this.endpoint(sheet), options).then((res) => res.data);
+    });
+  }
+  Delete(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.delete(this.endpoint(sheet), {
+        params: options
+      }).then((res) => res.data);
+    });
+  }
+  AddSheet(options) {
+    return __async(this, null, function* () {
+      return this.axios.post("/sheet", options).then((res) => res.data);
+    });
+  }
+  DeleteSheet(sheet) {
+    return __async(this, null, function* () {
+      if (!sheet) throw new Error("sheet is required to Delete Sheet");
+      return this.axios.delete(this.endpoint(sheet)).then((res) => res.data);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Sheet2DBClient
+});

package/dist/index.mjs

@@ -0,0 +1,93 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import axios from "axios";
+var isNode = typeof window == "undefined";
+var Sheet2DBClient = class {
+  constructor(apiId, version = "v1") {
+    this.authentication = null;
+    if (!(apiId == null ? void 0 : apiId.trim())) throw new Error("apiId is required to create a Sheet2DBClient.");
+    this.axios = axios.create({
+      baseURL: process.env.SHEET2DB_BASE_URL || "https://api.sheet2db.io/" + version + "/data/" + apiId,
+      paramsSerializer: {
+        serialize: (params) => new URLSearchParams(params).toString()
+      }
+    });
+    this.axios.interceptors.request.use((config) => {
+      if (this.authentication) {
+        config.headers.Authorization = this.authentication;
+      }
+      return config;
+    });
+  }
+  endpoint(sheet) {
+    return sheet ? `/${sheet}` : "/";
+  }
+  useBasicAuthentication(username, password) {
+    const token = isNode ? Buffer.from(`${username}:${password}`).toString("base64") : btoa(`${username}:${password}`);
+    this.authentication = `Basic ${token}`;
+  }
+  useJWTAuthentication(token) {
+    this.authentication = "Bearer " + token;
+  }
+  useBearerTokenAuthentication(token) {
+    this.authentication = "Bearer " + token;
+  }
+  Read(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.get(this.endpoint(sheet), {
+        params: options
+      }).then((res) => res.data);
+    });
+  }
+  Update(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.patch(this.endpoint(sheet), options).then((res) => res.data);
+    });
+  }
+  Insert(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.post(this.endpoint(sheet), options).then((res) => res.data);
+    });
+  }
+  Delete(options, sheet) {
+    return __async(this, null, function* () {
+      return this.axios.delete(this.endpoint(sheet), {
+        params: options
+      }).then((res) => res.data);
+    });
+  }
+  AddSheet(options) {
+    return __async(this, null, function* () {
+      return this.axios.post("/sheet", options).then((res) => res.data);
+    });
+  }
+  DeleteSheet(sheet) {
+    return __async(this, null, function* () {
+      if (!sheet) throw new Error("sheet is required to Delete Sheet");
+      return this.axios.delete(this.endpoint(sheet)).then((res) => res.data);
+    });
+  }
+};
+export {
+  Sheet2DBClient
+};

package/jest.config.js

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