@jskit-ai/connectors-catalog 0.2.2 → 0.2.4

package/test/brevo.test.js

@@ -20,7 +20,7 @@ test("Brevo explicitly sends messages and campaigns, manages contacts and retain
       return state.response === null ? new Response(null, { status: 204 }) : Response.json(state.response, { status: state.status }); }
   });
   const invoke = (operation, input = {}) => service.invoke({ ...identity, operation, input }); await service.connectApiKey(identity);
-  const sender = { email: "bookings@example.test", name: "Dog and Groom" };
+  const sender = { email: "bookings@example.test", name: "Example Bookings" };
   const email = { sender, to: [{ email: "customer@example.test" }], subject: "Booking confirmed", textContent: "Tuesday at 10" };
   const dns = { brevo_code: { host_name: "example.test", type: "TXT", value: "brevo-code:fixture", status: false },
     dkim_record: { host_name: "mail._domainkey.example.test", type: "TXT", value: "fixture-dkim", status: false } };

package/test/chargebee.test.js

@@ -149,7 +149,7 @@ test("Chargebee app billing uses indexed forms, explicit idempotency and verifie
   const returns = { redirect_url: "https://app.example/billing/return", cancel_url: "https://app.example/billing/cancel" };
   const samples = [
     ["customers.create", "customers", { email: "sam@example.test", first_name: "Sam", id: "customer-1" }, { customer: { id: "customer-1" } }],
-    ["customers.update", "customers/customer-1", { resource: "customer-1", company: "Dog and Groom" }, { customer: { id: "customer-1", company: "Dog and Groom" } }],
+    ["customers.update", "customers/customer-1", { resource: "customer-1", company: "Example Grooming" }, { customer: { id: "customer-1", company: "Example Grooming" } }],
     ["subscriptions.create", "customers/customer-1/subscription_for_items", { resource: "customer-1", subscription_items: items, auto_collection: "off", invoice_immediately: false }, { subscription: { id: "sub-1", status: "active" }, unbilled_charges: [{ id: "charge-1" }] }],
     ["subscriptions.updateAtTermEnd", "subscriptions/sub-1/update_for_items", { resource: "sub-1", subscription_items: items, replace_items_list: true }, { subscription: { id: "sub-1", has_scheduled_changes: true } }, { end_of_term: "true" }],
     ["subscriptions.cancelAtTermEnd", "subscriptions/sub-1/cancel_for_items", { resource: "sub-1" }, { subscription: { id: "sub-1", status: "non_renewing" } }, { cancel_option: "end_of_term" }],

package/test/google-ads.test.js

@@ -274,7 +274,7 @@ async function searchFixture(t) {
     if (url.pathname.endsWith("campaigns:mutate")) { live.campaign.status = body.operations[0].update.status; return { results: [{ resourceName: `customers/${customerId}/campaigns/33` }] }; }
     if (url.pathname.endsWith("conversionActions:mutate")) return { results: [{ resourceName: `customers/${customerId}/conversionActions/22` }] };
     const q = body.query;
-    if (q.includes("FROM customer ")) return { results: [{ customer: { id: customerId, descriptiveName: "Dog And Groom", currencyCode: "AUD", timeZone: "Australia/Perth", status: "ENABLED", manager: false } }] };
+    if (q.includes("FROM customer ")) return { results: [{ customer: { id: customerId, descriptiveName: "Example Grooming", currencyCode: "AUD", timeZone: "Australia/Perth", status: "ENABLED", manager: false } }] };
     if (q.includes("FROM conversion_action")) return { results: [{ conversionAction: { id: "22", name: "Booking", type: "WEBPAGE", status: "ENABLED", tagSnippets: [{ eventSnippet: "<script>fixture-only</script>" }] } }] };
     if (q.includes("FROM geo_target_constant")) return { results: [{ geoTargetConstant: { id: "2036", canonicalName: "Australia" } }] };
     if (q.includes("FROM language_constant")) return { results: [{ languageConstant: { id: "1000", name: "English" } }] };
@@ -345,9 +345,13 @@ test("Search rejects stale plans and live budgets, unsupported campaigns and den
 
 test("Search application command fragment reuses the native service and emits bounded display results", async t => {
   const f = await searchFixture(t);
-  const request = { protocol: "vibe64.integration-setup.command.v1", requestId: "ads-fixture", operation: "ads-preview", ads: {} };
-  const reply = await dispatchAdsSetup(request, f.ads);
+  const host = { protocol: "example-host.integration-setup.command.v1", maxResponseBytes: 32768 };
+  const request = { protocol: host.protocol, requestId: "ads-fixture", operation: "ads-preview", ads: {} };
+  const reply = await dispatchAdsSetup(request, f.ads, host);
   assert.equal(reply.status, "ads"); assert.equal(reply.operation, "ads-preview"); assert.equal(reply.data.plan.name, searchPlan.name);
+  assert.equal(reply.protocol, host.protocol);
   assert.equal(JSON.stringify(reply).includes("access-fixture"), false);
-  await assert.rejects(dispatchAdsSetup({ ...request, operation: "ads-arbitrary" }, f.ads));
+  await assert.rejects(dispatchAdsSetup({ ...request, operation: "ads-arbitrary" }, f.ads, host));
+  await assert.rejects(dispatchAdsSetup({ ...request, protocol: "other-host.command.v1" }, f.ads, host), /Invalid advertising setup request/);
+  await assert.rejects(dispatchAdsSetup(request, f.ads, { ...host, maxResponseBytes: 64 }), /exceeds the host's response limit/);
 });

package/test/linkedin.test.js

@@ -201,7 +201,7 @@ test("LinkedIn respects host policy, registration identity and unavailable manag
   await assert.rejects(service.invoke({ ...input, operation: "profile.read" })); assert.equal(state.calls.length, count); state.deny = false;
   const changed = structuredClone(configuration); changed.registrations.linkedin.clientId = "other-client";
   await assert.rejects(createConnectionService({ ...options, configuration: changed }).invoke({ ...input, operation: "profile.read" }), { code: "connector_reconnect_required" });
-  changed.registrations.linkedin = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:GATEWAY_KEY", assignmentRef: "online" };
+  changed.registrations.linkedin = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:GATEWAY_KEY", assignmentRef: "shared" };
   assert.throws(() => createConnectionService({ ...options, configuration: changed }), { code: "integration_configuration_invalid" });
   assert.equal(state.calls.length, count);
 });

package/test/resend.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createHash } from "node:crypto";
 import { createLocalAuthService, createLocalFileBackend } from "../../auth-provider-local-core/src/server/lib/index.js";
+import { localServiceOptions } from "../../auth-provider-local-core/test-support/localService.js";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
@@ -82,9 +83,8 @@ test("documented application wiring sends auth recovery through the Resend adapt
   const createRecoverySender = new Function("createHash", `${example.replace('import { createHash } from "node:crypto";', "")}\nreturn createRecoverySender;`)(createHash);
   const sender = createRecoverySender({ connections: service, context, integrationId: "mail", from: input.from });
   const auth = createLocalAuthService({
+    ...localServiceOptions({ env: { APP_PUBLIC_URL: "https://app.example.com" }, emailRecovery: true }),
     backend: createLocalFileBackend({ storeDir: path.join(directory, "auth") }),
-    config: { nodeEnv: "test", sessionSecret: "fixture-session-secret",
-      appPublicUrl: "https://app.example.com", recoveryDevOutput: "response" },
     recoverySender: sender
   });
   await auth.register({ email: "person@example.com", password: "correct horse battery staple" });

package/test/salesforce.test.js

@@ -229,7 +229,7 @@ test("Salesforce host policy, cancelled/denied consent and managed references ca
   f.state.deny = true; await assert.rejects(f.service.beginAuthorization(input), /Host denied/);
   assert.equal(f.state.requests.length, 0);
   f.state.deny = false;
-  const config = structuredClone(f.configuration); config.registrations.sf = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:APP", assignmentRef: "online" };
+  const config = structuredClone(f.configuration); config.registrations.sf = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:APP", assignmentRef: "shared" };
   assert.throws(() => createConnectionService({ ...f.options, configuration: config }), { code: "integration_configuration_invalid" });
   assert.equal(f.state.requests.length, 0);
 });

package/test/snowflake.test.js

@@ -11,8 +11,8 @@ import { snowflakeProvider } from "../src/server/snowflake.js";
 const context = { applicationId: "app-one", subjectId: "owner-one" };
 const args = { context, integrationId: "warehouse" };
 const callback = "https://app.example.test/oauth/snowflake/callback";
-const database = { name: "INVENTORY", owner: "VIBE64_READER", kind: "PERMANENT", comment: "Stock", created_on: "2026-09-01T12:00:00Z" };
-async function fixture(t, { role = "VIBE64_READER", accountUrl = "https://myorg-myaccount.snowflakecomputing.com", basic = false, sqlContext = {} } = {}) {
+const database = { name: "INVENTORY", owner: "REPORTING_READER", kind: "PERMANENT", comment: "Stock", created_on: "2026-09-01T12:00:00Z" };
+async function fixture(t, { role = "REPORTING_READER", accountUrl = "https://myorg-myaccount.snowflakecomputing.com", basic = false, sqlContext = {} } = {}) {
   const directory = await mkdtemp(path.join(tmpdir(), "snowflake-connector-"));
   t.after(() => rm(directory, { recursive: true, force: true }));
   const settings = { accountUrl, ...(role ? { role } : {}), ...sqlContext };
@@ -84,7 +84,7 @@ async function fixture(t, { role = "VIBE64_READER", accountUrl = "https://myorg-
 test("Snowflake binds PKCE and credentials to the account and persists encrypted restartable consent", async (t) => {
   const f = await fixture(t); const start = await f.start();
   assert.equal(start.url.href.split("?")[0], "https://myorg-myaccount.snowflakecomputing.com/oauth/authorize");
-  assert.equal(start.url.searchParams.get("scope"), "refresh_token session:role:VIBE64_READER");
+  assert.equal(start.url.searchParams.get("scope"), "refresh_token session:role:REPORTING_READER");
   assert.equal(start.url.searchParams.get("code_challenge_method"), "S256"); assert.equal(start.url.searchParams.has("client_secret"), false);
   await f.service.completeAuthorization({ ...args, callbackUrl: start.callbackUrl });
   for (const file of await readdir(f.directory)) {
@@ -93,7 +93,7 @@ test("Snowflake binds PKCE and credentials to the account and persists encrypted
   }
   const restarted = createConnectionService(f.options);
   assert.equal((await restarted.status(args)).status, "connected");
-  assert.deepEqual((await restarted.status(args)).grantedScopes, ["refresh_token", "session:role:VIBE64_READER"]);
+  assert.deepEqual((await restarted.status(args)).grantedScopes, ["refresh_token", "session:role:REPORTING_READER"]);
   assert.deepEqual(await restarted.invoke({ ...args, operation: "databases.list" }), [database]);
 });
 
@@ -133,7 +133,7 @@ test("Snowflake isolates application users and invalidates saved grants after ac
   }
   const denied = createConnectionService({ ...f.options, authorize: async () => null });
   await assert.rejects(denied.invoke({ ...args, operation: "databases.list" }), { code: "connector_access_denied" });
-  for (const settings of [{ accountUrl: "https://other-account.snowflakecomputing.com", role: "VIBE64_READER" }, { accountUrl: "https://myorg-myaccount.snowflakecomputing.com", role: "PUBLIC" }]) {
+  for (const settings of [{ accountUrl: "https://other-account.snowflakecomputing.com", role: "REPORTING_READER" }, { accountUrl: "https://myorg-myaccount.snowflakecomputing.com", role: "PUBLIC" }]) {
     const configuration = structuredClone(f.options.configuration); configuration.integrations.warehouse.settings = settings;
     configuration.integrations.warehouse.scopes = getProviderScopes(snowflakeProvider, settings).map((scope) => scope.value);
     const changed = createConnectionService({ ...f.options, configuration });
@@ -246,14 +246,14 @@ test("Snowflake SQL lifecycle binds context, preserves typed partitions and canc
   let phase = 0;
   state.sqlReply = (url, init) => {
     assert.equal(new Headers(init.headers).get("authorization"), "Bearer private-access-1");
-    assert.equal(new Headers(init.headers).get("x-snowflake-role"), '\"VIBE64_READER\"');
+    assert.equal(new Headers(init.headers).get("x-snowflake-role"), '\"REPORTING_READER\"');
     assert.equal(init.redirect, "error");
     if (phase++ === 0) {
       assert.equal(init.method, "POST");
       assert.equal(url.searchParams.get("requestId"), requestId);
       assert.equal(url.searchParams.get("async"), "true");
       assert.deepEqual(JSON.parse(init.body), { statement: "select ?", bindings: { "1": { type: "FIXED", value: "9007199254740993" } }, timeout: 60,
-        warehouse: "APP_WH", database: "DATA", schema: "PUBLIC", role: "VIBE64_READER", parameters: { multi_statement_count: "1" } });
+        warehouse: "APP_WH", database: "DATA", schema: "PUBLIC", role: "REPORTING_READER", parameters: { multi_statement_count: "1" } });
       return Response.json({ code: "333334", statementHandle: handle, statementStatusUrl: "https://untrusted.test/never-follow" }, { status: 202 });
     }
     assert.equal(url.pathname, `/api/v2/statements/${handle}${phase === 4 ? "/cancel" : ""}`);

package/test/tiktok.test.js

@@ -231,7 +231,7 @@ test("TikTok enforces host policy, registration ownership and unavailable manage
   await assert.rejects(service.invoke({ ...input, operation: "profile.read" })); assert.equal(state.calls.length, before); state.deny = false;
   const changed = structuredClone(configuration); changed.registrations.tiktok.clientId = "other-key";
   await assert.rejects(createConnectionService({ ...options, configuration: changed }).invoke({ ...input, operation: "profile.read" }), { code: "connector_reconnect_required" });
-  changed.registrations.tiktok = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:GATEWAY_KEY", assignmentRef: "online" };
+  changed.registrations.tiktok = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:GATEWAY_KEY", assignmentRef: "shared" };
   assert.throws(() => createConnectionService({ ...options, configuration: changed }), { code: "integration_configuration_invalid" });
   assert.equal(state.calls.length, before);
 });

package/test/wiz.test.js

@@ -104,7 +104,7 @@ test("Wiz preserves Auth0 configuration but rejects unsupported execution before
   const f = await fixture(t); f.config.integrations.security.settings.tokenUrl = "https://auth.wiz.io/oauth/token";
   assert.equal(validateIntegrationConfiguration(f.config, { providers: [wizDefinition] }).integrations.security.settings.tokenUrl, "https://auth.wiz.io/oauth/token");
   await assert.rejects(f.scanner().scan(args), { code: "connector_authentication_unsupported" }); assert.deepEqual(f.resolutions, []);
-  f.config.registrations.wiz = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:IDENTITY", assignmentRef: "online-wiz" };
+  f.config.registrations.wiz = { source: "managed", serviceUrlRef: "env:GATEWAY", serviceCredentialRef: "env:IDENTITY", assignmentRef: "shared-wiz" };
   assert.throws(() => f.scanner(), { code: "integration_configuration_invalid" }); assert.deepEqual(f.resolutions, []);
 });