@kontent-ai/gatsby-source/src/createSchemaCustomization.items.js

Source plugin providing Kontent.ai data from REST Delivery API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.kontentItemsCreateSchemaCustomization = void 0;
const client_1 = require("./client");
const naming_1 = require("./naming");
const getLanguageLinkExtension = () => ({
    name: (0, naming_1.getKontentItemLanguageLinkExtensionName)(),
    extend: () => ({
        async resolve(source, _args, 
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        context) {
            const nodesCodeNames = source.type === 'modular_content'
                ? source.value
                : source.modular_content;
            if (nodesCodeNames.length === 0) {
                return [];
            }
            const kontentItemNode = context.nodeModel.findRootNodeAncestor(source);
            const nodesLanguage = kontentItemNode[naming_1.PREFERRED_LANGUAGE_IDENTIFIER];
            const promises = nodesCodeNames.map(codename => context.nodeModel.findOne({
                query: {
                    filter: {
                        system: {
                            codename: {
                                eq: codename,
                            },
                        },
                        [naming_1.PREFERRED_LANGUAGE_IDENTIFIER]: {
                            eq: nodesLanguage,
                        },
                    },
                },
                type: (0, naming_1.getKontentItemInterfaceName)(),
            }));
            const nodes = await Promise.all(promises);
            return nodes;
        },
    }),
});
const getElementFieldsDefinitionForType = (type) => {
    const elementFields = {};
    for (const elementKey in type.elements) {
        if (Object.prototype.hasOwnProperty.call(type.elements, elementKey)) {
            const element = type.elements[elementKey];
            const elementType = (0, naming_1.getKontentItemElementTypeNameByType)(element.type);
            if (elementType !== '') {
                elementFields[elementKey] = {
                    type: elementType,
                };
            }
        }
    }
    return elementFields;
};
const createSchemaCustomization = async (api, pluginConfig) => {
    // TODO check https://github.com/gatsbyjs/gatsby/pull/14610/files/5c50c435ab49884b6d854cd07f20efd95d1e5f52#diff-29de3acf9ce1010435f2b2f0043dba8cR252
    // failing for update run
    const languageExtension = getLanguageLinkExtension();
    api.actions.createFieldExtension(languageExtension);
    const baseSchemaTypes = (0, naming_1.getKontentItemsSchemaNamingConfiguration)();
    api.actions.createTypes(baseSchemaTypes);
    const types = await (0, client_1.loadAllKontentTypesCached)(pluginConfig, api.cache);
    for (const type of types) {
        const kontentItemElementsTypeName = (0, naming_1.getKontentItemElementsSchemaTypeName)(type.system.codename);
        const elementsFieldDefinition = getElementFieldsDefinitionForType(type);
        const typeContainsElements = Object.keys(elementsFieldDefinition).length > 0;
        if (typeContainsElements) {
            const elementsTypeDef = api.schema.buildObjectType({
                name: kontentItemElementsTypeName,
                fields: elementsFieldDefinition,
                extensions: {
                    infer: false
                }
            });
            api.actions.createTypes(elementsTypeDef);
        }
        const typeName = (0, naming_1.getKontentItemNodeTypeName)(type.system.codename);
        const systemElementsTypeName = (0, naming_1.getKontentItemSystemElementTypeName)();
        const typeInterfaceName = (0, naming_1.getKontentItemInterfaceName)();
        const typeItemObjectDefinition = {
            name: typeName,
            fields: {
                system: `${systemElementsTypeName}!`,
                elements: kontentItemElementsTypeName,
                [naming_1.PREFERRED_LANGUAGE_IDENTIFIER]: 'String!',
            },
            interfaces: ['Node', typeInterfaceName],
            infer: false,
        };
        if (!typeContainsElements) {
            delete typeItemObjectDefinition.fields.elements;
        }
        const typeItemDef = api.schema.buildObjectType(typeItemObjectDefinition);
        api.actions.createTypes(typeItemDef);
    }
};
exports.kontentItemsCreateSchemaCustomization = createSchemaCustomization;
//# sourceMappingURL=createSchemaCustomization.items.js.map