joist-graphql-codegen 2.3.0-next.7 → 2.3.0-next.71

package/build/graphqlUtils.cjs

@@ -0,0 +1,160 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+require("./utils.cjs");
+require("joist-codegen");
+let ts_poet = require("ts-poet");
+let joist_utils = require("joist-utils");
+let graphql = require("graphql");
+let prettier = require("prettier");
+prettier = require_runtime.__toESM(prettier, 1);
+//#region src/graphqlUtils.ts
+/** Given a `file` and `fields` to go in it (for potentially different objects), upserts into the existing types. */
+async function upsertIntoFile(fs, file, fields) {
+	const byObjectName = (0, joist_utils.groupBy)(fields, (f) => f.objectName);
+	const existingDoc = parseOrNewEmptyDoc(await fs.load(file));
+	const newDocs = Object.entries(byObjectName).map(([objectName, fields]) => {
+		const [entry] = fields;
+		return [objectName, entry.objectType === "union" ? createUnionDoc(entry) : createFieldDoc(objectName, fields)];
+	});
+	const formatted = await formatGraphQL((0, graphql.print)(mergeDocs(existingDoc, newDocs)));
+	await fs.save(file, formatted);
+}
+let prettierPromise;
+async function formatGraphQL(content) {
+	const prettierConfig = await (prettierPromise ??= (0, prettier.resolveConfig)("./"));
+	return prettier.default.format(content, {
+		parser: "graphql",
+		...prettierConfig,
+		plugins: []
+	});
+}
+/**
+* Creates a new AST DocumentNode for the given object + field definitions.
+*
+* This leverages `parse` to do the dirty work of taking an "easy for us to create"
+* string of GraphQL SDL and turning it into a "pita to create by hand" AST
+* of object / field / type / etc. nodes.
+*/
+function createFieldDoc(objectName, fields) {
+	const [{ objectType }] = fields;
+	const type = objectType === "output" ? "type" : objectType;
+	const maybeArgs = (f) => f.argsString ? `(${f.argsString})` : "";
+	const source = `${fields.some((f) => f.extends) ? "extend " : ""}${type} ${objectName} {
+    ${fields.map((f) => `${f.fieldName}${maybeArgs(f)}: ${f.fieldType}`)}
+  }`;
+	return (0, graphql.parse)(source);
+}
+function createUnionDoc(union) {
+	const { objectName, types } = union;
+	return (0, graphql.parse)(`union ${objectName} = ${types.join(" | ")}`);
+}
+function parseOrNewEmptyDoc(content) {
+	return content ? (0, graphql.parse)(content) : newEmptyDocument();
+}
+function newEmptyDocument() {
+	return (0, graphql.visit)((0, graphql.parse)("type Foo"), { ObjectTypeDefinition() {
+		return null;
+	} });
+}
+/**
+* Merges a given `newType` from `newDoc` into `existingDoc*.
+*
+* There are existing "merge schema" libraries/tools out there, but we want to be very purposeful
+* about keeping the existing SDL and this is really not too bad because we're only stitching
+* ~two levels of the AST (document -> objects and object -> fields).
+*
+* We also cheat by using `createNewDoc` to get ASTs of the new content, so we don't have
+* to laboriously built up the ASTs by hand.
+*/
+function mergeDocs(existingDoc, newDocs) {
+	return (0, graphql.visit)(existingDoc, {
+		Document(node) {
+			return {
+				...node,
+				definitions: [...node.definitions, ...newDocs.filter(([objectType]) => {
+					return !node.definitions.some((d) => (d.kind === "ObjectTypeDefinition" || d.kind === "ObjectTypeExtension" || d.kind === "InputObjectTypeDefinition" || d.kind === "UnionTypeDefinition") && d.name.value === objectType);
+				}).flatMap(([, d]) => d.definitions)].sort(byOperationExtensionsFirst)
+			};
+		},
+		ObjectTypeDefinition(node) {
+			return mergeObjectTypeFields(node, newDocs);
+		},
+		ObjectTypeExtension(node) {
+			return mergeObjectTypeFields(node, newDocs);
+		},
+		InputObjectTypeDefinition(node) {
+			const found = newDocs.find(([objectType]) => node.name.value === objectType);
+			if (found) {
+				const [, newDoc] = found;
+				const existingFieldNames = (node.fields || []).map((f) => f.name.value);
+				const newObjectType = newDoc.definitions[0];
+				return {
+					...node,
+					fields: [...node.fields || [], ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value))]
+				};
+			}
+			return node;
+		},
+		UnionTypeDefinition(node) {
+			const found = newDocs.find(([objectType]) => node.name.value === objectType);
+			if (found) {
+				const [, newDoc] = found;
+				const [definition] = newDoc.definitions;
+				return {
+					...node,
+					types: definition.types
+				};
+			}
+			return node;
+		}
+	});
+}
+/** Merges generated fields into an existing `type` or `extend type`. */
+function mergeObjectTypeFields(node, newDocs) {
+	const found = newDocs.find(([objectType]) => node.name.value === objectType);
+	if (found) {
+		const [, newDoc] = found;
+		const existingFieldNames = (node.fields || []).map((f) => f.name.value);
+		const newObjectType = newDoc.definitions[0];
+		return {
+			...node,
+			fields: [...node.fields || [], ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value))]
+		};
+	}
+	return node;
+}
+/** Keeps the primary operation extensions at the top of generated schema files. */
+function byOperationExtensionsFirst(a, b) {
+	return operationExtensionRank(a) - operationExtensionRank(b);
+}
+/** Returns the priority for placing generated operation extensions before types/inputs. */
+function operationExtensionRank(definition) {
+	if (definition.kind === "ObjectTypeExtension" && definition.name.value === "Query") return 0;
+	if (definition.kind === "ObjectTypeExtension" && definition.name.value === "Mutation") return 1;
+	return 2;
+}
+function mapTypescriptTypeToGraphQLType(fieldName, type) {
+	if (type === "string") return "String";
+	else if (type === "boolean") return "Boolean";
+	else if (type === "number") return "Int";
+	else if (type === "bigint") return "BigInt";
+	else if (type instanceof ts_poet.Code) {
+		const rawType = type.toCodeString([]);
+		if (rawType.startsWith("Date")) return fieldName.endsWith("At") ? "DateTime" : "Date";
+		else if (rawType.startsWith("Temporal.ZonedDateTime")) return "DateTime";
+		else if (rawType.startsWith("Temporal.PlainDateTime")) return "DateTime";
+		else if (rawType.startsWith("Temporal.PlainDate")) return "Date";
+		else return;
+	} else if (type instanceof ts_poet.Import) return;
+	else return;
+}
+function isJsonbColumn(p) {
+	return p.fieldType === "Object" || p.fieldType instanceof ts_poet.Import;
+}
+//#endregion
+exports.formatGraphQL = formatGraphQL;
+exports.isJsonbColumn = isJsonbColumn;
+exports.mapTypescriptTypeToGraphQLType = mapTypescriptTypeToGraphQLType;
+exports.upsertIntoFile = upsertIntoFile;
+
+//# sourceMappingURL=graphqlUtils.cjs.map

package/build/graphqlUtils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlUtils.cjs","names":["groupBy","print","resolveConfig","parse","visit","Code","Import"],"sources":["../src/graphqlUtils.ts"],"sourcesContent":["import {\n  type DocumentNode,\n  type InputObjectTypeDefinitionNode,\n  type ObjectTypeDefinitionNode,\n  type ObjectTypeExtensionNode,\n  type UnionTypeDefinitionNode,\n  parse,\n  print,\n  visit,\n} from \"graphql\";\nimport { type PrimitiveField, type PrimitiveTypescriptType } from \"joist-codegen\";\nimport { groupBy } from \"joist-utils\";\nimport prettier, { type Options, resolveConfig } from \"prettier\";\nimport { Code, Import } from \"ts-poet\";\n\nimport { type Fs } from \"./utils.ts\";\n\n/** A type for the fields we want to add to `*.graphql` files. */\nexport type GqlField = {\n  file: string;\n  objectType: \"input\" | \"output\";\n  objectName: string;\n  fieldName: string;\n  fieldType: string;\n  // Not a true AST, but just `foo: Bar, zaz: number`\n  argsString?: string;\n  extends?: boolean;\n};\n\nexport type GqlUnion = { file: string; objectName: string; objectType: \"union\"; types: string[] };\n\nexport type GqlEntry = GqlField | GqlUnion;\n\n/** Given a `file` and `fields` to go in it (for potentially different objects), upserts into the existing types. */\nexport async function upsertIntoFile(fs: Fs, file: string, fields: GqlEntry[]): Promise<void> {\n  // Group the fields by each individual object (either input types or output types)\n  const byObjectName = groupBy(fields, (f) => f.objectName);\n  const existingDoc = parseOrNewEmptyDoc(await fs.load(file));\n\n  // For each type, create a \"new\" / ideal definition that exactly matches the domain model\n  const newDocs = Object.entries(byObjectName).map(([objectName, fields]) => {\n    const [entry] = fields;\n    return [\n      objectName,\n      entry.objectType === \"union\"\n        ? createUnionDoc(entry as GqlUnion)\n        : createFieldDoc(objectName, fields as GqlField[]),\n    ] as [string, DocumentNode];\n  });\n\n  // Merge each `newDoc` object definition into the file's existing types\n  const content = print(mergeDocs(existingDoc, newDocs));\n  const formatted = await formatGraphQL(content);\n\n  await fs.save(file, formatted);\n}\n\nlet prettierPromise: Promise<Options | null>;\n\nexport async function formatGraphQL(content: string): Promise<string> {\n  const prettierConfig = await (prettierPromise ??= resolveConfig(\"./\"));\n  return prettier.format(content, {\n    parser: \"graphql\",\n    ...prettierConfig,\n    plugins: [],\n  });\n}\n\n/**\n * Creates a new AST DocumentNode for the given object + field definitions.\n *\n * This leverages `parse` to do the dirty work of taking an \"easy for us to create\"\n * string of GraphQL SDL and turning it into a \"pita to create by hand\" AST\n * of object / field / type / etc. nodes.\n */\nfunction createFieldDoc(objectName: string, fields: GqlField[]): DocumentNode {\n  const [{ objectType }] = fields;\n  const type = objectType === \"output\" ? \"type\" : objectType;\n  const maybeArgs = (f: GqlField) => (f.argsString ? `(${f.argsString})` : \"\");\n  const maybeExtends = fields.some((f: GqlField) => f.extends) ? \"extend \" : \"\";\n  const source = `${maybeExtends}${type} ${objectName} {\n    ${fields.map((f) => `${f.fieldName}${maybeArgs(f)}: ${f.fieldType}`)}\n  }`;\n  return parse(source);\n}\n\nfunction createUnionDoc(union: GqlUnion): DocumentNode {\n  const { objectName, types } = union;\n  return parse(`union ${objectName} = ${types.join(\" | \")}`);\n}\n\nfunction parseOrNewEmptyDoc(content: string | undefined): DocumentNode {\n  return content ? parse(content) : newEmptyDocument();\n}\n\nfunction newEmptyDocument(): DocumentNode {\n  // I can't figure out how to `parse(\"\")`, i.e. create an empty DocumentNode, so pretend\n  // to make a `type Foo` but then throw it away so that DocumentNode ends up empty.\n  return visit(parse(\"type Foo\"), {\n    ObjectTypeDefinition() {\n      return null;\n    },\n  });\n}\n\n/**\n * Merges a given `newType` from `newDoc` into `existingDoc*.\n *\n * There are existing \"merge schema\" libraries/tools out there, but we want to be very purposeful\n * about keeping the existing SDL and this is really not too bad because we're only stitching\n * ~two levels of the AST (document -> objects and object -> fields).\n *\n * We also cheat by using `createNewDoc` to get ASTs of the new content, so we don't have\n * to laboriously built up the ASTs by hand.\n */\nfunction mergeDocs(existingDoc: DocumentNode, newDocs: [string, DocumentNode][]): DocumentNode {\n  // Now merged the two\n  return visit(existingDoc, {\n    // If the `type Book` does not exist yet, add it\n    Document(node) {\n      return {\n        ...node,\n        definitions: [\n          ...node.definitions,\n          ...newDocs\n            .filter(([objectType]) => {\n              return !node.definitions.some(\n                (d) =>\n                  (d.kind === \"ObjectTypeDefinition\" ||\n                    d.kind === \"ObjectTypeExtension\" ||\n                    d.kind === \"InputObjectTypeDefinition\" ||\n                    d.kind === \"UnionTypeDefinition\") &&\n                  d.name.value === objectType,\n              );\n            })\n            .flatMap(([, d]) => d.definitions),\n        ].sort(byOperationExtensionsFirst),\n      };\n    },\n\n    // If fields don't exist yet, add them\n    ObjectTypeDefinition(node) {\n      return mergeObjectTypeFields(node, newDocs);\n    },\n\n    ObjectTypeExtension(node) {\n      return mergeObjectTypeFields(node, newDocs);\n    },\n\n    // If fields don't exist yet, add them\n    InputObjectTypeDefinition(node) {\n      const found = newDocs.find(([objectType]) => node.name.value === objectType);\n      if (found) {\n        const [, newDoc] = found;\n        const existingFieldNames = (node.fields || []).map((f) => f.name.value);\n        const newObjectType = newDoc.definitions[0] as InputObjectTypeDefinitionNode;\n        return {\n          ...node,\n          fields: [\n            ...(node.fields || []),\n            ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value)),\n          ],\n        };\n      }\n      return node;\n    },\n\n    UnionTypeDefinition(node) {\n      const found = newDocs.find(([objectType]) => node.name.value === objectType);\n      if (found) {\n        const [, newDoc] = found;\n        const [definition] = newDoc.definitions as UnionTypeDefinitionNode[];\n        return {\n          ...node,\n          types: definition.types,\n        };\n      }\n      return node;\n    },\n  });\n}\n\n/** Merges generated fields into an existing `type` or `extend type`. */\nfunction mergeObjectTypeFields<T extends ObjectTypeDefinitionNode | ObjectTypeExtensionNode>(\n  node: T,\n  newDocs: [string, DocumentNode][],\n): T {\n  const found = newDocs.find(([objectType]) => node.name.value === objectType);\n  if (found) {\n    const [, newDoc] = found;\n    const existingFieldNames = (node.fields || []).map((f) => f.name.value);\n    const newObjectType = newDoc.definitions[0] as ObjectTypeDefinitionNode;\n    return {\n      ...node,\n      fields: [\n        ...(node.fields || []),\n        ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value)),\n      ],\n    };\n  }\n  return node;\n}\n\n/** Keeps the primary operation extensions at the top of generated schema files. */\nfunction byOperationExtensionsFirst(\n  a: DocumentNode[\"definitions\"][number],\n  b: DocumentNode[\"definitions\"][number],\n): number {\n  return operationExtensionRank(a) - operationExtensionRank(b);\n}\n\n/** Returns the priority for placing generated operation extensions before types/inputs. */\nfunction operationExtensionRank(definition: DocumentNode[\"definitions\"][number]): number {\n  if (definition.kind === \"ObjectTypeExtension\" && definition.name.value === \"Query\") return 0;\n  if (definition.kind === \"ObjectTypeExtension\" && definition.name.value === \"Mutation\") return 1;\n  return 2;\n}\n\nexport type GraphQLType = \"BigInt\" | \"Boolean\" | \"String\" | \"Int\" | \"Date\" | \"DateTime\" | string;\n\nexport type SupportedTypescriptTypes = Exclude<PrimitiveTypescriptType, \"Object\" | Import>;\n\nexport function mapTypescriptTypeToGraphQLType(\n  fieldName: string,\n  type: PrimitiveTypescriptType | Import | Code,\n): GraphQLType | undefined {\n  if (type === \"string\") {\n    return \"String\";\n  } else if (type === \"boolean\") {\n    return \"Boolean\";\n  } else if (type === \"number\") {\n    return \"Int\";\n  } else if (type === \"bigint\") {\n    return \"BigInt\";\n  } else if (type instanceof Code) {\n    const rawType = type.toCodeString([]);\n    if (rawType.startsWith(\"Date\")) {\n      // Legacy javascript Date doesn't have different `date` vs. `datetime` types but GraphQL does\n      // so lean on the `..._at` suffix convention to know \"DateTime\".\n      return fieldName.endsWith(\"At\") ? \"DateTime\" : \"Date\";\n    } else if (rawType.startsWith(\"Temporal.ZonedDateTime\")) {\n      return \"DateTime\";\n    } else if (rawType.startsWith(\"Temporal.PlainDateTime\")) {\n      return \"DateTime\";\n    } else if (rawType.startsWith(\"Temporal.PlainDate\")) {\n      return \"Date\";\n    } else {\n      // If this is a fancy import like a superstruct/something, we can't guess what it will be in GraphQL\n      return undefined;\n    }\n  } else if (type instanceof Import) {\n    // If this is a fancy import like a superstruct/something, we can't guess what it will be in GraphQL\n    return undefined;\n  } else {\n    // Anything else like `jsonb` (which shows up as `Object`) is also unlikely to be a valid\n    // GraphQL type, and doing things like `someField: Object` w/o predefined scalar types will\n    // cause GraphQL parsing errors.\n    return undefined;\n  }\n}\n\nexport function isJsonbColumn(p: PrimitiveField) {\n  return p.fieldType === \"Object\" || p.fieldType instanceof Import;\n}\n"],"mappings":"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"}

package/build/graphqlUtils.d.cts

@@ -0,0 +1,31 @@
+import { Fs } from "./utils.cjs";
+import { PrimitiveField, PrimitiveTypescriptType } from "joist-codegen";
+import { Code, Import } from "ts-poet";
+//#region src/graphqlUtils.d.ts
+/** A type for the fields we want to add to `*.graphql` files. */
+type GqlField = {
+  file: string;
+  objectType: "input" | "output";
+  objectName: string;
+  fieldName: string;
+  fieldType: string;
+  argsString?: string;
+  extends?: boolean;
+};
+type GqlUnion = {
+  file: string;
+  objectName: string;
+  objectType: "union";
+  types: string[];
+};
+type GqlEntry = GqlField | GqlUnion;
+/** Given a `file` and `fields` to go in it (for potentially different objects), upserts into the existing types. */
+declare function upsertIntoFile(fs: Fs, file: string, fields: GqlEntry[]): Promise<void>;
+declare function formatGraphQL(content: string): Promise<string>;
+type GraphQLType = "BigInt" | "Boolean" | "String" | "Int" | "Date" | "DateTime" | string;
+type SupportedTypescriptTypes = Exclude<PrimitiveTypescriptType, "Object" | Import>;
+declare function mapTypescriptTypeToGraphQLType(fieldName: string, type: PrimitiveTypescriptType | Import | Code): GraphQLType | undefined;
+declare function isJsonbColumn(p: PrimitiveField): boolean;
+//#endregion
+export { GqlEntry, GqlField, GqlUnion, GraphQLType, SupportedTypescriptTypes, formatGraphQL, isJsonbColumn, mapTypescriptTypeToGraphQLType, upsertIntoFile };
+//# sourceMappingURL=graphqlUtils.d.cts.map

package/build/graphqlUtils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlUtils.d.cts","names":[],"sources":["../src/graphqlUtils.ts"],"mappings":";;;;;KAkBY;EACV;EACA;EACA;EACA;EACA;EAEA;EACA;;KAGU;EAAa;EAAc;EAAoB;EAAqB;;KAEpE,WAAW,WAAW;;iBAGZ,eAAe,IAAI,IAAI,cAAc,QAAQ,aAAa;iBAyB1D,cAAc,kBAAkB;KA+J1C;KAEA,2BAA2B,QAAQ,oCAAoC;iBAEnE,+BACd,mBACA,MAAM,0BAA0B,SAAS,OACxC;iBAoCa,cAAc,GAAG"}

package/build/graphqlUtils.d.mts

@@ -0,0 +1,31 @@
+import { Fs } from "./utils.mjs";
+import { PrimitiveField, PrimitiveTypescriptType } from "joist-codegen";
+import { Code, Import } from "ts-poet";
+//#region src/graphqlUtils.d.ts
+/** A type for the fields we want to add to `*.graphql` files. */
+type GqlField = {
+  file: string;
+  objectType: "input" | "output";
+  objectName: string;
+  fieldName: string;
+  fieldType: string;
+  argsString?: string;
+  extends?: boolean;
+};
+type GqlUnion = {
+  file: string;
+  objectName: string;
+  objectType: "union";
+  types: string[];
+};
+type GqlEntry = GqlField | GqlUnion;
+/** Given a `file` and `fields` to go in it (for potentially different objects), upserts into the existing types. */
+declare function upsertIntoFile(fs: Fs, file: string, fields: GqlEntry[]): Promise<void>;
+declare function formatGraphQL(content: string): Promise<string>;
+type GraphQLType = "BigInt" | "Boolean" | "String" | "Int" | "Date" | "DateTime" | string;
+type SupportedTypescriptTypes = Exclude<PrimitiveTypescriptType, "Object" | Import>;
+declare function mapTypescriptTypeToGraphQLType(fieldName: string, type: PrimitiveTypescriptType | Import | Code): GraphQLType | undefined;
+declare function isJsonbColumn(p: PrimitiveField): boolean;
+//#endregion
+export { GqlEntry, GqlField, GqlUnion, GraphQLType, SupportedTypescriptTypes, formatGraphQL, isJsonbColumn, mapTypescriptTypeToGraphQLType, upsertIntoFile };
+//# sourceMappingURL=graphqlUtils.d.mts.map

package/build/graphqlUtils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlUtils.d.mts","names":[],"sources":["../src/graphqlUtils.ts"],"mappings":";;;;;KAkBY;EACV;EACA;EACA;EACA;EACA;EAEA;EACA;;KAGU;EAAa;EAAc;EAAoB;EAAqB;;KAEpE,WAAW,WAAW;;iBAGZ,eAAe,IAAI,IAAI,cAAc,QAAQ,aAAa;iBAyB1D,cAAc,kBAAkB;KA+J1C;KAEA,2BAA2B,QAAQ,oCAAoC;iBAEnE,+BACd,mBACA,MAAM,0BAA0B,SAAS,OACxC;iBAoCa,cAAc,GAAG"}

package/build/graphqlUtils.js

@@ -1,252 +1,154 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.upsertIntoFile = upsertIntoFile;
-exports.formatGraphQL = formatGraphQL;
-exports.mapTypescriptTypeToGraphQLType = mapTypescriptTypeToGraphQLType;
-exports.isJsonbColumn = isJsonbColumn;
-const graphql_1 = require("graphql");
-const joist_utils_1 = require("joist-utils");
-const prettier_1 = __importStar(require("prettier"));
-const ts_poet_1 = require("ts-poet");
+import "./utils.js";
+import "joist-codegen";
+import { Code, Import } from "ts-poet";
+import { groupBy } from "joist-utils";
+import { parse, print, visit } from "graphql";
+import prettier, { resolveConfig } from "prettier";
+//#region src/graphqlUtils.ts
 /** Given a `file` and `fields` to go in it (for potentially different objects), upserts into the existing types. */
 async function upsertIntoFile(fs, file, fields) {
-    // Group the fields by each individual object (either input types or output types)
-    const byObjectName = (0, joist_utils_1.groupBy)(fields, (f) => f.objectName);
-    const existingDoc = parseOrNewEmptyDoc(await fs.load(file));
-    // For each type, create a "new" / ideal definition that exactly matches the domain model
-    const newDocs = Object.entries(byObjectName).map(([objectName, fields]) => {
-        const [entry] = fields;
-        return [
-            objectName,
-            entry.objectType === "union"
-                ? createUnionDoc(entry)
-                : createFieldDoc(objectName, fields),
-        ];
-    });
-    // Merge each `newDoc` object definition into the file's existing types
-    const content = (0, graphql_1.print)(mergeDocs(existingDoc, newDocs));
-    const formatted = await formatGraphQL(content);
-    await fs.save(file, formatted);
+	const byObjectName = groupBy(fields, (f) => f.objectName);
+	const existingDoc = parseOrNewEmptyDoc(await fs.load(file));
+	const newDocs = Object.entries(byObjectName).map(([objectName, fields]) => {
+		const [entry] = fields;
+		return [objectName, entry.objectType === "union" ? createUnionDoc(entry) : createFieldDoc(objectName, fields)];
+	});
+	const formatted = await formatGraphQL(print(mergeDocs(existingDoc, newDocs)));
+	await fs.save(file, formatted);
 }
 let prettierPromise;
 async function formatGraphQL(content) {
-    const prettierConfig = await (prettierPromise ??= (0, prettier_1.resolveConfig)("./"));
-    return prettier_1.default.format(content, {
-        parser: "graphql",
-        ...prettierConfig,
-        plugins: [],
-    });
+	const prettierConfig = await (prettierPromise ??= resolveConfig("./"));
+	return prettier.format(content, {
+		parser: "graphql",
+		...prettierConfig,
+		plugins: []
+	});
 }
 /**
- * Creates a new AST DocumentNode for the given object + field definitions.
- *
- * This leverages `parse` to do the dirty work of taking an "easy for us to create"
- * string of GraphQL SDL and turning it into a "pita to create by hand" AST
- * of object / field / type / etc. nodes.
- */
+* Creates a new AST DocumentNode for the given object + field definitions.
+*
+* This leverages `parse` to do the dirty work of taking an "easy for us to create"
+* string of GraphQL SDL and turning it into a "pita to create by hand" AST
+* of object / field / type / etc. nodes.
+*/
 function createFieldDoc(objectName, fields) {
-    const [{ objectType }] = fields;
-    const type = objectType === "output" ? "type" : objectType;
-    const maybeArgs = (f) => (f.argsString ? `(${f.argsString})` : "");
-    const maybeExtends = fields.some((f) => f.extends) ? "extend " : "";
-    const source = `${maybeExtends}${type} ${objectName} {
+	const [{ objectType }] = fields;
+	const type = objectType === "output" ? "type" : objectType;
+	const maybeArgs = (f) => f.argsString ? `(${f.argsString})` : "";
+	const source = `${fields.some((f) => f.extends) ? "extend " : ""}${type} ${objectName} {
     ${fields.map((f) => `${f.fieldName}${maybeArgs(f)}: ${f.fieldType}`)}
   }`;
-    return (0, graphql_1.parse)(source);
+	return parse(source);
 }
 function createUnionDoc(union) {
-    const { objectName, types } = union;
-    return (0, graphql_1.parse)(`union ${objectName} = ${types.join(" | ")}`);
+	const { objectName, types } = union;
+	return parse(`union ${objectName} = ${types.join(" | ")}`);
 }
 function parseOrNewEmptyDoc(content) {
-    return content ? (0, graphql_1.parse)(content) : newEmptyDocument();
+	return content ? parse(content) : newEmptyDocument();
 }
 function newEmptyDocument() {
-    // I can't figure out how to `parse("")`, i.e. create an empty DocumentNode, so pretend
-    // to make a `type Foo` but then throw it away so that DocumentNode ends up empty.
-    return (0, graphql_1.visit)((0, graphql_1.parse)("type Foo"), {
-        ObjectTypeDefinition() {
-            return null;
-        },
-    });
+	return visit(parse("type Foo"), { ObjectTypeDefinition() {
+		return null;
+	} });
 }
 /**
- * Merges a given `newType` from `newDoc` into `existingDoc*.
- *
- * There are existing "merge schema" libraries/tools out there, but we want to be very purposeful
- * about keeping the existing SDL and this is really not too bad because we're only stitching
- * ~two levels of the AST (document -> objects and object -> fields).
- *
- * We also cheat by using `createNewDoc` to get ASTs of the new content, so we don't have
- * to laboriously built up the ASTs by hand.
- */
+* Merges a given `newType` from `newDoc` into `existingDoc*.
+*
+* There are existing "merge schema" libraries/tools out there, but we want to be very purposeful
+* about keeping the existing SDL and this is really not too bad because we're only stitching
+* ~two levels of the AST (document -> objects and object -> fields).
+*
+* We also cheat by using `createNewDoc` to get ASTs of the new content, so we don't have
+* to laboriously built up the ASTs by hand.
+*/
 function mergeDocs(existingDoc, newDocs) {
-    // Now merged the two
-    return (0, graphql_1.visit)(existingDoc, {
-        // If the `type Book` does not exist yet, add it
-        Document(node) {
-            return {
-                ...node,
-                definitions: [
-                    ...node.definitions,
-                    ...newDocs
-                        .filter(([objectType]) => {
-                        return !node.definitions.some((d) => (d.kind === "ObjectTypeDefinition" ||
-                            d.kind === "ObjectTypeExtension" ||
-                            d.kind === "InputObjectTypeDefinition" ||
-                            d.kind === "UnionTypeDefinition") &&
-                            d.name.value === objectType);
-                    })
-                        .flatMap(([, d]) => d.definitions),
-                ].sort(byOperationExtensionsFirst),
-            };
-        },
-        // If fields don't exist yet, add them
-        ObjectTypeDefinition(node) {
-            return mergeObjectTypeFields(node, newDocs);
-        },
-        ObjectTypeExtension(node) {
-            return mergeObjectTypeFields(node, newDocs);
-        },
-        // If fields don't exist yet, add them
-        InputObjectTypeDefinition(node) {
-            const found = newDocs.find(([objectType]) => node.name.value === objectType);
-            if (found) {
-                const [, newDoc] = found;
-                const existingFieldNames = (node.fields || []).map((f) => f.name.value);
-                const newObjectType = newDoc.definitions[0];
-                return {
-                    ...node,
-                    fields: [
-                        ...(node.fields || []),
-                        ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value)),
-                    ],
-                };
-            }
-            return node;
-        },
-        UnionTypeDefinition(node) {
-            const found = newDocs.find(([objectType]) => node.name.value === objectType);
-            if (found) {
-                const [, newDoc] = found;
-                const [definition] = newDoc.definitions;
-                return {
-                    ...node,
-                    types: definition.types,
-                };
-            }
-            return node;
-        },
-    });
+	return visit(existingDoc, {
+		Document(node) {
+			return {
+				...node,
+				definitions: [...node.definitions, ...newDocs.filter(([objectType]) => {
+					return !node.definitions.some((d) => (d.kind === "ObjectTypeDefinition" || d.kind === "ObjectTypeExtension" || d.kind === "InputObjectTypeDefinition" || d.kind === "UnionTypeDefinition") && d.name.value === objectType);
+				}).flatMap(([, d]) => d.definitions)].sort(byOperationExtensionsFirst)
+			};
+		},
+		ObjectTypeDefinition(node) {
+			return mergeObjectTypeFields(node, newDocs);
+		},
+		ObjectTypeExtension(node) {
+			return mergeObjectTypeFields(node, newDocs);
+		},
+		InputObjectTypeDefinition(node) {
+			const found = newDocs.find(([objectType]) => node.name.value === objectType);
+			if (found) {
+				const [, newDoc] = found;
+				const existingFieldNames = (node.fields || []).map((f) => f.name.value);
+				const newObjectType = newDoc.definitions[0];
+				return {
+					...node,
+					fields: [...node.fields || [], ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value))]
+				};
+			}
+			return node;
+		},
+		UnionTypeDefinition(node) {
+			const found = newDocs.find(([objectType]) => node.name.value === objectType);
+			if (found) {
+				const [, newDoc] = found;
+				const [definition] = newDoc.definitions;
+				return {
+					...node,
+					types: definition.types
+				};
+			}
+			return node;
+		}
+	});
 }
 /** Merges generated fields into an existing `type` or `extend type`. */
 function mergeObjectTypeFields(node, newDocs) {
-    const found = newDocs.find(([objectType]) => node.name.value === objectType);
-    if (found) {
-        const [, newDoc] = found;
-        const existingFieldNames = (node.fields || []).map((f) => f.name.value);
-        const newObjectType = newDoc.definitions[0];
-        return {
-            ...node,
-            fields: [
-                ...(node.fields || []),
-                ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value)),
-            ],
-        };
-    }
-    return node;
+	const found = newDocs.find(([objectType]) => node.name.value === objectType);
+	if (found) {
+		const [, newDoc] = found;
+		const existingFieldNames = (node.fields || []).map((f) => f.name.value);
+		const newObjectType = newDoc.definitions[0];
+		return {
+			...node,
+			fields: [...node.fields || [], ...(newObjectType.fields || []).filter((f) => !existingFieldNames.includes(f.name.value))]
+		};
+	}
+	return node;
 }
 /** Keeps the primary operation extensions at the top of generated schema files. */
 function byOperationExtensionsFirst(a, b) {
-    return operationExtensionRank(a) - operationExtensionRank(b);
+	return operationExtensionRank(a) - operationExtensionRank(b);
 }
 /** Returns the priority for placing generated operation extensions before types/inputs. */
 function operationExtensionRank(definition) {
-    if (definition.kind === "ObjectTypeExtension" && definition.name.value === "Query")
-        return 0;
-    if (definition.kind === "ObjectTypeExtension" && definition.name.value === "Mutation")
-        return 1;
-    return 2;
+	if (definition.kind === "ObjectTypeExtension" && definition.name.value === "Query") return 0;
+	if (definition.kind === "ObjectTypeExtension" && definition.name.value === "Mutation") return 1;
+	return 2;
 }
 function mapTypescriptTypeToGraphQLType(fieldName, type) {
-    if (type === "string") {
-        return "String";
-    }
-    else if (type === "boolean") {
-        return "Boolean";
-    }
-    else if (type === "number") {
-        return "Int";
-    }
-    else if (type === "bigint") {
-        return "BigInt";
-    }
-    else if (type instanceof ts_poet_1.Code) {
-        const rawType = type.toCodeString([]);
-        if (rawType.startsWith("Date")) {
-            // Legacy javascript Date doesn't have different `date` vs. `datetime` types but GraphQL does
-            // so lean on the `..._at` suffix convention to know "DateTime".
-            return fieldName.endsWith("At") ? "DateTime" : "Date";
-        }
-        else if (rawType.startsWith("Temporal.ZonedDateTime")) {
-            return "DateTime";
-        }
-        else if (rawType.startsWith("Temporal.PlainDateTime")) {
-            return "DateTime";
-        }
-        else if (rawType.startsWith("Temporal.PlainDate")) {
-            return "Date";
-        }
-        else {
-            // If this is a fancy import like a superstruct/something, we can't guess what it will be in GraphQL
-            return undefined;
-        }
-    }
-    else if (type instanceof ts_poet_1.Import) {
-        // If this is a fancy import like a superstruct/something, we can't guess what it will be in GraphQL
-        return undefined;
-    }
-    else {
-        // Anything else like `jsonb` (which shows up as `Object`) is also unlikely to be a valid
-        // GraphQL type, and doing things like `someField: Object` w/o predefined scalar types will
-        // cause GraphQL parsing errors.
-        return undefined;
-    }
+	if (type === "string") return "String";
+	else if (type === "boolean") return "Boolean";
+	else if (type === "number") return "Int";
+	else if (type === "bigint") return "BigInt";
+	else if (type instanceof Code) {
+		const rawType = type.toCodeString([]);
+		if (rawType.startsWith("Date")) return fieldName.endsWith("At") ? "DateTime" : "Date";
+		else if (rawType.startsWith("Temporal.ZonedDateTime")) return "DateTime";
+		else if (rawType.startsWith("Temporal.PlainDateTime")) return "DateTime";
+		else if (rawType.startsWith("Temporal.PlainDate")) return "Date";
+		else return;
+	} else if (type instanceof Import) return;
+	else return;
 }
 function isJsonbColumn(p) {
-    return p.fieldType === "Object" || p.fieldType instanceof ts_poet_1.Import;
+	return p.fieldType === "Object" || p.fieldType instanceof Import;
 }
+//#endregion
+export { formatGraphQL, isJsonbColumn, mapTypescriptTypeToGraphQLType, upsertIntoFile };
+
 //# sourceMappingURL=graphqlUtils.js.map