@lukoweb/apitogo 0.1.23 → 0.1.37

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

@@ -1,84 +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;
-};
+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

@@ -1,32 +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;
-};
+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

@@ -1,129 +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;
-};
+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;
+};