Refactor vertically

server/src/app.ts

@@ -6,7 +6,7 @@ import { redisConfig, serverConfig } from './config'
 import { errorHandler, sessionStore } from './lib/express'
 import logger from './lib/log'
 import pdfRouter from './pdf-processing/handler'
-import userRouter from './users/handler'
+import userRouter from './features/users/router'
 
 const app = express()
 

server/src/entities/user.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod'
+
+const userSchema = z.object({
+  id: z.string().uuid(),
+  firstName: z.string(),
+  lastName: z.string(),
+  email: z.string().email(),
+  password: z.string().min(5),
+  pdfs: z.array(z.object({ id: z.string(), fileName: z.string() })).min(1)
+})
+
+type User = z.infer<typeof userSchema>
+
+export { User }

server/src/features/users/create/createUser.ts

@@ -0,0 +1,38 @@
+import { Request, Response } from 'express'
+
+import * as z from 'zod'
+import { createError } from '../../../lib/error'
+import { createUser, userExists } from './data'
+
+const userRequest = z.object({
+  firstName: z.string(),
+  lastName: z.string(),
+  email: z.string().email(),
+  password: z.string().min(5)
+})
+
+const errors = {
+  validationError: {
+    name: 'ValidationError',
+    code: 400,
+    msg: 'Invalid input',
+    retryable: false
+  },
+  emailConflictError: {
+    name: 'EmailConflictError',
+    code: 409,
+    msg: 'Email already exists',
+    retryable: false
+  }
+}
+
+const create = async (req: Request, res: Response) => {
+  const request = await userRequest.parseAsync(req.body).catch((err) => createError(errors.validationError, err))
+
+  if (await userExists(request.email)) createError(errors.emailConflictError)
+
+  await createUser(request)
+  res.json({ result: 'ok' })
+}
+
+export { create }

server/src/features/users/create/data.ts

@@ -0,0 +1,48 @@
+import bcrypt from 'bcrypt'
+import * as uuid from 'uuid'
+import { User } from '../../../entities/user'
+import r, { idx, key, userKey } from '../../../lib/redis'
+
+const handleCreateIdxError = (err: Error) => {
+  if (err.message.toLowerCase().includes('index already exists')) return
+
+  throw err
+}
+
+const userExists = async (email: string) => r.sismember(key('emails'), email)
+
+const createIdx = async (userId: string) => {
+  await r
+    .send_command(
+      'FT.CREATE',
+      idx(userId),
+      'ON',
+      'HASH',
+      'PREFIX',
+      '1',
+      key(`pdfs:${userId}`),
+      'SCHEMA',
+      'content',
+      'TEXT',
+      'PHONETIC',
+      'dm:en'
+    )
+    .catch(handleCreateIdxError)
+}
+
+const createUser = async (userReq: Partial<User>) => {
+  const saltRounds = 8
+  const password = await bcrypt.hash(userReq.password, saltRounds)
+
+  const newUser = { ...userReq, id: uuid.v4(), password } as User
+
+  await createIdx(newUser.id)
+  await r
+    .multi([
+      ['call', 'JSON.SET', userKey(newUser.id), '.', JSON.stringify(newUser)],
+      ['sadd', key('emails'), newUser.email],
+      ['hmset', idx('email'), newUser.email, newUser.id]
+    ])
+    .exec()
+}
+export { createUser, userExists }

server/src/features/users/get/data.ts

@@ -0,0 +1,11 @@
+import r, { userKey } from '../../../lib/redis'
+import { User } from '../../../entities/user'
+
+const getUser = async (userId: string) => {
+  const resp = (await r.send_command('JSON.GET', userKey(userId))) as User
+  const { password, ...payload } = resp
+
+  return payload
+}
+
+export { getUser }

server/src/features/users/get/getUser.ts

@@ -0,0 +1,30 @@
+import { Request, Response } from 'express'
+import { getUser } from './data'
+import * as z from 'zod'
+import { createError } from '../../../lib/error'
+
+const response = z.object({
+  firstName: z.string(),
+  lastName: z.string(),
+  email: z.string().email(),
+  pdfs: z.array(z.object({ id: z.string(), fileName: z.string() })).min(1)
+})
+
+const errors = {
+  validationError: {
+    name: 'InteralServerError',
+    code: 500,
+    msg: 'Invalid data',
+    retryable: false
+  }
+}
+
+const getCurrentUser = async (req: Request, res: Response) => {
+  const user = await getUser(req.session.userId)
+
+  const result = await response.parseAsync(user).catch((err) => createError(errors.validationError, err))
+
+  res.json({ result })
+}
+
+export { getCurrentUser }

server/src/features/users/router.ts

@@ -0,0 +1,12 @@
+import { create } from './create/createUser'
+import express, { Router } from 'express'
+
+import { auth, safeRouteHandler } from '../../lib/express'
+import { getCurrentUser } from './get/getUser'
+
+const router = Router()
+
+router.post('/users', express.json(), safeRouteHandler(create))
+router.get('/me', auth, safeRouteHandler(getCurrentUser))
+
+export default router

server/src/pdf-processing/store.ts

@@ -16,12 +16,7 @@ const getParagraphs = (sentences: string[]) => {
     const words = sentence.trim().split(' ')
 
     if (words.length + paragraph.length > MAX_PARAGRAPH_SIZE) {
-      paragraphs.push(
-        paragraph
-          .join(' ')
-          .slice(0)
-          .trim()
-      )
+      paragraphs.push(paragraph.join(' ').slice(0).trim())
       console.log(paragraph.length)
       paragraph = []
     }