@mehdad67/apitogo 0.1.24

package/src/lib/oas/graphql/index.ts

@@ -0,0 +1,791 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: Allow any type
+import SchemaBuilder from "@pothos/core";
+import { GraphQLJSON, GraphQLJSONObject } from "graphql-type-json";
+import { createYoga, type YogaServerOptions } from "graphql-yoga";
+import {
+  type CountableSlugify,
+  slugifyWithCounter,
+} from "../../util/slugify.js";
+import { HttpMethods, validate } from "../parser/index.js";
+import type {
+  ContactObject,
+  EncodingObject,
+  ExampleObject,
+  ExternalDocumentationObject,
+  LicenseObject,
+  OpenAPIDocument,
+  OperationObject,
+  ParameterObject,
+  PathsObject,
+  SchemaObject,
+  ServerObject,
+  TagObject,
+} from "../parser/index.js";
+import { GraphQLJSONSchema } from "./circular.js";
+
+export type {
+  EncodingObject,
+  ExampleObject,
+  OpenAPIDocument,
+  OperationObject,
+  ParameterObject,
+  PathsObject,
+  SchemaObject,
+  TagObject,
+};
+
+type OperationLike = {
+  summary?: string | null;
+  operationId?: string | null;
+  path: string;
+  method: string;
+};
+
+export const createOperationSlug = (
+  slugify: CountableSlugify,
+  operation: OperationLike,
+) => {
+  const summary =
+    operation.summary ||
+    operation.operationId ||
+    `${operation.method}-${operation.path}`;
+
+  return slugify(summary);
+};
+
+export type SchemaImport = () => Promise<{ schema: OpenAPIDocument }>;
+
+export type SchemaImports = Record<string, SchemaImport>;
+
+type Slugs = {
+  operations: Record<string, string>;
+  tags: Record<string, string>;
+};
+
+type Context = {
+  schema: OpenAPIDocument;
+  operations: GraphQLOperationObject[];
+  schemaImports?: SchemaImports;
+  tags: ReturnType<typeof getAllTags>;
+  slugs: Slugs;
+};
+
+const builder = new SchemaBuilder<{
+  DefaultFieldNullability: false;
+  Scalars: {
+    JSON: any;
+    JSONObject: any;
+    JSONSchema: any;
+  };
+  Context: Context;
+}>({
+  defaultFieldNullability: false,
+});
+
+type GraphQLOperationObject = OperationObject & {
+  path: string;
+  method: string;
+  slug?: string;
+  parentTag?: string;
+};
+
+const JSONScalar = builder.addScalarType("JSON", GraphQLJSON);
+const JSONObjectScalar = builder.addScalarType("JSONObject", GraphQLJSONObject);
+const JSONSchemaScalar = builder.addScalarType("JSONSchema", GraphQLJSONSchema);
+
+const resolveExtensions = (obj: Record<string, any>) =>
+  Object.fromEntries(
+    Object.entries(obj).filter(([key]) => key.startsWith("x-")),
+  );
+
+export const getAllTags = (
+  schema: OpenAPIDocument,
+): Array<Omit<TagObject, "name"> & { name?: string; slug?: string }> => {
+  const rootTags = schema.tags ?? [];
+  const operations = Object.values(schema.paths ?? {}).flatMap((path) =>
+    HttpMethods.map((k) => path?.[k]).filter((op) => op != null),
+  );
+
+  const operationTags = new Set(operations.flatMap((op) => op.tags ?? []));
+
+  const hasUntaggedOperations = operations.some(
+    (op) => (op.tags?.length ?? 0) === 0,
+  );
+
+  const slugify = slugifyWithCounter();
+  const slugs = Object.fromEntries(
+    Array.from(
+      new Set([...Array.from(operationTags), ...rootTags.map((t) => t.name)]),
+    ).map((tag) => [tag, slugify(tag)]),
+  );
+
+  const result = [
+    // Keep root tags that are actually used in operations
+    ...rootTags
+      .filter((tag) => operationTags.has(tag.name))
+      .map((tag) => ({ ...tag, slug: slugs[tag.name] })),
+    // Add tags found in operations but not defined in root tags
+    ...Array.from(operationTags)
+      .filter((tag) => !rootTags.some((rt) => rt.name === tag))
+      .map((tag) => ({ name: tag, slug: slugs[tag] })),
+    // Add untagged operations if there are any
+    ...(hasUntaggedOperations ? [{ name: undefined, slug: undefined }] : []),
+  ];
+
+  // Apply x-tagGroups ordering if present
+  const tagGroups = (schema as any)["x-tagGroups"] ?? [];
+
+  if (tagGroups.length === 0) return result;
+
+  const groupOrder = tagGroups.flatMap((group: any) => group.tags);
+  return result.sort((a, b) => {
+    if (!a.name || !b.name) return 0; // Keep untagged at end
+    const indexA = groupOrder.indexOf(a.name);
+    const indexB = groupOrder.indexOf(b.name);
+    if (indexA === -1 && indexB === -1) return 0; // Keep original order for ungrouped
+    if (indexA === -1) return 1; // Ungrouped after grouped
+    if (indexB === -1) return -1; // Grouped before ungrouped
+    return indexA - indexB;
+  });
+};
+
+export const getAllSlugs = (
+  ops: GraphQLOperationObject[],
+  schemaTags: TagObject[] = [],
+): Slugs => {
+  const operationSlugify = slugifyWithCounter();
+  const tagSlugify = slugifyWithCounter();
+
+  const tags = Array.from(
+    new Set([
+      ...ops.flatMap((op) => op.tags ?? []),
+      ...schemaTags.map((tag) => tag.name),
+    ]),
+  );
+
+  return {
+    operations: Object.fromEntries(
+      ops.map((op) => [
+        getOperationSlugKey(op),
+        createOperationSlug(operationSlugify, op),
+      ]),
+    ),
+    tags: Object.fromEntries(tags.map((tag) => [tag, tagSlugify(tag)])),
+  };
+};
+
+const getOperationSlugKey = (op: GraphQLOperationObject) =>
+  [op.path, op.method, op.operationId, op.summary].filter(Boolean).join("-");
+
+export const getAllOperations = (
+  paths?: PathsObject,
+): GraphQLOperationObject[] => {
+  const operations = Object.entries(paths ?? {}).flatMap(([path, value]) =>
+    HttpMethods.flatMap((method) => {
+      if (!value?.[method]) return [];
+
+      const operation = value[method] as OperationObject;
+      const pathParameters = value.parameters ?? [];
+      const operationParameters = operation.parameters ?? [];
+
+      // parameters are inherited from the parent path object,
+      // but can be overridden by their `name` and `in` location
+      const parameters = [
+        ...pathParameters.filter(
+          // remove path parameters that are already defined in the operation
+          (pp) =>
+            !operationParameters.some(
+              (op) => op.name === pp.name && op.in === pp.in,
+            ),
+        ),
+        ...operationParameters,
+      ];
+
+      // servers follow the OpenAPI 3.0 resolution hierarchy:
+      // 1. Operation-level servers (highest precedence)
+      // 2. Path-level servers
+      // 3. Global servers (handled at query time, lowest precedence)
+      const pathServers = value.servers ?? [];
+      const operationServers = operation.servers ?? [];
+      const servers =
+        operationServers.length > 0 ? operationServers : pathServers;
+
+      return {
+        ...operation,
+        method,
+        path,
+        parameters,
+        servers,
+        tags: operation.tags ?? [],
+      } satisfies GraphQLOperationObject;
+    }),
+  );
+
+  return operations;
+};
+
+const SchemaContact = builder
+  .objectRef<ContactObject>("SchemaContact")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name", { nullable: true }),
+      url: t.exposeString("url", { nullable: true }),
+      email: t.exposeString("email", { nullable: true }),
+    }),
+  });
+
+const SchemaLicense = builder
+  .objectRef<LicenseObject>("SchemaLicense")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      url: t.exposeString("url", { nullable: true }),
+      identifier: t.exposeString("identifier", { nullable: true }),
+    }),
+  });
+
+const SchemaExternalDocs = builder
+  .objectRef<ExternalDocumentationObject>("SchemaExternalDocs")
+  .implement({
+    fields: (t) => ({
+      description: t.exposeString("description", { nullable: true }),
+      url: t.exposeString("url"),
+    }),
+  });
+
+const SchemaTag = builder.objectRef<
+  Omit<TagObject, "name"> & { name?: string; slug?: string }
+>("SchemaTag");
+
+SchemaTag.implement({
+  fields: (t) => ({
+    name: t.exposeString("name", { nullable: true }),
+    slug: t.exposeString("slug", { nullable: true }),
+    isUntagged: t.field({ type: "Boolean", resolve: (parent) => !parent.name }),
+    description: t.exposeString("description", { nullable: true }),
+    operations: t.field({
+      type: [OperationItem],
+      resolve: (parent, _args, ctx) => {
+        const rootTags = ctx.tags.map((tag) => tag.name);
+
+        return ctx.operations
+          .filter((item) =>
+            parent.name
+              ? item.tags?.includes(parent.name)
+              : item.tags?.length === 0 ||
+                // If none of the tags are present in the root tags, then show them here
+                item.tags?.every((tag) => !rootTags.includes(tag)),
+          )
+          .map((item) => ({ ...item, parentTag: parent.name }));
+      },
+    }),
+    prev: t.field({
+      type: SchemaTag,
+      nullable: true,
+      resolve: (parent, _args, ctx) => {
+        const index = ctx.tags.findIndex((tag) => tag.slug === parent.slug);
+        return ctx.tags[index - 1];
+      },
+    }),
+    next: t.field({
+      type: SchemaTag,
+      nullable: true,
+      resolve: (parent, _args, ctx) => {
+        const index = ctx.tags.findIndex((tag) => tag.slug === parent.slug);
+        return ctx.tags[index + 1];
+      },
+    }),
+    extensions: t.field({
+      type: JSONObjectScalar,
+      resolve: (parent) => resolveExtensions(parent),
+      nullable: true,
+    }),
+  }),
+});
+
+const ServerItem = builder.objectRef<ServerObject>("Server").implement({
+  fields: (t) => ({
+    url: t.exposeString("url"),
+    description: t.exposeString("description", { nullable: true }),
+  }),
+});
+
+type WebhookData = {
+  name: string;
+  method: string;
+  summary?: string;
+  description?: string;
+  operationId?: string;
+};
+
+const WebhookItem = builder.objectRef<WebhookData>("WebhookItem").implement({
+  fields: (t) => ({
+    name: t.exposeString("name"),
+    method: t.exposeString("method"),
+    summary: t.exposeString("summary", { nullable: true }),
+    description: t.exposeString("description", { nullable: true }),
+    operationId: t.exposeString("operationId", { nullable: true }),
+  }),
+});
+
+const resolveWebhooks = (schema: OpenAPIDocument): WebhookData[] => {
+  const webhooks = (schema as any).webhooks ?? {};
+  return Object.entries(webhooks).flatMap(([name, pathItem]: [string, any]) =>
+    HttpMethods.flatMap((method) => {
+      const op = pathItem?.[method];
+      if (!op) return [];
+      return {
+        name,
+        method: method.toUpperCase(),
+        summary: op.summary,
+        description: op.description,
+        operationId: op.operationId,
+      };
+    }),
+  );
+};
+
+const PathItem = builder
+  .objectRef<{
+    path: string;
+    methods: typeof HttpMethods;
+  }>("PathItem")
+  .implement({
+    fields: (t) => ({
+      path: t.exposeString("path"),
+      methods: t.exposeStringList("methods"),
+    }),
+  });
+
+const TagItem = builder.objectRef<TagObject>("TagItem").implement({
+  fields: (t) => ({
+    name: t.exposeString("name"),
+    description: t.exposeString("description", { nullable: true }),
+    extensions: t.field({
+      type: JSONObjectScalar,
+      resolve: (parent) => resolveExtensions(parent),
+      nullable: true,
+    }),
+  }),
+});
+
+const EncodingItem = builder
+  .objectRef<EncodingObject & { name: string }>("EncodingItem")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      contentType: t.exposeString("contentType", { nullable: true }),
+      headers: t.expose("headers", { type: JSONObjectScalar, nullable: true }),
+      style: t.exposeString("style", { nullable: true }),
+      explode: t.exposeBoolean("explode", { nullable: true }),
+      allowReserved: t.exposeBoolean("allowReserved", { nullable: true }),
+    }),
+  });
+
+const ExampleItem = builder
+  .objectRef<ExampleObject & { name: string }>("ExampleItem")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      summary: t.exposeString("summary", { nullable: true }),
+      description: t.exposeString("description", { nullable: true }),
+      value: t.expose("value", { type: JSONScalar, nullable: true }),
+      externalValue: t.exposeString("externalValue", { nullable: true }),
+    }),
+  });
+
+const ParameterIn = builder.enumType("ParameterIn", {
+  values: ["query", "header", "path", "cookie"] as const,
+});
+
+const ParameterItem = builder
+  .objectRef<ParameterObject>("ParameterItem")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      in: t.field({
+        type: ParameterIn,
+        resolve: (parent) => parent.in as typeof ParameterIn.$inferType,
+      }),
+      description: t.exposeString("description", { nullable: true }),
+      required: t.exposeBoolean("required", { nullable: true }),
+      deprecated: t.exposeBoolean("deprecated", { nullable: true }),
+      allowEmptyValue: t.exposeBoolean("allowEmptyValue", { nullable: true }),
+      style: t.exposeString("style", { nullable: true }),
+      explode: t.exposeBoolean("explode", { nullable: true }),
+      allowReserved: t.exposeBoolean("allowReserved", { nullable: true }),
+      examples: t.field({
+        type: [ExampleItem],
+        resolve: (parent) =>
+          Object.entries(parent.examples ?? {}).map(([name, value]) => ({
+            name,
+            ...(typeof value === "string" ? { value } : value),
+          })),
+        nullable: true,
+      }),
+      schema: t.expose("schema", { type: JSONSchemaScalar, nullable: true }),
+      extensions: t.field({
+        type: JSONObjectScalar,
+        resolve: (parent) => resolveExtensions(parent),
+        nullable: true,
+      }),
+    }),
+  });
+
+const MediaTypeItem = builder
+  .objectRef<{
+    mediaType: string;
+    schema: any;
+    examples: Array<ExampleObject & { name: string }>;
+    encoding?: Array<EncodingObject & { name: string }>;
+  }>("MediaTypeObject")
+  .implement({
+    fields: (t) => ({
+      mediaType: t.exposeString("mediaType"),
+      schema: t.expose("schema", { type: JSONSchemaScalar, nullable: true }),
+      examples: t.expose("examples", { type: [ExampleItem], nullable: true }),
+      encoding: t.expose("encoding", { type: [EncodingItem], nullable: true }),
+    }),
+  });
+
+const RequestBodyObject = builder
+  .objectRef<{
+    description?: string;
+    required?: boolean;
+    content: Array<{
+      mediaType: string;
+      schema: any;
+      examples: Array<ExampleObject & { name: string }>;
+      encoding?: Array<EncodingObject & { name: string }>;
+    }>;
+  }>("RequestBodyObject")
+  .implement({
+    fields: (t) => ({
+      description: t.exposeString("description", { nullable: true }),
+      content: t.expose("content", { type: [MediaTypeItem], nullable: true }),
+      required: t.exposeBoolean("required", { nullable: true }),
+    }),
+  });
+
+const ResponseItem = builder
+  .objectRef<{
+    statusCode: string;
+    description?: string;
+    content: Array<{
+      mediaType: string;
+      schema: any;
+      examples: Array<ExampleObject & { name: string }>;
+    }>;
+    headers?: any;
+    links?: any;
+  }>("ResponseItem")
+  .implement({
+    fields: (t) => ({
+      statusCode: t.exposeString("statusCode"),
+      description: t.exposeString("description", { nullable: true }),
+      content: t.expose("content", { type: [MediaTypeItem], nullable: true }),
+      headers: t.expose("headers", { type: JSONScalar, nullable: true }),
+      links: t.expose("links", { type: JSONScalar, nullable: true }),
+      extensions: t.field({
+        type: JSONObjectScalar,
+        resolve: (parent) => resolveExtensions(parent),
+        nullable: true,
+      }),
+    }),
+  });
+
+const OperationItem = builder
+  .objectRef<GraphQLOperationObject>("OperationItem")
+  .implement({
+    fields: (t) => ({
+      slug: t.field({
+        type: "String",
+        resolve: (parent, _, ctx) => {
+          const slug = ctx.slugs.operations[getOperationSlugKey(parent)];
+
+          if (!slug) {
+            throw new Error(
+              `No slug found for operation: ${getOperationSlugKey(parent)}`,
+            );
+          }
+          return slug;
+        },
+      }),
+      path: t.exposeString("path"),
+      method: t.exposeString("method"),
+      operationId: t.exposeString("operationId", { nullable: true }),
+      summary: t.exposeString("summary", { nullable: true }),
+      description: t.exposeString("description", { nullable: true }),
+      contentTypes: t.stringList({
+        resolve: (parent) => Object.keys(parent.requestBody?.content ?? {}),
+      }),
+      parameters: t.expose("parameters", {
+        type: [ParameterItem],
+        nullable: true,
+      }),
+      servers: t.field({
+        type: [ServerItem],
+        resolve: (parent, _, ctx) => {
+          // Return operation/path-level servers if defined, otherwise fall back to global servers
+          return parent.servers && parent.servers.length > 0
+            ? parent.servers
+            : (ctx.schema.servers ?? []);
+        },
+      }),
+      requestBody: t.field({
+        type: RequestBodyObject,
+        resolve: (parent) => ({
+          description: parent.requestBody?.description,
+          required: parent.requestBody?.required,
+          content: Object.entries(parent.requestBody?.content ?? {}).map(
+            ([mediaType, content]) => ({
+              mediaType,
+              schema: content.schema,
+              examples: content.examples
+                ? Object.entries(content.examples).map(([name, value]) => ({
+                    name,
+                    ...(typeof value === "string" ? { value } : value),
+                  }))
+                : content.example !== undefined
+                  ? [{ name: "", value: content.example }]
+                  : [],
+              encoding: Object.entries(content.encoding ?? {}).map(
+                ([name, value]) => ({ name, ...value }),
+              ),
+            }),
+          ),
+        }),
+        nullable: true,
+      }),
+      responses: t.field({
+        type: [ResponseItem],
+        resolve: (parent) => {
+          return Object.entries(parent.responses ?? {}).map(
+            ([statusCode, response]) => ({
+              statusCode,
+              description: response.description,
+              content: Object.entries(response.content ?? {}).map(
+                ([mediaType, { schema, examples, example }]) => ({
+                  mediaType,
+                  schema,
+                  examples: examples
+                    ? Object.entries(examples).map(([name, value]) => ({
+                        name,
+                        ...(typeof value === "string" ? { value } : value),
+                      }))
+                    : example !== undefined
+                      ? [{ name: "", value: example }]
+                      : [],
+                }),
+              ),
+              headers: response.headers,
+              links: response.links,
+            }),
+          );
+        },
+      }),
+      tags: t.field({
+        type: [TagItem],
+        resolve: (parent, _, ctx) =>
+          parent.tags?.map((tag) => ({
+            name: tag,
+            description: ctx.schema.tags?.find((t) => t.name === tag)
+              ?.description,
+          })),
+        nullable: true,
+      }),
+      deprecated: t.exposeBoolean("deprecated", { nullable: true }),
+      extensions: t.field({
+        type: JSONObjectScalar,
+        resolve: (parent) => resolveExtensions(parent),
+        nullable: true,
+      }),
+    }),
+  });
+
+const SchemaItem = builder
+  .objectRef<{
+    name: string;
+    schema: SchemaObject;
+    extensions?: Record<string, any>;
+  }>("SchemaItem")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      schema: t.expose("schema", { type: JSONSchemaScalar }),
+      extensions: t.expose("extensions", {
+        type: JSONObjectScalar,
+        nullable: true,
+      }),
+    }),
+  });
+
+const Components = builder.objectRef<{
+  schemas?: Record<string, SchemaObject>;
+}>("Components");
+
+Components.implement({
+  fields: (t) => ({
+    schemas: t.field({
+      type: [SchemaItem],
+      resolve: (parent) => {
+        return Object.entries(parent.schemas ?? {}).map(([name, schema]) => ({
+          name,
+          schema,
+          extensions: resolveExtensions(schema),
+        }));
+      },
+      nullable: true,
+    }),
+  }),
+});
+
+const Schema = builder.objectRef<OpenAPIDocument>("Schema").implement({
+  fields: (t) => ({
+    openapi: t.string({ resolve: (root) => root.openapi }),
+    url: t.string({
+      resolve: (root) => root.servers?.at(0)?.url,
+      nullable: true,
+    }),
+    servers: t.field({
+      type: [ServerItem],
+      resolve: (root) => root.servers ?? [],
+    }),
+    title: t.string({ resolve: (root) => root.info.title }),
+    version: t.string({ resolve: (root) => root.info.version }),
+    description: t.string({
+      resolve: (root) => root.info.description,
+      nullable: true,
+    }),
+    summary: t.string({
+      resolve: (root) => root.info.summary,
+      nullable: true,
+    }),
+    contact: t.field({
+      type: SchemaContact,
+      nullable: true,
+      resolve: (root) => root.info.contact ?? null,
+    }),
+    license: t.field({
+      type: SchemaLicense,
+      nullable: true,
+      resolve: (root) => root.info.license ?? null,
+    }),
+    termsOfService: t.string({
+      resolve: (root) => root.info.termsOfService,
+      nullable: true,
+    }),
+    externalDocs: t.field({
+      type: SchemaExternalDocs,
+      nullable: true,
+      resolve: (root) => root.externalDocs ?? null,
+    }),
+    paths: t.field({
+      type: [PathItem],
+      resolve: (root) =>
+        Object.entries(root.paths ?? {}).map(([path, value]) => ({
+          path,
+          // biome-ignore lint/style/noNonNullAssertion: value is guaranteed to be defined
+          methods: Object.keys(value!) as typeof HttpMethods,
+        })),
+    }),
+    tag: t.field({
+      type: SchemaTag,
+      args: {
+        slug: t.arg.string(),
+        name: t.arg.string(),
+        untagged: t.arg.boolean(),
+      },
+      nullable: true,
+      resolve: (_, args, ctx) => {
+        if (args.untagged) {
+          return ctx.tags.find((tag) => tag.name === undefined);
+        }
+        if (args.slug) {
+          return ctx.tags.find((tag) => tag.slug === args.slug);
+        }
+        if (args.name) {
+          return ctx.tags.find((tag) => tag.name === args.name);
+        }
+      },
+    }),
+    tags: t.field({
+      type: [SchemaTag],
+      resolve: (_root, _args, ctx) => ctx.tags,
+    }),
+    operations: t.field({
+      type: [OperationItem],
+      args: {
+        path: t.arg.string(),
+        method: t.arg.string(),
+        operationId: t.arg.string(),
+        tag: t.arg.string(),
+        untagged: t.arg.boolean(),
+      },
+      resolve: (_parent, args, ctx) =>
+        ctx.operations.filter((op) => {
+          return (
+            (!args.operationId || op.operationId === args.operationId) &&
+            (!args.path || op.path === args.path) &&
+            (!args.method || op.method === args.method) &&
+            (!args.tag || op.tags?.some((tag) => args.tag?.includes(tag))) &&
+            (!args.untagged || (op.tags ?? []).length === 0)
+          );
+        }),
+    }),
+    webhooks: t.field({
+      type: [WebhookItem],
+      resolve: (root) => resolveWebhooks(root),
+    }),
+    components: t.field({
+      type: Components,
+      resolve: (root) => root.components,
+      nullable: true,
+    }),
+    extensions: t.field({
+      type: JSONObjectScalar,
+      resolve: (root) => resolveExtensions(root),
+      nullable: true,
+    }),
+  }),
+});
+
+const SchemaSource = builder.enumType("SchemaType", {
+  values: ["url", "file", "raw"] as const,
+});
+
+builder.queryType({
+  fields: (t) => ({
+    schema: t.field({
+      type: Schema,
+      args: {
+        type: t.arg({ type: SchemaSource, required: true }),
+        input: t.arg({ type: JSONScalar, required: true }),
+      },
+      resolve: async (_parent, args, ctx) => {
+        if (args.type === "file" && typeof args.input === "string") {
+          const loadSchema = ctx.schemaImports?.[args.input];
+
+          if (!loadSchema) {
+            throw new Error(`No schema loader found for path: ${args.input}`);
+          }
+          ctx.schema = (await loadSchema()).schema;
+        } else {
+          ctx.schema = await validate(args.input as string);
+        }
+
+        ctx.operations = getAllOperations(ctx.schema.paths);
+        ctx.slugs = getAllSlugs(ctx.operations, ctx.schema.tags);
+        ctx.tags = getAllTags(ctx.schema);
+
+        return ctx.schema;
+      },
+    }),
+  }),
+});
+
+export const schema = builder.toSchema();
+
+export const createGraphQLServer = (
+  options?: Omit<YogaServerOptions<any, any>, "schema">,
+) => createYoga({ schema, batching: true, ...options });