feat: fastify plugin

Author: crashmax-dev

examples/with-fastify/src/index.ts

@@ -1,25 +1,28 @@
 import 'reflect-metadata'
 import { dirname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { FastifySteno } from '@stenodb/fastify'
+import { AsyncAdapter, FastifySteno } from '@stenodb/fastify'
 import Fastify from 'fastify'
 import { Post, User, Users } from './entities.js'
 
 const fastify = Fastify()
 
 fastify.register(FastifySteno, {
   path: resolve(dirname(fileURLToPath(import.meta.url)), '..', 'db'),
-  entities: [User, Post]
+  entities: [User, Post],
+  adapters: [new AsyncAdapter('users', Users, new Users(new User('John', 18)))]
+})
+
+fastify.get('/', () => {
+  const users = fastify.steno.get<Users>('users')
+  return users?.data
 })
 
 fastify.post('/', { schema: { body: { $ref: 'User' } } }, (req) => {
-  return {
-    body: req.body,
-    schema: req.routeSchema
-  }
+  return req.body
 })
 
-fastify.listen({ host: '0.0.0.0', port: 3000 }, async (err, address) => {
+fastify.listen({ host: '0.0.0.0', port: 3000 }, (err, address) => {
   if (err) throw err
   console.log(address)
 })

packages/fastify/src/index.ts

@@ -1,10 +1,12 @@
+import { AsyncAdapter, SyncAdapter } from '@stenodb/node'
 import fp from 'fastify-plugin'
 import { StenoPlugin } from './plugin.js'
+import './types.js'
 
 const FastifySteno = fp(StenoPlugin.createInstance, {
   name: '@stenodb/fastify',
   fastify: '4.x'
 })
 
-export { FastifySteno }
+export { FastifySteno, AsyncAdapter, SyncAdapter }
 export default StenoPlugin.createInstance

packages/fastify/src/plugin.ts

@@ -1,41 +1,76 @@
-import { NodeProvider } from '@stenodb/node'
+import { AsyncAdapter, NodeProvider, SyncAdapter } from '@stenodb/node'
 import { targetConstructorToSchema } from 'class-validator-jsonschema'
 import type { Steno } from '@stenodb/node'
 import type { IOptions } from 'class-validator-jsonschema/build/options'
 import type { FastifyInstance } from 'fastify'
 
 export interface StenoOptions extends Steno.NodeProviderOptions {
-  entities: Steno.Entity<any>[]
+  adapters: Steno.NodeAdapter<any>[]
+  entities?: Steno.Entity<any>[]
+  entityOptions?: IOptions
 }
 
 export class StenoPlugin {
   #fastify: FastifyInstance
   #options: StenoOptions
   #provider: NodeProvider
+  #databases: Map<string, Steno.NodeProvider<any>>
 
-  constructor(fastify: FastifyInstance, options: StenoOptions, done: () => void) {
+  constructor(fastify: FastifyInstance, options: StenoOptions) {
     this.#fastify = fastify
     this.#options = options
     this.#provider = new NodeProvider(options)
-
-    this.#fastify.decorate('steno', {})
-    this.registerSchemas()
-
-    done()
+    this.#databases = new Map<string, Steno.NodeProvider<any>>()
+    this.#fastify.decorate('steno', { get: this.getDatabase.bind(this) })
   }
 
   static async createInstance(
     fastify: FastifyInstance,
     options: StenoOptions,
     done: () => void
   ): Promise<StenoPlugin> {
-    return new StenoPlugin(fastify, options, done)
+    const db = new StenoPlugin(fastify, options)
+    await db.registerDatabases()
+    done()
+    return db
+  }
+
+  async registerDatabases(): Promise<void> {
+    this.registerEntities()
+
+    for (const adapter of this.#options.adapters) {
+      const db = await this.#provider.create(adapter)
+
+      if (adapter instanceof SyncAdapter) {
+        db.read()
+      } else if (adapter instanceof AsyncAdapter) {
+        await db.read()
+      } else {
+        throw new TypeError('Invalid adapter')
+      }
+
+      this.addSchema(adapter.entity)
+      this.#databases.set(adapter.fileName, db)
+    }
   }
 
-  private registerSchemas(options?: IOptions): void {
+  private registerEntities() {
+    if (!this.#options.entities) return
     for (const entity of this.#options.entities) {
-      const schema = targetConstructorToSchema(entity, options)
-      this.#fastify.addSchema({ ...schema, $id: entity.name })
+      this.addSchema(entity)
     }
   }
+
+  private addSchema(entity: Steno.Entity<any>): void {
+    if (this.#fastify.getSchema(entity.name)) return
+    const schema = targetConstructorToSchema(
+      entity,
+      this.#options.entityOptions
+    )
+    this.#fastify.addSchema({ ...schema, $id: entity.name })
+  }
+
+  private getDatabase<T>(name: string): Steno.NodeProvider<T> | undefined {
+    return this.#databases.get(name)
+  }
 }

packages/fastify/src/types.ts

@@ -1,13 +1,8 @@
-import type { NodeProvider, Steno } from '@stenodb/node'
+import type { Steno } from '@stenodb/node'
 
 declare module 'fastify' {
   export interface FastifyInstance {
     steno: {
-      create: <T>(
-        name: string,
-        entity: Steno.Entity<T>,
-        initialData?: T
-      ) => Promise<void>
       get: <T>(name: string) => Steno.NodeProvider<T> | undefined
     }
   }