main.wasp

app CinemaVerse {
  wasp: {
    version: "^0.16.0"
  },

  title: "CinemaVerse - Movie & TV Tracking Platform",

  head: [
    "<link rel='icon' href='/favicon.ico' />",
    "<meta charset='utf-8' />",
    "<meta name='description' content='Track your favorite movies and TV shows with AI-powered recommendations.' />",
    "<meta name='author' content='CinemaVerse' />",
    "<meta name='keywords' content='movies, tv shows, tracking, watchlist, recommendations, entertainment' />",
    
    "<meta property='og:type' content='website' />",
    "<meta property='og:title' content='CinemaVerse - Movie & TV Tracking Platform' />",
    "<meta property='og:site_name' content='CinemaVerse' />",
    "<meta property='og:url' content='https://cinemaverse.app' />",
    "<meta property='og:description' content='Track your favorite movies and TV shows with AI-powered recommendations.' />",
    "<meta property='og:image' content='https://cinemaverse.app/public-banner.webp' />",
    "<meta name='twitter:image' content='https://cinemaverse.app/public-banner.webp' />",
    "<meta name='twitter:image:width' content='800' />",
    "<meta name='twitter:image:height' content='400' />",
    "<meta name='twitter:card' content='summary_large_image' />",
    // TODO: You can put your Plausible analytics scripts below (https://docs.opensaas.sh/guides/analytics/):
    // NOTE: Plausible does not use Cookies, so you can simply add the scripts here.
    // Google, on the other hand, does, so you must instead add the script dynamically
    // via the Cookie Consent component after the user clicks the "Accept" cookies button.
    "<script defer data-domain='<your-site-id>' src='https://plausible.io/js/script.js'></script>",  // for production
    "<script defer data-domain='<your-site-id>' src='https://plausible.io/js/script.local.js'></script>",  // for development
  ],

  // 🔐 Auth out of the box! https://wasp.sh/docs/auth/overview
  auth: {
    userEntity: User,
    methods: {
      // NOTE: If you decide to not use email auth, make sure to also delete the related routes and pages below.
      //   (RequestPasswordReset(Route|Page), PasswordReset(Route|Page), EmailVerification(Route|Page))
      email: {
        fromField: {
          name: "Open SaaS App",
          email: "me@example.com"
        },
        emailVerification: {
          clientRoute: EmailVerificationRoute,
          getEmailContentFn: import { getVerificationEmailContent } from "@src/auth/email-and-pass/emails",
        },
        passwordReset: {
          clientRoute: PasswordResetRoute,
          getEmailContentFn: import { getPasswordResetEmailContent } from "@src/auth/email-and-pass/emails",
        },
        userSignupFields: import { getEmailUserFields } from "@src/auth/userSignupFields",
      },
      // Google OAuth for CinemaVerse
      google: {
        userSignupFields: import { getGoogleUserFields } from "@src/auth/userSignupFields",
        configFn: import { getGoogleAuthConfig } from "@src/auth/userSignupFields",
      },
      // Uncomment to enable GitHub Auth (check https://wasp.sh/docs/auth/social-auth/github for setup instructions):
      // gitHub: {
      //   userSignupFields: import { getGitHubUserFields } from "@src/auth/userSignupFields",
      //   configFn: import { getGitHubAuthConfig } from "@src/auth/userSignupFields",
      // },
      // Uncomment to enable Discord Auth (check https://wasp.sh/docs/auth/social-auth/discord for setup instructions):
      // discord: {
      //   userSignupFields: import { getDiscordUserFields } from "@src/auth/userSignupFields",
      //   configFn: import { getDiscordAuthConfig } from "@src/auth/userSignupFields"
      // }
    },
    onAuthFailedRedirectTo: "/login",
    onAuthSucceededRedirectTo: "/search",
  },

  db: {
    // Run `wasp db seed` to seed the database with the seed functions below:
    seeds: [
      // Populates the database with a bunch of fake users to work with during development.
      import { seedMockUsers } from "@src/server/scripts/dbSeeds",
    ]
  },

  client: {
    rootComponent: import App from "@src/client/App",
  },

  emailSender: {
    // NOTE: "Dummy" provider is just for local development purposes.
    //   Make sure to check the server logs for the email confirmation url (it will not be sent to an address)!
    //   Once you are ready for production, switch to e.g. "SendGrid" or "Mailgun" providers. Check out https://docs.opensaas.sh/guides/email-sending/ .
    provider: SendGrid,
    defaultFrom: {
      name: "CinemaVerse",
      // When using a real provider, e.g. SendGrid, you must use the same email address that you configured your account to send out emails with!
      email: "noreply@cinemaverse.app"
    },
  },
}

route LandingPageRoute { path: "/", to: LandingPage }
page LandingPage {
  component: import LandingPage from "@src/landing-page/LandingPage"
}

//#region Public CinemaVerse Pages
route DiscoverRoute { path: "/discover", to: DiscoverPage }
page DiscoverPage {
  component: import DiscoverPage from "@src/features/discover/DiscoverPage"
}

route MoviesRoute { path: "/movies", to: MoviesPage }
page MoviesPage {
  component: import MoviesPage from "@src/features/movies/MoviesPage"
}

route TVShowsRoute { path: "/tv-shows", to: TVShowsPage }
page TVShowsPage {
  component: import TVShowsPage from "@src/features/tv-shows/TVShowsPage"
}

route GenresRoute { path: "/genres", to: GenresPage }
page GenresPage {
  component: import GenresPage from "@src/features/genres/GenresPage"
}
//#endregion

//#region CinemaVerse Core Features
route SearchRoute { path: "/search", to: SearchPage }
page SearchPage {
  authRequired: true,
  component: import SearchPage from "@src/features/search/SearchPage"
}

route WatchlistRoute { path: "/watchlist", to: WatchlistPage }
page WatchlistPage {
  authRequired: true,
  component: import WatchlistPage from "@src/features/watchlist/WatchlistPage"
}

route RecommendationsRoute { path: "/recommendations", to: RecommendationsPage }
page RecommendationsPage {
  authRequired: true,
  component: import RecommendationsPage from "@src/features/ai/RecommendationsPage"
}

route OnboardingRoute { path: "/onboarding", to: OnboardingPage }
page OnboardingPage {
  authRequired: true,
  component: import OnboardingPage from "@src/features/onboarding/OnboardingPage"
}

route ForumRoute { path: "/forum", to: ForumPage }
page ForumPage {
  authRequired: true,
  component: import ForumPage from "@src/features/forum/ForumPage"
}

route MovieDetailsRoute { path: "/movie/:movieId", to: MovieDetailsPage }
page MovieDetailsPage {
  component: import MovieDetailsPage from "@src/features/details/MovieDetailsPage"
}

route TVDetailsRoute { path: "/tv/:tvId", to: TVDetailsPage }
page TVDetailsPage {
  component: import TVDetailsPage from "@src/features/details/TVDetailsPage"
}
//#endregion

//#region Auth Pages
route LoginRoute { path: "/login", to: LoginPage }
page LoginPage {
  component: import Login from "@src/auth/LoginPage"
}

route SignupRoute { path: "/signup", to: SignupPage }
page SignupPage {
  component: import { Signup } from "@src/auth/SignupPage"
}

route RequestPasswordResetRoute { path: "/request-password-reset", to: RequestPasswordResetPage }
page RequestPasswordResetPage {
  component: import { RequestPasswordResetPage } from "@src/auth/email-and-pass/RequestPasswordResetPage",
}

route PasswordResetRoute { path: "/password-reset", to: PasswordResetPage }
page PasswordResetPage {
  component: import { PasswordResetPage } from "@src/auth/email-and-pass/PasswordResetPage",
}

route EmailVerificationRoute { path: "/email-verification", to: EmailVerificationPage }
page EmailVerificationPage {
  component: import { EmailVerificationPage } from "@src/auth/email-and-pass/EmailVerificationPage",
}
//#endregion

//#region User
route AccountRoute { path: "/account", to: AccountPage }
page AccountPage {
  authRequired: true,
  component: import Account from "@src/user/AccountPage"
}

query getPaginatedUsers {
  fn: import { getPaginatedUsers } from "@src/user/operations",
  entities: [User]
}

action updateIsUserAdminById {
  fn: import { updateIsUserAdminById } from "@src/user/operations",
  entities: [User]
}
//#endregion

//#region CinemaVerse Operations
query searchTMDB {
  fn: import { searchTMDB } from "@src/features/search/operations",
  entities: []
}

query getTrendingContent {
  fn: import { getTrendingContent } from "@src/features/search/operations",
  entities: []
}

query getWatchlist {
  fn: import { getWatchlist } from "@src/features/watchlist/operations",
  entities: [WatchItem, Episode]
}

action addToWatchlist {
  fn: import { addToWatchlist } from "@src/features/watchlist/operations",
  entities: [WatchItem]
}

action updateWatchItem {
  fn: import { updateWatchItem } from "@src/features/watchlist/operations",
  entities: [WatchItem]
}

action removeFromWatchlist {
  fn: import { removeFromWatchlist } from "@src/features/watchlist/operations",
  entities: [WatchItem]
}

// Episode Management Operations
query getEpisodes {
  fn: import { getEpisodes } from "@src/features/watchlist/operations",
  entities: [WatchItem, Episode]
}

action updateEpisode {
  fn: import { updateEpisode } from "@src/features/watchlist/operations",
  entities: [Episode, WatchItem]
}

action bulkUpdateEpisodes {
  fn: import { bulkUpdateEpisodes } from "@src/features/watchlist/operations",
  entities: [Episode, WatchItem]
}

action syncEpisodes {
  fn: import { syncEpisodes } from "@src/features/watchlist/operations",
  entities: [Episode, WatchItem]
}

// AI Operations
query getRecommendations {
  fn: import { getRecommendations } from "@src/features/ai/operations",
  entities: [WatchItem]
}

action generateSummary {
  fn: import { generateSummary } from "@src/features/ai/operations",
  entities: []
}

action generateReview {
  fn: import { generateReview } from "@src/features/ai/operations",
  entities: []
}

// Forum Operations
query getDiscussion {
  fn: import { getDiscussion } from "@src/features/forum/operations",
  entities: [Discussion]
}

query getComments {
  fn: import { getComments } from "@src/features/forum/operations",
  entities: [Comment, Discussion]
}

action createDiscussion {
  fn: import { createDiscussion } from "@src/features/forum/operations",
  entities: [Discussion]
}

action createComment {
  fn: import { createComment } from "@src/features/forum/operations",
  entities: [Comment, Discussion]
}

action updateComment {
  fn: import { updateComment } from "@src/features/forum/operations",
  entities: [Comment]
}

action deleteComment {
  fn: import { deleteComment } from "@src/features/forum/operations",
  entities: [Comment]
}

action likeComment {
  fn: import { likeComment } from "@src/features/forum/operations",
  entities: [Comment]
}

action dislikeComment {
  fn: import { dislikeComment } from "@src/features/forum/operations",
  entities: [Comment]
}

query getMovieDetails {
  fn: import { getMovieDetails } from "@src/features/details/operations",
  entities: []
}

query getTVDetails {
  fn: import { getTVDetails } from "@src/features/details/operations",
  entities: []
}

// Onboarding Operations
query createGuestSession {
  fn: import { createGuestSession } from "@src/features/onboarding/operations",
  entities: []
}

query getUserOnboarding {
  fn: import { getUserOnboarding } from "@src/features/onboarding/operations",
  entities: [UserOnboarding]
}

action updateUserOnboarding {
  fn: import { updateUserOnboarding } from "@src/features/onboarding/operations",
  entities: [UserOnboarding]
}
//#endregion

//#region Payment
route PricingPageRoute { path: "/pricing", to: PricingPage }
page PricingPage {
  component: import PricingPage from "@src/payment/PricingPage"
}

route CheckoutRoute { path: "/checkout", to: CheckoutPage }
page CheckoutPage {
  authRequired: true,
  component: import Checkout from "@src/payment/CheckoutPage"
}

query getCustomerPortalUrl {
  fn: import { getCustomerPortalUrl } from  "@src/payment/operations",
  entities: [User]
}

action generateCheckoutSession {
  fn: import { generateCheckoutSession } from "@src/payment/operations",
  entities: [User]
}

api paymentsWebhook {
  fn: import { paymentsWebhook } from "@src/payment/webhook",
  entities: [User],
  middlewareConfigFn: import { paymentsMiddlewareConfigFn } from "@src/payment/webhook",
  httpRoute: (POST, "/payments-webhook")
}
//#endregion





route NotFoundRoute { path: "*", to: NotFoundPage }
page NotFoundPage {
  component: import { NotFoundPage } from "@src/client/components/NotFoundPage"
}