spaps-sdk 0.1.0

package/README.md

@@ -0,0 +1,164 @@
+# @spaps/sdk
+
+> Sweet Potato Authentication & Payment Service SDK
+
+Zero-config client for SPAPS authentication and payments. Works automatically with local development mode.
+
+## Installation
+
+```bash
+npm install @spaps/sdk
+# or
+yarn add @spaps/sdk
+```
+
+## Quick Start
+
+```javascript
+import { SPAPSClient } from '@spaps/sdk';
+// or
+const { SPAPSClient } = require('@spaps/sdk');
+
+// Auto-detects local mode - no API key needed for localhost!
+const spaps = new SPAPSClient({
+  apiUrl: 'http://localhost:3300' // Optional, auto-detected
+});
+
+// Login
+const { data } = await spaps.login('user@example.com', 'password');
+console.log('User:', data.user);
+
+// Check authentication
+if (spaps.isAuthenticated()) {
+  const user = await spaps.getUser();
+  console.log('Current user:', user.data);
+}
+```
+
+## Features
+
+### 🚀 Zero Configuration
+- **Auto-detects local mode** - No API key needed for localhost
+- **Auto-refreshes tokens** - Handles expired tokens automatically
+- **TypeScript support** - Full type definitions included
+
+### 🔐 Authentication Methods
+```javascript
+// Email/Password
+await spaps.login(email, password);
+await spaps.register(email, password);
+
+// Wallet Authentication
+await spaps.walletSignIn(walletAddress, signature, message, 'solana');
+
+// Token Management
+await spaps.refresh();
+await spaps.logout();
+
+// Get User
+const user = await spaps.getUser();
+```
+
+### 💳 Stripe Integration
+```javascript
+// Create checkout session
+const session = await spaps.createCheckoutSession(priceId, successUrl);
+window.location.href = session.data.url;
+
+// Manage subscription
+const subscription = await spaps.getSubscription();
+await spaps.cancelSubscription();
+```
+
+### 📊 Usage Tracking
+```javascript
+// Check balance
+const balance = await spaps.getUsageBalance();
+console.log(`Credits: ${balance.data.balance}`);
+
+// Record usage
+await spaps.recordUsage('api-call', 1);
+```
+
+## Configuration
+
+### Production Mode
+```javascript
+const spaps = new SPAPSClient({
+  apiUrl: 'https://api.sweetpotato.com',
+  apiKey: 'spaps_your_api_key_here',
+  timeout: 10000 // Optional timeout in ms
+});
+```
+
+### Local Development Mode (Auto-detected)
+```javascript
+const spaps = new SPAPSClient();
+// Automatically uses http://localhost:3300 with no API key
+```
+
+### Environment Variables
+```bash
+# .env
+SPAPS_API_URL=https://api.sweetpotato.com
+SPAPS_API_KEY=spaps_your_api_key_here
+
+# Next.js
+NEXT_PUBLIC_SPAPS_API_URL=https://api.sweetpotato.com
+```
+
+## Helper Methods
+
+```javascript
+// Check if authenticated
+spaps.isAuthenticated() // boolean
+
+// Get current access token
+spaps.getAccessToken() // string | undefined
+
+// Set access token manually
+spaps.setAccessToken(token)
+
+// Check if in local mode
+spaps.isLocalMode() // boolean
+
+// Health check
+await spaps.health()
+```
+
+## Import Styles
+
+All these work:
+```javascript
+// ES6 Import
+import { SPAPSClient } from '@spaps/sdk';
+import SPAPSClient from '@spaps/sdk';
+
+// CommonJS
+const { SPAPSClient } = require('@spaps/sdk');
+const SPAPSClient = require('@spaps/sdk');
+
+// Alternative names
+import { SPAPS } from '@spaps/sdk';
+import { SweetPotatoSDK } from '@spaps/sdk';
+```
+
+## Error Handling
+
+```javascript
+try {
+  await spaps.login(email, password);
+} catch (error) {
+  if (error.response?.status === 401) {
+    console.error('Invalid credentials');
+  } else if (error.response?.status === 429) {
+    console.error('Rate limited');
+  } else {
+    console.error('Error:', error.message);
+  }
+}
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,82 @@
+/**
+ * @spaps/sdk - Sweet Potato Authentication & Payment Service SDK
+ * Zero-config client for SPAPS authentication and payments
+ */
+interface SPAPSConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    autoDetect?: boolean;
+    timeout?: number;
+}
+interface AuthResponse {
+    access_token: string;
+    refresh_token: string;
+    user: User;
+}
+interface User {
+    id: string;
+    email?: string;
+    wallet_address?: string;
+    chain_type?: string;
+    role: string;
+    created_at?: string;
+}
+interface CheckoutSession {
+    sessionId: string;
+    url: string;
+}
+interface Subscription {
+    id: string;
+    status: string;
+    plan: string;
+    current_period_end: string;
+}
+interface UsageBalance {
+    balance: number;
+    currency: string;
+    updated_at: string;
+}
+declare class SPAPSClient {
+    private client;
+    private apiKey?;
+    private accessToken?;
+    private refreshToken?;
+    private _isLocalMode;
+    constructor(config?: SPAPSConfig);
+    login(email: string, password: string): Promise<{
+        data: AuthResponse;
+    }>;
+    register(email: string, password: string): Promise<{
+        data: AuthResponse;
+    }>;
+    walletSignIn(walletAddress: string, signature: string, message: string, chainType?: 'solana' | 'ethereum'): Promise<{
+        data: AuthResponse;
+    }>;
+    refresh(refreshToken?: string): Promise<{
+        data: AuthResponse;
+    }>;
+    logout(): Promise<void>;
+    getUser(): Promise<{
+        data: User;
+    }>;
+    createCheckoutSession(priceId: string, successUrl: string, cancelUrl?: string): Promise<{
+        data: CheckoutSession;
+    }>;
+    getSubscription(): Promise<{
+        data: Subscription;
+    }>;
+    cancelSubscription(): Promise<void>;
+    getUsageBalance(): Promise<{
+        data: UsageBalance;
+    }>;
+    recordUsage(feature: string, amount: number): Promise<void>;
+    isAuthenticated(): boolean;
+    getAccessToken(): string | undefined;
+    setAccessToken(token: string): void;
+    isLocalMode(): boolean;
+    health(): Promise<{
+        data: any;
+    }>;
+}
+
+export { type AuthResponse, type CheckoutSession, SPAPSClient as SPAPS, SPAPSClient, type SPAPSConfig, type Subscription, SPAPSClient as SweetPotatoSDK, type UsageBalance, type User, SPAPSClient as default };

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @spaps/sdk - Sweet Potato Authentication & Payment Service SDK
+ * Zero-config client for SPAPS authentication and payments
+ */
+interface SPAPSConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    autoDetect?: boolean;
+    timeout?: number;
+}
+interface AuthResponse {
+    access_token: string;
+    refresh_token: string;
+    user: User;
+}
+interface User {
+    id: string;
+    email?: string;
+    wallet_address?: string;
+    chain_type?: string;
+    role: string;
+    created_at?: string;
+}
+interface CheckoutSession {
+    sessionId: string;
+    url: string;
+}
+interface Subscription {
+    id: string;
+    status: string;
+    plan: string;
+    current_period_end: string;
+}
+interface UsageBalance {
+    balance: number;
+    currency: string;
+    updated_at: string;
+}
+declare class SPAPSClient {
+    private client;
+    private apiKey?;
+    private accessToken?;
+    private refreshToken?;
+    private _isLocalMode;
+    constructor(config?: SPAPSConfig);
+    login(email: string, password: string): Promise<{
+        data: AuthResponse;
+    }>;
+    register(email: string, password: string): Promise<{
+        data: AuthResponse;
+    }>;
+    walletSignIn(walletAddress: string, signature: string, message: string, chainType?: 'solana' | 'ethereum'): Promise<{
+        data: AuthResponse;
+    }>;
+    refresh(refreshToken?: string): Promise<{
+        data: AuthResponse;
+    }>;
+    logout(): Promise<void>;
+    getUser(): Promise<{
+        data: User;
+    }>;
+    createCheckoutSession(priceId: string, successUrl: string, cancelUrl?: string): Promise<{
+        data: CheckoutSession;
+    }>;
+    getSubscription(): Promise<{
+        data: Subscription;
+    }>;
+    cancelSubscription(): Promise<void>;
+    getUsageBalance(): Promise<{
+        data: UsageBalance;
+    }>;
+    recordUsage(feature: string, amount: number): Promise<void>;
+    isAuthenticated(): boolean;
+    getAccessToken(): string | undefined;
+    setAccessToken(token: string): void;
+    isLocalMode(): boolean;
+    health(): Promise<{
+        data: any;
+    }>;
+}
+
+export { type AuthResponse, type CheckoutSession, SPAPSClient as SPAPS, SPAPSClient, type SPAPSConfig, type Subscription, SPAPSClient as SweetPotatoSDK, type UsageBalance, type User, SPAPSClient as default };

package/dist/index.js

@@ -0,0 +1,191 @@
+"use strict";
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SPAPS: () => SPAPSClient,
+  SPAPSClient: () => SPAPSClient,
+  SweetPotatoSDK: () => SPAPSClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios = __toESM(require("axios"));
+var SPAPSClient = class {
+  client;
+  apiKey;
+  accessToken;
+  refreshToken;
+  _isLocalMode = false;
+  constructor(config = {}) {
+    const apiUrl = config.apiUrl || process.env.SPAPS_API_URL || process.env.NEXT_PUBLIC_SPAPS_API_URL;
+    if (!apiUrl || apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) {
+      this._isLocalMode = true;
+      this.client = import_axios.default.create({
+        baseURL: apiUrl || "http://localhost:3300",
+        timeout: config.timeout || 1e4,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } else {
+      if (!config.apiKey && !process.env.SPAPS_API_KEY) {
+        console.warn("\u26A0\uFE0F SPAPS: No API key provided. Some features may not work.");
+      }
+      this.apiKey = config.apiKey || process.env.SPAPS_API_KEY;
+      this.client = import_axios.default.create({
+        baseURL: apiUrl,
+        timeout: config.timeout || 1e4,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey && { "X-API-Key": this.apiKey }
+        }
+      });
+    }
+    this.client.interceptors.request.use((config2) => {
+      if (this.accessToken && !config2.headers.Authorization) {
+        config2.headers.Authorization = `Bearer ${this.accessToken}`;
+      }
+      return config2;
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response?.status === 401 && this.refreshToken) {
+          try {
+            const { data } = await this.refresh(this.refreshToken);
+            this.accessToken = data.access_token;
+            this.refreshToken = data.refresh_token;
+            if (error.config) {
+              error.config.headers.Authorization = `Bearer ${this.accessToken}`;
+              return this.client.request(error.config);
+            }
+          } catch (refreshError) {
+            this.accessToken = void 0;
+            this.refreshToken = void 0;
+          }
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+  // Authentication Methods
+  async login(email, password) {
+    const response = await this.client.post("/api/auth/login", {
+      email,
+      password
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async register(email, password) {
+    const response = await this.client.post("/api/auth/register", {
+      email,
+      password
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async walletSignIn(walletAddress, signature, message, chainType = "solana") {
+    const response = await this.client.post("/api/auth/wallet-sign-in", {
+      wallet_address: walletAddress,
+      signature,
+      message,
+      chain_type: chainType
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async refresh(refreshToken) {
+    const response = await this.client.post("/api/auth/refresh", {
+      refresh_token: refreshToken || this.refreshToken
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async logout() {
+    await this.client.post("/api/auth/logout");
+    this.accessToken = void 0;
+    this.refreshToken = void 0;
+  }
+  async getUser() {
+    return this.client.get("/api/auth/user");
+  }
+  // Stripe Methods
+  async createCheckoutSession(priceId, successUrl, cancelUrl) {
+    return this.client.post("/api/stripe/create-checkout-session", {
+      price_id: priceId,
+      success_url: successUrl,
+      cancel_url: cancelUrl
+    });
+  }
+  async getSubscription() {
+    return this.client.get("/api/stripe/subscription");
+  }
+  async cancelSubscription() {
+    await this.client.delete("/api/stripe/subscription");
+  }
+  // Usage Methods
+  async getUsageBalance() {
+    return this.client.get("/api/usage/balance");
+  }
+  async recordUsage(feature, amount) {
+    await this.client.post("/api/usage/record", {
+      feature,
+      amount
+    });
+  }
+  // Utility Methods
+  isAuthenticated() {
+    return !!this.accessToken;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  isLocalMode() {
+    return this._isLocalMode;
+  }
+  async health() {
+    return this.client.get("/health");
+  }
+};
+var index_default = SPAPSClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SPAPS,
+  SPAPSClient,
+  SweetPotatoSDK
+});

package/dist/index.mjs

@@ -0,0 +1,154 @@
+// src/index.ts
+import axios from "axios";
+var SPAPSClient = class {
+  client;
+  apiKey;
+  accessToken;
+  refreshToken;
+  _isLocalMode = false;
+  constructor(config = {}) {
+    const apiUrl = config.apiUrl || process.env.SPAPS_API_URL || process.env.NEXT_PUBLIC_SPAPS_API_URL;
+    if (!apiUrl || apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) {
+      this._isLocalMode = true;
+      this.client = axios.create({
+        baseURL: apiUrl || "http://localhost:3300",
+        timeout: config.timeout || 1e4,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } else {
+      if (!config.apiKey && !process.env.SPAPS_API_KEY) {
+        console.warn("\u26A0\uFE0F SPAPS: No API key provided. Some features may not work.");
+      }
+      this.apiKey = config.apiKey || process.env.SPAPS_API_KEY;
+      this.client = axios.create({
+        baseURL: apiUrl,
+        timeout: config.timeout || 1e4,
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey && { "X-API-Key": this.apiKey }
+        }
+      });
+    }
+    this.client.interceptors.request.use((config2) => {
+      if (this.accessToken && !config2.headers.Authorization) {
+        config2.headers.Authorization = `Bearer ${this.accessToken}`;
+      }
+      return config2;
+    });
+    this.client.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response?.status === 401 && this.refreshToken) {
+          try {
+            const { data } = await this.refresh(this.refreshToken);
+            this.accessToken = data.access_token;
+            this.refreshToken = data.refresh_token;
+            if (error.config) {
+              error.config.headers.Authorization = `Bearer ${this.accessToken}`;
+              return this.client.request(error.config);
+            }
+          } catch (refreshError) {
+            this.accessToken = void 0;
+            this.refreshToken = void 0;
+          }
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+  // Authentication Methods
+  async login(email, password) {
+    const response = await this.client.post("/api/auth/login", {
+      email,
+      password
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async register(email, password) {
+    const response = await this.client.post("/api/auth/register", {
+      email,
+      password
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async walletSignIn(walletAddress, signature, message, chainType = "solana") {
+    const response = await this.client.post("/api/auth/wallet-sign-in", {
+      wallet_address: walletAddress,
+      signature,
+      message,
+      chain_type: chainType
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async refresh(refreshToken) {
+    const response = await this.client.post("/api/auth/refresh", {
+      refresh_token: refreshToken || this.refreshToken
+    });
+    this.accessToken = response.data.access_token;
+    this.refreshToken = response.data.refresh_token;
+    return response;
+  }
+  async logout() {
+    await this.client.post("/api/auth/logout");
+    this.accessToken = void 0;
+    this.refreshToken = void 0;
+  }
+  async getUser() {
+    return this.client.get("/api/auth/user");
+  }
+  // Stripe Methods
+  async createCheckoutSession(priceId, successUrl, cancelUrl) {
+    return this.client.post("/api/stripe/create-checkout-session", {
+      price_id: priceId,
+      success_url: successUrl,
+      cancel_url: cancelUrl
+    });
+  }
+  async getSubscription() {
+    return this.client.get("/api/stripe/subscription");
+  }
+  async cancelSubscription() {
+    await this.client.delete("/api/stripe/subscription");
+  }
+  // Usage Methods
+  async getUsageBalance() {
+    return this.client.get("/api/usage/balance");
+  }
+  async recordUsage(feature, amount) {
+    await this.client.post("/api/usage/record", {
+      feature,
+      amount
+    });
+  }
+  // Utility Methods
+  isAuthenticated() {
+    return !!this.accessToken;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  isLocalMode() {
+    return this._isLocalMode;
+  }
+  async health() {
+    return this.client.get("/health");
+  }
+};
+var index_default = SPAPSClient;
+export {
+  SPAPSClient as SPAPS,
+  SPAPSClient,
+  SPAPSClient as SweetPotatoSDK,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "spaps-sdk",
+  "version": "0.1.0",
+  "description": "Sweet Potato Authentication & Payment Service SDK - Zero-config client for SPAPS",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "echo \"No tests yet\"",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "authentication",
+    "payments",
+    "stripe",
+    "spaps",
+    "sdk",
+    "client",
+    "sweet-potato",
+    "wallet-auth"
+  ],
+  "author": "buildooor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/sweet-potato"
+  },
+  "homepage": "https://sweetpotato.dev",
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.2"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.5.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}