@takaro/db 0.0.1

package/dist/queryBuilder.d.ts

@@ -0,0 +1,28 @@
+import { QueryBuilder as ObjectionQueryBuilder, Model as ObjectionModel, Page } from 'objection';
+export declare class ITakaroQuery<T> {
+    filters?: {
+        [key in keyof T]?: unknown[] | unknown;
+    };
+    search?: {
+        [key in keyof T]?: unknown[] | unknown;
+    };
+    page?: number;
+    limit?: number;
+    sortBy?: Extract<keyof T, string>;
+    sortDirection?: SortDirection;
+    startDate?: string;
+    endDate?: string;
+    extend?: string[];
+}
+export declare enum SortDirection {
+    asc = "asc",
+    desc = "desc"
+}
+export declare class QueryBuilder<Model extends ObjectionModel, OutputDTO> {
+    private readonly query;
+    constructor(query?: ITakaroQuery<OutputDTO>);
+    build(query: ObjectionQueryBuilder<Model, Model[]>): ObjectionQueryBuilder<Model, Page<Model>>;
+    private filters;
+    private sorting;
+    private pagination;
+}

package/dist/queryBuilder.js

@@ -0,0 +1,132 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsDateString, IsEnum, IsNumber, IsOptional, IsString } from 'class-validator';
+export class ITakaroQuery {
+}
+__decorate([
+    IsOptional(),
+    __metadata("design:type", Object)
+], ITakaroQuery.prototype, "filters", void 0);
+__decorate([
+    IsOptional(),
+    __metadata("design:type", Object)
+], ITakaroQuery.prototype, "search", void 0);
+__decorate([
+    IsOptional(),
+    IsNumber(),
+    __metadata("design:type", Number)
+], ITakaroQuery.prototype, "page", void 0);
+__decorate([
+    IsOptional(),
+    IsNumber(),
+    __metadata("design:type", Number)
+], ITakaroQuery.prototype, "limit", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", Object)
+], ITakaroQuery.prototype, "sortBy", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsEnum(['asc', 'desc']),
+    __metadata("design:type", String)
+], ITakaroQuery.prototype, "sortDirection", void 0);
+__decorate([
+    IsOptional(),
+    IsDateString(),
+    __metadata("design:type", String)
+], ITakaroQuery.prototype, "startDate", void 0);
+__decorate([
+    IsOptional(),
+    IsDateString(),
+    __metadata("design:type", String)
+], ITakaroQuery.prototype, "endDate", void 0);
+__decorate([
+    IsOptional(),
+    IsString({ each: true }),
+    __metadata("design:type", Array)
+], ITakaroQuery.prototype, "extend", void 0);
+export var SortDirection;
+(function (SortDirection) {
+    SortDirection["asc"] = "asc";
+    SortDirection["desc"] = "desc";
+})(SortDirection || (SortDirection = {}));
+export class QueryBuilder {
+    constructor(query = new ITakaroQuery()) {
+        this.query = query;
+    }
+    build(query) {
+        const tableName = query.modelClass().tableName;
+        const pagination = this.pagination();
+        const sorting = this.sorting();
+        let qry = query.page(pagination.page, pagination.limit).orderBy(sorting.sortBy, sorting.sortDirection);
+        if (this.query.startDate) {
+            qry = qry.where(`${tableName}.createdAt`, '>=', this.query.startDate);
+        }
+        if (this.query.endDate) {
+            qry = qry.where(`${tableName}.createdAt`, '<=', this.query.endDate);
+        }
+        qry = this.filters(tableName, qry);
+        if (this.query.search) {
+            qry.where((builder) => {
+                for (const search in this.query.search) {
+                    if (Object.prototype.hasOwnProperty.call(this.query.search, search)) {
+                        const searchVal = this.query.search[search];
+                        if (Array.isArray(searchVal)) {
+                            searchVal.forEach((val) => {
+                                if (val) {
+                                    builder.orWhere(`${tableName}.${search}`, 'ilike', `%${val}%`);
+                                }
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        for (const extend of this.query.extend ?? []) {
+            qry.withGraphFetched(extend);
+        }
+        return qry;
+    }
+    filters(tableName, query) {
+        for (const filter in this.query.filters) {
+            if (Object.prototype.hasOwnProperty.call(this.query.filters, filter)) {
+                const searchVal = this.query.filters[filter];
+                if (searchVal && Array.isArray(searchVal)) {
+                    const filtered = searchVal.filter(Boolean);
+                    if (filtered.length) {
+                        query.whereIn(`${tableName}.${filter}`, searchVal.filter(Boolean));
+                    }
+                }
+            }
+        }
+        return query;
+    }
+    sorting() {
+        if (!this.query.sortBy) {
+            return {
+                sortBy: 'id',
+                sortDirection: SortDirection.asc,
+            };
+        }
+        return {
+            sortBy: this.query.sortBy,
+            sortDirection: this.query.sortDirection ?? SortDirection.asc,
+        };
+    }
+    pagination() {
+        return {
+            page: this.query.page ?? 0,
+            limit: this.query.limit ?? 100,
+        };
+    }
+}
+//# sourceMappingURL=queryBuilder.js.map

package/dist/queryBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryBuilder.js","sourceRoot":"","sources":["../src/queryBuilder.ts"],"names":[],"mappings":"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"}

package/dist/redis.d.ts

@@ -0,0 +1,20 @@
+import { createClient, RedisClientOptions } from 'redis';
+type RedisClient = ReturnType<typeof createClient>;
+declare class RedisClass {
+    private log;
+    private clients;
+    /**
+     * Get a Redis client from the cache, or create a new one.
+     * The client will already be connected.
+     * @param name Name for the client, used to cache the client.
+     * @param extra Any extra Redis options to pass to the client.
+     * @returns
+     */
+    getClient(name: string, extra?: RedisClientOptions): Promise<RedisClient>;
+    /**
+     * Disconnect all clients and clear the cache.
+     */
+    destroy(): Promise<void>;
+}
+export declare const Redis: RedisClass;
+export {};

package/dist/redis.js

@@ -0,0 +1,49 @@
+import { createClient } from 'redis';
+import { config } from './config.js';
+import { logger, health } from '@takaro/util';
+class RedisClass {
+    constructor() {
+        this.log = logger('redis');
+        this.clients = new Map();
+    }
+    /**
+     * Get a Redis client from the cache, or create a new one.
+     * The client will already be connected.
+     * @param name Name for the client, used to cache the client.
+     * @param extra Any extra Redis options to pass to the client.
+     * @returns
+     */
+    async getClient(name, extra = {}) {
+        const cachedClient = this.clients.get(name);
+        if (cachedClient)
+            return cachedClient;
+        this.log.debug(`Creating new Redis client for ${name}`);
+        const client = createClient({
+            name,
+            username: config.get('redis.username'),
+            password: config.get('redis.password'),
+            socket: {
+                host: config.get('redis.host'),
+                port: config.get('redis.port'),
+            },
+            ...extra,
+        });
+        await client.connect();
+        this.clients.set(name, client);
+        health.registerHook(name, async () => {
+            await client.ping();
+        });
+        return client;
+    }
+    /**
+     * Disconnect all clients and clear the cache.
+     */
+    async destroy() {
+        for (const [name, client] of this.clients.entries()) {
+            this.log.debug(`Disconnecting Redis client ${name}`);
+            await client.disconnect();
+        }
+    }
+}
+export const Redis = new RedisClass();
+//# sourceMappingURL=redis.js.map

package/dist/redis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.js","sourceRoot":"","sources":["../src/redis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAsB,MAAM,OAAO,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAI9C,MAAM,UAAU;IAAhB;QACU,QAAG,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAEtB,YAAO,GAAG,IAAI,GAAG,EAAuB,CAAC;IA8CnD,CAAC;IA5CC;;;;;;OAMG;IACH,KAAK,CAAC,SAAS,CAAC,IAAY,EAAE,QAA4B,EAAE;QAC1D,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAE5C,IAAI,YAAY;YAAE,OAAO,YAAY,CAAC;QAEtC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,iCAAiC,IAAI,EAAE,CAAC,CAAC;QAExD,MAAM,MAAM,GAAG,YAAY,CAAC;YAC1B,IAAI;YACJ,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC;YACtC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC;YACtC,MAAM,EAAE;gBACN,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC;gBAC9B,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC;aAC/B;YACD,GAAG,KAAK;SACT,CAAC,CAAC;QAEH,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;QACvB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAE/B,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;YACnC,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO;QACX,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;YACpD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,8BAA8B,IAAI,EAAE,CAAC,CAAC;YACrD,MAAM,MAAM,CAAC,UAAU,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;CACF;AAED,MAAM,CAAC,MAAM,KAAK,GAAG,IAAI,UAAU,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@takaro/db",
+  "version": "0.0.1",
+  "description": "An opinionated data layer",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "type": "module",
+  "scripts": {
+    "start:dev": "tsc --watch --preserveWatchOutput -p ./tsconfig.build.json",
+    "build": "tsc -p ./tsconfig.build.json",
+    "test": "npm run test:unit --if-present && npm run test:integration --if-present",
+    "test:unit": "echo 'No tests (yet :))'",
+    "test:integration": "mocha --config ../../.mocharc.js src/**/*.integration.test.ts --exit",
+    "migrate:create": "run(){ touch ./src/migrations/sql/$(date -u +\"%Y%m%d%H%M%S\")-$1.ts; }; run"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "convict": "^6.2.3",
+    "knex": "^2.2.0",
+    "objection": "^3.0.1",
+    "pg": "^8.8.0"
+  },
+  "devDependencies": {
+    "@takaro/test": "0.0.1",
+    "@types/convict": "^6.1.1"
+  }
+}

package/src/TakaroModel.ts

@@ -0,0 +1,32 @@
+import Objection, { Model } from 'objection';
+
+export class NOT_DOMAIN_SCOPED_TakaroModel extends Model {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+
+  static get idColumn() {
+    return 'id';
+  }
+
+  $beforeInsert() {
+    this.createdAt = new Date().toISOString();
+  }
+
+  $beforeUpdate() {
+    this.updatedAt = new Date().toISOString();
+  }
+}
+
+export class TakaroModel extends NOT_DOMAIN_SCOPED_TakaroModel {
+  domain: string;
+
+  static get modifiers() {
+    return {
+      domainScoped(query: Objection.QueryBuilder<Model>, domainId: string) {
+        const tableName = query.modelClass().tableName;
+        query.where(`${tableName}.domain`, domainId);
+      },
+    };
+  }
+}

package/src/__tests__/encryption.integration.test.ts

@@ -0,0 +1,56 @@
+import { compareHashed, decrypt, encrypt, hash } from '../encryption.js';
+import { expect } from '@takaro/test';
+import { getKnex } from '../knex.js';
+
+describe('Database encryption', () => {
+  before(async () => {
+    const knex = await getKnex();
+    await knex.raw('CREATE EXTENSION IF NOT EXISTS pgcrypto;');
+  });
+
+  describe('Encryption', () => {
+    it('Can encrypt a simple string', async () => {
+      const encrypted = await encrypt('test');
+      expect(encrypted).to.not.eq('test');
+    });
+
+    it('Can decrypt a simple string', async () => {
+      const encrypted = await encrypt('test');
+      const decrypted = await decrypt(encrypted);
+      expect(decrypted).to.eq('test');
+    });
+
+    it('Can handle complex JSON structures', async () => {
+      const encrypted = await encrypt(JSON.stringify({ foo: 'bar' }));
+      const decrypted = await decrypt(encrypted);
+      expect(decrypted).to.eq(JSON.stringify({ foo: 'bar' }));
+    });
+
+    it('Can handle very long values', async () => {
+      const longValue = 'a'.repeat(10000);
+      const encrypted = await encrypt(longValue);
+      const decrypted = await decrypt(encrypted);
+      expect(decrypted).to.eq(longValue);
+    });
+  });
+
+  describe('Hashing', async () => {
+    it('Can hash a simple string', async () => {
+      const hashed = await hash('test');
+      expect(hashed).to.not.eq('test');
+      expect(hashed).to.match(/^\$2a\$06\$/);
+    });
+
+    it('Can compare a simple string', async () => {
+      const hashed = await hash('test');
+      const result = await compareHashed('test', hashed);
+      expect(result).to.eq(true);
+    });
+
+    it('Returns false when comparing different strings', async () => {
+      const hashed = await hash('test');
+      const result = await compareHashed('test2', hashed);
+      expect(result).to.eq(false);
+    });
+  });
+});

package/src/__tests__/queryBuilder.integration.test.ts

@@ -0,0 +1,202 @@
+import { disconnectKnex, getKnex } from '../knex.js';
+import { QueryBuilder, SortDirection } from '../queryBuilder.js';
+import { expect } from '@takaro/test';
+import { TakaroModel } from '../TakaroModel.js';
+import { Model } from 'objection';
+import { sleep } from '@takaro/util';
+
+const TEST_TABLE_USERS_NAME = 'test_users';
+const TEST_TABLE_POSTS_NAME = 'test_posts';
+
+class TestPostModel extends TakaroModel {
+  static tableName = TEST_TABLE_POSTS_NAME;
+  title!: string;
+  userId!: string;
+
+  static relationMappings = {
+    author: {
+      relation: Model.HasOneRelation,
+      modelClass: () => TestUserModel,
+      join: {
+        from: `${TEST_TABLE_POSTS_NAME}.userId`,
+        to: `${TEST_TABLE_USERS_NAME}.id`,
+      },
+    },
+  };
+}
+
+class TestUserModel extends TakaroModel {
+  static tableName = TEST_TABLE_USERS_NAME;
+  name!: string;
+
+  static relationMappings = {
+    posts: {
+      relation: Model.HasManyRelation,
+      modelClass: TestPostModel,
+      join: {
+        from: `${TEST_TABLE_USERS_NAME}.id`,
+        to: `${TEST_TABLE_POSTS_NAME}.userId`,
+      },
+    },
+  };
+}
+
+describe('QueryBuilder', () => {
+  beforeEach(async () => {
+    const knex = await getKnex();
+    await knex.schema.dropTableIfExists(TEST_TABLE_USERS_NAME);
+    await knex.schema.dropTableIfExists(TEST_TABLE_POSTS_NAME);
+    await knex.schema.createTable(TEST_TABLE_USERS_NAME, (table) => {
+      table.timestamps(true, true, true);
+      table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+      table.string('name');
+    });
+    await knex.schema.createTable(TEST_TABLE_POSTS_NAME, (table) => {
+      table.timestamps(true, true, true);
+      table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+      table.string('title');
+      table.uuid('userId');
+    });
+
+    TestUserModel.knex(knex);
+    TestPostModel.knex(knex);
+  });
+
+  afterEach(async () => {
+    const knex = await getKnex();
+    await knex.schema.dropTableIfExists(TEST_TABLE_USERS_NAME);
+    await disconnectKnex();
+  });
+
+  it('Can create basic filters', async () => {
+    await TestUserModel.query().insert({ name: 'test1' });
+    await TestUserModel.query().insert({ name: 'test2' });
+    await TestUserModel.query().insert({ name: 'test3' });
+
+    const res = await new QueryBuilder<TestUserModel, TestUserModel>({
+      filters: { name: ['test2'] },
+    }).build(TestUserModel.query());
+
+    expect(res.results).to.have.lengthOf(1);
+    expect(res.results[0].name).to.equal('test2');
+  });
+
+  it('Can filter based on multiple values', async () => {
+    await TestUserModel.query().insert({ name: 'test1' });
+    await TestUserModel.query().insert({ name: 'test2' });
+    await TestUserModel.query().insert({ name: 'test3' });
+
+    const res = await new QueryBuilder<TestUserModel, TestUserModel>({
+      filters: { name: ['test2', 'test3'] },
+      sortBy: 'name',
+    }).build(TestUserModel.query());
+
+    expect(res.results).to.have.lengthOf(2);
+    expect(res.results[0].name).to.equal('test2');
+    expect(res.results[1].name).to.equal('test3');
+  });
+
+  it('Can do paging', async () => {
+    const totalTestRecords = 100;
+
+    for (let i = 0; i < totalTestRecords; i++) {
+      const number = i.toString().padStart(3, '0');
+      await TestUserModel.query().insert({ name: `test${number}` });
+    }
+
+    const res = await new QueryBuilder<TestUserModel, TestUserModel>({
+      page: 2,
+      limit: 10,
+      sortBy: 'name',
+      sortDirection: SortDirection.asc,
+    }).build(TestUserModel.query());
+
+    expect(res.results).to.have.lengthOf(10);
+    expect(res.results[0].name).to.equal('test020');
+    expect(res.total).to.equal(totalTestRecords);
+  });
+
+  it('Can do sorting', async () => {
+    await TestUserModel.query().insert({ name: 'test1' });
+    await TestUserModel.query().insert({ name: 'test2' });
+    await TestUserModel.query().insert({ name: 'test3' });
+
+    const res = await new QueryBuilder<TestUserModel, TestUserModel>({
+      sortBy: 'name',
+      sortDirection: SortDirection.desc,
+    }).build(TestUserModel.query());
+
+    expect(res.results).to.have.lengthOf(3);
+    expect(res.results[0].name).to.equal('test3');
+  });
+
+  it('Can do extending', async () => {
+    const user = await TestUserModel.query().insert({ name: 'test1' });
+    await TestPostModel.query().insert({ title: 'test1', userId: user.id });
+
+    const res = await new QueryBuilder<
+      TestPostModel & { author?: TestUserModel },
+      TestPostModel & { author?: TestUserModel }
+    >({ extend: ['author'] }).build(TestPostModel.query());
+
+    expect(res.results).to.have.lengthOf(1);
+    expect(res.results[0].author?.name).to.equal('test1');
+  });
+
+  it('Can do partial matching of strings', async () => {
+    await TestUserModel.query().insert({ name: 'test1' });
+    await TestUserModel.query().insert({ name: 'test2' });
+    await TestUserModel.query().insert({ name: 'test3' });
+
+    const res = await new QueryBuilder<TestUserModel, TestUserModel>({
+      search: {
+        name: ['test'],
+      },
+    }).build(TestUserModel.query());
+
+    expect(res.results).to.have.lengthOf(3);
+
+    const res2 = await new QueryBuilder<TestUserModel, TestUserModel>({
+      search: {
+        name: ['1'],
+      },
+    }).build(TestUserModel.query());
+
+    expect(res2.results).to.have.lengthOf(1);
+  });
+
+  it('Can search for multiple values, ORs them', async () => {
+    await TestUserModel.query().insert({ name: 'test1' });
+    await TestUserModel.query().insert({ name: 'test2' });
+    await TestUserModel.query().insert({ name: 'test3' });
+
+    const res = await new QueryBuilder<TestUserModel, TestUserModel>({
+      search: {
+        name: ['st1', 'st2'],
+      },
+    }).build(TestUserModel.query());
+
+    expect(res.results).to.have.lengthOf(2);
+  });
+
+  it('Can search between a date range', async () => {
+    const start = new Date();
+    await TestUserModel.query().insert({ name: 'test1' });
+    await TestUserModel.query().insert({ name: 'test2' });
+
+    const end = new Date();
+
+    // Quick hack to make the test pass
+    // Relying on times like this with an external DB is troublesome...
+    await sleep(250);
+
+    await TestUserModel.query().insert({ name: 'test3', createdAt: end.toISOString() });
+
+    const res = await new QueryBuilder<TestUserModel, TestUserModel>({
+      startDate: start.toISOString(),
+      endDate: end.toISOString(),
+    }).build(TestUserModel.query());
+
+    expect(res.results).to.have.lengthOf(2);
+  });
+});

package/src/config.ts

@@ -0,0 +1,101 @@
+import { Config, IBaseConfig, baseConfigConvict } from '@takaro/config';
+
+export interface IDbConfig extends IBaseConfig {
+  postgres: {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+  };
+  redis: {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+  };
+  systemSchema: string;
+  baseDomainSchema: string;
+  encryptionKey: string;
+}
+
+export const configSchema = {
+  postgres: {
+    host: {
+      doc: 'The Postgres host to connect to',
+      format: String,
+      default: 'localhost',
+      env: 'POSTGRES_HOST',
+    },
+    port: {
+      doc: 'The Postgres port to connect to',
+      format: Number,
+      default: 5432,
+      env: 'POSTGRES_PORT',
+    },
+    user: {
+      doc: 'The Postgres user to connect as',
+      format: String,
+      default: 'postgres',
+      env: 'POSTGRES_USER',
+    },
+    password: {
+      doc: 'The Postgres password to use',
+      format: String,
+      default: 'postgres',
+      env: 'POSTGRES_PASSWORD',
+    },
+    database: {
+      doc: 'The Postgres database to use',
+      format: String,
+      default: 'postgres',
+      env: 'POSTGRES_DB',
+    },
+  },
+  redis: {
+    host: {
+      doc: 'The host of the redis server',
+      format: String,
+      default: 'localhost',
+      env: 'REDIS_HOST',
+    },
+    port: {
+      doc: 'The port of the redis server',
+      format: Number,
+      default: 6379,
+      env: 'REDIS_PORT',
+    },
+    username: {
+      doc: 'The username of the redis server',
+      format: String,
+      default: '',
+      env: 'REDIS_USERNAME',
+    },
+    password: {
+      doc: 'The password of the redis server',
+      format: String,
+      default: '',
+      env: 'REDIS_PASSWORD',
+    },
+  },
+  systemSchema: {
+    doc: 'The Postgres schema to use for system-related actions (like domain management)',
+    format: String,
+    default: 'takaro',
+    env: 'POSTGRES_SYSTEM_SCHEMA',
+  },
+  baseDomainSchema: {
+    doc: 'String used as base for creating name of domain-scoped schemas',
+    format: String,
+    default: 'domain_',
+    env: 'POSTGRES_BASE_DOMAIN_SCHEMA',
+  },
+  encryptionKey: {
+    doc: 'Encryption key used for encrypting sensitive data',
+    format: String,
+    default: null,
+    env: 'POSTGRES_ENCRYPTION_KEY',
+  },
+};
+
+export const config = new Config<IDbConfig>([configSchema, baseConfigConvict]);