@ponxa/potatobase-client 0.1.0

package/dist/index.js

@@ -0,0 +1,517 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PotatoBaseClient: () => PotatoBaseClient,
+  TableClient: () => TableClient,
+  between: () => between,
+  createClient: () => createClient,
+  daysAgo: () => daysAgo,
+  hoursAgo: () => hoursAgo,
+  lastDays: () => lastDays,
+  minutesAgo: () => minutesAgo,
+  since: () => since,
+  thisMonth: () => thisMonth,
+  thisYear: () => thisYear,
+  today: () => today,
+  until: () => until
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/table-client.ts
+var TableClient = class {
+  constructor(apiUrl, apiKey, projectId, tableName, debug = false) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+    this.projectId = projectId;
+    this.tableName = tableName;
+    this.debug = debug;
+  }
+  async callAPI(procedure, input, method = "GET") {
+    const url = `${this.apiUrl}/${procedure}`;
+    if (method === "GET") {
+      const params = new URLSearchParams({
+        input: JSON.stringify(input)
+      });
+      const response = await fetch(`${url}?${params}`, {
+        method: "GET",
+        headers: {
+          "x-api-key": this.apiKey
+        }
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API error: ${error}`);
+      }
+      const data = await response.json();
+      return data.result?.data || data;
+    } else {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey
+        },
+        body: JSON.stringify(input)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API error: ${error}`);
+      }
+      const data = await response.json();
+      return data.result?.data || data;
+    }
+  }
+  /**
+   * Query records from the table
+   *
+   * @param params - Query parameters (index, where, range, limit, cursor)
+   * @returns Query result with data and optional cursor
+   *
+   * @example
+   * ```typescript
+   * // Query by primary key
+   * const result = await products.query({ where: { id: 'prod-1' } });
+   *
+   * // Query by GSI
+   * const result = await products.query({
+   *   index: 'byCategory',
+   *   where: { category: 'clothing' },
+   *   limit: 10
+   * });
+   *
+   * // Query with date range
+   * const result = await products.query({
+   *   index: 'byCategory',
+   *   where: { category: 'clothing' },
+   *   range: {
+   *     field: 'createdAt',
+   *     gte: '2025-01-01',
+   *     lte: '2025-01-31'
+   *   }
+   * });
+   * ```
+   */
+  async query(params) {
+    if (this.debug) {
+      console.log(`[TableClient:${this.tableName}] query:`, params);
+    }
+    try {
+      const result = await this.callAPI("query.execute", {
+        projectId: this.projectId,
+        tableName: this.tableName,
+        index: params?.index,
+        where: params?.where,
+        range: params?.range,
+        limit: params?.limit,
+        cursor: params?.cursor
+      });
+      if (this.debug) {
+        console.log(`[TableClient:${this.tableName}] query result:`, {
+          count: result.data?.length || 0,
+          hasMore: !!result.cursor
+        });
+      }
+      return result.data || result;
+    } catch (error) {
+      console.error(`[TableClient:${this.tableName}] query error:`, error.message);
+      throw new Error(`Failed to query ${this.tableName}: ${error.message}`);
+    }
+  }
+  /**
+   * Get a single record by ID
+   *
+   * @param id - Record ID
+   * @returns Record or null if not found
+   *
+   * @example
+   * ```typescript
+   * const product = await products.get('prod-1');
+   * ```
+   */
+  async get(id) {
+    if (this.debug) {
+      console.log(`[TableClient:${this.tableName}] get:`, id);
+    }
+    try {
+      const result = await this.callAPI("query.get", {
+        projectId: this.projectId,
+        tableName: this.tableName,
+        recordId: id
+      });
+      return result || null;
+    } catch (error) {
+      if (error.message?.includes("not found")) {
+        return null;
+      }
+      console.error(`[TableClient:${this.tableName}] get error:`, error.message);
+      throw new Error(`Failed to get record from ${this.tableName}: ${error.message}`);
+    }
+  }
+  /**
+   * Insert a new record
+   *
+   * @param data - Record data (must include 'id' field)
+   * @returns Created record
+   *
+   * @example
+   * ```typescript
+   * const newProduct = await products.insert({
+   *   id: 'prod-1',
+   *   title: 'T-Shirt',
+   *   price: 29.99,
+   *   category: 'clothing'
+   * });
+   * ```
+   */
+  async insert(data) {
+    if (this.debug) {
+      console.log(`[TableClient:${this.tableName}] insert:`, data);
+    }
+    if (!data.id) {
+      throw new Error('Record must have an "id" field');
+    }
+    try {
+      const result = await this.callAPI("query.create", {
+        projectId: this.projectId,
+        tableName: this.tableName,
+        data
+      }, "POST");
+      if (this.debug) {
+        console.log(`[TableClient:${this.tableName}] insert success:`, result.id);
+      }
+      return result;
+    } catch (error) {
+      console.error(`[TableClient:${this.tableName}] insert error:`, error.message);
+      throw new Error(`Failed to insert into ${this.tableName}: ${error.message}`);
+    }
+  }
+  /**
+   * Update an existing record
+   *
+   * @param id - Record ID
+   * @param data - Fields to update
+   * @returns Updated record
+   *
+   * @example
+   * ```typescript
+   * const updated = await products.update('prod-1', {
+   *   price: 24.99,
+   *   stock: 100
+   * });
+   * ```
+   */
+  async update(id, data) {
+    if (this.debug) {
+      console.log(`[TableClient:${this.tableName}] update:`, { id, data });
+    }
+    try {
+      const result = await this.callAPI("query.update", {
+        projectId: this.projectId,
+        tableName: this.tableName,
+        recordId: id,
+        data
+      }, "POST");
+      if (this.debug) {
+        console.log(`[TableClient:${this.tableName}] update success`);
+      }
+      return result;
+    } catch (error) {
+      console.error(`[TableClient:${this.tableName}] update error:`, error.message);
+      throw new Error(`Failed to update record in ${this.tableName}: ${error.message}`);
+    }
+  }
+  /**
+   * Delete a record
+   *
+   * @param id - Record ID
+   * @returns Success status
+   *
+   * @example
+   * ```typescript
+   * await products.delete('prod-1');
+   * ```
+   */
+  async delete(id) {
+    if (this.debug) {
+      console.log(`[TableClient:${this.tableName}] delete:`, id);
+    }
+    try {
+      const result = await this.callAPI("query.delete", {
+        projectId: this.projectId,
+        tableName: this.tableName,
+        recordId: id
+      }, "POST");
+      if (this.debug) {
+        console.log(`[TableClient:${this.tableName}] delete success`);
+      }
+      return result;
+    } catch (error) {
+      console.error(`[TableClient:${this.tableName}] delete error:`, error.message);
+      throw new Error(`Failed to delete from ${this.tableName}: ${error.message}`);
+    }
+  }
+  /**
+   * Create a new record (alias for insert)
+   *
+   * @param data - Record data (must include 'id' field)
+   * @returns Created record
+   *
+   * @example
+   * ```typescript
+   * const newProduct = await products.create({
+   *   id: 'prod-1',
+   *   title: 'T-Shirt',
+   *   price: 29.99,
+   *   category: 'clothing'
+   * });
+   * ```
+   */
+  async create(data) {
+    return this.insert(data);
+  }
+  /**
+   * Alias for query() - chainable method
+   *
+   * @example
+   * ```typescript
+   * const items = await products.from().query({ limit: 10 });
+   * ```
+   */
+  from() {
+    return this;
+  }
+};
+
+// src/helpers.ts
+function daysAgo(days) {
+  const date = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+  return date.toISOString();
+}
+function hoursAgo(hours) {
+  const date = new Date(Date.now() - hours * 60 * 60 * 1e3);
+  return date.toISOString();
+}
+function minutesAgo(minutes) {
+  const date = new Date(Date.now() - minutes * 60 * 1e3);
+  return date.toISOString();
+}
+function lastDays(field, days) {
+  return {
+    field,
+    gte: daysAgo(days)
+  };
+}
+function between(field, startDate, endDate) {
+  return {
+    field,
+    between: [startDate, endDate]
+  };
+}
+function since(field, date) {
+  return {
+    field,
+    gte: date
+  };
+}
+function until(field, date) {
+  return {
+    field,
+    lte: date
+  };
+}
+function thisMonth(field) {
+  const now = /* @__PURE__ */ new Date();
+  const start = new Date(now.getFullYear(), now.getMonth(), 1);
+  const end = new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59, 999);
+  return {
+    field,
+    between: [start.toISOString(), end.toISOString()]
+  };
+}
+function thisYear(field) {
+  const now = /* @__PURE__ */ new Date();
+  const start = new Date(now.getFullYear(), 0, 1);
+  const end = new Date(now.getFullYear(), 11, 31, 23, 59, 59, 999);
+  return {
+    field,
+    between: [start.toISOString(), end.toISOString()]
+  };
+}
+function today(field) {
+  const now = /* @__PURE__ */ new Date();
+  const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const end = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59, 999);
+  return {
+    field,
+    between: [start.toISOString(), end.toISOString()]
+  };
+}
+
+// src/index.ts
+var PotatoBaseClient = class {
+  constructor(config) {
+    if (!config.projectId) {
+      throw new Error("PotatoBase: projectId is required");
+    }
+    if (!config.apiKey) {
+      throw new Error("PotatoBase: apiKey is required");
+    }
+    this.config = {
+      ...config,
+      apiUrl: config.apiUrl || "https://api.potatobase.com",
+      debug: config.debug || false
+    };
+    this.tableClients = /* @__PURE__ */ new Map();
+    if (this.config.debug) {
+      console.log("[PotatoBaseClient] Initializing with config:", {
+        projectId: this.config.projectId,
+        apiUrl: this.config.apiUrl,
+        apiKey: this.config.apiKey.substring(0, 20) + "..."
+      });
+    }
+  }
+  /**
+   * Access a table by name
+   *
+   * Returns a TableClient instance for performing CRUD operations.
+   * TableClient instances are cached for performance.
+   *
+   * @param tableName - Name of the table
+   * @returns TableClient for the specified table
+   *
+   * @example
+   * ```typescript
+   * const products = pb.table('products');
+   * const items = await products.query({ limit: 10 });
+   * ```
+   */
+  table(tableName) {
+    const key = tableName;
+    if (this.tableClients.has(key)) {
+      return this.tableClients.get(key);
+    }
+    if (this.config.debug) {
+      console.log(`[PotatoBaseClient] Creating TableClient for: ${key}`);
+    }
+    const tableClient = new TableClient(
+      this.config.apiUrl,
+      this.config.apiKey,
+      this.config.projectId,
+      key,
+      this.config.debug
+    );
+    this.tableClients.set(key, tableClient);
+    return tableClient;
+  }
+  /**
+   * Generate TypeScript types for your project
+   *
+   * Fetches the current schema and generates TypeScript interface definitions.
+   * Save the result to a .d.ts file in your project.
+   *
+   * @returns Generated TypeScript types as string
+   *
+   * @example
+   * ```typescript
+   * const types = await pb.generateTypes();
+   * fs.writeFileSync('./types/database.d.ts', types);
+   * ```
+   */
+  async generateTypes() {
+    if (this.config.debug) {
+      console.log("[PotatoBaseClient] Generating types for project:", this.config.projectId);
+    }
+    try {
+      const params = new URLSearchParams({
+        input: JSON.stringify(this.config.projectId)
+      });
+      const response = await fetch(`${this.config.apiUrl}/projects.generateTypes?${params}`, {
+        method: "GET",
+        headers: {
+          "x-api-key": this.config.apiKey
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to generate types: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const result = data.result?.data || data;
+      if (this.config.debug) {
+        console.log("[PotatoBaseClient] Types generated:", {
+          length: result.types.length
+        });
+      }
+      return result.types;
+    } catch (error) {
+      console.error("[PotatoBaseClient] Failed to generate types:", error.message);
+      throw new Error(`Failed to generate types: ${error.message}`);
+    }
+  }
+  /**
+   * Get the project ID
+   */
+  getProjectId() {
+    return this.config.projectId;
+  }
+  /**
+   * Get the API URL
+   */
+  getApiUrl() {
+    return this.config.apiUrl;
+  }
+  /**
+   * Clear all cached table clients
+   *
+   * Useful for testing or when you want to force fresh clients.
+   */
+  clearCache() {
+    if (this.config.debug) {
+      console.log("[PotatoBaseClient] Clearing table client cache");
+    }
+    this.tableClients.clear();
+  }
+  /**
+   * Enable/disable debug logging
+   */
+  setDebug(enabled) {
+    this.config.debug = enabled;
+  }
+};
+function createClient(config) {
+  return new PotatoBaseClient(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PotatoBaseClient,
+  TableClient,
+  between,
+  createClient,
+  daysAgo,
+  hoursAgo,
+  lastDays,
+  minutesAgo,
+  since,
+  thisMonth,
+  thisYear,
+  today,
+  until
+});