@mehdad67/apitogo 0.1.24

package/src/lib/oas/parser/dereference/index.ts

@@ -0,0 +1,84 @@
+import type { JSONSchema4, JSONSchema6 } from "json-schema";
+import { CIRCULAR_REF } from "../../graphql/constants.js";
+import { resolveLocalRef } from "./resolveRef.js";
+
+export type JSONSchema = JSONSchema4 | JSONSchema6;
+
+type CustomResolver = (ref: string) => Promise<JSONSchema | undefined>;
+
+const cache = new Map<JSONSchema, JSONSchema>();
+
+// biome-ignore lint/suspicious/noExplicitAny: Allow any type
+const isIndexableObject = (obj: any): obj is Record<string, any> =>
+  obj !== null && typeof obj === "object";
+
+// Taken and inspired from `dereference-json-schema` package.
+export const dereference = async (
+  schema: JSONSchema,
+  resolvers: CustomResolver[] = [],
+) => {
+  if (cache.has(schema)) {
+    // biome-ignore lint/style/noNonNullAssertion: Cache is guaranteed to have a value
+    return cache.get(schema)!;
+  }
+
+  const cloned = structuredClone(schema);
+  const visited = new Set<unknown>();
+
+  const resolve = async (current: unknown, path: string) => {
+    if (isIndexableObject(current)) {
+      if (visited.has(current)) {
+        return CIRCULAR_REF;
+      }
+
+      visited.add(current);
+
+      if (Array.isArray(current)) {
+        for (let index = 0; index < current.length; index++) {
+          current[index] = await resolve(current[index], `${path}/${index}`);
+        }
+      } else {
+        if ("$ref" in current && typeof current.$ref === "string") {
+          const { $ref, ...siblings } = current;
+          current.__$ref = $ref;
+          const hasSiblings = Object.keys(siblings).length > 0;
+
+          let result: unknown;
+          for (const resolver of resolvers) {
+            const resolved = await resolver($ref);
+            if (resolved) {
+              result = await resolve(resolved, path);
+              break;
+            }
+          }
+          if (result === undefined) {
+            const resolved = await resolveLocalRef(cloned, $ref);
+            result = await resolve(resolved, path);
+          }
+
+          if (hasSiblings) {
+            if (result === CIRCULAR_REF) {
+              return { ...siblings };
+            }
+            if (isIndexableObject(result)) {
+              return { ...result, ...siblings };
+            }
+          }
+          return result;
+        }
+
+        for (const key in current) {
+          current[key] = await resolve(current[key], `${path}/${key}`);
+        }
+      }
+
+      visited.delete(current);
+    }
+
+    return current;
+  };
+
+  const result = (await resolve(cloned, "#")) as JSONSchema;
+  cache.set(schema, result);
+  return result;
+};

package/src/lib/oas/parser/dereference/resolveRef.ts

@@ -0,0 +1,32 @@
+import type { JSONSchema } from "./index.js";
+
+const cache = new Map<JSONSchema, Map<string, unknown>>();
+
+/**
+ * Resolves a $ref pointer in a schema and returns the referenced value.
+ */
+export const resolveLocalRef = (schema: JSONSchema, ref: string): unknown => {
+  if (!cache.has(schema)) {
+    cache.set(schema, new Map<string, unknown>());
+  }
+  const schemaCache = cache.get(schema);
+
+  if (schemaCache?.has(ref)) {
+    return schemaCache.get(ref);
+  }
+
+  const path = ref.split("/").slice(1);
+
+  // biome-ignore lint/suspicious/noExplicitAny: Allow any type
+  let current: any = schema;
+  for (const segment of path) {
+    if (!current || typeof current !== "object") {
+      // we've reached a dead end
+      current = null;
+    }
+    current = current[segment] ?? null;
+  }
+
+  schemaCache?.set(ref, current);
+  return current;
+};

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

@@ -0,0 +1,129 @@
+import { GraphQLError } from "graphql/error/index.js";
+import { OpenAPIV3, type OpenAPIV3_1 } from "openapi-types";
+import { flattenAllOf } from "../../util/flattenAllOf.js";
+import { traverse } from "../../util/traverse.js";
+import { dereference, type JSONSchema } from "./dereference/index.js";
+import { upgradeSchema } from "./upgrade/index.js";
+
+// Must be an interface (not a type) to allow merging with OpenAPI types with index signatures
+interface WithRef {
+  __$ref?: string;
+}
+
+type DeepOmitReference<T> = T extends OpenAPIV3_1.ReferenceObject
+  ? never
+  : T extends object
+    ? { [K in keyof T]: DeepOmitReference<T[K]> } & WithRef
+    : T;
+
+export type OpenAPIDocument = DeepOmitReference<OpenAPIV3_1.Document>;
+export type ResponseObject = DeepOmitReference<OpenAPIV3_1.ResponseObject>;
+export type OperationObject = DeepOmitReference<OpenAPIV3_1.OperationObject>;
+export type PathsObject = DeepOmitReference<OpenAPIV3_1.PathsObject>;
+export type PathItemObject = DeepOmitReference<OpenAPIV3_1.PathItemObject>;
+export type ParameterObject = DeepOmitReference<OpenAPIV3_1.ParameterObject>;
+export type TagObject = DeepOmitReference<OpenAPIV3_1.TagObject>;
+export type ExampleObject = DeepOmitReference<OpenAPIV3_1.ExampleObject>;
+export type EncodingObject = DeepOmitReference<OpenAPIV3_1.EncodingObject>;
+export type SchemaObject = DeepOmitReference<OpenAPIV3_1.SchemaObject>;
+export type ArraySchemaObject =
+  DeepOmitReference<OpenAPIV3_1.ArraySchemaObject>;
+export type ServerObject = DeepOmitReference<OpenAPIV3_1.ServerObject>;
+export type ContactObject = DeepOmitReference<OpenAPIV3_1.ContactObject>;
+export type LicenseObject = DeepOmitReference<OpenAPIV3_1.LicenseObject>;
+export type ExternalDocumentationObject =
+  DeepOmitReference<OpenAPIV3_1.ExternalDocumentationObject>;
+
+export const HttpMethods = Object.values(OpenAPIV3.HttpMethods);
+
+const parseSchemaInput = async (
+  schemaInput: unknown,
+): Promise<JSONSchema & { openapi?: string }> => {
+  if (typeof schemaInput === "string") {
+    if (schemaInput.trim().startsWith("{")) {
+      try {
+        return JSON.parse(schemaInput);
+      } catch (err) {
+        throw new GraphQLError("Invalid JSON schema", {
+          originalError: err,
+        });
+      }
+    }
+    if (schemaInput.includes("://")) {
+      let response: Response;
+      try {
+        response = await fetch(schemaInput, {
+          cache: "force-cache",
+        });
+      } catch (err) {
+        throw new GraphQLError("Failed to fetch schema", {
+          originalError: err,
+        });
+      }
+
+      if (!response.ok) {
+        throw new GraphQLError(
+          `Failed to fetch schema: ${response.statusText}`,
+        );
+      }
+
+      const schemaText = await response.text();
+
+      try {
+        if (schemaText.trim().startsWith("{")) {
+          return JSON.parse(schemaText) as JSONSchema;
+        } else {
+          const yaml = await import("yaml");
+          return yaml.parse(schemaText) as JSONSchema;
+        }
+      } catch (err) {
+        throw new GraphQLError("Fetched invalid schema", {
+          originalError: err,
+        });
+      }
+    }
+    const yaml = await import("yaml");
+    const parsed = yaml.parse(schemaInput);
+
+    if (typeof parsed === "object") return parsed;
+  }
+
+  if (typeof schemaInput === "object") return schemaInput as JSONSchema;
+
+  throw new GraphQLError(`Unsupported schema input: ${schemaInput}`);
+};
+
+/**
+ * Validates, dereferences and upgrades the OpenAPI schema (to v3.1) if necessary.
+ *
+ * This only happens for URL schemas (or in standalone mode).
+ * File schemas are pre-processed by the SchemaManager
+ */
+export const validate = async (schemaInput: unknown) => {
+  const schema = await parseSchemaInput(schemaInput);
+
+  if (!schema.openapi) {
+    throw new GraphQLError("OpenAPI version is not defined");
+  }
+
+  const dereferenced = await dereference(schema);
+  const upgraded = upgradeSchema(dereferenced);
+
+  const flattened = traverse(upgraded, (spec) => {
+    if (!spec || typeof spec !== "object" || Array.isArray(spec)) {
+      return spec;
+    }
+    const isSchemaObject =
+      "type" in spec ||
+      "properties" in spec ||
+      "allOf" in spec ||
+      "anyOf" in spec ||
+      "oneOf" in spec;
+
+    if (!isSchemaObject) return spec;
+
+    return flattenAllOf(spec) as typeof spec;
+  }) as OpenAPIDocument;
+
+  return flattened;
+};