dsh-dbhub-live 5.0.1 → 5.2.0-dev.3

package/test/update.test.mjs

@@ -0,0 +1,270 @@
+// Unit tests for the plugin self-update check (lib/update.mjs): npm-first with a
+// GitHub fallback, prerelease-aware hasUpdate, error sanitization, the 30 min
+// throttle, `force`, concurrent-call dedupe and the per-request timeout.
+//
+// Everything is driven through an injected fetch stub and an injected clock, so
+// these tests never touch the network and never wait on a real timer.
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  DEFAULT_THROTTLE_MS,
+  GITHUB_LATEST_URL,
+  NPM_LATEST_URL,
+  createUpdateChecker,
+  versionFromGithubBody,
+  versionFromNpmBody,
+} from '../lib/update.mjs'
+
+// ── helpers ───────────────────────────────────────────────────────────────
+
+/** A fetch stub that answers from a per-URL table: value = body | {status}. */
+function stubFetch(routes) {
+  const calls = []
+  const impl = async (url) => {
+    calls.push(url)
+    const route = routes[url]
+    if (!route) throw new Error('unexpected url ' + url)
+    if (route instanceof Error) throw route
+    if (typeof route === 'function') return route(url)
+    const status = typeof route.status === 'number' ? route.status : 200
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      json: async () => route.body,
+    }
+  }
+  impl.calls = calls
+  impl.byUrl = (needle) => calls.filter((url) => url.includes(needle)).length
+  return impl
+}
+
+const ok = (body) => ({ status: 200, body })
+const fail = (status) => ({ status })
+
+function checker(overrides = {}) {
+  return createUpdateChecker({
+    currentVersion: '5.1.1-dev.1',
+    now: () => 1000,
+    ...overrides,
+  })
+}
+
+const NPM_OK = { [NPM_LATEST_URL]: ok({ version: '5.2.0' }) }
+const GH_OK = { [GITHUB_LATEST_URL]: ok({ tag_name: 'v5.2.0' }) }
+
+// ── pure body extractors ──────────────────────────────────────────────────
+
+test('versionFromNpmBody accepts objects and raw JSON strings, rejects junk', () => {
+  assert.equal(versionFromNpmBody({ version: '5.2.0' }), '5.2.0')
+  assert.equal(versionFromNpmBody({ version: ' 5.2.0-dev.1 ' }), '5.2.0-dev.1')
+  assert.equal(versionFromNpmBody('{"version":"5.2.0"}'), '5.2.0')
+  assert.equal(versionFromNpmBody({ version: 'latest' }), '')
+  assert.equal(versionFromNpmBody({ version: '' }), '')
+  assert.equal(versionFromNpmBody({}), '')
+  assert.equal(versionFromNpmBody(null), '')
+  assert.equal(versionFromNpmBody('not json'), '')
+})
+
+test('versionFromGithubBody strips the release tag v prefix', () => {
+  assert.equal(versionFromGithubBody({ tag_name: 'v5.2.0' }), '5.2.0')
+  assert.equal(versionFromGithubBody({ tag_name: '5.2.0' }), '5.2.0')
+  assert.equal(versionFromGithubBody({ tag_name: 'V5.2.0-dev.3' }), '5.2.0-dev.3')
+  assert.equal(versionFromGithubBody('{"tag_name":"v5.2.0"}'), '5.2.0')
+  assert.equal(versionFromGithubBody({ tag_name: 'vnext' }), '')
+  assert.equal(versionFromGithubBody({ name: 'v5.2.0' }), '')
+  assert.equal(versionFromGithubBody(null), '')
+})
+
+// ── happy path + fallback ─────────────────────────────────────────────────
+
+test('npm success produces the full snapshot', async () => {
+  const fetchImpl = stubFetch(NPM_OK)
+  const update = checker({ fetchImpl, now: () => 4242 })
+  assert.deepEqual(update.snapshot(), {
+    latest: '',
+    latestSpec: '',
+    hasUpdate: false,
+    checkedAt: 0,
+    source: '',
+    error: '',
+  }, 'nothing is claimed before the first check')
+  const snap = await update.check()
+  assert.deepEqual(snap, {
+    latest: '5.2.0',
+    latestSpec: 'dsh-dbhub-live@5.2.0',
+    hasUpdate: true,
+    checkedAt: 4242,
+    source: 'npm',
+    error: '',
+  })
+  assert.deepEqual(fetchImpl.calls, [NPM_LATEST_URL], 'github is not asked when npm answered')
+  // No rejected promise, no throw: check() resolves on every path.
+  assert.deepEqual(update.snapshot(), snap)
+})
+
+test('npm failure falls back to the GitHub release tag', async () => {
+  const fetchImpl = stubFetch({ [NPM_LATEST_URL]: fail(503), [GITHUB_LATEST_URL]: ok({ tag_name: 'v5.2.0' }) })
+  const snap = await checker({ fetchImpl }).check()
+  assert.equal(snap.source, 'github')
+  assert.equal(snap.latest, '5.2.0')
+  assert.equal(snap.latestSpec, 'dsh-dbhub-live@5.2.0')
+  assert.equal(snap.hasUpdate, true)
+  assert.equal(snap.error, '', 'a successful fallback clears the npm error')
+})
+
+test('an invalid npm payload also falls back instead of claiming a version', async () => {
+  const fetchImpl = stubFetch({
+    [NPM_LATEST_URL]: ok({ version: 'latest' }),
+    [GITHUB_LATEST_URL]: ok({ tag_name: 'v5.2.0' }),
+  })
+  const snap = await checker({ fetchImpl }).check()
+  assert.equal(snap.latest, '5.2.0')
+  assert.equal(snap.source, 'github')
+  assert.equal(snap.error, '')
+})
+
+test('both sources failing yields a short error and KEEPS the previous result', async () => {
+  let clock = 1000
+  let current = stubFetch(NPM_OK)
+  // One checker; the stub it calls is swapped between runs (like a network
+  // that worked once and then went down).
+  const flaky = createUpdateChecker({
+    currentVersion: '5.1.1-dev.1',
+    now: () => clock,
+    throttleMs: 0,
+    fetchImpl: (url, init) => current(url, init),
+  })
+  const good = await flaky.check()
+  assert.equal(good.latest, '5.2.0')
+  assert.equal(good.error, '')
+
+  current = stubFetch({ [NPM_LATEST_URL]: fail(503), [GITHUB_LATEST_URL]: fail(500) })
+  clock = 60_000
+  const bad = await flaky.check(true)
+  assert.equal(bad.latest, '5.2.0', 'stale latest preserved')
+  assert.equal(bad.latestSpec, 'dsh-dbhub-live@5.2.0')
+  assert.equal(bad.source, 'npm')
+  assert.equal(bad.hasUpdate, true)
+  assert.equal(bad.checkedAt, 60_000, 'checkedAt advances even on failure')
+  assert.equal(bad.error, 'npm: HTTP 503; github: HTTP 500')
+
+  // A brand-new checker has nothing to preserve: a failure leaves it empty.
+  const fresh = createUpdateChecker({
+    currentVersion: '5.1.1-dev.1',
+    now: () => clock,
+    fetchImpl: stubFetch({ [NPM_LATEST_URL]: fail(503), [GITHUB_LATEST_URL]: fail(500) }),
+  })
+  const empty = await fresh.check(true)
+  assert.equal(empty.latest, '')
+  assert.equal(empty.latestSpec, '')
+  assert.equal(empty.hasUpdate, false)
+  assert.equal(empty.source, '')
+  assert.equal(empty.error, 'npm: HTTP 503; github: HTTP 500')
+})
+
+test('hasUpdate is strictly-newer and prerelease-aware', async () => {
+  const cases = [
+    // current, latest, expected hasUpdate
+    ['5.1.1-dev.1', '5.2.0', true, 'a newer release'],
+    ['5.2.0-dev.1', '5.2.0', true, 'the release supersedes its own dev build'],
+    ['5.2.0', '5.2.0-dev.2', false, 'a dev build is older than the release'],
+    ['5.2.0', '5.2.0', false, 'equal versions'],
+    ['5.2.0', '5.1.0', false, 'an older release'],
+    ['5.1.0', '5.2.0-dev.1', true, 'a newer dev build'],
+    ['', '5.2.0', false, 'unknown current version never claims an update'],
+  ]
+  for (const [currentVersion, latest, expected, why] of cases) {
+    const fetchImpl = stubFetch({ [NPM_LATEST_URL]: ok({ version: latest }) })
+    const snap = await createUpdateChecker({ currentVersion, fetchImpl, now: () => 1 }).check(true)
+    assert.equal(snap.hasUpdate, expected, currentVersion + ' -> ' + latest + ' (' + why + ')')
+    assert.equal(snap.latest, latest)
+  }
+})
+
+// ── throttle / force / dedupe ─────────────────────────────────────────────
+
+test('a second check inside the throttle window makes no request', async () => {
+  let clock = 10_000
+  const fetchImpl = stubFetch(NPM_OK)
+  const update = createUpdateChecker({ fetchImpl, now: () => clock })
+  const first = await update.check()
+  assert.equal(fetchImpl.calls.length, 1)
+
+  clock = 10_000 + DEFAULT_THROTTLE_MS - 1
+  const reused = await update.check()
+  assert.deepEqual(reused, first, 'the snapshot is reused verbatim')
+  assert.equal(fetchImpl.calls.length, 1, 'no new request inside the throttle window')
+
+  // `force` always refetches, even immediately.
+  const forced = await update.check(true)
+  assert.equal(fetchImpl.calls.length, 2)
+  assert.equal(forced.checkedAt, clock)
+})
+
+test('concurrent checks share one in-flight request', async () => {
+  let release
+  const gate = new Promise((resolve) => { release = resolve })
+  const fetchImpl = stubFetch({
+    [NPM_LATEST_URL]: async () => {
+      await gate
+      return { ok: true, status: 200, json: async () => ({ version: '5.2.0' }) }
+    },
+  })
+  const update = createUpdateChecker({ fetchImpl, now: () => 7 })
+  const first = update.check(true)
+  const second = update.check(true)
+  assert.equal(first, second, 'the same promise is handed to every concurrent caller')
+  release()
+  const [a, b] = await Promise.all([first, second])
+  assert.deepEqual(a, b)
+  assert.equal(fetchImpl.calls.length, 1, 'one request burst, not one per caller')
+})
+
+test('a failing check never rejects and error text is sanitized', async () => {
+  const fetchImpl = stubFetch({
+    [NPM_LATEST_URL]: new Error('boom https://registry.npmjs.org/dsh-dbhub-live/latest?token=abc123'),
+    [GITHUB_LATEST_URL]: new Error('fetch failed'),
+  })
+  const snap = await createUpdateChecker({ fetchImpl, now: () => 5 }).check(true)
+  assert.equal(snap.latest, '')
+  assert.equal(snap.source, '')
+  assert.match(snap.error, /^npm: /)
+  assert.match(snap.error, /github: /)
+  assert.ok(!snap.error.includes('http'), 'no URL survives into the view: ' + snap.error)
+  assert.ok(!snap.error.includes('token='), 'no query token survives into the view: ' + snap.error)
+  assert.ok(snap.error.length <= 200, 'the message stays short')
+})
+
+test('a request that outlives the budget is aborted and reported as timeout', async () => {
+  const fetchImpl = (url, init) => new Promise((resolve, reject) => {
+    const signal = init && init.signal
+    if (!signal) {
+      reject(new Error('no abort signal was passed'))
+      return
+    }
+    const abort = () => {
+      const error = new Error('The operation was aborted')
+      error.name = 'AbortError'
+      reject(error)
+    }
+    if (signal.aborted) abort()
+    else signal.addEventListener('abort', abort)
+  })
+  const snap = await createUpdateChecker({ fetchImpl, now: () => 1, timeoutMs: 20 }).check(true)
+  assert.equal(snap.latest, '')
+  assert.equal(snap.source, '')
+  assert.equal(snap.error, 'npm: timeout; github: timeout')
+  assert.equal(snap.checkedAt, 1)
+})
+
+test('snapshot() returns a detached copy', async () => {
+  const update = checker({ fetchImpl: stubFetch(NPM_OK) })
+  await update.check(true)
+  const snap = update.snapshot()
+  snap.latest = 'tampered'
+  snap.hasUpdate = false
+  assert.equal(update.snapshot().latest, '5.2.0')
+  assert.equal(update.snapshot().hasUpdate, true)
+})

package/test/util.test.mjs

@@ -106,6 +106,23 @@ test('scrubSecrets removes the DSN password and generic password= tokens', () =>
   assert.ok(cfg.scrubSecrets('SELECT 1 OK', dsn).includes('SELECT 1 OK'))
 })
 
+test('scrubSecrets collapses the whole userinfo of a URL-shaped connection string', () => {
+  const dsn = 'mysql://root:secret.pw@198.51.100.1:3306/mydb'
+  // dbhub's own startup banner masks only the password, so the USERNAME used to
+  // survive into the model-facing diagnostics. Both must go now.
+  const banner = 'Configuration source: dbhub-1.toml\n- default: mysql://root:****@198.51.100.1:3306/mydb'
+  const out = cfg.scrubSecrets(banner, dsn)
+  assert.ok(!out.includes('root'), 'the username must not survive: ' + out)
+  assert.ok(out.includes('mysql://****:****@198.51.100.1:3306/mydb'), out)
+  // A userinfo without a password is collapsed the same way.
+  assert.ok(!cfg.scrubSecrets('connect mysql://ops@198.51.100.2:3306/app', dsn).includes('ops'))
+  // A metadata label carries no userinfo at all and must stay byte-identical.
+  assert.equal(cfg.scrubSecrets('mysql://198.51.100.1:3306/mydb', dsn), 'mysql://198.51.100.1:3306/mydb')
+  // SSH secrets riding the child environment are replaced like the DSN password.
+  const sshOut = cfg.scrubSecrets('ssh_password=CHANGE_ME', dsn, ['CHANGE_ME'])
+  assert.ok(!sshOut.includes('CHANGE_ME'), sshOut)
+})
+
 test('dsnUser extracts the username host-side only (never surfaced)', () => {
   assert.equal(cfg.dsnUser('mysql://root:secret@h/d'), 'root')
   assert.equal(cfg.dsnUser('postgres://alice@h/db'), 'alice')

package/test/zero-knowledge.test.mjs

@@ -1,79 +1,121 @@
-// Zero-knowledge gate: the model-facing surface must never carry a password
-// (or a full DSN / username). Four layers are asserted here:
-//   1. summarizeRows produces metadata only (no dsn field, no password).
-//   2. Tool sources: the 4-tool contract has no dbhub_query and dbhub_configure
-//      has NO dsn parameter (a password may never ride a tool argument).
-//   3. Tool descriptions must never instruct the model to pass credentials.
-//   4. i18n copy must never embed a DSN with a real-looking password.
-//
-// Together with util.test's scrubSecrets/connLabel tests this is the
-// "no password reaches the model" regression suite.
-
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, rmSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const home = mkdtempSync(join(tmpdir(), 'dsh-dbhub-zk-'))
-process.env.DSH_HOME = home
-
-const mcp = await import('../lib/mcp.mjs?zk=' + Date.now())
-const i18n = await import('../lib/i18n.mjs?zk=' + Date.now())
-const here = dirname(fileURLToPath(import.meta.url))
-const toolsSource = readFileSync(join(here, '..', 'lib', 'tools.mjs'), 'utf8')
-
-test.after(() => {
-  rmSync(home, { recursive: true, force: true })
-})
-
-test('summarizeRows is metadata-only (no dsn/password/username)', () => {
-  const rows = [{
-    wsPath: 'C:\\ws\\demo',
-    title: 'Demo App',
-    env: 'default',
-    dsn: 'mysql://root:secret.pw@198.51.100.1:3306/mydb',
-    source: 'persisted(user)',
-    persisted: true,
-  }]
-  const summary = mcp.summarizeRows(rows)[0]
-  assert.equal(summary.conn, 'mysql://198.51.100.1:3306/mydb')
-  assert.equal(summary.dsn, undefined)
-  assert.ok(!JSON.stringify(summary).includes('secret.pw'))
-  assert.ok(!JSON.stringify(summary).includes('root'))
-})
-
-test('tools.mjs registers exactly the 4-tool zero-knowledge contract', () => {
-  // no ad-hoc dsn-passthrough tools remain
-  assert.doesNotMatch(toolsSource, /name:\s*["']dbhub_query["']/)
-  assert.doesNotMatch(toolsSource, /name:\s*["']dbhub_query_objects["']/)
-  // the 4 tools are declared
-  for (const tool of ['dbhub_configure', 'dbhub_list_sources', 'dbhub_execute_sql', 'dbhub_search_objects']) {
-    assert.match(toolsSource, new RegExp('name:\\s*["\']' + tool + '["\']'), tool)
-  }
-  // NO tool declares a `dsn` schema property the model could fill with a secret
-  assert.doesNotMatch(toolsSource, /dsn:\s*\{\s*type:\s*["']string["']/)
-  // descriptions explicitly forbid passing credentials as arguments
-  assert.match(toolsSource, /不能作为本工具参数传入/)
-})
-
-test('no tool description embeds a real-looking DSN', () => {
-  // Placeholder examples (user:pass@, u:p@, username:password@, 账号:密码@) are
-  // tolerated user-facing copy; anything else in the password position is a leak.
-  const dsnLike = /[a-z]+:\/\/[^/\s]*:[^@\s]+@/g
-  const placeholders = /(user:pass|u:p|username:password|account:password|账号:密码)@$/
-  for (const m of toolsSource.matchAll(dsnLike)) {
-    assert.ok(placeholders.test(m[0]), 'real-looking DSN in copy: ' + m[0])
-  }
-})
-
-test('i18n copy never embeds a DSN with a password', () => {
-  const dsnLike = /[a-z]+:\/\/[^/\s]*:[^@\s]+@/
-  for (const locale of ['zh', 'en']) {
-    const dict = i18n.dictionaryFor(locale)
-    for (const key of Object.keys(dict)) {
-      assert.doesNotMatch(String(dict[key]), dsnLike, key + ' (' + locale + ')')
-    }
-  }
+// Zero-knowledge gate: the model-facing surface must never carry a password
+// (or a full DSN / username). Four layers are asserted here:
+//   1. summarizeRows produces metadata only (no dsn field, no password).
+//   2. Tool sources: the 4-tool contract has no dbhub_query and dbhub_configure
+//      has NO dsn parameter (a password may never ride a tool argument).
+//   3. Tool descriptions must never instruct the model to pass credentials.
+//   4. i18n copy must never embed a DSN with a real-looking password.
+//
+// Together with util.test's scrubSecrets/connLabel tests this is the
+// "no password reaches the model" regression suite.
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const home = mkdtempSync(join(tmpdir(), 'dsh-dbhub-zk-'))
+process.env.DSH_HOME = home
+
+const mcp = await import('../lib/mcp.mjs?zk=' + Date.now())
+const i18n = await import('../lib/i18n.mjs?zk=' + Date.now())
+const here = dirname(fileURLToPath(import.meta.url))
+const toolsSource = readFileSync(join(here, '..', 'lib', 'tools.mjs'), 'utf8')
+
+test.after(() => {
+  rmSync(home, { recursive: true, force: true })
+})
+
+test('summarizeRows is metadata-only (no dsn/password/username)', () => {
+  const rows = [{
+    wsPath: 'C:\\ws\\demo',
+    title: 'Demo App',
+    env: 'default',
+    dsn: 'mysql://root:secret.pw@198.51.100.1:3306/mydb',
+    source: 'persisted(user)',
+    persisted: true,
+  }]
+  const summary = mcp.summarizeRows(rows)[0]
+  assert.equal(summary.conn, 'mysql://198.51.100.1:3306/mydb')
+  assert.equal(summary.dsn, undefined)
+  assert.equal(summary.ro, false)
+  assert.equal(summary.ssh, null)
+  assert.ok(!JSON.stringify(summary).includes('secret.pw'))
+  assert.ok(!JSON.stringify(summary).includes('root'))
+})
+
+test('summarizeRows never carries a tunnel secret or the key path', () => {
+  // The SSH password / passphrase / private-key path live next to the DSN in the
+  // store; the mirrored row may only say WHETHER each exists.
+  const rows = [{
+    wsPath: 'C:\\ws\\demo',
+    title: 'Demo App',
+    env: 'prod',
+    dsn: 'mysql://root:secret.pw@198.51.100.1:3306/mydb',
+    source: 'persisted(user)',
+    persisted: true,
+    ro: true,
+    ssh: {
+      host: 'bastion.example.com', port: 22, user: 'ops', auth: 'password',
+      password: 'CHANGE_ME', keyPath: '~/.ssh/id_ed25519', passphrase: 'CHANGE_ME_TOO',
+    },
+  }]
+  const summary = mcp.summarizeRows(rows)[0]
+  const text = JSON.stringify(summary)
+  assert.equal(summary.ro, true)
+  assert.equal(summary.ssh.authKind, 'password')
+  assert.equal(summary.ssh.hasPassword, true)
+  assert.equal(summary.ssh.hasPassphrase, false, 'a password-auth tunnel has no key passphrase')
+  assert.equal(summary.ssh.keyReady, false)
+  assert.equal(text.includes('CHANGE_ME'), false)
+  assert.equal(text.includes('id_ed25519'), false, 'the key path is not mirrored either')
+  assert.equal(text.includes('secret.pw'), false)
+  assert.equal(summary.ssh.host, 'bastion.example.com', 'the host is routing metadata, not a secret')
+})
+
+test('tools.mjs registers exactly the 4-tool zero-knowledge contract', () => {
+  // no ad-hoc dsn-passthrough tools remain
+  assert.doesNotMatch(toolsSource, /name:\s*["']dbhub_query["']/)
+  assert.doesNotMatch(toolsSource, /name:\s*["']dbhub_query_objects["']/)
+  // the 4 tools are declared
+  for (const tool of ['dbhub_configure', 'dbhub_list_sources', 'dbhub_execute_sql', 'dbhub_search_objects']) {
+    assert.match(toolsSource, new RegExp('name:\\s*["\']' + tool + '["\']'), tool)
+  }
+  // NO tool declares a `dsn` schema property the model could fill with a secret
+  assert.doesNotMatch(toolsSource, /dsn:\s*\{\s*type:\s*["']string["']/)
+  // ... and no tool may declare a TUNNEL secret either: the model can name a
+  // host / user / key path, never a password or a passphrase.
+  assert.doesNotMatch(toolsSource, /sshPassword\s*:/)
+  assert.doesNotMatch(toolsSource, /sshPassphrase\s*:/)
+  // the tunnel parameters that DO exist are the non-secret ones
+  for (const key of ['sshHost', 'sshPort', 'sshUser', 'sshAuthKind', 'sshKeyPath', 'sshProxyJump', 'sshOff']) {
+    assert.match(toolsSource, new RegExp(key + ':\\s*\\{\\s*type:'), key)
+  }
+  // read-only is a model-facing toggle, but only in the tightening direction
+  assert.match(toolsSource, /readOnly:\s*\{\s*type:\s*["']boolean["']/)
+  assert.match(toolsSource, /args\.readOnly === false/)
+  // descriptions explicitly forbid passing credentials as arguments
+  assert.match(toolsSource, /不能作为本工具参数传入/)
+})
+
+test('no tool description embeds a real-looking DSN', () => {
+  // Placeholder examples (user:pass@, u:p@, username:password@, 账号:密码@) are
+  // tolerated user-facing copy; anything else in the password position is a leak.
+  const dsnLike = /[a-z]+:\/\/[^/\s]*:[^@\s]+@/g
+  const placeholders = /(user:pass|u:p|username:password|account:password|账号:密码)@$/
+  for (const m of toolsSource.matchAll(dsnLike)) {
+    assert.ok(placeholders.test(m[0]), 'real-looking DSN in copy: ' + m[0])
+  }
+})
+
+test('i18n copy never embeds a DSN with a password', () => {
+  const dsnLike = /[a-z]+:\/\/[^/\s]*:[^@\s]+@/
+  for (const locale of ['zh', 'en']) {
+    const dict = i18n.dictionaryFor(locale)
+    for (const key of Object.keys(dict)) {
+      assert.doesNotMatch(String(dict[key]), dsnLike, key + ' (' + locale + ')')
+    }
+  }
 })