feat: add postgres support + migrations

.github/ISSUE_TEMPLATE/bug.yml

@@ -55,6 +55,14 @@ body:
         - tablet
     validations:
       required: true
+  - type: dropdown
+    id: database
+    attributes:
+      options:
+        - SQLite (default)
+        - PostgreSQL
+      label: Database
+      description: Which database backend are you using?
   - type: input
     id: device
     attributes:

README.md

@@ -47,6 +47,54 @@ _*On Jellyfin/Emby, ensure the `Settings > Home > Automatically group content fr
 Check out our docker hub for instructions on how to install and run Jellyseerr:
 https://hub.docker.com/r/fallenbagel/jellyseerr
 
+### Database configuration
+
+Jellyseerr supports sqlite and postgres. The database connection can be configured using the following options:
+
+#### SQLite Options
+
+```dotenv
+DB_TYPE="sqlite" # Which DB engine to use. The default is "sqlite"
+CONFIG_DIRECTORY="config" # The path to the config directory where the db file is stored
+DB_LOG_QUERIES="false" # Whether to log the DB queries for debugging
+```
+
+#### PostgreSQL Options
+
+```dotenv
+DB_TYPE="postgres" # Which DB engine to use. The default is "sqlite". To use postgres, this needs to be set to "postgres"
+DB_HOST= # The host (url) of the database
+DB_PORT="5432" # The port to connect to
+DB_USER= # Username used to connect to the database
+DB_PASS= # Password of the user used to connect to the database
+DB_NAME="jellyseerr" # The name of the database to connect to
+DB_LOG_QUERIES="false" # Whether to log the DB queries for debugging
+DB_USE_SSL="false" # Whether to enable ssl for database connection
+
+# The following options can be used to further configure ssl:
+DB_SSL_REJECT_UNAUTHORIZED="true" # Whether to reject ssl connections with unverifiable certificates i.e. self-signed certificates without providing the below settings
+DB_SSL_CA= # The CA certificate to verify the connection, provided as a string
+DB_SSL_CA_FILE= # The path to a CA certificate to verify the connection
+DB_SSL_KEY= # The private key for the connection in PEM format, provided as a string
+DB_SSL_KEY_FILE= # Path to the private key for the connection in PEM format
+DB_SSL_CERT= # Certificate chain in pem format for the private key, provided as a string
+DB_SSL_CERT_FILE= # Path to certificate chain in pem format for the private key
+```
+
+#### Migrating from SQLite to PostgreSQL
+
+1. Set up your PostgreSQL database and configure Jellyseerr to use it
+2. Run Jellyseerr to create the tables in the PostgreSQL database
+3. Stop Jellyseerr
+4. Run the following command to export the data from the SQLite database and import it into the PostgreSQL database:
+   - Edit the postgres connection string to match your setup
+   - WARNING: The most recent release of pgloader has an issue quoting the table columns. Use the version in the docker container to avoid this issue.
+   - "I don't have or don't want to use docker" - You can build the working pgloader version [in this PR](https://github.com/dimitri/pgloader/pull/1531) from source and use the same options as below.
+   ```bash
+   docker run --rm -v config/db.sqlite3:/db.sqlite3:ro -v pgloader/pgloader.load:/pgloader.load ghcr.io/ralgar/pgloader:pr-1531 pgloader --with "quote identifiers" --with "data only" /db.sqlite3 postgresql://{{DB_USER}}:{{DB_PASS}}@{{DB_HOST}}:{{DB_PORT}}/{{DB_NAME}}
+   ```
+5. Start Jellyseerr
+
 ### Building from source (ADVANCED):
 
 #### Windows

docker-compose.postgres.yaml

@@ -0,0 +1,38 @@
+---
+version: '3.8'
+services:
+  jellyseerr:
+    build:
+      context: .
+      dockerfile: Dockerfile.local
+    ports:
+      - '5055:5055'
+    environment:
+      DB_TYPE: 'postgres' # Which DB engine to use. The default is "sqlite". To use postgres, this needs to be set to "postgres"
+      DB_HOST: 'postgres' # The host (url) of the database
+      DB_PORT: '5432' # The port to connect to
+      DB_USER: 'jellyseerr' # Username used to connect to the database
+      DB_PASS: 'jellyseerr' # Password of the user used to connect to the database
+      DB_NAME: 'jellyseerr' # The name of the database to connect to
+      DB_LOG_QUERIES: 'false' # Whether to log the DB queries for debugging
+      DB_USE_SSL: 'false' # Whether to enable ssl for database connection
+    volumes:
+      - .:/app:rw,cached
+      - /app/node_modules
+      - /app/.next
+    depends_on:
+      - postgres
+    links:
+      - postgres
+  postgres:
+    image: postgres
+    environment:
+      POSTGRES_USER: jellyseerr
+      POSTGRES_PASSWORD: jellyseerr
+      POSTGRES_DB: jellyseerr
+    ports:
+      - '5432:5432'
+    volumes:
+      - postgres:/var/lib/postgresql/data
+volumes:
+  postgres:

package.json

@@ -69,6 +69,7 @@
     "node-schedule": "2.1.1",
     "nodemailer": "6.9.1",
     "openpgp": "5.7.0",
+    "pg": "8.11.0",
     "plex-api": "5.3.2",
     "pug": "3.0.2",
     "react": "18.2.0",

server/datasource.ts

@@ -1,18 +1,55 @@
-import 'reflect-metadata';
+import fs from 'fs';
+import * as process from 'process';
+import type { TlsOptions } from 'tls';
 import type { DataSourceOptions, EntityTarget, Repository } from 'typeorm';
 import { DataSource } from 'typeorm';
 
+const DB_SSL_PREFIX = 'DB_SSL_';
+
+function boolFromEnv(envVar: string, defaultVal = false) {
+  if (process.env[envVar]) {
+    return process.env[envVar]?.toLowerCase() === 'true';
+  }
+  return defaultVal;
+}
+
+function stringOrReadFileFromEnv(envVar: string): Buffer | string | undefined {
+  if (process.env[envVar]) {
+    return process.env[envVar];
+  }
+  const filePath = process.env[`${envVar}_FILE`];
+  if (filePath) {
+    return fs.readFileSync(filePath);
+  }
+  return undefined;
+}
+
+function buildSslConfig(): TlsOptions | undefined {
+  if (process.env.DB_USE_SSL?.toLowerCase() !== 'true') {
+    return undefined;
+  }
+  return {
+    rejectUnauthorized: boolFromEnv(
+      `${DB_SSL_PREFIX}REJECT_UNAUTHORIZED`,
+      true
+    ),
+    ca: stringOrReadFileFromEnv(`${DB_SSL_PREFIX}CA`),
+    key: stringOrReadFileFromEnv(`${DB_SSL_PREFIX}KEY`),
+    cert: stringOrReadFileFromEnv(`${DB_SSL_PREFIX}CERT`),
+  };
+}
+
 const devConfig: DataSourceOptions = {
   type: 'sqlite',
   database: process.env.CONFIG_DIRECTORY
     ? `${process.env.CONFIG_DIRECTORY}/db/db.sqlite3`
     : 'config/db/db.sqlite3',
   synchronize: true,
   migrationsRun: false,
-  logging: false,
+  logging: boolFromEnv('DB_LOG_QUERIES'),
   enableWAL: true,
   entities: ['server/entity/**/*.ts'],
-  migrations: ['server/migration/**/*.ts'],
+  migrations: ['server/migration/sqlite/**/*.ts'],
   subscribers: ['server/subscriber/**/*.ts'],
 };
 
@@ -23,16 +60,60 @@ const prodConfig: DataSourceOptions = {
     : 'config/db/db.sqlite3',
   synchronize: false,
   migrationsRun: false,
-  logging: false,
+  logging: boolFromEnv('DB_LOG_QUERIES'),
   enableWAL: true,
   entities: ['dist/entity/**/*.js'],
-  migrations: ['dist/migration/**/*.js'],
+  migrations: ['dist/migration/sqlite/**/*.js'],
   subscribers: ['dist/subscriber/**/*.js'],
 };
 
-const dataSource = new DataSource(
-  process.env.NODE_ENV !== 'production' ? devConfig : prodConfig
-);
+const postgresDevConfig: DataSourceOptions = {
+  type: 'postgres',
+  host: process.env.DB_HOST,
+  port: parseInt(process.env.DB_PORT ?? '5432'),
+  username: process.env.DB_USER,
+  password: process.env.DB_PASS,
+  database: process.env.DB_NAME ?? 'jellyseerr',
+  ssl: buildSslConfig(),
+  synchronize: false,
+  migrationsRun: true,
+  logging: boolFromEnv('DB_LOG_QUERIES'),
+  entities: ['server/entity/**/*.ts'],
+  migrations: ['server/migration/postgres/**/*.ts'],
+  subscribers: ['server/subscriber/**/*.ts'],
+};
+
+const postgresProdConfig: DataSourceOptions = {
+  type: 'postgres',
+  host: process.env.DB_HOST,
+  port: parseInt(process.env.DB_PORT ?? '5432'),
+  username: process.env.DB_USER,
+  password: process.env.DB_PASS,
+  database: process.env.DB_NAME ?? 'jellyseerr',
+  ssl: buildSslConfig(),
+  synchronize: false,
+  migrationsRun: false,
+  logging: boolFromEnv('DB_LOG_QUERIES'),
+  entities: ['dist/entity/**/*.js'],
+  migrations: ['dist/migration/postgres/**/*.js'],
+  subscribers: ['dist/subscriber/**/*.js'],
+};
+
+export const isPgsql = process.env.DB_TYPE === 'postgres';
+
+function getDataSource(): DataSourceOptions {
+  if (process.env.NODE_ENV === 'production') {
+    if (isPgsql) {
+      return postgresProdConfig;
+    }
+    return prodConfig;
+  } else if (isPgsql) {
+    return postgresDevConfig;
+  }
+  return devConfig;
+}
+
+const dataSource = new DataSource(getDataSource());
 
 export const getRepository = <Entity extends object>(
   target: EntityTarget<Entity>

server/entity/Media.ts

@@ -9,6 +9,7 @@ import type { DownloadingItem } from '@server/lib/downloadtracker';
 import downloadTracker from '@server/lib/downloadtracker';
 import { getSettings } from '@server/lib/settings';
 import logger from '@server/logger';
+import { DbAwareColumn } from '@server/utils/DbColumnHelper';
 import { getHostname } from '@server/utils/getHostname';
 import {
   AfterLoad,
@@ -122,10 +123,10 @@ class Media {
   @UpdateDateColumn()
   public updatedAt: Date;
 
-  @Column({ type: 'datetime', default: () => 'CURRENT_TIMESTAMP' })
+  @DbAwareColumn({ type: 'datetime', default: () => 'CURRENT_TIMESTAMP' })
   public lastSeasonChange: Date;
 
-  @Column({ type: 'datetime', nullable: true })
+  @DbAwareColumn({ type: 'datetime', nullable: true })
   public mediaAddedAt: Date;
 
   @Column({ nullable: true, type: 'int' })

server/entity/MediaRequest.ts

@@ -376,6 +376,7 @@ export class MediaRequest {
   @ManyToOne(() => Media, (media) => media.requests, {
     eager: true,
     onDelete: 'CASCADE',
+    nullable: false,
   })
   public media: Media;
 
@@ -848,7 +849,7 @@ export class MediaRequest {
             const requestRepository = getRepository(MediaRequest);
 
             this.status = MediaRequestStatus.FAILED;
-            requestRepository.save(this);
+            await requestRepository.save(this);
 
             logger.warn(
               'Something went wrong sending movie request to Radarr, marking status as FAILED',
@@ -1123,13 +1124,14 @@ export class MediaRequest {
             media[this.is4k ? 'externalServiceSlug4k' : 'externalServiceSlug'] =
               sonarrSeries.titleSlug;
             media[this.is4k ? 'serviceId4k' : 'serviceId'] = sonarrSettings?.id;
+
             await mediaRepository.save(media);
           })
           .catch(async () => {
             const requestRepository = getRepository(MediaRequest);
 
             this.status = MediaRequestStatus.FAILED;
-            requestRepository.save(this);
+            await requestRepository.save(this);
 
             logger.warn(
               'Something went wrong sending series request to Sonarr, marking status as FAILED',

server/entity/Season.ts

@@ -23,7 +23,10 @@ class Season {
   @Column({ type: 'int', default: MediaStatus.UNKNOWN })
   public status4k: MediaStatus;
 
-  @ManyToOne(() => Media, (media) => media.seasons, { onDelete: 'CASCADE' })
+  @ManyToOne(() => Media, (media) => media.seasons, {
+    onDelete: 'CASCADE',
+    nullable: false,
+  })
   public media: Promise<Media>;
 
   @CreateDateColumn()

server/entity/Watchlist.ts

@@ -53,6 +53,7 @@ export class Watchlist implements WatchlistItem {
   @ManyToOne(() => Media, (media) => media.watchlists, {
     eager: true,
     onDelete: 'CASCADE',
+    nullable: false,
   })
   public media: Media;
 

server/index.ts

@@ -1,5 +1,5 @@
 import PlexAPI from '@server/api/plexapi';
-import dataSource, { getRepository } from '@server/datasource';
+import dataSource, { getRepository, isPgsql } from '@server/datasource';
 import DiscoverSlider from '@server/entity/DiscoverSlider';
 import { Session } from '@server/entity/Session';
 import { User } from '@server/entity/User';
@@ -75,9 +75,13 @@ app
 
     // Run migrations in production
     if (process.env.NODE_ENV === 'production') {
-      await dbConnection.query('PRAGMA foreign_keys=OFF');
-      await dbConnection.runMigrations();
-      await dbConnection.query('PRAGMA foreign_keys=ON');
+      if (isPgsql) {
+        await dbConnection.runMigrations();
+      } else {
+        await dbConnection.query('PRAGMA foreign_keys=OFF');
+        await dbConnection.runMigrations();
+        await dbConnection.query('PRAGMA foreign_keys=ON');
+      }
     }
 
     // Load Settings