@jskit-ai/connectors-catalog 0.2.2 → 0.2.4

package/src/server/gemini-enterprise.js

@@ -2,6 +2,8 @@ import { createSchema } from "json-rest-schema";
 import { geminiEnterpriseDefinition, geminiEnterpriseScope } from "../shared/gemini-enterprise.js";
 import { googleProvider } from "./google.js";
 import { jsonOperation } from "./jsonOperation.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+import { isText } from "./connectorValues.js";
 
 function apiOrigin({ location = "global" } = {}) {
   return `https://${location === "global" ? "" : `${location}-`}discoveryengine.googleapis.com`;
@@ -9,12 +11,10 @@ function apiOrigin({ location = "global" } = {}) {
 function engineUrl(settings) {
   return `${apiOrigin(settings)}/v1/projects/${settings.projectId}/locations/${settings.location || "global"}/collections/default_collection/engines/${settings.engineId}`;
 }
-const object = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
-const text = (value) => typeof value === "string" && value.length > 0;
 const geminiEnterpriseProvider = Object.freeze({
   ...googleProvider(geminiEnterpriseDefinition, apiOrigin(), "engine.get", {
     "engine.get": {
-      ...jsonOperation(engineUrl, {}, (result) => object(result) && !result.error && text(result.displayName)
+      ...jsonOperation(engineUrl, {}, (result) => isRecord(result) && !result.error && isText(result.displayName)
         && typeof result.name === "string" && /^projects\/[a-z0-9-]+\/locations\/(global|us|eu)\/collections\/default_collection\/engines\/[a-z0-9][a-z0-9_-]{0,62}$/u.test(result.name)),
       scopes: [geminiEnterpriseScope]
     },
@@ -33,12 +33,12 @@ const geminiEnterpriseProvider = Object.freeze({
           }) }
         }) },
         pageToken: { type: "string", minLength: 1, maxLength: 16000, noTrim: true }
-      }, (result) => object(result) && !result.error && text(result.attributionToken)
+      }, (result) => isRecord(result) && !result.error && isText(result.attributionToken)
         && (result.totalSize === undefined || Number.isInteger(result.totalSize) && result.totalSize >= 0)
         && (result.nextPageToken === undefined || typeof result.nextPageToken === "string")
         && (result.redirectUri === undefined || typeof result.redirectUri === "string")
         && (result.results === undefined || Array.isArray(result.results) && result.results.length <= 25
-          && result.results.every((item) => object(item) && text(item.id) && object(item.document))), "POST"),
+          && result.results.every((item) => isRecord(item) && isText(item.id) && isRecord(item.document))), "POST"),
       scopes: [geminiEnterpriseScope]
     }
   }),

package/src/server/google-ads-search.js

@@ -4,25 +4,25 @@ import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 import { ConnectorError } from "@jskit-ai/connectors-core/server";
 import { validateGoogleAdsSearchPlan } from "../shared/google-ads-search.js";
 import { validatedOperation } from "./jsonOperation.js";
+import { googleAdsApi, googleAdsScope, loginCustomerHeaders } from "./googleAdsApi.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
-const api = "https://googleads.googleapis.com/v25";
-const scope = "https://www.googleapis.com/auth/adwords";
 const customerId = { type: "string", required: true, validator: value => /^[0-9]{10}$/.test(value) || "Use a ten-digit customer ID." };
 const id = { type: "string", required: true, validator: value => /^[0-9]{1,20}$/.test(value) || "Use a numeric campaign ID." };
 const error = (message, codes) => { throw new ConnectorError("connector_input_invalid", message, { statusCode: 422, ...codes }); };
 const hash = value => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 function requestOperation(fields, build, validateResult) {
   return validatedOperation(fields, (values, settings) => (
-    { method: "POST", ...build(values), headers: settings.loginCustomerId ? { "login-customer-id": settings.loginCustomerId } : {} }
-  ), validateResult, [scope]);
+    { method: "POST", ...build(values), headers: loginCustomerHeaders(settings) }
+  ), validateResult, [googleAdsScope]);
 }
-const mutated = result => result && typeof result === "object" && !Array.isArray(result) && !result.partialFailureError &&
+const mutated = result => isRecord(result) && !result.partialFailureError &&
   (result.results === undefined || Array.isArray(result.results)) && (result.mutateOperationResponses === undefined || Array.isArray(result.mutateOperationResponses));
 
 function searchMutation(plan, validateOnly) {
   const p = validateGoogleAdsSearchPlan(plan), root = `customers/${p.customerId}`;
   const budget = `${root}/campaignBudgets/-1`, campaign = `${root}/campaigns/-2`, group = `${root}/adGroups/-3`, goal = `${root}/customConversionGoals/-4`;
-  return { url: `${api}/${root}/googleAds:mutate`, body: { validateOnly, partialFailure: false, mutateOperations: [
+  return { url: `${googleAdsApi}/${root}/googleAds:mutate`, body: { validateOnly, partialFailure: false, mutateOperations: [
     { campaignBudgetOperation: { create: { resourceName: budget, name: `${p.name} budget`, amountMicros: p.dailyBudgetMicros, deliveryMethod: "STANDARD", explicitlyShared: false } } },
     { campaignOperation: { create: { resourceName: campaign, name: p.name, advertisingChannelType: "SEARCH", status: "PAUSED", campaignBudget: budget,
       manualCpc: {}, containsEuPoliticalAdvertising: "DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING",
@@ -39,15 +39,28 @@ function searchMutation(plan, validateOnly) {
   ] } };
 }
 const googleAdsSearchOperations = {
-  "search.validate": { scopes: [scope], request: (input, settings) => ({ method: "POST", ...searchMutation(input, true), headers: settings.loginCustomerId ? { "login-customer-id": settings.loginCustomerId } : {} }), validateResult: mutated },
-  "search.createPaused": { scopes: [scope], request: (input, settings) => ({ method: "POST", ...searchMutation(input, false), headers: settings.loginCustomerId ? { "login-customer-id": settings.loginCustomerId } : {} }), validateResult: result => mutated(result) && Array.isArray(result.mutateOperationResponses) && result.mutateOperationResponses.some(item => /^customers\/[0-9]{10}\/campaigns\/[0-9]+$/.test(item.campaignResult?.resourceName || "")) },
+  "search.validate": { scopes: [googleAdsScope], request: (input, settings) => ({ method: "POST", ...searchMutation(input, true), headers: loginCustomerHeaders(settings) }), validateResult: mutated },
+  "search.createPaused": { scopes: [googleAdsScope], request: (input, settings) => ({ method: "POST", ...searchMutation(input, false), headers: loginCustomerHeaders(settings) }), validateResult: result => mutated(result) && Array.isArray(result.mutateOperationResponses) && result.mutateOperationResponses.some(item => /^customers\/[0-9]{10}\/campaigns\/[0-9]+$/.test(item.campaignResult?.resourceName || "")) },
   "campaigns.setStatus": requestOperation({ customerId, campaignId: id, status: { type: "string", required: true, enum: ["PAUSED", "ENABLED"] } },
-    p => ({ url: `${api}/customers/${p.customerId}/campaigns:mutate`, body: { operations: [{ update: { resourceName: `customers/${p.customerId}/campaigns/${p.campaignId}`, status: p.status }, updateMask: "status" }] } }), result => mutated(result) && result.results?.length === 1),
+    p => ({ url: `${googleAdsApi}/customers/${p.customerId}/campaigns:mutate`, body: { operations: [{ update: { resourceName: `customers/${p.customerId}/campaigns/${p.campaignId}`, status: p.status }, updateMask: "status" }] } }), result => mutated(result) && result.results?.length === 1),
   "conversions.createWebsite": requestOperation({ customerId, name: { type: "string", required: true, minLength: 1, maxLength: 100 } },
-    p => ({ url: `${api}/customers/${p.customerId}/conversionActions:mutate`, body: { operations: [{ create: { name: p.name, type: "WEBPAGE", category: "SUBMIT_LEAD_FORM", status: "ENABLED", countingType: "ONE_PER_CLICK", primaryForGoal: true } }] } }), result => mutated(result) && result.results?.length === 1)
+    p => ({ url: `${googleAdsApi}/customers/${p.customerId}/conversionActions:mutate`, body: { operations: [{ create: { name: p.name, type: "WEBPAGE", category: "SUBMIT_LEAD_FORM", status: "ENABLED", countingType: "ONE_PER_CLICK", primaryForGoal: true } }] } }), result => mutated(result) && result.results?.length === 1)
 };
 
-// Application composition: this service has no editor protocol, command runner or storage.
+/**
+ * Runs the saved Search plan through the Google Ads integration's operations: it
+ * discovers accounts and targets, reviews the plan and creates its campaign paused,
+ * creates a website conversion, inspects, launches and pauses a campaign, and reports
+ * campaign metrics. Creating and launching need the id of an unchanged review, a hash
+ * of the caller, the plan and what was reviewed; the service stores nothing.
+ * @param {object} options
+ * @param {import("@jskit-ai/connectors-core/server/types").ConnectorsCore} options.connections
+ *   The connection service whose Google Ads integration it invokes.
+ * @param {Record<string, any>} options.configuration The integration configuration, with the Search plan under `extensions.googleAdsSearch`.
+ * @param {{ applicationId: string, subjectId: string }} options.context The caller's context, which authorize() receives;
+ *   its application and subject also bind each review.
+ * @param {string} options.integrationId
+ */
 function createGoogleAdsSearchService({ connections, configuration, context, integrationId }) {
   const slot = configuration.integrations?.[integrationId];
   if (slot?.provider !== "google-ads") error("Choose a Google Ads integration.", { messageCode: "connectors.googleAdsSearch.chooseIntegration" });
@@ -90,44 +103,51 @@ function createGoogleAdsSearchService({ connections, configuration, context, int
     if (details.ads.length > 20 || details.targets.length > 30 || details.keywords.length > 30) error("This campaign exceeds the bounded Search review. Manage it in Google Ads.", { messageCode: "connectors.googleAdsSearch.campaignExceedsBoundedSearchReview" });
     return { ...details, reviewId: review(details) };
   }
-  return {
-    async discover(id) {
-      if (!id) return { accounts: (await invoke("customers.listAccessible", {})).resourceNames || [] };
-      const selected = await account(id);
-      return { account: selected,
-        clients: selected.manager ? (await invoke("customers.listClients", { customerId: id })).results || [] : [],
-        conversions: await query(id, "SELECT conversion_action.id, conversion_action.name, conversion_action.status, conversion_action.type, conversion_action.tag_snippets FROM conversion_action WHERE conversion_action.type = 'WEBPAGE' AND conversion_action.status = 'ENABLED' LIMIT 50"),
-        campaigns: await query(id, "SELECT campaign.id, campaign.name, campaign.status FROM campaign WHERE campaign.advertising_channel_type = 'SEARCH' AND campaign.status != 'REMOVED' LIMIT 50") };
-    },
-    async targets(id, name) {
-      customer(id);
-      if (typeof name !== "string" || !/^[\p{L}\p{N} .-]{2,80}$/u.test(name)) error("Enter a location name using letters, numbers, spaces, dots or hyphens.", { messageCode: "connectors.googleAdsSearch.enterLocationNameUsingLetters" });
-      return { locations: await query(id, `SELECT geo_target_constant.id, geo_target_constant.canonical_name, geo_target_constant.status FROM geo_target_constant WHERE geo_target_constant.name LIKE '%${name}%' AND geo_target_constant.status = 'ENABLED' LIMIT 20`),
-        languages: await query(id, "SELECT language_constant.id, language_constant.name FROM language_constant WHERE language_constant.targetable = TRUE LIMIT 100") };
-    },
+  async function discover(id) {
+    if (!id) return { accounts: (await invoke("customers.listAccessible", {})).resourceNames || [] };
+    const selected = await account(id);
+    return { account: selected,
+      clients: selected.manager ? (await invoke("customers.listClients", { customerId: id })).results || [] : [],
+      conversions: await query(id, "SELECT conversion_action.id, conversion_action.name, conversion_action.status, conversion_action.type, conversion_action.tag_snippets FROM conversion_action WHERE conversion_action.type = 'WEBPAGE' AND conversion_action.status = 'ENABLED' LIMIT 50"),
+      campaigns: await query(id, "SELECT campaign.id, campaign.name, campaign.status FROM campaign WHERE campaign.advertising_channel_type = 'SEARCH' AND campaign.status != 'REMOVED' LIMIT 50") };
+  }
+  async function targets(id, name) {
+    customer(id);
+    if (typeof name !== "string" || !/^[\p{L}\p{N} .-]{2,80}$/u.test(name)) error("Enter a location name using letters, numbers, spaces, dots or hyphens.", { messageCode: "connectors.googleAdsSearch.enterLocationNameUsingLetters" });
+    return { locations: await query(id, `SELECT geo_target_constant.id, geo_target_constant.canonical_name, geo_target_constant.status FROM geo_target_constant WHERE geo_target_constant.name LIKE '%${name}%' AND geo_target_constant.status = 'ENABLED' LIMIT 20`),
+      languages: await query(id, "SELECT language_constant.id, language_constant.name FROM language_constant WHERE language_constant.targetable = TRUE LIMIT 100") };
+  }
+  async function create(reviewId) {
+    const checked = await preview();
+    if (reviewId !== checked.reviewId) error("The Search plan changed. Review it again before creation.", { messageCode: "connectors.googleAdsSearch.searchPlanChangedReviewAgain" });
+    const response = await invoke("search.createPaused", checked.plan);
+    const resource = response.mutateOperationResponses.find(item => item.campaignResult)?.campaignResult.resourceName;
+    return { campaignId: resource.split("/").at(-1), status: "PAUSED" };
+  }
+  const createConversion = ({ customerId, name }) => invoke("conversions.createWebsite", { customerId, name });
+  async function launch({ campaignId, reviewId, trackingConfirmed, billingConfirmed }) {
+    const current = await campaign(campaignId);
+    if (current.reviewId !== reviewId) error("The campaign changed. Inspect and approve it again.", { messageCode: "connectors.googleAdsSearch.campaignChangedInspectApproveAgain" });
+    if (trackingConfirmed !== true || billingConfirmed !== true) error("Confirm installed conversion tracking and billing/advertiser readiness before launch.", { messageCode: "connectors.googleAdsSearch.confirmInstalledConversionTrackingBilling" });
+    if (current.account.manager || current.account.status !== "ENABLED") error("Choose an active client account.", { messageCode: "connectors.googleAdsSearch.chooseActiveClientAccount" });
+    if (current.campaign.containsEuPoliticalAdvertising !== "DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING" ||
+        !current.customGoals?.length || current.customGoals[0].customConversionGoal?.status !== "ENABLED") error("Review a non-political Search campaign with an enabled custom conversion goal.", { messageCode: "connectors.googleAdsSearch.reviewNonPoliticalSearchCampaign" });
+    if (!current.ads.length || !current.keywords.length || current.campaign.biddingStrategyType !== "MANUAL_CPC") error("This screen launches only Search campaigns with manual CPC, ads and keywords. Manage other campaigns in Google Ads.", { messageCode: "connectors.googleAdsSearch.screenLaunchesSearchCampaignsManual" });
+    if (current.campaign.status !== "PAUSED") error("Only a paused campaign can be launched here.", { messageCode: "connectors.googleAdsSearch.pausedCampaignCanLaunchedHere" });
+    return invoke("campaigns.setStatus", { customerId: current.customerId, campaignId, status: "ENABLED" });
+  }
+  const pause = id => invoke("campaigns.setStatus", { customerId: plan().customerId, campaignId: campaignId(id), status: "PAUSED" });
+  const report = async () => ({ campaigns: await query(plan().customerId, "SELECT campaign.id, campaign.name, campaign.status, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions FROM campaign WHERE segments.date DURING LAST_30_DAYS AND campaign.advertising_channel_type = 'SEARCH' LIMIT 50") });
+  return Object.freeze({
+    discover,
+    targets,
     preview,
-    async create(reviewId) {
-      const checked = await preview();
-      if (reviewId !== checked.reviewId) error("The Search plan changed. Review it again before creation.", { messageCode: "connectors.googleAdsSearch.searchPlanChangedReviewAgain" });
-      const response = await invoke("search.createPaused", checked.plan);
-      const resource = response.mutateOperationResponses.find(item => item.campaignResult)?.campaignResult.resourceName;
-      return { campaignId: resource.split("/").at(-1), status: "PAUSED" };
-    },
-    createConversion: ({ customerId, name }) => invoke("conversions.createWebsite", { customerId, name }),
+    create,
+    createConversion,
     campaign,
-    async launch({ campaignId, reviewId, trackingConfirmed, billingConfirmed }) {
-      const current = await campaign(campaignId);
-      if (current.reviewId !== reviewId) error("The campaign changed. Inspect and approve it again.", { messageCode: "connectors.googleAdsSearch.campaignChangedInspectApproveAgain" });
-      if (trackingConfirmed !== true || billingConfirmed !== true) error("Confirm installed conversion tracking and billing/advertiser readiness before launch.", { messageCode: "connectors.googleAdsSearch.confirmInstalledConversionTrackingBilling" });
-      if (current.account.manager || current.account.status !== "ENABLED") error("Choose an active client account.", { messageCode: "connectors.googleAdsSearch.chooseActiveClientAccount" });
-      if (current.campaign.containsEuPoliticalAdvertising !== "DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING" ||
-          !current.customGoals?.length || current.customGoals[0].customConversionGoal?.status !== "ENABLED") error("Review a non-political Search campaign with an enabled custom conversion goal.", { messageCode: "connectors.googleAdsSearch.reviewNonPoliticalSearchCampaign" });
-      if (!current.ads.length || !current.keywords.length || current.campaign.biddingStrategyType !== "MANUAL_CPC") error("This screen launches only Search campaigns with manual CPC, ads and keywords. Manage other campaigns in Google Ads.", { messageCode: "connectors.googleAdsSearch.screenLaunchesSearchCampaignsManual" });
-      if (current.campaign.status !== "PAUSED") error("Only a paused campaign can be launched here.", { messageCode: "connectors.googleAdsSearch.pausedCampaignCanLaunchedHere" });
-      return invoke("campaigns.setStatus", { customerId: current.customerId, campaignId, status: "ENABLED" });
-    },
-    pause: id => invoke("campaigns.setStatus", { customerId: plan().customerId, campaignId: campaignId(id), status: "PAUSED" }),
-    report: async () => ({ campaigns: await query(plan().customerId, "SELECT campaign.id, campaign.name, campaign.status, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions FROM campaign WHERE segments.date DURING LAST_30_DAYS AND campaign.advertising_channel_type = 'SEARCH' LIMIT 50") })
-  };
+    launch,
+    pause,
+    report
+  });
 }
 export { googleAdsSearchOperations, createGoogleAdsSearchService };

package/src/server/google-ads.js

@@ -1,14 +1,12 @@
 import { createSchema } from "json-rest-schema";
 import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
-import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { ConnectorError, providerStatusError } from "@jskit-ai/connectors-core/server";
 import { googleAdsSearchOperations } from "./google-ads-search.js";
 import { googleAdsDefinition } from "../shared/google-ads.js";
 import { googleProvider, googleRead } from "./google.js";
+import { googleAdsOrigin, googleAdsApi, googleAdsScope, loginCustomerHeaders } from "./googleAdsApi.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
-const origin = "https://googleads.googleapis.com";
-const api = `${origin}/v25`;
-const scope = "https://www.googleapis.com/auth/adwords";
-const record = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const customerId = { type: "string", required: true, noTrim: true, minLength: 10, maxLength: 10,
   validator: (value) => /^[0-9]{10}$/u.test(value) || "Use a 10-digit customer ID without hyphens." };
 const pageToken = { type: "string", minLength: 1, maxLength: 4096, noTrim: true,
@@ -21,27 +19,27 @@ const clientsSchema = createSchema({ customerId, pageToken });
 
 function searchRequest(schema, input, settings, fixedQuery) {
   const { customerId: id, ...body } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-  return { method: "POST", url: `${api}/customers/${id}/googleAds:search`,
-    headers: settings.loginCustomerId ? { "login-customer-id": settings.loginCustomerId } : {},
+  return { method: "POST", url: `${googleAdsApi}/customers/${id}/googleAds:search`,
+    headers: loginCustomerHeaders(settings),
     body: fixedQuery ? { ...body, query: fixedQuery } : body };
 }
 
 function searchResult(value) {
-  return record(value) && !value.error &&
-    (value.results === undefined || Array.isArray(value.results) && value.results.length <= 10000 && value.results.every(record)) &&
+  return isRecord(value) && !value.error &&
+    (value.results === undefined || Array.isArray(value.results) && value.results.length <= 10000 && value.results.every(isRecord)) &&
     (value.nextPageToken === undefined || typeof value.nextPageToken === "string" && value.nextPageToken.length <= 4096 && !/[\p{Cc}]/u.test(value.nextPageToken)) &&
     (value.fieldMask === undefined || typeof value.fieldMask === "string") &&
     (value.totalResultsCount === undefined || typeof value.totalResultsCount === "string" && /^[0-9]+$/u.test(value.totalResultsCount));
 }
 
 const googleAdsProvider = Object.freeze({
-  ...googleProvider(googleAdsDefinition, origin, "customers.listAccessible", {
+  ...googleProvider(googleAdsDefinition, googleAdsOrigin, "customers.listAccessible", {
     ...googleAdsSearchOperations,
-    "customers.listAccessible": googleRead([scope], {}, () => ({ url: `${api}/customers:listAccessibleCustomers` }),
-      (value) => record(value) && !value.error && (value.resourceNames === undefined || Array.isArray(value.resourceNames) &&
+    "customers.listAccessible": googleRead([googleAdsScope], {}, () => ({ url: `${googleAdsApi}/customers:listAccessibleCustomers` }),
+      (value) => isRecord(value) && !value.error && (value.resourceNames === undefined || Array.isArray(value.resourceNames) &&
         value.resourceNames.every((name) => typeof name === "string" && /^customers\/[0-9]{10}$/u.test(name)))),
-    "reports.search": { scopes: [scope], request: (input, settings) => searchRequest(searchSchema, input, settings), validateResult: searchResult },
-    "customers.listClients": { scopes: [scope], request: (input, settings) => searchRequest(clientsSchema, input, settings,
+    "reports.search": { scopes: [googleAdsScope], request: (input, settings) => searchRequest(searchSchema, input, settings), validateResult: searchResult },
+    "customers.listClients": { scopes: [googleAdsScope], request: (input, settings) => searchRequest(clientsSchema, input, settings,
       "SELECT customer_client.client_customer, customer_client.level, customer_client.manager, customer_client.descriptive_name, customer_client.currency_code, customer_client.time_zone, customer_client.id, customer_client.status FROM customer_client"), validateResult: searchResult }
   }),
   async exchange(url, options, { fetchImpl }) {
@@ -55,7 +53,7 @@ const googleAdsProvider = Object.freeze({
     if (!response.ok || value?.error) {
       const details = Array.isArray(value?.error?.details) ? value.error.details : [];
       const errors = details.flatMap((detail) => Array.isArray(detail?.errors) ? detail.errors : []);
-      const codes = errors.flatMap((error) => record(error?.errorCode) ? Object.values(error.errorCode) : []);
+      const codes = errors.flatMap((error) => isRecord(error?.errorCode) ? Object.values(error.errorCode) : []);
       if (response.status === 429 || value?.error?.status === "RESOURCE_EXHAUSTED" || errors.some((error) => error?.errorCode?.quotaError)) {
         throw new ConnectorError("connector_rate_limited", "Google Ads API capacity is exhausted. Check the Cloud project and account quotas.", { statusCode: 429, messageCode: "connectors.googleAds.apiCapacityExhaustedCheckCloud" });
       }
@@ -70,9 +68,9 @@ const googleAdsProvider = Object.freeze({
       }
       if (response.status === 400) throw new ConnectorError("connector_input_invalid", "Google Ads rejected the operation. Check campaign fields, policy requirements and account permissions.", { statusCode: 422, messageCode: "connectors.googleAds.rejectedOperationCheckCampaignFields" });
       if (response.status === 404) throw new ConnectorError("connector_resource_not_found", "This Google Ads resource is unavailable.", { statusCode: 404, messageCode: "connectors.googleAds.resourceUnavailable" });
-      throw Object.assign(new Error("Google Ads request failed."), { status: response.ok ? 502 : response.status });
+      throw providerStatusError(response.status);
     }
-    if (response.status !== 200 || !record(value)) throw new ConnectorError("connector_response_invalid", "Google Ads returned an unexpected response.", { statusCode: 502, messageCode: "connectors.shared.unexpectedResponse", messageParams: { provider: "Google Ads" } });
+    if (response.status !== 200 || !isRecord(value)) throw new ConnectorError("connector_response_invalid", "Google Ads returned an unexpected response.", { statusCode: 502, messageCode: "connectors.shared.unexpectedResponse", messageParams: { provider: "Google Ads" } });
     return value;
   }
 });

package/src/server/google-drive.js

@@ -1,12 +1,12 @@
 import { randomUUID } from "node:crypto";
-import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { ConnectorError, providerStatusError } from "@jskit-ai/connectors-core/server";
 import { googleDriveDefinition } from "../shared/google.js";
 import { googleOperation, googleRead, googleProvider, inputInvalid, pageToken } from "./google.js";
+import { hasStringId } from "./connectorValues.js";
 const origin = "https://www.googleapis.com";
 const fileId = { type: "string", required: true, minLength: 1, maxLength: 1024, validator: value => /^[A-Za-z0-9_-]+$/.test(value) || "Use a Drive file ID, not a URL." };
 const contentScopes = ["drive", "drive.file", "drive.readonly"];
 const writeScopes = ["drive", "drive.file"];
-const validFile = value => typeof value?.id === "string";
 const validBytes = value => typeof value?.bodyBase64 === "string" && Number.isInteger(value.size) && typeof value.contentType === "string";
 const fields = "id,name,mimeType,parents,size,trashed,webViewLink,capabilities,exportLinks";
 function url(fileId, query = {}, suffix = "") {
@@ -15,14 +15,14 @@ function url(fileId, query = {}, suffix = "") {
   return address.href;
 }
 const baseProvider = googleProvider(googleDriveDefinition, origin, "files.list", {
-  "files.get": googleRead([...contentScopes, "drive.metadata", "drive.metadata.readonly"], { fileId }, ({ fileId }) => ({ url: url(fileId, { supportsAllDrives: true, fields }) }), validFile),
+  "files.get": googleRead([...contentScopes, "drive.metadata", "drive.metadata.readonly"], { fileId }, ({ fileId }) => ({ url: url(fileId, { supportsAllDrives: true, fields }) }), hasStringId),
   "files.download": googleRead(contentScopes, { fileId }, ({ fileId }) => ({ url: url(fileId, { supportsAllDrives: true, alt: "media" }) }), validBytes),
   "files.export": googleRead(contentScopes, { fileId, mimeType: { type: "string", required: true, minLength: 1, maxLength: 200 } }, ({ fileId, mimeType }) => ({ url: url(fileId, { mimeType }, "/export") }), validBytes),
-  "files.create": googleOperation(writeScopes, { name: { type: "string", required: true, minLength: 1, maxLength: 1024 }, parentId: { ...fileId, required: false }, folder: { type: "boolean", defaultTo: false } }, ({ name, parentId, folder }) => ({ method: "POST", url: url(undefined, { supportsAllDrives: true, fields }), body: { name, ...(parentId ? { parents: [parentId] } : {}), ...(folder ? { mimeType: "application/vnd.google-apps.folder" } : {}) } }), validFile),
+  "files.create": googleOperation(writeScopes, { name: { type: "string", required: true, minLength: 1, maxLength: 1024 }, parentId: { ...fileId, required: false }, folder: { type: "boolean", defaultTo: false } }, ({ name, parentId, folder }) => ({ method: "POST", url: url(undefined, { supportsAllDrives: true, fields }), body: { name, ...(parentId ? { parents: [parentId] } : {}), ...(folder ? { mimeType: "application/vnd.google-apps.folder" } : {}) } }), hasStringId),
   "files.update": googleOperation([...writeScopes, "drive.metadata"], { fileId, name: { type: "string", minLength: 1, maxLength: 1024 }, description: { type: "string", maxLength: 16384 }, trashed: { type: "boolean" } }, ({ fileId, ...body }) => {
     if (!Object.keys(body).length) throw inputInvalid("Supply a name, description or trashed value.", { messageCode: "connectors.googleDrive.metadataChangeRequired" });
     return { method: "PATCH", url: url(fileId, { supportsAllDrives: true, fields }), body };
-  }, validFile),
+  }, hasStringId),
   "files.upload": googleOperation(writeScopes, {
     fileId: { ...fileId, required: false }, name: { type: "string", required: true, minLength: 1, maxLength: 1024 },
     parentId: { ...fileId, required: false }, contentType: { type: "string", required: true, minLength: 3, maxLength: 200 },
@@ -39,7 +39,7 @@ const baseProvider = googleProvider(googleDriveDefinition, origin, "files.list",
     const metadata = { name, ...(parentId ? { parents: [parentId] } : {}) };
     const body = Buffer.concat([Buffer.from(`--${boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n${JSON.stringify(metadata)}\r\n--${boundary}\r\nContent-Type: ${contentType}\r\n\r\n`), data, Buffer.from(`\r\n--${boundary}--\r\n`)]);
     return { method: fileId ? "PATCH" : "POST", url: url(fileId, { uploadType: "multipart", supportsAllDrives: true, fields }).replace("/drive/v3/", "/upload/drive/v3/"), headers: { "Content-Type": `multipart/related; boundary=${boundary}` }, body };
-  }, validFile),
+  }, hasStringId),
   "files.list": googleRead(["drive", "drive.file", "drive.metadata", "drive.metadata.readonly", "drive.readonly", "drive.meet.readonly", "drive.photos.readonly"], {
     pageToken, pageSize: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
     q: { type: "string", maxLength: 8192 },
@@ -56,7 +56,7 @@ const googleDriveProvider = Object.freeze({ ...baseProvider,
     const download = target.searchParams.get("alt") === "media" || target.pathname.endsWith("/export");
     if (!upload && !download) return request(address, options);
     const response = await fetchImpl(address, { ...options, credentials: "omit", redirect: "error" });
-    if (!response.ok) { await response.body?.cancel(); throw Object.assign(new Error("Google Drive transfer failed."), { status: response.status }); }
+    if (!response.ok) { await response.body?.cancel(); throw providerStatusError(response.status); }
     const chunks = []; let size = 0;
     const reader = response.body?.getReader();
     if (reader) try { while (true) {

package/src/server/google-maps-platform.js

@@ -3,6 +3,8 @@ import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 import { ConnectorError } from "@jskit-ai/connectors-core/server";
 import { googleMapsPlatformDefinition } from "../shared/google-maps-platform.js";
 import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+import { hasStringId } from "./connectorValues.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 const endpoint = "https://maps.googleapis.com/maps/api/geocode/json";
 const language = { type: "string", minLength: 2, maxLength: 35,
@@ -53,7 +55,7 @@ const googleMapsPlatformProvider = Object.freeze({
   },
   operations: {
     "places.search": validatedOperation({ textQuery: { type: "string", required: true, minLength: 1, maxLength: 1000 }, pageSize: { type: "integer", min: 1, max: 20, defaultTo: 10 }, pageToken: { type: "string", minLength: 1, maxLength: 4096 }, languageCode: language }, body => ({ method: "POST", url: "https://places.googleapis.com/v1/places:searchText", headers: { "X-Goog-FieldMask": placeFields.split(",").map(field => `places.${field}`).join(",") + ",nextPageToken" }, body }),
-      result => Boolean(result && typeof result === "object" && !Array.isArray(result) && !result.error && (result.places === undefined || Array.isArray(result.places) && result.places.every(place => typeof place?.id === "string")))),
+      result => Boolean(isRecord(result) && !result.error && (result.places === undefined || Array.isArray(result.places) && result.places.every(hasStringId)))),
     "places.get": validatedOperation({ placeId: { type: "string", required: true, minLength: 1, maxLength: 512, validator: value => /^[A-Za-z0-9_-]+$/.test(value) || "Use a place ID, not a URL." } }, ({ placeId }) => ({ method: "GET", url: `https://places.googleapis.com/v1/places/${encodeURIComponent(placeId)}`, headers: { "X-Goog-FieldMask": placeFields } }), result => typeof result?.id === "string"),
     "routes.compute": validatedOperation({ originLatitude: latitude, originLongitude: longitude, destinationLatitude: latitude, destinationLongitude: longitude,
       travelMode: { type: "string", enum: ["DRIVE", "WALK", "BICYCLE"], defaultTo: "DRIVE" }
@@ -61,7 +63,7 @@ const googleMapsPlatformProvider = Object.freeze({
       origin: { location: { latLng: { latitude: originLatitude, longitude: originLongitude } } },
       destination: { location: { latLng: { latitude: destinationLatitude, longitude: destinationLongitude } } },
       travelMode, polylineEncoding: "GEO_JSON_LINESTRING"
-    } }), result => Boolean(result && typeof result === "object" && !Array.isArray(result) && !result.error && (result.routes === undefined || Array.isArray(result.routes)))),
+    } }), result => Boolean(isRecord(result) && !result.error && (result.routes === undefined || Array.isArray(result.routes)))),
     "geocoding.forward": jsonOperation(endpoint, {
       address: { type: "string", required: true, minLength: 1, maxLength: 1000,
         validator: (value) => Boolean(value.trim()) || "Enter an address or plus code." },

package/src/server/google-search-console.js

@@ -1,5 +1,6 @@
 import { googleSearchConsoleDefinition } from "../shared/google.js";
 import { googleOperation, googleRead, googleProvider, inputInvalid } from "./google.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 const origin = "https://searchconsole.googleapis.com";
 const readScopes = ["webmasters.readonly", "webmasters"];
 const website = value => { try { const url = new URL(value); return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.hash; } catch { return false; } };
@@ -7,13 +8,13 @@ const siteUrl = { type: "string", required: true, minLength: 1, maxLength: 2048,
 const feedpath = { type: "string", required: true, minLength: 1, maxLength: 2048, validator: value => website(value) || "Use the full sitemap URL." };
 const date = { type: "string", required: true, maxLength: 10, validator: value => /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value || "Use a valid YYYY-MM-DD date." };
 const dimensions = ["date", "country", "device", "page", "query", "searchAppearance"];
-const plain = value => Boolean(value && typeof value === "object" && !Array.isArray(value) && !value.error);
+const plain = value => Boolean(isRecord(value) && !value.error);
 function propertyPath(site) { return `${origin}/webmasters/v3/sites/${encodeURIComponent(site)}`; }
 const googleSearchConsoleProvider = googleProvider(googleSearchConsoleDefinition, origin, "sites.list", {
   "sites.get": googleRead(readScopes, { siteUrl }, ({ siteUrl }) => ({ url: propertyPath(siteUrl) }), value => typeof value?.siteUrl === "string" && typeof value.permissionLevel === "string"),
   "searchAnalytics.query": googleOperation(readScopes, { siteUrl, startDate: date, endDate: date,
     dimensions: { type: "array", validator: value => value.length <= dimensions.length && new Set(value).size === value.length && value.every(dimension => dimensions.includes(dimension)) || "Choose distinct supported dimensions." },
-    filters: { type: "array", validator: filters => filters.length <= 100 && filters.every(filter => filter && typeof filter === "object" && !Array.isArray(filter) && Object.keys(filter).every(key => ["dimension", "operator", "expression"].includes(key)) && dimensions.includes(filter.dimension) && filter.dimension !== "date" && ["contains", "equals", "notContains", "notEquals", "includingRegex", "excludingRegex"].includes(filter.operator) && typeof filter.expression === "string" && filter.expression.length <= 4096) || "Use supported dimension/operator/expression filters." },
+    filters: { type: "array", validator: filters => filters.length <= 100 && filters.every(filter => isRecord(filter) && Object.keys(filter).every(key => ["dimension", "operator", "expression"].includes(key)) && dimensions.includes(filter.dimension) && filter.dimension !== "date" && ["contains", "equals", "notContains", "notEquals", "includingRegex", "excludingRegex"].includes(filter.operator) && typeof filter.expression === "string" && filter.expression.length <= 4096) || "Use supported dimension/operator/expression filters." },
     type: { type: "string", enum: ["web", "image", "video", "news", "discover", "googleNews"], defaultTo: "web" },
     rowLimit: { type: "integer", min: 1, max: 25000, defaultTo: 1000 }, startRow: { type: "integer", min: 0, defaultTo: 0 }
   }, ({ siteUrl, filters, ...body }) => {
@@ -26,6 +27,6 @@ const googleSearchConsoleProvider = googleProvider(googleSearchConsoleDefinition
   "sitemaps.submit": googleOperation(["webmasters"], { siteUrl, feedpath }, ({ siteUrl, feedpath }) => ({ method: "PUT", url: `${propertyPath(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}` }), value => value === null || plain(value) && !Object.keys(value).length),
   "sitemaps.delete": googleOperation(["webmasters"], { siteUrl, feedpath }, ({ siteUrl, feedpath }) => ({ method: "DELETE", url: `${propertyPath(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}` }), value => value === null || plain(value) && !Object.keys(value).length),
   "sites.list": googleRead(["webmasters.readonly", "webmasters"], {}, () => ({ url: `${origin}/webmasters/v3/sites` }),
-    (value) => Boolean(value && typeof value === "object" && !Array.isArray(value) && !value.error && (value.siteEntry === undefined || Array.isArray(value.siteEntry))))
+    (value) => Boolean(isRecord(value) && !value.error && (value.siteEntry === undefined || Array.isArray(value.siteEntry))))
 });
 export { googleSearchConsoleProvider };

package/src/server/google.js

@@ -1,20 +1,21 @@
 import { createSchema } from "json-rest-schema";
 import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { googleScope } from "../shared/googleScope.js";
 import { validatedOperation } from "./jsonOperation.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 const oauth = Object.freeze({
   issuer: "https://accounts.google.com",
   authorization_endpoint: "https://accounts.google.com/o/oauth2/v2/auth",
   token_endpoint: "https://oauth2.googleapis.com/token"
 });
-const googleScope = (name) => name.startsWith("https:") ? name : `https://www.googleapis.com/auth/${name}`;
 const documentId = { type: "string", required: true, minLength: 1, maxLength: 1024, validator: (value) => /^[a-zA-Z0-9_-]+$/u.test(value) || "Enter the document ID from its URL." };
 const pageToken = { type: "string", minLength: 1, maxLength: 4096 };
 
 // Request builders report rejected input as the caller's mistake, not a provider outage.
 const inputInvalid = (message, { statusCode = 422, ...codes } = {}) => new ConnectorError("connector_input_invalid", message, { statusCode, ...codes });
-const nativeRequest = request => request && typeof request === "object" && !Array.isArray(request) && Object.keys(request).length === 1 &&
+const nativeRequest = request => isRecord(request) && Object.keys(request).length === 1 &&
   /^[a-zA-Z][a-zA-Z0-9]+$/.test(Object.keys(request)[0]) && Boolean(Object.values(request)[0]) &&
   typeof Object.values(request)[0] === "object" && !Array.isArray(Object.values(request)[0]);
 // Docs, Slides and Sheets batchUpdate share one limit: 1-100 single-operation request objects within 1 MiB.
@@ -50,9 +51,12 @@ function googleRead(scopes, fields, destination, validateResult) {
 
 function googleProvider(definition, origin, checkOperation, operations) {
   return Object.freeze({
-    ...definition, oauth, apiOrigins: [origin],
+    ...definition,
+    oauth,
+    apiOrigins: [origin],
     authorizationParameters: { access_type: "offline", prompt: "consent" },
-    checkOperation, operations
+    checkOperation,
+    operations
   });
 }
 function googleFileVerification(get, field) {

package/src/server/googleAdsApi.js

@@ -0,0 +1,14 @@
+// What the Google Ads provider and its Search extension share: the API they call, the
+// permission every operation needs and the header that acts through a manager account.
+
+const googleAdsOrigin = "https://googleads.googleapis.com";
+const googleAdsApi = `${googleAdsOrigin}/v25`;
+const googleAdsScope = "https://www.googleapis.com/auth/adwords";
+
+/**
+ * The header that sends a request as the configured manager account, when there is one.
+ * @param {{ loginCustomerId?: string }} settings
+ */
+const loginCustomerHeaders = (settings) => settings.loginCustomerId ? { "login-customer-id": settings.loginCustomerId } : {};
+
+export { googleAdsOrigin, googleAdsApi, googleAdsScope, loginCustomerHeaders };

package/src/server/granola.js

@@ -1,6 +1,6 @@
 import { createSchema } from "json-rest-schema";
 import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
-import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { ConnectorError, providerStatusError } from "@jskit-ai/connectors-core/server";
 import { granolaDefinition } from "../shared/granola.js";
 import { jsonOperation } from "./jsonOperation.js";
 import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
@@ -68,7 +68,7 @@ const granolaApiProvider = Object.freeze({
     const response = await fetchImpl(address, { ...options, credentials: "omit" });
     if (response.status === 404) throw new ConnectorError("connector_resource_not_found", "The Granola note is unavailable, inaccessible or still being processed.", { statusCode: 404, messageCode: "connectors.granola.noteUnavailable" });
     if (response.status === 413) throw new ConnectorError("connector_response_too_large", "Read the transcript in pages with transcripts.list.", { statusCode: 413, messageCode: "connectors.granola.readTranscriptPagesTranscriptsList" });
-    if (!response.ok) throw Object.assign(new Error("Granola request failed."), { status: response.status });
+    if (!response.ok) throw providerStatusError(response.status);
     let value;
     try { value = await response.json(); } catch { /* checked below */ }
     if (response.status !== 200 || !value || typeof value !== "object" || value.error) {

package/src/server/hubspot.js

@@ -3,6 +3,7 @@ import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
 import { ConnectorError } from "@jskit-ai/connectors-core/server";
 import { hubspotDefinition } from "../shared/tokens.js";
 import { jsonOperation } from "./jsonOperation.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 const base = "https://api.hubapi.com/crm/objects/2026-09";
 const recordId = { type: "string", required: true, minLength: 1, maxLength: 100,
@@ -18,7 +19,7 @@ const readFields = {
   associations: { type: "string", enum: ["contacts", "deals", "contacts,deals"] },
   archived: { type: "boolean", defaultTo: false }
 };
-const validRecord = value => typeof value?.id === "string" && value.properties && typeof value.properties === "object" && !Array.isArray(value.properties);
+const validRecord = value => typeof value?.id === "string" && isRecord(value.properties);
 function objectOperations(object) {
   const readScope = `crm.objects.${object}.read`, writeScope = `crm.objects.${object}.write`;
   const read = createSchema({ id: recordId, ...readFields });

package/src/server/incident-io.js

@@ -1,6 +1,7 @@
 import { createSchema } from "json-rest-schema";
 import { incidentIoDefinition } from "../shared/tokens.js";
 import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 const id = { type: "string", required: true, minLength: 1, maxLength: 200,
   validator: value => /^[a-zA-Z0-9_-]+$/u.test(value) || "Use the incident.io resource ID, not a URL." };
@@ -13,11 +14,11 @@ const address = path => `https://api.incident.io${path}`;
 const incidentFields = { name: text, summary: text, severity_id: optionalId, incident_status_id: optionalId };
 const followUpFields = { title: { ...text, required: true, maxLength: 1000 }, description: text,
   assignee_id: optionalId, assignee_team_id: optionalId, follow_up_category_id: optionalId, follow_up_priority_option_id: optionalId };
-const literal = value => value && typeof value === "object" && !Array.isArray(value) &&
+const literal = value => isRecord(value) &&
   Object.keys(value).length === 1 && typeof value.literal === "string" && value.literal.length <= 20000;
 const attributes = { type: "object", required: true, additionalProperties: true,
   validator: value => Object.keys(value).length <= 250 && Buffer.byteLength(JSON.stringify(value)) <= 100000 &&
-    Object.entries(value).every(([key, binding]) => /^[a-zA-Z0-9_-]+$/u.test(key) && binding && typeof binding === "object" && !Array.isArray(binding) &&
+    Object.entries(value).every(([key, binding]) => /^[a-zA-Z0-9_-]+$/u.test(key) && isRecord(binding) &&
       Object.keys(binding).every(field => ["value", "array_value"].includes(field)) &&
       (binding.value === undefined || literal(binding.value)) &&
       (binding.array_value === undefined || Array.isArray(binding.array_value) && binding.array_value.length <= 100 && binding.array_value.every(literal))) ||

package/src/server/lexware.js

@@ -1,14 +1,15 @@
 import { createSchema } from "json-rest-schema";
 import { lexwareDefinition } from "../shared/tokens.js";
+import { hasStringId } from "./connectorValues.js";
 import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+import { isUuid } from "../shared/uuid.js";
 
-const id = { type: "string", required: true, validator: value => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value) || "Use a Lexware resource UUID." };
+const id = { type: "string", required: true, validator: value => isUuid(value) || "Use a Lexware resource UUID." };
 const text = { type: "string", minLength: 1, maxLength: 1000 };
 const date = { type: "string", required: true, validator: value => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/u.test(value) && Number.isFinite(Date.parse(value)) && new Date(`${value.slice(0, 10)}T00:00:00Z`).toISOString().startsWith(value.slice(0, 10)) || "Use an ISO timestamp with timezone." };
 const paging = { page: { type: "integer", min: 0, max: 100000, defaultTo: 0 }, size: { type: "integer", min: 1, max: 250, defaultTo: 25 } };
 const pageResult = result => Array.isArray(result?.content) && typeof result.first === "boolean" && typeof result.last === "boolean" &&
   ["totalPages", "totalElements", "numberOfElements", "number"].every(field => Number.isInteger(result[field]) && result[field] >= 0) && Number.isInteger(result.size) && result.size > 0;
-const resourceResult = result => typeof result?.id === "string";
 const line = createSchema({
   name: { ...text, required: true }, description: { ...text, maxLength: 5000 },
   quantity: { type: "number", required: true, min: 0.000001, max: 1000000 },
@@ -26,7 +27,7 @@ const lexwareProvider = Object.freeze({
       ...paging, customer: { type: "boolean" }, vendor: { type: "boolean" }
     }, pageResult),
     ...Object.fromEntries(["contacts", "articles", "invoices", "vouchers"].map(resource => [
-      `${resource}.get`, validatedOperation({ id }, ({ id }) => ({ method: "GET", url: `https://api.lexware.io/v1/${resource}/${id}` }), resourceResult)
+      `${resource}.get`, validatedOperation({ id }, ({ id }) => ({ method: "GET", url: `https://api.lexware.io/v1/${resource}/${id}` }), hasStringId)
     ])),
     "articles.list": jsonOperation("https://api.lexware.io/v1/articles", {
       ...paging, articleNumber: text, gtin: text, type: { type: "string", enum: ["PRODUCT", "SERVICE"] }
@@ -48,7 +49,7 @@ const lexwareProvider = Object.freeze({
       body: { ...other, voucherDate, address: { contactId },
         lineItems: lineItems.map(({ netAmount, taxRatePercentage, ...item }) => ({ ...item, type: "custom", unitPrice: { currency: "EUR", netAmount, taxRatePercentage } })),
         totalPrice: { currency: "EUR" }, taxConditions: { taxType: "net" }, shippingConditions: { shippingDate, shippingType } }
-    }), resourceResult)
+    }), hasStringId)
   }
 });
 export { lexwareProvider };

package/src/server/lightspeed.js

@@ -1,9 +1,11 @@
 import { ConnectorError } from "@jskit-ai/connectors-core/server";
 import { lightspeedDefinition } from "../shared/lightspeed.js";
 import { jsonOperation } from "./jsonOperation.js";
+import { isCount } from "./connectorValues.js";
+import { isUuid } from "../shared/uuid.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 const apiOrigin = (settings) => `https://${settings.domainPrefix}.retail.lightspeed.app`;
-const versionNumber = (value) => Number.isSafeInteger(value) && value >= 0;
 const identifier = (value) => typeof value === "string" && /^[a-zA-Z0-9_-]{1,128}$/u.test(value);
 
 function collection(resource) {
@@ -13,12 +15,12 @@ function collection(resource) {
     page_size: { type: "integer", min: 1, max: 100, defaultTo: 20 },
     ...(resource === "sales" ? {} : { deleted: { type: "boolean", defaultTo: false } })
   }, (result) => {
-    if (!Array.isArray(result?.data) || !result.data.every((row) => identifier(row?.id) && versionNumber(row.version))) return false;
+    if (!Array.isArray(result?.data) || !result.data.every((row) => identifier(row?.id) && isCount(row.version))) return false;
     // The customer reference includes a response without the optional envelope version.
     if (resource === "customers" && result.version === undefined) return true;
     const { min, max } = result.version || {};
     return result.data.length === 0 ? min === null && max === null :
-      versionNumber(min) && versionNumber(max) && min <= max && result.data.every((row) => row.version >= min && row.version <= max);
+      isCount(min) && isCount(max) && min <= max && result.data.every((row) => row.version >= min && row.version <= max);
   });
   return {
     ...operation, scopes: [`${resource}:read`],
@@ -39,9 +41,9 @@ const inventoryRead = jsonOperation(settings => `${apiOrigin(settings)}/api/2026
   size: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
   include_deleted: { type: "boolean", defaultTo: false },
   sort_direction: { type: "string", enum: ["asc", "desc"], defaultTo: "asc" },
-  product_id: { type: "string", validator: value => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value) || "Use a product UUID." },
+  product_id: { type: "string", validator: value => isUuid(value) || "Use a product UUID." },
   variants: { type: "boolean", defaultTo: false }
-}, result => Array.isArray(result) && result.every(row => row && typeof row === "object" && !Array.isArray(row) && versionNumber(row.version)), "POST");
+}, result => Array.isArray(result) && result.every(row => isRecord(row) && isCount(row.version)), "POST");
 
 const lightspeedProvider = Object.freeze({
   ...lightspeedDefinition,