Function fireAuthEvent

apps/web/src/lib/user/index.ts:329–413

(
  user: Pick<
    User,
    | 'id'
    | 'google_user_email'
    | 'created_at'
    | 'hosted_domain'
    | 'signup_ip'
    | 'is_admin'
    | 'is_bot'
    | 'blocked_at'
    | 'completed_welcome_form'
    | 'linkedin_url'
    | 'github_url'
    | 'discord_server_membership_verified_at'
    | 'customer_source'
    | 'cohorts'
    | 'has_validation_stytch'
    | 'has_validation_novel_card_with_hold'
  >,
  eventType: 'signup' | 'signin',
  provider: AuthProviderId,
  requestHeaders?: Headers
)

    return (await findUserById(args.provider_account_id)) ?? null;
  }

  const existing_kilo_user_id = await findUserIdByAuthProvider(
    args.provider,
    args.provider_account_id
  );
  if (!existing_kilo_user_id) {
    return null;
  }

  const existingUser = await findUserById(existing_kilo_user_id);
  assert(existingUser, `User not found for kiloUserId: ${existing_kilo_user_id}`);

  if (existingUser.hosted_domain !== args.hosted_domain) {
    //This really should only affect legacy users.
    await db
      .update(kilocode_users)
      .set({ hosted_domain: args.hosted_domain })
      .where(eq(kilocode_users.id, existingUser.id));
    console.log(
      `Updated hosted_domain for user ${existingUser.id}: ${existingUser.hosted_domain} -> ${args.hosted_domain}`
    );
    existingUser.hosted_domain = args.hosted_domain;
  }

  // Sync display_name from OAuth on every sign-in
  if (args.display_name) {
    await db
      .update(user_auth_provider)
      .set({ display_name: args.display_name })
      .where(
        and(
          eq(user_auth_provider.kilo_user_id, existingUser.id),
          eq(user_auth_provider.provider, args.provider),
          eq(user_auth_provider.provider_account_id, args.provider_account_id)
        )
      );
  }

  timer.log(`findFirst user with id ${existingUser.id}`);
  return existingUser;
}

export async function findUserByEmail(email: string): Promise<User | undefined> {
  return await db.query.kilocode_users.findFirst({
    where: eq(kilocode_users.google_user_email, email),
  });
}

export async function findUserByEmailCaseInsensitive(email: string): Promise<User[]> {
  return db.query.kilocode_users.findMany({
    where: eq(sql`lower(${kilocode_users.google_user_email})`, email.trim().toLowerCase()),
  });
}

export async function findUserByNormalizedEmail(email: string): Promise<User | undefined> {
  const normalizedEmail = normalizeEmail(email);
  return await db.query.kilocode_users.findFirst({
    where: or(