First

Author: kylealwyn

.env

@@ -0,0 +1 @@
+DATABASE_URL=postgres://localhost/books

.eslintrc.yml

@@ -0,0 +1,41 @@
+extends:
+  - airbnb-base
+  - plugin:prettier/recommended
+env:
+  node: true
+parser: typescript-eslint-parser
+parserOptions:
+  ecmaVersion: 7
+  sourceType: module
+  ecmaFeatures:
+    modules: true
+plugins:
+  - import
+  - typescript
+  - prettier
+  - security
+rules:
+  strict: 0
+  object-curly-spacing:
+    - error
+    - always
+
+  # Follow up: https://github.com/eslint/typescript-eslint-parser/issues/416
+  no-undef: 0
+  no-use-before-define: 0
+  no-restricted-globals: 0
+
+  import/extensions: 0
+settings:
+  import/resolver:
+    node:
+      extensions:
+        - .ts
+        - .tsx
+        - .d.ts
+        - .js
+        - .json
+
+  import/parsers:
+    typescript-eslint-parser:
+      - .ts

.gitignore

@@ -0,0 +1,4 @@
+.env
+node_modules
+yarn-error.log
+.DS_STORE

.prettierrc.yml

@@ -0,0 +1,9 @@
+printWidth: 120
+parser: typescript
+semi: true
+useTabs: false
+singleQuote: true
+trailingComma: es5
+bracketSpacing: true
+jsxBracketSameLine: true
+

db/migrations/20180128104235_initial.js

@@ -0,0 +1,19 @@
+exports.up = async knex =>
+  knex.schema
+    .createTable('authors', table => {
+      table.increments('id');
+      table.string('firstName');
+      table.string('lastName');
+    })
+    .createTable('books', table => {
+      table.increments('id');
+      table.string('title');
+      table
+        .integer('authorId')
+        .unsigned()
+        .references('authors.id')
+        .onDelete('CASCADE')
+        .onUpdate('CASCADE');
+    });
+
+exports.down = async knex => knex.schema.dropTableIfExists('books').dropTableIfExists('authors');

knexfile.js

@@ -0,0 +1,37 @@
+const parse = require('connection-string');
+const _ = require('lodash');
+
+require('dotenv').config();
+
+const connection = parse(process.env.DATABASE_URL);
+
+const defaults = {
+  client: 'pg',
+  connection: {
+    user: connection.user || 'root',
+    password: connection.password || '',
+    host: connection.host,
+    port: connection.port || 5432,
+    database: connection.segments[0],
+  },
+  migrations: {
+    directory: `${__dirname}/db/migrations`,
+  },
+  seeds: {
+    directory: `${__dirname}/db/seeds`,
+  },
+  debug: false,
+};
+
+const environments = {
+  production: {
+    pool: {
+      min: 2,
+      max: 10,
+    },
+  },
+};
+
+const config = _.merge(defaults, environments[process.env.NODE_ENV]);
+
+module.exports = config;

nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src"],
+  "ext": "ts json",
+  "ignore": ["src/**/*.spec.ts"],
+  "exec": "ts-node ./src/main.ts"
+}

package.json

@@ -0,0 +1,43 @@
+{
+  "scripts": {
+    "start": "nodemon",
+    "debug": "nodemon",
+    "knex": "ts-node ./node_modules/.bin/knex"
+  },
+  "dependencies": {
+    "apollo-server-express": "^1.3.2",
+    "body-parser": "^1.18.2",
+    "connection-string": "^0.4.1",
+    "core-js": "^2.5.3",
+    "dotenv": "^4.0.0",
+    "express": "^4.16.2",
+    "graphql": "^0.12.3",
+    "graphql-tools": "^2.19.0",
+    "knex": "^0.14.2",
+    "lodash": "^4.17.4",
+    "morgan": "^1.9.0",
+    "pg": "^7.4.1"
+  },
+  "devDependencies": {
+    "@types/body-parser": "^1.16.8",
+    "@types/express": "^4.11.0",
+    "@types/knex": "^0.14.4",
+    "@types/node": "^9.4.0",
+    "ava": "^0.25.0",
+    "eslint": "^4.16.0",
+    "eslint-config-airbnb-base": "^12.1.0",
+    "eslint-config-google": "^0.9.1",
+    "eslint-config-prettier": "^2.9.0",
+    "eslint-import-resolver-typescript": "^1.0.2",
+    "eslint-plugin-import": "^2.8.0",
+    "eslint-plugin-prettier": "^2.5.0",
+    "eslint-plugin-security": "^1.4.0",
+    "eslint-plugin-typescript": "^0.8.1",
+    "nodemon": "^1.14.11",
+    "prettier": "^1.10.2",
+    "ts-node": "^4.1.0",
+    "tslint": "^5.9.1",
+    "typescript": "^2.6.2",
+    "typescript-eslint-parser": "^12.0.0"
+  }
+}

src/database.ts

@@ -0,0 +1,35 @@
+import * as _ from 'lodash';
+import * as Knex from 'knex';
+import * as knexfile from '../knexfile';
+
+class Database {
+  private knexInstance: Knex;
+  private config: Object;
+
+  public connect(options = {}): void {
+    if (this.knexInstance) {
+      return;
+    }
+    this.config = _.merge({}, knexfile, options);
+    this.knexInstance = Knex(this.config);
+  }
+
+  public get query(): Knex {
+    if (!this.knexInstance) {
+      this.connect();
+    }
+
+    return this.knexInstance;
+  }
+
+  public close(done): void {
+    if (!this.knexInstance) {
+      done();
+      return;
+    }
+
+    this.knexInstance.destroy(done);
+  }
+}
+
+export default new Database();

src/main.ts

@@ -0,0 +1,17 @@
+import Server from './server';
+import Database from './database';
+
+Database.connect();
+Server.start();
+
+const shutdown = done => {
+  Database.close(() => {
+    Server.stop(done);
+  });
+};
+
+// Nodemon
+process.once('SIGUSR2', shutdown.bind(null, process.exit));
+process.on('exit', shutdown.bind(null, process.exit));
+process.on('SIGINT', shutdown.bind(null, process.exit));
+process.on('uncaughtException', shutdown.bind(null, process.exit));

src/schema/author/index.ts

@@ -0,0 +1,54 @@
+import db from '../../database';
+
+export const type = `
+type Author {
+  id: ID!,
+  firstName: String,
+  lastName: String
+
+  books(limit: Int, offset: Int): [Book]
+}
+`;
+
+export const queries = {
+  author: {
+    definition: `author(firstName: String): Author!`,
+    resolve(root, { firstName = '' }) {
+      return db
+        .query('authors')
+        .where({ firstName })
+        .first();
+    },
+  },
+  authors: {
+    definition: 'authors: [Author]!',
+    resolve: () => db.query('authors'),
+  },
+};
+
+export const mutations = {
+  createAuthor: {
+    definition: `createAuthor(firstName: String!, lastName: String!): Author`,
+    async resolve(root, args) {
+      const [author] = await db
+        .query('authors')
+        .insert(args)
+        .returning('*');
+
+      return author;
+    },
+  },
+};
+
+export const resolvers = {
+  Author: {
+    books(author, { limit = 100, offset = 0 }) {
+      // TODO: Only query for selected fields (d.fieldNodes[0].selectionSet.selections)
+      return db
+        .query('books')
+        .where({ authorId: author.id })
+        .limit(limit)
+        .offset(offset);
+    },
+  },
+};

src/schema/book/index.ts

@@ -0,0 +1,55 @@
+import db from '../../database';
+
+export const type = `
+type Book {
+  id: ID!,
+  title: String
+  author: Author
+}
+`;
+
+export const queries = {
+  book: {
+    definition: 'book(title: String): Book',
+    resolve(root, { title = '' }) {
+      return db
+        .query('books')
+        .where({ title })
+        .first();
+    },
+  },
+  books: {
+    definition: 'books(limit: Int): [Book]',
+    resolve(root, { limit = 100, offset = 0 }) {
+      return db
+        .query('books')
+        .limit(limit)
+        .offset(offset);
+    },
+  },
+};
+
+export const mutations = {
+  createBook: {
+    definition: `createBook(title: String!, authorId: ID!): Book`,
+    async resolve(root, args) {
+      const [book] = await db
+        .query('books')
+        .insert(args)
+        .returning('*');
+
+      return book;
+    },
+  },
+};
+
+export const resolvers = {
+  Book: {
+    author(book): Object {
+      return db
+        .query('authors')
+        .where({ id: book.authorId })
+        .first();
+    },
+  },
+};