@c4a/extract-contract 0.7.4 → 0.7.8

package/index.js

@@ -21512,6 +21512,12 @@ function parseGraphQlSources(files) {
         name,
         extension,
         field_names: fields.map((field) => field.name.value).sort(),
+        fields: fields.map((field) => ({
+          name: field.name.value,
+          type: import_graphql.print(field.type),
+          optional: field.type.kind !== import_graphql.Kind.NON_NULL_TYPE,
+          ...field.description === undefined ? {} : { description: field.description.value }
+        })),
         locator: locator(document.path, definition, `type:${name}${extension ? ":extension" : ""}`)
       };
       catalog.types.push(type);
@@ -21539,6 +21545,13 @@ function parseGraphQlSources(files) {
         const fieldName = field.name.value;
         const operation = { operation_ref: `${document.path}#root:${name}:field:${fieldName}`, protocol: "graphql", operation_kind: operationKind, name: fieldName, parent: name, deprecated: deprecated(field), locator: locator(document.path, field, `operation:${operationKind}:${name}.${fieldName}`) };
         catalog.operations.push(operation);
+        operation.fields = [...(field.arguments ?? []).map((argument) => ({
+          name: argument.name.value,
+          type: import_graphql.print(argument.type),
+          optional: argument.type.kind !== import_graphql.Kind.NON_NULL_TYPE || argument.defaultValue !== undefined,
+          location: "argument",
+          ...argument.defaultValue === undefined ? {} : { defaultValue: import_graphql.print(argument.defaultValue) }
+        })), { name: "return", type: import_graphql.print(field.type), optional: field.type.kind !== import_graphql.Kind.NON_NULL_TYPE, location: "response" }];
       }
     }
   }
@@ -21546,10 +21559,123 @@ function parseGraphQlSources(files) {
 }
 
 // src/openApiParser.ts
-var import_yaml = __toESM(require_dist(), 1);
 import { posix } from "node:path";
+
+// src/openApiFields.ts
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+function resolved(value, root, seen = new Set) {
+  const schema = record(value);
+  const ref = schema.$ref;
+  if (typeof ref !== "string" || !ref.startsWith("#/") || seen.has(ref))
+    return schema;
+  seen.add(ref);
+  let target = root;
+  for (const part of ref.slice(2).split("/"))
+    target = record(target)[part.replace(/~1/gu, "/").replace(/~0/gu, "~")];
+  return target === undefined ? schema : { ...resolved(target, root, seen), ...schema };
+}
+function declaredType(schema) {
+  if (typeof schema.$ref === "string")
+    return schema.$ref;
+  if (schema.type === "array")
+    return `Array<${declaredType(record(schema.items))}>`;
+  if (Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) {
+    return (schema.oneOf ?? schema.anyOf).map((item) => declaredType(record(item))).join(" | ");
+  }
+  return Array.isArray(schema.type) ? schema.type.join(" | ") : typeof schema.type === "string" ? schema.type : "not declared";
+}
+function constraints(schema) {
+  return Object.fromEntries([
+    "enum",
+    "const",
+    "format",
+    "pattern",
+    "minimum",
+    "maximum",
+    "minLength",
+    "maxLength",
+    "minItems",
+    "maxItems",
+    "nullable",
+    "readOnly",
+    "writeOnly",
+    "additionalProperties"
+  ].filter((key) => schema[key] !== undefined).map((key) => [key, schema[key]]));
+}
+function openApiFields(value, depth = 0, root = value) {
+  if (depth > 8)
+    return [];
+  const schema = resolved(value, root);
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const own = Object.entries(record(schema.properties)).map(([name, raw]) => {
+    const field = resolved(raw, root);
+    return {
+      name,
+      type: declaredType(field),
+      constraints: constraints(field),
+      optional: !required.has(name),
+      ...field.default === undefined ? {} : { defaultValue: JSON.stringify(field.default) },
+      ...typeof field.description === "string" ? { description: field.description } : {},
+      ...field.properties === undefined ? {} : { fields: openApiFields(field, depth + 1, root) }
+    };
+  });
+  const inherited = Array.isArray(schema.allOf) ? schema.allOf.flatMap((part) => openApiFields(part, depth + 1, root)) : [];
+  return [...new Map([...inherited, ...own].map((field) => [field.name, field])).values()];
+}
+function openApiOperationFields(path, operation, root = {}) {
+  const parameters = new Map;
+  for (const raw of [
+    ...Array.isArray(path.parameters) ? path.parameters : [],
+    ...Array.isArray(operation.parameters) ? operation.parameters : []
+  ]) {
+    const parameter = resolved(raw, root);
+    parameters.set(`${parameter.in}/${parameter.name}`, parameter);
+  }
+  const fields = [...parameters.values()].map((parameter) => {
+    const schema = resolved(parameter.schema ?? parameter, root);
+    return {
+      name: String(parameter.name ?? parameter.$ref ?? "parameter"),
+      type: declaredType(schema),
+      constraints: constraints(schema),
+      optional: parameter.required !== true,
+      location: String(parameter.in ?? "reference"),
+      ...schema.default === undefined ? {} : { defaultValue: JSON.stringify(schema.default) },
+      ...typeof parameter.description === "string" ? { description: parameter.description } : {}
+    };
+  });
+  const body = resolved(operation.requestBody, root);
+  for (const [media, value] of Object.entries(record(body.content))) {
+    const schema = resolved(record(value).schema, root);
+    fields.push({
+      name: `request (${media})`,
+      type: declaredType(schema),
+      constraints: constraints(schema),
+      optional: body.required !== true,
+      location: "body",
+      fields: openApiFields(schema, 0, root)
+    });
+  }
+  for (const [status, response] of Object.entries(record(operation.responses))) {
+    const content = record(resolved(response, root).content);
+    for (const [media, value] of Object.entries(content)) {
+      const schema = resolved(record(value).schema, root);
+      fields.push({
+        name: `response ${status} (${media})`,
+        type: declaredType(schema),
+        constraints: constraints(schema),
+        optional: false,
+        location: "response",
+        fields: openApiFields(schema, 0, root)
+      });
+    }
+  }
+  return fields;
+}
+
+// src/openApiParser.ts
+var import_yaml = __toESM(require_dist(), 1);
 var HTTP_METHODS = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace", "query"]);
-function record(value) {
+function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function portablePath(path) {
@@ -21580,7 +21706,7 @@ function valueAt(root, path) {
         return;
       continue;
     }
-    const item = record(current);
+    const item = record2(current);
     if (item === null || !(part in item))
       return;
     current = item[part];
@@ -21615,7 +21741,7 @@ function collectRefs(parsed) {
       value.forEach((item2, index) => visit(item2, [...path, String(index)], inheritedBaseId));
       return;
     }
-    const item = record(value);
+    const item = record2(value);
     if (item === null)
       return;
     const underBaseId = inheritedBaseId || typeof item.$id === "string";
@@ -21632,23 +21758,24 @@ function collectRefs(parsed) {
 }
 function schemaTypes(parsed, root) {
   const candidates = [];
-  const components = record(root.components);
-  const schemas = record(components?.schemas);
-  const definitions = record(root.definitions);
+  const components = record2(root.components);
+  const schemas = record2(components?.schemas);
+  const definitions = record2(root.definitions);
   if (schemas !== null)
     candidates.push(...Object.entries(schemas).map(([name, value]) => ({ path: ["components", "schemas", name], value })));
   if (definitions !== null)
     candidates.push(...Object.entries(definitions).map(([name, value]) => ({ path: ["definitions", name], value })));
   return candidates.map(({ path, value }) => {
     const name = path.at(-1);
-    const schema = record(value);
+    const schema = record2(value);
     return {
       type_ref: `${parsed.path}#/${path.join("/")}`,
       protocol: "openapi",
       kind: typeof schema?.type === "string" ? schema.type : "schema",
       name,
       extension: false,
-      field_names: Object.keys(record(schema?.properties) ?? {}).sort(),
+      field_names: Object.keys(record2(schema?.properties) ?? {}).sort(),
+      fields: openApiFields(schema, 0, root),
       locator: yamlLocator(parsed, path, `schema:${name}`)
     };
   });
@@ -21656,11 +21783,11 @@ function schemaTypes(parsed, root) {
 function pathCatalog(parsed, root, key) {
   const endpoints = [];
   const operations = [];
-  const paths = record(root[key]);
+  const paths = record2(root[key]);
   if (paths === null)
     return { endpoints, operations };
   for (const [route, rawPathItem] of Object.entries(paths).sort(([left], [right]) => left.localeCompare(right))) {
-    const pathItem = record(rawPathItem);
+    const pathItem = record2(rawPathItem);
     if (pathItem === null)
       continue;
     const parent = key === "paths" ? route : `webhook:${route}`;
@@ -21668,7 +21795,7 @@ function pathCatalog(parsed, root, key) {
     for (const [method, rawOperation] of Object.entries(pathItem)) {
       if (!HTTP_METHODS.has(method.toLowerCase()))
         continue;
-      const operation = record(rawOperation);
+      const operation = record2(rawOperation);
       if (operation === null)
         continue;
       const operationId = typeof operation.operationId === "string" ? operation.operationId : `${method.toLowerCase()} ${parent}`;
@@ -21679,6 +21806,7 @@ function pathCatalog(parsed, root, key) {
         name: operationId,
         parent,
         deprecated: operation.deprecated === true,
+        fields: openApiOperationFields(pathItem, operation, root),
         locator: yamlLocator(parsed, [key, route, method], `operation:${method.toLowerCase()}:${parent}`)
       });
     }
@@ -21732,7 +21860,7 @@ function analyzeDocument(input) {
     catalog.diagnostics.push({ code: "contract-source-unsupported", severity: "error", locator: { path: parsed.path, line: 1, column: 1, qualified_item_path: "file" }, detail: parsed.parseError });
     return catalog;
   }
-  const root = record(parsed.root);
+  const root = record2(parsed.root);
   if (input.primary && root === null) {
     catalog.disposition = "unsupported";
     catalog.diagnostics.push({ code: "contract-source-unsupported", severity: "error", locator: { path: parsed.path, line: 1, column: 1, qualified_item_path: "file" }, detail: "contract document root must be an object" });
@@ -21795,7 +21923,7 @@ function parseOpenApiSources(files) {
     if (/\.(?:json|ya?ml)$/iu.test(path))
       candidates.set(path, parseYaml(path, source));
   }
-  const roots = [...candidates.values()].filter((item) => record(item.root)?.openapi !== undefined || record(item.root)?.swagger !== undefined || item.marker && item.parseError !== null);
+  const roots = [...candidates.values()].filter((item) => record2(item.root)?.openapi !== undefined || record2(item.root)?.swagger !== undefined || item.marker && item.parseError !== null);
   const rootPaths = new Set(roots.map((item) => item.path));
   const reachable = new Set(rootPaths);
   const graph = new Map;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/extract-contract",
-  "version": "0.7.4",
+  "version": "0.7.8",
   "type": "module",
   "description": "OpenAPI and GraphQL contract catalog adapter for Context",
   "license": "MIT",