added objection and knex

Author: chescos

.env.example

@@ -1,2 +1,8 @@
 NODE_ENV=development
 PORT=3000
+
+DATABASE_URL=postgres://app:secret@localhost:5432/app
+DATABASE_DEBUG=true
+DATABASE_SSL=false
+DATABASE_MIN_CONNECTIONS=1
+DATABASE_MAX_CONNECTIONS=10

config/default.js

@@ -6,4 +6,16 @@ const { env } = process;
 module.exports = {
   env: env.NODE_ENV || 'development',
   port: env.PORT || 3000,
+
+  database: {
+    url: env.DATABASE_URL,
+    ssl: env.DATABASE_SSL === 'true',
+    debug: env.DATABASE_DEBUG === 'true',
+    queryTimeout: env.DYNO && env.DYNO.startsWith('web.') ? 20000 : 300000,
+    transactionTimeout: env.DYNO && env.DYNO.startsWith('web.') ? 20000 : 60000,
+    connections: {
+      min: parseInt(env.DATABASE_MIN_CONNECTIONS, 10) || 10,
+      max: parseInt(env.DATABASE_MAX_CONNECTIONS, 10) || 100,
+    },
+  },
 };

database/base/BaseModel.js

@@ -0,0 +1,28 @@
+const path = require('path');
+const { Model } = require('objection');
+const BaseQueryBuilder = require('./BaseQueryBuilder');
+
+class BaseModel extends Model {
+  static get modelPaths() {
+    return [path.join(__dirname, '..', 'models')];
+  }
+
+  static get QueryBuilder() {
+    return BaseQueryBuilder;
+  }
+
+  static get useLimitInFirst() {
+    return true;
+  }
+
+  $beforeInsert() {
+    this.created_at = new Date().toISOString();
+    this.updated_at = new Date().toISOString();
+  }
+
+  $beforeUpdate() {
+    this.updated_at = new Date().toISOString();
+  }
+}
+
+module.exports = BaseModel;

database/base/BaseQueryBuilder.js

@@ -0,0 +1,7 @@
+const { QueryBuilder } = require('objection');
+
+class BaseQueryBuilder extends QueryBuilder {
+
+}
+
+module.exports = BaseQueryBuilder;

database/index.js

@@ -0,0 +1,12 @@
+const Knex = require('knex');
+const { Model } = require('objection');
+const knexConfig = require('../knexfile.js');
+
+// Initialize knex.
+const knex = Knex(knexConfig);
+
+// Bind all Models to the knex instance.
+// This only needs to be done once before any models can be used.
+Model.knex(knex);
+
+module.exports = knex;

database/migrations/20200624203236_create_items.js

@@ -0,0 +1,16 @@
+exports.up = async (knex) => {
+  await knex.schema.createTable('items', (table) => {
+    table.increments('id');
+    table.string('name').notNullable().unique();
+    table.string('name_technical').notNullable().unique();
+    table.integer('defindex').notNullable().unique();
+    table.string('image_url').notNullable();
+    table.string('class').notNullable().index();
+    table.string('type').notNullable().index();
+    table.timestamps(false, true);
+  });
+};
+
+exports.down = async (knex) => {
+  await knex.schema.dropTable('items');
+};

database/migrations/20200624203241_create_paintkits.js

@@ -0,0 +1,13 @@
+exports.up = async (knex) => {
+  await knex.schema.createTable('paintkits', (table) => {
+    table.increments('id');
+    table.string('name').notNullable().index();
+    table.string('name_technical').notNullable().unique();
+    table.integer('defindex').notNullable().unique();
+    table.timestamps(false, true);
+  });
+};
+
+exports.down = async (knex) => {
+  await knex.schema.dropTable('paintkits');
+};

database/migrations/20200624203244_create_skins.js

@@ -0,0 +1,19 @@
+exports.up = async (knex) => {
+  await knex.schema.createTable('skins', (table) => {
+    table.increments('id');
+    table.integer('item_id').notNullable().index();
+    table.integer('paintkit_id').nullable().index();
+    table.string('name').notNullable().index();
+    table.string('name_technical').notNullable().unique();
+    table.string('image_url').notNullable();
+    table.timestamps(false, true);
+
+    table.foreign('item_id').references('id').inTable('items');
+    table.foreign('paintkit_id').references('id').inTable('paintkits');
+    table.unique(['item_id', 'paintkit_id']);
+  });
+};
+
+exports.down = async (knex) => {
+  await knex.schema.dropTable('skins');
+};

database/models/Item.js

@@ -0,0 +1,26 @@
+const Model = require('../base/BaseModel');
+
+class Item extends Model {
+  static get tableName() {
+    return 'items';
+  }
+
+  static get idColumn() {
+    return 'id';
+  }
+
+  static get relationMappings() {
+    return {
+      skins: {
+        relation: Model.HasManyRelation,
+        modelClass: 'Skin',
+        join: {
+          from: 'items.id',
+          to: 'skins.item_id',
+        },
+      },
+    };
+  }
+}
+
+module.exports = Item;

database/models/Paintkit.js

@@ -0,0 +1,26 @@
+const Model = require('../base/BaseModel');
+
+class Paintkit extends Model {
+  static get tableName() {
+    return 'paintkits';
+  }
+
+  static get idColumn() {
+    return 'id';
+  }
+
+  static get relationMappings() {
+    return {
+      skins: {
+        relation: Model.HasManyRelation,
+        modelClass: 'Skin',
+        join: {
+          from: 'paintkits.id',
+          to: 'skins.paintkit_id',
+        },
+      },
+    };
+  }
+}
+
+module.exports = Paintkit;

database/models/Skin.js

@@ -0,0 +1,35 @@
+const Model = require('../base/BaseModel');
+
+class Skin extends Model {
+  static get tableName() {
+    return 'skins';
+  }
+
+  static get idColumn() {
+    return 'id';
+  }
+
+  static get relationMappings() {
+    return {
+      item: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: 'Item',
+        join: {
+          from: 'skins.item_id',
+          to: 'items.id',
+        },
+      },
+
+      paintkit: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: 'Paintkit',
+        join: {
+          from: 'skins.paintkit_id',
+          to: 'paintkits.id',
+        },
+      },
+    };
+  }
+}
+
+module.exports = Skin;

docker-compose.yml

@@ -0,0 +1,14 @@
+version: '3.3'
+
+services:
+  postgres:
+    image: postgres:12
+    volumes:
+      - .:/app
+    environment:
+      POSTGRES_PASSWORD: secret
+      POSTGRES_USER: app
+      POSTGRES_DB: app
+      TZ: UTC
+    ports:
+      - 5432:5432

knexfile.js

@@ -0,0 +1,71 @@
+const config = require('config');
+const async = require('async');
+const pg = require('pg');
+
+// In order to enable SSL, it seems to be enough to set `pg.defaults.ssl`
+// to `true` or to an empty object. With Heroku however, we also need to
+// explicitly allow self-signed SSL certificates. That's why we set
+// `rejectUnauthorized` to `false`.
+if (config.get('database.ssl')) {
+  pg.defaults.ssl = {
+    rejectUnauthorized: false,
+  };
+}
+
+module.exports = {
+  client: 'pg',
+  connection: config.get('database.url'),
+  debug: config.get('database.debug'),
+  migrations: {
+    directory: './database/migrations',
+    tableName: 'knex_migrations',
+  },
+  seeds: {
+    directory: './database/seeds',
+  },
+  acquireConnectionTimeout: 10000,
+  pool: {
+    min: config.get('database.connections.min'),
+    max: config.get('database.connections.max'),
+    // This method can be used to execute SQL statements right after a
+    // connection has been established.
+    afterCreate: (conn, done) => {
+      const queries = [
+        // Terminate any session with an open transaction that has been idle
+        // for longer than the specified duration in milliseconds.
+        `set idle_in_transaction_session_timeout to ${config.get('database.transactionTimeout')};`,
+
+        // Abort any statement that takes more than the specified number of
+        // milliseconds, starting from the time the command arrives at the
+        // server from the client.
+        `set statement_timeout to ${config.get('database.queryTimeout')};`,
+      ];
+
+      async.eachSeries(queries, async (query) => new Promise((resolve, reject) => {
+        // Execute the query and wait for the callback to check if any
+        // error occurred.
+        conn.query(query, (error) => {
+          if (error) {
+            // The query returned an error, we'll have to abort the further
+            // execution of any remaining queries and return the error.
+            reject(error);
+          } else {
+            // The query successfully completed, we can execute the next one.
+            resolve();
+          }
+        });
+      }))
+        .then(() => {
+          // All queries have been successfully run and no error occurred.
+          // Tell Knex that we're done with the setup of the connection.
+          done(false, conn);
+        })
+        .catch((error) => {
+          // If `error` is not falsy, the connection is discarded from the pool.
+          // If connection acquire was triggered by a query, then the error is
+          // passed to query promise.
+          done(error, conn);
+        });
+    },
+  },
+};