spaps 0.4.3 → 0.5.1

package/src/docs-system.js

@@ -16,21 +16,21 @@ ${chalk.green('Installation:')}
   yarn add spaps-sdk
 
 ${chalk.green('Basic Usage:')}
-  ${chalk.gray('// ES6 Import')}
-  import { SPAPSClient } from 'spaps-sdk'
+  ${chalk.gray('// ES Module')}
+  import { SweetPotatoSDK } from 'spaps-sdk'
   
   ${chalk.gray('// CommonJS')}
-  const { SPAPSClient } = require('spaps-sdk')
+  const { SweetPotatoSDK } = require('spaps-sdk')
   
   ${chalk.gray('// Create client (auto-detects local mode)')}
-  const spaps = new SPAPSClient()
-  
-  ${chalk.gray('// With custom config')}
-  const spaps = new SPAPSClient({
-    apiUrl: 'http://localhost:3300',
-    apiKey: 'your-api-key',  ${chalk.gray('// Not needed for localhost')}
-    timeout: 10000
+  const sdk = new SweetPotatoSDK({
+    apiUrl: process.env.SPAPS_API_URL || 'http://localhost:3300',
+    apiKey: process.env.SPAPS_API_KEY,  ${chalk.gray('// Not required in local mode')}
   })
+  
+  ${chalk.gray('// Sign in with email/password (local mode accepts any credentials)')}
+  const auth = await sdk.auth.signInWithPassword({ email: 'user@example.com', password: 'password' })
+  console.log('User:', auth.user)
 `
   },
 
@@ -39,48 +39,30 @@ ${chalk.green('Basic Usage:')}
     content: `
 ${chalk.green('Email/Password Authentication:')}
   ${chalk.gray('// Register new user')}
-  const { data } = await spaps.register(email, password)
-  console.log('User:', data.user)
-  console.log('Token:', data.access_token)
+  const registered = await sdk.auth.register({ email, password })
+  console.log('User:', registered.user)
+  console.log('Token:', registered.access_token)
   
   ${chalk.gray('// Login existing user')}
-  const { data } = await spaps.login(email, password)
+  const auth = await sdk.auth.signInWithPassword({ email, password })
   
   ${chalk.gray('// Check authentication status')}
-  if (spaps.isAuthenticated()) {
-    const user = await spaps.getUser()
-    console.log('Current user:', user.data)
+  if (sdk.auth.isAuthenticated()) {
+    const user = await sdk.auth.getCurrentUser()
+    console.log('Current user:', user)
   }
   
   ${chalk.gray('// Logout')}
-  await spaps.logout()
+  await sdk.auth.logout()
 
 ${chalk.green('Wallet Authentication:')}
-  ${chalk.gray('// Solana wallet')}
-  await spaps.walletSignIn(
-    walletAddress,
-    signature,
-    message,
-    'solana'
-  )
-  
-  ${chalk.gray('// Ethereum wallet')}
-  await spaps.walletSignIn(
-    walletAddress,
-    signature,
-    message,
-    'ethereum'
-  )
+  ${chalk.gray('// One-call helper: authenticateWallet')}
+  const resp = await sdk.auth.authenticateWallet(walletAddress, signMessage, 'ethereum')
+  console.log('User:', resp.user)
 
 ${chalk.green('Token Management:')}
-  ${chalk.gray('// Get current token')}
-  const token = spaps.getAccessToken()
-  
-  ${chalk.gray('// Set token manually')}
-  spaps.setAccessToken(token)
-  
-  ${chalk.gray('// Refresh token')}
-  await spaps.refresh()
+  ${chalk.gray('// Access token is managed internally; you can also set it manually')}
+  sdk.setAccessToken('jwt-token')
 `
   },
 
@@ -89,33 +71,25 @@ ${chalk.green('Token Management:')}
     content: `
 ${chalk.green('Stripe Checkout:')}
   ${chalk.gray('// Create checkout session')}
-  const session = await spaps.createCheckoutSession(
-    'price_123abc',           ${chalk.gray('// Stripe price ID')}
-    'http://localhost:3000/success',  ${chalk.gray('// Success URL')}
-    'http://localhost:3000/cancel'    ${chalk.gray('// Cancel URL (optional)')}
-  )
+  const session = await sdk.payments.createCheckoutSession({
+    price_id: 'price_123abc',
+    success_url: 'http://localhost:3000/success',
+    cancel_url: 'http://localhost:3000/cancel'
+  })
   
   ${chalk.gray('// Redirect to Stripe')}
-  window.location.href = session.data.url
+  window.location.href = session.url
 
 ${chalk.green('Subscription Management:')}
   ${chalk.gray('// Get current subscription')}
-  const subscription = await spaps.getSubscription()
-  console.log('Status:', subscription.data.status)
-  console.log('Plan:', subscription.data.plan)
-  console.log('Renews:', subscription.data.current_period_end)
+  // Example subscription helpers would go here if enabled
   
   ${chalk.gray('// Cancel subscription')}
   await spaps.cancelSubscription()
 
 ${chalk.green('Usage Tracking:')}
   ${chalk.gray('// Check balance')}
-  const balance = await spaps.getUsageBalance()
-  console.log('Credits:', balance.data.balance)
-  
-  ${chalk.gray('// Record usage')}
-  await spaps.recordUsage('api-call', 1)
-  await spaps.recordUsage('image-generation', 10)
+  // Usage APIs depend on your server config
 `
   },
 
@@ -132,18 +106,9 @@ ${chalk.green('Environment Variables:')}
   NEXT_PUBLIC_SPAPS_API_KEY=spaps_live_abc123...
 
 ${chalk.green('Configuration Options:')}
-  const spaps = new SPAPSClient({
-    ${chalk.gray('// API endpoint (auto-detected from env)')}
-    apiUrl: 'http://localhost:3300',
-    
-    ${chalk.gray('// API key (not needed for localhost)')}
-    apiKey: 'spaps_live_abc123...',
-    
-    ${chalk.gray('// Request timeout in milliseconds')}
-    timeout: 10000,
-    
-    ${chalk.gray('// Auto-detect local mode (default: true)')}
-    autoDetect: true
+  const sdk = new SweetPotatoSDK({
+    apiUrl: process.env.SPAPS_API_URL || 'http://localhost:3300',
+    apiKey: process.env.SPAPS_API_KEY, ${chalk.gray('// Omit in local dev')}
   })
 
 ${chalk.green('Local Mode Detection:')}
@@ -153,7 +118,7 @@ ${chalk.green('Local Mode Detection:')}
   - No API URL is provided
   
   ${chalk.gray('// Check if in local mode')}
-  if (spaps.isLocalMode()) {
+  if (sdk.isLocalMode) {
     console.log('Running in local mode - no API key needed!')
   }
 `
@@ -165,14 +130,14 @@ ${chalk.green('Local Mode Detection:')}
 ${chalk.green('React Context Setup:')}
   ${chalk.gray('// contexts/SpapsContext.tsx')}
   import { createContext, useContext } from 'react'
-  import { SPAPSClient } from 'spaps-sdk'
+  import { SweetPotatoSDK } from 'spaps-sdk'
   
-  const spaps = new SPAPSClient()
-  const SpapsContext = createContext(spaps)
+  const sdk = new SweetPotatoSDK({ apiUrl: process.env.NEXT_PUBLIC_SPAPS_API_URL || 'http://localhost:3300' })
+  const SpapsContext = createContext(sdk)
   
   export function SpapsProvider({ children }) {
     return (
-      <SpapsContext.Provider value={spaps}>
+      <SpapsContext.Provider value={sdk}>
         {children}
       </SpapsContext.Provider>
     )
@@ -273,26 +238,23 @@ ${chalk.green('Server Actions:')}
   ${chalk.gray('// app/actions/auth.ts')}
   'use server'
   
-  import { SPAPSClient } from 'spaps-sdk'
+  import { SweetPotatoSDK } from 'spaps-sdk'
   import { cookies } from 'next/headers'
   
-  const spaps = new SPAPSClient({
-    apiUrl: process.env.SPAPS_API_URL,
-    apiKey: process.env.SPAPS_API_KEY
-  })
+  const sdk = new SweetPotatoSDK({ apiUrl: process.env.SPAPS_API_URL, apiKey: process.env.SPAPS_API_KEY })
   
   export async function loginAction(email: string, password: string) {
-    const { data } = await spaps.login(email, password)
+    const auth = await sdk.auth.signInWithPassword({ email, password })
     
     // Store token in cookie
-    cookies().set('spaps_token', data.access_token, {
+    cookies().set('spaps_token', auth.access_token, {
       httpOnly: true,
       secure: process.env.NODE_ENV === 'production',
       sameSite: 'lax',
       maxAge: 60 * 60 * 24 * 7 // 1 week
     })
     
-    return { success: true, user: data.user }
+    return { success: true, user: auth.user }
   }
 
 ${chalk.green('Middleware Protection:')}
@@ -322,17 +284,14 @@ ${chalk.green('Middleware Protection:')}
 ${chalk.green('Express Middleware:')}
   ${chalk.gray('// server.js')}
   const express = require('express')
-  const { SPAPSClient } = require('spaps-sdk')
+  const { SweetPotatoSDK } = require('spaps-sdk')
   
   const app = express()
-  const spaps = new SPAPSClient({
-    apiUrl: process.env.SPAPS_API_URL,
-    apiKey: process.env.SPAPS_API_KEY
-  })
+  const sdk = new SweetPotatoSDK({ apiUrl: process.env.SPAPS_API_URL, apiKey: process.env.SPAPS_API_KEY })
   
   ${chalk.gray('// Add SPAPS to request')}
   app.use((req, res, next) => {
-    req.spaps = spaps
+    req.spaps = sdk
     next()
   })
   
@@ -346,8 +305,8 @@ ${chalk.green('Express Middleware:')}
     
     try {
       req.spaps.setAccessToken(token)
-      const { data } = await req.spaps.getUser()
-      req.user = data
+      const user = await req.spaps.auth.getCurrentUser()
+      req.user = user
       next()
     } catch (error) {
       res.status(401).json({ error: 'Invalid token' })
@@ -360,8 +319,8 @@ ${chalk.green('Route Examples:')}
     const { email, password } = req.body
     
     try {
-      const { data } = await req.spaps.login(email, password)
-      res.json(data)
+      const auth = await req.spaps.auth.signInWithPassword({ email, password })
+      res.json(auth)
     } catch (error) {
       res.status(401).json({ error: 'Invalid credentials' })
     }
@@ -567,17 +526,17 @@ ${chalk.green('E2E Testing with Cypress:')}
 ${chalk.green('Mocking for Tests:')}
   ${chalk.gray('// Mock SPAPS client')}
   jest.mock('spaps-sdk', () => ({
-    SPAPSClient: jest.fn().mockImplementation(() => ({
-      login: jest.fn().mockResolvedValue({
-        data: {
+    SweetPotatoSDK: jest.fn().mockImplementation(() => ({
+      auth: {
+        signInWithPassword: jest.fn().mockResolvedValue({
           user: { id: '123', email: 'test@example.com' },
-          access_token: 'mock-token'
-        }
-      }),
-      isAuthenticated: jest.fn().mockReturnValue(true),
-      getUser: jest.fn().mockResolvedValue({
-        data: { id: '123', email: 'test@example.com' }
-      })
+          access_token: 'mock-token',
+          refresh_token: 'mock-refresh'
+        }),
+        isAuthenticated: jest.fn().mockReturnValue(true),
+        getCurrentUser: jest.fn().mockResolvedValue({ id: '123', email: 'test@example.com' })
+      },
+      setAccessToken: jest.fn()
     }))
   }))
 `
@@ -587,39 +546,29 @@ ${chalk.green('Mocking for Tests:')}
     title: 'API Reference',
     content: `
 ${chalk.green('Authentication Methods:')}
-  login(email: string, password: string): Promise<{data: AuthResponse}>
-  register(email: string, password: string): Promise<{data: AuthResponse}>
-  walletSignIn(address: string, signature: string, message: string, chain: string): Promise<{data: AuthResponse}>
-  refresh(refreshToken?: string): Promise<{data: AuthResponse}>
-  logout(): Promise<void>
-  getUser(): Promise<{data: User}>
+  sdk.auth.signInWithPassword({ email, password }): Promise<AuthResponse>
+  sdk.auth.register({ email, password, username? }): Promise<AuthResponse>
+  sdk.auth.authenticateWallet(address, signFn, chain?): Promise<AuthResponse>
+  sdk.auth.refreshToken(refreshToken): Promise<AuthResponse>
+  sdk.auth.logout(): Promise<void>
+  sdk.auth.getCurrentUser(): Promise<User>
 
 ${chalk.green('Payment Methods:')}
-  createCheckoutSession(priceId: string, successUrl: string, cancelUrl?: string): Promise<{data: CheckoutSession}>
-  getSubscription(): Promise<{data: Subscription}>
-  cancelSubscription(): Promise<void>
+  sdk.payments.createCheckoutSession({ price_id, success_url, cancel_url }): Promise<CheckoutSession>
+  sdk.payments.getCheckoutSession(id): Promise<CheckoutSession>
+  sdk.payments.listProducts({ category?, active?, limit? }): Promise<ProductsListResponse>
 
 ${chalk.green('Usage Methods:')}
-  getUsageBalance(): Promise<{data: UsageBalance}>
-  recordUsage(feature: string, amount: number): Promise<void>
+  See server docs if enabled
 
 ${chalk.green('Utility Methods:')}
-  isAuthenticated(): boolean
-  getAccessToken(): string | undefined
-  setAccessToken(token: string): void
-  isLocalMode(): boolean
-  health(): Promise<{data: any}>
-
-${chalk.green('Properties:')}
-  client: AxiosInstance  ${chalk.gray('// Direct access to Axios client')}
+  sdk.setAccessToken(token: string): void
+  sdk.clearAccessToken(): void
 
 ${chalk.green('Response Types:')}
-  ${chalk.gray('// All methods return data wrapped in { data: T }')}
-  ${chalk.gray('// This matches Axios response structure')}
-  ${chalk.gray('// Example:')}
-  const response = await spaps.login(email, password)
-  // response.data contains AuthResponse
-  // response.status, response.headers also available
+  ${chalk.gray('// Methods generally return typed objects directly')}
+  const auth = await sdk.auth.signInWithPassword({ email, password })
+  console.log(auth.access_token)
 `
   }
 };
@@ -636,7 +585,7 @@ ${chalk.green('Authentication Endpoints:')}
   GET    /api/auth/user             ${chalk.gray('Get current user')}
 
 ${chalk.green('Stripe Endpoints:')}
-  POST   /api/stripe/create-checkout-session  ${chalk.gray('Create Stripe checkout')}
+  POST   /api/stripe/checkout-sessions       ${chalk.gray('Create Stripe checkout')}
   GET    /api/stripe/subscription             ${chalk.gray('Get subscription status')}
   DELETE /api/stripe/subscription             ${chalk.gray('Cancel subscription')}
   POST   /api/stripe/webhook                  ${chalk.gray('Stripe webhook handler')}
@@ -803,4 +752,4 @@ module.exports = {
   searchDocs,
   SDK_DOCS,
   API_ENDPOINTS
-};
+};

package/src/handlers.js

@@ -0,0 +1,155 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const { DEFAULT_PORT } = require('./config');
+const { handleError } = require('./error-handler');
+const { showInteractiveHelp, showQuickHelp } = require('./help-system');
+const { showInteractiveDocs, showQuickReference, searchDocs } = require('./docs-system');
+const { getQuickStartInstructions, getServerStatus, runQuickTest } = require('./ai-helper');
+
+function createHandlers(version, logo) {
+  return {
+    local: async ({ options }) => {
+      const isJson = options.json;
+      if (!isJson) console.log(logo);
+      try {
+        const LocalServer = require('./local-server.js');
+        const server = new LocalServer({ port: options.port, json: isJson });
+        if (isJson) {
+          await server.start();
+          console.log(JSON.stringify({
+            success: true,
+            command: 'local',
+            server: {
+              url: `http://localhost:${options.port}`,
+              docs: `http://localhost:${options.port}/docs`,
+              mode: 'local-development',
+              port: Number(options.port),
+              features: { autoAuth: true, corsEnabled: true, testUsers: ['user', 'admin', 'premium'], apiKeyRequired: false }
+            }
+          }));
+        } else {
+          await server.start();
+          if (options.open) {
+            const { exec } = require('child_process');
+            const url = `http://localhost:${options.port}/docs`;
+            const start = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+            exec(`${start} ${url}`);
+          }
+        }
+        process.on('SIGINT', () => {
+          if (!isJson) console.log(chalk.yellow('\n👋 Shutting down SPAPS local server...'));
+          process.exit(0);
+        });
+      } catch (error) {
+        handleError(error, { port: options.port, command: 'local' }, { json: isJson });
+      }
+    },
+    quickstart: async ({ options }) => {
+      const instructions = getQuickStartInstructions(options.port);
+      if (options.json) {
+        console.log(JSON.stringify(instructions, null, 2));
+      } else {
+        console.log(chalk.yellow('\n🍠 SPAPS Quick Start Instructions\n'));
+        console.log('1. Install SDK: npm install spaps-sdk');
+        console.log('2. Create test file with the code above');
+        console.log('3. Run: node test-spaps.js');
+        console.log('\nFor JSON output: npx spaps quickstart --json');
+      }
+    },
+    status: async ({ options }) => {
+      const status = await getServerStatus(options.port);
+      if (options.json) {
+        console.log(JSON.stringify(status));
+      } else {
+        if (!status.running) {
+          console.log(chalk.red('\n❌ SPAPS server is not running'));
+          console.log('Start it with:');
+          console.log(chalk.cyan(`  npx spaps local --port ${options.port}`));
+          console.log();
+        } else {
+          console.log(chalk.green('\n✅ SPAPS server is running!\n'));
+          console.log('  URL:', chalk.cyan(status.url));
+          console.log('  Docs:', chalk.cyan(status.docs));
+          console.log();
+        }
+      }
+    },
+    test: async ({ options }) => {
+      const result = await runQuickTest(options.port);
+      console.log(JSON.stringify(result, null, 2));
+    },
+    init: async ({ options }) => {
+      const isJson = options.json;
+      const envContent = `# SPAPS Local Development\nSPAPS_API_URL=http://localhost:${DEFAULT_PORT}\n# SPAPS_API_KEY=your-api-key-here\n`;
+      const result = { success: true, command: 'init', files_created: [], files_skipped: [], next_steps: ['npx spaps local', 'npm install @spaps/sdk', 'Start coding!'] };
+      if (!fs.existsSync('.env.local')) {
+        fs.writeFileSync('.env.local', envContent);
+        result.files_created.push('.env.local');
+        if (!isJson) console.log(chalk.green('✅ Created .env.local'));
+      } else {
+        result.files_skipped.push('.env.local');
+        result.message = '.env.local already exists';
+        if (!isJson) console.log(chalk.yellow('⚠️  .env.local already exists'));
+      }
+      if (isJson) {
+        console.log(JSON.stringify(result));
+      } else {
+        console.log();
+        console.log(chalk.green('✨ SPAPS initialized!'));
+        console.log();
+        console.log('Next steps:');
+        console.log(chalk.cyan('  1. Run: npx spaps local'));
+        console.log(chalk.cyan('  2. Install SDK: npm install @spaps/sdk'));
+        console.log(chalk.cyan('  3. Start coding!'));
+      }
+    },
+    create: () => {
+      console.log(chalk.yellow('🍠 SPAPS'));
+      console.log(chalk.yellow(`🚧 'spaps create' coming in v0.3.0!`));
+      console.log();
+      console.log('For now, check out our examples:');
+      console.log(chalk.cyan('  https://github.com/yourusername/sweet-potato/tree/main/examples'));
+    },
+    types: () => {
+      console.log(chalk.yellow('🍠 SPAPS'));
+      console.log(chalk.yellow(`🚧 'spaps types' coming in v0.4.0!`));
+    },
+    help: async ({ options }) => {
+      if (options.interactive) {
+        await showInteractiveHelp();
+      } else if (options.quick) {
+        showQuickHelp();
+      } else {
+        showQuickHelp();
+      }
+    },
+    docs: async ({ options }) => {
+      if (options.search) {
+        const results = searchDocs(options.search);
+        if (options.json) {
+          console.log(JSON.stringify({ results }, null, 2));
+        } else {
+          console.log(chalk.yellow(`\n🔍 Search results for "${options.search}":\n`));
+          if (results.length === 0) {
+            console.log(chalk.gray('  No results found'));
+          } else {
+            results.forEach((result, i) => {
+              console.log(chalk.green(`  ${i + 1}. ${result.title}`));
+              console.log(chalk.gray(`     ${result.preview}`));
+              console.log();
+            });
+          }
+          console.log(chalk.blue('  Run: npx spaps docs --interactive'));
+          console.log(chalk.blue('  to browse full documentation\n'));
+        }
+      } else if (options.interactive) {
+        await showInteractiveDocs();
+      } else {
+        showQuickReference();
+      }
+    }
+  };
+}
+
+module.exports = { createHandlers };
+

package/src/help-system.js

@@ -6,6 +6,8 @@
 const chalk = require('chalk');
 const prompts = require('prompts');
 
+const { DEFAULT_PORT } = require('./config');
+
 const HELP_TREE = {
   root: {
     question: 'What would you like to do?',
@@ -45,12 +47,12 @@ const HELP_TREE = {
         title: 'Quick start (default settings)',
         value: 'quick-start',
         command: 'npx spaps local',
-        description: 'Start on port 3300'
+        description: `Start on port ${DEFAULT_PORT}`
       },
       {
         title: 'Custom port',
         value: 'custom-port',
-        command: 'npx spaps local --port 3001',
+        command: `npx spaps local --port ${DEFAULT_PORT + 1}`,
         description: 'Choose your own port'
       },
       {
@@ -484,4 +486,4 @@ module.exports = {
   showInteractiveHelp,
   showQuickHelp,
   HELP_TREE
-};
+};

package/src/index.js

@@ -0,0 +1,42 @@
+/**
+ * SPAPS Package Main Export
+ * Provides middleware, utilities, and client functionality
+ */
+
+const adminMiddleware = require('./middleware/admin');
+
+// Export admin middleware and utilities
+module.exports = {
+  // Admin middleware functions
+  requireAdmin: adminMiddleware.requireAdmin,
+  requirePermission: adminMiddleware.requirePermission,
+  
+  // Permission checking utilities
+  isAdminAccount: adminMiddleware.isAdminAccount,
+  getUserRole: adminMiddleware.getUserRole,
+  hasPermission: adminMiddleware.hasPermission,
+  getRoleAwareErrorMessage: adminMiddleware.getRoleAwareErrorMessage,
+  
+  // Constants
+  DEFAULT_ADMIN_ACCOUNTS: adminMiddleware.DEFAULT_ADMIN_ACCOUNTS,
+  
+  // Factory function for custom admin configurations
+  createPermissionChecker: adminMiddleware.createPermissionChecker,
+  
+  // Express middleware aliases for convenience
+  admin: adminMiddleware.requireAdmin,
+  permission: adminMiddleware.requirePermission,
+  
+  // Version and metadata
+  version: require('../package.json').version,
+  name: 'spaps'
+};
+
+// Named exports for ES6 compatibility
+module.exports.requireAdmin = adminMiddleware.requireAdmin;
+module.exports.requirePermission = adminMiddleware.requirePermission;
+module.exports.isAdminAccount = adminMiddleware.isAdminAccount;
+module.exports.getUserRole = adminMiddleware.getUserRole;
+module.exports.hasPermission = adminMiddleware.hasPermission;
+module.exports.getRoleAwareErrorMessage = adminMiddleware.getRoleAwareErrorMessage;
+module.exports.createPermissionChecker = adminMiddleware.createPermissionChecker;