create-epic-graphql-server 0.5.0

package/specs/Order.spec.ts

@@ -0,0 +1,80 @@
+const { expect } = require('chai')
+import { orderSchema } from '../src/models/Order'
+import { Product, Status } from '../src/typing/enums'
+
+describe('orderSchema', () => {
+  it('validates a correct order object', () => {
+    const input = {
+      name: Product.productOne,
+      status: Status.processing,
+      customerId: 'abc123',
+      notes: 'Fragile item',
+    }
+
+    const result = orderSchema.safeParse(input)
+    expect(result.success).to.be.true
+    if (result.success) {
+      expect(result.data).to.deep.include(input)
+    }
+  })
+
+  it('fails if required fields are missing', () => {
+    const input = {
+      name: Product.productTwo,
+    }
+
+    const result = orderSchema.safeParse(input)
+    expect(result.success).to.be.false
+    if (!result.success) {
+      const errors = result.error.flatten().fieldErrors
+      expect(errors).to.have.property('status')
+      expect(errors).to.have.property('customerId')
+    }
+  })
+
+  it('fails if name or status is not a valid enum', () => {
+    const input = {
+      name: 'Invalid Product',
+      status: 'Invalid Status',
+      customerId: 'abc123',
+    }
+
+    const result = orderSchema.safeParse(input)
+    expect(result.success).to.be.false
+    if (!result.success) {
+      const errors = result.error.flatten().fieldErrors
+      expect(errors.name?.[0]).to.include('Invalid enum value')
+      expect(errors.status?.[0]).to.include('Invalid enum value')
+    }
+  })
+
+  it('accepts when optional fields are omitted', () => {
+    const input = {
+      name: Product.productThree,
+      status: Status.sent,
+      customerId: 'xyz789',
+    }
+
+    const result = orderSchema.safeParse(input)
+    expect(result.success).to.be.true
+    if (result.success) {
+      expect(result.data.notes).to.be.undefined
+      expect(result.data.id).to.be.undefined
+    }
+  })
+
+  it('accepts if id is provided but optional', () => {
+    const input = {
+      id: 'order-001',
+      name: Product.productTwo,
+      status: Status.notStarted,
+      customerId: 'cust001',
+    }
+
+    const result = orderSchema.safeParse(input)
+    expect(result.success).to.be.true
+    if (result.success) {
+      expect(result.data.id).to.equal('order-001')
+    }
+  })
+})

package/specs/logger.spec.ts

@@ -0,0 +1,92 @@
+
+const { expect } = require('chai')
+const sinon = require('sinon')
+const logger = require('../src/utilities/logger')
+import type { SinonStub, SinonFakeTimers } from 'sinon'
+
+describe('CustomLogger', () => {
+  let infoStub: SinonStub
+  let errorStub: SinonStub
+  let warnStub: SinonStub
+  let clock: SinonFakeTimers
+
+  beforeEach(() => {
+    if (!logger.log) {
+      throw new Error('logger.log must be initialized before tests')
+    }
+
+    infoStub = sinon.stub(logger.log, 'info')
+    errorStub = sinon.stub(logger.log, 'error')
+    warnStub = sinon.stub(logger.log, 'warn')
+    clock = sinon.useFakeTimers(new Date('2025-06-29T12:00:00Z').getTime())
+  })
+
+  afterEach(() => {
+    infoStub.restore()
+    errorStub.restore()
+    warnStub.restore()
+    clock.restore()
+  })
+
+  it('logs a timestamp with default message', () => {
+    logger.logTimeStamp()
+
+    expect(infoStub.calledOnce).to.be.true
+    const logged = infoStub.firstCall.args[0]
+    expect(logged).to.match(/\[\d{1,2}\/\d{1,2}\/\d{2}, 12:00:00/)
+  })
+
+  it('logs a timestamp with a custom message', () => {
+    logger.logTimeStamp({ msg: 'Started at' })
+
+    expect(infoStub.calledOnce).to.be.true
+    const logged = infoStub.firstCall.args[0]
+    expect(logged).to.include('Started at')
+    expect(logged).to.match(/\[\d{1,2}\/\d{1,2}\/\d{2}, 12:00:00/)
+  })
+
+  it('logs environment with custom message', () => {
+    logger.logEnv({ msg: 'Server started' })
+
+    expect(infoStub.calledOnce).to.be.true
+    const logged = infoStub.firstCall.args[0]
+    expect(logged).to.include('Server started')
+    expect(logged).to.include('[development]')
+  })
+
+  it('logs an error with a header and Error instance', () => {
+    logger.logErr({
+      header: 'TestHeader',
+      err: new Error('Something went wrong'),
+    })
+  
+    expect(errorStub.calledOnce).to.be.true
+    const [message] = errorStub.firstCall.args
+    expect(message).to.equal('TestHeader: Something went wrong')
+  })
+  
+  it('logs a warning with custom level', () => {
+    logger.logErr({
+      header: 'WarnHeader',
+      err: new Error('This is a warning'),
+      level: 'warn',
+      meta: { cause: 'testing' },
+    })
+  
+    expect(warnStub.calledOnce).to.be.true
+    const [message, meta] = warnStub.firstCall.args
+    expect(message).to.equal('WarnHeader: This is a warning')
+    expect(meta).to.deep.equal({ cause: 'testing' })
+  })
+  
+  it('logs unexpected error types gracefully', () => {
+    logger.logErr({
+      header: 'Oops',
+      err: 'some string error',
+    })
+  
+    expect(errorStub.calledOnce).to.be.true
+    const [message] = errorStub.firstCall.args
+    expect(message).to.equal('unexpected Oops: some string error')
+  })
+})

package/specs/schema.spec.ts

@@ -0,0 +1,103 @@
+const { expect } = require('chai')
+const request = require('supertest')
+const sinon = require('sinon')
+const express = require('express')
+const { createHandler } = require('graphql-http/lib/use/express')
+const { schema } = require('../src/schema/schema')
+const db = require('../src/config/db')
+import type { SinonStub } from 'sinon' 
+
+const app = express()
+app.use('/graphql', createHandler({ schema }))
+
+describe('GraphQL Schema', () => {
+  let saveStub: SinonStub
+  let findStub: SinonStub
+
+  beforeEach(() => {
+    // Stub db methods
+    saveStub = sinon.stub(db.customers, 'save').resolves({
+      id: '1',
+      name: 'Alice',
+      email: 'alice@example.com',
+      phone: '123-456',
+    })
+
+    findStub = sinon.stub(db.customers, 'find').resolves([
+      {
+        id: '1',
+        name: 'Alice',
+        email: 'alice@example.com',
+        phone: '123-456',
+      },
+    ])
+  })
+
+  afterEach(() => {
+    sinon.restore()
+  })
+
+  it('returns customers', async () => {
+    const query = {
+      query: `
+        query {
+          customers {
+            id
+            name
+            email
+            phone
+          }
+        }
+      `,
+    }
+
+    const res = await request(app)
+      .post('/graphql')
+      .send(query)
+      .set('Accept', 'application/json')
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.body).to.have.nested.property('data.customers').that.is.an('array')
+    expect(res.body.data.customers[0]).to.include({
+      id: '1',
+      name: 'Alice',
+      email: 'alice@example.com',
+      phone: '123-456',
+    })
+  })
+
+  it('adds a customer', async () => {
+    const mutation = {
+      query: `
+        mutation {
+          addCustomer(name: "Alice", email: "alice@example.com", phone: "123-456") {
+            id
+            name
+            email
+            phone
+          }
+        }
+      `,
+    }
+
+    const res = await request(app)
+      .post('/graphql')
+      .send(mutation)
+      .set('Accept', 'application/json')
+
+    expect(res.statusCode).to.equal(200)
+    expect(res.body).to.have.nested.property('data.addCustomer').that.includes({
+      id: '1',
+      name: 'Alice',
+      email: 'alice@example.com',
+      phone: '123-456',
+    })
+
+    expect(saveStub.calledOnce).to.be.true
+    expect(saveStub.firstCall.args[0]).to.include({
+      name: 'Alice',
+      email: 'alice@example.com',
+      phone: '123-456',
+    })
+  })
+})

package/src/config/db.ts

@@ -0,0 +1,267 @@
+const path = require('path')
+const z = require('zod')
+const { log, logErr } = require('../utilities/logger')
+const { customerSchema } = require('../models/Customer')
+const { orderSchema } = require('../models/Order')
+import type { Customer } from '../models/Customer'
+import type { Order } from '../models/Order'
+import { DataSet } from '../typing/enums'
+import type { Id, Err } from '../typing/types'
+import type * as I from '../typing/interfaces'
+
+require('dotenv-flow').config()
+
+const crud = {
+  url: `http://localhost:${process.env.JSON_SERVER_PORT || 3210}`,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  datasets: { ...DataSet },
+  errors: {
+    throw({ response }: { response: Response }) {
+      throw new Error(`fetch failed with status ${response.status}`)
+    },
+    handle({ err }: { err: Err }) {
+      logErr({ header: 'fetch error', err })
+    },
+  },
+  async create({ dataSet, doc }: I.Create) {
+    const resource = path.join(this.url, dataSet)
+    const options = {
+      method: 'POST',
+      headers: this.headers,
+      body: JSON.stringify(doc),
+    }
+
+    let result
+
+    try {
+      const response: Response = await fetch(resource, options)
+
+      if (!response.ok) this.errors.throw({ response })
+
+      result = await response.json()
+    } catch (err: unknown) {
+      this.errors.handle({ err })
+    }
+
+    return result
+  },
+  async read({ dataSet, filter }: I.Read) {
+    let resource = path.join(this.url, dataSet)
+
+    // add "filter" as query params
+    if (filter && Object.keys(filter).length) {
+      const searchParams = new URLSearchParams(
+        Object.entries(filter)
+      )
+
+      resource += '?' + searchParams.toString()
+    }
+
+    let result: Customer[] | Order[]
+
+    try {
+      const response: Response = await fetch(resource)
+
+      if (!response.ok) this.errors.throw({ response })
+
+      result = await response.json()
+
+      return result
+    } catch (err: unknown) {
+      this.errors.handle({ err })
+    }
+  },
+  async readOne({ dataSet, id }: I.ReadOne) {
+    const resource = path.join(this.url, dataSet, id)
+
+    let result: Customer | Order
+
+    try {
+      const response: Response = await fetch(resource)
+
+      if (!response.ok) this.errors.throw({ response })
+
+      result = await response.json()
+
+      return result
+    } catch (err: unknown) {
+      this.errors.handle({ err })
+    }
+  },
+  async update({ dataSet, id, update }: I.Update) {
+    const resource = path.join(this.url, dataSet, id)
+    const options = {
+      method: 'PATCH',
+      headers: this.headers,
+      body: JSON.stringify(update),
+    }
+
+    let result
+
+    try {
+      const response: Response = await fetch(resource, options)
+
+      if (!response.ok) this.errors.throw({ response })
+
+      result = await response.json()
+    } catch (err: unknown) {
+      this.errors.handle({ err })
+    }
+
+    return result
+  },
+  async delete({ dataSet, id }: I.Delete) {
+    const resource = path.join(this.url, dataSet, id)
+    const options = {
+      method: 'DELETE',
+      headers: this.headers,
+    }
+
+    let result
+
+    try {
+      const response: Response = await fetch(resource, options)
+
+      if (!response.ok) this.errors.throw({ response })
+
+      result = await response.json()
+    } catch (err: unknown) {
+      this.errors.handle({ err })
+    }
+
+    return result
+  },
+}
+
+export = {
+  [crud.datasets.customers]: {
+    async save(doc: Customer) {
+      let customer: Customer | undefined
+
+      try {
+        customer = customerSchema.parse({
+          name: doc.name,
+          email: doc.email,
+          phone: doc.phone,
+        })
+      } catch (err: typeof z.ZodError | unknown) {
+        if(err instanceof z.ZodError) {
+          err.issues.forEach((err: typeof z.ZodError, index: number) => {
+            log.error(`${err.path[index]} ${err.message}`, { index })
+          })
+        } else {
+          logErr({ header: 'customer parse error', err })
+        }
+      }
+
+      if (customer) {
+        const result = await crud.create({
+          dataSet: crud.datasets.customers,
+          doc: customer,
+        })
+
+        return result
+      }
+    },
+    async find({ filter }: I.FilterOptions) {
+      const result = await crud.read({
+        dataSet: crud.datasets.customers,
+        filter,
+      })
+
+      return result
+    },
+    async findById(id: Id) {
+      const result = await crud.readOne({
+        dataSet: crud.datasets.customers,
+        id,
+      })
+
+      return result
+    },
+    async findByIdAndUpdate(id: Id, { update }: I.UpdateOptions) {
+      const result = await crud.update({
+        dataSet: crud.datasets.customers,
+        id,
+        update,
+      })
+
+      return result
+    },
+    async findByIdAndRemove(id: Id) {
+      const result = await crud.delete({
+        dataSet: crud.datasets.customers,
+        id,
+      })
+
+      return result
+    },
+  },
+  [crud.datasets.orders]: {
+    async save(doc: Order) {
+      let order: Order | undefined
+
+      try {
+        order = orderSchema.parse({
+          name: doc.name,
+          ...(doc.notes && { notes: doc.notes }),
+          status: doc.status,
+          customerId: doc.customerId,
+        })
+      } catch (err: typeof z.ZodError | unknown) {
+        if (err instanceof z.ZodError) {
+          err.issues.forEach((err: typeof z.ZodError, index: number) => {
+            log.error(`${err.path[index]} ${err.message}`, { index })
+          })
+        } else {
+          logErr({ header: 'order parse error', err })
+        }
+      }
+
+      if (order) {
+        const result = await crud.create({
+          dataSet: crud.datasets.orders,
+          doc: order,
+        })
+
+        return result
+      }
+    },
+    async find({ filter }: I.FilterOptions) {
+      const result = await crud.read({
+        dataSet: crud.datasets.orders,
+        filter,
+      })
+
+      return result
+    },
+    async findById(id: Id) {
+      console.log(id)
+      const result = await crud.readOne({
+        dataSet: crud.datasets.orders,
+        id,
+      })
+
+      return result
+    },
+    async findByIdAndUpdate(id: Id, { update }: I.UpdateOptions) {
+      const result = await crud.update({
+        dataSet: crud.datasets.orders,
+        id,
+        update,
+      })
+
+      return result
+    },
+    async findByIdAndRemove(id: Id) {
+      const result = await crud.delete({
+        dataSet: crud.datasets.orders,
+        id,
+      })
+
+      return result
+    },
+  },
+}

package/src/index.ts

@@ -0,0 +1,57 @@
+const express = require('express')
+const graphqlRouter = express.Router()
+const cors = require('cors')
+const helmet = require('helmet')
+const chalk = require('chalk')
+const { createHandler } = require('graphql-http/lib/use/express')
+const { ruruHTML } = require('ruru/server')
+const routes = require('./routes')
+const { schema } = require('./schema/schema')
+const logger = require('./utilities/logger')
+import type { Application, Request, Response } from 'express'
+import { NodeEnv } from './typing/enums'
+
+require('dotenv-flow').config()
+
+const { production, development } = NodeEnv
+
+const PORT = process.env.PORT || 3000
+const NODE_ENV = process.env.NODE_ENV || development
+
+const app: Application = express()
+
+app.use(cors())
+
+if (NODE_ENV === production) {
+  app.use(helmet())
+} else {
+  app.use(
+    helmet({
+      contentSecurityPolicy: false,
+    })
+  )
+}
+
+app.use(routes)
+
+graphqlRouter.all('/',
+  createHandler({
+    schema,
+  })
+)
+
+app.use('/graphql', graphqlRouter)
+
+if (NODE_ENV === development) {
+  // ruru GraphiQL runs on the endpoint '/' not '/graphql'
+  app.get('/', (req: Request, res: Response) => {
+    res.type('html')
+    res.end(ruruHTML({
+      endpoint: '/graphql',
+    }))
+  })
+}
+
+app.listen(PORT, () => logger.logEnv({
+  msg: `running on ${chalk.blue.bold(PORT)}`,
+}))

package/src/models/Customer.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod'
+
+export const customerSchema = z.object({
+  id: z.string().optional(),  // optional? let db add id on save
+  name: z.string(),
+  email: z.string().email(),
+  phone: z.string(),
+})
+
+export type Customer = z.infer<typeof customerSchema>

package/src/models/Order.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+import { Product, Status } from '../typing/enums'
+
+export const orderSchema = z.object({
+  id: z.string().optional(),  // optional? let db add id on save
+  name: z.nativeEnum(Product),
+  notes: z.string().optional(),
+  status: z.nativeEnum(Status),
+  customerId: z.string(),
+})
+
+export type Order = z.infer<typeof orderSchema>

package/src/routes/check.ts

@@ -0,0 +1,18 @@
+const express = require('express')
+const router = express.Router()
+import type { Request, Response } from 'express'
+import { NodeEnv } from '../typing/enums'
+
+require('dotenv-flow').config()
+
+// NOTE remove this if you wish, it won't affect the graphql route,
+// this is just here to test express and typescript live transpile, 
+// but also demonstrates a conventional routing pattern if needed
+
+if (process.env.NODE_ENV === NodeEnv.development) {
+  router.get('/check', (req: Request, res: Response) => {
+    res.status(200).send('okay...')
+  })
+}
+
+export = router

package/src/routes/index.ts

@@ -0,0 +1,8 @@
+const express = require('express')
+const router = express.Router()
+
+router.use(
+  require('./check')
+)
+
+export = router