@anywayseo/gatsby-plugin 1.0.0 → 2.0.0

package/utils/strapi-source/schema/site.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.site = void 0;
+exports.site = `
+    # === STRAPI SITE DEFINITIONS ===
+    type StrapiSite implements Node {
+      id: ID!
+      name: String
+      locale: String
+      currency: String
+      seo: Seo
+      logo: Image
+    }
+  `;

package/utils/{strapi-client.d.ts → strapi-source/strapi-client/index.d.ts}

@@ -2,5 +2,6 @@ export declare class StrapiClient {
     private apiUrl;
     private accessToken;
     constructor(apiUrl?: string, accessToken?: string);
-    fetch(path: string): Promise<Response>;
+    fetch<T = any>(path: string): Promise<T>;
+    getApiUrl(): string;
 }

package/utils/strapi-source/strapi-client/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiClient = void 0;
+class StrapiClient {
+    constructor(apiUrl, accessToken) {
+        if (!apiUrl || !accessToken) {
+            throw new Error('Missing STRAPI_API_URL or STRAPI_TOKEN in environment variables.');
+        }
+        this.apiUrl = apiUrl;
+        this.accessToken = accessToken;
+    }
+    fetch(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield fetch(`${this.apiUrl}/api/${path}`, {
+                    headers: {
+                        Authorization: `Bearer ${this.accessToken}`,
+                    },
+                });
+                if (!result.ok) {
+                    throw new Error(`Fetch Error with status ${result.status}: ${result.statusText}`);
+                }
+                const data = yield result.json();
+                return data;
+            }
+            catch (error) {
+                throw new Error(`Error occurred while fetching ${path}: ${error}`);
+            }
+        });
+    }
+    getApiUrl() {
+        return this.apiUrl;
+    }
+}
+exports.StrapiClient = StrapiClient;

package/utils/strapi-source/strapi-content/clean-entity.d.ts

@@ -0,0 +1,2 @@
+import type { Entity, Schema } from './types';
+export declare function cleanEntity(entity: Entity, contentTypeUid: string, schemas: Schema[]): Entity;

package/utils/strapi-source/strapi-content/clean-entity.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanEntity = cleanEntity;
+const helpers_1 = require("./helpers");
+const utils_1 = require("./utils");
+const MEDIA_FIELDS = [
+    'id',
+    'name',
+    'alternativeText',
+    'caption',
+    'width',
+    'height',
+    'formats',
+    'hash',
+    'ext',
+    'mime',
+    'size',
+    'url',
+    'previewUrl',
+    'createdAt',
+    'updatedAt',
+    'documentId',
+    'publishedAt',
+];
+const restrictedFields = new Set(['__component', 'children', 'fields', 'internal', 'parent']);
+function cleanAttributes(entity, currentSchema, schemas) {
+    return Object.entries(entity).reduce((accumulator, [name, value]) => {
+        const attribute = currentSchema.schema.attributes[name];
+        const attributeName = restrictedFields.has(name)
+            ? (0, utils_1.toSnakeCase)(`strapi_${name.startsWith('__') ? name.slice(2) : name}`)
+            : name;
+        if (!(attribute === null || attribute === void 0 ? void 0 : attribute.type)) {
+            accumulator[attributeName] = value;
+            return accumulator;
+        }
+        if (attribute.type === 'richtext') {
+            return Object.assign(Object.assign({}, accumulator), { [attributeName]: {
+                    data: value || '',
+                    medias: [],
+                } });
+        }
+        if (!value) {
+            accumulator[attributeName] = value;
+            return accumulator;
+        }
+        if (attribute.type === 'dynamiczone') {
+            return Object.assign(Object.assign({}, accumulator), { [attributeName]: value.map((entity) => {
+                    const schema = (0, helpers_1.getContentTypeSchema)(schemas, entity.__component);
+                    if (!schema) {
+                        return entity;
+                    }
+                    return cleanAttributes(entity, schema, schemas);
+                }) });
+        }
+        if (attribute.type === 'component') {
+            const schema = (0, helpers_1.getContentTypeSchema)(schemas, attribute.component);
+            if (!schema) {
+                return accumulator;
+            }
+            if (attribute.repeatable) {
+                return Object.assign(Object.assign({}, accumulator), { [attributeName]: value.map((entity) => cleanAttributes(entity, schema, schemas)) });
+            }
+            return Object.assign(Object.assign({}, accumulator), { [attributeName]: cleanAttributes(value, schema, schemas) });
+        }
+        if (attribute.type === 'media') {
+            if (Array.isArray(value)) {
+                return Object.assign(Object.assign({}, accumulator), { [attributeName]: value.map((data) => (0, utils_1.pick)(data, MEDIA_FIELDS)) });
+            }
+            return Object.assign(Object.assign({}, accumulator), { [attributeName]: value ? (0, utils_1.pick)(value, MEDIA_FIELDS) : undefined });
+        }
+        if (attribute.type === 'relation') {
+            const schema = (0, helpers_1.getContentTypeSchema)(schemas, attribute.target);
+            if (!schema) {
+                return accumulator;
+            }
+            if (Array.isArray(value)) {
+                return Object.assign(Object.assign({}, accumulator), { [attributeName]: value.map((data) => {
+                        return cleanAttributes(data, schema, schemas);
+                    }) });
+            }
+            return Object.assign(Object.assign({}, accumulator), { [attributeName]: cleanAttributes(value, schema, schemas) });
+        }
+        accumulator[attributeName] = value;
+        return accumulator;
+    }, {});
+}
+function cleanEntity(entity, contentTypeUid, schemas) {
+    const contentTypeSchema = (0, helpers_1.getContentTypeSchema)(schemas, contentTypeUid);
+    if (!contentTypeSchema) {
+        return entity;
+    }
+    return cleanAttributes(entity, contentTypeSchema, schemas);
+}

package/utils/strapi-source/strapi-content/create-nodes.d.ts

@@ -0,0 +1,3 @@
+import type { NodeInput, SourceNodesArgs } from 'gatsby';
+import type { Entity, Schema } from './types';
+export declare function createNodes(entity: Entity, uid: string, schemas: Schema[], actions: SourceNodesArgs): NodeInput[];

package/utils/strapi-source/strapi-content/create-nodes.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = createNodes;
+const helpers_1 = require("./helpers");
+const utils_1 = require("./utils");
+function prepareNodeId(parentNode, attributeName, name) {
+    return `${parentNode[utils_1.STRAPI_ID_PROPERTY]}-${parentNode.internal.type}-${attributeName}-${name}`;
+}
+function prepareTextNode(text, context) {
+    const { parentNode, attributeName, actions } = context;
+    const { createContentDigest, createNodeId } = actions;
+    const id = createNodeId(prepareNodeId(parentNode, attributeName, 'TextNode'));
+    const textNode = {
+        id,
+        parent: parentNode.id,
+        children: [],
+        internal: {
+            type: `${parentNode.internal.type}_${attributeName}_TextNode`.toUpperCase(),
+            mediaType: `text/markdown`,
+            content: text,
+            contentDigest: createContentDigest(text),
+        },
+        [attributeName]: text,
+    };
+    return textNode;
+}
+function prepareJsonNode(json, context) {
+    const { parentNode, attributeName, actions } = context;
+    const { createContentDigest, createNodeId } = actions;
+    const id = createNodeId(prepareNodeId(parentNode, attributeName, 'JSONNode'));
+    const jsonNode = {
+        id,
+        parent: parentNode.id,
+        children: [],
+        internal: {
+            type: `${parentNode.internal.type}_${attributeName}_JSONNode`.toUpperCase(),
+            mediaType: `application/json`,
+            content: JSON.stringify(json),
+            contentDigest: createContentDigest(json),
+        },
+        strapi_json_value: json,
+    };
+    return jsonNode;
+}
+function prepareMediaNode(media, context) {
+    const { parentNode, actions } = context;
+    const { createNodeId, createContentDigest } = actions;
+    const nodeType = 'STRAPI__MEDIA';
+    const id = createNodeId(`${nodeType}-${media.id}`);
+    const mediaNode = Object.assign(Object.assign({}, media), { id, parent: parentNode.id, children: [], internal: {
+            type: nodeType,
+            content: JSON.stringify(media),
+            contentDigest: createContentDigest(media),
+        }, [utils_1.STRAPI_ID_PROPERTY]: media.id, documentId: media.documentId });
+    return mediaNode;
+}
+function prepareRelationNode(relation, context) {
+    const { parentNode, targetSchemaUid, schemas, actions } = context;
+    const { createNodeId, createContentDigest } = actions;
+    const nodeType = (0, helpers_1.makeParentNodeName)(schemas, targetSchemaUid);
+    const id = createNodeId(`${nodeType}-${relation.id}`);
+    const node = Object.assign(Object.assign({}, relation), { id, parent: parentNode.id, children: [], internal: {
+            type: nodeType,
+            content: JSON.stringify(relation),
+            contentDigest: createContentDigest(relation),
+        }, [utils_1.STRAPI_ID_PROPERTY]: relation.id, documentId: relation.documentId });
+    return node;
+}
+function createNodes(entity, uid, schemas, actions) {
+    var _a;
+    const { createNodeId, createContentDigest, getNode } = actions;
+    const nodes = [];
+    const nodeType = (0, helpers_1.makeParentNodeName)(schemas, uid);
+    const schema = (0, helpers_1.getContentTypeSchema)(schemas, uid);
+    if (!schema) {
+        return [];
+    }
+    let entryNode = {
+        id: createNodeId(`${nodeType}-${entity.id}`),
+        parent: null,
+        children: [],
+        internal: {
+            type: nodeType,
+            content: JSON.stringify(entity),
+            contentDigest: createContentDigest(entity),
+        },
+        [utils_1.STRAPI_ID_PROPERTY]: entity.id,
+        documentId: entity.documentId,
+    };
+    for (const attributeName of Object.keys(entity)) {
+        const value = entity[attributeName];
+        const attribute = schema.schema.attributes[attributeName];
+        const type = attribute === null || attribute === void 0 ? void 0 : attribute.type;
+        if (value) {
+            if (type === 'dynamiczone') {
+                for (const v of value) {
+                    const componentNodeName = (0, helpers_1.makeParentNodeName)(schemas, v.strapi_component);
+                    const componentsNodes = createNodes(v, v.strapi_component, schemas, actions).flat();
+                    entity[`${attributeName}___NODE`] = [
+                        ...(entity[`${attributeName}___NODE`] || []),
+                        ...componentsNodes.filter(({ internal }) => internal.type === componentNodeName).map(({ id }) => id),
+                    ];
+                    for (const node of componentsNodes) {
+                        nodes.push(node);
+                    }
+                }
+                delete entity[attributeName];
+            }
+            if (type === 'component') {
+                const componentSchema = (0, helpers_1.getContentTypeSchema)(schemas, attribute.component);
+                if (!componentSchema) {
+                    continue;
+                }
+                const componentNodeName = (0, helpers_1.makeParentNodeName)(schemas, componentSchema.uid);
+                if (attribute.repeatable) {
+                    const componentNodes = value.flatMap((entity) => createNodes(entity, attribute.component, schemas, actions));
+                    entity[`${attributeName}___NODE`] = componentNodes
+                        .filter(({ internal }) => internal.type === componentNodeName)
+                        .map(({ id }) => id);
+                    for (const node of componentNodes) {
+                        nodes.push(node);
+                    }
+                }
+                else {
+                    const componentNodes = createNodes(value, attribute.component, schemas, actions).flat();
+                    const foundNode = componentNodes.find(({ internal }) => internal.type === componentNodeName);
+                    if (foundNode) {
+                        entity[`${attributeName}___NODE`] = foundNode.id;
+                    }
+                    for (const node of componentNodes) {
+                        nodes.push(node);
+                    }
+                }
+                delete entity[attributeName];
+            }
+            if (type === 'richtext') {
+                const textNode = prepareTextNode(value.data, { parentNode: entryNode, attributeName, actions });
+                entity[attributeName][`data___NODE`] = textNode.id;
+                nodes.push(textNode);
+                delete entity[attributeName].data;
+            }
+            if (type === 'json') {
+                const jsonNode = prepareJsonNode(value, { parentNode: entryNode, attributeName, actions });
+                entryNode.children = [...((_a = entryNode.children) !== null && _a !== void 0 ? _a : []), jsonNode.id];
+                entity[`${attributeName}___NODE`] = jsonNode.id;
+                nodes.push(jsonNode);
+                delete entity[attributeName];
+            }
+            if (type == 'media') {
+                const context = {
+                    parentNode: entryNode,
+                    actions,
+                };
+                if (Array.isArray(value)) {
+                    const mediaNodes = value.map((relation) => prepareMediaNode(relation, context));
+                    entity[`${attributeName}___NODE`] = mediaNodes.map(({ id }) => id);
+                    for (const node of mediaNodes) {
+                        if (!getNode(node.id)) {
+                            nodes.push(node);
+                        }
+                    }
+                }
+                else {
+                    const mediaNode = prepareMediaNode(value, context);
+                    entity[`${attributeName}___NODE`] = mediaNode.id;
+                    if (!getNode(mediaNode.id)) {
+                        nodes.push(mediaNode);
+                    }
+                }
+                delete entity[attributeName];
+            }
+            if (type === 'relation') {
+                const context = {
+                    parentNode: entryNode,
+                    targetSchemaUid: attribute.target,
+                    schemas,
+                    actions,
+                };
+                if (Array.isArray(value)) {
+                    const relationNodes = value.map((relation) => prepareRelationNode(relation, context));
+                    entity[`${attributeName}___NODE`] = relationNodes.map(({ id }) => id);
+                    for (const node of relationNodes) {
+                        if (!getNode(node.id)) {
+                            nodes.push(node);
+                        }
+                    }
+                }
+                else {
+                    const node = prepareRelationNode(value, context);
+                    entity[`${attributeName}___NODE`] = node.id;
+                    if (!getNode(node.id)) {
+                        nodes.push(node);
+                    }
+                }
+                delete entity[attributeName];
+            }
+        }
+    }
+    entryNode = Object.assign(Object.assign({}, entity), entryNode);
+    nodes.push(entryNode);
+    return nodes;
+}

package/utils/strapi-source/strapi-content/delete-nodes.d.ts

@@ -0,0 +1,3 @@
+import type { SourceNodesArgs } from 'gatsby';
+import type { Entity, SchemaEndpoint } from './types';
+export declare function deleteNodes(data: Entity[][], endpoints: SchemaEndpoint[], args: SourceNodesArgs): void;

package/utils/strapi-source/strapi-content/delete-nodes.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteNodes = deleteNodes;
+const helpers_1 = require("./helpers");
+const utils_1 = require("./utils");
+const buildMapFromNodes = (nodes) => {
+    return nodes.reduce((map, node) => {
+        var _a, _b;
+        const id = node.id;
+        const nodeName = (_a = node.internal) === null || _a === void 0 ? void 0 : _a.type;
+        const strapiId = node[utils_1.STRAPI_ID_PROPERTY];
+        if (nodeName.includes('STRAPI__COMPONENT_')) {
+            return map;
+        }
+        if (nodeName.includes('_JSONNODE')) {
+            return map;
+        }
+        if (nodeName.includes('_TEXTNODE')) {
+            return map;
+        }
+        if (nodeName && id && strapiId) {
+            map[nodeName] = [{ id, [utils_1.STRAPI_ID_PROPERTY]: String(strapiId) }, ...((_b = map[nodeName]) !== null && _b !== void 0 ? _b : [])];
+        }
+        return map;
+    }, {});
+};
+const buildMapFromData = (data, endpoints) => {
+    const map = {};
+    if (data.length) {
+        for (const [index, { singularName }] of endpoints.entries()) {
+            const nodeName = (0, helpers_1.makeNodeName)(singularName);
+            if (data[index] && data[index].length) {
+                for (const entity of data[index]) {
+                    map[nodeName] = [{ [utils_1.STRAPI_ID_PROPERTY]: entity.id }, ...(map[nodeName] || [])];
+                }
+            }
+        }
+    }
+    return map;
+};
+const buildNodesToRemoveMap = (nodes, data, endpoints) => {
+    const existingNodes = buildMapFromNodes(nodes);
+    const newNodes = buildMapFromData(data, endpoints);
+    const nodesToRemove = Object.entries(existingNodes).reduce((accumulator, [name, value]) => {
+        const currentNodes = newNodes[name];
+        if (!currentNodes) {
+            return accumulator;
+        }
+        accumulator[name] = value.filter((index) => {
+            return !currentNodes.some((node) => node[utils_1.STRAPI_ID_PROPERTY] === index[utils_1.STRAPI_ID_PROPERTY]);
+        });
+        return accumulator;
+    }, {});
+    return nodesToRemove;
+};
+function deleteNodes(data, endpoints, args) {
+    const { reporter, actions, getNode, getNodes } = args;
+    const { touchNode, deleteNode } = actions;
+    const strapiNodes = getNodes().filter(helpers_1.isStrapiOrFileNode);
+    for (const node of strapiNodes) {
+        touchNode(node);
+    }
+    const nodesToRemoveMap = buildNodesToRemoveMap(strapiNodes, data, endpoints);
+    for (const [nodeName, nodesToRemove] of Object.entries(nodesToRemoveMap)) {
+        if (nodesToRemove.length) {
+            reporter.info(`Strapi: ${nodeName} deleting ${nodesToRemove.length}`);
+            for (const { id } of nodesToRemove) {
+                const node = getNode(String(id));
+                if (node) {
+                    touchNode(node);
+                    deleteNode(node);
+                }
+            }
+        }
+    }
+}

package/utils/strapi-source/strapi-content/download-media.d.ts

@@ -0,0 +1,15 @@
+import type { SourceNodesArgs } from 'gatsby';
+import type { StrapiClient } from '../strapi-client';
+import type { Entity, Schema } from './types';
+interface IDownloadMediaConfig {
+    apiUrl: string;
+    remoteFileHeaders?: Record<string, string>;
+}
+interface IDownloadMediaContext {
+    schemas: Schema[];
+    strapiClient: StrapiClient;
+    config: IDownloadMediaConfig;
+    args: SourceNodesArgs;
+}
+export declare function downloadMediaFiles(entities: Entity[], uid: string, context: IDownloadMediaContext): Promise<void>;
+export {};

package/utils/strapi-source/strapi-content/download-media.js

@@ -0,0 +1,174 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadMediaFiles = downloadMediaFiles;
+const gatsby_source_filesystem_1 = require("gatsby-source-filesystem");
+const commonmark_1 = require("commonmark");
+const qs_1 = __importDefault(require("qs"));
+const helpers_1 = require("./helpers");
+const reader = new commonmark_1.Parser();
+/** Retrieves all medias from the markdown */
+function extractFiles(text, apiUrl) {
+    var _a;
+    const files = [];
+    const parsed = reader.parse(text);
+    const walker = parsed.walker();
+    let event, node;
+    while ((event = walker.next())) {
+        node = event.node;
+        // process image nodes
+        if (event.entering && node.type === 'image') {
+            let destination;
+            const alternativeText = ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.literal) || '';
+            if (typeof node.destination === 'string' && /^\//.test(node.destination)) {
+                destination = `${apiUrl}${node.destination}`;
+            }
+            else if (typeof node.destination === 'string' && /^http/i.test(node.destination)) {
+                destination = node.destination;
+            }
+            if (destination) {
+                files.push({ url: destination, src: node.destination, alternativeText });
+            }
+        }
+    }
+    return files.filter(Boolean);
+}
+/** Download file and create node */
+function downloadFile(file, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { args, config } = context;
+        const { actions, cache, createNodeId, getNode } = args;
+        const { createNode, touchNode } = actions;
+        const { apiUrl, remoteFileHeaders } = config;
+        let fileNodeID = null;
+        const mediaDataCacheKey = `strapi-media-${file.id}`;
+        const cacheMediaData = yield cache.get(mediaDataCacheKey);
+        // If we have cached media data and it wasn't modified, reuse
+        // previously created file node to not try to redownload
+        if (cacheMediaData && cacheMediaData.updatedAt === file.updatedAt) {
+            fileNodeID = cacheMediaData.fileNodeID;
+            const existingNode = getNode(fileNodeID);
+            if (existingNode) {
+                touchNode(existingNode);
+            }
+        }
+        if (!fileNodeID) {
+            try {
+                const url = `${file.url.startsWith('http') ? '' : apiUrl}${file.url}`;
+                const fileNode = yield (0, gatsby_source_filesystem_1.createRemoteFileNode)({
+                    url,
+                    cache,
+                    httpHeaders: remoteFileHeaders || {},
+                    createNode,
+                    createNodeId,
+                });
+                if (fileNode) {
+                    fileNodeID = fileNode.id;
+                    yield cache.set(mediaDataCacheKey, { fileNodeID, updatedAt: file.updatedAt });
+                }
+            }
+            catch (error) {
+                console.log('Error while downloading media occurred:', error);
+            }
+        }
+        return fileNodeID;
+    });
+}
+/** Extract images and create remote nodes for images in all fields. */
+function extractImages(item, uid, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { schemas, strapiClient, config } = context;
+        const { apiUrl } = config;
+        const schema = (0, helpers_1.getContentTypeSchema)(schemas, uid);
+        if (!schema) {
+            return;
+        }
+        for (const attributeName of Object.keys(item)) {
+            const value = item[attributeName];
+            const attribute = schema.schema.attributes[attributeName];
+            const type = attribute === null || attribute === void 0 ? void 0 : attribute.type;
+            if (value && type) {
+                if (type === 'richtext') {
+                    const extractedFiles = extractFiles(value.data, apiUrl);
+                    const files = yield Promise.all(extractedFiles.map((_a) => __awaiter(this, [_a], void 0, function* ({ url }) {
+                        const filters = qs_1.default.stringify({ filters: { url: url.replace(`${apiUrl}`, '') } }, { encode: false });
+                        const result = yield strapiClient.fetch(`upload/files?${filters}`);
+                        const file = result.length ? result[0] : null;
+                        if (!file) {
+                            return;
+                        }
+                        const fileNodeID = yield downloadFile(file, context);
+                        return { fileNodeID, file };
+                    })));
+                    const fileNodes = files.filter(Boolean);
+                    for (const [index, fileNode] of fileNodes.entries()) {
+                        if ((fileNode === null || fileNode === void 0 ? void 0 : fileNode.fileNodeID) && (fileNode === null || fileNode === void 0 ? void 0 : fileNode.file)) {
+                            item[attributeName].medias.push({
+                                alternativeText: extractedFiles[index].alternativeText,
+                                url: extractedFiles[index].url,
+                                src: extractedFiles[index].src,
+                                localFile___NODE: fileNode.fileNodeID,
+                                file: fileNode.file,
+                            });
+                        }
+                    }
+                }
+                if (type === 'dynamiczone') {
+                    for (const element of value) {
+                        yield extractImages(element, element.strapi_component, context);
+                    }
+                }
+                if (type === 'component') {
+                    if (attribute.repeatable) {
+                        for (const element of value) {
+                            yield extractImages(element, attribute.component, context);
+                        }
+                    }
+                    else {
+                        yield extractImages(value, attribute.component, context);
+                    }
+                }
+                if (type === 'relation') {
+                    yield extractImages(value, attribute.target, context);
+                }
+                if (type === 'media') {
+                    const isMultiple = attribute.multiple;
+                    const imagesField = isMultiple ? value : [value];
+                    // Dowload all files
+                    const files = yield Promise.all(imagesField.map((file) => __awaiter(this, void 0, void 0, function* () {
+                        const fileNodeID = yield downloadFile(file, context);
+                        return fileNodeID;
+                    })));
+                    const images = files.filter(Boolean);
+                    if (images && images.length > 0) {
+                        if (isMultiple) {
+                            for (let index = 0; index < value.length; index++) {
+                                item[attributeName][index][`localFile___NODE`] = images[index];
+                            }
+                        }
+                        else {
+                            item[attributeName][`localFile___NODE`] = isMultiple ? images : images[0];
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+// Downloads media from image type fields
+function downloadMediaFiles(entities, uid, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(entities.map((entity) => extractImages(entity, uid, context)));
+    });
+}

package/utils/strapi-source/strapi-content/fetch-entity.d.ts

@@ -0,0 +1,4 @@
+import type { Reporter } from 'gatsby';
+import type { StrapiClient } from '../strapi-client';
+import type { Entity, Schema, SchemaEndpoint } from './types';
+export declare function fetchEntity({ endpoint, queryParams, uid }: SchemaEndpoint, schemas: Schema[], strapiClient: StrapiClient, reporter: Reporter): Promise<Entity[]>;