refactor(db-config): Use typeorm-style options

TypeORM does not use a separate config option for the path
to the SQLite file.
Additionally, the "dialect" is called "type."

This commit adjusts our config to follow the upstream convention
to reduce confusion.

Signed-off-by: David Mehren <git@herrmehren.de>

docs/content/config/index.md

@@ -56,14 +56,13 @@ We officially support and test these databases:
 - MariaDB
 
 | environment variable  | default | example             | description                                                                                |
-|------------------------|---------|---------------------|-----------------------------------------------------------------------------------------------|
-| `HD_DATABASE_DIALECT`  | -       | `postgres`          | The database dialect you want to use. This can be `postgres`, `mysql`, `mariadb` or `sqlite`. |
+|-----------------------|---------|---------------------|--------------------------------------------------------------------------------------------|
+| `HD_DATABASE_TYPE`    | -       | `postgres`          | The database type you want to use. This can be `postgres`, `mysql`, `mariadb` or `sqlite`. |
+| `HD_DATABASE_NAME`    | -       | `hedgedoc`          | The name of the database to use. When using SQLite, this is the path to the database file. |
 | `HD_DATABASE_HOST`    | -       | `db.example.com`    | The host, where the database runs. *Only if you're **not** using `sqlite`.*                |
 | `HD_DATABASE_PORT`    | -       | `5432`              | The port, where the database runs. *Only if you're **not** using `sqlite`.*                |
-| `HD_DATABASE_NAME`     | -       | `hedgedoc`          | The name of the database to use. *Only if you're **not** using `sqlite`.*                     |
 | `HD_DATABASE_USER`    | -       | `hedgedoc`          | The user that logs in the database. *Only if you're **not** using `sqlite`.*               |
 | `HD_DATABASE_PASS`    | -       | `password`          | The password to log into the database. *Only if you're **not** using `sqlite`.*            |
-| `HD_DATABASE_STORAGE`  | -       | `./hedgedoc.sqlite` | The location of the database file. *Only if you're using `sqlite`.*                           |
 
 ## External services
 

src/config/database-type.enum.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-export enum DatabaseDialect {
+export enum DatabaseType {
   POSTGRES = 'postgres',
   MYSQL = 'mysql',
   MARIADB = 'mariadb',

src/config/database.config.ts

@@ -6,7 +6,7 @@
 import { registerAs } from '@nestjs/config';
 import * as Joi from 'joi';
 
-import { DatabaseDialect } from './database-dialect.enum';
+import { DatabaseType } from './database-type.enum';
 import { buildErrorMessage, parseOptionalNumber } from './utils';
 
 export interface DatabaseConfig {
@@ -15,56 +15,48 @@ export interface DatabaseConfig {
   database: string;
   host: string;
   port: number;
-  storage: string;
-  dialect: DatabaseDialect;
+  type: DatabaseType;
 }
 
 const databaseSchema = Joi.object({
-  username: Joi.when('dialect', {
-    is: Joi.invalid(DatabaseDialect.SQLITE),
+  type: Joi.string()
+    .valid(...Object.values(DatabaseType))
+    .label('HD_DATABASE_TYPE'),
+
+  // This is the database name, except for SQLite,
+  // where it is the path to the database file.
+  database: Joi.string().label('HD_DATABASE_NAME'),
+  username: Joi.when('type', {
+    is: Joi.invalid(DatabaseType.SQLITE),
     then: Joi.string(),
     otherwise: Joi.optional(),
   }).label('HD_DATABASE_USER'),
-  password: Joi.when('dialect', {
-    is: Joi.invalid(DatabaseDialect.SQLITE),
+  password: Joi.when('type', {
+    is: Joi.invalid(DatabaseType.SQLITE),
     then: Joi.string(),
     otherwise: Joi.optional(),
   }).label('HD_DATABASE_PASS'),
-  database: Joi.when('dialect', {
-    is: Joi.invalid(DatabaseDialect.SQLITE),
-    then: Joi.string(),
-    otherwise: Joi.optional(),
-  }).label('HD_DATABASE_NAME'),
-  host: Joi.when('dialect', {
-    is: Joi.invalid(DatabaseDialect.SQLITE),
+  host: Joi.when('type', {
+    is: Joi.invalid(DatabaseType.SQLITE),
     then: Joi.string(),
     otherwise: Joi.optional(),
   }).label('HD_DATABASE_HOST'),
-  port: Joi.when('dialect', {
-    is: Joi.invalid(DatabaseDialect.SQLITE),
+  port: Joi.when('type', {
+    is: Joi.invalid(DatabaseType.SQLITE),
     then: Joi.number(),
     otherwise: Joi.optional(),
   }).label('HD_DATABASE_PORT'),
-  storage: Joi.when('dialect', {
-    is: Joi.valid(DatabaseDialect.SQLITE),
-    then: Joi.string(),
-    otherwise: Joi.optional(),
-  }).label('HD_DATABASE_STORAGE'),
-  dialect: Joi.string()
-    .valid(...Object.values(DatabaseDialect))
-    .label('HD_DATABASE_DIALECT'),
 });
 
 export default registerAs('databaseConfig', () => {
   const databaseConfig = databaseSchema.validate(
     {
+      type: process.env.HD_DATABASE_TYPE,
       username: process.env.HD_DATABASE_USER,
       password: process.env.HD_DATABASE_PASS,
       database: process.env.HD_DATABASE_NAME,
       host: process.env.HD_DATABASE_HOST,
       port: parseOptionalNumber(process.env.HD_DATABASE_PORT),
-      storage: process.env.HD_DATABASE_STORAGE,
-      dialect: process.env.HD_DATABASE_DIALECT,
     },
     {
       abortEarly: false,

src/config/mock/database.config.mock.ts

@@ -5,18 +5,18 @@
  */
 import { registerAs } from '@nestjs/config';
 
-import { DatabaseDialect } from '../database-dialect.enum';
+import { DatabaseType } from '../database-type.enum';
 import { DatabaseConfig } from '../database.config';
 
 export default registerAs(
   'databaseConfig',
   (): DatabaseConfig => ({
-    dialect: (process.env.HEDGEDOC_TEST_DB_TYPE || 'sqlite') as DatabaseDialect,
+    type: (process.env.HEDGEDOC_TEST_DB_TYPE ||
+      DatabaseType.SQLITE) as DatabaseType,
     database: 'hedgedoc',
     password: 'hedgedoc',
     host: 'localhost',
     port: 0,
-    storage: '',
     username: 'hedgedoc',
   }),
 );

src/utils/session.ts

@@ -10,7 +10,7 @@ import session from 'express-session';
 import { Repository } from 'typeorm';
 
 import { AuthConfig } from '../config/auth.config';
-import { DatabaseDialect } from '../config/database-dialect.enum';
+import { DatabaseType } from '../config/database-type.enum';
 import { DatabaseConfig } from '../config/database.config';
 import { Session } from '../users/session.entity';
 
@@ -36,7 +36,7 @@ export function setupSessionMiddleware(
       saveUninitialized: false,
       store: new TypeormStore({
         cleanupLimit: 2,
-        limitSubquery: dbConfig.dialect !== DatabaseDialect.MARIADB,
+        limitSubquery: dbConfig.type !== DatabaseType.MARIADB,
       }).connect(app.get<Repository<Session>>(getRepositoryToken(Session))),
     }),
   );

test/app.e2e-spec.ts

@@ -33,8 +33,8 @@ describe('App', () => {
       })
       .overrideProvider(getConfigToken('databaseConfig'))
       .useValue({
-        storage: ':memory:',
-        dialect: 'sqlite',
+        database: ':memory:',
+        type: 'sqlite',
       })
       .overrideProvider(getConfigToken('authConfig'))
       .useValue({