@hedeqiang/dsh-nl2sql 0.10.0 → 0.11.1

package/channels/http.js

@@ -0,0 +1,63 @@
+/**
+ * Shared HTTP helpers for channel adapters.
+ *
+ * Adapters throw `ChannelError(code, message)`: a stable code such as
+ * `channel/auth`, `channel/config`, `channel/network`, `channel/rate-limit`,
+ * `channel/rejected` (or a platform-specific `channel/<platform>-<code>`) and
+ * a Chinese user-facing message.
+ */
+
+export class ChannelError extends Error {
+  /** @param {{ field?: string }} [opts] - `field`: the form field key the error belongs to. */
+  constructor(code, message, { field } = {}) {
+    super(message)
+    this.name = 'ChannelError'
+    this.code = code
+    if (field) this.field = field
+  }
+}
+
+function parseBody(text) {
+  try { return JSON.parse(text) } catch { return { raw: String(text ?? '').slice(0, 300) } }
+}
+
+/**
+ * fetch with a timeout. Returns { status, json, headers } — json is the parsed
+ * body, or `{ raw }` (first 300 chars) when the body is not JSON.
+ * Network failures and timeouts throw ChannelError('channel/network').
+ * @param {string} url
+ * @param {{ method?: string, headers?: object, body?: any, json?: any, timeoutMs?: number, label?: string, fetch?: Function }} [opts]
+ *   `json` is serialized as the request body with a JSON content type;
+ *   `label` names the platform in error messages (e.g. '飞书').
+ */
+export async function request(url, { method, headers = {}, body, json, timeoutMs = 15000, label = '', fetch: fetchImpl = globalThis.fetch } = {}) {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  const init = { method: method ?? (json !== undefined || body !== undefined ? 'POST' : 'GET'), headers: { ...headers }, signal: controller.signal }
+  if (json !== undefined) {
+    init.headers['content-type'] ??= 'application/json; charset=utf-8'
+    init.body = JSON.stringify(json)
+  } else if (body !== undefined) {
+    init.body = body
+  }
+  try {
+    const res = await fetchImpl(url, init)
+    const text = await res.text()
+    return { status: res.status, json: parseBody(text), headers: res.headers }
+  } catch (error) {
+    const who = label ? `${label}接口` : '接口'
+    throw new ChannelError('channel/network', error?.name === 'AbortError' ? `请求${who}超时` : `无法访问${who}：${error?.cause?.code ?? error?.message ?? error}`)
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/** POST a JSON body. Returns { status, json }. */
+export function postJson(url, body, headers = {}, opts = {}) {
+  return request(url, { ...opts, method: 'POST', headers, json: body })
+}
+
+/** GET a URL. Returns { status, json }. */
+export function getJson(url, headers = {}, opts = {}) {
+  return request(url, { ...opts, method: 'GET', headers })
+}

package/channels/index.js

@@ -0,0 +1,138 @@
+/**
+ * Channel adapter registry (see docs/CHANNELS.md).
+ *
+ * Built-in adapters: lark (static), telegram / wecom / dingtalk (loaded with
+ * dynamic import so a missing or broken module never breaks the registry).
+ * Adapters must NOT import this module (import ./http.js and ./message.js
+ * instead) — the registry imports them.
+ *
+ * Call `await loadAdapters()` once before using the synchronous lookups; the
+ * service core does this on start and in every channel RPC.
+ */
+import lark from './lark.js'
+import { ChannelError } from './http.js'
+
+const adapters = new Map()
+const kinds = new Map()
+
+/** Register (or replace) an adapter. Its kinds become valid channel types. */
+export function registerAdapter(adapter) {
+  if (!adapter?.id || !Array.isArray(adapter.kinds)) throw new Error('adapter needs id and kinds')
+  const previous = adapters.get(adapter.id)
+  if (previous) for (const k of previous.kinds) kinds.delete(k.id)
+  adapters.set(adapter.id, adapter)
+  for (const kind of adapter.kinds) kinds.set(kind.id, { adapter, kind: { platform: adapter.id, ...kind } })
+  return adapter
+}
+
+/** Remove an adapter (tests). */
+export function unregisterAdapter(id) {
+  const adapter = adapters.get(id)
+  if (!adapter) return false
+  for (const k of adapter.kinds) kinds.delete(k.id)
+  adapters.delete(id)
+  return true
+}
+
+registerAdapter(lark)
+
+const OPTIONAL = ['telegram', 'wecom', 'dingtalk']
+const loadErrors = {}
+let loading
+
+/** Load the optional built-in adapters (idempotent). Resolves to the list of loaded ids. */
+export function loadAdapters() {
+  loading ??= Promise.all(OPTIONAL.map(async (id) => {
+    try {
+      const mod = await import(`./${id}.js`)
+      const adapter = mod.default ?? mod.adapter
+      // A test may have registered a replacement already: keep it.
+      if (adapter && !adapters.has(adapter.id)) registerAdapter(adapter)
+      return adapter?.id
+    } catch (error) {
+      loadErrors[id] = error?.message ?? String(error)
+      return undefined
+    }
+  })).then(ids => ids.filter(Boolean))
+  return loading
+}
+
+/** Errors from optional adapters that failed to load: { [platform]: message }. */
+export function adapterLoadErrors() {
+  return { ...loadErrors }
+}
+
+export function getAdapter(platform) {
+  return adapters.get(platform)
+}
+
+export function listAdapters() {
+  return [...adapters.values()]
+}
+
+/** Resolve a channel type to { adapter, kind }, or undefined. */
+export function kindOf(type) {
+  return kinds.get(type)
+}
+
+/** Like kindOf, but throws ChannelError('channel/config') for unknown types. */
+export function requireKind(type) {
+  const found = kinds.get(type)
+  if (!found) throw new ChannelError('channel/config', `不支持的渠道类型：${type}`)
+  return found
+}
+
+/** Pick zh/en text from a { zh, en } object (or return a plain string). */
+export function localized(text, locale = 'zh') {
+  if (text === null || text === undefined) return text
+  if (typeof text !== 'object' || Array.isArray(text)) return text
+  return text[locale] ?? text.zh ?? text.en
+}
+
+/** A JSON-safe description of a kind for the UI: no functions, never a value. */
+export function describeKind(kind) {
+  return {
+    id: kind.id,
+    platform: kind.platform,
+    label: kind.label,
+    description: kind.description,
+    fields: (kind.fields ?? []).map(f => {
+      const secret = Boolean(f.secret || f.type === 'secret')
+      const out = { ...f, secret }
+      if (secret) delete out.default // never any secret value
+      return JSON.parse(JSON.stringify(out))
+    }),
+    capabilities: { ...kind.capabilities },
+    setupSteps: kind.setupSteps ?? { zh: [], en: [] },
+  }
+}
+
+/**
+ * The catalog for the page: [{ platform, name, kinds:[{ id, label, description, fields, capabilities, setupSteps }] }].
+ * With a locale, `name` / `label` / `description` / `setupSteps` / field labels are also given as `*Text` strings.
+ */
+export function listCatalog(locale) {
+  return listAdapters().map(adapter => ({
+    platform: adapter.id,
+    name: adapter.name,
+    ...(locale ? { nameText: localized(adapter.name, locale) } : {}),
+    kinds: adapter.kinds.map(k => {
+      const d = describeKind({ platform: adapter.id, ...k })
+      if (!locale) return d
+      return {
+        ...d,
+        labelText: localized(d.label, locale),
+        descriptionText: localized(d.description, locale),
+        setupStepsText: localized(d.setupSteps, locale) ?? [],
+        fields: d.fields.map(f => ({ ...f, labelText: localized(f.label, locale), helpText: localized(f.help, locale) })),
+      }
+    }),
+  }))
+}
+
+/** Secret field keys of a kind. */
+export function secretKeys(kind) {
+  return (kind.fields ?? []).filter(f => f.secret || f.type === 'secret').map(f => f.key)
+}
+
+export { ChannelError }