create-stackr 0.2.0

package/templates/base/backend/utils/redis.ts.ejs

@@ -0,0 +1,279 @@
+import Redis from 'ioredis';
+import { REDIS_KEYS, TTL } from '../lib/constants';
+
+const redisHost = process.env.REDIS_HOST || 'localhost';
+const redisPort = parseInt(process.env.REDIS_PORT || '6379', 10);
+const redisPassword = process.env.REDIS_PASSWORD;
+const redisDb = parseInt(process.env.REDIS_DB || '0', 10);
+const isDevelopment = process.env.NODE_ENV === 'development';
+
+// =============================================================================
+// In-Memory Store (Development Fallback Only)
+// =============================================================================
+// This store is ONLY used when Redis is unavailable in development.
+// In production, Redis unavailability will cause OAuth to fail (as intended).
+
+interface MemoryStoreEntry {
+  data: string;
+  expiresAt: number;
+}
+
+class InMemoryStore {
+  private store = new Map<string, MemoryStoreEntry>();
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor() {
+    // Cleanup expired entries every 60 seconds
+    this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+  }
+
+  async setex(key: string, ttlSeconds: number, value: string): Promise<void> {
+    this.store.set(key, {
+      data: value,
+      expiresAt: Date.now() + ttlSeconds * 1000,
+    });
+  }
+
+  async get(key: string): Promise<string | null> {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+
+  async del(key: string): Promise<void> {
+    this.store.delete(key);
+  }
+
+  async getdel(key: string): Promise<string | null> {
+    const value = await this.get(key);
+    if (value) {
+      this.store.delete(key);
+    }
+    return value;
+  }
+
+  // Lua script simulation for atomic get-and-delete
+  async eval(_script: string, _numKeys: number, ...args: string[]): Promise<string | null> {
+    // For our use case, this is always the atomic get-delete pattern
+    const key = args[0];
+    return this.getdel(key);
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expiresAt) {
+        this.store.delete(key);
+      }
+    }
+  }
+
+  destroy(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.store.clear();
+  }
+}
+
+// =============================================================================
+// Redis Client
+// =============================================================================
+
+let redis: Redis | null = null;
+let redisAvailable = false;
+let memoryStore: InMemoryStore | null = null;
+let usingMemoryFallback = false;
+
+function createRedisClient(): Redis {
+  const client = new Redis({
+    host: redisHost,
+    port: redisPort,
+    password: redisPassword || undefined,
+    db: redisDb,
+    maxRetriesPerRequest: 3,
+    retryStrategy(times) {
+      if (times > 3) return null; // Stop retrying after 3 attempts
+      return Math.min(times * 100, 3000); // Exponential backoff
+    },
+    enableOfflineQueue: false, // Don't queue commands when disconnected
+  });
+
+  client.on('error', (err) => {
+    console.error('Redis connection error:', err.message);
+    redisAvailable = false;
+
+    // In development, activate memory fallback when Redis fails
+    if (isDevelopment && !usingMemoryFallback) {
+      console.warn('⚠️  Redis unavailable in development - using in-memory store fallback');
+      console.warn('⚠️  OAuth state will NOT persist across server restarts!');
+      usingMemoryFallback = true;
+      if (!memoryStore) {
+        memoryStore = new InMemoryStore();
+      }
+    }
+  });
+
+  client.on('connect', () => {
+    console.log('Connected to Redis');
+    redisAvailable = true;
+    usingMemoryFallback = false;
+  });
+
+  client.on('close', () => {
+    redisAvailable = false;
+  });
+
+  return client;
+}
+
+// Initialize Redis client
+export async function initRedis(): Promise<void> {
+  if (!redis) {
+    redis = createRedisClient();
+    try {
+      await redis.ping();
+      redisAvailable = true;
+      console.log('✅ Redis connected successfully');
+    } catch (err) {
+      console.error('Failed to connect to Redis:', (err as Error).message);
+      redisAvailable = false;
+
+      if (isDevelopment) {
+        console.warn('⚠️  Using in-memory store fallback for development');
+        usingMemoryFallback = true;
+        memoryStore = new InMemoryStore();
+      }
+    }
+  }
+}
+
+// Get the active store (Redis or in-memory fallback)
+function getStore(): Redis | InMemoryStore {
+  if (redisAvailable && redis) {
+    return redis;
+  }
+
+  if (isDevelopment && usingMemoryFallback && memoryStore) {
+    return memoryStore;
+  }
+
+  throw new Error('Redis is not available');
+}
+
+// Check if Redis (or fallback) is available
+export function isRedisAvailable(): boolean {
+  return redisAvailable || (isDevelopment && usingMemoryFallback);
+}
+
+// Check if using in-memory fallback
+export function isUsingMemoryFallback(): boolean {
+  return usingMemoryFallback;
+}
+
+/**
+ * OAuth store helpers with graceful error handling
+ * Uses Redis when available, falls back to in-memory store in development
+ */
+export const oauthStore = {
+  /**
+   * Store PKCE challenge during OAuth init
+   * @throws if store is unavailable (Redis down in production)
+   */
+  async storeOAuthState(
+    state: string,
+    data: {
+      code_challenge: string;
+      callback_url: string;
+      provider: string;
+    }
+  ): Promise<void> {
+    const store = getStore();
+    await store.setex(
+      `${REDIS_KEYS.OAUTH_WEB_STATE}${state}`,
+      TTL.OAUTH_STATE,
+      JSON.stringify({ ...data, created_at: Date.now() })
+    );
+  },
+
+  /**
+   * Retrieve OAuth state (does NOT delete - caller should delete after use)
+   */
+  async getOAuthState(state: string): Promise<{
+    code_challenge: string;
+    callback_url: string;
+    provider: string;
+    created_at: number;
+  } | null> {
+    const store = getStore();
+    const data = await store.get(`${REDIS_KEYS.OAUTH_WEB_STATE}${state}`);
+    if (!data) return null;
+    return JSON.parse(data);
+  },
+
+  /**
+   * Delete OAuth state after use
+   */
+  async deleteOAuthState(state: string): Promise<void> {
+    const store = getStore();
+    await store.del(`${REDIS_KEYS.OAUTH_WEB_STATE}${state}`);
+  },
+
+  /**
+   * Store exchange token after OAuth callback
+   */
+  async storeExchangeToken(
+    token: string,
+    data: {
+      session_token: string;
+      code_challenge: string;
+    }
+  ): Promise<void> {
+    const store = getStore();
+    await store.setex(
+      `${REDIS_KEYS.OAUTH_EXCHANGE}${token}`,
+      TTL.EXCHANGE_TOKEN,
+      JSON.stringify(data)
+    );
+  },
+
+  /**
+   * Retrieve and delete exchange token (single use)
+   * Uses atomic operations to prevent race conditions
+   */
+  async consumeExchangeToken(token: string): Promise<{
+    session_token: string;
+    code_challenge: string;
+  } | null> {
+    const store = getStore();
+    const key = `${REDIS_KEYS.OAUTH_EXCHANGE}${token}`;
+
+    // Use GETDEL for atomic get-and-delete (Redis 6.2+ / in-memory store)
+    let data: string | null = null;
+
+    try {
+      data = await store.getdel(key);
+    } catch {
+      // Fallback for older Redis versions using Lua script for atomicity
+      // This ensures the token can only be consumed once even under concurrent requests
+      const luaScript = `
+        local value = redis.call('GET', KEYS[1])
+        if value then
+          redis.call('DEL', KEYS[1])
+        end
+        return value
+      `;
+      data = (await store.eval(luaScript, 1, key)) as string | null;
+    }
+
+    if (!data) return null;
+    return JSON.parse(data);
+  },
+};
+
+// Export for direct Redis access if needed (use getStore() for fallback support)
+export { redis, getStore };

package/templates/base/mobile/.env.example.ejs

@@ -0,0 +1,35 @@
+# =============================================================================
+# IMPORTANT: SDK API Keys Configuration
+# =============================================================================
+# SDK API keys (RevenueCat, Adjust, Scate) are configured in app.json and
+# embedded at build time via expo-constants. They are NOT read from this file.
+#
+# This file is provided for reference and documentation purposes only.
+# The actual keys used by the app come from app.json's "extra" field.
+#
+# To change SDK keys, update app.json and rebuild the app.
+# =============================================================================
+
+# Backend API
+API_URL=http://localhost:8080
+
+<% if (integrations.revenueCat.enabled) { %># RevenueCat Configuration
+# NOTE: These keys are configured in app.json and embedded at build time
+# Get your API keys from: https://app.revenuecat.com/
+# Reference values (not used at runtime):
+REVENUECAT_IOS_KEY=<%= integrations.revenueCat.iosKey || 'YOUR_IOS_API_KEY_HERE' %>
+REVENUECAT_ANDROID_KEY=<%= integrations.revenueCat.androidKey || 'YOUR_ANDROID_API_KEY_HERE' %>
+<% } %>
+<% if (integrations.adjust.enabled) { %># Adjust Configuration
+# NOTE: These values are configured in app.json and embedded at build time
+# Get your app token from: https://dash.adjust.com/
+# Reference values (not used at runtime):
+ADJUST_APP_TOKEN=<%= integrations.adjust.appToken || 'YOUR_ADJUST_APP_TOKEN_HERE' %>
+ADJUST_ENVIRONMENT=<%= integrations.adjust.environment %>
+<% } %>
+<% if (integrations.scate.enabled) { %># Scate Configuration
+# NOTE: This key is configured in app.json and embedded at build time
+# Get your API key from: https://scate.io/
+# Reference value (not used at runtime):
+SCATE_API_KEY=<%= integrations.scate.apiKey || 'YOUR_SCATE_API_KEY_HERE' %>
+<% } %>

package/templates/base/mobile/.gitignore.ejs

@@ -0,0 +1,167 @@
+# React Native/Expo Mobile App - Git Ignore
+
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-store/
+
+# Expo
+.expo/
+dist/
+web-build/
+expo-env.d.ts
+
+# Native build directories and files
+ios/
+android/
+.kotlin/
+
+# Metro
+.metro-health-check*
+.metro/
+
+# Debug files
+npm-debug.*
+yarn-debug.*
+yarn-error.*
+
+# macOS
+.DS_Store
+*.pem
+
+# Environment files
+.env
+.env.*
+!.env.example
+
+# TypeScript
+*.tsbuildinfo
+tsconfig.tsbuildinfo
+
+# EAS
+build/
+*.ipa
+*.apk
+*.aab
+.eas/
+
+# React Native
+*.orig.*
+*.jks
+*.p8
+*.p12
+*.key
+*.mobileprovision
+*.keystore
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+*.temp
+
+# Logs
+logs/
+*.log
+
+# Test coverage
+coverage/
+.nyc_output/
+
+# Editor and IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Cache directories
+.cache/
+.eslintcache
+
+# OS files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Backup files
+*.bak
+*.backup
+*.old
+
+# Archive files
+*.zip
+*.tar.gz
+*.rar
+
+# Simulator files
+*.trace
+
+# Flipper
+Flipper/
+
+# CocoaPods (iOS)
+ios/Pods/
+ios/Podfile.lock
+*.xcworkspace
+
+# Gradle (Android)
+android/.gradle/
+android/build/
+android/app/build/
+android/local.properties
+
+# Fastlane
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots
+fastlane/test_output
+fastlane/readme.md
+
+# Bundle artifacts
+*.jsbundle
+
+# Watchman
+.watchmanconfig
+
+# Xcode
+*.xcodeproj/*
+!*.xcodeproj/project.pbxproj
+!*.xcodeproj/xcshareddata/
+!*.xcodeproj/project.xcworkspace/
+*.xcworkspace/*
+!*.xcworkspace/contents.xcworkspacedata
+/*.gcno
+
+# Android Studio
+.gradle
+/build/
+/captures
+.externalNativeBuild
+
+# Detox
+e2e/*.js
+e2e/artifacts/
+
+# Storybook
+storybook-static/
+
+# Firebase
+.firebase/
+firebase-debug.log
+firebase-debug.*.log
+
+# React Native Debugger
+rndebugger_log.txt
+
+# CodePush
+CodePush/
+
+# App Center
+AppCenter/

package/templates/base/mobile/app/+not-found.tsx

@@ -0,0 +1,85 @@
+import React from 'react';
+import { View, Text, StyleSheet } from 'react-native';
+import { router } from 'expo-router';
+import { Button } from '../src/components/ui';
+
+export default function NotFoundScreen() {
+  const handleGoHome = () => {
+    router.replace('/(tabs)');
+  };
+
+  const handleGoBack = () => {
+    if (router.canGoBack()) {
+      router.back();
+    } else {
+      handleGoHome();
+    }
+  };
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.title}>404</Text>
+      <Text style={styles.message}>Page Not Found</Text>
+      <Text style={styles.description}>
+        The page you're looking for doesn't exist or has been moved.
+      </Text>
+      
+      <View style={styles.actions}>
+        <Button
+          title="Go Back"
+          onPress={handleGoBack}
+          style={styles.button}
+        />
+        <Button
+          title="Go Home"
+          variant="outline"
+          onPress={handleGoHome}
+          style={styles.button}
+        />
+      </View>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+    backgroundColor: '#FFFFFF',
+  },
+  
+  title: {
+    fontSize: 72,
+    fontWeight: 'bold',
+    color: '#007AFF',
+    marginBottom: 16,
+  },
+  
+  message: {
+    fontSize: 24,
+    fontWeight: '600',
+    color: '#000000',
+    marginBottom: 8,
+    textAlign: 'center',
+  },
+  
+  description: {
+    fontSize: 16,
+    color: '#8E8E93',
+    textAlign: 'center',
+    lineHeight: 22,
+    marginBottom: 32,
+  },
+  
+  actions: {
+    gap: 12,
+    width: '100%',
+    maxWidth: 300,
+  },
+  
+  button: {
+    width: '100%',
+  },
+});

package/templates/base/mobile/app/_layout.tsx.ejs

@@ -0,0 +1,71 @@
+import { Stack, router } from 'expo-router';
+import { useEffect<% if (features.sessionManagement) { %>, useState<% } %> } from 'react';
+import Constants from 'expo-constants';
+import { ThemeProvider } from '@/context/ThemeContext';
+<% if (features.onboarding.enabled) { %>import AsyncStorage from '@react-native-async-storage/async-storage';
+<% } %><% if (integrations.revenueCat.enabled || integrations.adjust.enabled || integrations.scate.enabled) { %>import { initializeSDKs } from '@/services/sdkInitializer';
+<% } %><% if (features.sessionManagement) { %>import { useSessionActions, useSession } from '../src/store/deviceSession.store';
+<% } %>import { logger } from '../src/utils/logger';
+
+export default function RootLayout() {
+<% if (features.sessionManagement) { %>  const { initializeSession } = useSessionActions();
+  const { isSessionChecked } = useSession();
+<% } else { %>  const [isReady, setIsReady] = useState(false);
+<% } %>
+  // Get feature flags from app.json
+  const onboardingEnabled = Constants.expoConfig?.extra?.features?.onboarding?.enabled ?? false;
+
+  useEffect(() => {
+<% if (integrations.revenueCat.enabled || integrations.adjust.enabled || integrations.scate.enabled) { %>    // Initialize SDKs
+    initializeSDKs().catch(console.error);
+
+<% } %>    // App initialization and navigation
+    const initializeApp = async () => {
+<% if (features.sessionManagement) { %>      // Skip if session already checked
+      if (isSessionChecked) {
+        logger.debug('RootLayout: Session already checked, skipping');
+        return;
+      }
+<% } %>
+      try {
+        logger.info('RootLayout: Initializing app...');
+
+<% if (features.onboarding.enabled) { %>        // Check onboarding completion
+        const onboardingCompleted = await AsyncStorage.getItem('onboarding_completed');
+
+        if (onboardingEnabled && onboardingCompleted !== 'true') {
+          // Onboarding not completed - navigate to onboarding
+          logger.info('RootLayout: Onboarding not completed, navigating to onboarding');
+          router.replace('/(onboarding)/page-1');
+          return;
+        }
+<% } %>
+<% if (features.sessionManagement) { %>        // Initialize session
+        logger.info('RootLayout: Initializing session');
+        await initializeSession();
+<% } %>
+        router.replace('/(tabs)');
+      } catch (error) {
+        logger.error('RootLayout: Failed to initialize app', { error });
+        // Fallback to tabs on error
+        router.replace('/(tabs)');
+      }<% if (!features.sessionManagement) { %> finally {
+        setIsReady(true);
+      }<% } %>
+    };
+
+    initializeApp();
+  }, [<% if (features.sessionManagement) { %>isSessionChecked, initializeSession, <% } %>onboardingEnabled]);
+
+  return (
+    <ThemeProvider>
+      <Stack screenOptions={{ headerShown: false }}>
+<% if (features.onboarding.enabled) { %>        <Stack.Screen name="(onboarding)" />
+<% } %><% if (features.authentication.enabled) { %>        <Stack.Screen name="(auth)" />
+<% } %><% if (features.paywall) { %>        <Stack.Screen name="paywall" options={{ presentation: 'modal' }} />
+<% } %>        <Stack.Screen name="(tabs)" />
+        <Stack.Screen name="+not-found" />
+      </Stack>
+    </ThemeProvider>
+  );
+}