Merge pull request #948 from trycompai/claudio/stripe

[dev] [claudfuen] claudio/stripe

Author: claudfuen

apps/app/package.json

@@ -57,7 +57,7 @@
     "languine": "^3.1.4",
     "marked": "^15.0.11",
     "motion": "^12.9.2",
-    "next": "15.4.0-canary.83",
+    "next": "15.4.0-canary.85",
     "next-international": "^1.3.1",
     "next-intl": "^3.26.5",
     "next-safe-action": "^8.0.3",
@@ -94,7 +94,7 @@
     "@types/d3": "^7.4.3",
     "@types/node": "^22.13.2",
     "eslint": "^9",
-    "eslint-config-next": "15.4.0-canary.83",
+    "eslint-config-next": "15.4.0-canary.85",
     "fleetctl": "^4.68.1",
     "postcss": "^8.5.4",
     "react": "^19.1.0",

…ganization/create-organization-action.ts …zation/initialize-organization-action.tsapps/app/src/actions/organization/create-organization-action.ts renamed to apps/app/src/actions/organization/initialize-organization-action.ts apps/app/src/actions/organization/create-organization-action.ts renamed to apps/app/src/actions/organization/initialize-organization-action.ts

@@ -10,12 +10,12 @@ import { organizationSchema } from '../schema';
 import { createStripeCustomer } from './lib/create-stripe-customer';
 import { initializeOrganization } from './lib/initialize-organization';
 
-export const createOrganizationAction = authActionClient
+export const initializeOrganizationAction = authActionClient
   .inputSchema(organizationSchema)
   .metadata({
-    name: 'create-organization',
+    name: 'initialize-organization',
     track: {
-      event: 'create-organization',
+      event: 'initialize-organization',
       channel: 'server',
     },
   })

apps/app/src/actions/safe-action.ts

@@ -253,3 +253,89 @@ export const authWithOrgAccessClient = authActionClient.use(async ({ next, clien
     },
   });
 });
+
+// New action client that requires auth but not an active organization
+export const authActionClientWithoutOrg = actionClientWithMeta
+  .use(async ({ next, clientInput }) => {
+    const response = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    const { session, user } = response ?? {};
+
+    if (!session) {
+      throw new Error('Unauthorized');
+    }
+
+    const result = await next({
+      ctx: {
+        user: user,
+        session: session,
+      },
+    });
+
+    if (process.env.NODE_ENV === 'development') {
+      logger('Input ->', JSON.stringify(clientInput, null, 2));
+      logger('Result ->', JSON.stringify(result.data, null, 2));
+
+      // Also log validation errors if they exist
+      if (result.validationErrors) {
+        logger('Validation Errors ->', JSON.stringify(result.validationErrors, null, 2));
+      }
+
+      return result;
+    }
+
+    return result;
+  })
+  .use(async ({ next, metadata }) => {
+    const headersList = await headers();
+    let remaining: number | undefined;
+
+    if (ratelimit) {
+      const { success, remaining: rateLimitRemaining } = await ratelimit.limit(
+        `${headersList.get('x-forwarded-for')}-${metadata.name}`,
+      );
+
+      if (!success) {
+        throw new Error('Too many requests');
+      }
+
+      remaining = rateLimitRemaining;
+    }
+
+    return next({
+      ctx: {
+        ip: headersList.get('x-forwarded-for'),
+        userAgent: headersList.get('user-agent'),
+        ratelimit: {
+          remaining: remaining ?? 0,
+        },
+      },
+    });
+  })
+  .use(async ({ next, metadata, ctx }) => {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session) {
+      throw new Error('Unauthorized');
+    }
+
+    if (metadata.track) {
+      track(session.user.id, metadata.track.event, {
+        channel: metadata.track.channel,
+        email: session.user.email,
+        name: session.user.name,
+        // organizationId is optional here since there might not be one
+        organizationId: session.session.activeOrganizationId || undefined,
+      });
+    }
+
+    return next({
+      ctx: {
+        user: session.user,
+      },
+    });
+  });

apps/app/src/app/(app)/invite/[code]/page.tsx

@@ -0,0 +1,51 @@
+import { auth } from '@/utils/auth';
+import { db } from '@comp/db';
+import { headers } from 'next/headers';
+import { notFound, redirect } from 'next/navigation';
+import { AcceptInvite } from '../../setup/components/accept-invite';
+
+interface InvitePageProps {
+  params: Promise<{ code: string }>;
+}
+
+export default async function InvitePage({ params }: InvitePageProps) {
+  const { code } = await params;
+  const session = await auth.api.getSession({
+    headers: await headers(),
+  });
+
+  if (!session) {
+    // Redirect to auth with the invite code
+    return redirect(`/auth?inviteCode=${code}`);
+  }
+
+  // Check if this invitation exists and is valid for this user
+  const invitation = await db.invitation.findFirst({
+    where: {
+      id: code,
+      email: session.user.email,
+      status: 'pending',
+    },
+    include: {
+      organization: {
+        select: {
+          name: true,
+        },
+      },
+    },
+  });
+
+  if (!invitation) {
+    // Either invitation doesn't exist, already accepted, or not for this user
+    notFound();
+  }
+
+  return (
+    <div className="flex min-h-screen items-center justify-center p-4">
+      <AcceptInvite
+        inviteCode={invitation.id}
+        organizationName={invitation.organization.name || ''}
+      />
+    </div>
+  );
+}

apps/app/src/app/(app)/no-access/page.tsx

@@ -30,16 +30,6 @@ export default async function NoAccess() {
     },
   });
 
-  const frameworks = await db.frameworkEditorFramework.findMany({
-    select: {
-      id: true,
-      name: true,
-      description: true,
-      version: true,
-      visible: true,
-    },
-  });
-
   return (
     <div className="bg-foreground/05 flex h-screen flex-col items-center justify-center gap-4">
       <h1 className="text-2xl font-bold">Access Denied</h1>
@@ -54,11 +44,7 @@ export default async function NoAccess() {
         <p>Please select another organization or contact your organization administrator.</p>
       </div>
       <div>
-        <OrganizationSwitcher
-          organizations={organizations}
-          organization={currentOrg}
-          frameworks={frameworks}
-        />
+        <OrganizationSwitcher organizations={organizations} organization={currentOrg} />
       </div>
     </div>
   );

apps/app/src/app/(app)/setup/actions/create-organization-minimal.ts

@@ -0,0 +1,133 @@
+'use server';
+
+import { createStripeCustomer } from '@/actions/organization/lib/create-stripe-customer';
+import { initializeOrganization } from '@/actions/organization/lib/initialize-organization';
+import { authActionClientWithoutOrg } from '@/actions/safe-action';
+import { auth } from '@/utils/auth';
+import { db } from '@comp/db';
+import { revalidatePath } from 'next/cache';
+import { headers } from 'next/headers';
+import { z } from 'zod';
+
+const createOrganizationMinimalSchema = z.object({
+  organizationName: z.string().min(1, 'Organization name is required'),
+  website: z.string().url('Please enter a valid URL'),
+  frameworkIds: z.array(z.string()).default([]),
+});
+
+export const createOrganizationMinimal = authActionClientWithoutOrg
+  .inputSchema(createOrganizationMinimalSchema)
+  .metadata({
+    name: 'create-organization-minimal',
+    track: {
+      event: 'create-organization-minimal',
+      channel: 'server',
+    },
+  })
+  .action(async ({ parsedInput, ctx }) => {
+    try {
+      const session = await auth.api.getSession({
+        headers: await headers(),
+      });
+
+      if (!session) {
+        return {
+          success: false,
+          error: 'Not authorized.',
+        };
+      }
+
+      // Create a new organization directly in the database
+      const randomSuffix = Math.floor(100000 + Math.random() * 900000).toString();
+
+      const newOrg = await db.organization.create({
+        data: {
+          name: parsedInput.organizationName,
+          website: parsedInput.website,
+          members: {
+            create: {
+              userId: session.user.id,
+              role: 'owner',
+            },
+          },
+        },
+      });
+
+      const orgId = newOrg.id;
+
+      // Create onboarding record for new org (mark as completed since they're skipping)
+      await db.onboarding.create({
+        data: {
+          organizationId: orgId,
+          completed: true,
+        },
+      });
+
+      // Create Stripe customer for new org
+      const stripeCustomerId = await createStripeCustomer({
+        name: parsedInput.organizationName,
+        email: session.user.email,
+        organizationId: orgId,
+      });
+
+      if (stripeCustomerId) {
+        await db.organization.update({
+          where: { id: orgId },
+          data: { stripeCustomerId },
+        });
+      }
+
+      // Initialize frameworks if provided
+      if (parsedInput.frameworkIds && parsedInput.frameworkIds.length > 0) {
+        await initializeOrganization({
+          frameworkIds: parsedInput.frameworkIds,
+          organizationId: orgId,
+        });
+      }
+
+      // Set new org as active
+      await auth.api.setActiveOrganization({
+        headers: await headers(),
+        body: {
+          organizationId: orgId,
+        },
+      });
+
+      const userOrgs = await db.member.findMany({
+        where: {
+          userId: session.user.id,
+        },
+        select: {
+          organizationId: true,
+        },
+      });
+
+      for (const org of userOrgs) {
+        revalidatePath(`/${org.organizationId}`);
+      }
+
+      revalidatePath('/');
+      revalidatePath(`/${orgId}`);
+      revalidatePath('/setup');
+
+      return {
+        success: true,
+        organizationId: orgId,
+      };
+    } catch (error) {
+      console.error('Error during organization setup:', error);
+
+      // Return the actual error message for debugging
+      if (error instanceof Error) {
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+
+      return {
+        success: false,
+        error: 'Failed to setup organization',
+      };
+    }
+  });