Auto-register template creators as referrers in echo-start

packages/app/control/scripts/seed-test-referral-data.ts

@@ -0,0 +1,108 @@
+/**
+ * Script to seed test data for local template referral testing
+ * 
+ * Creates:
+ * - Test user with GitHub link
+ * - Test app with membership
+ * - Returns app ID for use with echo-start
+ */
+
+import { PrismaClient } from '../src/generated/prisma/index.js';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  console.log('Seeding test data for template referral system...\n');
+
+  // Create or get test user
+  const testEmail = '[email protected]';
+  let user = await prisma.user.findUnique({
+    where: { email: testEmail },
+    include: { githubLink: true },
+  });
+
+  if (!user) {
+    console.log('Creating test user...');
+    user = await prisma.user.create({
+      data: {
+        email: testEmail,
+        name: 'Test Template User',
+        githubLink: {
+          create: {
+            githubId: 123456,
+            githubType: 'user',
+            githubUrl: 'https://github.com/Trynax',
+          },
+        },
+      },
+      include: { githubLink: true },
+    });
+    console.log(`Created user: ${user.email} (ID: ${user.id})`);
+  } else {
+    console.log(`Found existing user: ${user.email} (ID: ${user.id})`);
+
+    // Ensure GitHub link exists
+    if (!user.githubLink) {
+      await prisma.githubLink.create({
+        data: {
+          userId: user.id,
+          githubId: 123456,
+          githubType: 'user',
+          githubUrl: 'https://github.com/Trynax',
+        },
+      });
+      console.log('✅ Added GitHub link for Trynax');
+    }
+  }
+
+  // Create or get test app
+  const testAppName = 'Test Template Referral App';
+  let app = await prisma.echoApp.findFirst({
+    where: { name: testAppName },
+    include: { appMemberships: true },
+  });
+
+  if (!app) {
+    console.log('\nCreating test app...');
+    app = await prisma.echoApp.create({
+      data: {
+        name: testAppName,
+        appMemberships: {
+          create: {
+            userId: user.id,
+            role: 'OWNER',
+            totalSpent: 0,
+          },
+        },
+      },
+      include: { appMemberships: true },
+    });
+    console.log(`Created app: ${app.name} (ID: ${app.id})`);
+  } else {
+    console.log(`\nFound existing app: ${app.name} (ID: ${app.id})`);
+  }
+
+  console.log('\nTest Data Summary:');
+  console.log('─────────────────────────────────────────────────────');
+  console.log(`User ID:        ${user.id}`);
+  console.log(`User Email:     ${user.email}`);
+  console.log(`GitHub URL:     ${user.githubLink?.githubUrl || 'https://github.com/Trynax'}`);
+  console.log(`App ID:         ${app.id}`);
+  console.log(`App Name:       ${app.name}`);
+  console.log('─────────────────────────────────────────────────────');
+
+  console.log('\nTest Command:');
+  console.log(`cd /tmp && /root/developments/opensource/echo/packages/sdk/echo-start/dist/index.js \\`);
+  console.log(`  --template https://github.com/Trynax/commitcraft \\`);
+  console.log(`  --app-id ${app.id} \\`);
+  console.log(`  test-echo-local\n`);
+}
+
+main()
+  .catch((e) => {
+    console.error('Error seeding data:', e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });

packages/app/control/src/app/api/v1/referrals/register-template/route.ts

@@ -0,0 +1,76 @@
+import { NextResponse, NextRequest } from 'next/server';
+import {
+  registerTemplateReferral,
+  registerTemplateReferralSchema,
+} from '@/services/db/apps/template-referral';
+import { db } from '@/services/db/client';
+import { AppRole } from '@/services/db/apps/permissions/types';
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const validatedData = registerTemplateReferralSchema.parse(body);
+    const { appId, githubUsername, templateUrl } = validatedData;
+
+    const app = await db.echoApp.findUnique({
+      where: { id: appId },
+      include: {
+        appMemberships: {
+          where: { role: AppRole.OWNER },
+          take: 1,
+        },
+      },
+    });
+
+    if (!app || app.appMemberships.length === 0) {
+      return NextResponse.json(
+        { success: false, message: 'App not found' },
+        { status: 404 }
+      );
+    }
+
+    const userId = app.appMemberships[0].userId;
+
+    const result = await registerTemplateReferral(userId, {
+      appId,
+      githubUsername,
+      templateUrl,
+    });
+
+    if (result.status === 'registered') {
+      return NextResponse.json({
+        success: true,
+        status: 'registered',
+        message: `Template creator ${result.referrerUsername} registered as referrer`,
+        referrerUsername: result.referrerUsername,
+      });
+    }
+
+    if (result.status === 'skipped') {
+      return NextResponse.json({
+        success: true,
+        status: 'skipped',
+        message: result.reason || 'Referral skipped',
+        reason: result.reason,
+      });
+    }
+
+    return NextResponse.json({
+      success: true,
+      status: 'not_found',
+      message: result.reason || 'Template creator not found on Echo',
+      reason: result.reason,
+    });
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : 'Unknown error occurred';
+
+    return NextResponse.json(
+      {
+        success: false,
+        message,
+      },
+      { status: 400 }
+    );
+  }
+}

packages/app/control/src/services/db/apps/template-referral.ts

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+import { db } from '@/services/db/client';
+import { appIdSchema } from './lib/schemas';
+import { AppRole } from './permissions/types';
+
+export const registerTemplateReferralSchema = z.object({
+  appId: appIdSchema,
+  githubUsername: z.string().min(1),
+  templateUrl: z.string().url(),
+});
+
+export type RegisterTemplateReferralInput = z.infer<
+  typeof registerTemplateReferralSchema
+>;
+
+export interface RegisterTemplateReferralResult {
+  status: 'registered' | 'skipped' | 'not_found';
+  reason?: string;
+  referrerUsername?: string;
+  referralCodeId?: string;
+}
+
+export async function registerTemplateReferral(
+  userId: string,
+  input: RegisterTemplateReferralInput
+): Promise<RegisterTemplateReferralResult> {
+  const { appId, githubUsername, templateUrl } = input;
+
+  const app = await db.echoApp.findUnique({
+    where: { id: appId },
+    include: {
+      appMemberships: {
+        where: {
+          userId,
+          role: AppRole.OWNER,
+        },
+      },
+    },
+  });
+
+  if (!app || app.appMemberships.length === 0) {
+    throw new Error('App not found or user is not the owner');
+  }
+
+  const membership = await db.appMembership.findUnique({
+    where: {
+      userId_echoAppId: {
+        userId,
+        echoAppId: appId,
+      },
+    },
+    select: {
+      referrerId: true,
+    },
+  });
+
+  if (!membership) {
+    throw new Error('App membership not found');
+  }
+
+  if (membership.referrerId) {
+    return {
+      status: 'skipped',
+      reason: 'existing_referrer',
+    };
+  }
+
+  const githubLink = await db.githubLink.findFirst({
+    where: {
+      githubUrl: {
+        contains: githubUsername,
+      },
+      githubType: 'user',
+      isArchived: false,
+    },
+    include: {
+      user: {
+        select: {
+          id: true,
+          name: true,
+        },
+      },
+    },
+  });
+
+  if (!githubLink || !githubLink.user) {
+    return {
+      status: 'not_found',
+      reason: 'template_creator_not_on_echo',
+    };
+  }
+
+  let referralCode = await db.referralCode.findFirst({
+    where: {
+      userId: githubLink.user.id,
+      isArchived: false,
+    },
+    select: {
+      id: true,
+    },
+  });
+
+  if (!referralCode) {
+    const code = crypto.randomUUID();
+    const expiresAt = new Date();
+    expiresAt.setFullYear(expiresAt.getFullYear() + 1);
+
+    referralCode = await db.referralCode.create({
+      data: {
+        code,
+        userId: githubLink.user.id,
+        expiresAt,
+      },
+      select: {
+        id: true,
+      },
+    });
+  }
+
+  await db.appMembership.update({
+    where: {
+      userId_echoAppId: {
+        userId,
+        echoAppId: appId,
+      },
+    },
+    data: {
+      referrerId: referralCode.id,
+    },
+  });
+
+  return {
+    status: 'registered',
+    referrerUsername: githubUsername,
+    referralCodeId: referralCode.id,
+  };
+}