supabase-js: Json type: Type instantiation is excessively deep and possibly infinite.

Bug report

  • I confirm this is a bug with Supabase, not with my own application.
  • I confirm I have searched the Docs, GitHub Discussions, and Discord.

Describe the bug

I have a Vue/Nuxt project with TypeScript which is throwing me an error with the profile table when I try to assign it to a variable based on the types generated from the DB. “Type instantiation is excessively deep and possibly infinite.”

The problematic column in question is one called “links” which stores JSONB data. The type that is generated from the Supabase Cli using the command npx supabase gen types typescript creates a self referencing type called Json.

export type Json =
  | string
  | number
  | boolean
  | null
  | { [key: string]: Json | undefined }
  | Json[]

With my (generated) profile row types looking like:

profile: {
  Row: {
    about: string | null
    available: string | null
    avatar: string | null
    avatar_url: string | null
    created_at: string | null
    id: number
    links: Json | null // this is the problematic column.
    location: string | null
    name: string | null
    poster: string | null
    poster_url: string | null
    tagline: string | null
    updated_at: string
    user_id: string
    username: string | null
  }
}

In my Pinia Vue store I get the following error when trying to assign it against these types.

import type { Database } from '@/types/supabase'
import { defineStore } from 'pinia'

export const useUserStore = defineStore('user', {
  state: () => ({
    profile: null as Database['public']['Tables']['profile']['Row'] | null
  }),
  actions: {
    setProfile(profile: Database['public']['Tables']['profile']['Row'] | null) {
      this.profile = profile // Here is where the TS error occurs.
    }
  }
})

I’m guessing this error happens because the generated type is self referencing and TS does not know how deep it would be?

To Reproduce

Steps to reproduce the behavior, please provide code snippets or a repository:

  1. Create a column and set its type to jsonb
  2. Generate types using the Supabase Cli
  3. Try to do something similar and see that TS complains.

Expected behavior

There should be no TS error.

Screenshots

Screenshot 2023-07-15 at 21 02 12 Screenshot 2023-07-15 at 21 16 15

System information

  • OS: Apple Macbook Pro M2 Ventura 13.4
  • Version of supabase-js: 2.26.0
  • Version of Node.js: 18.16.0

Additional context

I have not been able to see similar issues with other Supabase users but perhaps the use of JSONB is quite rare?

About this issue

  • Original URL
  • State: open
  • Created 3 years ago
  • Reactions: 34
  • Comments: 24 (3 by maintainers)

Most upvoted comments

@kiwicopple, this is such a simple thing to fix, yet it kills the developer experience (through extensive CPU usage / slow VSC) of anyone working on any half-serious project with Supabase and Typescript. Fixing these small issues has a much bigger impact to existing customers than anything you release during launch weeks, yet these never get prioritised, even (or especially if) the PRs are created by the community. Been a customer for 3+ years, and this issue is soon clocking in on 2 years, potentially longer. Very disappointing.

Using this StackOverflow post as an example, I have modified it for the Json type:

export type Json<D extends number = 9, DA extends any[] = []> =
	| string
	| number
	| boolean
	| null
	| (D extends DA['length'] ? any : { [key: string]: Json<D, [0, ...DA]> | undefined })
	| (D extends DA['length'] ? any : Json<D, [0, ...DA]>[]);

D defines the depth limit. When the depth limit is reached (D extends DA['length']), any is used to stop the recursion. Might require some testing but it works for me and retains type safety.

I did a little more digging and I think it may be an issue in combination with Vue’s reactivity and not directly Supabase afterall. You may see something similar with React?

If I try to a assign to a simple variable with let for example it’s okay but using ref() in Vue causes the warning, possibly due to Vue / TS not knowing how deep it would have to watch the reactive object.

If I use shallowRef() instead, it’s fine: https://vuejs.org/api/reactivity-advanced.html#shallowref

Bump

I gotta say I love supabase a ton. Such an amazing platform with fantastic UI/UX and so many great features. This Json typing issue has been the number 2 biggest hurdle for me in working with the supabase libraries. Number 1 was definitely database transactions (plpgsql ftl).

I remember seeing a PR up a while ago to swap the Json type for an unknown in the generated types. That would be quick and easy fix for this, and it could be behind a flag in the types generation script. Can’t find the PR anymore though… I’m just trying to avoid manually updating my generated types every time I re-generate them via cli.

Are there any plans on the supabase side to build Json field typing on top of Postgres? Like a Json column could have an expected schema which could be defined in the UI. This could then be used for types generation. Perhaps schema validation if you wanted to get fancy with it, but I assume that’s crossing into a territory the platform may not want to go toward.

Fix I’m using is to update your supabase generated types to have Json as below:

export type Json = Record<string, any>

The Json type does reference itself. Could it be that? I’ve also been having the same problem with the Json type columns.

Edit: changed my generated Json type to this and it all went away:

export type Json =
  | string
  | number
  | boolean
  | null
  | { [key: string]: any | undefined }
  | any[]

The error is complaining in my opinion that the line | { [key: string]: Json | undefined } has no end to type instantiation, which when you think about it, is true.

Its probably that loop of autoreferencing without finishing the main json reference.

@encima

I would suggest the following solution, since I implemented this, I’ve never had a problem:


type Primitive = string | number | boolean | null;

type JsonObject = { [key: string]: Json | undefined };

type JsonArray = Json[];

export type Json = Primitive | JsonObject | JsonArray;

This is still going on.

I made something for this before maybe someone wants to use it. When generating types with supabase, it replaces the json type with your custom type

app/types/generate-types.js:

import fs from 'fs';
import { execSync } from 'child_process';
import path from 'path';

// Run the Supabase type generator normally (change to your project ID and types file path ie.: ./app/types/database.types.ts)
execSync('npx supabase gen types --lang=typescript --project-id <YOUR-PROJECT-ID> --schema public > <YOUR-TYPES-FILE-PATH>',);

// Get the path to the output file
const typesFilePath = path.resolve('<YOUR-TYPES-FILE-PATH>');

let content = fs.readFileSync(typesFilePath, 'utf8');

// Find the Json type on the generated file and replace it
content = content.replace(/export type Json =\s*\|\s*string\s*\|\s*number\s*\|\s*boolean\s*\|\s*null\s*\|\s*{\s*\[key: string\]: Json \| undefined\s*}\s*\|\s*Json\[\]/g,
  'export type Json = Record<string, any>'); // You can change the type to any other type you want

fs.writeFileSync(typesFilePath, content);

console.log('Types generated and Json type simplified successfully.');

and on package.json:

...

  "scripts": {
...
    "generate-types": "node app/types/generate-types.js" // Change to your js path
  },

...

Also for validation on Supabase side, you can use pg_jsonschema: https://supabase.com/docs/guides/database/extensions/pg_jsonschema

I’m still dying

Just wanted to confirm this is still an issue at time of writing with the latest version of Vue and supabase-js and makes it impossible to work with supabase-js in any serious capacity when using Typescript and Vue.

Any status on this? :I

I have add this issue in various table but the solution for us has been to “patch” the generated type using type-fest, and only use this type in the rest of our app:

import type { MergeDeep } from "type-fest";
import type { Database as DatabaseGenerated } from "./database-generated.types";

export type Database = MergeDeep<
  DatabaseGenerated,
  {
    public: {
      Tables: {
        steps: { // replace with your table name
          Row: {
            config: Record<string, unknown>;
          };
          Insert: {
            config: Record<string, unknown>;
          };
          Update: {
            config: Record<string, unknown>;
          };
        };
      };
    };
  }
>;

It’s a bit of manual work but it worked well for us. We wanted to make this automatic by detecting the usage of Json inside the schema and replacing it with one of the version suggested above in this thread by using something similar to the schema offered by type-fest and we came up with the following solution (take this with a grain of salt, this is experimental):

type AsIsOrEmptyArray<A, U> =
  U extends Array<never> ? [A] : U extends Array<unknown> ? [A, ...U] : [A];

export type DeepReplaceJson<
  ObjectType,
  JsonType,
  Options extends SchemaOptions = {},
> =
  IsEqual<ObjectType, Json> extends true
    ? JsonType
    : ObjectType extends [infer First, ...infer Rest]
      ? Options["recurseIntoArrays"] extends false | undefined
        ? ObjectType
        : AsIsOrEmptyArray<
            DeepReplaceJson<First, JsonType>,
            DeepReplaceJson<Rest, JsonType>
          >
      : ObjectType extends Array<infer U>
        ? Options["recurseIntoArrays"] extends false | undefined
          ? ObjectType
          : Array<DeepReplaceJson<U, JsonType>>
        : ObjectType extends object
          ? SchemaObject<ObjectType, JsonType, Options>
          : ObjectType;

type SchemaObject<
  ObjectType extends object,
  K,
  Options extends SchemaOptions,
> = {
  [KeyType in keyof ObjectType]: ObjectType[KeyType] extends
    | readonly unknown[]
    | unknown[]
    ? Options["recurseIntoArrays"] extends false | undefined
      ? ObjectType[KeyType]
      : DeepReplaceJson<ObjectType[KeyType], K, Options>
    : DeepReplaceJson<ObjectType[KeyType], K, Options>;
};

export type SchemaOptions = {
  readonly recurseIntoArrays?: boolean | undefined;
};

// pick you favorite implementation from https://github.com/supabase/supabase-js/issues/808
export type JsonType = unknown;

export type Database = SimplifyDeep<
  DeepReplaceJson<DatabaseGenerated, JsonType, { recurseIntoArrays: true }>
>;


type X = Database["public"]["Tables"]["steps"]["Row"]["config"]; // type is `JsonType`

Bringing the comments from the related issue made for the CLI here.

Summary of suggestions:

  1. @daniel-j-h suggests to create all Json types as unknown and allow the developer to decide
  2. @shanehoban suggests creating a Json type as Record with a string key and any value
  3. @lauri865 suggests using the MergeDeep from the typefest library
  4. @antoniormrzz suggests changing the Json type to any
  5. @michaelpumo suggests that this could be a combination of Supabase’s type generation coupled with Vue’s reference handling for watching objects