@aloma.io/integration-sdk 3.8.68 → 3.8.70

package/test/fetcher-query-params.test.mjs

@@ -0,0 +1,294 @@
+// PLAT-47: the Fetcher sends fetchOptions.params as the query string.
+// Standalone script (no mocha). Global fetch is stubbed in this process, except one test that uses a local
+// HTTP server on 127.0.0.1. No request leaves the test process.
+import http from 'node:http';
+import fs from 'node:fs';
+import Fetcher from '../build/internal/fetcher/fetcher.mjs';
+import {OAuth} from '../build/internal/fetcher/oauth-fetcher.mjs';
+
+const colors = {green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m', reset: '\x1b[0m', cyan: '\x1b[36m'};
+
+let passed = 0;
+let failed = 0;
+
+async function test(name, fn) {
+  try {
+    console.log(`${colors.cyan}Running: ${name}${colors.reset}`);
+    await fn();
+    console.log(`${colors.green}✓ PASS: ${name}${colors.reset}\n`);
+    passed++;
+  } catch (error) {
+    console.log(`${colors.red}✗ FAIL: ${name}${colors.reset}`);
+    console.log(`${colors.red}  Error: ${error.message}${colors.reset}\n`);
+    failed++;
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message || 'Assertion failed');
+}
+
+function assertEqual(actual, expected, message) {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(`${message || 'not equal'}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+const BASE = 'https://api.vendor.example.test';
+// Fetcher collapses every run of slashes in baseUrl + url, so the scheme loses one slash (today's behaviour).
+const RAW = 'https:/api.vendor.example.test';
+
+// Replace global fetch with a recorder. `replies` is a list of statuses; the last one repeats.
+function stubFetch(replies = [200]) {
+  const calls = [];
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = async (url, init) => {
+    calls.push({url, init});
+    const status = replies[Math.min(calls.length - 1, replies.length - 1)];
+    return new Response(status === 204 ? null : JSON.stringify({ok: status < 400}), {
+      status,
+      headers: {'content-type': 'application/json'},
+    });
+  };
+  return {calls, restore: () => (globalThis.fetch = realFetch)};
+}
+
+async function send(path, options, fetcherOptions = {}, replies) {
+  const stub = stubFetch(replies);
+  try {
+    const fetcher = new Fetcher({baseUrl: BASE, retry: 1, ...fetcherOptions});
+    let error;
+    try {
+      await fetcher.fetch(path, options);
+    } catch (e) {
+      error = e;
+    }
+    return {calls: stub.calls, error};
+  } finally {
+    stub.restore();
+  }
+}
+
+function initWithoutSignal(init) {
+  const {signal, ...rest} = init;
+  return rest;
+}
+
+// --- Rule 1: params become the query string ---
+
+await test('numbers, strings and booleans are stringified into the query string', async () => {
+  const {calls} = await send('/crm/v3/objects/contacts', {
+    method: 'GET',
+    params: {limit: 10, after: 'abc', archived: false},
+  });
+  assertEqual(calls.length, 1, 'one request');
+  assertEqual(calls[0].url, `${RAW}/crm/v3/objects/contacts?limit=10&after=abc&archived=false`, 'url');
+});
+
+await test('query parameters already in the url are kept', async () => {
+  const {calls} = await send('/items?foo=1', {method: 'GET', params: {bar: 2}});
+  assertEqual(calls[0].url, `${RAW}/items?foo=1&bar=2`, 'url');
+});
+
+await test('undefined and null values are skipped', async () => {
+  const {calls} = await send('/items', {method: 'GET', params: {a: undefined, b: null, c: 'x', d: 0, e: ''}});
+  assertEqual(calls[0].url, `${RAW}/items?c=x&d=0&e=`, 'url');
+});
+
+await test('arrays become repeated keys', async () => {
+  const {calls} = await send('/crm/v3/objects/contacts', {
+    method: 'GET',
+    params: {properties: ['firstname', 'lastname'], limit: 1},
+  });
+  assertEqual(calls[0].url, `${RAW}/crm/v3/objects/contacts?properties=firstname&properties=lastname&limit=1`, 'url');
+});
+
+await test('undefined and null array items are skipped, other items stringified', async () => {
+  const {calls} = await send('/items', {method: 'GET', params: {ids: [1, undefined, null, true, 'x']}});
+  assertEqual(calls[0].url, `${RAW}/items?ids=1&ids=true&ids=x`, 'url');
+});
+
+await test('nested objects are refused with a clear error and nothing is sent', async () => {
+  const started = Date.now();
+  const {calls, error} = await send('/items', {method: 'GET', params: {filter: {a: 1}}}, {retry: 3});
+  assert(error, 'fetch must reject');
+  assert(/params\.filter/.test(error.message) && /object/.test(error.message), `error message: ${error.message}`);
+  assertEqual(calls.length, 0, 'no request sent');
+  assert(Date.now() - started < 400, 'refused at once, not retried');
+});
+
+await test('objects inside arrays are refused too', async () => {
+  const {calls, error} = await send('/items', {method: 'GET', params: {ids: [{a: 1}]}});
+  assert(error && /params\.ids/.test(error.message), `error: ${error && error.message}`);
+  assertEqual(calls.length, 0, 'no request sent');
+});
+
+await test('values are encoded by URLSearchParams and a "//" inside a value is not collapsed', async () => {
+  const value = 'a b&c=d/é https://x.test//y';
+  const {calls} = await send('/items', {method: 'GET', params: {q: value}});
+  assertEqual(calls[0].url, `${RAW}/items?${new URLSearchParams({q: value})}`, 'url');
+  assertEqual(new URL(calls[0].url).searchParams.get('q'), value, 'decoded value round-trips');
+});
+
+await test('a URLSearchParams instance is sent as it is', async () => {
+  const {calls} = await send('/items', {
+    method: 'GET',
+    params: new URLSearchParams([
+      ['a', '1'],
+      ['a', '2'],
+    ]),
+  });
+  assertEqual(calls[0].url, `${RAW}/items?a=1&a=2`, 'url');
+});
+
+await test('without baseUrl the query is appended to the url as given', async () => {
+  const {calls} = await send('https://other.example.test/x', {method: 'GET', params: {a: 1}}, {baseUrl: undefined});
+  assertEqual(calls[0].url, 'https://other.example.test/x?a=1', 'url');
+});
+
+// --- Rule 2: nothing else changes ---
+
+await test('params is not passed on to global fetch; headers, body and method are unchanged', async () => {
+  const options = {method: 'POST', headers: {'X-Custom': '1'}, body: {name: 'n'}};
+  const plain = await send('/items', {...options});
+  const withParams = await send('/items', {...options, params: {a: 1}});
+  assert(!('params' in withParams.calls[0].init), 'params must not reach native fetch');
+  assertEqual(initWithoutSignal(withParams.calls[0].init), initWithoutSignal(plain.calls[0].init), 'init');
+});
+
+await test('the caller options and params objects are not mutated', async () => {
+  const params = {a: 1, list: ['x', 'y'], skip: undefined};
+  const options = {method: 'GET', params};
+  await send('/items', options);
+  assertEqual(Object.keys(options), ['method', 'params'], 'options keys');
+  assert(options.params === params, 'same params object');
+  assertEqual(Object.keys(params), ['a', 'list', 'skip'], 'params keys');
+  assertEqual(params.list, ['x', 'y'], 'array untouched');
+});
+
+await test('customize runs as before and can change url and params', async () => {
+  let seen;
+  const {calls} = await send(
+    '/items',
+    {method: 'GET', params: {a: 1}},
+    {
+      customize: (o) => {
+        seen = {url: o.url, params: {...o.params}};
+        o.url = '/v2' + o.url;
+        o.params = {...o.params, key: 'k'};
+        o.headers = {...o.headers, Authorization: 'Bearer t'};
+      },
+    }
+  );
+  assertEqual(seen, {url: '/items', params: {a: 1}}, 'customize input');
+  assertEqual(calls[0].url, `${RAW}/v2/items?a=1&key=k`, 'url');
+  assertEqual(calls[0].init.headers.Authorization, 'Bearer t', 'customize header');
+});
+
+await test('a retried request sends the same url with the query string exactly once', async () => {
+  const {calls, error} = await send(
+    '/items',
+    {method: 'GET', params: {a: 1, list: ['x', 'y']}},
+    {retry: 2},
+    [500, 200]
+  );
+  assert(!error, `no error expected, got ${error && error.message}`);
+  assertEqual(calls.length, 2, 'first try + one retry');
+  assertEqual(calls[0].url, `${RAW}/items?a=1&list=x&list=y`, 'first url');
+  assertEqual(calls[1].url, calls[0].url, 'retry url');
+  assert(!('params' in calls[1].init), 'params must not reach native fetch on retry');
+});
+
+await test('a failed attempt logs the url without its query string', async () => {
+  const logged = [];
+  const realLog = console.log;
+  console.log = (...args) => logged.push(args.map(String).join(' '));
+  let calls;
+  try {
+    ({calls} = await send('/items?id=user42', {method: 'GET', params: {email: 'person@example.test'}}, {retry: 1}, [
+      500,
+    ]));
+  } finally {
+    console.log = realLog;
+  }
+  assertEqual(calls[0].url, `${RAW}/items?id=user42&email=person%40example.test`, 'the query is sent');
+  assert(logged.length > 0, 'the failure is logged');
+  assert(
+    !logged.some((l) => l.includes('person') || l.includes('user42')),
+    `query value leaked into the log: ${logged.join(' | ')}`
+  );
+  assert(
+    logged.some((l) => l.includes(`${RAW}/items`)),
+    'the path is still logged'
+  );
+});
+
+// --- Rule 3: no params gives exactly today's URL ---
+
+await test('no params, empty params or all-undefined params give exactly the old url', async () => {
+  for (const options of [
+    {method: 'GET'},
+    {method: 'GET', params: {}},
+    {method: 'GET', params: {a: undefined, b: null}},
+    {method: 'GET', params: undefined},
+  ]) {
+    const {calls} = await send('/items/1', options);
+    assertEqual(calls[0].url, `${RAW}/items/1`, `url for ${JSON.stringify(options)}`);
+  }
+  const {calls} = await send('/items/1?x=1', {method: 'GET', params: {}});
+  assertEqual(calls[0].url, `${RAW}/items/1?x=1`, 'existing query alone is untouched');
+});
+
+// --- OAuth fetcher inherits the behaviour ---
+
+await test('the OAuth fetcher sends the query string and its Bearer token', async () => {
+  const stub = stubFetch();
+  try {
+    const client = new OAuth({access_token: 'tok'}).getClient({baseUrl: BASE, retry: 1});
+    await client.fetch('/crm/v3/objects/contacts', {method: 'GET', params: {properties: ['a', 'b'], archived: true}});
+    assertEqual(stub.calls[0].url, `${RAW}/crm/v3/objects/contacts?properties=a&properties=b&archived=true`, 'url');
+    assertEqual(stub.calls[0].init.headers.Authorization, 'Bearer tok', 'auth header');
+    assert(!('params' in stub.calls[0].init), 'params must not reach native fetch');
+  } finally {
+    stub.restore();
+  }
+});
+
+// --- End to end over a local socket ---
+
+await test('a local HTTP server receives the query string through the real global fetch', async () => {
+  const seen = [];
+  const server = http.createServer((req, res) => {
+    seen.push(req.url);
+    res.writeHead(200, {'content-type': 'application/json'});
+    res.end('{"ok":true}');
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const {port} = server.address();
+    const fetcher = new Fetcher({baseUrl: `http://127.0.0.1:${port}`, retry: 1});
+    const ret = await fetcher.fetch('/crm/v3/objects/contacts', {
+      method: 'GET',
+      params: {limit: 2, properties: ['a', 'b']},
+    });
+    assertEqual(ret, {ok: true}, 'response');
+    assertEqual(seen, ['/crm/v3/objects/contacts?limit=2&properties=a&properties=b'], 'request line');
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
+
+// --- Typing for hand-written connectors ---
+
+await test('params is part of the typed fetch options', async () => {
+  const dts = fs.readFileSync(new URL('../build/internal/fetcher/fetcher.d.mts', import.meta.url), 'utf8');
+  assert(/params\?:/.test(dts), 'fetcher.d.mts declares params?');
+});
+
+console.log(`\n${colors.yellow}--- Fetcher query params test results ---${colors.reset}`);
+console.log(`${colors.green}Passed: ${passed}${colors.reset}`);
+console.log(`${colors.red}Failed: ${failed}${colors.reset}`);
+
+if (failed > 0) {
+  process.exit(1);
+}

package/test/fixtures/transform/basic/expected.json

@@ -0,0 +1,9 @@
+{
+ "text": "\n/**\n * greet somebody\n *\n * @namespace demo\n * @example usage\n```javascript\ngreet({name: 'Ann'})\n```\n **/    \ndeclare function greet({name; times = 2; loud = false; label = 'x'; neg = -1; nothing}: {\n/**\nwho to greet, e.g. Ann\n */\n name: any; \n/**\nhow often\n */\n times: any; \n/**\n\n */\n loud: any; \n/**\n\n */\n label: any; \n/**\n\n */\n neg: any; \n/**\n\n */\n nothing: any}): { ok: boolean; greeting: any; };\n      \n/**\n * no params\n *\n * \n * \n **/    \ndeclare function ping(): { ok: boolean; };\n      \n/**\n * \n *\n * \n * \n **/    \ndeclare function list(): string[];\n      \n/**\n * \n *\n * \n * \n **/    \ndeclare function nothing(): void;\n      ",
+ "methods": [
+  "greet",
+  "ping",
+  "list",
+  "nothing"
+ ]
+}

package/test/fixtures/transform/basic/src/controller/abstract.mts

@@ -0,0 +1,5 @@
+// stands in for AbstractController from @aloma.io/integration-sdk
+export class AbstractController {
+  protected config: any = {};
+  async inheritedPublic(): Promise<void> {}
+}

package/test/fixtures/transform/basic/src/controller/index.mts

@@ -0,0 +1,30 @@
+import {AbstractController} from './abstract.mjs';
+
+export default class Controller extends AbstractController {
+  /**
+   * greet somebody
+   * @param name - who to greet, e.g. Ann
+   * @param times - how often
+   * @param opts - extra \@options
+   * @namespace demo
+   *
+   * @example
+   * ```javascript
+   * greet({name: 'Ann'})
+   * ```
+   */
+  async greet({name, times = 2, loud = false, label = 'x', neg = -1, nothing = null}, other = 1) {
+    return {ok: true, greeting: name + times};
+  }
+
+  /** no params */
+  async ping() {
+    return {ok: true};
+  }
+
+  async list(): Promise<string[]> {
+    return [];
+  }
+
+  async nothing(): Promise<void> {}
+}

package/test/fixtures/transform/basic/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es2022","module":"node16","moduleResolution":"node16","skipLibCheck":true,"strict":true,"noImplicitAny":false,"experimentalDecorators":true,"esModuleInterop":true},"include":["src/**/*"]}

package/test/fixtures/transform/interface-param/src/controller/abstract.mts

@@ -0,0 +1,5 @@
+// stands in for AbstractController from @aloma.io/integration-sdk
+export class AbstractController {
+  protected config: any = {};
+  async inheritedPublic(): Promise<void> {}
+}

package/test/fixtures/transform/interface-param/src/controller/index.mts

@@ -0,0 +1,12 @@
+import {AbstractController} from './abstract.mjs';
+
+interface Opts {
+  id: string;
+  n?: number;
+}
+
+export default class Controller extends AbstractController {
+  async viaInterface({id, n}: Opts): Promise<{id: string; n: number | undefined}> {
+    return {id, n};
+  }
+}

package/test/fixtures/transform/interface-param/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es2022","module":"node16","moduleResolution":"node16","skipLibCheck":true,"strict":true,"noImplicitAny":false,"experimentalDecorators":true,"esModuleInterop":true},"include":["src/**/*"]}

package/test/fixtures/transform/overloads/expected.json

@@ -0,0 +1,6 @@
+{
+ "text": "\n/**\n * first form\n *\n * \n * \n **/    \ndeclare function over({a}: {\n/**\n\n */\n a: string}): string;\n      \n\n/**\n * second form\n *\n * \n * \n **/    \ndeclare function over({b}: {\n/**\n\n */\n b: number}): number;\n      ",
+ "methods": [
+  "over"
+ ]
+}

package/test/fixtures/transform/overloads/src/controller/abstract.mts

@@ -0,0 +1,5 @@
+// stands in for AbstractController from @aloma.io/integration-sdk
+export class AbstractController {
+  protected config: any = {};
+  async inheritedPublic(): Promise<void> {}
+}

package/test/fixtures/transform/overloads/src/controller/index.mts

@@ -0,0 +1,11 @@
+import {AbstractController} from './abstract.mjs';
+
+export default class Controller extends AbstractController {
+  /** first form */
+  async over({a}: {a: string}): Promise<string>;
+  /** second form */
+  async over({b}: {b: number}): Promise<number>;
+  async over(args: any): Promise<any> {
+    return args;
+  }
+}

package/test/fixtures/transform/overloads/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es2022","module":"node16","moduleResolution":"node16","skipLibCheck":true,"strict":true,"noImplicitAny":false,"experimentalDecorators":true,"esModuleInterop":true},"include":["src/**/*"]}

package/test/fixtures/transform/tdd-stub/expected.json

@@ -0,0 +1,8 @@
+{
+ "text": "\n/**\n * Returns recorded calls scoped to the current task.\n *\n * \n * @example usage\n```javascript\nconst log = await connectors.testing.getCallLog({})\n// log.calls = [{method, args, timestamp}, ...] for THIS task only\n```\n **/    \ndeclare function getCallLog(): { calls: CallRecord[]; count: number; };\n      \n/**\n * Resets the call log for the current task only.\n *\n * \n * @example usage\n```javascript\nawait connectors.testing.clearCallLog({})\n```\n **/    \ndeclare function clearCallLog(): { cleared: boolean; };\n      \n/**\n * Updates the response map for the current task at runtime.\n *\n * \n * @example usage\n```javascript\nawait connectors.testing.setResponses({\n  responses: { \"someConnector.create\": { id: \"456\" } }\n})\n```\n **/    \ndeclare function setResponses(): { updated: boolean; responseCount: number; };\n      ",
+ "methods": [
+  "getCallLog",
+  "clearCallLog",
+  "setResponses"
+ ]
+}

package/test/fixtures/transform/tdd-stub/src/controller/abstract.mts

@@ -0,0 +1,6 @@
+// stands in for AbstractController from @aloma.io/integration-sdk
+export class AbstractController {
+  protected config: any = {};
+  async inheritedPublic(): Promise<void> {}
+}
+export {};

package/test/fixtures/transform/tdd-stub/src/controller/index.mts

@@ -0,0 +1,204 @@
+import { AbstractController } from "./abstract.mjs";
+
+interface CallRecord {
+  method: string;
+  args: any;
+  timestamp: string;
+}
+
+/**
+ * Per-task scoped mock connector for ALOMA test workflows.
+ *
+ * State (responseMap, callLog) is keyed by ctx.taskId so concurrent
+ * test tasks against the same Testing pod do not contaminate each
+ * other's stubbed responses or recorded calls.
+ *
+ * Requires @aloma.io/integration-sdk ^3.8.67, which forwards
+ * { taskId, namespace, sticky } as the second arg to controller
+ * method handlers and to the __default fallback.
+ *
+ * Backward compatibility: when ctx is missing (legacy invocation or
+ * non-task call from admin UI), state falls into the "__no_ctx__"
+ * bucket so the connector does not crash. Isolation is NOT guaranteed
+ * in that mode — it is degraded compatibility only.
+ */
+export default class Controller extends AbstractController {
+  // Per-task scoped state — Maps keyed by taskId (insertion order = LRU order)
+  private responseMapByTask: Map<string, Record<string, any>> = new Map();
+  private callLogByTask: Map<string, CallRecord[]> = new Map();
+  private recording: boolean = true;
+  private defaultResponses: Record<string, any> = {};
+  // Memory cap (LRU). Configurable via config.maxTasks; default 1000.
+  private maxTasks: number = 1000;
+
+  protected async start() {
+    this.loadConfig();
+  }
+
+  private loadConfig() {
+    const config = this.config;
+
+    // Parse default responses from connector config — these seed each
+    // task's bucket when first touched.
+    if (config.responses) {
+      try {
+        this.defaultResponses =
+          typeof config.responses === "string"
+            ? JSON.parse(config.responses)
+            : config.responses;
+      } catch (e) {
+        this.defaultResponses = {};
+      }
+    } else {
+      this.defaultResponses = {};
+    }
+
+    this.recording = config.recordCalls !== "false";
+
+    // Allow config-driven override of LRU cap. Default 1000 if not set
+    // or not a positive number.
+    const configured = Number(config.maxTasks);
+    if (Number.isFinite(configured) && configured > 0) {
+      this.maxTasks = Math.floor(configured);
+    }
+  }
+
+  /**
+   * Resolve the bucket key for the current invocation. When ctx is
+   * absent or lacks taskId, falls back to a single shared bucket so
+   * legacy / hand-rolled callers do not crash. Isolation is not
+   * guaranteed in that mode.
+   */
+  private bucketKey(ctx?: { taskId?: string }): string {
+    return ctx && ctx.taskId ? ctx.taskId : "__no_ctx__";
+  }
+
+  /**
+   * LRU touch — ensures the bucket exists for the given key, evicting
+   * the least-recently-used entry if the cap would be exceeded. Map
+   * iteration order is insertion order; reinserting promotes a key to
+   * "most recently used" position.
+   */
+  private touchTask(key: string) {
+    // If not present and at cap, evict the oldest (insertion order)
+    if (!this.responseMapByTask.has(key)) {
+      if (this.responseMapByTask.size >= this.maxTasks) {
+        const firstKey = this.responseMapByTask.keys().next().value as
+          | string
+          | undefined;
+        if (firstKey !== undefined) {
+          this.responseMapByTask.delete(firstKey);
+          this.callLogByTask.delete(firstKey);
+        }
+      }
+      this.responseMapByTask.set(key, { ...this.defaultResponses });
+      this.callLogByTask.set(key, []);
+    }
+  }
+
+  /**
+   * Catch-all handler — registered as __default by the SDK via the
+   * fallback override below. Looks up the response in the task-scoped
+   * map, records the call in the task-scoped log, and returns the
+   * configured response or a default stub acknowledgement.
+   */
+  private async handleStubCall(
+    arg: any,
+    ctx?: { taskId?: string },
+  ): Promise<any> {
+    const key = this.bucketKey(ctx);
+    this.touchTask(key);
+
+    const method = Array.isArray(arg?.__method)
+      ? arg.__method.join(".")
+      : arg?.__method || "unknown";
+
+    if (this.recording) {
+      const log = this.callLogByTask.get(key)!;
+      log.push({
+        method,
+        args: { ...arg, __method: undefined },
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    const responseMap = this.responseMapByTask.get(key)!;
+    if (responseMap[method] !== undefined) {
+      return responseMap[method];
+    }
+    if (responseMap["default"] !== undefined) {
+      return responseMap["default"];
+    }
+
+    return { stubbed: true, method };
+  }
+
+  /**
+   * SDK override hook — invoked by AbstractController.__default with
+   * the per-invocation ctx (taskId, namespace, sticky) as second arg.
+   */
+  protected fallback(arg: any, ctx?: { taskId?: string }): Promise<any> {
+    return this.handleStubCall(arg, ctx);
+  }
+
+  /**
+   * Returns recorded calls scoped to the current task.
+   * @example
+   * ```javascript
+   * const log = await connectors.testing.getCallLog({})
+   * // log.calls = [{method, args, timestamp}, ...] for THIS task only
+   * ```
+   */
+  async getCallLog(_args: any, ctx?: { taskId?: string }) {
+    const key = this.bucketKey(ctx);
+    const calls = this.callLogByTask.get(key) || [];
+    return { calls: [...calls], count: calls.length };
+  }
+
+  /**
+   * Resets the call log for the current task only.
+   * @example
+   * ```javascript
+   * await connectors.testing.clearCallLog({})
+   * ```
+   */
+  async clearCallLog(_args: any, ctx?: { taskId?: string }) {
+    const key = this.bucketKey(ctx);
+    if (this.callLogByTask.has(key)) {
+      this.callLogByTask.set(key, []);
+    }
+    return { cleared: true };
+  }
+
+  /**
+   * Updates the response map for the current task at runtime.
+   * @example
+   * ```javascript
+   * await connectors.testing.setResponses({
+   *   responses: { "someConnector.create": { id: "456" } }
+   * })
+   * ```
+   */
+  async setResponses(args: any, ctx?: { taskId?: string }) {
+    const key = this.bucketKey(ctx);
+    this.touchTask(key);
+
+    if (args?.responses) {
+      try {
+        const newResponses =
+          typeof args.responses === "string"
+            ? JSON.parse(args.responses)
+            : args.responses;
+        const existing = this.responseMapByTask.get(key)!;
+        this.responseMapByTask.set(key, { ...existing, ...newResponses });
+      } catch (e) {
+        // ignore parse errors — leave existing map untouched
+      }
+    }
+
+    return {
+      updated: true,
+      responseCount: Object.keys(this.responseMapByTask.get(key)!).length,
+    };
+  }
+}

package/test/fixtures/transform/tdd-stub/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es2022","module":"node16","moduleResolution":"node16","skipLibCheck":true,"strict":true,"noImplicitAny":false,"experimentalDecorators":true,"esModuleInterop":true},"include":["src/**/*"]}

package/test/fixtures/transform/two-exports/src/controller/abstract.mts

@@ -0,0 +1,5 @@
+// stands in for AbstractController from @aloma.io/integration-sdk
+export class AbstractController {
+  protected config: any = {};
+  async inheritedPublic(): Promise<void> {}
+}

package/test/fixtures/transform/two-exports/src/controller/index.mts

@@ -0,0 +1,9 @@
+import {AbstractController} from './abstract.mjs';
+
+export interface Extra {
+  a: string;
+}
+
+export default class Controller extends AbstractController {
+  async one() {}
+}

package/test/fixtures/transform/two-exports/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es2022","module":"node16","moduleResolution":"node16","skipLibCheck":true,"strict":true,"noImplicitAny":false,"experimentalDecorators":true,"esModuleInterop":true},"include":["src/**/*"]}

package/test/fixtures/transform/type-error/src/controller/abstract.mts

@@ -0,0 +1,5 @@
+// stands in for AbstractController from @aloma.io/integration-sdk
+export class AbstractController {
+  protected config: any = {};
+  async inheritedPublic(): Promise<void> {}
+}

package/test/fixtures/transform/type-error/src/controller/index.mts

@@ -0,0 +1,7 @@
+import {AbstractController} from './abstract.mjs';
+
+export default class Controller extends AbstractController {
+  async one(): Promise<number> {
+    return 'not a number';
+  }
+}

package/test/fixtures/transform/type-error/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es2022","module":"node16","moduleResolution":"node16","skipLibCheck":true,"strict":true,"noImplicitAny":false,"experimentalDecorators":true,"esModuleInterop":true},"include":["src/**/*"]}