feat(nuxt-drizzle): drizzle hooks

Author: Akryum

packages/nuxt-drizzle/package.json

@@ -43,6 +43,7 @@
     "@rstore/shared": "workspace:^",
     "@rstore/vue": "workspace:^",
     "h3": "^1.15.1",
+    "hookable": "^5.5.3",
     "jiti": "^2.4.2",
     "pathe": "^2.0.3"
   },

packages/nuxt-drizzle/src/module.ts

@@ -5,7 +5,7 @@ import type { getTableConfig as pgGetTableConfig } from 'drizzle-orm/pg-core'
 import type { getTableConfig as singleStoreGetTableConfig } from 'drizzle-orm/singlestore-core'
 import type { getTableConfig as sqliteGetTableConfig } from 'drizzle-orm/sqlite-core'
 import fs from 'node:fs'
-import { addImportsDir, addServerHandler, addServerTemplate, addTemplate, addTypeTemplate, createResolver, defineNuxtModule, hasNuxtModule, installModule, updateTemplates, useLogger } from '@nuxt/kit'
+import { addImportsDir, addServerHandler, addServerImports, addServerTemplate, addTemplate, addTypeTemplate, createResolver, defineNuxtModule, hasNuxtModule, installModule, updateTemplates, useLogger } from '@nuxt/kit'
 import { createTableRelationsHelpers, getTableName, is, isTable, Many, One, Relations, type Table, type TableConfig } from 'drizzle-orm'
 import { createJiti } from 'jiti'
 import path from 'pathe'
@@ -93,6 +93,9 @@ export default defineNuxtModule<ModuleOptions>({
       method: 'delete',
     })
     addImportsDir(resolve('./runtime/utils'))
+    addServerImports([
+      'rstoreDrizzleHooks',
+    ].map(name => ({ from: resolve('./runtime/server/utils/hooks'), name })))
 
     const jiti = createJiti(import.meta.url, {
       moduleCache: false,

packages/nuxt-drizzle/src/runtime/server/api/[key]/index.delete.ts

@@ -1,9 +1,52 @@
+import { and } from 'drizzle-orm'
 import { defineEventHandler, getRouterParams } from 'h3'
 import { getDrizzleKeyWhere, getDrizzleTableFromModel, rstoreUseDrizzle } from '../../utils'
+import { rstoreDrizzleHooks, type RstoreDrizzleMeta, type RstoreDrizzleTransformQuery } from '../../utils/hooks'
 
 export default defineEventHandler(async (event) => {
-  const { model: modelName, key } = getRouterParams(event) as { model: string, key: string }
+  const meta: RstoreDrizzleMeta = {}
+  const transforms: Array<RstoreDrizzleTransformQuery> = []
+
+  const params = getRouterParams(event) as { model: string, key: string }
+  const { model: modelName, key } = params
+  const query = getQuery(event)
+
+  await rstoreDrizzleHooks.callHook('item.delete.before', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query,
+    transformQuery: (transform) => { transforms.push(transform) },
+  })
+
   const { table, primaryKeys } = getDrizzleTableFromModel(modelName)
 
-  await rstoreUseDrizzle().delete(table as any).where(getDrizzleKeyWhere(key, primaryKeys, table))
+  const where: any[] = [
+    getDrizzleKeyWhere(key, primaryKeys, table),
+  ]
+
+  for (const transform of transforms) {
+    transform({
+      where: (condition) => { where.push(condition) },
+    })
+  }
+
+  await rstoreUseDrizzle().delete(table as any).where(and(
+    ...where,
+  ))
+
+  let result: any = null
+
+  await rstoreDrizzleHooks.callHook('item.delete.after', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query,
+    result,
+    setResult: (r) => { result = r },
+  })
+
+  return result
 })

packages/nuxt-drizzle/src/runtime/server/api/[key]/index.get.ts

@@ -1,17 +1,56 @@
 import type { RelationalQueryBuilder } from 'drizzle-orm/pg-core/query-builders/query'
+import { and } from 'drizzle-orm'
 import { defineEventHandler, getQuery, getRouterParams } from 'h3'
 import { getDrizzleKeyWhere, getDrizzleTableFromModel, type RstoreDrizzleQueryParamsOne, rstoreUseDrizzle } from '../../utils'
+import { rstoreDrizzleHooks, type RstoreDrizzleMeta, type RstoreDrizzleTransformQuery } from '../../utils/hooks'
 
 export default defineEventHandler(async (event) => {
-  const { model: modelName, key } = getRouterParams(event) as { model: string, key: string }
+  const meta: RstoreDrizzleMeta = {}
+  const transforms: Array<RstoreDrizzleTransformQuery> = []
+
+  const params = getRouterParams(event) as { model: string, key: string }
+  const { model: modelName, key } = params
   const query = getQuery(event) as RstoreDrizzleQueryParamsOne
+
+  await rstoreDrizzleHooks.callHook('item.get.before', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query: query as Record<string, string | string[]>,
+    transformQuery: (transform) => { transforms.push(transform) },
+  })
+
   const { table, primaryKeys } = getDrizzleTableFromModel(modelName)
 
+  const where: any[] = []
+  for (const transform of transforms) {
+    transform({
+      where: (condition) => { where.push(condition) },
+    })
+  }
+
   const dbQuery = rstoreUseDrizzle().query as unknown as Record<string, RelationalQueryBuilder<any, any>>
-  const result = await dbQuery[modelName].findFirst({
-    where: getDrizzleKeyWhere(key, primaryKeys, table),
+  let result: any = await dbQuery[modelName].findFirst({
+    where: and(
+      getDrizzleKeyWhere(key, primaryKeys, table),
+      ...where,
+    ),
     with: query.with ? JSON.parse(query.with) : undefined,
     columns: query.columns ? JSON.parse(query.columns) : undefined,
   })
-  return result ?? null
+
+  result ??= null
+
+  await rstoreDrizzleHooks.callHook('item.get.after', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query: query as Record<string, string | string[]>,
+    result,
+    setResult: (r) => { result = r },
+  })
+
+  return result
 })

packages/nuxt-drizzle/src/runtime/server/api/[key]/index.patch.ts

@@ -1,22 +1,68 @@
+import { and } from 'drizzle-orm'
 import { defineEventHandler, getRouterParams, readBody } from 'h3'
 import { getDrizzleDialect, getDrizzleKeyWhere, getDrizzleTableFromModel, rstoreUseDrizzle } from '../../utils'
+import { rstoreDrizzleHooks, type RstoreDrizzleMeta, type RstoreDrizzleTransformQuery } from '../../utils/hooks'
 
 export default defineEventHandler(async (event) => {
-  const { model: modelName, key } = getRouterParams(event) as { model: string, key: string }
-  const { table, primaryKeys } = getDrizzleTableFromModel(modelName)
+  const meta: RstoreDrizzleMeta = {}
+  const transforms: Array<RstoreDrizzleTransformQuery> = []
+
+  const params = getRouterParams(event) as { model: string, key: string }
+  const { model: modelName, key } = params
+  const query = getQuery(event)
   const body = await readBody(event)
 
-  const where = getDrizzleKeyWhere(key, primaryKeys, table)
-  const q = rstoreUseDrizzle().update(table as any).set(body).where(where)
+  await rstoreDrizzleHooks.callHook('item.patch.before', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query,
+    body,
+    transformQuery: (transform) => { transforms.push(transform) },
+  })
+
+  const { table, primaryKeys } = getDrizzleTableFromModel(modelName)
+
+  const where: any[] = [
+    getDrizzleKeyWhere(key, primaryKeys, table),
+  ]
+
+  for (const transform of transforms) {
+    transform({
+      where: (condition) => { where.push(condition) },
+    })
+  }
+
+  const q = rstoreUseDrizzle().update(table as any).set(body).where(and(
+    ...where,
+  ))
+
+  let result: any
 
   const dialect = getDrizzleDialect()
   if (dialect === 'pg' || dialect === 'sqlite') {
-    const result = await q.returning()
-    return result[0]
+    const _result = await q.returning()
+    result = _result[0]
   }
   else {
     await q
-    const select = await rstoreUseDrizzle().select().from(table as any).where(where).limit(1)
-    return select[0]
+    const select = await rstoreUseDrizzle().select().from(table as any).where(and(
+      ...where,
+    )).limit(1)
+    result = select[0]
   }
+
+  await rstoreDrizzleHooks.callHook('item.patch.after', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query,
+    body,
+    result,
+    setResult: (r) => { result = r },
+  })
+
+  return result
 })

packages/nuxt-drizzle/src/runtime/server/api/index.get.ts

@@ -1,29 +1,45 @@
 import type { RelationalQueryBuilder } from 'drizzle-orm/pg-core/query-builders/query'
-import { asc, desc } from 'drizzle-orm'
+import { and, asc, desc } from 'drizzle-orm'
 import { createError, eventHandler, getQuery, getRouterParams } from 'h3'
 import { getDrizzleCondition, getDrizzleTableFromModel, type RstoreDrizzleQueryParams, rstoreUseDrizzle } from '../utils'
+import { rstoreDrizzleHooks, type RstoreDrizzleMeta, type RstoreDrizzleTransformQuery } from '../utils/hooks'
 
 const orderByOperators = {
   asc,
   desc,
 }
 
 export default eventHandler(async (event) => {
-  const { model: modelName } = getRouterParams(event) as { model: string }
-  const { table } = getDrizzleTableFromModel(modelName)
+  const meta: RstoreDrizzleMeta = {}
+  const transforms: Array<RstoreDrizzleTransformQuery> = []
 
+  const params = getRouterParams(event) as { model: string }
+  const { model: modelName } = params
   const query = getQuery(event) as RstoreDrizzleQueryParams
 
+  await rstoreDrizzleHooks.callHook('index.get.before', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query: query as Record<string, string | string[]>,
+    transformQuery: (transform) => { transforms.push(transform) },
+  })
+
+  const { table } = getDrizzleTableFromModel(modelName)
+
   const dbQuery = rstoreUseDrizzle().query as unknown as Record<string, RelationalQueryBuilder<any, any>>
 
   const q = {} as NonNullable<Parameters<typeof dbQuery[typeof modelName]['findMany']>[0]>
 
+  const where: any[] = []
+
   if (query.where) {
     try {
       const where = JSON.parse(query.where as string) as any
       if (where) {
         const condition = getDrizzleCondition(table, where)
-        q.where = condition
+        where.push(condition)
       }
     }
     catch (e) {
@@ -35,6 +51,14 @@ export default eventHandler(async (event) => {
     }
   }
 
+  for (const transform of transforms) {
+    transform({
+      where: (condition) => { where.push(condition) },
+    })
+  }
+
+  q.where = where.length ? and(...where) : undefined
+
   if (query.limit != null) {
     q.limit = Number.parseInt(query.limit)
   }
@@ -69,6 +93,18 @@ export default eventHandler(async (event) => {
     q.orderBy = orderBy
   }
 
-  const result = await dbQuery[modelName].findMany(q)
-  return result ?? []
+  let result = await dbQuery[modelName].findMany(q)
+  result ??= []
+
+  await rstoreDrizzleHooks.callHook('index.get.after', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query: query as Record<string, string | string[]>,
+    result,
+    setResult: (r) => { result = r },
+  })
+
+  return result
 })

packages/nuxt-drizzle/src/runtime/server/api/index.post.ts

@@ -1,28 +1,60 @@
 import { and, eq, type Table } from 'drizzle-orm'
 import { defineEventHandler, getRouterParams, readBody } from 'h3'
 import { getDrizzleDialect, getDrizzleTableFromModel, rstoreUseDrizzle } from '../utils'
+import { rstoreDrizzleHooks, type RstoreDrizzleMeta, type RstoreDrizzleTransformQuery } from '../utils/hooks'
 
 export default defineEventHandler(async (event) => {
-  const { model: modelName } = getRouterParams(event) as { model: string }
-  const { table } = getDrizzleTableFromModel(modelName)
+  const meta: RstoreDrizzleMeta = {}
+  const transforms: Array<RstoreDrizzleTransformQuery> = []
+
+  const params = getRouterParams(event) as { model: string }
+  const { model: modelName } = params
   const body = await readBody(event)
+  const query = getQuery(event)
+
+  await rstoreDrizzleHooks.callHook('index.post.before', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query,
+    body,
+    transformQuery: (transform) => { transforms.push(transform) },
+  })
+
+  const { table } = getDrizzleTableFromModel(modelName)
 
   const q = rstoreUseDrizzle().insert(table as any).values(body)
 
+  let result: any
+
   const dialect = getDrizzleDialect()
   if (dialect === 'pg' || dialect === 'sqlite') {
-    const result = await q.returning()
-    return result[0]
+    const _result = await q.returning()
+    result = _result[0]
   }
   else if (dialect === 'mysql' || dialect === 'singlestore') {
     // @ts-expect-error specific to mysql
-    const result = await q.$returningId()
-    const primaryKey = result[0]
+    const _result = await q.$returningId()
+    const primaryKey = _result[0]
     const select = await rstoreUseDrizzle().select().from(table as any).where(and(
       ...Object.entries(primaryKey).map(([key, value]) => {
         return eq(table[key as keyof typeof table] as Table, value)
       }),
     )).limit(1)
-    return select[0]
+    result = select[0]
   }
+
+  await rstoreDrizzleHooks.callHook('index.post.after', {
+    event,
+    model: modelName,
+    meta,
+    params,
+    query,
+    body,
+    result,
+    setResult: (r) => { result = r },
+  })
+
+  return result
 })