spaps 0.3.10 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spaps",
-  "version": "0.3.10",
+  "version": "0.4.0",
   "description": "Sweet Potato Authentication & Payment Service CLI - Zero-config local development and project scaffolding",
   "main": "bin/spaps.js",
   "bin": {

package/src/local-server.js

@@ -523,6 +523,331 @@ class LocalServer {
       }
     });
 
+    // Enhanced Stripe Product Management - Full CRUD
+    
+    // GET /api/stripe/products - List all products with filtering
+    this.app.get('/api/stripe/products', async (req, res) => {
+      try {
+        if (USE_REAL_STRIPE) {
+          const { active, category, limit = '100' } = req.query;
+          
+          const products = await stripe.products.list({
+            active: active === 'true' ? true : active === 'false' ? false : undefined,
+            limit: parseInt(limit),
+            expand: ['data.default_price']
+          });
+
+          // Filter out non-SPAPS managed products if needed
+          let filteredProducts = products.data;
+          if (category === 'spaps') {
+            filteredProducts = products.data.filter(p => 
+              p.metadata && p.metadata.spaps_managed === 'true'
+            );
+          }
+
+          res.json({
+            success: true,
+            data: {
+              products: filteredProducts.map(product => ({
+                id: product.id,
+                name: product.name,
+                description: product.description,
+                images: product.images,
+                active: product.active,
+                metadata: product.metadata,
+                default_price: product.default_price ? {
+                  id: product.default_price.id,
+                  unit_amount: product.default_price.unit_amount,
+                  currency: product.default_price.currency,
+                  recurring: product.default_price.recurring
+                } : null,
+                created: product.created,
+                updated: product.updated
+              })),
+              has_more: products.has_more,
+              total_count: filteredProducts.length
+            }
+          });
+        } else {
+          // Mock response
+          const localProducts = this.adminManager.listProducts();
+          res.json({
+            success: true,
+            data: {
+              products: localProducts,
+              has_more: false,
+              total_count: localProducts.length
+            }
+          });
+        }
+      } catch (error) {
+        console.error('List products error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'LIST_PRODUCTS_ERROR',
+            message: error.message || 'Failed to list products'
+          }
+        });
+      }
+    });
+
+    // POST /api/stripe/products - Create new product
+    this.app.post('/api/stripe/products', async (req, res) => {
+      try {
+        const { name, description, images, metadata = {}, active = true } = req.body;
+
+        if (!name) {
+          return res.status(400).json({
+            success: false,
+            error: { message: 'Product name is required' }
+          });
+        }
+
+        if (USE_REAL_STRIPE) {
+          // Create product in Stripe
+          const stripeProduct = await stripe.products.create({
+            name,
+            description,
+            images,
+            active,
+            metadata: {
+              ...metadata,
+              spaps_managed: 'true',
+              created_by: 'spaps_cli'
+            }
+          });
+
+          res.json({
+            success: true,
+            data: {
+              product: {
+                id: stripeProduct.id,
+                name: stripeProduct.name,
+                description: stripeProduct.description,
+                images: stripeProduct.images,
+                active: stripeProduct.active,
+                metadata: stripeProduct.metadata,
+                created: stripeProduct.created
+              }
+            }
+          });
+        } else {
+          // Create locally
+          const product = this.adminManager.createProduct({
+            name,
+            description,
+            price: 0, // Will need to set price separately
+            currency: 'usd'
+          });
+
+          res.json({
+            success: true,
+            data: { product }
+          });
+        }
+      } catch (error) {
+        console.error('Create product error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'CREATE_PRODUCT_ERROR',
+            message: error.message || 'Failed to create product'
+          }
+        });
+      }
+    });
+
+    // PUT /api/stripe/products/:productId - Update product
+    this.app.put('/api/stripe/products/:productId', async (req, res) => {
+      try {
+        const { productId } = req.params;
+        const { name, description, images, metadata, active } = req.body;
+
+        if (USE_REAL_STRIPE) {
+          // Update in Stripe
+          const updateData = {};
+          if (name !== undefined) updateData.name = name;
+          if (description !== undefined) updateData.description = description;
+          if (images !== undefined) updateData.images = images;
+          if (metadata !== undefined) updateData.metadata = metadata;
+          if (active !== undefined) updateData.active = active;
+
+          const stripeProduct = await stripe.products.update(productId, updateData);
+
+          res.json({
+            success: true,
+            data: {
+              product: {
+                id: stripeProduct.id,
+                name: stripeProduct.name,
+                description: stripeProduct.description,
+                images: stripeProduct.images,
+                active: stripeProduct.active,
+                metadata: stripeProduct.metadata,
+                updated: stripeProduct.updated
+              }
+            }
+          });
+        } else {
+          // Update locally
+          const product = this.adminManager.updateProduct(productId, {
+            name,
+            description,
+            active
+          });
+
+          res.json({
+            success: true,
+            data: { product }
+          });
+        }
+      } catch (error) {
+        console.error('Update product error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'UPDATE_PRODUCT_ERROR',
+            message: error.message || 'Failed to update product'
+          }
+        });
+      }
+    });
+
+    // DELETE /api/stripe/products/:productId - Archive product
+    this.app.delete('/api/stripe/products/:productId', async (req, res) => {
+      try {
+        const { productId } = req.params;
+
+        if (USE_REAL_STRIPE) {
+          // Archive in Stripe (can't truly delete)
+          const stripeProduct = await stripe.products.update(productId, {
+            active: false
+          });
+
+          res.json({
+            success: true,
+            message: 'Product archived successfully',
+            data: {
+              product: {
+                id: stripeProduct.id,
+                active: stripeProduct.active,
+                updated: stripeProduct.updated
+              }
+            }
+          });
+        } else {
+          // Soft delete locally
+          const result = this.adminManager.deleteProduct(productId);
+
+          res.json({
+            success: true,
+            message: 'Product deleted successfully',
+            data: result
+          });
+        }
+      } catch (error) {
+        console.error('Delete product error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'DELETE_PRODUCT_ERROR',
+            message: error.message || 'Failed to delete product'
+          }
+        });
+      }
+    });
+
+    // POST /api/stripe/prices - Create price for product
+    this.app.post('/api/stripe/prices', async (req, res) => {
+      try {
+        const { 
+          product_id, 
+          unit_amount, 
+          currency = 'usd', 
+          recurring = null,
+          nickname,
+          metadata = {},
+          active = true 
+        } = req.body;
+
+        if (!product_id || !unit_amount) {
+          return res.status(400).json({
+            success: false,
+            error: { message: 'Product ID and unit amount are required' }
+          });
+        }
+
+        if (USE_REAL_STRIPE) {
+          // Create price in Stripe
+          const priceData = {
+            product: product_id,
+            unit_amount: parseInt(unit_amount),
+            currency,
+            metadata: {
+              ...metadata,
+              spaps_managed: 'true'
+            }
+          };
+
+          if (recurring) {
+            priceData.recurring = {
+              interval: recurring.interval || 'month',
+              interval_count: recurring.interval_count || 1
+            };
+          }
+
+          if (nickname) priceData.nickname = nickname;
+
+          const stripePrice = await stripe.prices.create(priceData);
+
+          res.json({
+            success: true,
+            data: {
+              price: {
+                id: stripePrice.id,
+                product: stripePrice.product,
+                unit_amount: stripePrice.unit_amount,
+                currency: stripePrice.currency,
+                type: stripePrice.type,
+                recurring: stripePrice.recurring,
+                nickname: stripePrice.nickname,
+                active: stripePrice.active,
+                created: stripePrice.created
+              }
+            }
+          });
+        } else {
+          // Mock price creation
+          res.json({
+            success: true,
+            data: {
+              price: {
+                id: `price_local_${Date.now()}`,
+                product: product_id,
+                unit_amount,
+                currency,
+                type: recurring ? 'recurring' : 'one_time',
+                recurring,
+                nickname,
+                active,
+                created: Math.floor(Date.now() / 1000)
+              }
+            }
+          });
+        }
+      } catch (error) {
+        console.error('Create price error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'CREATE_PRICE_ERROR',
+            message: error.message || 'Failed to create price'
+          }
+        });
+      }
+    });
+
     // Mock usage endpoints
     this.app.get('/api/usage/balance', (req, res) => {
       res.json({