@contractkit/plugin-openapi 0.8.1

package/dist/index.js

@@ -0,0 +1,701 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { resolve } from "path";
+
+// src/codegen-openapi.ts
+import { resolveModifiers, resolveSecurity, SECURITY_NONE } from "@contractkit/core";
+function collectRefsFromType(type, out) {
+  switch (type.kind) {
+    case "ref":
+      out.add(type.name);
+      break;
+    case "array":
+      collectRefsFromType(type.item, out);
+      break;
+    case "tuple":
+      for (const item of type.items) collectRefsFromType(item, out);
+      break;
+    case "record":
+      collectRefsFromType(type.value, out);
+      break;
+    case "union":
+    case "discriminatedUnion":
+    case "intersection":
+      for (const member of type.members) collectRefsFromType(member, out);
+      break;
+    case "lazy":
+      collectRefsFromType(type.inner, out);
+      break;
+    case "inlineObject":
+      for (const field of type.fields) collectRefsFromType(field.type, out);
+      break;
+  }
+}
+__name(collectRefsFromType, "collectRefsFromType");
+function collectParamSourceRefs(source, out) {
+  if (!source) return;
+  if (source.kind === "ref") {
+    out.add(source.name);
+    return;
+  }
+  if (source.kind === "params") {
+    for (const p of source.nodes) collectRefsFromType(p.type, out);
+    return;
+  }
+  collectRefsFromType(source.node, out);
+}
+__name(collectParamSourceRefs, "collectParamSourceRefs");
+function collectPublicTypeRefs(opRoots, includeInternal = false) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const opRoot of opRoots) {
+    for (const route of opRoot.routes) {
+      for (const op of route.operations) {
+        if (!includeInternal && resolveModifiers(route, op).includes("internal")) continue;
+        if (op.request) {
+          for (const body of op.request.bodies) collectRefsFromType(body.bodyType, refs);
+        }
+        for (const resp of op.responses) {
+          if (resp.bodyType) collectRefsFromType(resp.bodyType, refs);
+          if (resp.headers) {
+            for (const h of resp.headers) collectRefsFromType(h.type, refs);
+          }
+        }
+        collectParamSourceRefs(route.params, refs);
+        collectParamSourceRefs(op.query, refs);
+        collectParamSourceRefs(op.headers, refs);
+      }
+    }
+  }
+  return refs;
+}
+__name(collectPublicTypeRefs, "collectPublicTypeRefs");
+function computeReachableSchemas(seeds, modelMap) {
+  const reachable = new Set(seeds);
+  const frontier = [
+    ...seeds
+  ];
+  while (frontier.length > 0) {
+    const name = frontier.pop();
+    const model = modelMap.get(name);
+    if (!model) continue;
+    const refs = /* @__PURE__ */ new Set();
+    if (model.type) collectRefsFromType(model.type, refs);
+    for (const field of model.fields) collectRefsFromType(field.type, refs);
+    if (model.bases) for (const b of model.bases) refs.add(b);
+    for (const ref of refs) {
+      if (!reachable.has(ref)) {
+        reachable.add(ref);
+        frontier.push(ref);
+      }
+    }
+  }
+  return reachable;
+}
+__name(computeReachableSchemas, "computeReachableSchemas");
+function generateOpenApi(ctx) {
+  const { contractRoots, opRoots, config, securitySchemes } = ctx;
+  const includeInternal = config.includeInternal ?? false;
+  const doc = {
+    openapi: "3.1.0",
+    info: {
+      title: config.info?.title ?? "API",
+      version: config.info?.version ?? "0.0.1",
+      ...config.info?.description ? {
+        description: config.info.description
+      } : {}
+    }
+  };
+  if (config.servers && config.servers.length > 0) {
+    doc.servers = config.servers;
+  }
+  if (config.security && config.security.length > 0) {
+    doc.security = config.security;
+  }
+  const allSchemas = {};
+  const modelMap = /* @__PURE__ */ new Map();
+  for (const contractRoot of contractRoots) {
+    for (const model of contractRoot.models) {
+      modelMap.set(model.name, model);
+    }
+  }
+  for (const contractRoot of contractRoots) {
+    for (const model of contractRoot.models) {
+      allSchemas[model.name] = modelToSchema(model, modelMap);
+    }
+  }
+  const paths = {};
+  for (const opRoot of opRoots) {
+    for (const route of opRoot.routes) {
+      const oaPath = convertPath(route.path);
+      for (const op of route.operations) {
+        const mods = resolveModifiers(route, op);
+        if (!includeInternal && mods.includes("internal")) continue;
+        if (!paths[oaPath]) paths[oaPath] = {};
+        const operation = buildOperation(route, op);
+        if (mods.includes("deprecated")) operation.deprecated = true;
+        paths[oaPath][op.method] = operation;
+      }
+    }
+  }
+  doc.paths = paths;
+  const schemas = opRoots.length > 0 ? (() => {
+    const reachable = computeReachableSchemas(collectPublicTypeRefs(opRoots, includeInternal), modelMap);
+    const filtered = {};
+    for (const [name, schema] of Object.entries(allSchemas)) {
+      if (reachable.has(name)) filtered[name] = schema;
+    }
+    return filtered;
+  })() : allSchemas;
+  const components = {};
+  if (Object.keys(schemas).length > 0) {
+    components.schemas = schemas;
+  }
+  if (securitySchemes && Object.keys(securitySchemes).length > 0) {
+    components.securitySchemes = securitySchemes;
+  }
+  if (Object.keys(components).length > 0) {
+    doc.components = components;
+  }
+  return toYaml(doc);
+}
+__name(generateOpenApi, "generateOpenApi");
+function convertPath(path) {
+  return path;
+}
+__name(convertPath, "convertPath");
+function modelToSchema(model, modelMap) {
+  if (model.type) {
+    const schema2 = typeToSchema(model.type, modelMap);
+    if (model.description) schema2.description = model.description;
+    return schema2;
+  }
+  const properties = {};
+  const required = [];
+  for (const field of model.fields) {
+    const prop = fieldToSchema(field, modelMap);
+    properties[field.name] = prop;
+    if (!field.optional) {
+      required.push(field.name);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  if (model.bases && model.bases.length > 0) {
+    return {
+      allOf: [
+        ...model.bases.map((b) => ({
+          $ref: `#/components/schemas/${b}`
+        })),
+        schema
+      ]
+    };
+  }
+  if (model.description) {
+    schema.description = model.description;
+  }
+  if (model.deprecated) {
+    schema.deprecated = true;
+  }
+  return schema;
+}
+__name(modelToSchema, "modelToSchema");
+function fieldToSchema(field, modelMap) {
+  let schema = typeToSchema(field.type, modelMap);
+  if (field.nullable) {
+    schema = wrapNullable(schema);
+  }
+  if (field.visibility === "readonly") {
+    schema.readOnly = true;
+  } else if (field.visibility === "writeonly") {
+    schema.writeOnly = true;
+  }
+  if (field.default !== void 0) {
+    schema.default = field.default;
+  }
+  if (field.description) {
+    schema.description = field.description;
+  }
+  if (field.deprecated) {
+    schema.deprecated = true;
+  }
+  return schema;
+}
+__name(fieldToSchema, "fieldToSchema");
+function typeToSchema(type, modelMap) {
+  switch (type.kind) {
+    case "scalar":
+      return scalarToSchema(type);
+    case "array":
+      return arrayToSchema(type, modelMap);
+    case "tuple":
+      return {
+        type: "array",
+        prefixItems: type.items.map((i) => typeToSchema(i, modelMap))
+      };
+    case "record":
+      return {
+        type: "object",
+        additionalProperties: typeToSchema(type.value, modelMap)
+      };
+    case "enum":
+      return {
+        type: "string",
+        enum: type.values
+      };
+    case "literal":
+      return {
+        const: type.value
+      };
+    case "union":
+      return {
+        oneOf: type.members.map((m) => typeToSchema(m, modelMap))
+      };
+    case "discriminatedUnion": {
+      const oneOf = type.members.map((m) => typeToSchema(m, modelMap));
+      const mapping = {};
+      for (const member of type.members) {
+        if (member.kind !== "ref") continue;
+        const literalValues = resolveDiscriminatorLiterals(member.name, type.discriminator, modelMap);
+        if (literalValues.length === 0) continue;
+        for (const v of literalValues) {
+          mapping[v] = `#/components/schemas/${member.name}`;
+        }
+      }
+      const result = {
+        oneOf,
+        discriminator: {
+          propertyName: type.discriminator
+        }
+      };
+      if (Object.keys(mapping).length > 0) {
+        result.discriminator.mapping = mapping;
+      }
+      return result;
+    }
+    case "intersection":
+      return {
+        allOf: type.members.map((m) => typeToSchema(m, modelMap))
+      };
+    case "ref":
+      return {
+        $ref: `#/components/schemas/${type.name}`
+      };
+    case "inlineObject":
+      return inlineObjectToSchema(type.fields, modelMap);
+    case "lazy":
+      return typeToSchema(type.inner, modelMap);
+  }
+}
+__name(typeToSchema, "typeToSchema");
+function resolveDiscriminatorLiterals(modelName, discriminator, modelMap) {
+  if (!modelMap) return [];
+  const model = modelMap.get(modelName);
+  if (!model) return [];
+  const field = model.fields.find((f) => f.name === discriminator);
+  if (!field) return [];
+  if (field.type.kind === "literal") return [
+    String(field.type.value)
+  ];
+  if (field.type.kind === "enum") return field.type.values;
+  return [];
+}
+__name(resolveDiscriminatorLiterals, "resolveDiscriminatorLiterals");
+function scalarToSchema(type) {
+  const s = {};
+  switch (type.name) {
+    case "string":
+      s.type = "string";
+      if (type.min !== void 0) s.minLength = Number(type.min);
+      if (type.max !== void 0) s.maxLength = Number(type.max);
+      if (type.len !== void 0) {
+        s.minLength = type.len;
+        s.maxLength = type.len;
+      }
+      if (type.regex) s.pattern = type.regex;
+      break;
+    case "number":
+      s.type = "number";
+      if (type.min !== void 0) s.minimum = Number(type.min);
+      if (type.max !== void 0) s.maximum = Number(type.max);
+      break;
+    case "int":
+      s.type = "integer";
+      if (type.min !== void 0) s.minimum = Number(type.min);
+      if (type.max !== void 0) s.maximum = Number(type.max);
+      break;
+    case "bigint":
+      s.type = "integer";
+      s.format = "int64";
+      break;
+    case "boolean":
+      s.type = "boolean";
+      break;
+    case "date":
+      s.type = "string";
+      s.format = "date";
+      break;
+    case "datetime":
+      s.type = "string";
+      s.format = "date-time";
+      break;
+    case "duration":
+      s.type = "string";
+      s.format = "duration";
+      break;
+    case "email":
+      s.type = "string";
+      s.format = "email";
+      break;
+    case "url":
+      s.type = "string";
+      s.format = "uri";
+      break;
+    case "uuid":
+      s.type = "string";
+      s.format = "uuid";
+      break;
+    case "unknown":
+      break;
+    case "null":
+      s.type = "null";
+      break;
+    case "object":
+      s.type = "object";
+      break;
+    case "binary":
+      s.type = "string";
+      s.format = "binary";
+      break;
+    case "json":
+      break;
+  }
+  return s;
+}
+__name(scalarToSchema, "scalarToSchema");
+function arrayToSchema(type, modelMap) {
+  const s = {
+    type: "array",
+    items: typeToSchema(type.item, modelMap)
+  };
+  if (type.min !== void 0) s.minItems = type.min;
+  if (type.max !== void 0) s.maxItems = type.max;
+  return s;
+}
+__name(arrayToSchema, "arrayToSchema");
+function inlineObjectToSchema(fields, modelMap) {
+  const properties = {};
+  const required = [];
+  for (const field of fields) {
+    properties[field.name] = fieldToSchema(field, modelMap);
+    if (!field.optional) {
+      required.push(field.name);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) schema.required = required;
+  return schema;
+}
+__name(inlineObjectToSchema, "inlineObjectToSchema");
+function wrapNullable(schema) {
+  if (schema.$ref) {
+    return {
+      oneOf: [
+        schema,
+        {
+          type: "null"
+        }
+      ]
+    };
+  }
+  if (typeof schema.type === "string") {
+    schema.type = [
+      schema.type,
+      "null"
+    ];
+  }
+  return schema;
+}
+__name(wrapNullable, "wrapNullable");
+function buildOperation(route, op) {
+  const operation = {};
+  if (op.sdk) {
+    operation.operationId = op.sdk;
+  } else if (op.service) {
+    const methodPart = op.service.split(".").pop();
+    if (methodPart) operation.operationId = methodPart;
+  }
+  if (op.description) {
+    operation.description = op.description;
+  }
+  const parameters = [];
+  if (route.params) {
+    parameters.push(...paramSourceToParams(route.params, "path"));
+  }
+  if (op.query) {
+    parameters.push(...paramSourceToParams(op.query, "query"));
+  }
+  if (op.headers) {
+    parameters.push(...paramSourceToParams(op.headers, "header"));
+  }
+  if (parameters.length > 0) {
+    operation.parameters = parameters;
+  }
+  if (op.request && op.request.bodies.length > 0) {
+    const content = {};
+    for (const body of op.request.bodies) {
+      content[body.contentType] = {
+        schema: typeToSchema(body.bodyType)
+      };
+    }
+    operation.requestBody = {
+      required: true,
+      content
+    };
+  }
+  const effectiveSecurity = resolveSecurity(route, op);
+  if (effectiveSecurity === SECURITY_NONE) {
+    operation.security = [];
+  }
+  const responses = {};
+  for (const resp of op.responses) {
+    const statusKey = String(resp.statusCode);
+    const responseObject = {
+      description: statusDescription(resp.statusCode)
+    };
+    if (resp.bodyType && resp.contentType) {
+      responseObject.content = {
+        [resp.contentType]: {
+          schema: typeToSchema(resp.bodyType)
+        }
+      };
+    }
+    if (resp.headers && resp.headers.length > 0) {
+      const headers = {};
+      for (const h of resp.headers) {
+        const headerObject = {
+          schema: typeToSchema(h.type)
+        };
+        if (!h.optional) headerObject.required = true;
+        if (h.description) headerObject.description = h.description;
+        headers[h.name] = headerObject;
+      }
+      responseObject.headers = headers;
+    }
+    responses[statusKey] = responseObject;
+  }
+  if (Object.keys(responses).length > 0) {
+    operation.responses = responses;
+  }
+  return operation;
+}
+__name(buildOperation, "buildOperation");
+function paramSourceToParams(source, location) {
+  if (source.kind === "ref") {
+    return [
+      {
+        name: source.name,
+        in: location,
+        required: location === "path",
+        schema: {
+          $ref: `#/components/schemas/${source.name}`
+        }
+      }
+    ];
+  }
+  if (source.kind === "params") {
+    return source.nodes.map((p) => ({
+      name: p.name,
+      in: location,
+      required: location === "path",
+      schema: typeToSchema(p.type)
+    }));
+  }
+  if (source.node.kind === "inlineObject") {
+    return source.node.fields.map((f) => ({
+      name: f.name,
+      in: location,
+      required: location === "path" ? true : !f.optional,
+      schema: typeToSchema(f.type)
+    }));
+  }
+  if (source.node.kind === "ref") {
+    return [
+      {
+        name: source.node.name,
+        in: location,
+        required: location === "path",
+        schema: {
+          $ref: `#/components/schemas/${source.node.name}`
+        }
+      }
+    ];
+  }
+  return [];
+}
+__name(paramSourceToParams, "paramSourceToParams");
+function statusDescription(code) {
+  const descriptions = {
+    200: "Successful response",
+    201: "Created",
+    204: "No content",
+    400: "Bad request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not found",
+    409: "Conflict",
+    422: "Unprocessable entity",
+    500: "Internal server error"
+  };
+  return descriptions[code] ?? `Response ${code}`;
+}
+__name(statusDescription, "statusDescription");
+function toYaml(value, indent = 0) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "string") {
+    return yamlString(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")) {
+      const items = value.map((v) => typeof v === "string" ? yamlString(v) : String(v));
+      const inline = `[${items.join(", ")}]`;
+      if (inline.length < 80) return inline;
+    }
+    const lines = [];
+    const pad = "  ".repeat(indent);
+    for (const item of value) {
+      if (isPlainObject(item)) {
+        const entries = Object.entries(item);
+        if (entries.length > 0) {
+          const [firstKey, firstVal] = entries[0];
+          const firstValStr = isComplex(firstVal) ? `
+${toYamlValue(firstVal, indent + 2)}` : ` ${toYaml(firstVal, indent + 2)}`;
+          lines.push(`${pad}- ${yamlKey(firstKey)}:${firstValStr}`);
+          for (let i = 1; i < entries.length; i++) {
+            const [k, v] = entries[i];
+            const valStr = isComplex(v) ? `
+${toYamlValue(v, indent + 2)}` : ` ${toYaml(v, indent + 2)}`;
+            lines.push(`${pad}  ${yamlKey(k)}:${valStr}`);
+          }
+        } else {
+          lines.push(`${pad}- {}`);
+        }
+      } else {
+        lines.push(`${pad}- ${toYaml(item, indent + 1)}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  if (isPlainObject(value)) {
+    const obj = value;
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    const pad = "  ".repeat(indent);
+    const lines = [];
+    for (const [key, val] of entries) {
+      if (isComplex(val)) {
+        lines.push(`${pad}${yamlKey(key)}:`);
+        lines.push(toYamlValue(val, indent + 1));
+      } else {
+        lines.push(`${pad}${yamlKey(key)}: ${toYaml(val, indent + 1)}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  return String(value);
+}
+__name(toYaml, "toYaml");
+function toYamlValue(value, indent) {
+  if (Array.isArray(value)) {
+    return toYaml(value, indent);
+  }
+  if (isPlainObject(value)) {
+    return toYaml(value, indent);
+  }
+  return "  ".repeat(indent) + toYaml(value, indent);
+}
+__name(toYamlValue, "toYamlValue");
+function isComplex(value) {
+  if (Array.isArray(value)) {
+    if (value.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")) {
+      const items = value.map((v) => typeof v === "string" ? yamlString(v) : String(v));
+      return `[${items.join(", ")}]`.length >= 80;
+    }
+    return true;
+  }
+  return isPlainObject(value);
+}
+__name(isComplex, "isComplex");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function yamlString(s) {
+  if (s === "") return "''";
+  if (/^[\w./-]+$/.test(s) && !/^(true|false|null|yes|no|on|off)$/i.test(s) && !/^\d/.test(s)) {
+    return s;
+  }
+  return `'${s.replace(/'/g, "''")}'`;
+}
+__name(yamlString, "yamlString");
+function yamlKey(key) {
+  if (/^[\w-]+$/.test(key) && !/^(true|false|null|yes|no|on|off)$/i.test(key)) {
+    return key;
+  }
+  return `'${key.replace(/'/g, "''")}'`;
+}
+__name(yamlKey, "yamlKey");
+
+// src/index.ts
+var plugin = {
+  name: "openapi",
+  cacheKey: "openapi",
+  async generateTargets({ contractRoots, opRoots }, ctx) {
+    const { securitySchemes, ...openapiConfig } = ctx.options;
+    const base = openapiConfig.baseDir ? resolve(ctx.rootDir, openapiConfig.baseDir) : ctx.rootDir;
+    const outPath = resolve(base, openapiConfig.output ?? "openapi.yaml");
+    ctx.emitFile(outPath, generateOpenApi({
+      contractRoots,
+      opRoots,
+      config: openapiConfig,
+      securitySchemes
+    }));
+  }
+};
+var index_default = plugin;
+function createOpenApiPlugin(openapiConfig, rootDir, securitySchemes) {
+  return {
+    name: "openapi",
+    cacheKey: `openapi:${JSON.stringify(openapiConfig)}`,
+    async generateTargets({ contractRoots, opRoots }, ctx) {
+      const base = openapiConfig.baseDir ? resolve(rootDir, openapiConfig.baseDir) : rootDir;
+      const outPath = resolve(base, openapiConfig.output ?? "openapi.yaml");
+      const content = generateOpenApi({
+        contractRoots,
+        opRoots,
+        config: openapiConfig,
+        securitySchemes
+      });
+      ctx.emitFile(outPath, content);
+    }
+  };
+}
+__name(createOpenApiPlugin, "createOpenApiPlugin");
+export {
+  createOpenApiPlugin,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map