fix: typescript interface

index.d.ts

@@ -1,40 +1,41 @@
 import type { FastifyPluginCallback } from 'fastify'
-import type { Document, Orama, ProvidedTypes, Results, SearchParams, create } from '@orama/orama'
+import type { TypedDocument, insert, Orama, Results, SearchParams, create, AnyOrama, PartialSchemaDeep, Schema } from '@orama/orama'
 
-interface OramaPersistence {
-  restore: () => Promise<ReturnType<typeof create> | null>
-  persist: (data: ReturnType<typeof create>) => Promise<any>
+interface FastifyOramaPersistence<T = any, O = any> {
+  restore: () => Promise<Orama<T> | null>
+  persist: (data: Orama<T>) => Promise<O>
 }
 
-declare class PersistenceInMemory implements OramaPersistence {
+
+declare class PersistenceInMemory<T = any, O = string | Buffer> implements FastifyOramaPersistence<T, O> {
   constructor(options?: {
     jsonIndex?: string,
   })
-  restore: () => Promise<Promise<Orama<ProvidedTypes>> | null>
-  persist: (data: Promise<Orama<ProvidedTypes>>) => Promise<string>
+  restore: () => Promise<Orama<T> | null>
+  persist: (data: Orama<T>) => Promise<O>
 }
 
-declare class PersistenceInFile implements OramaPersistence {
+declare class PersistenceInFile<T = any, O = string> implements FastifyOramaPersistence<T, O> {
   constructor(options?: {
     filePath?: string,
     format?: string,
     mustExistOnStart?: boolean
   })
-  restore: () => Promise<Promise<Orama<ProvidedTypes>> | null>
-  persist: (data: Promise<Orama<ProvidedTypes>>) => Promise<string>
+  restore: () => Promise<Orama<T> | null>
+  persist: (data: Orama<T>) => Promise<O>
 }
 
-type OramaPluginOptions = {
-  persistence?: OramaPersistence
+type FastifyOramaPluginOptions = {
+  persistence?: FastifyOramaPersistence
 } & Partial<Parameters<typeof create>[0]>
 
-declare const fastifyOrama: FastifyPluginCallback<OramaPluginOptions>
+declare const fastifyOrama: FastifyPluginCallback<FastifyOramaPluginOptions>
 
 declare module 'fastify' {
   interface FastifyInstance {
-    orama: {
-      insert: (document: Document) => Promise<string>,
-      search: (params: SearchParams) => Promise<Results>,
+    getOrama<T>(): {
+      insert: (document: PartialSchemaDeep<TypedDocument<Orama<T>>>) => Promise<string>,
+      search: (params: SearchParams<Orama<Schema<T>>, T>) => Promise<Results<Schema<T>>>,
       persist?: () => Promise<any>,
     }
   }

index.js

@@ -52,6 +52,9 @@ async function fastifyOrama (fastify, options) {
   }
 
   fastify.decorate('orama', oramaApi)
+  fastify.decorate('getOrama', function () {
+    return oramaApi
+  })
 }
 
 module.exports = fp(fastifyOrama, {

index.test-d.ts

@@ -1,17 +1,21 @@
 import { expectType } from 'tsd'
 
 import Fastify from 'fastify'
-import { Result } from '@orama/orama'
+import { TypedDocument, Orama, Results, Schema, InternalTypedDocument } from '@orama/orama'
 
 import { fastifyOrama, PersistenceInMemory, PersistenceInFile } from '.'
 
 const app = Fastify()
 
+const mySchema = {
+  quote: 'string',
+  author: 'string'
+} as const
+type MySchema = Schema<typeof mySchema>
+
+
 app.register(fastifyOrama, {
-  schema: {
-    quote: 'string',
-    author: 'string'
-  },
+  schema: mySchema,
   prefix: '/api/orama',
   language: 'en'
 })
@@ -37,12 +41,17 @@ app.register(fastifyOrama, {
   })
 })
 
-app.orama.insert({ quote: 'Hello', author: 'World' })
+const orama = app.getOrama<typeof mySchema>()
+const id = await orama.insert({ quote: 'Hello', author: 'World' })
+expectType<string>(id)
 
 app.get('/hello', async () => {
-  const result = await app.orama.search({ term: 'hello' })
 
-  expectType<Result[]>(result.hits)
+  const orama = app.getOrama<typeof mySchema>()
+  const result = await orama.search({ term: 'hello' })
+
+  expectType<Results<InternalTypedDocument<MySchema>>>(result)
+  expectType<string>(result.hits[0].document.author)
 
   return {
     hello: result.hits

test/index.test.js

@@ -72,3 +72,16 @@ it('Should throw when trying to register multiple instances without giving a nam
     strictEqual(error.message, 'fastify-orama is already registered')
   }
 })
+
+it('Expose a getOrama function', async () => {
+  const fastify = Fastify()
+
+  await fastify.register(fastifyOrama, {
+    schema: {
+      quote: 'string',
+      author: 'string'
+    }
+  })
+
+  strictEqual(fastify.orama, fastify.getOrama())
+})