@contractkit/plugin-bruno 0.9.1

package/dist/index.js

@@ -0,0 +1,631 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { resolve, basename as basename2, dirname } from "path";
+import { existsSync, readFileSync, rmSync, readdirSync, rmdirSync } from "fs";
+
+// src/codegen-bruno.ts
+import { resolveSecurity, resolveModifiers, SECURITY_NONE } from "@contractkit/core";
+import { basename } from "path";
+var MANIFEST_FILENAME = ".contractkit-bruno-manifest.json";
+function generateOpenCollection(roots, options) {
+  const files = [];
+  const modelMap = buildModelMap(options.contractRoots ?? []);
+  const authOpts = options.auth;
+  const defaultScheme = authOpts?.defaultScheme ? authOpts.schemes?.[authOpts.defaultScheme] : void 0;
+  const randomExamples = options.randomExamples ?? false;
+  const includeInternal = options.includeInternal ?? true;
+  files.push({
+    relativePath: "opencollection.yml",
+    content: generateCollectionRoot(options.collectionName, defaultScheme)
+  });
+  files.push({
+    relativePath: "environments/local.yml",
+    content: generateEnvFile(defaultScheme)
+  });
+  for (let rootIdx = 0; rootIdx < roots.length; rootIdx++) {
+    const root = roots[rootIdx];
+    const folder = root.meta["area"] ? slugifyName(root.meta["area"]) : deriveFolderName(root.file);
+    const displayName = (root.meta["area"] ?? folder).charAt(0).toUpperCase() + (root.meta["area"] ?? folder).slice(1);
+    files.push({
+      relativePath: `${folder}/folder.yml`,
+      content: generateFolderFile(displayName, rootIdx + 1)
+    });
+    const subarea = root.meta["subarea"];
+    const subareaSlug = subarea ? slugifyName(subarea) : void 0;
+    const requestDir = subareaSlug ? `${folder}/${subareaSlug}` : folder;
+    if (subareaSlug) {
+      const subareaDisplayName = subarea.charAt(0).toUpperCase() + subarea.slice(1);
+      files.push({
+        relativePath: `${requestDir}/folder.yml`,
+        content: generateFolderFile(subareaDisplayName, 1)
+      });
+    }
+    let seq = 1;
+    for (const route of root.routes) {
+      for (const op of route.operations) {
+        if (!includeInternal && resolveModifiers(route, op).includes("internal")) continue;
+        const requestName = op.name ?? route.path;
+        const fileName = op.name ? `${slugifyName(op.name)}.yml` : `${op.method}-${sanitizePath(route.path)}.yml`;
+        files.push({
+          relativePath: `${requestDir}/${fileName}`,
+          content: generateRequestFile(route, op, requestName, seq, modelMap, root, defaultScheme, randomExamples)
+        });
+        seq++;
+      }
+    }
+  }
+  const trackedPaths = [
+    ...files.map((f) => f.relativePath),
+    MANIFEST_FILENAME
+  ].sort();
+  files.push({
+    relativePath: MANIFEST_FILENAME,
+    content: JSON.stringify({
+      files: trackedPaths
+    }, null, 2) + "\n"
+  });
+  return files;
+}
+__name(generateOpenCollection, "generateOpenCollection");
+function parseManifest(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed?.files) && parsed.files.every((f) => typeof f === "string")) {
+      return parsed.files;
+    }
+  } catch {
+  }
+  return [];
+}
+__name(parseManifest, "parseManifest");
+function generateCollectionRoot(name, scheme) {
+  const lines = [
+    `opencollection: "1.0.0"`,
+    `info:`,
+    `  name: ${yamlString(name)}`
+  ];
+  if (scheme) {
+    lines.push(``);
+    lines.push(`request:`);
+    lines.push(...renderAuthBlock(scheme, "  "));
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+__name(generateCollectionRoot, "generateCollectionRoot");
+function generateEnvFile(scheme) {
+  const lines = [
+    `name: Local`,
+    `variables:`,
+    `  - name: baseUrl`,
+    `    value: "http://localhost:3000"`
+  ];
+  if (scheme) {
+    for (const varName of authEnvVarNames(scheme)) {
+      lines.push(`  - name: ${varName}`);
+      lines.push(`    value: ""`);
+    }
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+__name(generateEnvFile, "generateEnvFile");
+function generateFolderFile(name, seq) {
+  return [
+    `info:`,
+    `  name: ${yamlString(name)}`,
+    `  type: folder`,
+    `  seq: ${seq}`,
+    ``
+  ].join("\n");
+}
+__name(generateFolderFile, "generateFolderFile");
+function generateRequestFile(route, op, name, seq, modelMap, root, defaultScheme, randomExamples = false) {
+  const lines = [];
+  lines.push(`info:`);
+  lines.push(`  name: ${yamlString(name)}`);
+  lines.push(`  type: http`);
+  lines.push(`  seq: ${seq}`);
+  lines.push(``);
+  lines.push(`http:`);
+  lines.push(`  method: ${op.method.toUpperCase()}`);
+  lines.push(`  url: ${yamlString(`{{baseUrl}}${openCollectionPath(route.path)}`)}`);
+  const pathParams = extractPathParamNames(route.path).map((n) => ({
+    name: n,
+    type: findParamType(route.params, n, modelMap),
+    optional: false,
+    kind: "path"
+  }));
+  const queryParams = op.query ? expandParamSource(op.query, modelMap).map((e) => ({
+    ...e,
+    kind: "query"
+  })) : [];
+  const allParams = [
+    ...pathParams,
+    ...queryParams
+  ];
+  if (allParams.length > 0) {
+    lines.push(`  params:`);
+    for (const p of allParams) {
+      lines.push(`    - name: ${p.name}`);
+      lines.push(`      value: ${paramExampleValue(p.type, p.default, randomExamples)}`);
+      lines.push(`      type: ${p.kind}`);
+      if (p.optional && p.kind === "query") lines.push(`      disabled: true`);
+    }
+  }
+  if (op.headers) {
+    const headerEntries = expandParamSource(op.headers, modelMap);
+    if (headerEntries.length > 0) {
+      lines.push(`  headers:`);
+      for (const h of headerEntries) {
+        lines.push(`    - name: ${h.name}`);
+        lines.push(`      value: ${paramExampleValue(h.type, h.default, randomExamples)}`);
+        if (h.optional) lines.push(`      disabled: true`);
+      }
+    }
+  }
+  if (defaultScheme) {
+    const security = root ? resolveSecurity(route, op, root) : op.security ?? route.security;
+    if (security === SECURITY_NONE) {
+      lines.push(`  auth:`);
+      lines.push(`    type: none`);
+    } else {
+      lines.push(`  auth: inherit`);
+    }
+  }
+  if (op.request && op.request.bodies.length > 0) {
+    const preferredOrder = [
+      "application/json",
+      "application/x-www-form-urlencoded",
+      "multipart/form-data"
+    ];
+    const primary = preferredOrder.map((ct) => op.request.bodies.find((b) => b.contentType === ct)).find((b) => b !== void 0) ?? op.request.bodies[0];
+    lines.push(`  body:`);
+    if (primary.contentType === "multipart/form-data") {
+      lines.push(`    type: multipart-form`);
+      lines.push(`    data: []`);
+    } else if (primary.contentType === "application/x-www-form-urlencoded") {
+      lines.push(`    type: form-urlencoded`);
+      lines.push(`    data: []`);
+    } else {
+      const json = JSON.stringify(typeToExampleValue(primary.bodyType, modelMap, randomExamples), null, 2);
+      lines.push(`    type: json`);
+      lines.push(`    data: |`);
+      for (const jsonLine of json.split("\n")) {
+        lines.push(`      ${jsonLine}`);
+      }
+    }
+  }
+  const expectedStatus = pickAssertionStatus(op.responses);
+  const assertedResponse = op.responses.find((r) => r.statusCode === expectedStatus);
+  const requiredHeaders = (assertedResponse?.headers ?? []).filter((h) => !h.optional);
+  if (expectedStatus !== void 0) {
+    lines.push(``);
+    lines.push(`runtime:`);
+    lines.push(`  assertions:`);
+    lines.push(`    - expression: res.status`);
+    lines.push(`      operator: eq`);
+    lines.push(`      value: "${expectedStatus}"`);
+    for (const h of requiredHeaders) {
+      lines.push(`    - expression: res.headers["${h.name.toLowerCase()}"]`);
+      lines.push(`      operator: isDefined`);
+      lines.push(`      value: ""`);
+    }
+  }
+  const docs = buildRequestDocs(route, op, assertedResponse);
+  if (docs) {
+    lines.push(``);
+    lines.push(`docs: |-`);
+    for (const docLine of docs.split("\n")) {
+      lines.push(`  ${docLine}`);
+    }
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+__name(generateRequestFile, "generateRequestFile");
+function pickAssertionStatus(responses) {
+  const success = responses.find((r) => r.statusCode >= 200 && r.statusCode < 300);
+  return success?.statusCode ?? responses[0]?.statusCode;
+}
+__name(pickAssertionStatus, "pickAssertionStatus");
+function buildRequestDocs(route, op, assertedResponse) {
+  const parts = [];
+  if (route.description) parts.push(route.description.trim());
+  if (op.description) parts.push(op.description.trim());
+  const headers = assertedResponse?.headers ?? [];
+  if (headers.length > 0) {
+    const lines = [
+      "**Response headers**",
+      ""
+    ];
+    for (const h of headers) {
+      const tag = h.optional ? "optional" : "required";
+      const desc = h.description ? ` \u2014 ${h.description}` : "";
+      lines.push(`- \`${h.name}\` (${tag})${desc}`);
+    }
+    parts.push(lines.join("\n"));
+  }
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+__name(buildRequestDocs, "buildRequestDocs");
+function renderAuthBlock(scheme, indent) {
+  const i = indent;
+  if (scheme.type === "http" && scheme.scheme === "bearer") {
+    return [
+      `${i}auth:`,
+      `${i}  type: bearer`,
+      `${i}  token: "{{token}}"`
+    ];
+  }
+  if (scheme.type === "http" && scheme.scheme === "basic") {
+    return [
+      `${i}auth:`,
+      `${i}  type: basic`,
+      `${i}  username: "{{username}}"`,
+      `${i}  password: "{{password}}"`
+    ];
+  }
+  if (scheme.type === "apiKey" && scheme.in === "header") {
+    const headerName = scheme.name ?? "X-Api-Key";
+    return [
+      `${i}auth:`,
+      `${i}  type: apikey`,
+      `${i}  key: ${headerName}`,
+      `${i}  value: "{{apiKey}}"`,
+      `${i}  placement: header`
+    ];
+  }
+  return [];
+}
+__name(renderAuthBlock, "renderAuthBlock");
+function authEnvVarNames(scheme) {
+  if (scheme.type === "http" && scheme.scheme === "bearer") return [
+    "token"
+  ];
+  if (scheme.type === "http" && scheme.scheme === "basic") return [
+    "username",
+    "password"
+  ];
+  if (scheme.type === "apiKey") return [
+    "apiKey"
+  ];
+  return [];
+}
+__name(authEnvVarNames, "authEnvVarNames");
+function buildModelMap(contractRoots) {
+  const map = /* @__PURE__ */ new Map();
+  for (const root of contractRoots) {
+    for (const model of root.models) {
+      map.set(model.name, model);
+    }
+  }
+  return map;
+}
+__name(buildModelMap, "buildModelMap");
+function resolveModelFields(model, modelMap) {
+  const collected = [];
+  if (model.bases) {
+    for (const base of model.bases) {
+      const baseModel = modelMap.get(base);
+      if (baseModel) collected.push(...resolveModelFields(baseModel, modelMap));
+    }
+  }
+  return [
+    ...collected,
+    ...model.fields
+  ];
+}
+__name(resolveModelFields, "resolveModelFields");
+function expandParamSource(source, modelMap) {
+  if (source.kind === "params") {
+    return source.nodes.map((n) => ({
+      name: n.name,
+      type: n.type,
+      default: n.default,
+      optional: n.optional
+    }));
+  }
+  if (source.kind === "ref") {
+    const model = modelMap.get(source.name);
+    if (model) {
+      return resolveModelFields(model, modelMap).filter((f) => f.visibility !== "readonly").map((f) => ({
+        name: f.name,
+        type: f.type,
+        default: f.default,
+        optional: f.optional
+      }));
+    }
+    const name = source.name.charAt(0).toLowerCase() + source.name.slice(1);
+    return [
+      {
+        name,
+        type: void 0,
+        optional: false
+      }
+    ];
+  }
+  if (source.node.kind === "inlineObject") {
+    return source.node.fields.map((f) => ({
+      name: f.name,
+      type: f.type,
+      default: f.default,
+      optional: f.optional
+    }));
+  }
+  return [];
+}
+__name(expandParamSource, "expandParamSource");
+function findParamType(source, name, modelMap) {
+  if (!source) return void 0;
+  if (source.kind === "params") return source.nodes.find((n) => n.name === name)?.type;
+  if (source.kind === "ref") {
+    const model = modelMap.get(source.name);
+    if (model) return resolveModelFields(model, modelMap).find((f) => f.name === name)?.type;
+  }
+  if (source.kind === "type" && source.node.kind === "inlineObject") {
+    return source.node.fields.find((f) => f.name === name)?.type;
+  }
+  return void 0;
+}
+__name(findParamType, "findParamType");
+function paramExampleValue(type, defaultValue, randomExamples = false) {
+  if (defaultValue !== void 0) return `"${defaultValue}"`;
+  if (!type) return '""';
+  if (type.kind === "enum") return type.values.length > 0 ? `"${type.values[0]}"` : '""';
+  if (type.kind === "literal") return `"${type.value}"`;
+  if (type.kind !== "scalar") return '""';
+  if (randomExamples) {
+    const random = randomScalarTemplate(type.name);
+    if (random !== void 0) return `"${random}"`;
+  }
+  switch (type.name) {
+    case "uuid":
+      return '"00000000-0000-0000-0000-000000000000"';
+    case "email":
+      return '"user@example.com"';
+    case "url":
+      return '"https://example.com"';
+    case "number":
+    case "int":
+    case "bigint":
+      return '"0"';
+    case "boolean":
+      return '"true"';
+    case "date":
+      return '"2024-01-01"';
+    case "time":
+      return '"00:00:00"';
+    case "datetime":
+      return '"2024-01-01T00:00:00Z"';
+    case "duration":
+      return '"PT1H"';
+    default:
+      return '""';
+  }
+}
+__name(paramExampleValue, "paramExampleValue");
+function randomScalarTemplate(name) {
+  switch (name) {
+    case "uuid":
+      return "{{$randomUUID}}";
+    case "email":
+      return "{{$randomEmail}}";
+    case "url":
+      return "{{$randomUrl}}";
+    case "number":
+    case "int":
+    case "bigint":
+      return "{{$randomInt}}";
+    case "boolean":
+      return "{{$randomBoolean}}";
+    case "datetime":
+      return "{{$isoTimestamp}}";
+    default:
+      return void 0;
+  }
+}
+__name(randomScalarTemplate, "randomScalarTemplate");
+function typeToExampleValue(type, modelMap, randomExamples = false) {
+  switch (type.kind) {
+    case "scalar":
+      switch (type.name) {
+        case "string":
+          return "";
+        case "email":
+          return randomExamples ? "{{$randomEmail}}" : "user@example.com";
+        case "url":
+          return randomExamples ? "{{$randomUrl}}" : "https://example.com";
+        case "uuid":
+          return randomExamples ? "{{$randomUUID}}" : "00000000-0000-0000-0000-000000000000";
+        case "number":
+        case "int":
+        case "bigint":
+          return 0;
+        case "boolean":
+          return true;
+        case "date":
+          return "2024-01-01";
+        case "time":
+          return "00:00:00";
+        case "datetime":
+          return randomExamples ? "{{$isoTimestamp}}" : "2024-01-01T00:00:00Z";
+        case "duration":
+          return "PT1H";
+        case "null":
+          return null;
+        default:
+          return null;
+      }
+    case "enum":
+      return type.values[0] ?? "";
+    case "literal":
+      return type.value;
+    case "array":
+      return [
+        typeToExampleValue(type.item, modelMap, randomExamples)
+      ];
+    case "tuple":
+      return type.items.map((t) => typeToExampleValue(t, modelMap, randomExamples));
+    case "record":
+      return {};
+    case "union":
+      return type.members.length > 0 ? typeToExampleValue(type.members[0], modelMap, randomExamples) : null;
+    case "discriminatedUnion":
+      return type.members.length > 0 ? typeToExampleValue(type.members[0], modelMap, randomExamples) : null;
+    case "intersection":
+      return {};
+    case "ref": {
+      const model = modelMap.get(type.name);
+      if (!model) return {};
+      if (model.type) return typeToExampleValue(model.type, modelMap, randomExamples);
+      return modelToExampleObject(model, modelMap, randomExamples);
+    }
+    case "lazy":
+      return typeToExampleValue(type.inner, modelMap, randomExamples);
+    case "inlineObject":
+      return fieldsToExampleObject(type.fields, modelMap, randomExamples);
+    default:
+      return null;
+  }
+}
+__name(typeToExampleValue, "typeToExampleValue");
+function modelToExampleObject(model, modelMap, randomExamples = false) {
+  return fieldsToExampleObject(resolveModelFields(model, modelMap), modelMap, randomExamples);
+}
+__name(modelToExampleObject, "modelToExampleObject");
+function fieldsToExampleObject(fields, modelMap, randomExamples = false) {
+  const obj = {};
+  for (const field of fields) {
+    if (field.visibility === "readonly") continue;
+    if (field.default !== void 0) {
+      obj[field.name] = field.default;
+    } else if (field.optional) {
+      obj[field.name] = null;
+    } else {
+      obj[field.name] = typeToExampleValue(field.type, modelMap, randomExamples);
+    }
+  }
+  return obj;
+}
+__name(fieldsToExampleObject, "fieldsToExampleObject");
+function openCollectionPath(path) {
+  return path.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, ":$1");
+}
+__name(openCollectionPath, "openCollectionPath");
+function slugifyName(name) {
+  const result = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return result || "request";
+}
+__name(slugifyName, "slugifyName");
+function sanitizePath(path) {
+  const result = path.replace(/^\//, "").replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, "$1").replace(/\//g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return result || "root";
+}
+__name(sanitizePath, "sanitizePath");
+function extractPathParamNames(path) {
+  return [
+    ...path.matchAll(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g)
+  ].map((m) => m[1]);
+}
+__name(extractPathParamNames, "extractPathParamNames");
+function deriveFolderName(file) {
+  return basename(file).replace(/\.(op|ck)$/, "");
+}
+__name(deriveFolderName, "deriveFolderName");
+function yamlString(value) {
+  if (/[:{}[\],&*#?|<>=!%@`"']/.test(value) || /^\s|\s$/.test(value)) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+__name(yamlString, "yamlString");
+
+// src/index.ts
+var plugin = {
+  name: "bruno",
+  cacheKey: "bruno",
+  async generateTargets({ opRoots, contractRoots }, ctx) {
+    const { auth, ...config } = ctx.options;
+    const base = config.baseDir ? resolve(ctx.rootDir, config.baseDir) : ctx.rootDir;
+    const outDir = resolve(base, config.output ?? "bruno-collection");
+    const collectionName = config.collectionName ?? basename2(ctx.rootDir);
+    cleanupTrackedFiles(outDir);
+    const files = generateOpenCollection(opRoots, {
+      collectionName,
+      contractRoots,
+      auth,
+      randomExamples: config.randomExamples ?? true,
+      includeInternal: config.includeInternal
+    });
+    for (const { relativePath, content } of files) {
+      ctx.emitFile(resolve(outDir, relativePath), content);
+    }
+  }
+};
+var index_default = plugin;
+function createBrunoPlugin(config, rootDir, auth) {
+  return {
+    name: "bruno",
+    cacheKey: `bruno:${JSON.stringify(config)}`,
+    async generateTargets({ opRoots, contractRoots }, ctx) {
+      const base = config.baseDir ? resolve(rootDir, config.baseDir) : rootDir;
+      const outDir = resolve(base, config.output ?? "bruno-collection");
+      const collectionName = config.collectionName ?? basename2(rootDir);
+      cleanupTrackedFiles(outDir);
+      const files = generateOpenCollection(opRoots, {
+        collectionName,
+        contractRoots,
+        auth,
+        randomExamples: config.randomExamples ?? true
+      });
+      for (const { relativePath, content } of files) {
+        ctx.emitFile(resolve(outDir, relativePath), content);
+      }
+    }
+  };
+}
+__name(createBrunoPlugin, "createBrunoPlugin");
+function cleanupTrackedFiles(outDir) {
+  const manifestPath = resolve(outDir, MANIFEST_FILENAME);
+  if (!existsSync(manifestPath)) return;
+  let tracked;
+  try {
+    tracked = parseManifest(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return;
+  }
+  const removedDirs = /* @__PURE__ */ new Set();
+  for (const rel of tracked) {
+    const abs = resolve(outDir, rel);
+    if (existsSync(abs)) {
+      rmSync(abs, {
+        force: true
+      });
+      removedDirs.add(dirname(abs));
+    }
+  }
+  for (const dir of removedDirs) {
+    let current = dir;
+    while (current.startsWith(outDir) && current !== outDir) {
+      try {
+        if (readdirSync(current).length === 0) {
+          rmdirSync(current);
+          current = dirname(current);
+        } else {
+          break;
+        }
+      } catch {
+        break;
+      }
+    }
+  }
+}
+__name(cleanupTrackedFiles, "cleanupTrackedFiles");
+export {
+  createBrunoPlugin,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map