Improve TypeScript compatibility

[felixh10r]

Description

When using TypeScript > 5.1, there are numerous type check errors, most of which are related to Element implicitly has an 'any' type because expression of type 'string' can't be used to index type (…), but also Parameter (…) implicitly has an 'any' type.. My tsconfig.json already includes "skipLibCheck": true so there is not a lot I can do to work around besides pinning the TS version.

Steps to reproduce

Include typesense in a JS project and e.g. import type { SearchResponse } from "typesense/lib/Typesense/Documents";. Run tsc >= 5.2.

Expected Behavior

The project compiles without any issues.

Actual Behavior

There are a lot of typescript issues, probably depending on how much typesense interfaces are imported.

Metadata

Typesense Version:
1.7.2

OS:
MacOS 14.1.1
Node 21.2.0

[berenddeboer]

Yeah, just started using this, and it's unusable in typescript because of the errors. At least for me, Trying to figure out how I can ignore typechecks on this library only.

[CavalcanteLeo]

I'm working a lot with multi-search, and I created a util class to generate the type and return the include_fields as well, I mainly created it because I wanted a model that also gets the include_fields, I didn't want to get all data for each request, neither to manually add the include_fields.

// modeGenerator.ts
type ConfigObject = {
  type: 'string' | 'number' | 'boolean' | 'array' | 'object';
  required: boolean;
  items?: ConfigObject;
  properties?: Record<string, ConfigObject>;
};

// Utility type to generate TypeScript types from the configuration
export type GenerateType<T> = {
  [K in keyof T]: T[K] extends { type: 'object'; properties: infer P }
    ? GenerateType<P> &
        (K extends keyof T
          ? T[K] extends { required: true }
            ? {}
            : undefined
          : undefined)
    : T[K] extends { type: 'string' }
      ? K extends keyof T
        ? T[K] extends { required: true }
          ? string
          : string | undefined
        : never
      : T[K] extends { type: 'number' }
        ? K extends keyof T
          ? T[K] extends { required: true }
            ? number
            : number | undefined
          : never
        : T[K] extends { type: 'boolean' }
          ? K extends keyof T
            ? T[K] extends { required: true }
              ? boolean
              : boolean | undefined
            : never
          : T[K] extends { type: 'array'; items: infer I }
            ? (I extends { type: 'number' }
                ? number[]
                : I extends { type: 'string' }
                  ? string[]
                  : I extends { type: 'boolean' }
                    ? boolean[]
                    : I extends { type: 'object'; properties: infer P }
                      ? GenerateType<P>[]
                      : never) &
                (K extends keyof T
                  ? T[K] extends { required: true }
                    ? {}
                    : undefined
                  : undefined)
            : never;
};

// Function to generate INCLUDE_FIELDS string
export function generateIncludeFields(
  config: Record<string, ConfigObject>,
  prefix: string = ''
): string {
  const fields: string[] = [];

  for (const key in config) {
    if (config.hasOwnProperty(key)) {
      const path = prefix ? `${prefix}.${key}` : key;
      if (config[key].type === 'object' && config[key].properties) {
        const nestedFields = generateIncludeFields(config[key].properties!, path);
        fields.push(...nestedFields.split(',')); 
      } else {
        fields.push(path);
      }
    }
  }
  const joinedFields = fields.join(',');
  return joinedFields;
}

// Function to create a model with type and INCLUDE_FIELDS
export function createModel<T extends Record<string, ConfigObject>>(config: T) {
  const includeFields = generateIncludeFields(config);
  return { object: config, includeFields };
}

and to use it:

import { createModel, GenerateType } from 'YOUR_DIR';

const { includeFields, object } = createModel({
  name: { type: 'string', required: true },
  logo: { type: 'string', required: false },
  id: { type: 'string', required: true },
  location: {
    type: 'array',
    required: true,
    items: { type: 'number', required: true },
  },
  someObj: {
    type: 'object',
    required: true,
    properties: {
      id: { type: 'string', required: true },
      name: { type: 'string', required: true },
    },
  }
});

type MyBeautifulType = GenerateType<typeof object>;

// check the include_fields:
console.log(includeFields)

It's not perfect, but it does the job for what I need. Improvements are welcome, as they would benefit me

[tharropoulos]

I've published an unofficial typesafe client for Typesense you can check out here.

It provides native type inference based on collection schema, strictly typed search parameters and autocomplete and errors with explanations on filters and sorting.

[CavalcanteLeo]

I've published an unofficial typesafe client for Typesense you can check out here.

It provides native type inference based on collection schema, strictly typed search parameters and autocomplete and errors with explanations on filters and sorting.

You deserve my like not just for the type safety, but especially for not using Axios like the official lib does.

https://bundlephobia.com/package/axios@1.9.0

[Thaigun]

I've published an unofficial typesafe client for Typesense you can check out here.

It provides native type inference based on collection schema, strictly typed search parameters and autocomplete and errors with explanations on filters and sorting.

That's brilliant, I'll definitely try this out! And very well timed for us, as I had just setup things for the first time and was looking for better typing. What are the chances it gets promoted as official at some point?

[tharropoulos]

That's brilliant, I'll definitely try this out! And very well timed for us, as I had just setup things for the first time and was looking for better typing. What are the chances it gets promoted as official at some point?

Happy you find value in it! I don't think this would be feasible as a main client in terms of typing, as there's so much overhead when new features come out. For example, new filter syntax would need a bunch of new tests and changes in the type system. There's a lot of technical overhead with Typescript's type system in order for the community and the rest of the Typesense team to be able to maintain such a type-heavy client.

I would love to sprinkle some type magic here and there on this client too, and introduce some of the techniques for tree-shaking, if more of the community adopts it!

[Jackman3005]

I think it's awesome what you've done @tharropoulos !

We were unable to switch over to that client fully though. What would it take to fix this client sdk to at least remove these specific type errors?

[Jackman3005]

I found a fix that appears to work while waiting for this to be resolved...
I put the following in my tsconfig.json in the compilerOptions section.

    // Redirect typesense src imports to lib (temporary fix for https://github.com/typesense/typesense-js/issues/183)
    "paths": {
      "typesense/src/Typesense/*": ["./node_modules/typesense/lib/Typesense/*"]
    }

[tharropoulos]

@Jackman3005 I've posted a PR to export types on the main entrypoint of the library as well