joist-graphql-codegen 2.3.0-next.41 → 2.3.0-next.43

package/build/generateGraphqlSchemaFiles.js

@@ -1,330 +1,488 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateGraphqlSchemaFiles = generateGraphqlSchemaFiles;
-const change_case_1 = require("change-case");
-const joist_utils_1 = require("joist-utils");
-const pluralize_1 = __importDefault(require("pluralize"));
-const graphqlUtils_1 = require("./graphqlUtils");
-const history_1 = require("./history");
+import "./utils.js";
+import { mapTypescriptTypeToGraphQLType, upsertIntoFile } from "./graphqlUtils.js";
+import { loadHistory, writeHistory } from "./history.js";
+import { camelCase } from "change-case";
+import "joist-codegen";
+import pluralize from "pluralize";
+import { groupBy } from "joist-utils";
+//#region src/generateGraphqlSchemaFiles.ts
 /**
- * Generates `*.graphql` files based on the database schema.
- *
- * This follows an "evergreen" approach where we upsert changes into files that are also
- * hand-modified by the programmer. We remember what insertions we've made in a history file,
- * and will only do them once, which allows programmers to manually add/edit/remove fields
- * without this stomping over their changes.
- */
+* Generates `*.graphql` files based on the database schema.
+*
+* This follows an "evergreen" approach where we upsert changes into files that are also
+* hand-modified by the programmer. We remember what insertions we've made in a history file,
+* and will only do them once, which allows programmers to manually add/edit/remove fields
+* without this stomping over their changes.
+*/
 async function generateGraphqlSchemaFiles(config, fs, dbMeta) {
-    const { entities } = dbMeta;
-    // Generate the "ideal" fields based solely on the domain model
-    const fields = [
-        ...createPageInfoFields(config),
-        ...createQueryFields(config, entities),
-        ...createSaveMutation(entities),
-        ...createEntityFields(dbMeta),
-        ...createFilterFields(dbMeta),
-        ...createSaveEntityInputFields(dbMeta),
-        ...createSaveEntityResultFields(entities),
-    ];
-    const unions = createPolymorphicUnions(entities);
-    // Load the history and filter out only "new" / not-yet-added-to-.graphql fields
-    const history = await (0, history_1.loadHistory)(fs);
-    const newEntries = [
-        ...fields.filter(({ objectName, fieldName }) => !history[objectName]?.includes(fieldName)),
-        ...unions.filter(({ objectName, types }) => {
-            const set = new Set(history[objectName] ?? []);
-            return !(set.size === types.length && types.every((type) => set.has(type)));
-        }),
-    ];
-    if (newEntries.length === 0) {
-        return;
-    }
-    // Update the `.graphql` files with our new types/fields
-    await Promise.all(Object.entries((0, joist_utils_1.groupBy)(newEntries, (f) => f.file)).map(([file, fields]) => {
-        return (0, graphqlUtils_1.upsertIntoFile)(fs, file, fields);
-    }));
-    // Record the current batch of fields back to the history file
-    newEntries.forEach((entry) => {
-        if (entry.objectType === "union") {
-            const { objectName, types } = entry;
-            history[objectName] = types;
-        }
-        else {
-            const { objectName, fieldName } = entry;
-            const fields = (history[objectName] = history[objectName] || []);
-            if (!fields.includes(fieldName)) {
-                fields.push(fieldName);
-            }
-        }
-    });
-    await (0, history_1.writeHistory)(fs, history);
+	const { entities } = dbMeta;
+	const fields = [
+		...createPageInfoFields(config),
+		...createQueryFields(config, entities),
+		...createSaveMutation(entities),
+		...createEntityFields(dbMeta),
+		...createFilterFields(dbMeta),
+		...createSaveEntityInputFields(dbMeta),
+		...createSaveEntityResultFields(entities)
+	];
+	const unions = createPolymorphicUnions(entities);
+	const history = await loadHistory(fs);
+	const newEntries = [...fields.filter(({ objectName, fieldName }) => !history[objectName]?.includes(fieldName)), ...unions.filter(({ objectName, types }) => {
+		const set = new Set(history[objectName] ?? []);
+		return !(set.size === types.length && types.every((type) => set.has(type)));
+	})];
+	if (newEntries.length === 0) return;
+	await Promise.all(Object.entries(groupBy(newEntries, (f) => f.file)).map(([file, fields]) => {
+		return upsertIntoFile(fs, file, fields);
+	}));
+	newEntries.forEach((entry) => {
+		if (entry.objectType === "union") {
+			const { objectName, types } = entry;
+			history[objectName] = types;
+		} else {
+			const { objectName, fieldName } = entry;
+			const fields = history[objectName] = history[objectName] || [];
+			if (!fields.includes(fieldName)) fields.push(fieldName);
+		}
+	});
+	await writeHistory(fs, history);
 }
 /** Makes the project's pagination metadata type. */
 function createPageInfoFields(config) {
-    const common = { file: "pageInfo.graphql", objectType: "output", objectName: "PageInfo" };
-    const shared = [
-        { ...common, fieldName: "hasNextPage", fieldType: "Boolean!" },
-        { ...common, fieldName: "hasPreviousPage", fieldType: "Boolean!" },
-        { ...common, fieldName: "totalCount", fieldType: "Int!" },
-    ];
-    // Joist assumes each project uses either cursor or limit pagination, so the public GraphQL type is
-    // always named `PageInfo` but contains the fields for the configured pagination style.
-    if ((config.paginationStyle ?? "cursor") === "limit") {
-        return [
-            ...shared,
-            { ...common, fieldName: "nextPage", fieldType: "Int" },
-            { ...common, fieldName: "currentPage", fieldType: "Int" },
-        ];
-    }
-    return [
-        ...shared,
-        { ...common, fieldName: "startCursor", fieldType: "String" },
-        { ...common, fieldName: "endCursor", fieldType: "String" },
-    ];
+	const common = {
+		file: "pageInfo.graphql",
+		objectType: "output",
+		objectName: "PageInfo"
+	};
+	const shared = [
+		{
+			...common,
+			fieldName: "hasNextPage",
+			fieldType: "Boolean!"
+		},
+		{
+			...common,
+			fieldName: "hasPreviousPage",
+			fieldType: "Boolean!"
+		},
+		{
+			...common,
+			fieldName: "totalCount",
+			fieldType: "Int!"
+		}
+	];
+	if ((config.paginationStyle ?? "cursor") === "limit") return [
+		...shared,
+		{
+			...common,
+			fieldName: "nextPage",
+			fieldType: "Int"
+		},
+		{
+			...common,
+			fieldName: "currentPage",
+			fieldType: "Int"
+		}
+	];
+	return [
+		...shared,
+		{
+			...common,
+			fieldName: "startCursor",
+			fieldType: "String"
+		},
+		{
+			...common,
+			fieldName: "endCursor",
+			fieldType: "String"
+		}
+	];
 }
 /** Make all the fields for `type Author`, `type Book`, etc. */
 function createPolymorphicUnions(entities) {
-    return entities.flatMap((e) => {
-        const file = fileName(e);
-        return e.polymorphics.map(({ fieldType, components }) => {
-            return { file, objectType: "union", objectName: fieldType, types: components.map((c) => c.otherEntity.name) };
-        });
-    });
+	return entities.flatMap((e) => {
+		const file = fileName(e);
+		return e.polymorphics.map(({ fieldType, components }) => {
+			return {
+				file,
+				objectType: "union",
+				objectName: fieldType,
+				types: components.map((c) => c.otherEntity.name)
+			};
+		});
+	});
 }
 /** Make all the fields for `type Author`, `type Book`, etc. */
 function createEntityFields(dbMeta) {
-    const { entities } = dbMeta;
-    return entities.flatMap((e) => {
-        const file = fileName(e);
-        const objectType = "output";
-        const objectName = e.entity.name;
-        const common = { file, objectType, objectName };
-        const id = { ...common, fieldName: "id", fieldType: "ID!" };
-        const primitives = e.primitives.flatMap(({ fieldName, fieldType: tsType, isArray, notNull }) => {
-            const fieldType = primitiveFieldType(fieldName, tsType, isArray, notNull);
-            if (!fieldType)
-                return [];
-            return [{ ...common, fieldName, fieldType }];
-        });
-        const enums = e.enums.map(({ fieldName, enumType, notNull, isArray }) => {
-            const fieldType = isArray ? `[${enumType.symbol}!]!` : `${enumType.symbol}Detail${maybeRequired(notNull)}`;
-            return { ...common, fieldName, fieldType };
-        });
-        const pgEnums = e.pgEnums.map(({ fieldName, enumType, notNull }) => {
-            const fieldType = `${enumType.symbol}${maybeRequired(notNull)}`;
-            return { ...common, fieldName, fieldType };
-        });
-        const m2os = e.manyToOnes.map(({ fieldName, otherEntity, notNull }) => {
-            const other = dbMeta.entitiesByName[otherEntity.name];
-            const maybeLike = other.subTypes.length > 0 && !other.abstract ? "Like" : "";
-            const fieldType = `${otherEntity.name}${maybeLike}${maybeRequired(notNull)}`;
-            return { ...common, fieldName, fieldType };
-        });
-        const o2ms = e.oneToManys.map(({ fieldName, otherEntity }) => {
-            const fieldType = `[${otherEntity.name}!]!`;
-            return { ...common, fieldName, fieldType };
-        });
-        const m2ms = e.manyToManys.map(({ fieldName, otherEntity }) => {
-            const fieldType = `[${otherEntity.name}!]!`;
-            return { ...common, fieldName, fieldType };
-        });
-        const o2os = e.oneToOnes.map(({ fieldName, otherEntity }) => {
-            return { ...common, fieldName, fieldType: otherEntity.name };
-        });
-        const polys = e.polymorphics.map(({ fieldName, fieldType }) => {
-            return { ...common, fieldName, fieldType };
-        });
-        // GraphQL wants base fields copy/pasted onto subtypes, so re-run ourselves against just the base type
-        const inheritedFields = e.baseClassName
-            ? createEntityFields(findBaseEntity(dbMeta, e.baseClassName))
-                .map((f) => ({ ...f, ...common }))
-                .filter((f) => f.fieldName !== "id")
-            : [];
-        return [id, ...inheritedFields, ...primitives, ...enums, ...pgEnums, ...m2os, ...o2ms, ...m2ms, ...o2os, ...polys];
-    });
+	const { entities } = dbMeta;
+	return entities.flatMap((e) => {
+		const common = {
+			file: fileName(e),
+			objectType: "output",
+			objectName: e.entity.name
+		};
+		const id = {
+			...common,
+			fieldName: "id",
+			fieldType: "ID!"
+		};
+		const primitives = e.primitives.flatMap(({ fieldName, fieldType: tsType, isArray, notNull }) => {
+			const fieldType = primitiveFieldType(fieldName, tsType, isArray, notNull);
+			if (!fieldType) return [];
+			return [{
+				...common,
+				fieldName,
+				fieldType
+			}];
+		});
+		const enums = e.enums.map(({ fieldName, enumType, notNull, isArray }) => {
+			const fieldType = isArray ? `[${enumType.symbol}!]!` : `${enumType.symbol}Detail${maybeRequired(notNull)}`;
+			return {
+				...common,
+				fieldName,
+				fieldType
+			};
+		});
+		const pgEnums = e.pgEnums.map(({ fieldName, enumType, notNull }) => {
+			const fieldType = `${enumType.symbol}${maybeRequired(notNull)}`;
+			return {
+				...common,
+				fieldName,
+				fieldType
+			};
+		});
+		const m2os = e.manyToOnes.map(({ fieldName, otherEntity, notNull }) => {
+			const other = dbMeta.entitiesByName[otherEntity.name];
+			const maybeLike = other.subTypes.length > 0 && !other.abstract ? "Like" : "";
+			const fieldType = `${otherEntity.name}${maybeLike}${maybeRequired(notNull)}`;
+			return {
+				...common,
+				fieldName,
+				fieldType
+			};
+		});
+		const o2ms = e.oneToManys.map(({ fieldName, otherEntity }) => {
+			const fieldType = `[${otherEntity.name}!]!`;
+			return {
+				...common,
+				fieldName,
+				fieldType
+			};
+		});
+		const m2ms = e.manyToManys.map(({ fieldName, otherEntity }) => {
+			const fieldType = `[${otherEntity.name}!]!`;
+			return {
+				...common,
+				fieldName,
+				fieldType
+			};
+		});
+		const o2os = e.oneToOnes.map(({ fieldName, otherEntity }) => {
+			return {
+				...common,
+				fieldName,
+				fieldType: otherEntity.name
+			};
+		});
+		const polys = e.polymorphics.map(({ fieldName, fieldType }) => {
+			return {
+				...common,
+				fieldName,
+				fieldType
+			};
+		});
+		return [
+			id,
+			...e.baseClassName ? createEntityFields(findBaseEntity(dbMeta, e.baseClassName)).map((f) => ({
+				...f,
+				...common
+			})).filter((f) => f.fieldName !== "id") : [],
+			...primitives,
+			...enums,
+			...pgEnums,
+			...m2os,
+			...o2ms,
+			...m2ms,
+			...o2os,
+			...polys
+		];
+	});
 }
 /** Makes the `Mutations.save${entity}` placeholder. */
 function createSaveMutation(entities) {
-    return entities.map((e) => {
-        const file = fileName(e);
-        const inputType = `Save${e.entity.name}Input`;
-        const outputType = `Save${e.entity.name}Result`;
-        return {
-            file,
-            objectType: "output",
-            objectName: "Mutation",
-            fieldName: `save${e.entity.name}`,
-            fieldType: `${outputType}!`,
-            argsString: `input: ${inputType}!`,
-            extends: true,
-        };
-    });
+	return entities.map((e) => {
+		const file = fileName(e);
+		const inputType = `Save${e.entity.name}Input`;
+		const outputType = `Save${e.entity.name}Result`;
+		return {
+			file,
+			objectType: "output",
+			objectName: "Mutation",
+			fieldName: `save${e.entity.name}`,
+			fieldType: `${outputType}!`,
+			argsString: `input: ${inputType}!`,
+			extends: true
+		};
+	});
 }
 /** Makes the `Query.${entity}` and `Query.${entity}s` placeholders. */
 function createQueryFields(config, entities) {
-    return entities.flatMap((e) => {
-        const file = fileName(e);
-        const { name } = e.entity;
-        const pluralName = (0, pluralize_1.default)(name);
-        const camelName = (0, change_case_1.camelCase)(name);
-        const pluralCamelName = (0, pluralize_1.default)(camelName);
-        const collectionType = (config.paginationStyle ?? "cursor") === "limit" ? `${pluralName}Page!` : `${pluralName}Connection!`;
-        const collectionArgs = (config.paginationStyle ?? "cursor") === "limit"
-            ? `filter: ${name}Filter, limit: Int, offset: Int`
-            : `filter: ${name}Filter, first: Int, after: String, last: Int, before: String`;
-        return [
-            {
-                file,
-                objectType: "output",
-                objectName: "Query",
-                fieldName: camelName,
-                fieldType: `${name}!`,
-                argsString: `id: ID!`,
-                extends: true,
-            },
-            {
-                file,
-                objectType: "output",
-                objectName: "Query",
-                fieldName: pluralCamelName,
-                fieldType: collectionType,
-                argsString: collectionArgs,
-                extends: true,
-            },
-            ...createPaginationTypes(config, file, e),
-        ];
-    });
+	return entities.flatMap((e) => {
+		const file = fileName(e);
+		const { name } = e.entity;
+		const pluralName = pluralize(name);
+		const camelName = camelCase(name);
+		const pluralCamelName = pluralize(camelName);
+		const collectionType = (config.paginationStyle ?? "cursor") === "limit" ? `${pluralName}Page!` : `${pluralName}Connection!`;
+		const collectionArgs = (config.paginationStyle ?? "cursor") === "limit" ? `filter: ${name}Filter, limit: Int, offset: Int` : `filter: ${name}Filter, first: Int, after: String, last: Int, before: String`;
+		return [
+			{
+				file,
+				objectType: "output",
+				objectName: "Query",
+				fieldName: camelName,
+				fieldType: `${name}!`,
+				argsString: `id: ID!`,
+				extends: true
+			},
+			{
+				file,
+				objectType: "output",
+				objectName: "Query",
+				fieldName: pluralCamelName,
+				fieldType: collectionType,
+				argsString: collectionArgs,
+				extends: true
+			},
+			...createPaginationTypes(config, file, e)
+		];
+	});
 }
 /** Makes the `AuthorFilter`, `BookFilter`, etc. input types. */
 function createFilterFields(dbMeta) {
-    const { entities } = dbMeta;
-    return entities.flatMap((e) => {
-        const file = fileName(e);
-        const objectType = "input";
-        const objectName = `${e.entity.name}Filter`;
-        const common = { file, objectType, objectName };
-        const id = { ...common, fieldName: "id", fieldType: filterListType("ID") };
-        const primitives = e.primitives.flatMap(({ fieldName, fieldType: tsType, isArray }) => {
-            const fieldType = primitiveFieldType(fieldName, tsType, isArray);
-            if (!fieldType)
-                return [];
-            return [{ ...common, fieldName, fieldType: filterListType(fieldType) }];
-        });
-        const enums = e.enums.map(({ fieldName, enumType, isArray }) => {
-            const fieldType = isArray ? `[${enumType.symbol}!]` : enumType.symbol;
-            return { ...common, fieldName, fieldType: filterListType(fieldType) };
-        });
-        const pgEnums = e.pgEnums.map(({ fieldName, enumType }) => {
-            return { ...common, fieldName, fieldType: filterListType(enumType.symbol) };
-        });
-        const m2os = e.manyToOnes.map(({ fieldName }) => {
-            return { ...common, fieldName: `${fieldName}Id`, fieldType: filterListType("ID") };
-        });
-        const polys = e.polymorphics.map(({ fieldName }) => {
-            return { ...common, fieldName: `${fieldName}Id`, fieldType: filterListType("ID") };
-        });
-        const inherited = e.baseClassName
-            ? createFilterFields(findBaseEntity(dbMeta, e.baseClassName))
-                .map((f) => ({ ...f, ...common }))
-                .filter((f) => f.fieldName !== "id")
-            : [];
-        return [id, ...inherited, ...primitives, ...enums, ...pgEnums, ...m2os, ...polys];
-    });
+	const { entities } = dbMeta;
+	return entities.flatMap((e) => {
+		const common = {
+			file: fileName(e),
+			objectType: "input",
+			objectName: `${e.entity.name}Filter`
+		};
+		const id = {
+			...common,
+			fieldName: "id",
+			fieldType: filterListType("ID")
+		};
+		const primitives = e.primitives.flatMap(({ fieldName, fieldType: tsType, isArray }) => {
+			const fieldType = primitiveFieldType(fieldName, tsType, isArray);
+			if (!fieldType) return [];
+			return [{
+				...common,
+				fieldName,
+				fieldType: filterListType(fieldType)
+			}];
+		});
+		const enums = e.enums.map(({ fieldName, enumType, isArray }) => {
+			const fieldType = isArray ? `[${enumType.symbol}!]` : enumType.symbol;
+			return {
+				...common,
+				fieldName,
+				fieldType: filterListType(fieldType)
+			};
+		});
+		const pgEnums = e.pgEnums.map(({ fieldName, enumType }) => {
+			return {
+				...common,
+				fieldName,
+				fieldType: filterListType(enumType.symbol)
+			};
+		});
+		const m2os = e.manyToOnes.map(({ fieldName }) => {
+			return {
+				...common,
+				fieldName: `${fieldName}Id`,
+				fieldType: filterListType("ID")
+			};
+		});
+		const polys = e.polymorphics.map(({ fieldName }) => {
+			return {
+				...common,
+				fieldName: `${fieldName}Id`,
+				fieldType: filterListType("ID")
+			};
+		});
+		return [
+			id,
+			...e.baseClassName ? createFilterFields(findBaseEntity(dbMeta, e.baseClassName)).map((f) => ({
+				...f,
+				...common
+			})).filter((f) => f.fieldName !== "id") : [],
+			...primitives,
+			...enums,
+			...pgEnums,
+			...m2os,
+			...polys
+		];
+	});
 }
 /** Makes the page/connection types for `Query.authors`. */
 function createPaginationTypes(config, file, e) {
-    const { name } = e.entity;
-    const pluralName = (0, pluralize_1.default)(name);
-    const objectType = "output";
-    if ((config.paginationStyle ?? "cursor") === "limit") {
-        return [
-            { file, objectType, objectName: `${pluralName}Page`, fieldName: "entities", fieldType: `[${name}!]!` },
-            { file, objectType, objectName: `${pluralName}Page`, fieldName: "pageInfo", fieldType: "PageInfo!" },
-        ];
-    }
-    return [
-        { file, objectType, objectName: `${pluralName}Connection`, fieldName: "edges", fieldType: `[${pluralName}Edge!]!` },
-        { file, objectType, objectName: `${pluralName}Connection`, fieldName: "nodes", fieldType: `[${name}!]!` },
-        { file, objectType, objectName: `${pluralName}Connection`, fieldName: "pageInfo", fieldType: "PageInfo!" },
-        { file, objectType, objectName: `${pluralName}Edge`, fieldName: "node", fieldType: `${name}!` },
-        { file, objectType, objectName: `${pluralName}Edge`, fieldName: "cursor", fieldType: "String!" },
-    ];
+	const { name } = e.entity;
+	const pluralName = pluralize(name);
+	const objectType = "output";
+	if ((config.paginationStyle ?? "cursor") === "limit") return [{
+		file,
+		objectType,
+		objectName: `${pluralName}Page`,
+		fieldName: "entities",
+		fieldType: `[${name}!]!`
+	}, {
+		file,
+		objectType,
+		objectName: `${pluralName}Page`,
+		fieldName: "pageInfo",
+		fieldType: "PageInfo!"
+	}];
+	return [
+		{
+			file,
+			objectType,
+			objectName: `${pluralName}Connection`,
+			fieldName: "edges",
+			fieldType: `[${pluralName}Edge!]!`
+		},
+		{
+			file,
+			objectType,
+			objectName: `${pluralName}Connection`,
+			fieldName: "nodes",
+			fieldType: `[${name}!]!`
+		},
+		{
+			file,
+			objectType,
+			objectName: `${pluralName}Connection`,
+			fieldName: "pageInfo",
+			fieldType: "PageInfo!"
+		},
+		{
+			file,
+			objectType,
+			objectName: `${pluralName}Edge`,
+			fieldName: "node",
+			fieldType: `${name}!`
+		},
+		{
+			file,
+			objectType,
+			objectName: `${pluralName}Edge`,
+			fieldName: "cursor",
+			fieldType: "String!"
+		}
+	];
 }
 /** Make all the fields for `type SaveAuthorInput`, `type SaveBookBook`, etc. */
 function createSaveEntityInputFields(dbMeta) {
-    const { entities } = dbMeta;
-    return entities.flatMap((e) => {
-        const file = fileName(e);
-        const objectType = "input";
-        const objectName = `Save${e.entity.name}Input`;
-        const common = { file, objectType, objectName };
-        const id = { ...common, fieldName: "id", fieldType: "ID" };
-        const primitives = e.primitives
-            .filter((f) => f.derived === false)
-            .flatMap(({ fieldName, fieldType: tsType, isArray }) => {
-            const fieldType = primitiveFieldType(fieldName, tsType, isArray);
-            if (!fieldType)
-                return [];
-            return [{ ...common, fieldName, fieldType }];
-        });
-        const enums = e.enums.map(({ fieldName, enumType, isArray }) => {
-            return { ...common, fieldName, fieldType: isArray ? `[${enumType.symbol}!]` : enumType.symbol };
-        });
-        const pgEnums = e.pgEnums.map(({ fieldName, enumType }) => {
-            return { ...common, fieldName, fieldType: enumType.symbol };
-        });
-        const m2os = e.manyToOnes.map(({ fieldName }) => {
-            return { ...common, fieldName: `${fieldName}Id`, fieldType: "ID" };
-        });
-        const polys = e.polymorphics.map(({ fieldName }) => {
-            return { ...common, fieldName: `${fieldName}Id`, fieldType: "ID" };
-        });
-        const inherited = e.baseClassName
-            ? createSaveEntityInputFields(findBaseEntity(dbMeta, e.baseClassName))
-                .map((f) => ({ ...f, ...common }))
-                .filter((f) => f.fieldName !== "id")
-            : [];
-        return [id, ...inherited, ...primitives, ...enums, ...pgEnums, ...m2os, ...polys];
-    });
+	const { entities } = dbMeta;
+	return entities.flatMap((e) => {
+		const common = {
+			file: fileName(e),
+			objectType: "input",
+			objectName: `Save${e.entity.name}Input`
+		};
+		const id = {
+			...common,
+			fieldName: "id",
+			fieldType: "ID"
+		};
+		const primitives = e.primitives.filter((f) => f.derived === false).flatMap(({ fieldName, fieldType: tsType, isArray }) => {
+			const fieldType = primitiveFieldType(fieldName, tsType, isArray);
+			if (!fieldType) return [];
+			return [{
+				...common,
+				fieldName,
+				fieldType
+			}];
+		});
+		const enums = e.enums.map(({ fieldName, enumType, isArray }) => {
+			return {
+				...common,
+				fieldName,
+				fieldType: isArray ? `[${enumType.symbol}!]` : enumType.symbol
+			};
+		});
+		const pgEnums = e.pgEnums.map(({ fieldName, enumType }) => {
+			return {
+				...common,
+				fieldName,
+				fieldType: enumType.symbol
+			};
+		});
+		const m2os = e.manyToOnes.map(({ fieldName }) => {
+			return {
+				...common,
+				fieldName: `${fieldName}Id`,
+				fieldType: "ID"
+			};
+		});
+		const polys = e.polymorphics.map(({ fieldName }) => {
+			return {
+				...common,
+				fieldName: `${fieldName}Id`,
+				fieldType: "ID"
+			};
+		});
+		return [
+			id,
+			...e.baseClassName ? createSaveEntityInputFields(findBaseEntity(dbMeta, e.baseClassName)).map((f) => ({
+				...f,
+				...common
+			})).filter((f) => f.fieldName !== "id") : [],
+			...primitives,
+			...enums,
+			...pgEnums,
+			...m2os,
+			...polys
+		];
+	});
 }
 /** Makes the fields for `type SaveAuthorResult`, `type SaveBookResult`, etc. */
 function createSaveEntityResultFields(entities) {
-    return entities.flatMap((e) => {
-        const file = fileName(e);
-        const { entity: { name }, } = e;
-        const objectType = "output";
-        const objectName = `Save${name}Result`;
-        const fieldName = (0, change_case_1.camelCase)(name);
-        const entity = { file, objectType, objectName, fieldName, fieldType: `${name}!` };
-        return [entity];
-    });
+	return entities.flatMap((e) => {
+		const file = fileName(e);
+		const { entity: { name } } = e;
+		return [{
+			file,
+			objectType: "output",
+			objectName: `Save${name}Result`,
+			fieldName: camelCase(name),
+			fieldType: `${name}!`
+		}];
+	});
 }
 function maybeRequired(notNull) {
-    return notNull ? "!" : "";
+	return notNull ? "!" : "";
 }
 /** Returns the GraphQL type for primitive fields, including primitive arrays. */
 function primitiveFieldType(fieldName, tsType, isArray, notNull = false) {
-    const gqlType = (0, graphqlUtils_1.mapTypescriptTypeToGraphQLType)(fieldName, tsType);
-    if (!gqlType)
-        return undefined;
-    const fieldType = isArray ? `[${gqlType}!]` : gqlType;
-    return `${fieldType}${maybeRequired(notNull)}`;
+	const gqlType = mapTypescriptTypeToGraphQLType(fieldName, tsType);
+	if (!gqlType) return void 0;
+	return `${isArray ? `[${gqlType}!]` : gqlType}${maybeRequired(notNull)}`;
 }
 /** Wraps filter fields in lists so GraphQL callers can pass one value or OR several values. */
 function filterListType(fieldType) {
-    return `[${fieldType}!]`;
+	return `[${fieldType}!]`;
 }
 /** I.e. `Book` --> `books.graphql`. */
 function fileName(e) {
-    return `${(0, change_case_1.camelCase)(e.entity.name)}.graphql`;
+	return `${camelCase(e.entity.name)}.graphql`;
 }
 function findBaseEntity(dbMeta, baseClassName) {
-    return {
-        ...dbMeta,
-        entities: dbMeta.entities.filter((e) => e.entity.name === baseClassName),
-    };
+	return {
+		...dbMeta,
+		entities: dbMeta.entities.filter((e) => e.entity.name === baseClassName)
+	};
 }
+//#endregion
+export { generateGraphqlSchemaFiles };
+
 //# sourceMappingURL=generateGraphqlSchemaFiles.js.map