Contentful external references, crashes rendering in ResouceLink

[NielsRavn]

We use contentful nataive external references and ran into a problem where the whole rendering process gets blocked by a throw line in the renderer:

cf-content-types-generator/src/renderer/field/render-prop-resource-link.ts

Line 27 in d26dc75

throw new Error(`Unknown type "${resource.type}"`);

To fix this i have made a generator file which just logs the unknown type instead, so that all the other types work, we might implement som rendering for it in the future but for now this works, and then we handle the type manually.

A field that fails, its the allowedResouces that messes it up:

{
  "id": "test",
  "name": "test",
  "type": "Array",
  "localized": false,
  "required": false,
  "validations": [
  ],
  "disabled": false,
  "omitted": false,
  "items": {
    "type": "ResourceLink",
    "validations": [
    ]
  },
  "allowedResources": [
    {
      "type": "TMDB:Person"
    },
    {
      "type": "TMDB:Movie"
    }
  ]
}

I have fixed it by writing a part of the rendering my self and removed the throw error part.

import {
    CFDefinitionsBuilder,
    type CFEditorInterface,
    createV10Context,
    type FieldRenderer,
    type RenderContext,
    renderTypeGeneric,
    V10ContentTypeRenderer,
    v10Renderers,
    V10TypeGuardRenderer
} from 'cf-content-types-generator';
import type { ContentTypeField, ContentTypeFieldType } from 'contentful';
import * as path from 'node:path';
import * as fs from 'node:fs';
import content from './export.json';

export default async function createContentfulTypes() {
    try {
        const renderes = new CustomV10ContentTypeRenderer();

        const builder = new CFDefinitionsBuilder([renderes, new V10TypeGuardRenderer()]);

        const editorInterfaces = content.editorInterfaces as CFEditorInterface[] | undefined;

        for (const model of content.contentTypes) {
            const editorInterface = editorInterfaces?.find((e) => e.sys.contentType.sys.id === model.sys.id);
            builder.appendType(model, editorInterface);
        }

        const outDir = path.resolve('./wwwdev/types/autogen/contentful');
        if (fs.existsSync(outDir)) {
            fs.rmSync(outDir, { recursive: true, force: true });
        }

        fs.mkdirSync(outDir);
        await builder.write('./wwwdev/types/autogen/contentful', async (filePath, content) =>
            fs.writeFileSync(filePath, content)
        );
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
}

class CustomV10ContentTypeRenderer extends V10ContentTypeRenderer {
    renderPropResourceLinkV10(field: ContentTypeField, context: RenderContext): string {
        for (const resource of field.allowedResources) {
            if (resource.type !== 'Contentful:Entry') {
                console.warn(`unknown type ${resource.type}`);
            }
        }

        context.imports.add({
            moduleSpecifier: 'contentful',
            namedImports: ['EntryFieldTypes', 'EntrySkeletonType'],
            isTypeOnly: true
        });

        return renderTypeGeneric('EntryFieldTypes.EntryResourceLink', 'EntrySkeletonType');
    }

    public createContext(): RenderContext {
        const context = createV10Context();
        context.getFieldRenderer = <FType extends ContentTypeFieldType>(fieldType: FType) => {
            if (fieldType === 'ResourceLink') return this.renderPropResourceLinkV10;

            return v10Renderers[fieldType] as FieldRenderer<FType>;
        };

        return context;
    }
}

createContentfulTypes();

The code can be called by creating a package.json script with this
tsx ./contentfulTypes.ts