Merge branch 'master' of github.com:profullstack/generate-pdf-api

Author: ralyodio

.github/workflows/deploy.yml

@@ -88,10 +88,10 @@ jobs:
           # Explicitly copy the .env file to the remote server
           echo "Copying .env file to remote server..."
           scp -P 2048 .env [email protected]:$DEPLOY_REMOTE_DIR/.env
-          
+
           # Run deploy script with migrations
           ./bin/deploy-with-migrations.sh
-
+                    
           # Create a timestamp file to verify deployment
           echo "Creating timestamp file to verify deployment..."
           TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")

README.md

@@ -401,5 +401,3 @@ node scripts/test-pdf-generation.js
 ```
 
 This script will generate a test PDF and output the detected Chrome path.
-
-test2

TODO.md

@@ -316,4 +316,6 @@ This document outlines planned features and enhancements to provide additional v
   - [ ] Data export and import
   - [ ] Data audit logging
   - [ ] Data access monitoring
-  
+  
+
+  test\

bin/apply-migration.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+// Apply migration to add subscription fields to users table
+import 'dotenv/config';
+import { createClient } from '@supabase/supabase-js';
+
+// Access environment variables
+const supabaseUrl = process.env.SUPABASE_URL;
+const supabaseServiceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+if (!supabaseUrl || !supabaseServiceRoleKey) {
+  console.error('Missing Supabase credentials');
+  process.exit(1);
+}
+
+// Create Supabase client with service role key for admin privileges
+const supabase = createClient(supabaseUrl, supabaseServiceRoleKey, {
+  auth: {
+    autoRefreshToken: false,
+    persistSession: false
+  }
+});
+
+async function applyMigration() {
+  console.log('Applying migration: Adding subscription fields to users table...');
+  
+  try {
+    // Execute raw SQL to add the new columns
+    const { data, error } = await supabase.rpc('exec_sql', {
+      query: `
+        ALTER TABLE public.users
+          ADD COLUMN IF NOT EXISTS subscription_id UUID,
+          ADD COLUMN IF NOT EXISTS subscription_status TEXT,
+          ADD COLUMN IF NOT EXISTS subscription_plan TEXT;
+      `
+    });
+    
+    if (error) {
+      throw error;
+    }
+    
+    console.log('✅ Migration applied successfully!');
+    console.log('Added columns: subscription_id, subscription_status, subscription_plan');
+    
+    // Run the link subscription script again
+    console.log('\nNow run the link-subscription.js script to link the subscription to the user profile:');
+    console.log('node bin/link-subscription.js --email [email protected]');
+    
+  } catch (error) {
+    console.error('❌ Error applying migration:', error.message);
+    console.log('\nAlternative approach:');
+    console.log('1. Log into the Supabase dashboard');
+    console.log('2. Go to the SQL Editor');
+    console.log('3. Run the following SQL:');
+    console.log(`
+      ALTER TABLE public.users
+        ADD COLUMN IF NOT EXISTS subscription_id UUID,
+        ADD COLUMN IF NOT EXISTS subscription_status TEXT,
+        ADD COLUMN IF NOT EXISTS subscription_plan TEXT;
+    `);
+  }
+}
+
+applyMigration();

bin/create-test-payment.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * Script to create test subscriptions directly
+ * 
+ * Example:
+ * node bin/create-test-payment.js --email [email protected]
+ */
+
+import { supabase } from '../src/utils/supabase.js';
+import crypto from 'crypto';
+
+console.log('Supabase configuration:');
+console.log('SUPABASE_URL:', process.env.SUPABASE_URL);
+console.log('SUPABASE_KEY exists:', !!process.env.SUPABASE_KEY);
+console.log('SUPABASE_KEY from process.env:', !!process.env.SUPABASE_KEY);
+console.log('SUPABASE_SERVICE_ROLE_KEY from process.env:', !!process.env.SUPABASE_SERVICE_ROLE_KEY);
+if (process.env.SUPABASE_KEY) {
+  console.log('SUPABASE_KEY length:', process.env.SUPABASE_KEY.length);
+  console.log('Using service role key:', process.env.SUPABASE_KEY === process.env.SUPABASE_SERVICE_ROLE_KEY);
+}
+console.log('NODE_ENV:', process.env.NODE_ENV);
+console.log('All environment variables:');
+Object.keys(process.env).forEach(key => {
+  const value = key.includes('KEY') || key.includes('SECRET') || key.includes('PASSWORD') 
+    ? '[REDACTED]' 
+    : process.env[key];
+  console.log(`${key}: ${value}`);
+});
+
+console.log('Creating Supabase client...');
+try {
+  if (supabase) {
+    console.log('Supabase client created successfully' + 
+      (process.env.SUPABASE_KEY === process.env.SUPABASE_SERVICE_ROLE_KEY ? ' with service role key' : ''));
+  }
+} catch (e) {
+  console.error('Error creating Supabase client:', e);
+  process.exit(1);
+}
+
+// Simple argument parsing
+function parseCommandLineArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    email: null,
+    plan: 'monthly',
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } 
+    else if (arg.startsWith('--email=')) {
+      options.email = arg.split('=')[1];
+    }
+    else if (arg === '--email' || arg === '-e') {
+      options.email = args[++i];
+    }
+    else if (arg.startsWith('--plan=')) {
+      options.plan = arg.split('=')[1];
+    }
+    else if (arg === '--plan' || arg === '-p') {
+      options.plan = args[++i];
+    }
+  }
+  
+  return options;
+}
+
+// Parse command line arguments
+const { email, plan, help } = parseCommandLineArgs();
+
+// Show help if requested or no email provided
+if (help || !email) {
+  console.log(`
+  Create Test Subscription
+  =======================
+  This script creates an active subscription for testing purposes,
+  bypassing the actual payment process.
+
+  Usage:
+    node bin/create-test-payment.js --email <email> [--plan <plan_type>]
+
+  Options:
+    --email, -e      User's email address (required)
+    --plan, -p       Subscription plan: 'monthly' or 'yearly' (default: monthly)
+    --help, -h       Show this help message
+
+  Examples:
+    node bin/create-test-payment.js --email [email protected]
+    node bin/create-test-payment.js --email [email protected] --plan yearly
+  `);
+  process.exit(0);
+}
+
+// Validate inputs
+if (!['monthly', 'yearly'].includes(plan)) {
+  console.error(`Error: Invalid plan '${plan}'. Must be 'monthly' or 'yearly'.`);
+  process.exit(1);
+}
+
+async function activateSubscription() {
+  try {
+    console.log(`Creating active subscription for ${email} with ${plan} plan...`);
+    
+    // Calculate expiration date
+    const now = new Date();
+    const expirationDate = new Date(now);
+    if (plan === 'yearly') {
+      expirationDate.setFullYear(expirationDate.getFullYear() + 1);
+    } else {
+      expirationDate.setMonth(expirationDate.getMonth() + 1);
+    }
+    
+    // Check if user exists
+    const { data: userData, error: userError } = await supabase
+      .from('users')
+      .select('id')
+      .eq('email', email)
+      .maybeSingle();
+      
+    if (userError) {
+      console.error('Error checking for user:', userError.message);
+      process.exit(1);
+    }
+    
+    const userId = userData?.id;
+    if (userId) {
+      console.log(`Found user with ID: ${userId}`);
+    } else {
+      console.log('User not found in database. Will create subscription without user ID.');
+    }
+    
+    // First inspect the subscriptions table to see what columns we can use
+    console.log('Inspecting subscriptions table structure...');
+    const { data: subSample, error: subSampleError } = await supabase
+      .from('subscriptions')
+      .select('*')
+      .limit(1);
+    
+    if (subSampleError) {
+      console.error('Error inspecting subscriptions table:', subSampleError.message);
+      process.exit(1);
+    }
+    
+    // Get column names from database
+    const subColumns = subSample && subSample.length > 0 
+      ? Object.keys(subSample[0]) 
+      : ['id', 'email', 'status', 'expiration_date'];
+    
+    console.log('Available subscription columns:', subColumns.join(', '));
+    
+    // Set subscription data (only include fields that exist in the schema)
+    const subscriptionData = {
+      email,
+      status: 'active',
+    };
+    
+    // Add other fields only if they exist in the schema
+    if (subColumns.includes('expiration_date')) {
+      subscriptionData.expiration_date = expirationDate.toISOString();
+    }
+    
+    if (subColumns.includes('start_date')) {
+      subscriptionData.start_date = now.toISOString();
+    }
+    
+    if (subColumns.includes('plan')) {
+      subscriptionData.plan = plan;
+    }
+    
+    if (subColumns.includes('interval')) {
+      subscriptionData.interval = plan === 'monthly' ? 'month' : 'year';
+    }
+    
+    if (subColumns.includes('amount')) {
+      subscriptionData.amount = plan === 'monthly' ? 5.00 : 30.00;
+    }
+    
+    if (subColumns.includes('payment_method')) {
+      subscriptionData.payment_method = 'test';
+    }
+    
+    // Add user_id if available and column exists
+    if (userId && subColumns.includes('user_id')) {
+      subscriptionData.user_id = userId;
+    }
+    
+    // Check if subscription already exists - get the most recent one
+    const { data: existingSubs, error: subCheckError } = await supabase
+      .from('subscriptions')
+      .select('id')
+      .eq('email', email)
+      .order('created_at', { ascending: false })
+      .limit(1);
+    
+    if (subCheckError) {
+      console.error('Error checking for existing subscription:', subCheckError.message);
+      process.exit(1);
+    }
+    
+    // Get the first item if it exists
+    const existingSub = existingSubs && existingSubs.length > 0 ? existingSubs[0] : null;
+    
+    if (existingSub) {
+      // Update existing subscription
+      const { error: updateError } = await supabase
+        .from('subscriptions')
+        .update(subscriptionData)
+        .eq('id', existingSub.id);
+      
+      if (updateError) {
+        console.error('Error updating subscription:', updateError.message);
+        process.exit(1);
+      }
+      
+      console.log(`✅ Updated existing subscription (ID: ${existingSub.id})`);
+      console.log(`✅ Subscription is now active until: ${expirationDate.toISOString()}`);
+    } else {
+      // Create new subscription
+      const { data: newSub, error: createSubError } = await supabase
+        .from('subscriptions')
+        .insert(subscriptionData)
+        .select()
+        .single();
+      
+      if (createSubError) {
+        console.error('Error creating subscription:', createSubError.message);
+        process.exit(1);
+      }
+      
+      console.log(`✅ Created new subscription with ID: ${newSub.id}`);
+      console.log(`✅ Subscription is active until: ${expirationDate.toISOString()}`);
+    }
+    console.log('Test subscription creation successful!');
+  } catch (error) {
+    console.error('Error creating test subscription:', error.message);
+    process.exit(1);
+  }
+}
+
+activateSubscription();