cf-content-types-generator

You can enhance your generated types using optional renderers:

• JSDoc (-d, --jsdoc): Adds documentation comments to fields, skeletons, and entries.
• Type Guards (-g, --typeguard): Adds runtime predicate functions (e.g., isTypeAnimal) to check if an entry matches a specific content type.
• Response Aliases (-r, --response): Adds convenience type aliases for common response modifier combinations (e.g., TypeAnimalWithoutLinkResolutionResponse). Note that these aliases apply to the top-level entry type only; linked entries remain typed using standard contentful.js patterns.

cf-content-types-generator ./contentful-export.json -o src/@types/generated --jsdoc --typeguard --response

Version 3.x removes all pre-v10 output behavior. Follow these steps to migrate:

1. CLI: Remove --v10 and --localized flags. These will now cause errors.
2. Programmatic: Rename imports:
   • V10ContentTypeRenderer $\rightarrow$ ContentTypeRenderer
   • V10TypeGuardRenderer $\rightarrow$ TypeGuardRenderer
   • createV10Context() $\rightarrow$ createContext()
3. Regenerate: Run the generator to produce the new modern contentful.js typing model.
4. Update Code: Update any downstream code that relied on the old Entry<TypeFields> output format.

If you have a local JSON file generated via contentful space export, you can generate TypeScript types by passing the file path as the first argument and specifying an output directory with -o or --out.

cf-content-types-generator ./contentful-export.json -o src/@types/generated

You can fetch your content model directly from Contentful by providing your space credentials via the CLI. This method skips entry data and only reads schema data.

Required flags:

• -s, --spaceId: Your Contentful space ID.
• -t, --token: Your Contentful management token.
• -e, --environment: The environment name.
• -o, --out: The output directory for generated types.

cf-content-types-generator \
  -s <space-id> \
  -t <management-token> \
  -e <environment> \
  --proxy https://user:password@proxy.example:8443 \
  -o src/@types/generated

Install the generator as a development dependency using npm.

npm install --save-dev cf-content-types-generator

The cf-content-types-generator uses specific transformation rules to convert Contentful Content Type names into valid TypeScript identifiers for modules, skeletons, and field definitions.

When a name is processed, the following transformations are applied in order:

1. Spaces are removed.
2. Dashes (-) are replaced with double underscores (__).
3. Any characters that are not alphanumeric, underscores, or dollar signs are replaced with double underscores (__).
4. The first character is capitalized (UpperFirst).
5. If the resulting name does not start with Type, the prefix Type is added.

Generated Identifier Patterns:

• Module Name: Type<TransformedName>
• Skeleton Name: Type<TransformedName>Skeleton
• Fields Name: Type<TransformedName>Fields

The generated types are designed for use with contentful.js v10+. To get fully resolved assets and entries without unresolved-link unions, use the matching chain modifier on your client (e.g., .withoutUnresolvableLinks).

Example usage:

const articles = await client.withoutUnresolvableLinks.getEntries<TypeBlogArticleSkeleton>({
  content_type: 'blogArticle',
  include: 4,
});

// Accessing fields is now type-safe
articles.items[0]?.fields.image?.fields.file?.url;

const articles = await client.withoutUnresolvableLinks.getEntries<TypeBlogArticleSkeleton>({
  content_type: 'blogArticle',
  include: 4,
});

articles.items[0]?.fields.image?.fields.file?.url;
articles.items[0]?.fields.category?.[0]?.fields;

If you need to use the generator within your own code, you can use the CFDefinitionsBuilder and pass in specific renderers. You can extend BaseContentTypeRenderer or implement the Renderer interface for custom output.

import {
  CFDefinitionsBuilder,
  ContentTypeRenderer,
  ResponseTypeRenderer,
  TypeGuardRenderer,
} from 'cf-content-types-generator';

const builder = new CFDefinitionsBuilder([
  new ContentTypeRenderer(),
  new TypeGuardRenderer(),
  new ResponseTypeRenderer(),
]);

The following flags are available for the cf-content-types-generator CLI:

The primary entry point for the package is CFDefinitionsBuilder. You can use it to orchestrate the generation of TypeScript definitions from Contentful content type definitions. It is available as both a default and a named export.

To use it, you typically instantiate the builder and call its methods to configure the source (either a local JSON file or by fetching directly from Contentful) and the output format (via renderers).

import CFDefinitionsBuilder from 'cf-content-types-generator';

// Example usage pattern
const builder = new CFDefinitionsBuilder();
// ... configure source and renderers

The src/renderer/type module provides the core engine for transforming Contentful content type definitions into various code representations (like TypeScript types or JSDoc).

To use the rendering engine, you typically interact with one of the specialized renderer classes:

• Renderer: The primary entrypoint for the rendering process.
• JsDocRenderer: Generates JSDoc comments.
• TypeGuardRenderer: Generates TypeScript type guards.
• ResponseTypeRenderer: Generates TypeScript interfaces/types representing API responses.

All renderers operate within a RenderContext, which can be initialized using createContext.

import { Renderer, createContext } from 'cf-content-types-generator/renderer/type';

// Example conceptual usage:
const context = createContext(options);
const renderer = new Renderer(context);
const output = renderer.render(contentTypeDefinition);