Merge pull request #13 from inaiat/refactor/use_only_fn_to_collection_model_and_indexes/omurilo

refact: use only asCollecion and send collection name, schema and indexes

Author: inaiat

README.md

@@ -1,4 +1,5 @@
 # fastify-papr
+
 ![Statements](https://img.shields.io/badge/statements-98.75%25-brightgreen.svg?style=flat) ![Branches](https://img.shields.io/badge/branches-85%25-yellow.svg?style=flat) ![Functions](https://img.shields.io/badge/functions-100%25-brightgreen.svg?style=flat) ![Lines](https://img.shields.io/badge/lines-98.75%25-brightgreen.svg?style=flat)
 
 A fastify Papr plugin integration.
@@ -10,9 +11,10 @@ yarn add @inaiat/fastify-papr @fastify/mongodb
 ```
 
 Next, set up the plugin:
+
 ```ts
 import fastifyMongodb from '@fastify/mongodb'
-import fastifyPaprPlugin, { asModel, FastifyPaprOptions } from ' @inaiat/fastify-papr'
+import fastifyPaprPlugin, { asCollection, FastifyPaprOptions } from ' @inaiat/fastify-papr'
 import fp from 'fastify-plugin'
 import { Model, schema, types } from 'papr'
 
@@ -21,6 +23,8 @@ const userSchema = schema({
   phone: types.string({ required: true, minLength: 8, maxLength: 20 }),
 })
 
+const userIndexes = [{ key: { name: 1 } }]
+
 declare module 'fastify' {
   interface PaprModels {
     user: Model<typeof userSchema[0], Partial<typeof userSchema[1]>>
@@ -35,14 +39,15 @@ export default fp<FastifyPaprOptions>(
 
     await fastify.register(fastifyPaprPlugin, {
       db: fastify.mongo.client.db('test'),
-      models: { user: asModel('user', userSchema) },
+      models: { user: asCollection('user', userSchema, userIndexes) },
     })
   },
   { name: 'papr' },
 )
 ```
 
 How to use:
+
 ```ts
 import { FastifyPluginAsync } from 'fastify'
 import { Static, Type } from '@sinclair/typebox'

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@inaiat/fastify-papr",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Fastify Papr Plugin Integration",
   "type": "module",
   "engines": {
@@ -56,7 +56,7 @@
   },
   "devDependencies": {
     "@swc/cli": "^0.1.62",
-    "@swc/core": "^1.3.50",
+    "@swc/core": "^1.3.51",
     "@swc/helpers": "^0.5.0",
     "@types/node": "^18.15.11",
     "@types/semver": "^7.3.13",
@@ -70,8 +70,8 @@
     "typescript": "^5.0.4",
     "xo": "^0.54.1",
     "eslint-plugin-unused-imports": "^2.0.0",
-    "eslint-plugin-functional": "5.0.7",
-    "eslint-plugin-prettier": "4.2.1"
+    "eslint-plugin-functional": "^5.0.8",
+    "eslint-plugin-prettier": "^4.2.1"
   },
   "files": [
     "dist"
@@ -163,4 +163,4 @@
     }
   },
   "author": "[email protected]"
-}
+}

package.json

@@ -1,25 +1,42 @@
 import fp from 'fastify-plugin'
-import type {BaseSchema, Model, SchemaOptions} from 'papr'
+import type { BaseSchema, Model, SchemaOptions } from 'papr'
 import { IndexDescription } from 'mongodb'
-import type {FastifyPaprOptions, PaprModels} from './types.js'
-import {paprHelper} from './papr-helper.js'
+import type { FastifyPaprOptions, PaprModelItem, PaprModels } from './types.js'
+import { paprHelper } from './papr-helper.js'
 
-export const asModel = <TSchema extends BaseSchema>(
+export const asCollection = <TSchema extends BaseSchema>(
   collectionName: string,
   // eslint-disable-next-line functional/prefer-immutable-types
   collectionSchema: [TSchema, SchemaOptions<Partial<TSchema>>],
-) => ({
+  // eslint-disable-next-line functional/prefer-immutable-types
+  collectionIndexes?: IndexDescription[],
+): PaprModelItem => ({
   collectionName,
   collectionSchema,
+  collectionIndexes,
 })
 
-export const asIndexes = (collectionName: string, collectionIndexes: readonly IndexDescription[]) => ({collectionName, collectionIndexes})
+/**
+ * @deprecated Since version 4.0. Will be deleted in version 5.0. Use {@link asCollection} instead.
+ */
+export const asModel = <TSchema extends BaseSchema>(
+  collectionName: string,
+  // eslint-disable-next-line functional/prefer-immutable-types
+  collectionSchema: [TSchema, SchemaOptions<Partial<TSchema>>],
+): PaprModelItem => ({
+  collectionName,
+  collectionSchema,
+})
 
 const fastifyPaprPlugin = fp<FastifyPaprOptions>(
   async (mutable_fastify, options) => {
-    const helper = paprHelper(mutable_fastify, options.db, options.disableSchemaReconciliation)
-    const models = await helper.register(options.models, options.indexes)
-    const {name} = options
+    const helper = paprHelper(
+      mutable_fastify,
+      options.db,
+      options.disableSchemaReconciliation,
+    )
+    const models = await helper.register(options.models)
+    const { name } = options
     if (name) {
       if (!mutable_fastify.papr) {
         mutable_fastify.decorate('papr', models)
@@ -36,10 +53,10 @@ const fastifyPaprPlugin = fp<FastifyPaprOptions>(
       mutable_fastify.decorate('papr', models)
     }
   },
-  {fastify: '4.x', name: 'fastify-papr-plugin'},
+  { fastify: '4.x', name: 'fastify-papr-plugin' },
 )
 
 export default fastifyPaprPlugin
-export {fastifyPaprPlugin}
+export { fastifyPaprPlugin }
 export * from './types.js'
 export * from './simple-doc-failed-validation.js'

src/index.ts

@@ -1,7 +1,7 @@
 import type {FastifyInstance} from 'fastify'
 import type {Db, IndexDescription} from 'mongodb'
 import Papr, {type Model, BaseSchema, SchemaOptions} from 'papr'
-import {type PaprModels, ModelRegistrationPair, IndexesRegistrationPair} from './types.js'
+import {type PaprModels, ModelRegistrationPair} from './types.js'
 
 export const paprHelper = (fastify: Readonly<FastifyInstance>, db: Db, disableSchemaReconciliation = false) => {
   const papr = new Papr()
@@ -24,18 +24,17 @@ export const paprHelper = (fastify: Readonly<FastifyInstance>, db: Db, disableSc
   const registerIndexes = async (collectionName: string, indexes: readonly IndexDescription[]) => db.collection(collectionName).createIndexes(indexes as IndexDescription[])
 
   return {
-    async register(schemas: ModelRegistrationPair<PaprModels>, indexes: readonly IndexesRegistrationPair[] = []): Promise<PaprModels> {
-      indexes.map(async ({ collectionIndexes, collectionName}) => {
-        const index = await registerIndexes(collectionName, collectionIndexes)
-        fastify.log.info(`Indexes to ${collectionName} created`)
-        return index
-      })
-
+    async register(models: ModelRegistrationPair<PaprModels>): Promise<PaprModels> {
       return Object.fromEntries(await Promise.all(
-        Object.entries(schemas).map(async ([modelName, modelObject]) => {
-          const model = await registerModel(modelObject.collectionName, modelObject.collectionSchema)
-          fastify.log.info(`Model ${modelName} decorated`)
-          return [modelName, model] as [string, Model<BaseSchema, SchemaOptions<Partial<BaseSchema>>>]
+        Object.entries(models).map(async ([name, paprModel]) => {
+          const model = await registerModel(paprModel.collectionName, paprModel.collectionSchema)
+          fastify.log.info(`Model ${name} decorated`)
+          if (paprModel.collectionIndexes) {
+            const index = await registerIndexes(paprModel.collectionName, paprModel.collectionIndexes)
+            fastify.log.info(`Indexes for ${paprModel.collectionName} => ${index.join(', ')} created.`)
+          }
+
+          return [name, model] as [string, Model<BaseSchema, SchemaOptions<Partial<BaseSchema>>>]
         }),
       ))
     },

src/papr-helper.ts

@@ -1,8 +1,11 @@
-import type {Model} from 'papr'
+import type {BaseSchema, Model, SchemaOptions} from 'papr'
 import type {Db, IndexDescription} from 'mongodb'
-import type {asModel} from './index.js'
 
-export type PaprModelItem = ReturnType<typeof asModel>
+export type PaprModelItem = {
+  collectionName: string
+  collectionSchema: [BaseSchema, SchemaOptions<Partial<BaseSchema>>]
+  collectionIndexes?: IndexDescription[]
+}
 
 export type ModelRegistrationPair<T> = {
   [U in keyof T]: PaprModelItem
@@ -18,11 +21,10 @@ export type PaprModels = Record<string, Model<any, any>>
 export type FastifyPaprNestedObject = Record<string, PaprModels>
 
 export type FastifyPaprOptions = {
-  name?: string;
-  db: Db;
-  models: ModelRegistrationPair<PaprModels>;
-  disableSchemaReconciliation?: boolean;
-  indexes?: readonly IndexesRegistrationPair[];
+  name?: string
+  db: Db
+  models: ModelRegistrationPair<PaprModels>
+  disableSchemaReconciliation?: boolean
 }
 
 declare module 'fastify' {

src/types.ts

@@ -5,7 +5,7 @@ import {MongoMemoryServer} from 'mongodb-memory-server'
 import {MongoClient} from 'mongodb'
 
 export const getTestServer = () => {
-  const server = fastify()
+  const server = fastify({ logger: true})
 
   server.setErrorHandler((error, request, reply) => {
     console.error(error)

tests/helpers/server.ts

@@ -0,0 +1,67 @@
+import type {Model} from 'papr'
+import {schema, types} from 'papr'
+import { MongoServerError } from 'mongodb'
+import fastifyPaprPlugin, { asCollection} from '../src/index.js'
+import {getConfiguredTestServer, test} from './helpers/server.js'
+
+export const userSchema = schema({
+  name: types.string({required: true, maxLength: 20}),
+  phone: types.string({required: true, minimum: 14}),
+  age: types.number({required: true, minimum: 18, maximum: 200}),
+})
+
+declare module 'fastify' {
+  interface PaprModels {
+    user: Model<typeof userSchema[0], typeof userSchema[1]>;
+  }
+}
+
+test('Test if index exists and works', async t => {
+  const {server: fastify} = getConfiguredTestServer()
+
+  const db = t.context.client.db()
+
+  await fastify.register(fastifyPaprPlugin, {
+    db,
+    models: {
+      user: asCollection('user', userSchema, [{key: {name: -1}}, {key: {age: 1}}]),
+    },
+  })
+
+  await fastify.papr.user.insertOne({name: 'Elizeu Drummond', age: 35, phone: '552124561234'})
+  await fastify.papr.user.insertOne({name: 'Luiz Pareto', age: 70, phone: '552124561234'})
+  await fastify.papr.user.insertOne({name: 'José Augusto', age: 25, phone: '552124561234'})
+
+  const r = db.collection('user').find().hint({age: 1})
+
+  const e = await r.explain()
+
+  t.is(e.ok, 1)
+  t.is((await fastify.papr.user.find({})).length, 3)
+})
+
+test('Missing index should fail', async t => {
+  const {server: fastify} = getConfiguredTestServer()
+
+  const db = t.context.client.db()
+
+  await fastify.register(fastifyPaprPlugin, {
+    db,
+    models: {
+      user: asCollection('user', userSchema),
+    },
+  })
+
+  await fastify.papr.user.insertOne({name: 'Elizeu Drummond', age: 35, phone: '552124561234'})
+  await fastify.papr.user.insertOne({name: 'Luiz Pareto', age: 70, phone: '552124561234'})
+  await fastify.papr.user.insertOne({name: 'José Augusto', age: 25, phone: '552124561234'})
+
+  const r = db.collection('user').find().hint({name: -1})
+
+  const error = await t.throwsAsync(async () => r.explain(), {
+    instanceOf: MongoServerError,
+  })
+
+  t.is(error?.code, 2)
+})
+