@chenguangyao/devflow-kit 0.1.43

package/src/providers/base.js

@@ -0,0 +1,74 @@
+'use strict';
+/**
+ * Provider base classes & types (JS, doc-only).
+ *
+ *   type ProviderType = 'intake' | 'issue' | 'vcs' | 'ci' | 'notify' | 'kb' | 'api' | 'observability'
+ *
+ *   interface Provider {
+ *     name: string
+ *     type: ProviderType
+ *     driver: string
+ *     validate(): Promise<{ ok: boolean; reason?: string; needsLogin?: boolean }>
+ *     login?({ force }): Promise<void>
+ *     logout?(): Promise<void>
+ *   }
+ *
+ *   IntakeProvider extends Provider:
+ *     fetch(url): { title, body_md, attachments[], source: { type, ref } }
+ *     search?(q): SearchHit[]
+ *     supports(input): boolean   // does this provider know how to handle this input
+ *
+ *   IssueProvider:
+ *     fetch(id): { title, body_md, status, labels, source }
+ *
+ *   KbProvider:
+ *     upload(file, meta): { uuid, url? }
+ *     update(uuid, file, meta): void
+ *     delete(uuid): void
+ *     search(q, opts?): SearchHit[]
+ *
+ *   NotifyProvider:
+ *     send({ subject, body_md, to, links[] }): { id }
+ *
+ *   CiProvider:
+ *     trigger(job, params): { runId, url }
+ *     status(runId): { status, url, log? }
+ *
+ *   ApiProvider:
+ *     syncContract({ file, content, dryRun? }): { status, interfaces, url? }
+ *
+ *   ObservabilityProvider:
+ *     query({ query, traceId, requestId, since, limit }): { status, items[], url? }
+ *
+ *   VcsProvider:
+ *     pr({ title, body_md, base, head, draft? }): { url, number }
+ */
+
+class Provider {
+  constructor({ name, type, driver, config }) {
+    this.name = name;
+    this.type = type;
+    this.driver = driver;
+    this.config = config || {};
+  }
+  async validate() { return { ok: true }; }
+}
+
+class ProviderError extends Error {
+  constructor(message, { provider, code, retryable } = {}) {
+    super(message);
+    this.name = 'ProviderError';
+    this.provider = provider;
+    this.code = code;
+    this.retryable = !!retryable;
+  }
+}
+
+class AuthExpiredError extends ProviderError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, code: 'auth_expired', retryable: true });
+    this.name = 'AuthExpiredError';
+  }
+}
+
+module.exports = { Provider, ProviderError, AuthExpiredError };

package/src/providers/drivers/api-yapi.js

@@ -0,0 +1,78 @@
+'use strict';
+const http = require('http');
+const https = require('https');
+const { Provider } = require('../base.js');
+
+class YapiProvider extends Provider {
+  async validate() {
+    if (!this.config.baseUrl) return { ok: false, reason: 'baseUrl missing' };
+    if (!this.config.token) return { ok: false, reason: 'token missing', needsLogin: true };
+    return { ok: true };
+  }
+
+  async syncContract({ file, content, dryRun = false } = {}) {
+    const summary = summarizeContract(content, file);
+    if (dryRun) return { status: 'dry-run', ...summary };
+    const payload = {
+      type: this.config.importType || 'swagger',
+      token: this.config.token,
+      project_id: this.config.projectId,
+      catid: this.config.categoryId,
+      merge: this.config.merge || 'normal',
+      json: content,
+    };
+    const res = await postJson(joinUrl(this.config.baseUrl, this.config.syncPath || '/api/open/import_data'), payload);
+    return { status: 'synced', ...summary, response: res };
+  }
+}
+
+function summarizeContract(content = '', file = '') {
+  let interfaces = 0;
+  let title = file || 'contract';
+  try {
+    const json = JSON.parse(content);
+    title = json.info && json.info.title ? json.info.title : title;
+    if (json.paths && typeof json.paths === 'object') {
+      for (const item of Object.values(json.paths)) {
+        interfaces += Object.keys(item || {}).filter((k) => /^(get|post|put|patch|delete|head|options)$/i.test(k)).length;
+      }
+    }
+  } catch {
+    interfaces = (content.match(/^#{2,4}\s+/gm) || []).length;
+  }
+  return { title, interfaces, file };
+}
+
+function joinUrl(base, p) {
+  return String(base || '').replace(/\/+$/, '') + '/' + String(p || '').replace(/^\/+/, '');
+}
+
+function postJson(url, payload) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const body = JSON.stringify(payload);
+    const lib = u.protocol === 'https:' ? https : http;
+    const req = lib.request({
+      method: 'POST',
+      hostname: u.hostname,
+      port: u.port || (u.protocol === 'https:' ? 443 : 80),
+      path: u.pathname + u.search,
+      headers: {
+        'content-type': 'application/json',
+        'content-length': Buffer.byteLength(body),
+      },
+      timeout: 15000,
+    }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => resolve({ statusCode: res.statusCode, body: data.slice(0, 4000) }));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('YAPI sync timeout')));
+    req.write(body);
+    req.end();
+  });
+}
+
+module.exports = { default: YapiProvider, _internals: { summarizeContract } };

package/src/providers/drivers/ci-jenkins.js

@@ -0,0 +1,109 @@
+'use strict';
+const { Provider } = require('../base.js');
+
+class JenkinsProvider extends Provider {
+  constructor(opts) {
+    super(opts);
+  }
+
+  async validate() {
+    return { ok: true };
+  }
+
+  async trigger(job, params = {}) {
+    const cleanParams = stripEmpty(params);
+    const buildUrl = toBuildUrl(resolveJobUrl(job, this.config), cleanParams);
+    const mode = (this.config.triggerMethod || 'post').toLowerCase();
+    const headers = {};
+    const auth = authHeader(this.config);
+    if (auth) headers.authorization = auth;
+
+    let url = buildUrl;
+    const init = { method: mode === 'get' ? 'GET' : 'POST', headers };
+    if (mode === 'get') {
+      url = withParams(buildUrl, cleanParams);
+    } else if (Object.keys(cleanParams).length) {
+      headers['content-type'] = 'application/x-www-form-urlencoded';
+      init.body = new URLSearchParams(cleanParams).toString();
+    }
+
+    let res = await fetch(url, init);
+    if (!res.ok && res.status === 400 && mode !== 'get' && Object.keys(cleanParams).length) {
+      const retryHeaders = { ...headers };
+      delete retryHeaders['content-type'];
+      res = await fetch(url, { method: 'POST', headers: retryHeaders });
+    }
+    if (!res.ok && res.status !== 201) {
+      throw new Error(`jenkins trigger failed: HTTP ${res.status}`);
+    }
+
+    const queueUrl = res.headers.get('location') || null;
+    return {
+      runId: queueUrl || url,
+      url: queueUrl || url,
+      queueUrl,
+    };
+  }
+
+  async status(runId) {
+    if (!runId || !/^https?:\/\//i.test(String(runId))) {
+      return { status: 'unknown', url: null };
+    }
+    const apiUrl = String(runId).replace(/\/+$/, '') + '/api/json';
+    const headers = {};
+    const auth = authHeader(this.config);
+    if (auth) headers.authorization = auth;
+    const res = await fetch(apiUrl, { headers });
+    if (!res.ok) return { status: 'unknown', url: String(runId) };
+    const json = await res.json();
+    if (json.executable && json.executable.url) {
+      return { status: 'queued', url: json.executable.url, runId: String(json.executable.number || '') };
+    }
+    if (json.building) return { status: 'running', url: json.url || String(runId) };
+    if (json.result) return { status: String(json.result).toLowerCase(), url: json.url || String(runId) };
+    return { status: 'unknown', url: json.url || String(runId) };
+  }
+}
+
+function resolveJobUrl(job, config = {}) {
+  if (/^https?:\/\//i.test(String(job))) return String(job);
+  const base = String(config.baseUrl || '').replace(/\/+$/, '');
+  if (!base) throw new Error('jenkins job must be URL when config.baseUrl is not set');
+  return `${base}/job/${encodeURIComponent(String(job))}`;
+}
+
+function toBuildUrl(jobUrl, params = {}) {
+  const u = String(jobUrl).trim();
+  const hasParams = Object.keys(stripEmpty(params)).length > 0;
+  if (/\/buildWithParameters(?:\?|$)/.test(u)) return u;
+  if (/\/build(?:\?|$)/.test(u)) {
+    return hasParams ? u.replace(/\/build(?=\?|$)/, '/buildWithParameters') : u;
+  }
+  const endpoint = hasParams ? 'buildWithParameters' : 'build';
+  return u.replace(/\/+$/, '') + `/${endpoint}`;
+}
+
+function withParams(url, params = {}) {
+  const u = new URL(url);
+  for (const [k, v] of Object.entries(stripEmpty(params))) {
+    u.searchParams.set(k, String(v));
+  }
+  return u.toString();
+}
+
+function stripEmpty(params) {
+  const out = {};
+  for (const [k, v] of Object.entries(params || {})) {
+    if (v !== undefined && v !== null && v !== '') out[k] = v;
+  }
+  return out;
+}
+
+function authHeader(config = {}) {
+  if (!config.user && !config.token) return null;
+  return 'Basic ' + Buffer.from(`${config.user || ''}:${config.token || ''}`).toString('base64');
+}
+
+JenkinsProvider._internals = { resolveJobUrl, toBuildUrl, withParams, stripEmpty };
+
+module.exports = { default: JenkinsProvider };