Closes #456
/claim #456

This PR turns the Orama completely type-safe, below some examples of how to use:

Schema

Now, if you want to have the type from the result of your schema, you can do the following:

import { Schema } from '@orama/orama'

const mySchema = {
  title: 'string'
} as const;
type MySchemaDocument = Schema<typeof mySchema>;

Be careful with as const, it is required to be able to correctly infer your schema, if you didn't make it const, your document will be inferred to never.

Create

By default, create will create the correct typings from schema automatically:

const db = await create({
  schema: {
    quote: 'string',
    author: 'string',
  },
})

The return type will be:

It also works for more complex schemas:

If you didn't customize the index, sorter, or documentStore, it will infer to the default implementations.

Insert & Update

During the insert, all the properties are optional and you can also specific custom properties, like:

const oldDocId1 = await insert(db, {
  quote: "Life is what happens when you're busy making other plans",
  author: 'John Lennon',
  customProp: 'Olá'
})

But, if you specify a wrong value for some value in the schema, for example passing a number to quote, you will receive an error:

Search

With search, you will have two behaviors, by default the result type will be the typed-schema:

But, in cases where the result will be too much different from the typed-schema, you can do the following:

Also, now we automatically suggest options for groupBy.properties, sortBy.property and where, like this:

Currently, nested properties such as doc.title are not suggested even if you have schema support, but you can specify them without problems.

Sharing Typed Orama Instance

In cases where you need the type for Orama, you can do the following:

import { Schema, TypedDocument } from '@orama/orama'

const mySchema = {
  title: 'string'
} as const;

type MyOrama = Orama<typeof mySchema>;

// the following will be the same as Schema<typeof mySchema>;
type MySchemaDocument = TypedDocument<MyOrama>

Hooks

The hooks from components also are correctly typed based on the schema:

But is not possible to infer extra properties, like when your schema has just title but in your document you also insert description.

In those cases, you should do the following:

const db = await create({  
  schema: {
    strings: 'string[]',
    num: 'number[]',
    b: 'boolean[]',
  },
  components: {
    beforeInsert: (orama, key, doc) => {
      type MyDoc = { strings: string[], num: number[], b: boolean[], extraProperty: string };
      const typedDoc = doc as unknown as MyDoc
    }
  }
})

But nothing stops you from just grab the property you want, like:

console.log(doc!.extraProperty);

It just will just be typed as any.

Breaking Changes

I needed to upgrade the typescript to 5.0.0 because of the new modifier const, this makes it easier for the users to specify the schema without the need of doing { schema: { title: 'string' } as const }.