breaking: migrate to cjs

README.md

@@ -202,6 +202,58 @@ app.get('/genId', async function handler (req, reply) {
 })
 ```
 
+## Typescript
+
+This plugin comes with Typescript support out of the box.
+Using the `withOrama` helper, you can access the `orama` decorator in your Fastify application with the correct schema.
+
+```ts
+import Fastify from 'fastify'
+
+import { PersistenceInMemory, fastifyOrama } from 'fastify-orama'
+
+const app = Fastify()
+
+const mySchema = {
+  quote: 'string',
+  author: 'string'
+} as const
+
+await app.register(fastifyOrama, {
+  schema: mySchema,
+  persistence: new PersistenceInMemory()
+})
+
+const appWithOrama = app.withOrama<typeof mySchema>()
+const id = await appWithOrama.orama.insert({ quote: 'Hello', author: 'World' })
+
+appWithOrama.get('/hello', async () => {
+
+  const {orama} = appWithOrama
+  const result = await orama.search({ term: 'hello' })
+
+  return {
+    hello: result.hits
+  }
+})
+```
+
+Usage with `fastify-plugin`:
+
+```ts
+import fp from 'fastify-plugin'
+
+fp(function plugins(fastify) {
+  const fastifyWithOrama = fastify.withOrama<typeof mySchema>()
+
+  expectType<{
+    insert: (document: PartialSchemaDeep<TypedDocument<Orama<typeof mySchema>>>) => Promise<string>,
+    search: (params: SearchParams<Orama<Schema<typeof mySchema>>, typeof mySchema>) => Promise<Results<Schema<typeof mySchema>>>,
+    persist?: () => Promise<any>,
+  }>(fastifyWithOrama.orama)
+})
+```
+
 ## License
 
 fastifyOrama is licensed under the [MIT](LICENSE) license.

index.d.ts

@@ -1,42 +1,47 @@
 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>
+
+interface OramaApi<T> {
+  insert: (document: PartialSchemaDeep<TypedDocument<Orama<T>>>) => Promise<string>,
+  search: (params: SearchParams<Orama<Schema<T>>, T>) => Promise<Results<Schema<T>>>,
+  persist?: () => Promise<any>,
+}
 
 declare module 'fastify' {
   interface FastifyInstance {
-    orama: {
-      insert: (document: Document) => Promise<string>,
-      search: (params: SearchParams) => Promise<Results>,
-      persist?: () => Promise<any>,
-    }
+    withOrama<T>(): this & {
+      orama: OramaApi<T>
+    };
   }
 }
 

index.js

@@ -1,8 +1,10 @@
-import fp from 'fastify-plugin'
-import * as Orama from '@orama/orama'
+'use strict'
 
-import PersistenceInMemory from './lib/persistence/in-memory.js'
-import PersistenceInFile from './lib/persistence/in-file.js'
+const fp = require('fastify-plugin')
+const Orama = require('@orama/orama')
+
+const PersistenceInMemory = require('./lib/persistence/in-memory.js')
+const PersistenceInFile = require('./lib/persistence/in-file.js')
 
 const SKIP_METHODS = [
   'create'
@@ -49,17 +51,20 @@ async function fastifyOrama (fastify, options) {
     db = await Orama.create(oramaOptions)
   }
 
+  function withOrama () {
+    return this
+  }
+
   fastify.decorate('orama', oramaApi)
+  fastify.decorate('withOrama', withOrama)
 }
 
-export default fp(fastifyOrama, {
+module.exports = fp(fastifyOrama, {
   fastify: '4.x',
   name: 'fastify-orama'
 })
 
-export {
-  fastifyOrama,
-  PersistenceInMemory,
-  PersistenceInFile,
-  oramaInternals
-}
+module.exports.fastifyOrama = fastifyOrama
+module.exports.PersistenceInMemory = PersistenceInMemory
+module.exports.PersistenceInFile = PersistenceInFile
+module.exports.oramaInternals = oramaInternals

lib/persistence/in-file.js

@@ -1,6 +1,8 @@
-import path from 'node:path'
-import { existsSync } from 'node:fs'
-import { restoreFromFile, persistToFile } from '@orama/plugin-data-persistence/server'
+'use strict'
+
+const path = require('node:path')
+const { existsSync } = require('node:fs')
+const { restoreFromFile, persistToFile } = require('@orama/plugin-data-persistence/server')
 
 class PersistenceInFile {
   constructor (options = {}) {
@@ -30,4 +32,4 @@ class PersistenceInFile {
   }
 }
 
-export default PersistenceInFile
+module.exports = PersistenceInFile

lib/persistence/in-memory.js

@@ -1,4 +1,6 @@
-import { restore, persist } from '@orama/plugin-data-persistence'
+'use strict'
+
+const { restore, persist } = require('@orama/plugin-data-persistence')
 
 class PersistenceInMemory {
   constructor (options) {
@@ -18,4 +20,4 @@ class PersistenceInMemory {
   }
 }
 
-export default PersistenceInMemory
+module.exports = PersistenceInMemory

package.json

@@ -3,7 +3,6 @@
   "version": "0.7.0",
   "description": "Orama search-engine plugin for Fastify",
   "main": "index.js",
-  "type": "module",
   "types": "index.d.ts",
   "author": {
     "name": "Mateo Nunez",
@@ -14,7 +13,7 @@
     "lint": "standard | snazzy",
     "lint:fix": "standard --fix | snazzy",
     "pretest": "npm run clean",
-    "test": "npm run lint && npm run unit && npm run typescript",
+    "test": "npm run lint && npm run unit && npm run typescript && ts-node test/types/index.ts",
     "posttest": "npm run clean",
     "typescript": "tsd",
     "prepare": "husky install",
@@ -51,10 +50,14 @@
     "husky": "^8.0.3",
     "snazzy": "^9.0.0",
     "standard": "^17.1.0",
+    "ts-node": "^10.9.1",
     "tsd": "^0.29.0",
     "typescript": "^5.2.2"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "tsd": {
+    "directory": "test/types"
   }
 }

test/index.test.js

@@ -1,9 +1,9 @@
 'use strict'
 
-import { it } from 'node:test'
-import { ok, strictEqual } from 'node:assert'
-import Fastify from 'fastify'
-import fastifyOrama from '../index.js'
+const { it } = require('node:test')
+const { ok, strictEqual } = require('node:assert')
+const Fastify = require('fastify')
+const fastifyOrama = require('../index.js')
 
 it('Should register correctly fastifyOrama plugin', async () => {
   const fastify = Fastify()
@@ -72,3 +72,18 @@ it('Should throw when trying to register multiple instances without giving a nam
     strictEqual(error.message, 'fastify-orama is already registered')
   }
 })
+
+it('Expose a withOrama function', async () => {
+  const fastify = Fastify()
+
+  await fastify.register(fastifyOrama, {
+    schema: {
+      quote: 'string',
+      author: 'string'
+    }
+  })
+
+  const withOrama = fastify.withOrama()
+
+  strictEqual(fastify.orama, withOrama.orama)
+})

test/orama-proxy.test.js

@@ -1,9 +1,9 @@
 'use strict'
 
-import { it } from 'node:test'
-import { ok, strictEqual } from 'node:assert'
-import Fastify from 'fastify'
-import { fastifyOrama, oramaInternals } from '../index.js'
+const { it } = require('node:test')
+const { ok, strictEqual } = require('node:assert')
+const Fastify = require('fastify')
+const { fastifyOrama, oramaInternals } = require('../index.js')
 
 it('Should expose all the Orama APIs', async () => {
   const fastify = Fastify()

test/persistence.test.js

@@ -1,9 +1,11 @@
-import { describe, it } from 'node:test'
-import { strictEqual, match } from 'node:assert'
-import Fastify from 'fastify'
-import { fastifyOrama, PersistenceInMemory, PersistenceInFile } from '../index.js'
-import { create, insert } from '@orama/orama'
-import { persistToFile } from '@orama/plugin-data-persistence/server'
+'use strict'
+
+const { describe, it } = require('node:test')
+const { strictEqual, match } = require('node:assert')
+const Fastify = require('fastify')
+const { fastifyOrama, PersistenceInMemory, PersistenceInFile } = require('../index.js')
+const { create, insert } = require('@orama/orama')
+const { persistToFile } = require('@orama/plugin-data-persistence/server')
 
 async function buildFakeDb (filePath, format) {
   const db = await create({