generate:types - precise type-gen based on other args & support locale:all typings

[pabloelisseo]

Link to reproduction

No response

Describe the Bug

When using localisation, fields have the following structure:

     <field_name>: {
         <locale_1>: <value_1>,
         <locale_2>: <value_2>,
      },

However, when using npx payload generate:types we still get an interface for non localised content. E.g. the following collection:

const FormOptions: CollectionConfig = {
  slug: "form-options",
  labels: {
    singular: "Option",
    plural: "Options",
  },
  admin: {
    useAsTitle: "label",
  },
  versions: {
    drafts: true,
  },
  access: {},
  fields: [
    {
      name: "label",
      label: "Label",
      localized: true,
      type: "text",
      required: true,
    },
    {
      name: "value",
      label: "Value",
      type: "text",
      required: true,
    },
  ],
};

will get inferred the following interface:

export interface FormOption {
  id: string;
  label: string;
  value: string;
  updatedAt: string;
  createdAt: string;
  _status?: ('draft' | 'published') | null;
}

which is incorrect, the correct interface would be something like this:

export interface FormOption {
  id: string;
  label: {<locale_1>: string, <locale_2>: string};
  value: string;
  updatedAt: string;
  createdAt: string;
  _status?: ('draft' | 'published') | null;
}

inferring locale_1 and locale_2 from the payload.config.ts

To Reproduce

Create a Collection with localisation and try to get its type with payload generate:types

Payload Version

2.8.2

Adapters and Plugins

db-mongodb, bundler-webpack, richtext-slate, plugin-cloud-storage

[60pfennig]

The interface is correct. You can't receive all locales at once. You need to specify which locale you want to fetch via the locale query parameter. Otherwise the fallback language will get used.

[AlessioGr]

As of now the types output works as expected. You will only ever see the {<locale_1>: string, <locale_2>: string} output if you specify locale: all. Now the interface could be typed as string | {<locale_1>: string, <locale_2>: string} but that would make using this type a lot harder for the majority of users, as they would need to use type narrowing. Not worth it!

Instead, we could have 2 separate types - one with the full locale object, one without it. Depending on whether locale: all was used, we would infer the correct type for the user.

We should do the same thing for depth & relationships, where relationships would be strings for depth: 0 and objects for higher depths.

This however is a feature request for improving our type generation, not necessarily an issue with our current type gen, which is why I have converted this into a discussion. Our current type gen is set up to only output a single type per field, and this would already be the optimal to do it given the constraints