buro26-strapi-graphql 0.0.10 → 0.0.11

package/dist/server/bootstrap.d.ts

@@ -1,4 +1,4 @@
-import { Strapi } from '@strapi/strapi';
+import { type Strapi } from '@strapi/strapi';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => void;

package/dist/server/controllers/index.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     myController: ({ strapi }: {
-        strapi: import("@strapi/strapi").Strapi;
+        strapi: import("@strapi/types").Strapi;
     }) => {};
 };
 export default _default;

package/dist/server/destroy.d.ts

@@ -1,4 +1,4 @@
-import { Strapi } from '@strapi/strapi';
+import { type Strapi } from '@strapi/strapi';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => void;

package/dist/server/index.d.ts

@@ -1,9 +1,9 @@
-import { Strapi } from "@strapi/strapi";
-import { GraphQLExtension } from "./types";
+import { type Strapi } from '@strapi/strapi';
+import { type GraphQLExtension } from './types';
 declare const _default: {
     register: ({ strapi }: {
         strapi: Strapi;
-    }) => void;
+    }) => Promise<void>;
     bootstrap: ({ strapi }: {
         strapi: Strapi;
     }) => void;
@@ -24,7 +24,7 @@ declare const _default: {
         fileService: ({ strapi }: {
             strapi: Strapi;
         }) => {
-            getAllFilesInGraphQlDirectory(dirPath: string, arrayOfFiles?: GraphQLExtension[]): GraphQLExtension[];
+            getAllFilesInGraphQlDirectory(directoryPath: string, collectedExtensions?: GraphQLExtension[]): Promise<GraphQLExtension[]>;
         };
         graphQlService: ({ strapi }: {
             strapi: Strapi;
@@ -36,4 +36,10 @@ declare const _default: {
 };
 export default _default;
 export * from './types';
+export * from './utils';
 export declare const createGraphQLExtension: (factory: (strapi: Strapi) => GraphQLExtension) => GraphQLExtension;
+declare module '@strapi/strapi' {
+    interface Strapi {
+        createGraphQLExtension: (factory: (strapi: Strapi) => GraphQLExtension) => GraphQLExtension;
+    }
+}

package/dist/server/index.js

@@ -38,8 +38,9 @@ exports.default = {
     services: services_1.default,
     contentTypes: content_types_1.default,
     policies: policies_1.default,
-    middlewares: middlewares_1.default,
+    middlewares: middlewares_1.default
 };
 __exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
 const createGraphQLExtension = (factory) => factory(strapi);
 exports.createGraphQLExtension = createGraphQLExtension;

package/dist/server/register.d.ts

@@ -1,5 +1,5 @@
-import { Strapi } from '@strapi/strapi';
+import { type Strapi } from '@strapi/strapi';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
-}) => void;
+}) => Promise<void>;
 export default _default;

package/dist/server/register.js

@@ -1,32 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const nexus_1 = require("nexus");
-exports.default = ({ strapi }) => {
+exports.default = async ({ strapi }) => {
     const fileService = strapi
         .plugin('burotwosix-graphql-plugin')
         .service('fileService');
     const graphQlExtensionService = strapi
         .plugin('graphql')
         .service('extension');
-    console.log({
-        dirs: strapi.dirs,
-    });
     const extensions = [
-        ...fileService.getAllFilesInGraphQlDirectory(strapi.dirs.dist.src),
+        ...await fileService.getAllFilesInGraphQlDirectory(strapi.dirs.dist.src)
     ];
     graphQlExtensionService.use(() => ({
         plugins: [
-            (0, nexus_1.fieldAuthorizePlugin)(),
+            (0, nexus_1.fieldAuthorizePlugin)()
         ]
     }));
     for (const extension of extensions) {
-        (extension === null || extension === void 0 ? void 0 : extension.init) ? extension.init() : null;
+        (extension === null || extension === void 0 ? void 0 : extension.init) && extension.init();
         graphQlExtensionService.use(() => {
             var _a, _b, _c, _d, _e, _f;
             return ({
                 types: (_b = (_a = extension === null || extension === void 0 ? void 0 : extension.getTypes) === null || _a === void 0 ? void 0 : _a.call(extension)) !== null && _b !== void 0 ? _b : [],
                 resolvers: (_d = (_c = extension === null || extension === void 0 ? void 0 : extension.resolvers) === null || _c === void 0 ? void 0 : _c.call(extension)) !== null && _d !== void 0 ? _d : { Query: {}, Mutation: {} },
-                resolversConfig: (_f = (_e = extension === null || extension === void 0 ? void 0 : extension.getResolverConfig) === null || _e === void 0 ? void 0 : _e.call(extension)) !== null && _f !== void 0 ? _f : {},
+                resolversConfig: (_f = (_e = extension === null || extension === void 0 ? void 0 : extension.getResolverConfig) === null || _e === void 0 ? void 0 : _e.call(extension)) !== null && _f !== void 0 ? _f : {}
             });
         });
     }

package/dist/server/services/file-service.d.ts

@@ -1,8 +1,16 @@
-import { Strapi } from '@strapi/strapi';
-import { GraphQLExtension } from "../types";
+import { type Strapi } from '@strapi/strapi';
+import { GraphQLExtension } from '../types';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => {
-    getAllFilesInGraphQlDirectory(dirPath: string, arrayOfFiles?: GraphQLExtension[]): GraphQLExtension[];
+    /**
+     * Fetch all the files in the graphql directories within the given directory path
+     * Recursively searches for files in the graphql directory
+     * Returns an array of GraphQLExtension objects
+     *
+     * @param directoryPath
+     * @param collectedExtensions
+     */
+    getAllFilesInGraphQlDirectory(directoryPath: string, collectedExtensions?: GraphQLExtension[]): Promise<GraphQLExtension[]>;
 };
 export default _default;

package/dist/server/services/file-service.js

@@ -3,27 +3,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
 exports.default = ({ strapi }) => ({
-    getAllFilesInGraphQlDirectory(dirPath, arrayOfFiles = []) {
-        const files = fs_1.default.readdirSync(dirPath);
-        files.forEach((file) => {
-            if (fs_1.default.statSync(dirPath + "/" + file).isDirectory()) {
-                arrayOfFiles = this.getAllFilesInGraphQlDirectory(dirPath + "/" + file, arrayOfFiles);
-                return;
+    /**
+     * Fetch all the files in the graphql directories within the given directory path
+     * Recursively searches for files in the graphql directory
+     * Returns an array of GraphQLExtension objects
+     *
+     * @param directoryPath
+     * @param collectedExtensions
+     */
+    async getAllFilesInGraphQlDirectory(directoryPath, collectedExtensions = []) {
+        const fileEntries = await fs_1.promises.readdir(directoryPath);
+        // Create an array of promises for all the files
+        const filePromises = fileEntries.map(async (file) => {
+            const filePath = path_1.default.join(directoryPath, file);
+            const fileStats = await fs_1.promises.stat(filePath);
+            if (fileStats.isDirectory()) {
+                // Recursively get files from the directory
+                return this.getAllFilesInGraphQlDirectory(filePath, collectedExtensions);
             }
-            if (!dirPath.endsWith('/graphql') && !dirPath.includes('/graphql/')) {
+            if (!directoryPath.endsWith('/graphql') && !directoryPath.includes('/graphql/')) {
                 return;
             }
-            const ext = require(`${dirPath}/${file.replace('.js', '')}`);
-            if (!ext) {
+            const graphqlModule = require(filePath.replace('.js', ''));
+            if (!graphqlModule) {
                 return;
             }
-            arrayOfFiles.push({
-                ...ext,
-                ...(ext.default || {})
+            collectedExtensions.push({
+                ...graphqlModule,
+                ...(graphqlModule.default || {})
             });
         });
-        return arrayOfFiles;
+        // Wait for all the promises to resolve
+        await Promise.all(filePromises);
+        return collectedExtensions;
     }
 });

package/dist/server/services/graphql-service.d.ts

@@ -1,4 +1,4 @@
-import { Strapi } from '@strapi/strapi';
+import { type Strapi } from '@strapi/strapi';
 declare const _default: ({ strapi }: {
     strapi: Strapi;
 }) => {};

package/dist/server/services/index.d.ts

@@ -1,11 +1,11 @@
 declare const _default: {
     fileService: ({ strapi }: {
-        strapi: import("@strapi/strapi").Strapi;
+        strapi: import("@strapi/types").Strapi;
     }) => {
-        getAllFilesInGraphQlDirectory(dirPath: string, arrayOfFiles?: import("..").GraphQLExtension[]): import("..").GraphQLExtension[];
+        getAllFilesInGraphQlDirectory(directoryPath: string, collectedExtensions?: import("..").GraphQLExtension[]): Promise<import("..").GraphQLExtension[]>;
     };
     graphQlService: ({ strapi }: {
-        strapi: import("@strapi/strapi").Strapi;
+        strapi: import("@strapi/types").Strapi;
     }) => {};
 };
 export default _default;

package/dist/server/types.d.ts

@@ -25,4 +25,3 @@ export interface GraphQLExtension {
      */
     getResolverConfig: () => any;
 }
-

package/dist/server/utils/collection-type.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Easily resolve a collection of entities
+ *
+ * Based on node_modules/@strapi/plugin-graphql/server/services/builders/resolvers/association.js
+ */
+import { Entity, type ResolveArgs } from './types';
+export declare const resolveEntityCollection: <T extends Object>(contentType: string, resolveArgs: ResolveArgs) => Promise<Entity<T>[]>;
+export declare const resolveEntityRelationCollection: <T extends Object>(contentType: string, relationFieldName: keyof T, resolveArgs: ResolveArgs) => Promise<Entity<T>[]>;

package/dist/server/utils/collection-type.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Easily resolve a collection of entities
+ *
+ * Based on node_modules/@strapi/plugin-graphql/server/services/builders/resolvers/association.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEntityRelationCollection = exports.resolveEntityCollection = void 0;
+const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+const { toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+const resolveEntityCollection = async (contentType, resolveArgs) => {
+    const { buildQueriesResolvers } = strapi.plugin('graphql').service('builders').get('content-api');
+    const transformedArgs = transformArgs(resolveArgs.args, {
+        contentType: strapi.contentTypes[contentType],
+        usePagination: true
+    });
+    const { find } = buildQueriesResolvers({
+        contentType: strapi.contentTypes[contentType]
+    });
+    const items = await find(resolveArgs.parent, transformedArgs, resolveArgs.context);
+    return toEntityResponseCollection(items, {
+        args: transformedArgs,
+        resourceUID: contentType
+    });
+};
+exports.resolveEntityCollection = resolveEntityCollection;
+const resolveEntityRelationCollection = async (contentType, relationFieldName, resolveArgs) => {
+    const { buildAssociationResolver } = strapi.plugin('graphql').service('builders').get('content-api');
+    const find = buildAssociationResolver({
+        contentTypeUID: contentType,
+        attributeName: relationFieldName
+    });
+    return find(resolveArgs.parent, resolveArgs.args, resolveArgs.context);
+};
+exports.resolveEntityRelationCollection = resolveEntityRelationCollection;

package/dist/server/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './single-type';
+export * from './collection-type';
+export * from './override';

package/dist/server/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./single-type"), exports);
+__exportStar(require("./collection-type"), exports);
+__exportStar(require("./override"), exports);

package/dist/server/utils/override.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Override a field in a content type
+ *
+ * Based on node_modules/@strapi/plugin-graphql/server/services/builders/type.js
+ */
+import { type GraphQLResolveInfo } from 'graphql';
+type OverrideFieldOptions<T extends Object> = {
+    contentTypeName: string;
+    fieldName: keyof T;
+    type?: string;
+    authorize?: <Args = unknown, Context = unknown, Info = GraphQLResolveInfo>(parent: T, args: Args, context: Context, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+    resolve?: <Args = unknown, Context = unknown, Info = GraphQLResolveInfo>(parent: T, args: Args, context: Context, info: GraphQLResolveInfo) => unknown;
+};
+export declare const overrideField: <T extends Object>(t: any, overrideOptions: OverrideFieldOptions<T>) => void;
+export {};

package/dist/server/utils/override.js

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * Override a field in a content type
+ *
+ * Based on node_modules/@strapi/plugin-graphql/server/services/builders/type.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overrideField = void 0;
+const fp_1 = require("lodash/fp");
+const utils_1 = require("@strapi/utils");
+const getGraphQLService = strapi.plugin('graphql').service;
+const extension = getGraphQLService('extension');
+/**
+ * Add a scalar attribute to the type definition
+ *
+ * The attribute is added based on a simple association between a Strapi
+ * type and a GraphQL type (the map is defined in `strapiTypeToGraphQLScalar`)
+ */
+const addScalarAttribute = ({ builder, attributeName, attribute, ...options }) => {
+    const { mappers } = getGraphQLService('utils');
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+    builder.field(attributeName, { type: gqlType, ...options });
+};
+/**
+ * Add a component attribute to the type definition
+ *
+ * The attribute is added by fetching the component's type
+ * name and using it as the attribute's type
+ */
+const addComponentAttribute = ({ builder, attributeName, contentType, attribute, ...options }) => {
+    let localBuilder = builder;
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildComponentResolver } = getGraphQLService('builders').get('content-api');
+    const type = naming.getComponentNameFromAttribute(attribute);
+    if (attribute.repeatable) {
+        localBuilder = localBuilder.list;
+    }
+    // @ts-ignore
+    const targetComponent = strapi.getModel(attribute.component);
+    const resolve = buildComponentResolver({
+        contentTypeUID: contentType.uid,
+        attributeName,
+        strapi,
+    });
+    const args = getContentTypeArgs(targetComponent, { multiple: !!attribute.repeatable });
+    localBuilder.field(attributeName, { type, resolve, args, ...options });
+};
+/**
+ * Add a dynamic zone attribute to the type definition
+ *
+ * The attribute is added by fetching the dynamic zone's
+ * type name and using it as the attribute's type
+ */
+const addDynamicZoneAttribute = ({ builder, attributeName, contentType, ...options }) => {
+    const { naming } = getGraphQLService('utils');
+    const { ERROR_CODES } = getGraphQLService('constants');
+    const { buildDynamicZoneResolver } = getGraphQLService('builders').get('content-api');
+    const { components } = contentType.attributes[attributeName];
+    const isEmpty = components.length === 0;
+    const type = naming.getDynamicZoneName(contentType, attributeName);
+    const resolve = isEmpty
+        ? // If the dynamic zone don't have any component, then return an error payload
+            (0, fp_1.constant)({
+                code: ERROR_CODES.emptyDynamicZone,
+                message: `This dynamic zone don't have any component attached to it`,
+            })
+        : //  Else, return a classic dynamic-zone resolver
+            buildDynamicZoneResolver({
+                contentTypeUID: contentType.uid,
+                attributeName,
+            });
+    builder.list.field(attributeName, { type, resolve, ...options });
+};
+/**
+ * Add an enum attribute to the type definition
+ *
+ * The attribute is added by fetching the enum's type
+ * name and using it as the attribute's type
+ */
+const addEnumAttribute = ({ builder, attributeName, contentType, ...options }) => {
+    const { naming } = getGraphQLService('utils');
+    const type = naming.getEnumName(contentType, attributeName);
+    builder.field(attributeName, { type, ...options });
+};
+/**
+ * Add a media attribute to the type definition
+ */
+const addMediaAttribute = (options) => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    const extension = getGraphQLService('extension');
+    const { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+    const fileUID = 'plugin::upload.file';
+    if (extension.shadowCRUD(fileUID).isDisabled()) {
+        return;
+    }
+    const fileContentType = strapi.contentTypes[fileUID];
+    const resolve = buildAssociationResolver({
+        contentTypeUID: contentType.uid,
+        attributeName,
+        strapi,
+    });
+    const args = attribute.multiple ? getContentTypeArgs(fileContentType) : undefined;
+    const type = attribute.multiple
+        ? naming.getRelationResponseCollectionName(fileContentType)
+        : naming.getEntityResponseName(fileContentType);
+    builder.field(attributeName, { type, resolve, args, ...options });
+};
+/**
+ * Add a polymorphic relational attribute to the type definition
+ */
+const addPolymorphicRelationalAttribute = (options) => {
+    const { GENERIC_MORPH_TYPENAME } = getGraphQLService('constants');
+    const { naming } = getGraphQLService('utils');
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    let { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+    const { target } = attribute; // @ts-ignore
+    const isToManyRelation = attribute.relation.endsWith('Many');
+    if (isToManyRelation) {
+        builder = builder.list;
+    }
+    const resolve = buildAssociationResolver({
+        contentTypeUID: contentType.uid,
+        attributeName,
+        strapi,
+    });
+    // If there is no specific target specified, then use the GenericMorph type
+    if ((0, fp_1.isUndefined)(target)) {
+        builder.field(attributeName, {
+            type: GENERIC_MORPH_TYPENAME,
+            resolve,
+            ...options,
+        });
+    }
+    // If the target is an array of string, resolve the associated morph type and use it
+    else if ((0, fp_1.isArray)(target) && target.every(fp_1.isString)) {
+        const type = naming.getMorphRelationTypeName(contentType, attributeName);
+        builder.field(attributeName, { type, resolve, ...options });
+    }
+};
+/**
+ * Add a regular relational attribute to the type definition
+ */
+const addRegularRelationalAttribute = (options) => {
+    const { naming } = getGraphQLService('utils');
+    const { getContentTypeArgs } = getGraphQLService('builders').utils;
+    const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+    const extension = getGraphQLService('extension');
+    const { builder } = options;
+    const { attributeName, attribute, contentType } = options;
+    if (extension.shadowCRUD(attribute.target).isDisabled()) {
+        return;
+    }
+    // @ts-ignore
+    const isToManyRelation = attribute.relation.endsWith('Many');
+    const resolve = buildAssociationResolver({
+        contentTypeUID: contentType.uid,
+        attributeName,
+        strapi,
+    });
+    // @ts-ignore
+    const targetContentType = strapi.getModel(attribute.target);
+    const type = isToManyRelation
+        ? naming.getRelationResponseCollectionName(targetContentType)
+        : naming.getEntityResponseName(targetContentType);
+    const args = isToManyRelation ? getContentTypeArgs(targetContentType) : undefined;
+    const resolverPath = `${naming.getTypeName(contentType)}.${attributeName}`;
+    const resolverScope = `${targetContentType.uid}.find`;
+    extension.use({ resolversConfig: { [resolverPath]: { auth: { scope: [resolverScope] } } } });
+    builder.field(attributeName, { type, resolve, args, ...options });
+};
+const isPrivate = (contentType) => (attributeName) => {
+    return utils_1.contentTypes.isPrivateAttribute(contentType, attributeName);
+};
+const isDisabled = (contentType) => (attributeName) => {
+    return !extension.shadowCRUD(contentType.uid).field(attributeName).hasOutputEnabled();
+};
+const overrideField = (t, overrideOptions) => {
+    const utils = getGraphQLService('utils');
+    const { contentTypeName, fieldName } = overrideOptions;
+    const { isStrapiScalar, isComponent, isDynamicZone, isEnumeration, isMedia, isMorphRelation, isRelation, } = utils.attributes;
+    const contentType = strapi.contentTypes[contentTypeName];
+    const { attributes } = contentType;
+    // @ts-ignore
+    const attribute = attributes[fieldName];
+    if (isPrivate(contentType)(attribute)) {
+        return;
+    }
+    if (isDisabled(contentType)(attribute)) {
+        return;
+    }
+    // We create a copy of the builder (t) to apply custom
+    // rules only on the current attribute (eg: nonNull, list, ...)
+    let builder = t;
+    if (attribute.required) {
+        builder = builder.nonNull;
+    }
+    const options = {
+        builder,
+        attributeName: fieldName,
+        attribute,
+        contentType,
+        ...overrideOptions,
+    };
+    // Enums
+    if (isEnumeration(attribute)) {
+        // @ts-ignore
+        addEnumAttribute(options);
+    }
+    // Scalars
+    else if (isStrapiScalar(attribute)) {
+        // @ts-ignore
+        addScalarAttribute(options);
+    }
+    // Components
+    else if (isComponent(attribute)) {
+        // @ts-ignore
+        addComponentAttribute(options);
+    }
+    // Dynamic Zones
+    else if (isDynamicZone(attribute)) {
+        // @ts-ignore
+        addDynamicZoneAttribute(options);
+    }
+    // Media
+    else if (isMedia(attribute)) {
+        // @ts-ignore
+        addMediaAttribute(options);
+    }
+    // Polymorphic Relations
+    else if (isMorphRelation(attribute)) {
+        // @ts-ignore
+        addPolymorphicRelationalAttribute(options);
+    }
+    // Regular Relations
+    else if (isRelation(attribute)) {
+        // @ts-ignore
+        addRegularRelationalAttribute(options);
+    }
+};
+exports.overrideField = overrideField;

package/dist/server/utils/single-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Easily resolve a entity
+ *
+ * Based on node_modules/@strapi/plugin-graphql/server/services/builders/type.js
+ */
+import { Entity, ResolveArgs } from './types';
+type ResolveEntityArgs = Omit<ResolveArgs, 'args'> & {
+    args: {
+        id: string;
+    };
+};
+export declare const resolveEntity: <T extends Object>(contentType: string, resolveArgs: ResolveEntityArgs) => Promise<Entity<T>>;
+export {};

package/dist/server/utils/single-type.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Easily resolve a entity
+ *
+ * Based on node_modules/@strapi/plugin-graphql/server/services/builders/type.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEntity = void 0;
+const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+const resolveEntity = async (contentType, resolveArgs) => {
+    const { buildQueriesResolvers } = strapi.plugin('graphql').service('builders').get('content-api');
+    const transformedArgs = transformArgs(resolveArgs.args, { contentType });
+    const { findOne } = buildQueriesResolvers({ contentType });
+    const item = await findOne(resolveArgs.parent, transformedArgs, resolveArgs.context);
+    return toEntityResponse(item, {
+        args: resolveArgs.args,
+        resourceUID: contentType,
+    });
+};
+exports.resolveEntity = resolveEntity;

package/dist/server/utils/types.d.ts

@@ -0,0 +1,11 @@
+import type { GraphQLResolveInfo } from "graphql";
+export type ResolveArgs<Parent = unknown, Args = unknown, Context = unknown, Info = GraphQLResolveInfo> = {
+    parent: Parent;
+    args: Args;
+    context: Context;
+    info: Info;
+};
+export type Entity<T extends Object> = {
+    id: string;
+    attributes: Omit<T, 'id'>;
+};

package/dist/server/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });