kapix-typegraphql-prisma
Version:
278 lines • 11.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateInputTypeClassFromType = exports.generateImportsPostGis = exports.transformTypeGraphQLTypePostGis = exports.transformTSTypePostGis = exports.generateOutputTypeClassFromType = void 0;
const tslib_1 = require("tslib");
const ts_morph_1 = require("ts-morph");
const path_1 = tslib_1.__importDefault(require("path"));
const config_1 = require("./config");
const imports_1 = require("./imports");
const helpers_1 = require("./helpers");
function generateOutputTypeClassFromType(project, dirPath, type, dmmfDocument, generatorOptions) {
const fileDirPath = path_1.default.resolve(dirPath, config_1.outputsFolderName);
const filePath = path_1.default.resolve(fileDirPath, `${type.typeName}.ts`);
const sourceFile = project.createSourceFile(filePath, undefined, {
overwrite: true,
});
const fieldArgsTypeNames = type.fields
.filter(it => it.argsTypeName)
.map(it => it.argsTypeName);
(0, imports_1.generateTypeGraphQLImport)(sourceFile);
(0, imports_1.generateGraphQLScalarsImport)(sourceFile);
(0, imports_1.generatePrismaNamespaceImport)(sourceFile, dmmfDocument.options, 2);
(0, imports_1.generateCustomScalarsImport)(sourceFile, 2);
(0, imports_1.generateArgsImports)(sourceFile, fieldArgsTypeNames, 0);
(0, imports_1.generateOutputsImports)(sourceFile, type.fields
.filter(field => field.outputType.location === "outputObjectTypes")
.map(field => field.outputType.type), 1);
(0, imports_1.generateEnumsImports)(sourceFile, type.fields
.map(field => field.outputType)
.filter(fieldType => fieldType.location === "enumTypes")
.map(fieldType => fieldType.type), 2);
sourceFile.addClass({
name: type.typeName,
isExported: true,
decorators: [
{
name: "TypeGraphQL.ObjectType",
arguments: [
`"${type.typeName}"`,
ts_morph_1.Writers.object({
...(dmmfDocument.options.emitIsAbstract && {
isAbstract: "true",
}),
...(dmmfDocument.options.simpleResolvers && {
simpleResolvers: "true",
}),
}),
],
},
],
properties: [
...type.fields
.filter(field => !field.argsTypeName)
.map(field => ({
name: field.name,
type: field.fieldTSType,
hasExclamationToken: true,
hasQuestionToken: false,
trailingTrivia: "\r\n",
decorators: [
{
name: "TypeGraphQL.Field",
arguments: [
`_type => ${field.typeGraphQLType}`,
ts_morph_1.Writers.object({
nullable: `${!field.isRequired}`,
}),
],
},
],
})),
...type.fields
.filter(field => field.argsTypeName)
.map(field => ({
name: field.name,
type: field.fieldTSType,
hasExclamationToken: true,
hasQuestionToken: false,
})),
],
methods: type.fields
.filter(field => field.argsTypeName)
.map(field => ({
name: `get${(0, helpers_1.pascalCase)(field.name)}`,
returnType: field.fieldTSType,
trailingTrivia: "\r\n",
decorators: [
{
name: "TypeGraphQL.Field",
arguments: [
`_type => ${field.typeGraphQLType}`,
ts_morph_1.Writers.object({
name: `"${field.name}"`,
nullable: `${!field.isRequired}`,
}),
],
},
],
parameters: [
{
name: "root",
type: type.typeName,
decorators: [{ name: "TypeGraphQL.Root", arguments: [] }],
},
{
name: "args",
type: field.argsTypeName,
decorators: [
{
name: "TypeGraphQL.Args",
arguments: generatorOptions.emitRedundantTypesInfo
? [`_type => ${field.argsTypeName}`]
: [],
},
],
},
],
statements: [ts_morph_1.Writers.returnStatement(`root.${field.name}`)],
})),
});
}
exports.generateOutputTypeClassFromType = generateOutputTypeClassFromType;
function transformTSTypePostGis(fieldTSType, isGeometry, action) {
if (!isGeometry)
return fieldTSType;
switch (action) {
case "Create":
return "GeometryInput";
case "Update":
return "GeometryInput | undefined";
case "Where":
return "DistanceFilter | undefined";
default:
return fieldTSType;
}
}
exports.transformTSTypePostGis = transformTSTypePostGis;
function transformTypeGraphQLTypePostGis(typeGraphQLType, isGeometry, action) {
if (!isGeometry)
return typeGraphQLType;
switch (action) {
case "Create":
return "GeometryInput";
case "Update":
return "GeometryInput";
case "Where":
return "DistanceFilter";
default:
return typeGraphQLType;
}
}
exports.transformTypeGraphQLTypePostGis = transformTypeGraphQLTypePostGis;
function generateImportsPostGis(typeName, sourceFile, fieldsToEmit) {
let method = "";
if (typeName.includes("Create"))
method = "Create";
else if (typeName.includes("Update"))
method = "Update";
else if (typeName.includes("Where"))
method = "Where";
if (method !== "") {
if (fieldsToEmit.filter(field => field.isGeometry).length > 0) {
if (method === "Where") {
sourceFile.addImportDeclaration({
namedImports: ["DistanceFilter"],
moduleSpecifier: "../inputs/GeometryInput",
});
}
else {
sourceFile.addImportDeclaration({
namedImports: ["GeometryInput"],
moduleSpecifier: "../inputs/GeometryInput",
});
}
return method;
}
}
return null;
}
exports.generateImportsPostGis = generateImportsPostGis;
function generateInputTypeClassFromType(project, dirPath, inputType, options) {
const filePath = path_1.default.resolve(dirPath, config_1.inputsFolderName, `${inputType.typeName}.ts`);
const sourceFile = project.createSourceFile(filePath, undefined, {
overwrite: true,
});
(0, imports_1.generateTypeGraphQLImport)(sourceFile);
(0, imports_1.generateGraphQLScalarsImport)(sourceFile);
(0, imports_1.generatePrismaNamespaceImport)(sourceFile, options, 2);
(0, imports_1.generateCustomScalarsImport)(sourceFile, 2);
(0, imports_1.generateInputsImports)(sourceFile, inputType.fields
.filter(field => field.selectedInputType.location === "inputObjectTypes")
.map(field => field.selectedInputType.type)
.filter(fieldType => fieldType !== inputType.typeName));
(0, imports_1.generateEnumsImports)(sourceFile, inputType.fields
.map(field => field.selectedInputType)
.filter(fieldType => fieldType.location === "enumTypes")
.map(fieldType => fieldType.type), 2);
const fieldsToEmit = inputType.fields.filter(field => !field.isOmitted);
const mappedFields = fieldsToEmit.filter(field => field.hasMappedName);
const action = generateImportsPostGis(inputType.typeName, sourceFile, fieldsToEmit);
sourceFile.addClass({
name: inputType.typeName,
isExported: true,
decorators: [
{
name: "TypeGraphQL.InputType",
arguments: [
`"${inputType.typeName}"`,
ts_morph_1.Writers.object({
...(options.emitIsAbstract && {
isAbstract: "true",
}),
}),
],
},
],
properties: fieldsToEmit.map(field => {
return {
name: field.name,
type: transformTSTypePostGis(field.fieldTSType, field.isGeometry, action),
hasExclamationToken: !!field.isRequired,
hasQuestionToken: !field.isRequired,
trailingTrivia: "\r\n",
decorators: field.hasMappedName
? []
: [
{
name: "TypeGraphQL.Field",
arguments: [
`_type => ${transformTypeGraphQLTypePostGis(field.typeGraphQLType, field.isGeometry, action)}`,
ts_morph_1.Writers.object({
nullable: `${!field.isRequired}`,
}),
],
},
],
};
}),
getAccessors: mappedFields.map(field => {
return {
name: field.typeName,
type: transformTSTypePostGis(field.fieldTSType, field.isGeometry, action),
hasExclamationToken: field.isRequired,
hasQuestionToken: !field.isRequired,
trailingTrivia: "\r\n",
statements: [`return this.${field.name};`],
decorators: [
{
name: "TypeGraphQL.Field",
arguments: [
`_type => ${transformTypeGraphQLTypePostGis(field.typeGraphQLType, field.isGeometry, action)}`,
ts_morph_1.Writers.object({
nullable: `${!field.isRequired}`,
}),
],
},
],
};
}),
setAccessors: mappedFields.map(field => {
return {
name: field.typeName,
type: transformTSTypePostGis(field.fieldTSType, field.isGeometry, action),
hasExclamationToken: field.isRequired,
hasQuestionToken: !field.isRequired,
trailingTrivia: "\r\n",
parameters: [
{
name: field.name,
type: transformTypeGraphQLTypePostGis(field.typeGraphQLType, field.isGeometry, action),
},
],
statements: [`this.${field.name} = ${field.name};`],
};
}),
});
}
exports.generateInputTypeClassFromType = generateInputTypeClassFromType;
//# sourceMappingURL=type-class.js.map