chore: review tstyche test (#207)

* chore: review tstyche test

* refactor: types test

* refactor: change arrow functions to regular functions in test setup

* refactor: change import to type for Orama types

* refactor: update tsconfig and remove unused tstyche config

* refactor: simplify typescript script and remove tstyche config

Author: Puppo

index.d.ts

@@ -33,7 +33,7 @@ declare const fastifyOrama: FastifyPluginCallback<FastifyOramaPluginOptions>
 
 declare const oramaInternals: typeof internals
 
-interface OramaApi<T> {
+export 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>,

package.json

@@ -13,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 && ts-node test/types/index.ts",
+    "test": "npm run lint && npm run unit && npm run typescript",
     "posttest": "npm run clean",
     "typescript": "tstyche",
     "prepare": "husky",
@@ -48,10 +48,10 @@
     "borp": "^0.20.0",
     "c8": "^10.1.3",
     "fastify": "^5.4.0",
+    "fastify-tsconfig": "^3.0.0",
     "husky": "^9.1.7",
     "snazzy": "^9.0.0",
     "standard": "^17.1.2",
-    "ts-node": "^10.9.2",
     "tstyche": "^4.0.2",
     "typescript": "^5.8.3"
   },

test/types/index.ts

@@ -1,87 +1,121 @@
-import { expect, test } from 'tstyche'
+import { describe, expect, test } from 'tstyche'
 
-import { InternalTypedDocument, Orama, PartialSchemaDeep, Results, Schema, SearchParams, TypedDocument } from '@orama/orama'
+import type { InternalTypedDocument, Orama, PartialSchemaDeep, Results, Schema, SearchParams, TypedDocument } from '@orama/orama'
 import Fastify from 'fastify'
 import fp from 'fastify-plugin'
 
-import { PersistenceInFile, PersistenceInMemory, fastifyOrama } from '../../index.js'
-
-const app = Fastify()
+import { OramaApi, PersistenceInFile, PersistenceInMemory, fastifyOrama } from '../../index.js'
 
 const mySchema = {
   quote: 'string',
   author: 'string'
 } as const
+
 type MySchema = Schema<typeof mySchema>
 
+function baseSetup() {
+  const app = Fastify()
 
-app.register(fastifyOrama, {
-  schema: mySchema,
-  prefix: '/api/orama',
-  language: 'en'
-})
+  app.register(fastifyOrama, {
+    schema: mySchema,
+    persistence: new PersistenceInMemory()
+  })
 
-app.register(fastifyOrama, {
-  persistence: new PersistenceInMemory()
-})
+  return app.withOrama<typeof mySchema>()
+}
 
-app.register(fastifyOrama, {
-  persistence: new PersistenceInMemory({
-    jsonIndex: 'index.json'
-  })
-})
+function setupWithMorePersistenceOptions() {
+  const app = baseSetup()
 
-app.register(fastifyOrama, {
-  persistence: new PersistenceInFile()
-})
-app.register(fastifyOrama, {
-  persistence: new PersistenceInFile({
-    filePath: 'index.json',
-    format: 'json',
-    mustExistOnStart: true
+  app.register(fastifyOrama, {
+    schema: mySchema,
+    prefix: '/api/orama',
+    language: 'en'
   })
-})
 
-const appWithOrama = app.withOrama<typeof mySchema>()
+  app.register(fastifyOrama, {
+    persistence: new PersistenceInMemory({
+      jsonIndex: 'index.json'
+    })
+  })
 
-test('should enable the insertion of documents', () => {
-  appWithOrama.orama.insert({ quote: 'Hello', author: 'World' }).then(id => {
-    expect(id).type.toBe<string>()
+  app.register(fastifyOrama, {
+    persistence: new PersistenceInFile()
+  })
+  app.register(fastifyOrama, {
+    persistence: new PersistenceInFile({
+      filePath: 'index.json',
+      format: 'json',
+      mustExistOnStart: true
+    })
   })
-})
 
-test('should enable the searching of documents', () => {
-  appWithOrama.get('/hello', async () => {
+  return app.withOrama<typeof mySchema>()
+}
 
-    const {orama} = appWithOrama
-    const result = await orama.search({ term: 'hello' })
+describe('Fastify Orama', () => {
 
-    expect(result).type.toBe<Results<InternalTypedDocument<MySchema>>>()
-    expect(result.hits[0].document.author).type.toBe<string>()
+  test('should expose the Orama instance', async () => {
+    await (async function () {
+      const appWithOrama = baseSetup()
+      const id = await appWithOrama.orama.insert({ quote: 'Hello', author: 'World' })
+      expect(id).type.toBe<string>()
 
-    return {
-      hello: result.hits
-    }
+      appWithOrama.get('/hello', async () => {
+
+        const {orama} = appWithOrama
+        expect(orama).type.toBe<OramaApi<typeof mySchema>>()
+        const result = await orama.search({ term: 'hello' })
+
+        return {
+          hello: result.hits
+        }
+      })
+    })()
+  });
+
+  test('should enable the insertion of documents', () => {
+    const appWithOrama = setupWithMorePersistenceOptions()
+    appWithOrama.orama.insert({ quote: 'Hello', author: 'World' }).then(id => {
+      expect(id).type.toBe<string>()
+    })
   })
-})
 
-test('should expose the Orama API', () => {
-  expect(appWithOrama.orama).type.toBe<{
-    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>,
-  }>()
-})
+  test('should enable the searching of documents', () => {
+    const appWithOrama = setupWithMorePersistenceOptions()
+    appWithOrama.get('/hello', async () => {
 
+      const {orama} = appWithOrama
+      const result = await orama.search({ term: 'hello' })
 
-test('should enable the withOrama method', () => {
-  fp(function(fastify) {
-    const fastifyWithOrama = fastify.withOrama<typeof mySchema>()
+      expect(result).type.toBe<Results<InternalTypedDocument<MySchema>>>()
+      expect(result.hits[0].document.author).type.toBe<string>()
 
-    expect(fastifyWithOrama.orama).type.toBe<{
+      return {
+        hello: result.hits
+      }
+    })
+  })
+
+  test('should expose the Orama API', () => {
+    const appWithOrama = setupWithMorePersistenceOptions()
+    expect(appWithOrama.orama).type.toBe<{
       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>,
     }>()
   })
+
+
+  test('should enable the withOrama method', () => {
+    fp(function(fastify) {
+      const fastifyWithOrama = fastify.withOrama<typeof mySchema>()
+
+      expect(fastifyWithOrama.orama).type.toBe<{
+        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>,
+      }>()
+    })
+  })
 })

test/types/index.tst.ts

@@ -1,5 +1,6 @@
 {
+  "extends": "fastify-tsconfig",
   "compilerOptions": {
-    "esModuleInterop": true,
-  },
+    "strict": true,
+  }
 }