create-stackr 0.2.0

package/templates/features/web/auth/components/auth/register-form.tsx.ejs

@@ -0,0 +1,139 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import Link from "next/link";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { signUp } from "@/lib/auth/actions";
+
+export function RegisterForm() {
+  const router = useRouter();
+  const [name, setName] = useState("");
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [confirmPassword, setConfirmPassword] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError(null);
+
+    if (password !== confirmPassword) {
+      setError("Passwords do not match");
+      return;
+    }
+
+    if (password.length < 8) {
+      setError("Password must be at least 8 characters");
+      return;
+    }
+
+    setIsLoading(true);
+
+    try {
+      const result = await signUp(email, password, name || undefined);
+
+      if (!result.success) {
+        setError(result.error || "Failed to create account");
+        return;
+      }
+
+<% if (features.authentication.emailVerification) { %>
+      if (result.needsEmailVerification) {
+        router.push(`/verify-email?email=${encodeURIComponent(email)}`);
+      } else {
+        router.push("/dashboard");
+        router.refresh();
+      }
+<% } else { %>
+      router.push("/dashboard");
+      router.refresh();
+<% } %>
+    } catch {
+      setError("An unexpected error occurred");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className="space-y-3">
+      <div className="space-y-1.5">
+        <Label htmlFor="name" className="text-sm">
+          Name <span className="text-muted-foreground font-normal">(optional)</span>
+        </Label>
+        <Input
+          id="name"
+          type="text"
+          value={name}
+          onChange={(e) => setName(e.target.value)}
+          placeholder="John Doe"
+          disabled={isLoading}
+          autoComplete="name"
+        />
+      </div>
+
+      <div className="space-y-1.5">
+        <Label htmlFor="email" className="text-sm">Email</Label>
+        <Input
+          id="email"
+          type="email"
+          value={email}
+          onChange={(e) => setEmail(e.target.value)}
+          placeholder="you@example.com"
+          required
+          disabled={isLoading}
+          autoComplete="email"
+        />
+      </div>
+
+      <div className="space-y-1.5">
+        <Label htmlFor="password" className="text-sm">Password</Label>
+        <Input
+          id="password"
+          type="password"
+          value={password}
+          onChange={(e) => setPassword(e.target.value)}
+          placeholder="Min. 8 characters"
+          required
+          disabled={isLoading}
+          autoComplete="new-password"
+        />
+      </div>
+
+      <div className="space-y-1.5">
+        <Label htmlFor="confirmPassword" className="text-sm">Confirm Password</Label>
+        <Input
+          id="confirmPassword"
+          type="password"
+          value={confirmPassword}
+          onChange={(e) => setConfirmPassword(e.target.value)}
+          placeholder="Confirm your password"
+          required
+          disabled={isLoading}
+          autoComplete="new-password"
+        />
+      </div>
+
+      {error && (
+        <div className="p-2.5 text-sm text-destructive bg-destructive/10 rounded-lg border border-destructive/20">
+          {error}
+        </div>
+      )}
+
+      <Button type="submit" className="w-full" disabled={isLoading}>
+        {isLoading ? "Creating account..." : "Create account"}
+      </Button>
+
+      <p className="text-center text-sm text-muted-foreground">
+        Already have an account?{" "}
+        <Link href="/login" className="text-primary hover:underline font-medium">
+          Sign in
+        </Link>
+      </p>
+    </form>
+  );
+}

package/templates/features/web/auth/components/settings/session-card.tsx.ejs

@@ -0,0 +1,132 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { type SessionInfo } from "@/lib/auth/sessions";
+import { parseUserAgent } from "@/lib/auth/user-agent";
+
+interface SessionCardProps {
+  session: SessionInfo;
+  isCurrentSession: boolean;
+}
+
+export function SessionCard({ session, isCurrentSession }: SessionCardProps) {
+  const { browser, os, device } = parseUserAgent(session.userAgent);
+  const createdAt = new Date(session.createdAt);
+  const expiresAt = new Date(session.expiresAt);
+  const isExpired = expiresAt < new Date();
+
+  const handleRevoke = () => {
+    // Session revocation requires WebSocket support for proper real-time notification
+    // Without it, the revoked device would experience broken states (401 errors, failed forms)
+    alert("Session revocation will be available after WebSocket support is implemented.");
+  };
+
+  return (
+    <div
+      className={`p-4 border rounded-lg ${
+        isCurrentSession
+          ? "border-primary bg-primary/5"
+          : isExpired
+          ? "border-muted bg-muted/20 opacity-60"
+          : "border-border"
+      }`}
+    >
+      <div className="flex items-start justify-between gap-4">
+        <div className="flex items-start gap-3">
+          {/* Device Icon */}
+          <div className="mt-1">
+            {device === "Mobile" ? (
+              <svg
+                className="w-5 h-5 text-muted-foreground"
+                fill="none"
+                viewBox="0 0 24 24"
+                stroke="currentColor"
+              >
+                <path
+                  strokeLinecap="round"
+                  strokeLinejoin="round"
+                  strokeWidth={2}
+                  d="M12 18h.01M8 21h8a2 2 0 002-2V5a2 2 0 00-2-2H8a2 2 0 00-2 2v14a2 2 0 002 2z"
+                />
+              </svg>
+            ) : device === "Tablet" ? (
+              <svg
+                className="w-5 h-5 text-muted-foreground"
+                fill="none"
+                viewBox="0 0 24 24"
+                stroke="currentColor"
+              >
+                <path
+                  strokeLinecap="round"
+                  strokeLinejoin="round"
+                  strokeWidth={2}
+                  d="M12 18h.01M7 21h10a2 2 0 002-2V5a2 2 0 00-2-2H7a2 2 0 00-2 2v14a2 2 0 002 2z"
+                />
+              </svg>
+            ) : (
+              <svg
+                className="w-5 h-5 text-muted-foreground"
+                fill="none"
+                viewBox="0 0 24 24"
+                stroke="currentColor"
+              >
+                <path
+                  strokeLinecap="round"
+                  strokeLinejoin="round"
+                  strokeWidth={2}
+                  d="M9.75 17L9 20l-1 1h8l-1-1-.75-3M3 13h18M5 17h14a2 2 0 002-2V5a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z"
+                />
+              </svg>
+            )}
+          </div>
+
+          {/* Session Info */}
+          <div className="space-y-1">
+            <div className="flex items-center gap-2">
+              <span className="font-medium">
+                {browser} on {os}
+              </span>
+              {isCurrentSession && (
+                <span className="px-2 py-0.5 text-xs font-medium bg-primary text-primary-foreground rounded-full">
+                  Current
+                </span>
+              )}
+              {isExpired && (
+                <span className="px-2 py-0.5 text-xs font-medium bg-muted text-muted-foreground rounded-full">
+                  Expired
+                </span>
+              )}
+            </div>
+
+            <div className="text-sm text-muted-foreground space-y-0.5">
+              {session.ipAddress && (
+                <p>IP: {session.ipAddress}</p>
+              )}
+              <p>
+                Created: {createdAt.toLocaleDateString()} at{" "}
+                {createdAt.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
+              </p>
+              <p>
+                {isExpired ? "Expired" : "Expires"}:{" "}
+                {expiresAt.toLocaleDateString()} at{" "}
+                {expiresAt.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}
+              </p>
+            </div>
+          </div>
+        </div>
+
+        {/* Revoke Button */}
+        {!isCurrentSession && !isExpired && (
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={handleRevoke}
+            className="shrink-0"
+          >
+            Revoke
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}

package/templates/integrations/mobile/adjust/services/adjustService.ts.ejs

@@ -0,0 +1,163 @@
+import { Platform } from 'react-native';
+import { Adjust, AdjustConfig } from 'react-native-adjust';
+import Constants from 'expo-constants';
+import { logger } from '../utils/logger';
+
+class AdjustService {
+  private static readonly APP_TOKEN = Constants.expoConfig?.extra?.adjust?.appToken || '';
+  private static readonly ATT_CONSENT_WAITING_INTERVAL = 120;
+
+  /**
+   * Initialize Adjust SDK
+   */
+  initialize(): void {
+    try {
+      logger.info('AdjustService: Initializing Adjust SDK...');
+
+      // Determine environment from config or fallback to __DEV__
+      const configEnvironment = Constants.expoConfig?.extra?.adjust?.environment;
+      const environment = configEnvironment === 'production'
+        ? AdjustConfig.EnvironmentProduction
+        : configEnvironment === 'sandbox'
+        ? AdjustConfig.EnvironmentSandbox
+        : __DEV__ ? AdjustConfig.EnvironmentSandbox : AdjustConfig.EnvironmentProduction;
+
+      const adjustConfig = new AdjustConfig(
+        AdjustService.APP_TOKEN,
+        environment
+      );
+
+      // Set ATT consent waiting interval - gives time for ATT prompt response
+      adjustConfig.setAttConsentWaitingInterval(AdjustService.ATT_CONSENT_WAITING_INTERVAL);
+
+      // Initialize the SDK
+      Adjust.initSdk(adjustConfig);
+      
+      logger.info('AdjustService: Adjust SDK initialized successfully');
+    } catch (error) {
+      logger.error('AdjustService: Failed to initialize Adjust SDK', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieve ADID with retry mechanism and exponential backoff
+   */
+  async retrieveAdidWithRetry(
+    maxAttempts: number = 5,
+    maxTotalTimeMs: number = 10000,
+    initialDelayMs: number = 500
+  ): Promise<string | null> {
+    const startTime = Date.now();
+    let cumulativeDelay = 0;
+
+    logger.info('AdjustService: Starting ADID retrieval with exponential backoff retry...');
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      // Check if we have time for this attempt
+      const elapsedTime = Date.now() - startTime;
+      const remainingTime = maxTotalTimeMs - elapsedTime - cumulativeDelay;
+
+      if (remainingTime <= 0) {
+        logger.info(`AdjustService: ADID retry timeout reached before attempt ${attempt}`);
+        break;
+      }
+
+      // Calculate delay for this attempt (exponential backoff)
+      const delay = attempt === 1 ? initialDelayMs : Math.min(
+        initialDelayMs * Math.pow(2, attempt - 2),
+        remainingTime
+      );
+
+      // Wait before attempting (except for first attempt)
+      if (attempt > 1) {
+        logger.info(`AdjustService: ADID retry attempt ${attempt}/${maxAttempts} - waiting ${delay}ms...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        cumulativeDelay += delay;
+      } else {
+        logger.info(`AdjustService: ADID attempt ${attempt}/${maxAttempts} (initial attempt)...`);
+      }
+
+      // Check remaining time after delay
+      const currentElapsed = Date.now() - startTime;
+      if (currentElapsed >= maxTotalTimeMs) {
+        logger.info('AdjustService: ADID retry timeout reached after waiting');
+        break;
+      }
+
+      // Attempt to retrieve ADID
+      try {
+        const result = await new Promise<string | null>((resolve) => {
+          Adjust.getAdid((retrievedAdid) => {
+            logger.info(`AdjustService: ADID attempt ${attempt} result:`, retrievedAdid);
+            resolve(retrievedAdid);
+          });
+        });
+
+        if (result) {
+          const totalTime = Date.now() - startTime;
+          logger.info(`AdjustService: ADID retrieved successfully on attempt ${attempt} after ${totalTime}ms:`, result);
+          return result;
+        } else {
+          logger.info(`AdjustService: ADID attempt ${attempt} returned null`);
+        }
+      } catch (error) {
+        logger.error(`AdjustService: ADID attempt ${attempt} failed:`, error);
+      }
+    }
+
+    const totalTime = Date.now() - startTime;
+    logger.info(`AdjustService: ADID retrieval failed after ${maxAttempts} attempts in ${totalTime}ms`);
+    return null;
+  }
+
+  /**
+   * Get ADID immediately (single attempt)
+   */
+  async getAdid(): Promise<string | null> {
+    try {
+      return new Promise<string | null>((resolve) => {
+        Adjust.getAdid((adid) => {
+          resolve(adid);
+        });
+      });
+    } catch (error) {
+      logger.error('AdjustService: Failed to get ADID', { error });
+      return null;
+    }
+  }
+
+  /**
+   * Track event with Adjust
+   */
+  trackEvent(eventToken: string, revenue?: number, currency?: string): void {
+    try {
+      // Implementation would depend on your event tracking needs
+      logger.info('AdjustService: Event tracking would be implemented here', { 
+        eventToken, 
+        revenue, 
+        currency 
+      });
+    } catch (error) {
+      logger.error('AdjustService: Failed to track event', { error });
+    }
+  }
+
+  /**
+   * Get environment info
+   */
+  getEnvironment(): string {
+    const configEnvironment = Constants.expoConfig?.extra?.adjust?.environment;
+    return configEnvironment || (__DEV__ ? 'sandbox' : 'production');
+  }
+
+  /**
+   * Get app token
+   */
+  getAppToken(): string {
+    return AdjustService.APP_TOKEN;
+  }
+}
+
+// Export singleton instance
+export const adjustService = new AdjustService();

package/templates/integrations/mobile/adjust/store/adjust.store.ts

@@ -0,0 +1,243 @@
+import { create } from 'zustand';
+import { adjustService } from '../services/adjustService';
+import { useRevenueCatStore } from './revenuecat.store';
+import { useScateStore } from './scate.store';
+import { logger } from '../utils/logger';
+
+interface AdjustState {
+  // State
+  isInitialized: boolean;
+  adid: string | null;
+  isRetrievingAdid: boolean;
+  isLoading: boolean;
+  error: string | null;
+
+  // Actions
+  initialize: () => void;
+  retrieveAdid: () => Promise<void>;
+  retrieveAdidWithRetry: () => Promise<void>;
+  setAdid: (adid: string | null) => void;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  reset: () => void;
+  notifyOtherStores: (adid: string) => void;
+
+  // Computed values
+  hasAdid: boolean;
+}
+
+export const useAdjustStore = create<AdjustState>((set, get) => ({
+  // Initial state
+  isInitialized: false,
+  adid: null,
+  isRetrievingAdid: false,
+  isLoading: false,
+  error: null,
+  hasAdid: false,
+
+  // Actions
+  initialize: () => {
+    const state = get();
+    if (state.isInitialized) {
+      logger.info('AdjustStore: Already initialized, skipping');
+      return;
+    }
+
+    try {
+      set({ isLoading: true, error: null });
+      logger.info('AdjustStore: Initializing Adjust SDK...');
+
+      adjustService.initialize();
+      
+      set({
+        isInitialized: true,
+        isLoading: false,
+        error: null,
+        hasAdid: false
+      });
+
+      logger.info('AdjustStore: Adjust SDK initialized successfully');
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to initialize Adjust SDK';
+      logger.error('AdjustStore: Failed to initialize Adjust SDK', { error });
+      set({
+        error: errorMessage,
+        isLoading: false,
+        isInitialized: false,
+        hasAdid: false
+      });
+    }
+  },
+
+  retrieveAdid: async () => {
+    const state = get();
+    if (state.isRetrievingAdid || state.adid) {
+      logger.info('AdjustStore: ADID retrieval already in progress or ADID already available');
+      return;
+    }
+
+    try {
+      set({ isRetrievingAdid: true, error: null });
+      logger.info('AdjustStore: Retrieving ADID...');
+
+      const adid = await adjustService.getAdid();
+      
+      if (adid) {
+        set({
+          adid,
+          isRetrievingAdid: false,
+          error: null,
+          hasAdid: true
+        });
+
+        // Notify other stores about ADID availability
+        get().notifyOtherStores(adid);
+        
+        logger.info('AdjustStore: ADID retrieved successfully', { adid });
+      } else {
+        set({
+          adid: null,
+          isRetrievingAdid: false,
+          error: 'ADID not available',
+          hasAdid: false
+        });
+        logger.info('AdjustStore: ADID not available');
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to retrieve ADID';
+      logger.error('AdjustStore: Failed to retrieve ADID', { error });
+      set({
+        error: errorMessage,
+        isRetrievingAdid: false,
+        adid: null,
+        hasAdid: false
+      });
+    }
+  },
+
+  retrieveAdidWithRetry: async () => {
+    const state = get();
+    if (state.isRetrievingAdid || state.adid) {
+      logger.info('AdjustStore: ADID retrieval with retry already in progress or ADID already available');
+      return;
+    }
+
+    try {
+      set({ isRetrievingAdid: true, error: null });
+      logger.info('AdjustStore: Retrieving ADID with retry mechanism...');
+
+      const adid = await adjustService.retrieveAdidWithRetry();
+      
+      if (adid) {
+        set({
+          adid,
+          isRetrievingAdid: false,
+          error: null,
+          hasAdid: true
+        });
+
+        // Notify other stores about ADID availability
+        get().notifyOtherStores(adid);
+        
+        logger.info('AdjustStore: ADID retrieved successfully with retry', { adid });
+      } else {
+        set({
+          adid: null,
+          isRetrievingAdid: false,
+          error: 'ADID not available after retry attempts',
+          hasAdid: false
+        });
+        logger.info('AdjustStore: ADID not available after retry attempts');
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to retrieve ADID with retry';
+      logger.error('AdjustStore: Failed to retrieve ADID with retry', { error });
+      set({
+        error: errorMessage,
+        isRetrievingAdid: false,
+        adid: null,
+        hasAdid: false
+      });
+    }
+  },
+
+  setAdid: (adid) => {
+    const currentState = get();
+    if (currentState.adid === adid) {
+      return; // No change needed
+    }
+
+    set({ adid, hasAdid: !!adid });
+    
+    if (adid) {
+      // Notify other stores about ADID availability
+      get().notifyOtherStores(adid);
+    }
+    
+    logger.info('AdjustStore: ADID set', { adid });
+  },
+
+  setLoading: (isLoading) => set({ isLoading }),
+  
+  setError: (error) => set({ error }),
+
+  reset: () => {
+    set({
+      isInitialized: false,
+      adid: null,
+      isRetrievingAdid: false,
+      isLoading: false,
+      error: null,
+      hasAdid: false
+    });
+    logger.info('AdjustStore: Store reset');
+  },
+
+  // Helper method to notify other stores about ADID
+  notifyOtherStores: (adid: string) => {
+    try {
+      // Notify RevenueCat store
+      const revenueCatStore = useRevenueCatStore.getState();
+      if (revenueCatStore.isInitialized) {
+        revenueCatStore.setAdjustId(adid);
+      }
+
+      // Notify Scate store  
+      const scateStore = useScateStore.getState();
+      if (scateStore.isInitialized) {
+        scateStore.setAdid(adid);
+      }
+
+      logger.info('AdjustStore: Other stores notified about ADID', { adid });
+    } catch (error) {
+      logger.error('AdjustStore: Failed to notify other stores about ADID', { error });
+    }
+  },
+
+}));
+
+// Selectors for commonly used Adjust state
+export const useAdjust = () => {
+  const state = useAdjustStore();
+  return {
+    isInitialized: state.isInitialized,
+    adid: state.adid,
+    isRetrievingAdid: state.isRetrievingAdid,
+    isLoading: state.isLoading,
+    error: state.error,
+    hasAdid: state.hasAdid,
+  };
+};
+
+export const useAdjustActions = () => {
+  const state = useAdjustStore();
+  return {
+    initialize: state.initialize,
+    retrieveAdid: state.retrieveAdid,
+    retrieveAdidWithRetry: state.retrieveAdidWithRetry,
+    setAdid: state.setAdid,
+    setLoading: state.setLoading,
+    setError: state.setError,
+    reset: state.reset,
+  };
+};