@eddeee888/gcg-typescript-resolver-files
Version:
This [GraphQL Code Generator](https://www.the-guild.dev/graphql/codegen) plugin creates resolvers given GraphQL schema.
266 lines • 11.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.validatePresetConfig = void 0;
const tslib_1 = require("tslib");
const path = tslib_1.__importStar(require("path"));
const fs = tslib_1.__importStar(require("fs"));
const utils_1 = require("../utils");
const defaultResolverRelativeTargetDirMap = {
modules: 'resolvers',
merged: '',
};
const defaultTypeDefsFilePath = './typeDefs.generated.ts';
const defaultScalarsModule = 'graphql-scalars';
const validatePresetConfig = ({ add, resolverTypesPath = './types.generated.ts', resolverRelativeTargetDir, resolverMainFile = 'resolvers.generated.ts', resolverMainFileMode = 'merged', resolverGeneration = 'recommended', typeDefsFilePath = defaultTypeDefsFilePath, typeDefsFileMode: inputTypeDefsFileMode = 'merged', mappersRelativeTargetDir = './', mappersFileExtension = '.mappers.ts', mappersSuffix = 'Mapper', moduleNamingMode = 'last', mergeSchema, scalarsModule = 'graphql-scalars', scalarsOverrides = {}, mode = 'modules', whitelistedModules, blacklistedModules, externalResolvers = {}, typesPluginsConfig = {}, tsConfigFilePath = './tsconfig.json', fixObjectTypeResolvers = 'smart', emitLegacyCommonJSImports = true, }) => {
if (mode !== 'merged' && mode !== 'modules') {
throw new Error(utils_1.fmt.error('presetConfig.mode must be "merged" or "modules" (default is "modules")', 'Validation'));
}
if (typeof fixObjectTypeResolvers !== 'object' &&
fixObjectTypeResolvers !== 'smart' &&
fixObjectTypeResolvers !== 'disabled') {
throw new Error(utils_1.fmt.error('presetConfig.fixObjectTypeResolvers must be an object, "smart" or "disabled" (default is "smart")', 'Validation'));
}
if (typeof resolverGeneration !== 'object' &&
resolverGeneration !== 'disabled' &&
resolverGeneration !== 'recommended' &&
resolverGeneration !== 'minimal' &&
resolverGeneration !== 'all') {
throw new Error(utils_1.fmt.error('presetConfig.resolverGeneration must be an object, "disabled", "recommended", "minimal" or "all" (default is "recommended")', 'Validation'));
}
if (resolverMainFileMode !== 'merged' && resolverMainFileMode !== 'modules') {
throw new Error(utils_1.fmt.error('presetConfig.resolverMainFileMode must be "merged" or "modules" (default is "merged")', 'Validation'));
}
let typeDefsFileMode = inputTypeDefsFileMode;
if (mode === 'merged') {
// If mode is `merged`, `typeDefsFileMode` is also `merged` because there's no whitelisted or modules concepts
typeDefsFileMode = 'merged';
utils_1.logger.warn(`presetConfig.typeDefsFileMode has automatically been set to "merged" because presetConfig.mode is "merged"`);
}
if (typeDefsFileMode !== 'merged' &&
typeDefsFileMode !== 'modules' &&
typeDefsFileMode !== 'mergedWhitelisted') {
throw new Error(utils_1.fmt.error('presetConfig.typeDefsFileMode must be "merged", "mergedWhitelisted" or "modules" (default is "merged")', 'Validation'));
}
const finalModuleNamingMode = parseModuleNamingMode(moduleNamingMode);
if (!resolverTypesPath) {
throw new Error(utils_1.fmt.error('presetConfig.resolverTypesPath is required', 'Validation'));
}
const finalResolverRelativeTargetDir = resolverRelativeTargetDir === undefined
? defaultResolverRelativeTargetDirMap[mode]
: resolverRelativeTargetDir;
if (path.extname(resolverMainFile) === '') {
throw new Error(utils_1.fmt.error('presetConfig.mainFile must be a valid file name', 'Validation'));
}
if (whitelistedModules) {
if (!Array.isArray(whitelistedModules)) {
throw new Error(utils_1.fmt.error('presetConfig.whitelistedModules must be an array if provided', 'Validation'));
}
if (mode !== 'modules') {
throw new Error(utils_1.fmt.error('presetConfig.whitelistedModules can only be used with presetConfig.mode == "modules"', 'Validation'));
}
}
if (blacklistedModules) {
if (!Array.isArray(blacklistedModules)) {
throw new Error(utils_1.fmt.error('presetConfig.blacklistedModules must be an array if provided', 'Validation'));
}
if (mode !== 'modules') {
throw new Error(utils_1.fmt.error('presetConfig.blacklistedModules can only be used with presetConfig.mode == "modules"', 'Validation'));
}
}
const validatedTypesPluginsConfig = validateTypesPluginsConfig(typesPluginsConfig);
let finalTypeDefsFilePath = typeDefsFilePath;
if (finalTypeDefsFilePath === true) {
finalTypeDefsFilePath = defaultTypeDefsFilePath;
}
let finalScalarsModule = scalarsModule;
if (finalScalarsModule === true) {
finalScalarsModule = defaultScalarsModule;
}
const tsMorphProjectOptions = {
skipAddingFilesFromTsConfig: true, // avoid long startup time by NOT loading files included by tsconfig.json. We only use this virtually anyways so we don't need all the files
};
if (tsConfigFilePath) {
const absoluteTsConfigFilePath = path.join((0, utils_1.cwd)(), tsConfigFilePath);
if (fs.existsSync(absoluteTsConfigFilePath)) {
tsMorphProjectOptions.tsConfigFilePath = absoluteTsConfigFilePath;
}
else {
utils_1.logger.warn(`Unable to find TypeScript config at ${absoluteTsConfigFilePath}. Use presetConfig.tsConfigFilePath to set a custom value. Otherwise, type analysis may not work correctly.`);
}
}
const validatedAdd = validateAddOption(add);
return {
add: validatedAdd,
resolverTypesPath,
resolverRelativeTargetDir: finalResolverRelativeTargetDir,
resolverMainFile,
resolverMainFileMode,
resolverGeneration: parseResolverGeneration(resolverGeneration),
typeDefsFilePath: finalTypeDefsFilePath,
typeDefsFileMode,
mergeSchema: parseMergeSchema(mergeSchema),
mode,
mappersRelativeTargetDir,
mappersFileExtension,
mappersSuffix,
moduleNamingMode: finalModuleNamingMode,
scalarsModule: finalScalarsModule,
scalarsOverrides,
whitelistedModules: whitelistedModules || [],
blacklistedModules: blacklistedModules || [],
externalResolvers,
typesPluginsConfig: validatedTypesPluginsConfig,
tsMorphProjectOptions,
fixObjectTypeResolvers: parseFixObjectTypeResolvers(fixObjectTypeResolvers),
emitLegacyCommonJSImports,
};
};
exports.validatePresetConfig = validatePresetConfig;
const validateTypesPluginsConfig = (config) => {
if ('scalars' in config) {
throw new Error(utils_1.fmt.error('presetConfig.typesPluginsConfig.scalars is not supported. Use presetConfig.scalarsOverrides instead.', 'Validation'));
}
if ('emitLegacyCommonJSImports' in config) {
throw new Error(utils_1.fmt.error('presetConfig.typesPluginsConfig.emitLegacyCommonJSImports is not supported. Use presetConfig.emitLegacyCommonJSImports instead.', 'Validation'));
}
const { scalars: _, emitLegacyCommonJSImports: __ } = config, rest = tslib_1.__rest(config, ["scalars", "emitLegacyCommonJSImports"]);
return rest;
};
const parseResolverGeneration = (resolverGeneration) => {
if (resolverGeneration === 'all') {
return {
query: '*',
mutation: '*',
subscription: '*',
scalar: '*',
object: '*',
union: '*',
interface: '*',
enum: '*',
};
}
else if (resolverGeneration === 'minimal') {
return {
query: '*',
mutation: '*',
subscription: '*',
scalar: '*',
object: '',
union: '',
interface: '',
enum: '',
};
}
else if (resolverGeneration === 'recommended') {
return {
query: '*',
mutation: '*',
subscription: '*',
scalar: '*',
object: '*',
union: '',
interface: '',
enum: '',
};
}
else if (resolverGeneration === 'disabled') {
return {
query: '',
mutation: '',
subscription: '',
scalar: '',
object: '',
union: '',
interface: '',
enum: '',
};
}
return {
query: resolverGeneration.query || '',
mutation: resolverGeneration.mutation || '',
subscription: resolverGeneration.subscription || '',
scalar: resolverGeneration.scalar || '',
object: resolverGeneration.object || '',
union: resolverGeneration.union || '',
interface: resolverGeneration.interface || '',
enum: resolverGeneration.enum || '',
};
};
const parseFixObjectTypeResolvers = (fixObjectTypeResolvers) => {
if (fixObjectTypeResolvers === 'smart') {
return {
object: 'smart',
enum: 'smart',
};
}
if (fixObjectTypeResolvers === 'disabled') {
return {
object: 'disabled',
enum: 'disabled',
};
}
const allowedOptions = {
smart: 'smart',
disabled: 'disabled',
};
return {
object: allowedOptions[fixObjectTypeResolvers.object] || 'disabled',
enum: allowedOptions[fixObjectTypeResolvers.enum] || 'disabled',
};
};
const validateAddOption = (add) => {
if (!add) {
return undefined;
}
Object.entries(add).forEach(([_, pluginConfig]) => {
if (typeof pluginConfig !== 'object' || pluginConfig === null) {
throw new Error(utils_1.fmt.error('presetConfig.add must be an object', 'Validation'));
}
if (!('content' in pluginConfig)) {
throw new Error(utils_1.fmt.error('presetConfig.add must contain a "content" property', 'Validation'));
}
});
// TODO: a bit hacky here but what's a good way to coerce this type? 🤔
return add;
};
const parseMergeSchema = (mergeSchema) => {
const defaultPath = 'schema.generated.graphqls';
if (mergeSchema === false) {
return false;
}
if (mergeSchema === true || mergeSchema === undefined) {
return { path: defaultPath, config: {} };
}
if (typeof mergeSchema === 'string') {
return { path: mergeSchema, config: {} };
}
return {
path: mergeSchema.path,
config: mergeSchema.config,
};
};
const parseModuleNamingMode = (moduleNamingMode) => {
if (moduleNamingMode == null) {
// By default, for backwards compatibility prior to `moduleNamingMode`, we
// select the last directory in a path.
return -1;
}
if (typeof moduleNamingMode === 'string') {
// As a convenience we support the keywords "first" and "last".
if (moduleNamingMode === 'first') {
return 0;
}
else if (moduleNamingMode === 'last') {
return -1;
}
const parsedNumber = parseInt(moduleNamingMode);
if (!isNaN(parsedNumber)) {
return parsedNumber;
}
}
if (typeof moduleNamingMode === 'number') {
return moduleNamingMode;
}
throw new Error(utils_1.fmt.error('presetConfig.moduleNamingMode must be "first" or "last" or a number (default is "last")', 'Validation'));
};
//# sourceMappingURL=validatePresetConfig.js.map