@getcronit/pylon-builder 0.0.49

package/dist/bundler/bundler.d.ts

@@ -0,0 +1,13 @@
+export interface BundlerBuildOptions {
+    getTypeDefs: () => string;
+    watch?: boolean;
+    onWatch?: () => void;
+}
+export declare class Bundler {
+    sfiFilePath: string;
+    outputDir: string;
+    constructor(sfiFilePath: string, outputDir?: string);
+    build(options: BundlerBuildOptions): Promise<void>;
+    private prependTypeDefs;
+    private reportStatus;
+}

package/dist/bundler/index.d.ts

@@ -0,0 +1 @@
+export { Bundler } from './bundler.js';

package/dist/generate-client.d.ts

@@ -0,0 +1 @@
+export declare function generateClientWhenServerIsHealthy(): Promise<void>;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export interface BuildOptions {
+    sfiFilePath: string;
+    outputFilePath: string;
+    watch?: boolean;
+    onWatch?: () => void;
+}
+export declare const build: (options: BuildOptions) => Promise<void>;

package/dist/index.js

@@ -0,0 +1,834 @@
+// @bun
+// src/bundler/bundler.ts
+import fs from "fs";
+import chokidar from "chokidar";
+
+// src/load-package-json.ts
+import path from "path";
+import {readFile} from "fs/promises";
+async function loadPackageJson() {
+  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  const file = await readFile(packageJsonPath);
+  const packageJson = JSON.parse(file.toString());
+  return packageJson;
+}
+
+// src/bundler/bundler.ts
+import ncc2 from "@vercel/ncc";
+import path2 from "path";
+
+class Bundler {
+  sfiFilePath;
+  outputDir;
+  constructor(sfiFilePath, outputDir = "./.pylon") {
+    this.sfiFilePath = sfiFilePath;
+    this.outputDir = outputDir;
+  }
+  async build(options) {
+    this.reportStatus("start");
+    const build = async () => {
+      const external = new Set([
+        "@cronitio/pylon",
+        "hono",
+        "@prisma/client",
+        "openid-client",
+        "hono/http-exception"
+      ]);
+      const packageJson = await loadPackageJson();
+      if (packageJson.pylon && packageJson.pylon.external) {
+        packageJson.pylon.external.forEach((externalPackage) => {
+          external.add(externalPackage);
+        });
+      }
+      const nccOptions = {
+        quiet: true,
+        externals: Array.from(external),
+        sourceMap: true,
+        transpileOnly: true
+      };
+      const inputPath = path2.join(process.cwd(), this.sfiFilePath);
+      const dir = path2.join(process.cwd(), this.outputDir);
+      const { code, map, assets } = await ncc2(inputPath, nccOptions);
+      fs.mkdirSync(dir, {
+        recursive: true
+      });
+      fs.writeFileSync(`${dir}/index.js`, code);
+      Object.entries(assets).forEach(([name, asset]) => {
+        const source = asset.source;
+        if (typeof source === "string") {
+          fs.writeFileSync(`${dir}/${name}`, source);
+        } else if (typeof source === "object") {
+          fs.writeFileSync(`${dir}/${name}`, Buffer.from(source));
+        }
+      });
+      this.prependTypeDefs(options.getTypeDefs());
+      this.reportStatus("done");
+    };
+    if (options.watch) {
+      chokidar.watch(this.sfiFilePath).on("change", async () => {
+        await build();
+        if (options.onWatch) {
+          options.onWatch();
+        }
+      });
+    }
+    await build();
+  }
+  prependTypeDefs(typeDefs) {
+    const outputFile = `${this.outputDir}/index.js`;
+    fs.writeFileSync(outputFile, `export const typeDefs = ${JSON.stringify(typeDefs)};\n` + fs.readFileSync(outputFile));
+  }
+  reportStatus(status) {
+    if (status === "start") {
+      console.log("\x1B[32m%s\x1B[0m", `Bundling Pylon: ${this.sfiFilePath}...`);
+    }
+    if (status === "done") {
+      console.log("\x1B[32m%s\x1B[0m", "Bundling Pylon: done");
+    }
+  }
+}
+
+// src/schema/builder.ts
+import ts4 from "typescript";
+
+// src/schema/schema-parser.ts
+import ts3 from "typescript";
+
+// src/schema/types-helper.ts
+import ts from "typescript";
+function getPublicPropertiesOfType(checker, _type) {
+  let type = _type;
+  if (type.isUnion()) {
+    const nonArrayTypes = type.types.filter((t) => !(t.flags & ts.TypeFlags.Object && t.objectFlags & ts.ObjectFlags.Reference && t.typeArguments?.length));
+    const arrayElementTypes = type.types.filter((t) => t.flags & ts.TypeFlags.Object && t.objectFlags & ts.ObjectFlags.Reference && t.typeArguments?.length).map((t) => t.typeArguments[0]);
+    const filteredTypes = nonArrayTypes.filter((t) => !arrayElementTypes.some((et) => et === t));
+    type = checker.getUnionType(filteredTypes);
+  }
+  const properties = [];
+  if (isList(checker, type) || isPrimitive(type) || isEnum(type))
+    return properties;
+  let typeProperties = [];
+  typeProperties = type.resolvedProperties || type.getProperties() || [];
+  for (const prop of typeProperties) {
+    const isPublic = prop.valueDeclaration && !(ts.getCombinedModifierFlags(prop.valueDeclaration) & ts.ModifierFlags.Private) && !prop.getName().startsWith("#");
+    if (isPublic === false) {
+      continue;
+    }
+    properties.push(prop);
+  }
+  return properties;
+}
+var isEmptyObject = (type) => {
+  return type.flags & ts.TypeFlags.Object && type.getProperties().length === 0 && type.getCallSignatures().length === 0;
+};
+var isList = (checker, type) => {
+  const typeNode = checker.typeToTypeNode(type, undefined, undefined);
+  const is = !!(typeNode && (typeNode.kind === ts.SyntaxKind.ArrayType || typeNode.kind === ts.SyntaxKind.TupleType));
+  return is;
+};
+var isPrimitive = (type) => {
+  const primitive = type.flags & ts.TypeFlags.String || type.flags & ts.TypeFlags.Number || type.flags & ts.TypeFlags.Boolean || type.flags & ts.TypeFlags.StringLiteral || type.flags & ts.TypeFlags.NumberLiteral || type.flags & ts.TypeFlags.BooleanLiteral;
+  return primitive;
+};
+var isFunction = (type) => {
+  return type.getCallSignatures().length > 0;
+};
+var isEnum = (type) => {
+  if (isPrimitive(type))
+    return false;
+  const isUnion = type.types?.length > 1;
+  if (isUnion) {
+    const isAllPrimitives = type.types.every((t) => t.flags & ts.TypeFlags.StringLiteral || t.flags & ts.TypeFlags.NumberLiteral || t.flags & ts.TypeFlags.BooleanLiteral);
+    if (isAllPrimitives) {
+      return true;
+    }
+  }
+  return false;
+};
+var isPromise = (type) => {
+  return type.getSymbol()?.getName() === "Promise";
+};
+var getPromiseType = (type) => {
+  let objectType = type;
+  if (objectType.objectFlags & ts.ObjectFlags.Reference) {
+    const reference = type;
+    const typeArguments = reference.typeArguments;
+    if (typeArguments && typeArguments.length > 0) {
+      return typeArguments[0];
+    }
+  }
+};
+var excludeNullUndefinedFromType = (type) => {
+  if (!type.isUnion())
+    return {
+      type,
+      wasOptional: false
+    };
+  const types = type.types.filter((t) => !(t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Null));
+  const wasOptional = types.length !== type.types.length;
+  return {
+    type: type.getNonNullableType(),
+    wasOptional
+  };
+};
+var safeTypeName = (name) => {
+  return name.replace(/[^0-9a-zA-Z_]/g, "_");
+};
+
+// src/schema/type-definition-builder.ts
+import ts2 from "typescript";
+class TypeDefinitionBuilder {
+  checker;
+  schema;
+  typesNameMap = new Map;
+  inputsNameMap = new Map;
+  unions = [];
+  enums = [];
+  constructor(checker, schema) {
+    this.checker = checker;
+    this.schema = schema;
+  }
+  getTypeDefinition = (rawType, options = {
+    isInputType: false
+  }) => {
+    const { type, wasOptional } = excludeNullUndefinedFromType(rawType);
+    if (isPromise(type)) {
+      const promiseType = getPromiseType(type);
+      if (promiseType) {
+        return this.getTypeDefinition(promiseType, options);
+      }
+    }
+    const isRequired = options.isRequired !== undefined ? options.isRequired : !wasOptional;
+    if (isEmptyObject(type)) {
+      return {
+        name: "Object",
+        isList: false,
+        isRequired
+      };
+    }
+    let nameMap = options.isInputType ? this.inputsNameMap : this.typesNameMap;
+    if (nameMap.has(type)) {
+      const typeName2 = nameMap.get(type);
+      return {
+        name: typeName2,
+        isList: false,
+        isRequired
+      };
+    }
+    let typeName = type.aliasSymbol?.escapedName?.toString() || type.symbol?.escapedName.toString();
+    if (typeName === "__type" || typeName === "__object") {
+      if (!options.propertyName) {
+        typeName = undefined;
+      } else {
+        const capitalizedPropertyName = options.propertyName.charAt(0).toUpperCase() + options.propertyName.slice(1);
+        typeName = capitalizedPropertyName;
+      }
+    }
+    if (typeName) {
+      typeName = safeTypeName(typeName);
+    }
+    const duplicateName = (name) => {
+      return Array.from(nameMap.values()).includes(name);
+    };
+    if (typeName) {
+      if (options.isInputType) {
+        typeName = `${typeName}Input`;
+      }
+      let i = 1;
+      let originalTypeName = typeName;
+      while (duplicateName(typeName)) {
+        typeName = `${originalTypeName}_${i}`;
+        i++;
+      }
+    }
+    if (typeName && this.schema.scalars.includes(typeName)) {
+      return {
+        name: typeName,
+        isList: false,
+        isRequired
+      };
+    }
+    if (isList(this.checker, type)) {
+      const listType = this.checker.getIndexTypeOfType(type, ts2.IndexKind.Number);
+      if (listType) {
+        const def = this.getTypeDefinition(listType, options);
+        return {
+          name: def.name,
+          isList: true,
+          isRequired: def.isRequired,
+          isListRequired: isRequired
+        };
+      }
+    } else if (isEnum(type)) {
+      const typeNode = this.checker.typeToTypeNode(type, undefined, undefined);
+      const types = type.types.filter((t) => t.flags & ts2.TypeFlags.StringLiteral);
+      const members = types.map((t) => {
+        if (t.isLiteral()) {
+          const name = t.value?.toString();
+          if (!name) {
+            throw new Error("Enum member name is undefined");
+          }
+          return safeTypeName(name);
+        }
+        throw new Error("Invalid type for enum member");
+      });
+      if (members.length > 0) {
+        typeName = typeName || typeNode.typeName?.symbol?.escapedName;
+        if (!typeName) {
+          typeName = members.join("_").toUpperCase();
+          typeName = options.isInputType ? `${typeName}Input` : typeName;
+        }
+        this.enums.push({
+          name: typeName,
+          values: members,
+          rawType: type
+        });
+      }
+    } else if (isPrimitive(type)) {
+      let typeName2 = this.checker.typeToString(type);
+      if (type.flags & ts2.TypeFlags.StringLiteral) {
+        typeName2 = "String";
+      } else if (type.flags & ts2.TypeFlags.NumberLiteral) {
+        typeName2 = "Number";
+      } else if (type.flags & ts2.TypeFlags.BooleanLiteral) {
+        typeName2 = "Boolean";
+      } else if (type.flags & ts2.TypeFlags.String) {
+        typeName2 = "String";
+      } else if (type.flags & ts2.TypeFlags.Number) {
+        typeName2 = "Number";
+      } else if (type.flags & ts2.TypeFlags.Boolean) {
+        typeName2 = "Boolean";
+      }
+      return {
+        name: safeTypeName(typeName2),
+        isList: false,
+        isRequired
+      };
+    } else if (type.isIntersection()) {
+      const intersectionTypes = type.types;
+      const typeNames = intersectionTypes.map((t) => {
+        const typeDef = this.getTypeDefinition(t, options);
+        return typeDef.name;
+      });
+      typeName = safeTypeName(typeName || typeNames.join("And"));
+    } else if (type.isUnion()) {
+      const unionTypes = type.types;
+      const required = type.types.length === unionTypes.length;
+      const hasPrimitivesOrEnum = unionTypes.some((t) => {
+        const type2 = isList(this.checker, t) ? this.checker.getIndexTypeOfType(t, ts2.IndexKind.Number) : t;
+        if (!type2) {
+          return true;
+        }
+        return isPrimitive(type2) || isEnum(type2);
+      });
+      const unionTypeDefs = [
+        ...new Set(unionTypes.map((t) => this.getTypeDefinition(t, { ...options, isRequired: required })))
+      ];
+      const listTypes = unionTypeDefs.filter((t) => t.isList);
+      for (const listType of listTypes) {
+        const index = unionTypeDefs.findIndex((t) => t.name === listType.name && !t.isList);
+        if (index > -1) {
+          unionTypeDefs.splice(index, 1);
+        }
+      }
+      const typeNames = unionTypeDefs.map((t) => t.name);
+      typeName = safeTypeName(typeName || typeNames.join("Or"));
+      if (unionTypeDefs.length > 1 && !options.isInputType && !hasPrimitivesOrEnum) {
+        this.unions.push({
+          name: typeName,
+          types: typeNames,
+          rawType: type
+        });
+      } else {
+        const typeDef = unionTypeDefs[0];
+        if (!typeDef) {
+          throw new Error("Cannot get type definition");
+        }
+        const isList2 = unionTypeDefs.some((t) => {
+          return t.isList && t.name === typeDef.name;
+        });
+        return {
+          name: typeDef.name,
+          isList: isList2,
+          isRequired
+        };
+      }
+    } else if (isFunction(type)) {
+      const signature = type.getCallSignatures()[0];
+      let returnType = signature?.getReturnType();
+      if (returnType) {
+        if (isPromise(returnType)) {
+          const pt = getPromiseType(returnType);
+          if (pt) {
+            returnType = pt;
+          }
+        }
+      }
+      if (returnType) {
+        const def = this.getTypeDefinition(returnType, options);
+        return def;
+      }
+    }
+    if (!typeName) {
+      typeName = "Any";
+    }
+    nameMap.set(type, typeName);
+    return {
+      name: typeName,
+      isList: false,
+      isRequired
+    };
+  };
+  getUnions() {
+    return this.unions;
+  }
+  getEnums() {
+    return this.enums;
+  }
+  typeDefinitionToGraphQLType = (typeDefinition) => {
+    let type = typeDefinition.name;
+    const { isList: isList2, isRequired, isListRequired } = typeDefinition;
+    if (isRequired) {
+      type = `${type}!`;
+    }
+    if (isList2) {
+      type = `[${type}]`;
+      if (isListRequired) {
+        type = `${type}!`;
+      }
+    }
+    return type;
+  };
+}
+
+// src/schema/schema-parser.ts
+class SchemaParser {
+  schema;
+  checker;
+  sfiFile;
+  typeDefinitionBuilder;
+  constructor(checker, sfiFile) {
+    this.schema = {
+      types: [],
+      inputs: [],
+      unions: [],
+      enums: [],
+      scalars: [
+        "Number",
+        "Any",
+        "Object",
+        "File",
+        "Date",
+        "JSON",
+        "String",
+        "Boolean"
+      ]
+    };
+    this.checker = checker;
+    this.sfiFile = sfiFile;
+    this.typeDefinitionBuilder = new TypeDefinitionBuilder(checker, this.schema);
+  }
+  parse(index) {
+    const referenceSchema = this.makeReferenceSchema(index);
+    for (const [type, properties] of referenceSchema.types) {
+      let typeName = undefined;
+      if (index.Query === type) {
+        typeName = "Query";
+      } else if (index.Mutation === type) {
+        typeName = "Mutation";
+      }
+      this.processSchemaReference(type, properties, typeName, "types");
+    }
+    for (const [type, properties] of referenceSchema.inputs) {
+      this.processSchemaReference(type, properties, undefined, "inputs");
+    }
+    this.extractForbiddenFieldNamesFromSchema();
+    this.schema.unions = this.typeDefinitionBuilder.getUnions().map((union) => {
+      return {
+        ...union,
+        description: this.getJsDocHeaderFromType(union.rawType)
+      };
+    });
+    this.schema.enums = this.typeDefinitionBuilder.getEnums().map((enumType) => {
+      return {
+        ...enumType,
+        description: this.getJsDocHeaderFromType(enumType.rawType)
+      };
+    });
+  }
+  toString() {
+    const { typeDefinitionToGraphQLType } = this.typeDefinitionBuilder;
+    const addDescription = (description) => {
+      if (!description)
+        return "";
+      return `"""\n${description}\n"""\n`;
+    };
+    let schemaString = "";
+    for (const input of this.schema.inputs) {
+      schemaString += addDescription(input.description);
+      schemaString += `input ${input.name} {\n`;
+      if (input.fields.length === 0) {
+        schemaString += `\t_ : String\n`;
+      }
+      for (const field of input.fields) {
+        schemaString += `${addDescription(field.type.description)}`;
+        schemaString += `\t${field.name}: ${typeDefinitionToGraphQLType(field.type)}\n`;
+      }
+      schemaString += `}\n`;
+    }
+    for (const type of this.schema.types) {
+      if (type.fields.length === 0)
+        continue;
+      schemaString += addDescription(type.description);
+      schemaString += `type ${type.name} {\n`;
+      for (const field of type.fields) {
+        let args = "";
+        if (field.args.length > 0) {
+          args = `(${field.args.map((arg) => `${addDescription(type.description)}${arg.name}: ${typeDefinitionToGraphQLType(arg.type)}`).join(", ")})`;
+        }
+        schemaString += `${addDescription(field.type.description)}`;
+        schemaString += `${field.name}${args}: ${typeDefinitionToGraphQLType(field.type)}\n`;
+      }
+      schemaString += `}\n`;
+    }
+    for (const union of this.schema.unions) {
+      schemaString += addDescription(union.description);
+      schemaString += `union ${union.name} = ${union.types.join(" | ")}\n`;
+    }
+    for (const scalar of this.schema.scalars) {
+      schemaString += `scalar ${scalar}\n`;
+    }
+    for (const enumType of this.schema.enums) {
+      schemaString += addDescription(enumType.description);
+      schemaString += `enum ${enumType.name} {\n`;
+      for (const value of enumType.values) {
+        schemaString += `\t${value}\n`;
+      }
+      schemaString += `}\n`;
+    }
+    return schemaString;
+  }
+  getSchema() {
+    return this.schema;
+  }
+  processSchemaReference(type, properties, typeName, processing = "types") {
+    const { getTypeDefinition } = this.typeDefinitionBuilder;
+    const isInputType = processing === "inputs";
+    const def = getTypeDefinition(type, { isInputType });
+    const name = typeName || def.name;
+    let root = this.schema[processing].find((t) => t.name === name);
+    if (!root) {
+      if (this.schema.scalars.includes(name)) {
+        return;
+      } else {
+        this.schema[processing].push({
+          name,
+          description: this.getJsDocHeaderFromType(type),
+          fields: []
+        });
+        root = this.schema[processing][this.schema[processing].length - 1];
+      }
+    }
+    for (const [propertyName, property] of Object.entries(properties)) {
+      const fieldType = property.returnType;
+      const fieldDef = getTypeDefinition(fieldType, {
+        isInputType,
+        propertyName
+      });
+      if (processing === "types") {
+        const field = {
+          name: propertyName,
+          type: {
+            ...fieldDef,
+            description: this.getJsDocHeaderFromType(fieldType)
+          },
+          args: []
+        };
+        if (property.args) {
+          for (const [argName, arg] of Object.entries(property.args)) {
+            const argType = arg;
+            const fieldDef2 = getTypeDefinition(argType, {
+              isInputType: true,
+              propertyName: argName
+            });
+            if (this.schema.scalars.includes(this.checker.typeToString(argType))) {
+              fieldDef2.name = this.checker.typeToString(argType);
+            }
+            field.args.push({
+              name: argName,
+              type: {
+                ...fieldDef2,
+                description: this.getJsDocHeaderFromType(argType)
+              }
+            });
+          }
+        }
+        root.fields.push(field);
+      } else if (processing === "inputs") {
+        const field = {
+          name: propertyName,
+          type: {
+            ...fieldDef,
+            description: this.getJsDocHeaderFromType(fieldType)
+          }
+        };
+        if (!root.fields.find((f) => f.name === field.name)) {
+          root.fields.push(field);
+        }
+      }
+    }
+  }
+  getJsDocHeaderFromType = (type) => {
+    let header = "";
+    if (type.symbol) {
+      const typeDeclaration = type.symbol.declarations?.[0];
+      const comments = typeDeclaration?.jsDoc?.map((doc) => doc.comment).join(" ");
+      if (comments) {
+        header = comments;
+      }
+      const tags = type.symbol.getJsDocTags();
+      const tagComments = tags?.map((tag) => `@${tag.name} ${tag.text?.map((t) => t.text).join(" ")}`).join("\n");
+      if (tagComments) {
+        header = `${header} ${tagComments}`;
+      }
+    }
+    return header;
+  };
+  extractForbiddenFieldNamesFromSchema() {
+    const validFieldNameRegExp = /^[_A-Za-z][_0-9A-Za-z]*$/;
+    const isReserved = (name) => {
+      if (!validFieldNameRegExp.test(name)) {
+        return true;
+      }
+      return name.startsWith("__");
+    };
+    for (const type of this.schema.types) {
+      type.fields = type.fields.filter((field) => {
+        if (isReserved(field.name)) {
+          return false;
+        }
+        return true;
+      });
+    }
+    for (const input of this.schema.inputs) {
+      input.fields = input.fields.filter((field) => {
+        if (isReserved(field.name)) {
+          return false;
+        }
+        return true;
+      });
+    }
+  }
+  makeReferenceSchema(index) {
+    const referenceSchema = {
+      types: new Map,
+      inputs: new Map
+    };
+    const recLoop = (type, info = {}, processing = "types", path3 = []) => {
+      if (referenceSchema[processing].has(type)) {
+        return;
+      }
+      const wrongType = this.checker.typeToString(type) === "[]";
+      if (wrongType) {
+        return;
+      }
+      if (this.schema.scalars.includes(this.checker.typeToString(type))) {
+        return;
+      }
+      if (isPrimitive(type)) {
+        return;
+      }
+      if (isPromise(type)) {
+        if (processing === "inputs") {
+          return;
+        }
+        const promiseType = getPromiseType(type);
+        if (promiseType) {
+          recLoop(promiseType, info, processing, [...path3, "PROMISE"]);
+        }
+        return;
+      }
+      if (type.isUnion()) {
+        if (processing === "types") {
+          type.types.forEach((t) => {
+            if (t.flags & ts3.TypeFlags.Null || t.flags & ts3.TypeFlags.Undefined || isPrimitive(t)) {
+              return;
+            }
+            recLoop(t, info, processing, [
+              ...path3,
+              t.symbol?.getName() || `N/A ${this.checker.typeToString(t)}`
+            ]);
+          });
+        } else {
+          let properties = getPublicPropertiesOfType(this.checker, type.getNonNullableType());
+          if (properties.length === 0) {
+            const nt = type.getNonNullableType();
+            if (nt.isUnion()) {
+              properties = getPublicPropertiesOfType(this.checker, nt.types[0]);
+            }
+          }
+          if (properties.length > 0) {
+            if (!referenceSchema[processing].has(type)) {
+              referenceSchema[processing].set(type, {});
+            }
+            properties.forEach((property) => {
+              const propertyType = this.checker.getTypeOfSymbolAtLocation(property, this.sfiFile);
+              if (!isFunction(propertyType)) {
+                referenceSchema[processing].get(type)[property.escapedName] = {
+                  returnType: propertyType,
+                  args: {}
+                };
+                recLoop(propertyType, {
+                  propetyName: property.escapedName,
+                  parentType: type
+                }, processing, [...path3, property.escapedName]);
+              }
+            });
+          }
+        }
+      } else if (isFunction(type)) {
+        if (processing === "inputs") {
+          return;
+        }
+        if (!info.parentType) {
+          throw new Error("Cannot have a function without a parent type");
+        }
+        const signature = type.getCallSignatures()[0];
+        const args = signature?.getParameters() || [];
+        const returnType = signature?.getReturnType();
+        const schemaType = referenceSchema[processing].get(info.parentType)[info.propetyName];
+        args.forEach((arg) => {
+          if (arg.valueDeclaration && ts3.isParameter(arg.valueDeclaration) && arg.valueDeclaration.dotDotDotToken) {
+            console.warn("Cannot handle rest parameters yet, skipping", arg.escapedName);
+          } else {
+            const argType = this.checker.getTypeOfSymbolAtLocation(arg, this.sfiFile);
+            if (schemaType.args) {
+              schemaType.args[arg.escapedName] = argType;
+              recLoop(argType, {
+                parentType: type
+              }, "inputs", [...path3, arg.escapedName]);
+            }
+          }
+        });
+        if (returnType) {
+          recLoop(returnType, info, processing, [...path3, "RETURN_TYPE"]);
+        }
+      } else if (isList(this.checker, type)) {
+        const itemType = this.checker.getIndexTypeOfType(type, ts3.IndexKind.Number);
+        if (itemType && !isPrimitive(itemType)) {
+          if (!referenceSchema[processing].has(type)) {
+            referenceSchema[processing].set(type, {});
+          }
+          recLoop(itemType, info, processing, [...path3, "ITEM_TYPE"]);
+        }
+      } else if (!isPrimitive(type)) {
+        const properties = getPublicPropertiesOfType(this.checker, type);
+        if (!referenceSchema[processing].has(type)) {
+          referenceSchema[processing].set(type, {});
+        }
+        properties.forEach((property) => {
+          const propertyType = this.checker.getTypeOfSymbolAtLocation(property, this.sfiFile);
+          if (!referenceSchema[processing].get(type)[property.escapedName]) {
+            referenceSchema[processing].get(type)[property.escapedName] = {
+              returnType: propertyType,
+              args: {}
+            };
+          }
+          recLoop(propertyType, {
+            propetyName: property.escapedName,
+            parentType: type
+          }, processing, [...path3, property.escapedName]);
+        });
+      }
+    };
+    if (index.Query) {
+      recLoop(index.Query);
+    }
+    if (index.Mutation) {
+      recLoop(index.Mutation);
+    }
+    return referenceSchema;
+  }
+}
+
+// src/schema/builder.ts
+import path3 from "path";
+
+class SchemaBuilder {
+  program;
+  checker;
+  sfiFile;
+  sfi;
+  sfiFilePath;
+  constructor(sfiFilePath) {
+    this.sfiFilePath = path3.join(process.cwd(), sfiFilePath);
+    this.program = ts4.createProgram([this.sfiFilePath], {
+      target: ts4.ScriptTarget.ESNext,
+      module: ts4.ModuleKind.CommonJS,
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: false,
+      forceConsistentCasingInFileNames: true,
+      noImplicitAny: true,
+      experimentalDecorators: true
+    });
+    this.checker = this.program.getTypeChecker();
+    this.loadSfi();
+  }
+  loadSfi() {
+    const sourceFiles = this.program.getSourceFiles();
+    const file = sourceFiles.find((file2) => file2.fileName === this.sfiFilePath);
+    if (!file) {
+      throw new Error("Could not find index.ts (pylon entrypoint)");
+    }
+    this.sfiFile = file;
+    const sfiFileSymbol = this.checker.getSymbolAtLocation(file);
+    const sfiFileExports = this.checker.getExportsOfModule(sfiFileSymbol);
+    const sfiFileDefaultExport = sfiFileExports.find((exportSymbol) => exportSymbol.escapedName === "default");
+    if (!sfiFileDefaultExport) {
+      throw new Error("Could not find default export");
+    }
+    this.sfi = sfiFileDefaultExport;
+  }
+  build() {
+    const sfiType = this.checker.getTypeOfSymbolAtLocation(this.sfi, this.sfiFile);
+    const plainResolversProperty = sfiType.getProperty("plainResolvers");
+    if (!plainResolversProperty) {
+      throw new Error("Could not find plainResolvers property");
+    }
+    const plainResolversType = this.checker.getTypeOfSymbolAtLocation(plainResolversProperty, this.sfiFile);
+    const queryProperty = plainResolversType.getProperty("Query");
+    const mutationProperty = plainResolversType.getProperty("Mutation");
+    const queryType = queryProperty ? this.checker.getTypeOfSymbolAtLocation(queryProperty, this.sfiFile) : undefined;
+    const mutationType = mutationProperty ? this.checker.getTypeOfSymbolAtLocation(mutationProperty, this.sfiFile) : undefined;
+    const parser = new SchemaParser(this.checker, this.sfiFile);
+    parser.parse({
+      Query: queryType,
+      Mutation: mutationType
+    });
+    return {
+      typeDefs: parser.toString(),
+      schema: parser.getSchema()
+    };
+  }
+}
+
+// src/index.ts
+var build = async (options) => {
+  const bundler2 = new Bundler(options.sfiFilePath, options.outputFilePath);
+  await bundler2.build({
+    getTypeDefs: () => {
+      const builder2 = new SchemaBuilder(options.sfiFilePath);
+      const built = builder2.build();
+      const typeDefs = built.typeDefs;
+      return typeDefs;
+    },
+    watch: options.watch,
+    onWatch: options.onWatch
+  });
+};
+export {
+  build
+};
+
+//# debugId=0C352A137DDA7D9F64756e2164756e21

package/dist/index.js.map

@@ -0,0 +1,21 @@
+{
+  "version": 3,
+  "sources": ["../src/bundler/bundler.ts", "../src/load-package-json.ts", "../src/bundler/bundler.ts", "../src/schema/builder.ts", "../src/schema/schema-parser.ts", "../src/schema/types-helper.ts", "../src/schema/types-helper.ts", "../src/schema/type-definition-builder.ts", "../src/schema/type-definition-builder.ts", "../src/schema/schema-parser.ts", "../src/schema/builder.ts", "../src/index.ts"],
+  "sourcesContent": [
+    "// bundler.ts\nimport fs from 'fs'\nimport chokidar from 'chokidar'\nimport {loadPackageJson} from '../load-package-json'\nimport ncc from '@vercel/ncc'\nimport path from 'path'\n\nexport interface BundlerBuildOptions {\n  getTypeDefs: () => string\n  watch?: boolean\n  onWatch?: () => void\n}\n\nexport class Bundler {\n  sfiFilePath: string\n  outputDir: string\n\n  constructor(sfiFilePath: string, outputDir: string = './.pylon') {\n    this.sfiFilePath = sfiFilePath\n    this.outputDir = outputDir\n  }\n\n  public async build(options: BundlerBuildOptions): Promise<void> {\n    this.reportStatus('start')\n\n    const build = async () => {\n      const external = new Set<string>([\n        '@cronitio/pylon',\n        'hono',\n        '@prisma/client',\n        'openid-client',\n        'hono/http-exception'\n      ])\n\n      // Read \"external\" from package.json\n      const packageJson = await loadPackageJson()\n\n      if (packageJson.pylon && packageJson.pylon.external) {\n        packageJson.pylon.external.forEach((externalPackage: string) => {\n          external.add(externalPackage)\n        })\n      }\n\n      const nccOptions = {\n        quiet: true,\n        externals: Array.from(external),\n        sourceMap: true, // Generate sourcemap\n        transpileOnly: true\n      }\n\n      const inputPath = path.join(process.cwd(), this.sfiFilePath)\n      const dir = path.join(process.cwd(), this.outputDir)\n\n      const {code, map, assets} = await ncc(inputPath, nccOptions)\n\n      fs.mkdirSync(dir, {\n        recursive: true\n      })\n\n      fs.writeFileSync(`${dir}/index.js`, code)\n\n      Object.entries(assets).forEach(([name, asset]) => {\n        const source = (asset as any).source\n\n        if (typeof source === 'string') {\n          fs.writeFileSync(`${dir}/${name}`, source)\n        } else if (typeof source === 'object') {\n          fs.writeFileSync(`${dir}/${name}`, Buffer.from(source))\n        }\n      })\n\n      // attach typeDefs to the output\n      this.prependTypeDefs(options.getTypeDefs())\n\n      this.reportStatus('done')\n    }\n\n    if (options.watch) {\n      chokidar.watch(this.sfiFilePath).on('change', async () => {\n        await build()\n\n        if (options.onWatch) {\n          options.onWatch()\n        }\n      })\n    }\n\n    await build()\n  }\n\n  private prependTypeDefs(typeDefs: string): void {\n    const outputFile = `${this.outputDir}/index.js`\n\n    fs.writeFileSync(\n      outputFile,\n      `\\export const typeDefs = ${JSON.stringify(typeDefs)};\\n` +\n        fs.readFileSync(outputFile)\n    )\n  }\n\n  private reportStatus(status: 'start' | 'done'): void {\n    if (status === 'start') {\n      console.log('\\x1b[32m%s\\x1b[0m', `Bundling Pylon: ${this.sfiFilePath}...`)\n    }\n\n    if (status === 'done') {\n      console.log('\\x1b[32m%s\\x1b[0m', 'Bundling Pylon: done')\n    }\n  }\n}\n",
+  "import path from 'path'\nimport {readFile} from 'fs/promises'\n\nexport async function loadPackageJson(): Promise<{\n  baseURL?: string\n  pylon?: {\n    external?: string[]\n  }\n}> {\n  const packageJsonPath = path.resolve(process.cwd(), 'package.json')\n\n  const file = await readFile(packageJsonPath)\n  const packageJson = JSON.parse(file.toString())\n  return packageJson\n}\n",
+  "// bundler.ts\nimport fs from 'fs'\nimport chokidar from 'chokidar'\nimport {loadPackageJson} from '../load-package-json'\nimport ncc from '@vercel/ncc'\nimport path from 'path'\n\nexport interface BundlerBuildOptions {\n  getTypeDefs: () => string\n  watch?: boolean\n  onWatch?: () => void\n}\n\nexport class Bundler {\n  sfiFilePath: string\n  outputDir: string\n\n  constructor(sfiFilePath: string, outputDir: string = './.pylon') {\n    this.sfiFilePath = sfiFilePath\n    this.outputDir = outputDir\n  }\n\n  public async build(options: BundlerBuildOptions): Promise<void> {\n    this.reportStatus('start')\n\n    const build = async () => {\n      const external = new Set<string>([\n        '@cronitio/pylon',\n        'hono',\n        '@prisma/client',\n        'openid-client',\n        'hono/http-exception'\n      ])\n\n      // Read \"external\" from package.json\n      const packageJson = await loadPackageJson()\n\n      if (packageJson.pylon && packageJson.pylon.external) {\n        packageJson.pylon.external.forEach((externalPackage: string) => {\n          external.add(externalPackage)\n        })\n      }\n\n      const nccOptions = {\n        quiet: true,\n        externals: Array.from(external),\n        sourceMap: true, // Generate sourcemap\n        transpileOnly: true\n      }\n\n      const inputPath = path.join(process.cwd(), this.sfiFilePath)\n      const dir = path.join(process.cwd(), this.outputDir)\n\n      const {code, map, assets} = await ncc(inputPath, nccOptions)\n\n      fs.mkdirSync(dir, {\n        recursive: true\n      })\n\n      fs.writeFileSync(`${dir}/index.js`, code)\n\n      Object.entries(assets).forEach(([name, asset]) => {\n        const source = (asset as any).source\n\n        if (typeof source === 'string') {\n          fs.writeFileSync(`${dir}/${name}`, source)\n        } else if (typeof source === 'object') {\n          fs.writeFileSync(`${dir}/${name}`, Buffer.from(source))\n        }\n      })\n\n      // attach typeDefs to the output\n      this.prependTypeDefs(options.getTypeDefs())\n\n      this.reportStatus('done')\n    }\n\n    if (options.watch) {\n      chokidar.watch(this.sfiFilePath).on('change', async () => {\n        await build()\n\n        if (options.onWatch) {\n          options.onWatch()\n        }\n      })\n    }\n\n    await build()\n  }\n\n  private prependTypeDefs(typeDefs: string): void {\n    const outputFile = `${this.outputDir}/index.js`\n\n    fs.writeFileSync(\n      outputFile,\n      `\\export const typeDefs = ${JSON.stringify(typeDefs)};\\n` +\n        fs.readFileSync(outputFile)\n    )\n  }\n\n  private reportStatus(status: 'start' | 'done'): void {\n    if (status === 'start') {\n      console.log('\\x1b[32m%s\\x1b[0m', `Bundling Pylon: ${this.sfiFilePath}...`)\n    }\n\n    if (status === 'done') {\n      console.log('\\x1b[32m%s\\x1b[0m', 'Bundling Pylon: done')\n    }\n  }\n}\n",
+  "import ts from 'typescript'\nimport {SchemaParser} from './schema-parser'\nimport path from 'path'\n\nexport class SchemaBuilder {\n  private program: ts.Program\n  private checker: ts.TypeChecker\n  private sfiFile!: ts.SourceFile\n  private sfi!: ts.Symbol\n  private sfiFilePath: string\n\n  constructor(sfiFilePath: string) {\n    this.sfiFilePath = path.join(process.cwd(), sfiFilePath)\n\n    this.program = ts.createProgram([this.sfiFilePath], {\n      target: ts.ScriptTarget.ESNext,\n      module: ts.ModuleKind.CommonJS,\n      strict: true,\n      esModuleInterop: true,\n      skipLibCheck: false,\n      forceConsistentCasingInFileNames: true,\n      noImplicitAny: true,\n      experimentalDecorators: true\n    })\n\n    this.checker = this.program.getTypeChecker()\n\n    this.loadSfi()\n  }\n\n  private loadSfi() {\n    const sourceFiles = this.program.getSourceFiles()\n    const file = sourceFiles.find(file => file.fileName === this.sfiFilePath)\n\n    if (!file) {\n      throw new Error('Could not find index.ts (pylon entrypoint)')\n    }\n\n    this.sfiFile = file\n\n    const sfiFileSymbol = this.checker.getSymbolAtLocation(file)!\n    const sfiFileExports = this.checker.getExportsOfModule(sfiFileSymbol!)\n    const sfiFileDefaultExport = sfiFileExports.find(\n      exportSymbol => exportSymbol.escapedName === 'default'\n    )\n\n    if (!sfiFileDefaultExport) {\n      throw new Error('Could not find default export')\n    }\n\n    this.sfi = sfiFileDefaultExport\n  }\n\n  public build() {\n    const sfiType = this.checker.getTypeOfSymbolAtLocation(\n      this.sfi,\n      this.sfiFile\n    )\n\n    const plainResolversProperty = sfiType.getProperty('plainResolvers')\n\n    if (!plainResolversProperty) {\n      throw new Error('Could not find plainResolvers property')\n    }\n\n    const plainResolversType = this.checker.getTypeOfSymbolAtLocation(\n      plainResolversProperty,\n      this.sfiFile\n    )\n\n    const queryProperty = plainResolversType.getProperty('Query')\n    const mutationProperty = plainResolversType.getProperty('Mutation')\n\n    const queryType = queryProperty\n      ? this.checker.getTypeOfSymbolAtLocation(queryProperty, this.sfiFile)\n      : undefined\n    const mutationType = mutationProperty\n      ? this.checker.getTypeOfSymbolAtLocation(mutationProperty, this.sfiFile)\n      : undefined\n\n    const parser = new SchemaParser(this.checker, this.sfiFile)\n\n    parser.parse({\n      Query: queryType,\n      Mutation: mutationType\n    })\n\n    return {\n      typeDefs: parser.toString(),\n      schema: parser.getSchema()\n    }\n  }\n}\n",
+  "import ts from 'typescript'\nimport {\n  getPromiseType,\n  getPublicPropertiesOfType,\n  isFunction,\n  isList,\n  isPrimitive,\n  isPromise\n} from './types-helper.js'\nimport {\n  TypeDefinitionBuilder,\n  Union as _Union,\n  Enum as _Enum\n} from './type-definition-builder.js'\n\ntype Union = _Union & {\n  description: string\n}\n\ntype Enum = _Enum & {\n  description: string\n}\n\ninterface TypeDefinition {\n  name: string\n  isList: boolean\n  isRequired: boolean\n  description: string\n}\n\ninterface Field {\n  name: string\n  type: TypeDefinition\n}\n\ninterface Input {\n  name: string\n  description: string\n  fields: Array<{\n    name: string\n    type: TypeDefinition\n  }>\n}\n\ninterface Type {\n  name: string\n  description: string\n  fields: Array<\n    Field & {\n      args: Array<{\n        name: string\n        type: TypeDefinition\n      }>\n    }\n  >\n}\n\nexport interface Schema {\n  types: Array<Type>\n  inputs: Array<Input>\n  unions: Array<Union>\n  enums: Array<Enum>\n  scalars: Array<string>\n}\n\ntype ReferenceSchemaType = {\n  returnType: ts.Type\n  args: {\n    // value needs to be inputs type\n    [key: string]: ts.Type\n  }\n}\n\ninterface ReferenceSchema {\n  types: Map<\n    ts.Type,\n    {\n      [key: string]: ReferenceSchemaType\n    }\n  >\n  inputs: ReferenceSchema['types']\n}\n\ninterface Index {\n  Query?: ts.Type\n  Mutation?: ts.Type\n}\n\nexport class SchemaParser {\n  private schema: Schema\n  private checker: ts.TypeChecker\n  private sfiFile: ts.SourceFile\n  private typeDefinitionBuilder: TypeDefinitionBuilder\n\n  constructor(checker: ts.TypeChecker, sfiFile: ts.SourceFile) {\n    this.schema = {\n      types: [],\n      inputs: [],\n      unions: [],\n      enums: [],\n      scalars: [\n        'Number',\n        'Any',\n        'Object',\n        'File',\n        'Date',\n        'JSON',\n        'String',\n        'Boolean'\n      ]\n    }\n\n    this.checker = checker\n    this.sfiFile = sfiFile\n\n    this.typeDefinitionBuilder = new TypeDefinitionBuilder(checker, this.schema)\n  }\n\n  public parse(index: Index) {\n    const referenceSchema = this.makeReferenceSchema(index)\n\n    for (const [type, properties] of referenceSchema.types) {\n      let typeName: string | undefined = undefined\n\n      if (index.Query === type) {\n        typeName = 'Query'\n      } else if (index.Mutation === type) {\n        typeName = 'Mutation'\n      }\n\n      this.processSchemaReference(type, properties, typeName, 'types')\n    }\n\n    for (const [type, properties] of referenceSchema.inputs) {\n      this.processSchemaReference(type, properties, undefined, 'inputs')\n    }\n\n    this.extractForbiddenFieldNamesFromSchema()\n\n    this.schema.unions = this.typeDefinitionBuilder\n      .getUnions()\n      .map((union): Union => {\n        return {\n          ...union,\n          description: this.getJsDocHeaderFromType(union.rawType)\n        }\n      })\n\n    this.schema.enums = this.typeDefinitionBuilder\n      .getEnums()\n      .map((enumType): Enum => {\n        return {\n          ...enumType,\n          description: this.getJsDocHeaderFromType(enumType.rawType)\n        }\n      })\n  }\n\n  public toString() {\n    const {typeDefinitionToGraphQLType} = this.typeDefinitionBuilder\n\n    const addDescription = (description: string) => {\n      if (!description) return ''\n\n      return `\"\"\"\\n${description}\\n\"\"\"\\n`\n    }\n\n    // build a valid GraphQL schema string from the schema object\n    let schemaString = ''\n\n    // loop over the input objects in the schema\n    for (const input of this.schema.inputs) {\n      // add the input object to the schema string\n\n      schemaString += addDescription(input.description)\n      schemaString += `input ${input.name} {\\n`\n\n      // add a nop field to the input object if it has no fields\n      if (input.fields.length === 0) {\n        schemaString += `\\t_ : String\\n`\n      }\n\n      // loop over the fields in the input object\n      for (const field of input.fields) {\n        // add the field to the input object in the schema string\n        schemaString += `${addDescription(field.type.description)}`\n        schemaString += `\\t${field.name}: ${typeDefinitionToGraphQLType(\n          field.type\n        )}\\n`\n      }\n\n      schemaString += `}\\n`\n    }\n\n    // loop over the type objects in the schema\n    for (const type of this.schema.types) {\n      if (type.fields.length === 0) continue\n\n      // add the type object to the schema string\n      schemaString += addDescription(type.description)\n      schemaString += `type ${type.name} {\\n`\n\n      // loop over the fields in the type object\n      for (const field of type.fields) {\n        // build the argument list for the field if there is at least one argument\n        let args = ''\n\n        if (field.args.length > 0) {\n          args = `(${field.args\n            .map(\n              arg =>\n                `${addDescription(type.description)}${\n                  arg.name\n                }: ${typeDefinitionToGraphQLType(arg.type)}`\n            )\n            .join(', ')})`\n        }\n\n        // add the field to the type object in the schema string\n        schemaString += `${addDescription(field.type.description)}`\n        schemaString += `${field.name}${args}: ${typeDefinitionToGraphQLType(\n          field.type\n        )}\\n`\n      }\n\n      schemaString += `}\\n`\n    }\n\n    // loop over the union objects in the schema\n    for (const union of this.schema.unions) {\n      // add the union object to the schema string\n      schemaString += addDescription(union.description)\n      schemaString += `union ${union.name} = ${union.types.join(' | ')}\\n`\n    }\n\n    // loop over the scalar objects in the schema\n    for (const scalar of this.schema.scalars) {\n      // add the scalar object to the schema string\n      schemaString += `scalar ${scalar}\\n`\n    }\n\n    // loop over the enum objects in the schema\n    for (const enumType of this.schema.enums) {\n      // add the enum object to the schema string\n      schemaString += addDescription(enumType.description)\n      schemaString += `enum ${enumType.name} {\\n`\n\n      // loop over the values in the enum object\n      for (const value of enumType.values) {\n        // add the value to the enum object in the schema string\n        schemaString += `\\t${value}\\n`\n      }\n\n      schemaString += `}\\n`\n    }\n\n    // return the schema string\n    return schemaString\n  }\n\n  public getSchema() {\n    return this.schema\n  }\n\n  private processSchemaReference(\n    type: ts.Type,\n    properties: {[key: string]: ReferenceSchemaType},\n    typeName?: string,\n    processing: 'inputs' | 'types' = 'types'\n  ) {\n    const {getTypeDefinition} = this.typeDefinitionBuilder\n\n    const isInputType = processing === 'inputs'\n\n    const def = getTypeDefinition(type, {isInputType})\n\n    const name = typeName || def.name\n\n    let root = this.schema[processing].find(t => t.name === name)\n\n    if (!root) {\n      if (this.schema.scalars.includes(name)) {\n        return\n      } else {\n        this.schema[processing].push({\n          name,\n          description: this.getJsDocHeaderFromType(type),\n          fields: []\n        })\n\n        root = this.schema[processing][this.schema[processing].length - 1]!\n      }\n    }\n\n    for (const [propertyName, property] of Object.entries(properties)) {\n      const fieldType = property.returnType\n\n      const fieldDef = getTypeDefinition(fieldType, {\n        isInputType,\n        propertyName\n      })\n\n      if (processing === 'types') {\n        const field: Type['fields'][number] = {\n          name: propertyName,\n          type: {\n            ...fieldDef,\n            description: this.getJsDocHeaderFromType(fieldType)\n          },\n          args: []\n        }\n\n        if (property.args) {\n          for (const [argName, arg] of Object.entries(property.args)) {\n            const argType = arg\n\n            const fieldDef = getTypeDefinition(argType, {\n              isInputType: true,\n              propertyName: argName\n            })\n\n            if (\n              this.schema.scalars.includes(this.checker.typeToString(argType))\n            ) {\n              fieldDef.name = this.checker.typeToString(argType)\n            }\n\n            field.args.push({\n              name: argName,\n              type: {\n                ...fieldDef,\n                description: this.getJsDocHeaderFromType(argType)\n              }\n            })\n          }\n        }\n\n        root.fields.push(field)\n      } else if (processing === 'inputs') {\n        const field: Input['fields'][number] = {\n          name: propertyName,\n          type: {\n            ...fieldDef,\n            description: this.getJsDocHeaderFromType(fieldType)\n          }\n        }\n\n        if (!root.fields.find(f => f.name === field.name)) {\n          root.fields.push(field)\n        }\n      }\n    }\n  }\n\n  private getJsDocHeaderFromType = (type: ts.Type) => {\n    let header = ''\n\n    if (type.symbol) {\n      const typeDeclaration = type.symbol.declarations?.[0] as unknown as\n        | {\n            jsDoc: ts.JSDoc[]\n          }\n        | undefined\n\n      const comments = typeDeclaration?.jsDoc?.map(doc => doc.comment).join(' ')\n\n      if (comments) {\n        header = comments\n      }\n\n      const tags = type.symbol.getJsDocTags()\n      const tagComments = tags\n        ?.map(tag => `@${tag.name} ${tag.text?.map(t => t.text).join(' ')}`)\n        .join('\\n')\n\n      if (tagComments) {\n        header = `${header} ${tagComments}`\n      }\n    }\n\n    return header\n  }\n\n  /**\n   * Extracts reserved field names from the schema by removing them from their respective types and inputs.\n   */\n  private extractForbiddenFieldNamesFromSchema(): void {\n    // Define a regular expression to check if a field name is a valid GraphQL field name.\n    const validFieldNameRegExp = /^[_A-Za-z][_0-9A-Za-z]*$/\n\n    // Define a helper function to check if a field name is reserved.\n    const isReserved = (name: string): boolean => {\n      if (!validFieldNameRegExp.test(name)) {\n        // console.warn(\n        //   `\\x1b[33mWarning: forbidden field name \"${name}\" detected\\x1b[0m`\n        // )\n        return true\n      }\n      // Fields starting with \"__\" are considered reserved.\n      return name.startsWith('__')\n    }\n\n    // Loop over each type in the schema and remove any reserved fields.\n    for (const type of this.schema.types) {\n      type.fields = type.fields.filter(field => {\n        if (isReserved(field.name)) {\n          // console.warn(\n          //   `\\x1b[33mWarning: forbidden field \"${field.name}\" detected in type \"${type.name}\". This field will be excluded from the schema.\\x1b[0m`\n          // )\n          return false\n        }\n        return true\n      })\n    }\n\n    // Loop over each input in the schema and remove any reserved fields.\n    for (const input of this.schema.inputs) {\n      input.fields = input.fields.filter(field => {\n        if (isReserved(field.name)) {\n          // console.warn(\n          //   `\\x1b[33mWarning: reserved field \"${field.name}\" detected in input \"${input.name}\". This field will be excluded from the schema.\\x1b[0m`\n          // )\n          return false\n        }\n        return true\n      })\n    }\n  }\n\n  private makeReferenceSchema(index: Index): ReferenceSchema {\n    const referenceSchema: ReferenceSchema = {\n      types: new Map(),\n      inputs: new Map()\n    }\n\n    const recLoop = (\n      type: ts.Type,\n      info: {\n        propetyName?: string\n        parentType?: ts.Type\n      } = {},\n      processing: 'inputs' | 'types' = 'types',\n      path: Array<string> = []\n    ) => {\n      if (referenceSchema[processing].has(type)) {\n        return\n      }\n\n      // check if argType is a real type to ignore '[]'\n      const wrongType = this.checker.typeToString(type) === '[]'\n\n      if (wrongType) {\n        return\n      }\n\n      // skip if scalar\n      if (this.schema.scalars.includes(this.checker.typeToString(type))) {\n        return\n      }\n\n      if (isPrimitive(type)) {\n        return\n      }\n\n      if (isPromise(type)) {\n        // skip if input\n        if (processing === 'inputs') {\n          return\n        }\n\n        const promiseType = getPromiseType(type)\n\n        if (promiseType) {\n          recLoop(promiseType, info, processing, [...path, 'PROMISE'])\n        }\n\n        return\n      }\n\n      if (type.isUnion()) {\n        if (processing === 'types') {\n          type.types.forEach(t => {\n            // if null or undefined, skip\n            if (\n              t.flags & ts.TypeFlags.Null ||\n              t.flags & ts.TypeFlags.Undefined ||\n              isPrimitive(t)\n            ) {\n              return\n            }\n\n            recLoop(t, info, processing, [\n              ...path,\n              t.symbol?.getName() || `N/A ${this.checker.typeToString(t)}`\n            ])\n          })\n        } else {\n          let properties = getPublicPropertiesOfType(\n            this.checker,\n            type.getNonNullableType()\n          )\n\n          if (properties.length === 0) {\n            //get first union type of non nullable type\n            const nt = type.getNonNullableType()\n            if (nt.isUnion()) {\n              properties = getPublicPropertiesOfType(this.checker, nt.types[0]!)\n            }\n          }\n\n          if (properties.length > 0) {\n            if (!referenceSchema[processing].has(type)) {\n              referenceSchema[processing].set(type, {})\n            }\n\n            // Go through all properties of the union type and add them to the reference schema\n            properties.forEach(property => {\n              const propertyType = this.checker.getTypeOfSymbolAtLocation(\n                property,\n                this.sfiFile\n              )\n\n              if (!isFunction(propertyType)) {\n                referenceSchema[processing].get(type)![\n                  property.escapedName as string\n                ] = {\n                  returnType: propertyType,\n                  args: {}\n                }\n\n                recLoop(\n                  propertyType,\n                  {\n                    propetyName: property.escapedName as string,\n                    parentType: type\n                  },\n                  processing,\n                  [...path, property.escapedName as string]\n                )\n              }\n            })\n          }\n        }\n      } else if (isFunction(type)) {\n        // skip fn for inputs\n        if (processing === 'inputs') {\n          return\n        }\n\n        if (!info.parentType) {\n          throw new Error('Cannot have a function without a parent type')\n        }\n\n        const signature = type.getCallSignatures()[0]\n        const args = signature?.getParameters() || []\n        const returnType = signature?.getReturnType()\n\n        const schemaType = referenceSchema[processing].get(info.parentType)![\n          info.propetyName!\n        ]!\n\n        args.forEach(arg => {\n          if (\n            arg.valueDeclaration &&\n            ts.isParameter(arg.valueDeclaration) &&\n            arg.valueDeclaration.dotDotDotToken\n          ) {\n            console.warn(\n              'Cannot handle rest parameters yet, skipping',\n              arg.escapedName\n            )\n          } else {\n            const argType = this.checker.getTypeOfSymbolAtLocation(\n              arg,\n              this.sfiFile\n            )\n\n            // set args to empty object if not set\n            if (schemaType.args) {\n              schemaType.args[arg.escapedName as string] = argType\n\n              recLoop(\n                argType,\n                {\n                  parentType: type\n                },\n                'inputs',\n                [...path, arg.escapedName as string]\n              )\n            }\n          }\n        })\n\n        if (returnType) {\n          recLoop(returnType, info, processing, [...path, 'RETURN_TYPE'])\n        }\n      } else if (isList(this.checker, type)) {\n        const itemType = this.checker.getIndexTypeOfType(\n          type,\n          ts.IndexKind.Number\n        )\n\n        if (itemType && !isPrimitive(itemType)) {\n          if (!referenceSchema[processing].has(type)) {\n            referenceSchema[processing].set(type, {})\n          }\n\n          recLoop(itemType, info, processing, [...path, 'ITEM_TYPE'])\n        }\n      } else if (!isPrimitive(type)) {\n        const properties = getPublicPropertiesOfType(this.checker, type)\n\n        if (!referenceSchema[processing].has(type)) {\n          referenceSchema[processing].set(type, {})\n        }\n\n        properties.forEach(property => {\n          const propertyType = this.checker.getTypeOfSymbolAtLocation(\n            property,\n            this.sfiFile\n          )\n\n          if (\n            !referenceSchema[processing].get(type)![\n              property.escapedName as string\n            ]\n          ) {\n            referenceSchema[processing].get(type)![\n              property.escapedName as string\n            ] = {\n              returnType: propertyType,\n              args: {}\n            }\n          }\n\n          recLoop(\n            propertyType,\n            {\n              propetyName: property.escapedName as string,\n              parentType: type\n            },\n            processing,\n            [...path, property.escapedName as string]\n          )\n        })\n      }\n    }\n\n    if (index.Query) {\n      recLoop(index.Query)\n    }\n\n    if (index.Mutation) {\n      recLoop(index.Mutation)\n    }\n\n    return referenceSchema\n  }\n}\n",
+  "import ts from 'typescript'\n\nexport const isEmptyObject = (type: ts.Type) => {\n  return (\n    type.flags & ts.TypeFlags.Object &&\n    type.getProperties().length === 0 &&\n    type.getCallSignatures().length === 0\n  )\n}\n\nexport const isList = (checker: ts.TypeChecker, type: ts.Type) => {\n  const typeNode = checker.typeToTypeNode(type, undefined, undefined)\n\n  const is = !!(\n    typeNode &&\n    (typeNode.kind === ts.SyntaxKind.ArrayType ||\n      typeNode.kind === ts.SyntaxKind.TupleType)\n  )\n\n  return is\n}\n\nexport const isBoolean = (type: ts.Type) => {\n  // check if is union and all types are boolean\n  if (type.isUnion()) {\n    const isAllBooleans = type.types.every(\n      t => t.flags & ts.TypeFlags.BooleanLiteral\n    )\n\n    return isAllBooleans\n  }\n\n  return false\n}\n\nexport const isPrimitive = (type: ts.Type) => {\n  const primitive =\n    type.flags & ts.TypeFlags.String ||\n    type.flags & ts.TypeFlags.Number ||\n    type.flags & ts.TypeFlags.Boolean ||\n    type.flags & ts.TypeFlags.StringLiteral ||\n    type.flags & ts.TypeFlags.NumberLiteral ||\n    type.flags & ts.TypeFlags.BooleanLiteral\n\n  return primitive\n}\n\nexport const isFunction = (type: ts.Type) => {\n  return type.getCallSignatures().length > 0\n}\n\nexport const isEnum = (type: ts.Type) => {\n  if (isPrimitive(type)) return false\n\n  const isUnion = (type as ts.UnionType).types?.length > 1\n\n  if (isUnion) {\n    // check if all types are primitives\n    const isAllPrimitives = (type as ts.UnionType).types.every(\n      t =>\n        t.flags & ts.TypeFlags.StringLiteral ||\n        t.flags & ts.TypeFlags.NumberLiteral ||\n        t.flags & ts.TypeFlags.BooleanLiteral\n    )\n\n    if (isAllPrimitives) {\n      return true\n    }\n  }\n\n  return false\n}\n\nexport const isPromise = (type: ts.Type) => {\n  // check if type is a promise\n  return type.getSymbol()?.getName() === 'Promise'\n}\n\nexport const getPromiseType = (type: ts.Type) => {\n  let objectType = type as ts.ObjectType\n\n  if (objectType.objectFlags & ts.ObjectFlags.Reference) {\n    const reference = type as ts.TypeReference\n    const typeArguments = reference.typeArguments\n    if (typeArguments && typeArguments.length > 0) {\n      return typeArguments[0]\n    }\n  }\n}\n\nexport const excludeNullUndefinedFromType = (type: ts.Type) => {\n  if (!type.isUnion())\n    return {\n      type,\n      wasOptional: false\n    }\n\n  const types = type.types.filter(\n    t => !(t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Null)\n  )\n\n  const wasOptional = types.length !== type.types.length\n\n  return {\n    type: type.getNonNullableType(),\n    wasOptional\n  }\n}\n\nexport function getPublicPropertiesOfType(\n  checker: ts.TypeChecker,\n  _type: ts.Type\n): ts.Symbol[] {\n  let type = _type\n\n  if (type.isUnion()) {\n    // Filter out array types from the union if their non-array counterparts are also present\n    const nonArrayTypes = type.types.filter(\n      t =>\n        !(\n          t.flags & ts.TypeFlags.Object &&\n          (t as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference &&\n          (t as ts.TypeReference).typeArguments?.length\n        )\n    )\n    const arrayElementTypes = type.types\n      .filter(\n        t =>\n          t.flags & ts.TypeFlags.Object &&\n          (t as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference &&\n          (t as ts.TypeReference).typeArguments?.length\n      )\n      .map(t => (t as ts.TypeReference).typeArguments![0])\n    const filteredTypes = nonArrayTypes.filter(\n      t => !arrayElementTypes.some(et => et === t)\n    )\n    // .filter(t => {\n    //   // filter out primitive types\n    //   return !isPrimitive(t)\n    // })\n\n    // Create a new type that is the union of all the types in the union\n    // This is necessary because the type checker will not resolve properties\n    // that are only present on some types in the union\n    // getUnionType is not available in TS 3.7, so we have to use the private API\n    type = (checker as any).getUnionType(filteredTypes) as ts.Type\n  }\n\n  const properties: ts.Symbol[] = []\n\n  // if type is a primitive, return empty array\n  if (isList(checker, type) || isPrimitive(type) || isEnum(type))\n    return properties\n\n  let typeProperties: ts.Symbol[] = []\n\n  typeProperties =\n    (type as any).resolvedProperties || type.getProperties() || []\n\n  for (const prop of typeProperties) {\n    const isPublic =\n      prop.valueDeclaration &&\n      !(\n        ts.getCombinedModifierFlags(prop.valueDeclaration) &\n        ts.ModifierFlags.Private\n      ) &&\n      !prop.getName().startsWith('#')\n\n    if (isPublic === false) {\n      continue\n    }\n\n    properties.push(prop)\n  }\n\n  return properties\n}\n\nexport const safeTypeName = (name: string) => {\n  return name.replace(/[^0-9a-zA-Z_]/g, '_')\n}\n",
+  "import ts from 'typescript'\n\nexport const isEmptyObject = (type: ts.Type) => {\n  return (\n    type.flags & ts.TypeFlags.Object &&\n    type.getProperties().length === 0 &&\n    type.getCallSignatures().length === 0\n  )\n}\n\nexport const isList = (checker: ts.TypeChecker, type: ts.Type) => {\n  const typeNode = checker.typeToTypeNode(type, undefined, undefined)\n\n  const is = !!(\n    typeNode &&\n    (typeNode.kind === ts.SyntaxKind.ArrayType ||\n      typeNode.kind === ts.SyntaxKind.TupleType)\n  )\n\n  return is\n}\n\nexport const isBoolean = (type: ts.Type) => {\n  // check if is union and all types are boolean\n  if (type.isUnion()) {\n    const isAllBooleans = type.types.every(\n      t => t.flags & ts.TypeFlags.BooleanLiteral\n    )\n\n    return isAllBooleans\n  }\n\n  return false\n}\n\nexport const isPrimitive = (type: ts.Type) => {\n  const primitive =\n    type.flags & ts.TypeFlags.String ||\n    type.flags & ts.TypeFlags.Number ||\n    type.flags & ts.TypeFlags.Boolean ||\n    type.flags & ts.TypeFlags.StringLiteral ||\n    type.flags & ts.TypeFlags.NumberLiteral ||\n    type.flags & ts.TypeFlags.BooleanLiteral\n\n  return primitive\n}\n\nexport const isFunction = (type: ts.Type) => {\n  return type.getCallSignatures().length > 0\n}\n\nexport const isEnum = (type: ts.Type) => {\n  if (isPrimitive(type)) return false\n\n  const isUnion = (type as ts.UnionType).types?.length > 1\n\n  if (isUnion) {\n    // check if all types are primitives\n    const isAllPrimitives = (type as ts.UnionType).types.every(\n      t =>\n        t.flags & ts.TypeFlags.StringLiteral ||\n        t.flags & ts.TypeFlags.NumberLiteral ||\n        t.flags & ts.TypeFlags.BooleanLiteral\n    )\n\n    if (isAllPrimitives) {\n      return true\n    }\n  }\n\n  return false\n}\n\nexport const isPromise = (type: ts.Type) => {\n  // check if type is a promise\n  return type.getSymbol()?.getName() === 'Promise'\n}\n\nexport const getPromiseType = (type: ts.Type) => {\n  let objectType = type as ts.ObjectType\n\n  if (objectType.objectFlags & ts.ObjectFlags.Reference) {\n    const reference = type as ts.TypeReference\n    const typeArguments = reference.typeArguments\n    if (typeArguments && typeArguments.length > 0) {\n      return typeArguments[0]\n    }\n  }\n}\n\nexport const excludeNullUndefinedFromType = (type: ts.Type) => {\n  if (!type.isUnion())\n    return {\n      type,\n      wasOptional: false\n    }\n\n  const types = type.types.filter(\n    t => !(t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Null)\n  )\n\n  const wasOptional = types.length !== type.types.length\n\n  return {\n    type: type.getNonNullableType(),\n    wasOptional\n  }\n}\n\nexport function getPublicPropertiesOfType(\n  checker: ts.TypeChecker,\n  _type: ts.Type\n): ts.Symbol[] {\n  let type = _type\n\n  if (type.isUnion()) {\n    // Filter out array types from the union if their non-array counterparts are also present\n    const nonArrayTypes = type.types.filter(\n      t =>\n        !(\n          t.flags & ts.TypeFlags.Object &&\n          (t as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference &&\n          (t as ts.TypeReference).typeArguments?.length\n        )\n    )\n    const arrayElementTypes = type.types\n      .filter(\n        t =>\n          t.flags & ts.TypeFlags.Object &&\n          (t as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference &&\n          (t as ts.TypeReference).typeArguments?.length\n      )\n      .map(t => (t as ts.TypeReference).typeArguments![0])\n    const filteredTypes = nonArrayTypes.filter(\n      t => !arrayElementTypes.some(et => et === t)\n    )\n    // .filter(t => {\n    //   // filter out primitive types\n    //   return !isPrimitive(t)\n    // })\n\n    // Create a new type that is the union of all the types in the union\n    // This is necessary because the type checker will not resolve properties\n    // that are only present on some types in the union\n    // getUnionType is not available in TS 3.7, so we have to use the private API\n    type = (checker as any).getUnionType(filteredTypes) as ts.Type\n  }\n\n  const properties: ts.Symbol[] = []\n\n  // if type is a primitive, return empty array\n  if (isList(checker, type) || isPrimitive(type) || isEnum(type))\n    return properties\n\n  let typeProperties: ts.Symbol[] = []\n\n  typeProperties =\n    (type as any).resolvedProperties || type.getProperties() || []\n\n  for (const prop of typeProperties) {\n    const isPublic =\n      prop.valueDeclaration &&\n      !(\n        ts.getCombinedModifierFlags(prop.valueDeclaration) &\n        ts.ModifierFlags.Private\n      ) &&\n      !prop.getName().startsWith('#')\n\n    if (isPublic === false) {\n      continue\n    }\n\n    properties.push(prop)\n  }\n\n  return properties\n}\n\nexport const safeTypeName = (name: string) => {\n  return name.replace(/[^0-9a-zA-Z_]/g, '_')\n}\n",
+  "import ts from 'typescript'\nimport {\n  excludeNullUndefinedFromType,\n  getPromiseType,\n  isEmptyObject,\n  isEnum,\n  isFunction,\n  isList,\n  isPrimitive,\n  isPromise,\n  safeTypeName\n} from './types-helper.js'\nimport {Schema} from './schema-parser.js'\n\nexport interface Union {\n  name: string\n  rawType: ts.Type\n  types: Array<string>\n}\n\nexport interface Enum {\n  name: string\n  rawType: ts.Type\n  values: Array<string>\n}\n\ninterface FieldDefinition {\n  name: string\n  isList: boolean\n  isRequired: boolean\n  isListRequired?: boolean\n}\n\nexport class TypeDefinitionBuilder {\n  private checker: ts.TypeChecker\n  private schema: Schema\n\n  private typesNameMap: Map<ts.Type, string> = new Map()\n  private inputsNameMap: Map<ts.Type, string> = new Map()\n\n  private unions: Array<Union> = []\n  private enums: Array<Enum> = []\n\n  constructor(checker: ts.TypeChecker, schema: Schema) {\n    this.checker = checker\n    this.schema = schema\n  }\n\n  getTypeDefinition = (\n    rawType: ts.Type,\n    options: {\n      isInputType?: boolean\n      isRequired?: boolean\n      propertyName?: string\n    } = {\n      isInputType: false\n    }\n  ): FieldDefinition => {\n    const {type, wasOptional} = excludeNullUndefinedFromType(rawType)\n\n    if (isPromise(type)) {\n      const promiseType = getPromiseType(type)\n      if (promiseType) {\n        return this.getTypeDefinition(promiseType, options)\n      }\n    }\n\n    const isRequired =\n      options.isRequired !== undefined ? options.isRequired : !wasOptional\n\n    if (isEmptyObject(type)) {\n      return {\n        name: 'Object',\n        isList: false,\n        isRequired\n      }\n    }\n\n    let nameMap = options.isInputType ? this.inputsNameMap : this.typesNameMap\n\n    if (nameMap.has(type)) {\n      const typeName = nameMap.get(type) as string\n\n      return {\n        name: typeName,\n        isList: false,\n        isRequired\n      }\n    }\n\n    let typeName: string | undefined =\n      type.aliasSymbol?.escapedName?.toString() ||\n      type.symbol?.escapedName.toString()\n\n    if (typeName === '__type' || typeName === '__object') {\n      if (!options.propertyName) {\n        typeName = undefined\n      } else {\n        const capitalizedPropertyName =\n          options.propertyName.charAt(0).toUpperCase() +\n          options.propertyName.slice(1)\n\n        typeName = capitalizedPropertyName\n      }\n    }\n\n    if (typeName) {\n      typeName = safeTypeName(typeName)\n    }\n\n    const duplicateName = (name: string) => {\n      // find name in typeNameMap\n      return Array.from(nameMap.values()).includes(name)\n    }\n\n    if (typeName) {\n      if (options.isInputType) {\n        typeName = `${typeName}Input`\n      }\n\n      let i = 1\n      let originalTypeName = typeName\n      while (duplicateName(typeName as string)) {\n        typeName = `${originalTypeName}_${i}`\n\n        i++\n      }\n    }\n\n    if (typeName && this.schema.scalars.includes(typeName)) {\n      return {\n        name: typeName,\n        isList: false,\n        isRequired\n      }\n    }\n\n    if (isList(this.checker, type)) {\n      const listType = this.checker.getIndexTypeOfType(\n        type,\n        ts.IndexKind.Number\n      )\n\n      if (listType) {\n        const def = this.getTypeDefinition(listType, options)\n\n        return {\n          name: def.name,\n          isList: true,\n          isRequired: def.isRequired,\n          isListRequired: isRequired\n        }\n      }\n    } else if (isEnum(type)) {\n      const typeNode = this.checker.typeToTypeNode(\n        type,\n        undefined,\n        undefined\n      ) as any | undefined\n\n      const types = (type as ts.UnionType).types.filter(\n        t => t.flags & ts.TypeFlags.StringLiteral\n      )\n\n      // enumerate all members of the enum\n      const members = types.map((t: ts.Type) => {\n        if (t.isLiteral()) {\n          const name = t.value?.toString()\n\n          if (!name) {\n            throw new Error('Enum member name is undefined')\n          }\n\n          return safeTypeName(name)\n        }\n\n        throw new Error('Invalid type for enum member')\n      })\n\n      if (members.length > 0) {\n        typeName = typeName || typeNode.typeName?.symbol?.escapedName\n\n        if (!typeName) {\n          typeName = members.join('_').toUpperCase()\n          typeName = options.isInputType ? `${typeName}Input` : typeName\n        }\n\n        this.enums.push({\n          name: typeName,\n          values: members,\n          rawType: type\n        })\n      }\n    }\n    // handle primitives\n    else if (isPrimitive(type)) {\n      let typeName = this.checker.typeToString(type)\n\n      if (type.flags & ts.TypeFlags.StringLiteral) {\n        typeName = 'String'\n      } else if (type.flags & ts.TypeFlags.NumberLiteral) {\n        typeName = 'Number'\n      } else if (type.flags & ts.TypeFlags.BooleanLiteral) {\n        typeName = 'Boolean'\n      } else if (type.flags & ts.TypeFlags.String) {\n        typeName = 'String'\n      } else if (type.flags & ts.TypeFlags.Number) {\n        typeName = 'Number'\n      } else if (type.flags & ts.TypeFlags.Boolean) {\n        typeName = 'Boolean'\n      }\n\n      return {\n        name: safeTypeName(typeName),\n        isList: false,\n        isRequired\n      }\n    } else if (type.isIntersection()) {\n      const intersectionTypes = type.types\n\n      const typeNames = intersectionTypes.map(t => {\n        const typeDef = this.getTypeDefinition(t, options)\n\n        return typeDef.name\n      })\n\n      typeName = safeTypeName(typeName || typeNames.join('And'))\n    } else if (type.isUnion()) {\n      const unionTypes = type.types\n      const required = type.types.length === unionTypes.length\n\n      const hasPrimitivesOrEnum = unionTypes.some(t => {\n        // If t is a array take the element type\n        const type = isList(this.checker, t)\n          ? this.checker.getIndexTypeOfType(t, ts.IndexKind.Number)\n          : t\n\n        if (!type) {\n          // Return true if the type is undefined because we don't know what it is\n          // Marking it as a primitive or enum will make it more error prone\n          return true\n        }\n\n        return isPrimitive(type) || isEnum(type)\n      })\n\n      const unionTypeDefs = [\n        ...new Set(\n          unionTypes.map(t =>\n            this.getTypeDefinition(t, {...options, isRequired: required})\n          )\n        )\n      ]\n\n      // If the union contains a array of some type, remove the type from the union because\n      // the array type will be handled by the list type\n\n      const listTypes = unionTypeDefs.filter(t => t.isList)\n\n      // Check if the union contains the same type as a list\n      for (const listType of listTypes) {\n        const index = unionTypeDefs.findIndex(\n          t => t.name === listType.name && !t.isList\n        )\n\n        if (index > -1) {\n          unionTypeDefs.splice(index, 1)\n        }\n      }\n\n      const typeNames = unionTypeDefs.map(t => t.name)\n\n      typeName = safeTypeName(typeName || typeNames.join('Or'))\n\n      if (\n        unionTypeDefs.length > 1 &&\n        !options.isInputType &&\n        !hasPrimitivesOrEnum\n      ) {\n        this.unions.push({\n          name: typeName,\n          types: typeNames,\n          rawType: type\n        })\n      } else {\n        // We only care about the first type in the union since GraphQL doesn't support unions of input types\n        const typeDef = unionTypeDefs[0]\n\n        if (!typeDef) {\n          throw new Error('Cannot get type definition')\n        }\n\n        // If the types contain a list of the same type as the first type, then we can make the first type a list\n        const isList = unionTypeDefs.some(t => {\n          return t.isList && t.name === typeDef.name\n        })\n\n        return {\n          name: typeDef.name,\n          isList,\n          isRequired\n        }\n      }\n    }\n    // handle functions\n    else if (isFunction(type)) {\n      const signature = type.getCallSignatures()[0]\n      let returnType = signature?.getReturnType()\n\n      if (returnType) {\n        if (isPromise(returnType)) {\n          const pt = getPromiseType(returnType)\n\n          if (pt) {\n            returnType = pt\n          }\n        }\n      }\n\n      if (returnType) {\n        const def = this.getTypeDefinition(returnType, options)\n\n        return def\n      }\n    }\n\n    if (!typeName) {\n      typeName = 'Any'\n    }\n\n    nameMap.set(type, typeName)\n\n    return {\n      name: typeName,\n      isList: false,\n      isRequired\n    }\n  }\n\n  public getUnions(): Array<Union> {\n    return this.unions\n  }\n\n  public getEnums(): Array<Enum> {\n    return this.enums\n  }\n\n  public typeDefinitionToGraphQLType = (\n    typeDefinition: FieldDefinition\n  ): string => {\n    let type = typeDefinition.name\n    const {isList, isRequired, isListRequired} = typeDefinition\n\n    if (isRequired) {\n      type = `${type}!`\n    }\n\n    if (isList) {\n      type = `[${type}]`\n\n      if (isListRequired) {\n        type = `${type}!`\n      }\n    }\n\n    return type\n  }\n}\n",
+  "import ts from 'typescript'\nimport {\n  excludeNullUndefinedFromType,\n  getPromiseType,\n  isEmptyObject,\n  isEnum,\n  isFunction,\n  isList,\n  isPrimitive,\n  isPromise,\n  safeTypeName\n} from './types-helper.js'\nimport {Schema} from './schema-parser.js'\n\nexport interface Union {\n  name: string\n  rawType: ts.Type\n  types: Array<string>\n}\n\nexport interface Enum {\n  name: string\n  rawType: ts.Type\n  values: Array<string>\n}\n\ninterface FieldDefinition {\n  name: string\n  isList: boolean\n  isRequired: boolean\n  isListRequired?: boolean\n}\n\nexport class TypeDefinitionBuilder {\n  private checker: ts.TypeChecker\n  private schema: Schema\n\n  private typesNameMap: Map<ts.Type, string> = new Map()\n  private inputsNameMap: Map<ts.Type, string> = new Map()\n\n  private unions: Array<Union> = []\n  private enums: Array<Enum> = []\n\n  constructor(checker: ts.TypeChecker, schema: Schema) {\n    this.checker = checker\n    this.schema = schema\n  }\n\n  getTypeDefinition = (\n    rawType: ts.Type,\n    options: {\n      isInputType?: boolean\n      isRequired?: boolean\n      propertyName?: string\n    } = {\n      isInputType: false\n    }\n  ): FieldDefinition => {\n    const {type, wasOptional} = excludeNullUndefinedFromType(rawType)\n\n    if (isPromise(type)) {\n      const promiseType = getPromiseType(type)\n      if (promiseType) {\n        return this.getTypeDefinition(promiseType, options)\n      }\n    }\n\n    const isRequired =\n      options.isRequired !== undefined ? options.isRequired : !wasOptional\n\n    if (isEmptyObject(type)) {\n      return {\n        name: 'Object',\n        isList: false,\n        isRequired\n      }\n    }\n\n    let nameMap = options.isInputType ? this.inputsNameMap : this.typesNameMap\n\n    if (nameMap.has(type)) {\n      const typeName = nameMap.get(type) as string\n\n      return {\n        name: typeName,\n        isList: false,\n        isRequired\n      }\n    }\n\n    let typeName: string | undefined =\n      type.aliasSymbol?.escapedName?.toString() ||\n      type.symbol?.escapedName.toString()\n\n    if (typeName === '__type' || typeName === '__object') {\n      if (!options.propertyName) {\n        typeName = undefined\n      } else {\n        const capitalizedPropertyName =\n          options.propertyName.charAt(0).toUpperCase() +\n          options.propertyName.slice(1)\n\n        typeName = capitalizedPropertyName\n      }\n    }\n\n    if (typeName) {\n      typeName = safeTypeName(typeName)\n    }\n\n    const duplicateName = (name: string) => {\n      // find name in typeNameMap\n      return Array.from(nameMap.values()).includes(name)\n    }\n\n    if (typeName) {\n      if (options.isInputType) {\n        typeName = `${typeName}Input`\n      }\n\n      let i = 1\n      let originalTypeName = typeName\n      while (duplicateName(typeName as string)) {\n        typeName = `${originalTypeName}_${i}`\n\n        i++\n      }\n    }\n\n    if (typeName && this.schema.scalars.includes(typeName)) {\n      return {\n        name: typeName,\n        isList: false,\n        isRequired\n      }\n    }\n\n    if (isList(this.checker, type)) {\n      const listType = this.checker.getIndexTypeOfType(\n        type,\n        ts.IndexKind.Number\n      )\n\n      if (listType) {\n        const def = this.getTypeDefinition(listType, options)\n\n        return {\n          name: def.name,\n          isList: true,\n          isRequired: def.isRequired,\n          isListRequired: isRequired\n        }\n      }\n    } else if (isEnum(type)) {\n      const typeNode = this.checker.typeToTypeNode(\n        type,\n        undefined,\n        undefined\n      ) as any | undefined\n\n      const types = (type as ts.UnionType).types.filter(\n        t => t.flags & ts.TypeFlags.StringLiteral\n      )\n\n      // enumerate all members of the enum\n      const members = types.map((t: ts.Type) => {\n        if (t.isLiteral()) {\n          const name = t.value?.toString()\n\n          if (!name) {\n            throw new Error('Enum member name is undefined')\n          }\n\n          return safeTypeName(name)\n        }\n\n        throw new Error('Invalid type for enum member')\n      })\n\n      if (members.length > 0) {\n        typeName = typeName || typeNode.typeName?.symbol?.escapedName\n\n        if (!typeName) {\n          typeName = members.join('_').toUpperCase()\n          typeName = options.isInputType ? `${typeName}Input` : typeName\n        }\n\n        this.enums.push({\n          name: typeName,\n          values: members,\n          rawType: type\n        })\n      }\n    }\n    // handle primitives\n    else if (isPrimitive(type)) {\n      let typeName = this.checker.typeToString(type)\n\n      if (type.flags & ts.TypeFlags.StringLiteral) {\n        typeName = 'String'\n      } else if (type.flags & ts.TypeFlags.NumberLiteral) {\n        typeName = 'Number'\n      } else if (type.flags & ts.TypeFlags.BooleanLiteral) {\n        typeName = 'Boolean'\n      } else if (type.flags & ts.TypeFlags.String) {\n        typeName = 'String'\n      } else if (type.flags & ts.TypeFlags.Number) {\n        typeName = 'Number'\n      } else if (type.flags & ts.TypeFlags.Boolean) {\n        typeName = 'Boolean'\n      }\n\n      return {\n        name: safeTypeName(typeName),\n        isList: false,\n        isRequired\n      }\n    } else if (type.isIntersection()) {\n      const intersectionTypes = type.types\n\n      const typeNames = intersectionTypes.map(t => {\n        const typeDef = this.getTypeDefinition(t, options)\n\n        return typeDef.name\n      })\n\n      typeName = safeTypeName(typeName || typeNames.join('And'))\n    } else if (type.isUnion()) {\n      const unionTypes = type.types\n      const required = type.types.length === unionTypes.length\n\n      const hasPrimitivesOrEnum = unionTypes.some(t => {\n        // If t is a array take the element type\n        const type = isList(this.checker, t)\n          ? this.checker.getIndexTypeOfType(t, ts.IndexKind.Number)\n          : t\n\n        if (!type) {\n          // Return true if the type is undefined because we don't know what it is\n          // Marking it as a primitive or enum will make it more error prone\n          return true\n        }\n\n        return isPrimitive(type) || isEnum(type)\n      })\n\n      const unionTypeDefs = [\n        ...new Set(\n          unionTypes.map(t =>\n            this.getTypeDefinition(t, {...options, isRequired: required})\n          )\n        )\n      ]\n\n      // If the union contains a array of some type, remove the type from the union because\n      // the array type will be handled by the list type\n\n      const listTypes = unionTypeDefs.filter(t => t.isList)\n\n      // Check if the union contains the same type as a list\n      for (const listType of listTypes) {\n        const index = unionTypeDefs.findIndex(\n          t => t.name === listType.name && !t.isList\n        )\n\n        if (index > -1) {\n          unionTypeDefs.splice(index, 1)\n        }\n      }\n\n      const typeNames = unionTypeDefs.map(t => t.name)\n\n      typeName = safeTypeName(typeName || typeNames.join('Or'))\n\n      if (\n        unionTypeDefs.length > 1 &&\n        !options.isInputType &&\n        !hasPrimitivesOrEnum\n      ) {\n        this.unions.push({\n          name: typeName,\n          types: typeNames,\n          rawType: type\n        })\n      } else {\n        // We only care about the first type in the union since GraphQL doesn't support unions of input types\n        const typeDef = unionTypeDefs[0]\n\n        if (!typeDef) {\n          throw new Error('Cannot get type definition')\n        }\n\n        // If the types contain a list of the same type as the first type, then we can make the first type a list\n        const isList = unionTypeDefs.some(t => {\n          return t.isList && t.name === typeDef.name\n        })\n\n        return {\n          name: typeDef.name,\n          isList,\n          isRequired\n        }\n      }\n    }\n    // handle functions\n    else if (isFunction(type)) {\n      const signature = type.getCallSignatures()[0]\n      let returnType = signature?.getReturnType()\n\n      if (returnType) {\n        if (isPromise(returnType)) {\n          const pt = getPromiseType(returnType)\n\n          if (pt) {\n            returnType = pt\n          }\n        }\n      }\n\n      if (returnType) {\n        const def = this.getTypeDefinition(returnType, options)\n\n        return def\n      }\n    }\n\n    if (!typeName) {\n      typeName = 'Any'\n    }\n\n    nameMap.set(type, typeName)\n\n    return {\n      name: typeName,\n      isList: false,\n      isRequired\n    }\n  }\n\n  public getUnions(): Array<Union> {\n    return this.unions\n  }\n\n  public getEnums(): Array<Enum> {\n    return this.enums\n  }\n\n  public typeDefinitionToGraphQLType = (\n    typeDefinition: FieldDefinition\n  ): string => {\n    let type = typeDefinition.name\n    const {isList, isRequired, isListRequired} = typeDefinition\n\n    if (isRequired) {\n      type = `${type}!`\n    }\n\n    if (isList) {\n      type = `[${type}]`\n\n      if (isListRequired) {\n        type = `${type}!`\n      }\n    }\n\n    return type\n  }\n}\n",
+  "import ts from 'typescript'\nimport {\n  getPromiseType,\n  getPublicPropertiesOfType,\n  isFunction,\n  isList,\n  isPrimitive,\n  isPromise\n} from './types-helper.js'\nimport {\n  TypeDefinitionBuilder,\n  Union as _Union,\n  Enum as _Enum\n} from './type-definition-builder.js'\n\ntype Union = _Union & {\n  description: string\n}\n\ntype Enum = _Enum & {\n  description: string\n}\n\ninterface TypeDefinition {\n  name: string\n  isList: boolean\n  isRequired: boolean\n  description: string\n}\n\ninterface Field {\n  name: string\n  type: TypeDefinition\n}\n\ninterface Input {\n  name: string\n  description: string\n  fields: Array<{\n    name: string\n    type: TypeDefinition\n  }>\n}\n\ninterface Type {\n  name: string\n  description: string\n  fields: Array<\n    Field & {\n      args: Array<{\n        name: string\n        type: TypeDefinition\n      }>\n    }\n  >\n}\n\nexport interface Schema {\n  types: Array<Type>\n  inputs: Array<Input>\n  unions: Array<Union>\n  enums: Array<Enum>\n  scalars: Array<string>\n}\n\ntype ReferenceSchemaType = {\n  returnType: ts.Type\n  args: {\n    // value needs to be inputs type\n    [key: string]: ts.Type\n  }\n}\n\ninterface ReferenceSchema {\n  types: Map<\n    ts.Type,\n    {\n      [key: string]: ReferenceSchemaType\n    }\n  >\n  inputs: ReferenceSchema['types']\n}\n\ninterface Index {\n  Query?: ts.Type\n  Mutation?: ts.Type\n}\n\nexport class SchemaParser {\n  private schema: Schema\n  private checker: ts.TypeChecker\n  private sfiFile: ts.SourceFile\n  private typeDefinitionBuilder: TypeDefinitionBuilder\n\n  constructor(checker: ts.TypeChecker, sfiFile: ts.SourceFile) {\n    this.schema = {\n      types: [],\n      inputs: [],\n      unions: [],\n      enums: [],\n      scalars: [\n        'Number',\n        'Any',\n        'Object',\n        'File',\n        'Date',\n        'JSON',\n        'String',\n        'Boolean'\n      ]\n    }\n\n    this.checker = checker\n    this.sfiFile = sfiFile\n\n    this.typeDefinitionBuilder = new TypeDefinitionBuilder(checker, this.schema)\n  }\n\n  public parse(index: Index) {\n    const referenceSchema = this.makeReferenceSchema(index)\n\n    for (const [type, properties] of referenceSchema.types) {\n      let typeName: string | undefined = undefined\n\n      if (index.Query === type) {\n        typeName = 'Query'\n      } else if (index.Mutation === type) {\n        typeName = 'Mutation'\n      }\n\n      this.processSchemaReference(type, properties, typeName, 'types')\n    }\n\n    for (const [type, properties] of referenceSchema.inputs) {\n      this.processSchemaReference(type, properties, undefined, 'inputs')\n    }\n\n    this.extractForbiddenFieldNamesFromSchema()\n\n    this.schema.unions = this.typeDefinitionBuilder\n      .getUnions()\n      .map((union): Union => {\n        return {\n          ...union,\n          description: this.getJsDocHeaderFromType(union.rawType)\n        }\n      })\n\n    this.schema.enums = this.typeDefinitionBuilder\n      .getEnums()\n      .map((enumType): Enum => {\n        return {\n          ...enumType,\n          description: this.getJsDocHeaderFromType(enumType.rawType)\n        }\n      })\n  }\n\n  public toString() {\n    const {typeDefinitionToGraphQLType} = this.typeDefinitionBuilder\n\n    const addDescription = (description: string) => {\n      if (!description) return ''\n\n      return `\"\"\"\\n${description}\\n\"\"\"\\n`\n    }\n\n    // build a valid GraphQL schema string from the schema object\n    let schemaString = ''\n\n    // loop over the input objects in the schema\n    for (const input of this.schema.inputs) {\n      // add the input object to the schema string\n\n      schemaString += addDescription(input.description)\n      schemaString += `input ${input.name} {\\n`\n\n      // add a nop field to the input object if it has no fields\n      if (input.fields.length === 0) {\n        schemaString += `\\t_ : String\\n`\n      }\n\n      // loop over the fields in the input object\n      for (const field of input.fields) {\n        // add the field to the input object in the schema string\n        schemaString += `${addDescription(field.type.description)}`\n        schemaString += `\\t${field.name}: ${typeDefinitionToGraphQLType(\n          field.type\n        )}\\n`\n      }\n\n      schemaString += `}\\n`\n    }\n\n    // loop over the type objects in the schema\n    for (const type of this.schema.types) {\n      if (type.fields.length === 0) continue\n\n      // add the type object to the schema string\n      schemaString += addDescription(type.description)\n      schemaString += `type ${type.name} {\\n`\n\n      // loop over the fields in the type object\n      for (const field of type.fields) {\n        // build the argument list for the field if there is at least one argument\n        let args = ''\n\n        if (field.args.length > 0) {\n          args = `(${field.args\n            .map(\n              arg =>\n                `${addDescription(type.description)}${\n                  arg.name\n                }: ${typeDefinitionToGraphQLType(arg.type)}`\n            )\n            .join(', ')})`\n        }\n\n        // add the field to the type object in the schema string\n        schemaString += `${addDescription(field.type.description)}`\n        schemaString += `${field.name}${args}: ${typeDefinitionToGraphQLType(\n          field.type\n        )}\\n`\n      }\n\n      schemaString += `}\\n`\n    }\n\n    // loop over the union objects in the schema\n    for (const union of this.schema.unions) {\n      // add the union object to the schema string\n      schemaString += addDescription(union.description)\n      schemaString += `union ${union.name} = ${union.types.join(' | ')}\\n`\n    }\n\n    // loop over the scalar objects in the schema\n    for (const scalar of this.schema.scalars) {\n      // add the scalar object to the schema string\n      schemaString += `scalar ${scalar}\\n`\n    }\n\n    // loop over the enum objects in the schema\n    for (const enumType of this.schema.enums) {\n      // add the enum object to the schema string\n      schemaString += addDescription(enumType.description)\n      schemaString += `enum ${enumType.name} {\\n`\n\n      // loop over the values in the enum object\n      for (const value of enumType.values) {\n        // add the value to the enum object in the schema string\n        schemaString += `\\t${value}\\n`\n      }\n\n      schemaString += `}\\n`\n    }\n\n    // return the schema string\n    return schemaString\n  }\n\n  public getSchema() {\n    return this.schema\n  }\n\n  private processSchemaReference(\n    type: ts.Type,\n    properties: {[key: string]: ReferenceSchemaType},\n    typeName?: string,\n    processing: 'inputs' | 'types' = 'types'\n  ) {\n    const {getTypeDefinition} = this.typeDefinitionBuilder\n\n    const isInputType = processing === 'inputs'\n\n    const def = getTypeDefinition(type, {isInputType})\n\n    const name = typeName || def.name\n\n    let root = this.schema[processing].find(t => t.name === name)\n\n    if (!root) {\n      if (this.schema.scalars.includes(name)) {\n        return\n      } else {\n        this.schema[processing].push({\n          name,\n          description: this.getJsDocHeaderFromType(type),\n          fields: []\n        })\n\n        root = this.schema[processing][this.schema[processing].length - 1]!\n      }\n    }\n\n    for (const [propertyName, property] of Object.entries(properties)) {\n      const fieldType = property.returnType\n\n      const fieldDef = getTypeDefinition(fieldType, {\n        isInputType,\n        propertyName\n      })\n\n      if (processing === 'types') {\n        const field: Type['fields'][number] = {\n          name: propertyName,\n          type: {\n            ...fieldDef,\n            description: this.getJsDocHeaderFromType(fieldType)\n          },\n          args: []\n        }\n\n        if (property.args) {\n          for (const [argName, arg] of Object.entries(property.args)) {\n            const argType = arg\n\n            const fieldDef = getTypeDefinition(argType, {\n              isInputType: true,\n              propertyName: argName\n            })\n\n            if (\n              this.schema.scalars.includes(this.checker.typeToString(argType))\n            ) {\n              fieldDef.name = this.checker.typeToString(argType)\n            }\n\n            field.args.push({\n              name: argName,\n              type: {\n                ...fieldDef,\n                description: this.getJsDocHeaderFromType(argType)\n              }\n            })\n          }\n        }\n\n        root.fields.push(field)\n      } else if (processing === 'inputs') {\n        const field: Input['fields'][number] = {\n          name: propertyName,\n          type: {\n            ...fieldDef,\n            description: this.getJsDocHeaderFromType(fieldType)\n          }\n        }\n\n        if (!root.fields.find(f => f.name === field.name)) {\n          root.fields.push(field)\n        }\n      }\n    }\n  }\n\n  private getJsDocHeaderFromType = (type: ts.Type) => {\n    let header = ''\n\n    if (type.symbol) {\n      const typeDeclaration = type.symbol.declarations?.[0] as unknown as\n        | {\n            jsDoc: ts.JSDoc[]\n          }\n        | undefined\n\n      const comments = typeDeclaration?.jsDoc?.map(doc => doc.comment).join(' ')\n\n      if (comments) {\n        header = comments\n      }\n\n      const tags = type.symbol.getJsDocTags()\n      const tagComments = tags\n        ?.map(tag => `@${tag.name} ${tag.text?.map(t => t.text).join(' ')}`)\n        .join('\\n')\n\n      if (tagComments) {\n        header = `${header} ${tagComments}`\n      }\n    }\n\n    return header\n  }\n\n  /**\n   * Extracts reserved field names from the schema by removing them from their respective types and inputs.\n   */\n  private extractForbiddenFieldNamesFromSchema(): void {\n    // Define a regular expression to check if a field name is a valid GraphQL field name.\n    const validFieldNameRegExp = /^[_A-Za-z][_0-9A-Za-z]*$/\n\n    // Define a helper function to check if a field name is reserved.\n    const isReserved = (name: string): boolean => {\n      if (!validFieldNameRegExp.test(name)) {\n        // console.warn(\n        //   `\\x1b[33mWarning: forbidden field name \"${name}\" detected\\x1b[0m`\n        // )\n        return true\n      }\n      // Fields starting with \"__\" are considered reserved.\n      return name.startsWith('__')\n    }\n\n    // Loop over each type in the schema and remove any reserved fields.\n    for (const type of this.schema.types) {\n      type.fields = type.fields.filter(field => {\n        if (isReserved(field.name)) {\n          // console.warn(\n          //   `\\x1b[33mWarning: forbidden field \"${field.name}\" detected in type \"${type.name}\". This field will be excluded from the schema.\\x1b[0m`\n          // )\n          return false\n        }\n        return true\n      })\n    }\n\n    // Loop over each input in the schema and remove any reserved fields.\n    for (const input of this.schema.inputs) {\n      input.fields = input.fields.filter(field => {\n        if (isReserved(field.name)) {\n          // console.warn(\n          //   `\\x1b[33mWarning: reserved field \"${field.name}\" detected in input \"${input.name}\". This field will be excluded from the schema.\\x1b[0m`\n          // )\n          return false\n        }\n        return true\n      })\n    }\n  }\n\n  private makeReferenceSchema(index: Index): ReferenceSchema {\n    const referenceSchema: ReferenceSchema = {\n      types: new Map(),\n      inputs: new Map()\n    }\n\n    const recLoop = (\n      type: ts.Type,\n      info: {\n        propetyName?: string\n        parentType?: ts.Type\n      } = {},\n      processing: 'inputs' | 'types' = 'types',\n      path: Array<string> = []\n    ) => {\n      if (referenceSchema[processing].has(type)) {\n        return\n      }\n\n      // check if argType is a real type to ignore '[]'\n      const wrongType = this.checker.typeToString(type) === '[]'\n\n      if (wrongType) {\n        return\n      }\n\n      // skip if scalar\n      if (this.schema.scalars.includes(this.checker.typeToString(type))) {\n        return\n      }\n\n      if (isPrimitive(type)) {\n        return\n      }\n\n      if (isPromise(type)) {\n        // skip if input\n        if (processing === 'inputs') {\n          return\n        }\n\n        const promiseType = getPromiseType(type)\n\n        if (promiseType) {\n          recLoop(promiseType, info, processing, [...path, 'PROMISE'])\n        }\n\n        return\n      }\n\n      if (type.isUnion()) {\n        if (processing === 'types') {\n          type.types.forEach(t => {\n            // if null or undefined, skip\n            if (\n              t.flags & ts.TypeFlags.Null ||\n              t.flags & ts.TypeFlags.Undefined ||\n              isPrimitive(t)\n            ) {\n              return\n            }\n\n            recLoop(t, info, processing, [\n              ...path,\n              t.symbol?.getName() || `N/A ${this.checker.typeToString(t)}`\n            ])\n          })\n        } else {\n          let properties = getPublicPropertiesOfType(\n            this.checker,\n            type.getNonNullableType()\n          )\n\n          if (properties.length === 0) {\n            //get first union type of non nullable type\n            const nt = type.getNonNullableType()\n            if (nt.isUnion()) {\n              properties = getPublicPropertiesOfType(this.checker, nt.types[0]!)\n            }\n          }\n\n          if (properties.length > 0) {\n            if (!referenceSchema[processing].has(type)) {\n              referenceSchema[processing].set(type, {})\n            }\n\n            // Go through all properties of the union type and add them to the reference schema\n            properties.forEach(property => {\n              const propertyType = this.checker.getTypeOfSymbolAtLocation(\n                property,\n                this.sfiFile\n              )\n\n              if (!isFunction(propertyType)) {\n                referenceSchema[processing].get(type)![\n                  property.escapedName as string\n                ] = {\n                  returnType: propertyType,\n                  args: {}\n                }\n\n                recLoop(\n                  propertyType,\n                  {\n                    propetyName: property.escapedName as string,\n                    parentType: type\n                  },\n                  processing,\n                  [...path, property.escapedName as string]\n                )\n              }\n            })\n          }\n        }\n      } else if (isFunction(type)) {\n        // skip fn for inputs\n        if (processing === 'inputs') {\n          return\n        }\n\n        if (!info.parentType) {\n          throw new Error('Cannot have a function without a parent type')\n        }\n\n        const signature = type.getCallSignatures()[0]\n        const args = signature?.getParameters() || []\n        const returnType = signature?.getReturnType()\n\n        const schemaType = referenceSchema[processing].get(info.parentType)![\n          info.propetyName!\n        ]!\n\n        args.forEach(arg => {\n          if (\n            arg.valueDeclaration &&\n            ts.isParameter(arg.valueDeclaration) &&\n            arg.valueDeclaration.dotDotDotToken\n          ) {\n            console.warn(\n              'Cannot handle rest parameters yet, skipping',\n              arg.escapedName\n            )\n          } else {\n            const argType = this.checker.getTypeOfSymbolAtLocation(\n              arg,\n              this.sfiFile\n            )\n\n            // set args to empty object if not set\n            if (schemaType.args) {\n              schemaType.args[arg.escapedName as string] = argType\n\n              recLoop(\n                argType,\n                {\n                  parentType: type\n                },\n                'inputs',\n                [...path, arg.escapedName as string]\n              )\n            }\n          }\n        })\n\n        if (returnType) {\n          recLoop(returnType, info, processing, [...path, 'RETURN_TYPE'])\n        }\n      } else if (isList(this.checker, type)) {\n        const itemType = this.checker.getIndexTypeOfType(\n          type,\n          ts.IndexKind.Number\n        )\n\n        if (itemType && !isPrimitive(itemType)) {\n          if (!referenceSchema[processing].has(type)) {\n            referenceSchema[processing].set(type, {})\n          }\n\n          recLoop(itemType, info, processing, [...path, 'ITEM_TYPE'])\n        }\n      } else if (!isPrimitive(type)) {\n        const properties = getPublicPropertiesOfType(this.checker, type)\n\n        if (!referenceSchema[processing].has(type)) {\n          referenceSchema[processing].set(type, {})\n        }\n\n        properties.forEach(property => {\n          const propertyType = this.checker.getTypeOfSymbolAtLocation(\n            property,\n            this.sfiFile\n          )\n\n          if (\n            !referenceSchema[processing].get(type)![\n              property.escapedName as string\n            ]\n          ) {\n            referenceSchema[processing].get(type)![\n              property.escapedName as string\n            ] = {\n              returnType: propertyType,\n              args: {}\n            }\n          }\n\n          recLoop(\n            propertyType,\n            {\n              propetyName: property.escapedName as string,\n              parentType: type\n            },\n            processing,\n            [...path, property.escapedName as string]\n          )\n        })\n      }\n    }\n\n    if (index.Query) {\n      recLoop(index.Query)\n    }\n\n    if (index.Mutation) {\n      recLoop(index.Mutation)\n    }\n\n    return referenceSchema\n  }\n}\n",
+  "import ts from 'typescript'\nimport {SchemaParser} from './schema-parser'\nimport path from 'path'\n\nexport class SchemaBuilder {\n  private program: ts.Program\n  private checker: ts.TypeChecker\n  private sfiFile!: ts.SourceFile\n  private sfi!: ts.Symbol\n  private sfiFilePath: string\n\n  constructor(sfiFilePath: string) {\n    this.sfiFilePath = path.join(process.cwd(), sfiFilePath)\n\n    this.program = ts.createProgram([this.sfiFilePath], {\n      target: ts.ScriptTarget.ESNext,\n      module: ts.ModuleKind.CommonJS,\n      strict: true,\n      esModuleInterop: true,\n      skipLibCheck: false,\n      forceConsistentCasingInFileNames: true,\n      noImplicitAny: true,\n      experimentalDecorators: true\n    })\n\n    this.checker = this.program.getTypeChecker()\n\n    this.loadSfi()\n  }\n\n  private loadSfi() {\n    const sourceFiles = this.program.getSourceFiles()\n    const file = sourceFiles.find(file => file.fileName === this.sfiFilePath)\n\n    if (!file) {\n      throw new Error('Could not find index.ts (pylon entrypoint)')\n    }\n\n    this.sfiFile = file\n\n    const sfiFileSymbol = this.checker.getSymbolAtLocation(file)!\n    const sfiFileExports = this.checker.getExportsOfModule(sfiFileSymbol!)\n    const sfiFileDefaultExport = sfiFileExports.find(\n      exportSymbol => exportSymbol.escapedName === 'default'\n    )\n\n    if (!sfiFileDefaultExport) {\n      throw new Error('Could not find default export')\n    }\n\n    this.sfi = sfiFileDefaultExport\n  }\n\n  public build() {\n    const sfiType = this.checker.getTypeOfSymbolAtLocation(\n      this.sfi,\n      this.sfiFile\n    )\n\n    const plainResolversProperty = sfiType.getProperty('plainResolvers')\n\n    if (!plainResolversProperty) {\n      throw new Error('Could not find plainResolvers property')\n    }\n\n    const plainResolversType = this.checker.getTypeOfSymbolAtLocation(\n      plainResolversProperty,\n      this.sfiFile\n    )\n\n    const queryProperty = plainResolversType.getProperty('Query')\n    const mutationProperty = plainResolversType.getProperty('Mutation')\n\n    const queryType = queryProperty\n      ? this.checker.getTypeOfSymbolAtLocation(queryProperty, this.sfiFile)\n      : undefined\n    const mutationType = mutationProperty\n      ? this.checker.getTypeOfSymbolAtLocation(mutationProperty, this.sfiFile)\n      : undefined\n\n    const parser = new SchemaParser(this.checker, this.sfiFile)\n\n    parser.parse({\n      Query: queryType,\n      Mutation: mutationType\n    })\n\n    return {\n      typeDefs: parser.toString(),\n      schema: parser.getSchema()\n    }\n  }\n}\n",
+  "import {Bundler} from './bundler/bundler.js'\nimport {SchemaBuilder} from './schema/builder.js'\n\nexport interface BuildOptions {\n  sfiFilePath: string\n  outputFilePath: string\n  watch?: boolean\n  onWatch?: () => void\n}\n\nexport const build = async (options: BuildOptions) => {\n  const bundler = new Bundler(options.sfiFilePath, options.outputFilePath)\n\n  await bundler.build({\n    getTypeDefs: () => {\n      const builder = new SchemaBuilder(options.sfiFilePath)\n\n      const built = builder.build()\n\n      // Write typedefs to file (only for debugging purposes)\n      const typeDefs = built.typeDefs\n\n      return typeDefs\n    },\n    watch: options.watch,\n    onWatch: options.onWatch\n  })\n}\n"
+  ],
+  "mappings": ";;AA/////fACA;AACA;;;ACjgggggBAAA;AACA;AAEA,eAAsB,eAAe,GAKlC;AACD,QAAM,kBAAkB,KAAK,QAAQ,QAAQ,IAAI,GAAG,cAAc;AAElE,QAAM,OAAO,MAAM,SAAS,eAAe;AAC3C,QAAM,cAAc,KAAK,MAAM,KAAK,SAAS,CAAC;AAC9C,SAAO;AAAA;;;AC5gggggBTAA;;;AC/////fAAA;;;AC/////fAAA;AA6GO,SAAS,yBAAyB,CACvC,SACA,OACa;AACb,MAAI,OAAO;AAEX,MAAI,KAAK,QAAQ,GAAG;AAElB,UAAM,gBAAgB,KAAK,MAAM,OAC/B,SAEI,EAAE,QAAQ,GAAG,UAAU,UACtB,EAAoB,cAAc,GAAG,YAAY,aACjD,EAAuB,eAAe,OAE7C;AACA,UAAM,oBAAoB,KAAK,MAC5B,OACC,OACE,EAAE,QAAQ,GAAG,UAAU,UACtB,EAAoB,cAAc,GAAG,YAAY,aACjD,EAAuB,eAAe,MAC3C,EACC,IAAI,OAAM,EAAuB,cAAe,EAAE;AACrD,UAAM,gBAAgB,cAAc,OAClC,QAAM,kBAAkB,KAAK,QAAM,OAAO,CAAC,CAC7C;AAUA,WAAQ,QAAgB,aAAa,aAAa;AAAA,EACpD;AAEA,QAAM,aAA0B,CAAC;AAGjC,MAAI,OAAO,SAAS,IAAI,KAAK,YAAY,IAAI,KAAK,OAAO,IAAI;AAC3D,WAAO;AAET,MAAI,iBAA8B,CAAC;AAEnC,mBACG,KAAa,sBAAsB,KAAK,cAAc,KAAK,CAAC;AAE/D,aAAW,QAAQ,gBAAgB;AACjC,UAAM,WACJ,KAAK,sBAEH,GAAG,yBAAyB,KAAK,gBAAgB,IACjD,GAAG,cAAc,aAElB,KAAK,QAAQ,EAAE,WAAW,GAAG;AAEhC,QAAI,aAAa,OAAO;AACtB;AAAA,IACF;AAEA,eAAW,KAAK,IAAI;AAAA,EACtB;AAEA,SAAO;AAAA;AA7KF,IAAM,gBAAgB,CAAC,SAAkB;AAC9C,SACE,KAAK,QAAQ,GAAG,UAAU,UAC1B,KAAK,cAAc,EAAE,WAAW,KAChC,KAAK,kBAAkB,EAAE,WAAW;AAAA;AAIjC,IAAM,SAAS,CAAC,SAAyB,SAAkB;AAChE,QAAM,WAAW,QAAQ,eAAe,MAAM,WAAW,SAAS;AAElE,QAAM,QACJ,aACC,SAAS,SAAS,GAAG,WAAW,aAC/B,SAAS,SAAS,GAAG,WAAW;AAGpC,SAAO;AAAA;;;AClhggggBTAA;;;AC/////fAUO,IAAM,QAAQ,OAAO,YAA0B;AACpD,QAAM,WAAU,IAAI,QAAQ,QAAQ,aAAa,QAAQ,cAAc;AAEvE,QAAM,SAAQ,MAAM;AAAA,IAClB,aAAa,MAAM;AACjB,YAAM,WAAU,IAAI,cAAc,QAAQ,WAAW;AAErD,YAAM,QAAQ,SAAQ,MAAM;AAG5B,YAAM,WAAW,MAAM;AAEvB,aAAO;AAAA;AAAA,IAET,OAAO,QAAQ;AAAA,IACf,SAAS,QAAQ;AAAA,EACnB,CAAC;AAAA;",
+  "debugId": "0C352A137DDA7D9F64756e2164756e21",
+  "names": []
+}

package/dist/load-package-json.d.ts

@@ -0,0 +1,6 @@
+export declare function loadPackageJson(): Promise<{
+    baseURL?: string;
+    pylon?: {
+        external?: string[];
+    };
+}>;

package/dist/schema/builder.d.ts

@@ -0,0 +1,13 @@
+export declare class SchemaBuilder {
+    private program;
+    private checker;
+    private sfiFile;
+    private sfi;
+    private sfiFilePath;
+    constructor(sfiFilePath: string);
+    private loadSfi;
+    build(): {
+        typeDefs: string;
+        schema: import("./schema-parser").Schema;
+    };
+}

package/dist/schema/schema-parser.d.ts

@@ -0,0 +1,65 @@
+import ts from 'typescript';
+import { Union as _Union, Enum as _Enum } from './type-definition-builder.js';
+type Union = _Union & {
+    description: string;
+};
+type Enum = _Enum & {
+    description: string;
+};
+interface TypeDefinition {
+    name: string;
+    isList: boolean;
+    isRequired: boolean;
+    description: string;
+}
+interface Field {
+    name: string;
+    type: TypeDefinition;
+}
+interface Input {
+    name: string;
+    description: string;
+    fields: Array<{
+        name: string;
+        type: TypeDefinition;
+    }>;
+}
+interface Type {
+    name: string;
+    description: string;
+    fields: Array<Field & {
+        args: Array<{
+            name: string;
+            type: TypeDefinition;
+        }>;
+    }>;
+}
+export interface Schema {
+    types: Array<Type>;
+    inputs: Array<Input>;
+    unions: Array<Union>;
+    enums: Array<Enum>;
+    scalars: Array<string>;
+}
+interface Index {
+    Query?: ts.Type;
+    Mutation?: ts.Type;
+}
+export declare class SchemaParser {
+    private schema;
+    private checker;
+    private sfiFile;
+    private typeDefinitionBuilder;
+    constructor(checker: ts.TypeChecker, sfiFile: ts.SourceFile);
+    parse(index: Index): void;
+    toString(): string;
+    getSchema(): Schema;
+    private processSchemaReference;
+    private getJsDocHeaderFromType;
+    /**
+     * Extracts reserved field names from the schema by removing them from their respective types and inputs.
+     */
+    private extractForbiddenFieldNamesFromSchema;
+    private makeReferenceSchema;
+}
+export {};

package/dist/schema/type-definition-builder.d.ts

@@ -0,0 +1,36 @@
+import ts from 'typescript';
+import { Schema } from './schema-parser.js';
+export interface Union {
+    name: string;
+    rawType: ts.Type;
+    types: Array<string>;
+}
+export interface Enum {
+    name: string;
+    rawType: ts.Type;
+    values: Array<string>;
+}
+interface FieldDefinition {
+    name: string;
+    isList: boolean;
+    isRequired: boolean;
+    isListRequired?: boolean;
+}
+export declare class TypeDefinitionBuilder {
+    private checker;
+    private schema;
+    private typesNameMap;
+    private inputsNameMap;
+    private unions;
+    private enums;
+    constructor(checker: ts.TypeChecker, schema: Schema);
+    getTypeDefinition: (rawType: ts.Type, options?: {
+        isInputType?: boolean;
+        isRequired?: boolean;
+        propertyName?: string;
+    }) => FieldDefinition;
+    getUnions(): Array<Union>;
+    getEnums(): Array<Enum>;
+    typeDefinitionToGraphQLType: (typeDefinition: FieldDefinition) => string;
+}
+export {};

package/dist/schema/types-helper.d.ts

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+export declare const isEmptyObject: (type: ts.Type) => boolean | 0;
+export declare const isList: (checker: ts.TypeChecker, type: ts.Type) => boolean;
+export declare const isBoolean: (type: ts.Type) => boolean;
+export declare const isPrimitive: (type: ts.Type) => number;
+export declare const isFunction: (type: ts.Type) => boolean;
+export declare const isEnum: (type: ts.Type) => boolean;
+export declare const isPromise: (type: ts.Type) => boolean;
+export declare const getPromiseType: (type: ts.Type) => ts.Type | undefined;
+export declare const excludeNullUndefinedFromType: (type: ts.Type) => {
+    type: ts.Type;
+    wasOptional: boolean;
+};
+export declare function getPublicPropertiesOfType(checker: ts.TypeChecker, _type: ts.Type): ts.Symbol[];
+export declare const safeTypeName: (name: string) => string;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@getcronit/pylon-builder",
+  "version": "0.0.49",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "bun run ../../build.js && bun run build:declarations",
+    "build:declarations": "tsc --declaration --emitDeclarationOnly --outDir ./dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@vercel/ncc": "^0.38.1",
+    "chokidar": "^3.5.3",
+    "rollup": "^4.9.6",
+    "rollup-plugin-terser": "^7.0.2",
+    "source-map-support": "^0.5.21",
+    "typescript": "^4.9.5"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.21.0",
+    "@babel/plugin-syntax-import-assertions": "^7.20.0",
+    "babel-jest": "^29.4.2",
+    "jest": "^29.4.2",
+    "jest-environment-jsdom": "^29.4.2",
+    "microbundle": "^0.15.1",
+    "ts-jest": "^29.0.5",
+    "tslib": "^2.5.0"
+  }
+}