create-epic-graphql-server 0.5.0

package/src/schema/schema.ts

@@ -0,0 +1,227 @@
+const {
+  GraphQLObjectType,
+  GraphQLInputObjectType,
+  GraphQLID,
+  GraphQLString,
+  GraphQLSchema,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLEnumType,
+} = require('graphql')
+const db = require('../config/db')
+import type { Customer } from '../models/Customer'
+import type { Order } from '../models/Order'
+import { Product, Status } from '../typing/enums'
+
+// https://graphql.org/graphql-js/constructing-types/
+
+const customerType = new GraphQLObjectType({
+  name: 'Customer',
+  fields: {
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    email: { type: GraphQLString },
+    phone: { type: GraphQLString },
+  },
+})
+
+const orderType = new GraphQLObjectType({
+  name: 'Order',
+  fields: () => ({
+    id: { type: GraphQLID },
+    name: { type: GraphQLString },
+    notes: { type: GraphQLString },
+    status: { type: GraphQLString },
+    // NOTE creates relationship with other type
+    customer: {
+      type: customerType,
+      resolve(parent: Order, args: Customer) {
+        return db.customers.findById(parent.customerId)
+      },
+    },
+  }),
+})
+
+const orderFilterInput = new GraphQLInputObjectType({
+  name: 'OrderFilterInput',
+  fields: {
+    name: { type: GraphQLString },
+    status: { type: GraphQLString },
+    customerId: { type: GraphQLID },
+  },
+})
+
+const customerFilterInput = new GraphQLInputObjectType({
+  name: 'CustomerFilterInput',
+  fields: {
+    name: { type: GraphQLString },
+    email: { type: GraphQLString },
+    phone: { type: GraphQLString },
+  },
+})
+
+const queryType = new GraphQLObjectType({
+  name: 'Query',
+  fields: {
+    orders: {
+      type: new GraphQLList(orderType),
+      args: {
+        filter: { type: orderFilterInput },
+      },
+      resolve(parent: unknown, { filter }: { filter: Order }) {
+        return db.orders.find({ filter })
+      },
+      // NOTE:
+      // GraphQL efficiently resolves only the fields 
+      // requested by the client, but whether it fetches 
+      // only those fields from the data source depends 
+      // entirely on how resolvers are implemented...
+      // the example resolver implementation shown below 
+      // may avoid over fetching from a database or API
+      //
+      // resolve(parent, { filter }, context, info) {
+      //   const fields = info
+      //     .fieldNodes[0]
+      //     .selectionSet
+      //     .selections
+      //     .map(s => s.name.value)
+      //
+      //   return db.orders.find(filter, fields)
+      // },
+    },
+    order: {
+      type: orderType,
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLID) },
+      },
+      resolve: (parent: unknown, { id }: Order) => {
+        return db.orders.findById(id)
+      },
+    },
+    customers: {
+      type: new GraphQLList(customerType),
+      args: {
+        filter: { type: customerFilterInput },
+      },
+      resolve(parent: unknown, { filter }: { filter: Customer }) {
+        return db.customers.find({ filter })
+      },
+    },
+    customer: {
+      type: customerType,
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLID) },
+      },
+      resolve: (parent: unknown, { id }: Customer) => {
+        return db.customers.findById(id)
+      },
+    },
+  },
+})
+
+const mutation = new GraphQLObjectType({
+  name: 'Mutation',
+  fields: {
+    // Add a customer
+    addCustomer: {
+      type: customerType,
+      args: {
+        name: { type: new GraphQLNonNull(GraphQLString) },
+        email: { type: new GraphQLNonNull(GraphQLString) },
+        phone: { type: new GraphQLNonNull(GraphQLString) },
+      },
+      resolve(parent: unknown, args: Customer) {
+        return db.customers.save(args)
+      },
+    },
+    // Delete a customer
+    deleteCustomer: {
+      type: customerType,
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLID) },
+      },
+      async resolve(parent: unknown, args: Customer) {
+        const orders = await db.orders.find({
+          filter: { customerId: args.id },
+        })
+
+        orders.forEach(({ id }: Customer) => {
+          db.orders.findByIdAndRemove(id)
+        })
+
+        return db.customers.findByIdAndRemove(args.id)
+      },
+    },
+    // Add an order
+    addOrder: {
+      type: orderType,
+      args: {
+        name: {
+          type: new GraphQLNonNull(new GraphQLEnumType({
+            name: 'OrderName',
+            values: {
+              productOne: { value: Product.productOne },
+              productTwo: { value: Product.productTwo },
+              productThree: { value: Product.productThree },
+            },
+          })),
+          defaultValue: null,
+        },
+        notes: { type: GraphQLString },
+        status: {
+          type: new GraphQLNonNull(new GraphQLEnumType({
+            name: 'OrderStatus',
+            values: {
+              notStarted: { value: Status.notStarted },
+              processing: { value: Status.processing },
+              sent: { value: Status.sent },
+            },
+          })),
+          defaultValue: Status.notStarted,
+        },
+        customerId: { type: new GraphQLNonNull(GraphQLID) },
+      },
+      resolve(parent: unknown, args: Order) {
+        return db.orders.save(args)
+      },
+    },
+    // Update an order
+    updateOrder: {
+      type: orderType,
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLID) },
+        name: { type: GraphQLString },
+        notes: { type: GraphQLString },
+        status: {
+          type: new GraphQLEnumType({
+            name: 'OrderStatusUpdate',
+            values: {
+              notStarted: { value: Status.notStarted },
+              processing: { value: Status.processing },
+              sent: { value: Status.sent },
+            },
+          }),
+        },
+      },
+      resolve(parent: unknown, { id, ...update }: Order) {
+        return db.orders.findByIdAndUpdate(id, { update })
+      },
+    },
+    // Delete an order
+    deleteOrder: {
+      type: orderType,
+      args: {
+        id: { type: new GraphQLNonNull(GraphQLID) },
+      },
+      resolve(parent: unknown, { id }: Order) {
+        return db.orders.findByIdAndRemove(id)
+      },
+    },
+  },
+})
+
+export const schema = new GraphQLSchema({
+  query: queryType,
+  description: 'my schema',
+  mutation,
+})

package/src/typing/enums.ts

@@ -0,0 +1,37 @@
+export enum NodeEnv {
+  production = 'production',
+  test = 'test',
+  development = 'development',
+}
+
+export enum LogLevel {
+  error = 'error',
+  warn = 'warn',
+  info = 'info',
+  http = 'http',
+  verbose = 'verbose',
+  debug = 'debug',
+  silly = 'silly',
+}
+
+export enum LogFile {
+  combined = 'combined',
+  error = 'error',
+}
+
+export enum Product {
+  productOne = 'Product One',
+  productTwo = 'Product Two',
+  productThree = 'Product Three',
+}
+
+export enum Status {
+  notStarted = 'Not Started',
+  processing = 'Processing',
+  sent = 'Sent',
+}
+
+export enum DataSet {
+  customers = 'customers',
+  orders = 'orders',
+}

package/src/typing/interfaces.ts

@@ -0,0 +1,44 @@
+import type { Customer } from '../models/Customer'
+import type { Order } from '../models/Order'
+import type * as enums from './enums'
+import type * as types from './types'
+
+interface DataSetOptions {
+  dataSet: enums.DataSet,
+}
+
+export interface UpdateOptions {
+  update: Partial<Customer>|Partial<Order>,
+}
+
+interface IdOptions {
+  id: types.Id,
+}
+
+interface DocOptions {
+  doc: Customer | Order,
+}
+
+export interface FilterOptions {
+  filter?: Record<string, string>,
+}
+
+export interface Create extends DataSetOptions, DocOptions {}
+
+export interface Read extends DataSetOptions, FilterOptions {}
+
+export interface ReadOne extends Read, IdOptions {}
+
+export interface Update extends DataSetOptions, IdOptions, UpdateOptions {}
+
+export interface Delete extends DataSetOptions, IdOptions {}
+
+export interface ErrorHandler {
+  header?: types.Msg,
+  err: types.Err,
+}
+
+export interface LogErr extends ErrorHandler {
+  meta?: object,
+  level?: enums.LogLevel.warn | enums.LogLevel.error,
+}

package/src/typing/types.ts

@@ -0,0 +1,5 @@
+export type Id = string
+
+export type Err = Error | unknown
+
+export type Msg = string

package/src/utilities/logger.ts

@@ -0,0 +1,191 @@
+const path = require('path')
+const chalk = require('chalk')
+const winston = require('winston')
+require('winston-daily-rotate-file')
+const packageJson = require('../../package.json')
+import type { Logger } from 'winston'
+import type { Format } from 'logform'
+import { NodeEnv, LogLevel, LogFile } from '../typing/enums'
+import type { Msg } from '../typing/types'
+import type { ErrorHandler, LogErr } from '../typing/interfaces'
+
+require('dotenv-flow').config()
+
+const NODE_ENV = process.env.NODE_ENV as NodeEnv || NodeEnv.development
+
+// NOTE:
+// 1) production
+//   a) write log file in json to enable log analytics
+//   b) INFO logging enabled
+// 2) development
+//   a) display logs in console in more readable format, and 
+//      write to log files to align prod and dev behavior
+//   b) VERBOSE logging enabled
+
+class CustomLogger {
+  private dirPath: string
+  private locales: string
+  private timeZone: string
+  private settings: {
+    [key in NodeEnv]: {
+      level: keyof typeof winston.config.npm.levels,
+    }
+  }
+  log: Logger | null
+
+  constructor (options?: {
+    dirPath: string
+    locales: string
+    timeZone: string
+  }) {
+    this.dirPath = options?.dirPath || 'tmp'
+    this.locales = options?.locales || 'en-US'
+    this.timeZone = options?.timeZone || 'UTC'  // 'America/New_York'
+
+    this.settings = {
+      [NodeEnv.production]: {
+        level: LogLevel.info,
+      },
+      [NodeEnv.test]: {
+        level: LogLevel.info,
+      },
+      [NodeEnv.development]: {
+        level: LogLevel.verbose,
+      },
+    }
+
+    this.log = null
+
+    this.initWinston()
+  }
+
+  private initWinston() {
+    const {
+      combine,
+      timestamp,
+      json,
+      simple,
+      colorize,
+    } = winston.format
+
+    const transportsOptions = {
+      frequency: '24h',
+      datePattern: 'YYYY-MM-DD-HH',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '30d',
+    }
+
+    const formatFileName = (fileType: LogFile) => {
+      const file = `${packageJson.name}_${fileType}_%DATE%.log`
+
+      return path.join('/', this.dirPath, file)
+    }
+
+    const transports = [
+      new winston.transports.DailyRotateFile({
+        level: LogLevel.error,
+        filename: formatFileName(LogFile.error),
+        frequency: transportsOptions.frequency,
+        datePattern: transportsOptions.datePattern,
+        zippedArchive: transportsOptions.zippedArchive,
+        maxSize: transportsOptions.maxSize,
+        maxFiles: transportsOptions.maxFiles,
+      }),
+      new winston.transports.DailyRotateFile({
+        filename: formatFileName(LogFile.combined),
+        frequency: transportsOptions.frequency,
+        datePattern: transportsOptions.datePattern,
+        zippedArchive: transportsOptions.zippedArchive,
+        maxSize: transportsOptions.maxSize,
+        maxFiles: transportsOptions.maxFiles,
+      }),
+    ]
+
+    let format: Format
+
+    if (NODE_ENV === NodeEnv.production) {
+      format = combine(timestamp(), json())
+    } else {
+      format = combine(simple(), colorize())
+      transports.push(new winston.transports.Console({ format }))
+    }
+
+    const level = this.settings[NODE_ENV].level
+
+    return this.log = winston.createLogger({
+      level,
+      format,
+      transports,
+    })
+  }
+
+  logTimeStamp = (options?: {
+    msg?: string,
+  }) => {
+    const msg = options?.msg || ''
+
+    const now = new Date()
+
+    const time = now.toLocaleString(this.locales, {
+      timeZone: this.timeZone,
+      timeStyle: 'long',
+      dateStyle: 'short',
+      hour12: false,
+    })
+
+    const timeStamp = chalk.grey(`[${time}]`)
+
+    return this.log?.info(`${msg} ${timeStamp}`)
+  }
+
+  logEnv = ({
+    msg,
+  }: {
+    msg: string,
+  }) => {
+    const env = chalk.grey(`[${NODE_ENV}]`)
+
+    return this.log?.info(`${msg} ${env}`)
+  }
+
+  private errorHandler = ({
+    header,
+    err,
+  }: ErrorHandler): Msg => {
+    const myHeader: string = header
+      ? `${header}:`
+      : ''
+
+    if (err instanceof Error) {
+      return `${myHeader} ${err.message}`
+    } else {
+      return `unexpected ${myHeader} ${err}`
+    }
+  }
+
+  logErr = ({
+    header,
+    err,
+    meta = {},
+    level = LogLevel.error,
+  }: LogErr) => {
+    const msg = this.errorHandler({
+      err,
+      header,
+    })
+
+    switch(level) {
+      case LogLevel.warn:
+        return this.log?.warn(msg, { ...meta })
+      case LogLevel.error:
+        return this.log?.error(msg, { ...meta })
+      default:
+        return null
+    }
+  }
+}
+
+const logger = new CustomLogger()
+
+export = logger

package/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "ts-node": {
+    "transpileOnly": true,
+    "files": true,
+    "compilerOptions": {}
+  },
+  "compilerOptions": {
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "baseUrl": "src",
+    "preserveConstEnums": true,
+    "target": "es6",
+    "pretty": true,
+    "sourceMap": true,
+    "strict": true,
+    "outDir": "./build",
+    "types": [
+      "@types/chai",
+      "@types/chalk",
+      "@types/dotenv-flow",
+      "@types/express",
+      "@types/mocha",
+      "@types/node",
+      "@types/sinon",
+      "@types/supertest"
+    ],
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "./.env*",
+    "node_modules",
+    "bin",
+    "build",
+    ".vscode",
+    "*.json5",
+    "**/*.specs.ts",
+    "**/*.test.ts"
+  ]
+}