@ponxa/potatobase-client 0.1.0

package/dist/index.mjs

@@ -0,0 +1,478 @@
+// 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);
+}
+export {
+  PotatoBaseClient,
+  TableClient,
+  between,
+  createClient,
+  daysAgo,
+  hoursAgo,
+  lastDays,
+  minutesAgo,
+  since,
+  thisMonth,
+  thisYear,
+  today,
+  until
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@ponxa/potatobase-client",
+  "version": "0.1.0",
+  "description": "Official JavaScript/TypeScript client for PotatoBase",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ponxa/potatobase-client.git"
+  },
+  "homepage": "https://potatobase.com",
+  "bugs": {
+    "url": "https://github.com/ponxa/potatobase-client/issues"
+  },
+  "keywords": [
+    "potatobase",
+    "dynamodb",
+    "database",
+    "client",
+    "sdk",
+    "typescript",
+    "sst",
+    "serverless",
+    "aws"
+  ],
+  "author": "PotatoBase Team",
+  "license": "MIT",
+  "dependencies": {
+    "@trpc/client": "^10.45.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.2"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  }
+}