@jskit-ai/connectors-catalog 0.1.1

package/src/server/gmail.js

@@ -0,0 +1,60 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { gmailDefinition } from "../shared/google.js";
+import { googleRead, googleProvider, documentId, pageToken } from "./google.js";
+const origin = "https://gmail.googleapis.com";
+const read = ["gmail.readonly", "gmail.modify", "gmail.metadata", "https://mail.google.com/"];
+const contentScopes = ["gmail.readonly", "gmail.modify", "https://mail.google.com/"];
+const composeScopes = ["gmail.compose", "gmail.modify", "https://mail.google.com/"];
+const modifyScopes = ["gmail.modify", "https://mail.google.com/"];
+const labelScopes = ["gmail.labels", ...modifyScopes];
+const messageResult = value => typeof value?.id === "string" && typeof value.threadId === "string";
+const draftResult = value => typeof value?.id === "string" && messageResult(value.message);
+const rawField = { type: "string", required: true, minLength: 4, maxLength: 14000000, noTrim: true,
+  validator: value => /^[A-Za-z0-9_-]+={0,2}$/.test(value) && value.replace(/=+$/, "").length % 4 !== 1 || "Supply base64url-encoded MIME content." };
+const labelIds = { type: "array", items: { type: "string", minLength: 1, maxLength: 200 }, validator: value => value.length <= 100 || "Supply no more than 100 labels." };
+const listFields = { pageToken, maxResults: { type: "integer", min: 1, max: 500, defaultTo: 100 }, labelIds, includeSpamTrash: { type: "boolean", defaultTo: false } };
+function gmailWrite(scopes, fields, destination, validateResult, method = "POST") {
+  const schema = createSchema(fields);
+  return { scopes: scopes.map(value => value.startsWith("https:") ? value : `https://www.googleapis.com/auth/${value}`), validateResult,
+    request(input) {
+      const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const { path, body } = destination(values);
+      return { method, url: `${origin}/gmail/v1/users/me${path}`, ...(body ? { body } : {}) };
+    } };
+}
+const gmailProvider = Object.freeze({ ...googleProvider(gmailDefinition, origin, "profile.read", {
+  "messages.read": googleRead(contentScopes, { id: documentId, format: { type: "string", enum: ["full", "raw"], defaultTo: "full" } }, ({ id, format }) => ({ url: `${origin}/gmail/v1/users/me/messages/${encodeURIComponent(id)}`, query: { format } }), messageResult),
+  "messages.search": googleRead(contentScopes, { ...listFields, q: { type: "string", required: true, minLength: 1, maxLength: 4096 } }, query => ({ url: `${origin}/gmail/v1/users/me/messages`, query }), value => Number.isInteger(value?.resultSizeEstimate) && (value.messages === undefined || Array.isArray(value.messages))),
+  "attachments.get": googleRead(contentScopes, { messageId: documentId, id: documentId }, ({ messageId, id }) => ({ url: `${origin}/gmail/v1/users/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(id)}` }), value => Number.isInteger(value?.size) && typeof value.data === "string"),
+  "messages.send": gmailWrite(["gmail.send", ...composeScopes], { raw: rawField, threadId: { ...documentId, required: false } }, body => ({ path: "/messages/send", body }), messageResult),
+  "messages.modify": gmailWrite(modifyScopes, { id: documentId, addLabelIds: labelIds, removeLabelIds: labelIds }, ({ id, ...body }) => {
+    if (!body.addLabelIds?.length && !body.removeLabelIds?.length) throw new ConnectorError("connector_input_invalid", "Supply labels to add or remove.");
+    return { path: `/messages/${encodeURIComponent(id)}/modify`, body };
+  }, messageResult),
+  "messages.trash": gmailWrite(modifyScopes, { id: documentId }, ({ id }) => ({ path: `/messages/${encodeURIComponent(id)}/trash` }), messageResult),
+  "messages.untrash": gmailWrite(modifyScopes, { id: documentId }, ({ id }) => ({ path: `/messages/${encodeURIComponent(id)}/untrash` }), messageResult),
+  "drafts.list": googleRead([...contentScopes, "gmail.compose"], { pageToken, maxResults: listFields.maxResults }, query => ({ url: `${origin}/gmail/v1/users/me/drafts`, query }), value => Number.isInteger(value?.resultSizeEstimate) && (value.drafts === undefined || Array.isArray(value.drafts))),
+  "drafts.get": googleRead([...contentScopes, "gmail.compose"], { id: documentId }, ({ id }) => ({ url: `${origin}/gmail/v1/users/me/drafts/${encodeURIComponent(id)}`, query: { format: "full" } }), draftResult),
+  "drafts.create": gmailWrite(composeScopes, { raw: rawField, threadId: { ...documentId, required: false } }, message => ({ path: "/drafts", body: { message } }), draftResult),
+  "drafts.update": gmailWrite(composeScopes, { id: documentId, raw: rawField, threadId: { ...documentId, required: false } }, ({ id, ...message }) => ({ path: `/drafts/${encodeURIComponent(id)}`, body: { message } }), draftResult, "PUT"),
+  "drafts.delete": gmailWrite(composeScopes, { id: documentId }, ({ id }) => ({ path: `/drafts/${encodeURIComponent(id)}` }), value => value === null, "DELETE"),
+  "drafts.send": gmailWrite(composeScopes, { id: documentId }, body => ({ path: "/drafts/send", body }), messageResult),
+  "labels.list": googleRead([...read, "gmail.labels"], {}, () => ({ url: `${origin}/gmail/v1/users/me/labels` }), value => Array.isArray(value?.labels)),
+  "labels.delete": gmailWrite(labelScopes, { id: documentId }, ({ id }) => ({ path: `/labels/${encodeURIComponent(id)}` }), value => value === null, "DELETE"),
+  "labels.create": gmailWrite(labelScopes, { name: { type: "string", required: true, minLength: 1, maxLength: 225 } }, body => ({ path: "/labels", body }), value => typeof value?.id === "string" && typeof value.name === "string"),
+  "labels.update": gmailWrite(labelScopes, { id: documentId, name: { type: "string", required: true, minLength: 1, maxLength: 225 } }, ({ id, ...body }) => ({ path: `/labels/${encodeURIComponent(id)}`, body }), value => typeof value?.id === "string" && typeof value.name === "string", "PUT"),
+  "profile.read": googleRead([...read, "gmail.compose"], {}, () => ({ url: `${origin}/gmail/v1/users/me/profile` }),
+    (value) => typeof value?.emailAddress === "string" && Number.isInteger(value.messagesTotal)),
+  "messages.list": googleRead(read, {
+    pageToken, maxResults: { type: "integer", min: 1, max: 500, defaultTo: 100 },
+    labelIds: { type: "array", items: { type: "string", minLength: 1, maxLength: 200 } },
+    includeSpamTrash: { type: "boolean", defaultTo: false }
+  }, (query) => ({ url: `${origin}/gmail/v1/users/me/messages`, query }),
+  (value) => Number.isInteger(value?.resultSizeEstimate) && (value.messages === undefined || Array.isArray(value.messages))),
+  "messages.get": googleRead(read, { id: documentId }, ({ id }) => ({
+    url: `${origin}/gmail/v1/users/me/messages/${encodeURIComponent(id)}`, query: { format: "metadata" }
+  }), (value) => typeof value?.id === "string" && typeof value.threadId === "string")
+}), accountLabelFromVerification: (profile) => profile.emailAddress });
+export { gmailProvider };

package/src/server/gong.js

@@ -0,0 +1,52 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { gongDefinition } from "../shared/gong.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origin = (settings) => new URL(settings.apiBaseUrl).origin;
+const cursor = { type: "string", minLength: 1, maxLength: 8192, noTrim: true };
+const ids = { type: "array", items: { type: "string", pattern: "^[0-9]{1,20}$" }, validator: value => value.length >= 1 && value.length <= 100 || "Supply between 1 and 100 string IDs." };
+const timestamp = { type: "string", validator: value => /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(value) && Number.isFinite(Date.parse(value)) || "Enter an ISO timestamp including its time zone." };
+const callFields = { cursor, fromDateTime: timestamp, toDateTime: timestamp, callIds: ids,
+  workspaceId: { type: "string", pattern: "^[0-9]{1,20}$" } };
+const recordsValid = value => ["totalRecords", "currentPageSize", "currentPageNumber"].every(key => Number.isInteger(value?.records?.[key]) && value.records[key] >= 0) && (value.records.cursor === undefined || typeof value.records.cursor === "string");
+function callOperation(path, field, extensive = false) {
+  const schema = createSchema({ ...callFields, ...(extensive ? { includeMedia: { type: "boolean", defaultTo: false } } : {}) });
+  return { scopes: [], request(input, settings) {
+    if (Array.isArray(input.callIds) && input.callIds.some(id => typeof id !== "string") || input.workspaceId !== undefined && typeof input.workspaceId !== "string") throw new ConnectorError("connector_input_invalid", "Supply Gong IDs as strings to preserve all digits.");
+    const { cursor, includeMedia, ...filter } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    if ((!filter.fromDateTime !== !filter.toDateTime) || (filter.fromDateTime && Date.parse(filter.fromDateTime) >= Date.parse(filter.toDateTime)) || (!filter.callIds && !filter.fromDateTime)) throw new ConnectorError("connector_input_invalid", "Supply call IDs or an ordered timestamp range.");
+    const body = { filter, ...(cursor ? { cursor } : {}) };
+    if (extensive) body.contentSelector = { context: "Extended", contextTiming: ["Now", "TimeOfCall"], exposedFields: {
+      parties: true, content: { brief: true, outline: true, topics: true, keyPoints: true, callOutcome: true },
+      interaction: { speakers: true, personInteractionStats: true, questions: true }, media: includeMedia
+    } };
+    return { method: "POST", url: `${origin(settings)}${path}`, body };
+  }, validateResult: value => Array.isArray(value?.[field]) && recordsValid(value) };
+}
+const date = { type: "string", required: true, validator: value => /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value || "Enter a valid YYYY-MM-DD date." };
+const statsSchema = createSchema({ cursor, fromDate: date, toDate: date, userIds: ids });
+const gongProvider = Object.freeze({
+  ...gongDefinition,
+  apiOrigins: (settings) => [origin(settings)],
+  apiKey: { headers: (secret, settings) => ({ Authorization: `Basic ${Buffer.from(`${settings.accessKey}:${secret}`).toString("base64")}` }) },
+  checkOperation: "users.list",
+  operations: {
+    "calls.extensive": callOperation("/v2/calls/extensive", "calls", true),
+    "calls.transcripts": callOperation("/v2/calls/transcript", "callTranscripts"),
+    "stats.interaction": { scopes: [], request(input, settings) {
+      if (Array.isArray(input.userIds) && input.userIds.some(id => typeof id !== "string")) throw new ConnectorError("connector_input_invalid", "Supply Gong IDs as strings to preserve all digits.");
+      const { cursor, ...filter } = validateSchemaPayload({ schema: statsSchema, mode: "replace" }, input, { statusCode: 422 });
+      if (filter.fromDate >= filter.toDate) throw new ConnectorError("connector_input_invalid", "The end date must follow the start date.");
+      return { method: "POST", url: `${origin(settings)}/v2/stats/interaction`, body: { filter, ...(cursor ? { cursor } : {}) } };
+    }, validateResult: value => Array.isArray(value?.peopleInteractionStats) && recordsValid(value) },
+    "users.list": jsonOperation((settings) => `${origin(settings)}/v2/users`, {
+      cursor: { type: "string", minLength: 1, maxLength: 8192 },
+      includeAvatars: { type: "boolean", defaultTo: false }
+    }, (result) => Array.isArray(result?.users) &&
+      ["totalRecords", "currentPageSize", "currentPageNumber"].every((key) => Number.isInteger(result.records?.[key]) && result.records[key] >= 0) &&
+      (result.records.cursor === undefined || typeof result.records.cursor === "string"))
+  }
+});
+export { gongProvider };

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

@@ -0,0 +1,134 @@
+import { createHash } from "node:crypto";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { validateGoogleAdsSearchPlan } from "../shared/google-ads-search.js";
+
+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 => { throw new ConnectorError("connector_input_invalid", message, { statusCode: 422 }); };
+const hash = value => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+function requestOperation(fields, build, validateResult) {
+  const schema = createSchema(fields);
+  return { scopes: [scope], request(input, settings) {
+    const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "POST", ...build(values), headers: settings.loginCustomerId ? { "login-customer-id": settings.loginCustomerId } : {} };
+  }, validateResult };
+}
+const mutated = result => result && typeof result === "object" && !Array.isArray(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: [
+    { 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",
+      networkSettings: { targetGoogleSearch: true, targetSearchNetwork: false, targetContentNetwork: false, targetPartnerSearchNetwork: false },
+      geoTargetTypeSetting: { positiveGeoTargetType: "PRESENCE" } } } },
+    { customConversionGoalOperation: { create: { resourceName: goal, name: `${p.name} goal`, status: "ENABLED", conversionActions: [`${root}/conversionActions/${p.conversionActionId}`] } } },
+    { conversionGoalCampaignConfigOperation: { update: { resourceName: `${root}/conversionGoalCampaignConfigs/-2`, goalConfigLevel: "CAMPAIGN", customConversionGoal: goal }, updateMask: "goal_config_level,custom_conversion_goal" } },
+    ...p.locationIds.map(location => ({ campaignCriterionOperation: { create: { campaign, location: { geoTargetConstant: `geoTargetConstants/${location}` } } } })),
+    { campaignCriterionOperation: { create: { campaign, language: { languageConstant: `languageConstants/${p.languageId}` } } } },
+    { adGroupOperation: { create: { resourceName: group, name: `${p.name} group`, campaign, status: "ENABLED", type: "SEARCH_STANDARD", cpcBidMicros: p.maxCpcMicros } } },
+    ...p.keywords.map(text => ({ adGroupCriterionOperation: { create: { adGroup: group, status: "ENABLED", keyword: { text, matchType: "PHRASE" } } } })),
+    { adGroupAdOperation: { create: { adGroup: group, status: "ENABLED", ad: { finalUrls: [p.finalUrl], responsiveSearchAd: {
+      headlines: p.headlines.map(text => ({ text })), descriptions: p.descriptions.map(text => ({ text })) } } } } }
+  ] } };
+}
+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 || "")) },
+  "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),
+  "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)
+};
+
+// Application composition: this service has no editor protocol, command runner or storage.
+function createGoogleAdsSearchService({ connections, configuration, context, integrationId }) {
+  const slot = configuration.integrations?.[integrationId];
+  if (slot?.provider !== "google-ads") error("Choose a Google Ads integration.");
+  const invoke = (operation, input) => connections.invoke({ context, integrationId, operation, input });
+  const query = async (customer, query) => (await invoke("reports.search", { customerId: customer, query })).results || [];
+  const customer = value => validateSchemaPayload({ schema: createSchema({ customerId }), mode: "replace" }, { customerId: value }, { statusCode: 422 }).customerId;
+  const campaignId = value => validateSchemaPayload({ schema: createSchema({ id }), mode: "replace" }, { id: value }, { statusCode: 422 }).id;
+  const plan = () => validateGoogleAdsSearchPlan(configuration.extensions?.googleAdsSearch?.[integrationId]);
+  const review = data => hash([context.applicationId, context.subjectId, integrationId, slot, plan(), data]);
+  async function account(id) {
+    const rows = await query(customer(id), "SELECT customer.id, customer.descriptive_name, customer.currency_code, customer.time_zone, customer.status, customer.manager FROM customer LIMIT 1");
+    if (rows.length !== 1) error("Google did not return the selected account.");
+    return rows[0].customer;
+  }
+  async function preview() {
+    const p = plan(), selected = await account(p.customerId);
+    if (selected.manager || selected.status !== "ENABLED" || selected.currencyCode !== p.currency) error("Choose an active client account and match its currency.");
+    const goals = await query(p.customerId, `SELECT conversion_action.id, conversion_action.name, conversion_action.status, conversion_action.type FROM conversion_action WHERE conversion_action.id = ${p.conversionActionId} LIMIT 1`);
+    if (goals[0]?.conversionAction?.status !== "ENABLED" || goals[0]?.conversionAction?.type !== "WEBPAGE") error("Choose an enabled website conversion action.");
+    await invoke("search.validate", p);
+    const data = { plan: p, account: selected, conversion: goals[0].conversionAction };
+    return { ...data, reviewId: review(data) };
+  }
+  async function campaign(id) {
+    const p = plan(), selected = campaignId(id);
+    const rows = await query(p.customerId, `SELECT campaign.id, campaign.name, campaign.status, campaign.advertising_channel_type, campaign.bidding_strategy_type, campaign.network_settings.target_google_search, campaign.network_settings.target_search_network, campaign.network_settings.target_content_network, campaign.network_settings.target_partner_search_network, campaign.geo_target_type_setting.positive_geo_target_type, campaign.geo_target_type_setting.negative_geo_target_type, campaign.contains_eu_political_advertising, campaign_budget.amount_micros, campaign_budget.id FROM campaign WHERE campaign.id = ${selected} LIMIT 1`);
+    if (rows.length !== 1 || rows[0].campaign?.advertisingChannelType !== "SEARCH") error("Select an accessible Search campaign.");
+    const details = {
+      customerId: p.customerId, account: await account(p.customerId), ...rows[0],
+      ads: await query(p.customerId, `SELECT ad_group_ad.ad.id, ad_group_ad.ad.final_urls, ad_group_ad.ad.responsive_search_ad.headlines, ad_group_ad.ad.responsive_search_ad.descriptions, ad_group_ad.status, ad_group_ad.policy_summary.approval_status, ad_group.id, ad_group.status, ad_group.cpc_bid_micros FROM ad_group_ad WHERE campaign.id = ${selected} LIMIT 21`),
+      goals: await query(p.customerId, `SELECT conversion_goal_campaign_config.goal_config_level, conversion_goal_campaign_config.custom_conversion_goal FROM conversion_goal_campaign_config WHERE conversion_goal_campaign_config.campaign = 'customers/${p.customerId}/campaigns/${selected}' LIMIT 1`),
+      targets: await query(p.customerId, `SELECT campaign_criterion.type, campaign_criterion.location.geo_target_constant, campaign_criterion.language.language_constant, campaign_criterion.negative FROM campaign_criterion WHERE campaign.id = ${selected} LIMIT 31`),
+      keywords: await query(p.customerId, `SELECT ad_group_criterion.keyword.text, ad_group_criterion.keyword.match_type, ad_group_criterion.negative, ad_group_criterion.status FROM keyword_view WHERE campaign.id = ${selected} LIMIT 31`)
+    };
+    const goalResource = details.goals[0]?.conversionGoalCampaignConfig?.customConversionGoal;
+    if (goalResource) {
+      if (!new RegExp(`^customers/${p.customerId}/customConversionGoals/[0-9]+$`).test(goalResource)) error("Google returned an invalid campaign goal.");
+      details.customGoals = await query(p.customerId, `SELECT custom_conversion_goal.name, custom_conversion_goal.status, custom_conversion_goal.conversion_actions FROM custom_conversion_goal WHERE custom_conversion_goal.resource_name = '${goalResource}' LIMIT 1`);
+    }
+    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.");
+    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.");
+      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") };
+    },
+    preview,
+    async create(reviewId) {
+      const checked = await preview();
+      if (reviewId !== checked.reviewId) error("The Search plan changed. Review it again before creation.");
+      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 }),
+    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.");
+      if (trackingConfirmed !== true || billingConfirmed !== true) error("Confirm installed conversion tracking and billing/advertiser readiness before launch.");
+      if (current.account.manager || current.account.status !== "ENABLED") error("Choose an active client account.");
+      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.");
+      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.");
+      if (current.campaign.status !== "PAUSED") error("Only a paused campaign can be launched here.");
+      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") })
+  };
+}
+export { googleAdsSearchOperations, createGoogleAdsSearchService };

package/src/server/google-ads.js

@@ -0,0 +1,80 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } 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";
+
+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,
+  validator: (value) => !/[\p{Cc}]/u.test(value) || "Use the returned page token without control characters." };
+const searchSchema = createSchema({ customerId, pageToken,
+  query: { type: "string", required: true, minLength: 1, maxLength: 16000, noTrim: true,
+    validator: (value) => /^SELECT\s/iu.test(value) && !/[\p{Cc}]/u.test(value) && new TextEncoder().encode(value).length <= 32000 || "Use a single-line GAQL SELECT query of at most 32,000 UTF-8 bytes." }
+});
+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 } : {},
+    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)) &&
+    (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", {
+    ...googleAdsSearchOperations,
+    "customers.listAccessible": googleRead([scope], {}, () => ({ url: `${api}/customers:listAccessibleCustomers` }),
+      (value) => record(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,
+      "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 }) {
+    const headers = new Headers(options.headers);
+    options.signal.throwIfAborted();
+    if (options.body !== undefined) headers.set("Content-Type", "application/json");
+    const response = await fetchImpl(url, { ...options, headers, credentials: "omit",
+      ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }) });
+    let value;
+    try { value = await response.json(); } catch { /* handled below */ }
+    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) : []);
+      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 });
+      }
+      if (details.some((detail) => detail?.reason === "ACCESS_TOKEN_SCOPE_INSUFFICIENT")) {
+        throw new ConnectorError("connector_scope_missing", "Connect Google Ads again with its required permission.", { statusCode: 403 });
+      }
+      if (codes.some((code) => ["CLOUD_PROJECT_NOT_APPROVED_FOR_PRODUCTION"].includes(code))) {
+        throw new ConnectorError("connector_api_access_invalid", "Check Google Ads API access approval for the Cloud project that owns this OAuth client.", { statusCode: 403 });
+      }
+      if (codes.some((code) => ["OAUTH_TOKEN_INVALID", "OAUTH_TOKEN_EXPIRED", "OAUTH_TOKEN_REVOKED"].includes(code))) {
+        throw new ConnectorError("connector_reconnect_required", "Connect this Google Ads account again.", { statusCode: 401 });
+      }
+      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 });
+      if (response.status === 404) throw new ConnectorError("connector_resource_not_found", "This Google Ads resource is unavailable.", { statusCode: 404 });
+      throw Object.assign(new Error("Google Ads request failed."), { status: response.ok ? 502 : response.status });
+    }
+    if (response.status !== 200 || !record(value)) throw new ConnectorError("connector_response_invalid", "Google Ads returned an unexpected response.", { statusCode: 502 });
+    return value;
+  }
+});
+
+export { googleAdsProvider };

package/src/server/google-docs.js

@@ -0,0 +1,36 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { googleDocsDefinition } from "../shared/google.js";
+import { googleRead, googleProvider, googleFileVerification, documentId } from "./google.js";
+const origin = "https://docs.googleapis.com";
+const readScopes = ["documents.readonly", "documents", "drive.readonly", "drive.file", "drive"];
+const writable = ["documents", "drive.file", "drive"].map(scope => `https://www.googleapis.com/auth/${scope}`);
+const validDocument = value => typeof value?.documentId === "string" && typeof value.title === "string";
+const get = googleRead(readScopes, { documentId }, ({ documentId }) => ({
+  url: `${origin}/v1/documents/${encodeURIComponent(documentId)}`, query: { includeTabsContent: true }
+}), validDocument);
+const create = createSchema({ title: { type: "string", required: true, minLength: 1, maxLength: 1024 } });
+const batch = createSchema({ documentId, requests: { type: "array", required: true }, requiredRevisionId: { type: "string", minLength: 1, maxLength: 1024 } });
+const base = googleProvider(googleDocsDefinition, origin, "connection.verify", {
+  "connection.verify": googleFileVerification(get, "documentId"),
+  "documents.get": get,
+  "documents.create": {
+    scopes: writable, validateResult: validDocument,
+    request(input) {
+      return { method: "POST", url: `${origin}/v1/documents`, body: validateSchemaPayload({ schema: create, mode: "replace" }, input, { statusCode: 422 }) };
+    }
+  },
+  "documents.batchUpdate": {
+    scopes: writable,
+    validateResult: value => typeof value?.documentId === "string" && (value.replies === undefined || Array.isArray(value.replies)),
+    request(input) {
+      const { documentId, requests, requiredRevisionId } = validateSchemaPayload({ schema: batch, mode: "replace" }, input, { statusCode: 422 });
+      if (!requests.length || requests.length > 100 || JSON.stringify(requests).length > 1048576 || requests.some(request => !request || typeof request !== "object" || Array.isArray(request) || Object.keys(request).length !== 1 || !/^[a-zA-Z][a-zA-Z0-9]+$/.test(Object.keys(request)[0]) || !Object.values(request)[0] || typeof Object.values(request)[0] !== "object" || Array.isArray(Object.values(request)[0]))) {
+        throw Object.assign(new Error("Supply 1–100 Google Docs request objects, one native operation per object, within 1 MiB."), { statusCode: 422 });
+      }
+      return { method: "POST", url: `${origin}/v1/documents/${encodeURIComponent(documentId)}:batchUpdate`, body: { requests, ...(requiredRevisionId ? { writeControl: { requiredRevisionId } } : {}) } };
+    }
+  }
+});
+const googleDocsProvider = Object.freeze({ ...base, apiOrigins: [origin, "https://www.googleapis.com"] });
+export { googleDocsProvider };

package/src/server/google-drive.js

@@ -0,0 +1,71 @@
+import { randomUUID } from "node:crypto";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { googleDriveDefinition } from "../shared/google.js";
+import { googleOperation, googleRead, googleProvider, pageToken } from "./google.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 = "") {
+  const address = new URL(`${origin}/drive/v3/files${fileId ? `/${encodeURIComponent(fileId)}` : ""}${suffix}`);
+  for (const [key, value] of Object.entries(query)) if (value !== undefined) address.searchParams.set(key, String(value));
+  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.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.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 Object.assign(new Error("Supply a name, description or trashed value."), { statusCode: 422 });
+    return { method: "PATCH", url: url(fileId, { supportsAllDrives: true, fields }), body };
+  }, validFile),
+  "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 },
+    bodyBase64: { type: "string", required: true, maxLength: 6666668, noTrim: true }
+  }, ({ fileId, name, parentId, contentType, bodyBase64 }) => {
+    if (!/^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/.test(contentType)) throw Object.assign(new Error("Use a MIME type without header parameters."), { statusCode: 422 });
+    const data = Buffer.from(bodyBase64, "base64");
+    if (data.toString("base64") !== bodyBase64) throw Object.assign(new Error("Use standard padded base64 file data."), { statusCode: 422 });
+    if (data.byteLength > 5_000_000) throw Object.assign(new Error("Uploads above 5 MB require the framework's native resumable client."), { statusCode: 413 });
+    if (fileId && parentId) throw Object.assign(new Error("parentId applies to new files; moving files requires native addParents/removeParents wiring."), { statusCode: 422 });
+    const boundary = `drive_${randomUUID()}`;
+    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),
+  "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 },
+    driveId: { type: "string", minLength: 1, maxLength: 1024 }
+  }, ({ driveId, ...query }) => ({ url: `${origin}/drive/v3/files`, query: {
+    ...query, fields: "kind,nextPageToken,incompleteSearch,files(id,name,mimeType,modifiedTime)",
+    ...(driveId ? { driveId, corpora: "drive", supportsAllDrives: true, includeItemsFromAllDrives: true } : {})
+  } }), (value) => value?.kind === "drive#fileList" && (value.files === undefined || Array.isArray(value.files)))
+});
+const googleDriveProvider = Object.freeze({ ...baseProvider,
+  async exchange(address, options, { request, fetchImpl }) {
+    const target = new URL(address);
+    const upload = target.pathname.startsWith("/upload/drive/v3/");
+    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 }); }
+    const chunks = []; let size = 0;
+    const reader = response.body?.getReader();
+    if (reader) try { while (true) {
+      const { done, value } = await reader.read(); if (done) break;
+      size += value.byteLength;
+      if (size > 8 * 1024 * 1024) { await reader.cancel(); throw new ConnectorError("connector_response_too_large", "Use the framework's native Drive client for downloads or exports above 8 MiB.", { statusCode: 413 }); }
+      chunks.push(value);
+    } } finally { reader.releaseLock(); }
+    const body = Buffer.concat(chunks);
+    if (upload) return JSON.parse(body.toString("utf8"));
+    return { bodyBase64: body.toString("base64"), contentType: response.headers.get("content-type") || "application/octet-stream", size };
+  }
+});
+export { googleDriveProvider };

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

@@ -0,0 +1,90 @@
+import { createSchema } from "json-rest-schema";
+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 } from "./jsonOperation.js";
+
+const endpoint = "https://maps.googleapis.com/maps/api/geocode/json";
+const language = { type: "string", minLength: 2, maxLength: 35,
+  validator: (value) => /^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$/i.test(value) || "Use a language code such as en or pt-BR." };
+const reverseSchema = createSchema({
+  latitude: { type: "number", required: true, min: -90, max: 90 },
+  longitude: { type: "number", required: true, min: -180, max: 180 },
+  language
+});
+
+function validateGeocoding(result) {
+  switch (result?.status) {
+    case "OVER_QUERY_LIMIT":
+      throw new ConnectorError("connector_rate_limited", "The Google Maps request quota was reached.", { statusCode: 429 });
+    case "OVER_DAILY_LIMIT":
+      throw new ConnectorError("connector_configuration_invalid", "Check the Google Maps server key, billing and usage cap.");
+    case "REQUEST_DENIED":
+      throw new ConnectorError("connector_permission_denied", "Google Maps denied access. Check the enabled API and key restrictions.", { statusCode: 403 });
+    case "INVALID_REQUEST":
+      throw new ConnectorError("connector_input_invalid", "Google Maps could not accept this geocoding request.", { statusCode: 422 });
+    case "UNKNOWN_ERROR":
+      throw new ConnectorError("connector_provider_failed", "Google Maps could not process the request. Try again.", { statusCode: 502 });
+    case "ZERO_RESULTS":
+      return Array.isArray(result.results) && result.results.length === 0;
+    case "OK":
+      return Array.isArray(result.results) && result.results.length > 0 && result.results.every((place) =>
+        typeof place?.formatted_address === "string" && typeof place.place_id === "string" &&
+        Number.isFinite(place.geometry?.location?.lat) && Math.abs(place.geometry.location.lat) <= 90 &&
+        Number.isFinite(place.geometry.location.lng) && Math.abs(place.geometry.location.lng) <= 180);
+    default:
+      return false;
+  }
+}
+
+function mapsOperation(fields, request, validateResult) {
+  const schema = createSchema(fields);
+  return { scopes: [], validateResult, request(input) { return request(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 })); } };
+}
+const latitude = { type: "number", required: true, min: -90, max: 90 };
+const longitude = { type: "number", required: true, min: -180, max: 180 };
+const placeFields = "id,displayName,formattedAddress,location,attributions,googleMapsUri";
+const googleMapsPlatformProvider = Object.freeze({
+  ...googleMapsPlatformDefinition,
+  apiOrigins: ["https://maps.googleapis.com", "https://places.googleapis.com", "https://routes.googleapis.com"],
+  apiKey: { queryParameter: "key" },
+  checkOperation: "geocoding.forward",
+  exchange(address, options, { request, apiKey }) {
+    const target = new URL(address);
+    if (target.hostname === "maps.googleapis.com") return request(address, options);
+    target.searchParams.delete("key");
+    return request(target.href, { ...options, headers: { ...options.headers, "X-Goog-Api-Key": apiKey } });
+  },
+  operations: {
+    "places.search": mapsOperation({ 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")))),
+    "places.get": mapsOperation({ 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": mapsOperation({ originLatitude: latitude, originLongitude: longitude, destinationLatitude: latitude, destinationLongitude: longitude,
+      travelMode: { type: "string", enum: ["DRIVE", "WALK", "BICYCLE"], defaultTo: "DRIVE" }
+    }, ({ originLatitude, originLongitude, destinationLatitude, destinationLongitude, travelMode }) => ({ method: "POST", url: "https://routes.googleapis.com/directions/v2:computeRoutes", headers: { "X-Goog-FieldMask": "routes.distanceMeters,routes.duration,routes.polyline.geoJsonLinestring" }, body: {
+      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)))),
+    "geocoding.forward": jsonOperation(endpoint, {
+      address: { type: "string", required: true, minLength: 1, maxLength: 1000,
+        validator: (value) => Boolean(value.trim()) || "Enter an address or plus code." },
+      language,
+      region: { type: "string", minLength: 2, maxLength: 2,
+        validator: (value) => /^[a-z]{2}$/i.test(value) || "Use a two-letter region code." }
+    }, validateGeocoding),
+    "geocoding.reverse": {
+      scopes: [],
+      request(input) {
+        const values = validateSchemaPayload({ schema: reverseSchema, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL(endpoint);
+        url.searchParams.set("latlng", `${values.latitude},${values.longitude}`);
+        if (values.language !== undefined) url.searchParams.set("language", values.language);
+        return { method: "GET", url: url.href };
+      },
+      validateResult: validateGeocoding
+    }
+  }
+});
+
+export { googleMapsPlatformProvider };

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

@@ -0,0 +1,31 @@
+import { googleSearchConsoleDefinition } from "../shared/google.js";
+import { googleOperation, googleRead, googleProvider } from "./google.js";
+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; } };
+const siteUrl = { type: "string", required: true, minLength: 1, maxLength: 2048, validator: value => /^sc-domain:[A-Za-z0-9.-]+$/.test(value) || website(value) || "Copy the exact property URL or sc-domain:name from sites.list." };
+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);
+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." },
+    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 }) => {
+    if (body.startDate > body.endDate) throw Object.assign(new Error("startDate must not follow endDate."), { statusCode: 422 });
+    return { method: "POST", url: `${propertyPath(siteUrl)}/searchAnalytics/query`, body: { ...body, dataState: "final", ...(filters?.length ? { dimensionFilterGroups: [{ groupType: "and", filters }] } : {}) } };
+  }, value => plain(value) && (value.rows === undefined || Array.isArray(value.rows))),
+  "urlInspection.inspect": googleOperation(readScopes, { siteUrl, inspectionUrl: { ...feedpath }, languageCode: { type: "string", minLength: 2, maxLength: 35 } }, body => ({ method: "POST", url: `${origin}/v1/urlInspection/index:inspect`, body }), value => plain(value?.inspectionResult)),
+  "sitemaps.list": googleRead(readScopes, { siteUrl }, ({ siteUrl }) => ({ url: `${propertyPath(siteUrl)}/sitemaps` }), value => plain(value) && (value.sitemap === undefined || Array.isArray(value.sitemap))),
+  "sitemaps.get": googleRead(readScopes, { siteUrl, feedpath }, ({ siteUrl, feedpath }) => ({ url: `${propertyPath(siteUrl)}/sitemaps/${encodeURIComponent(feedpath)}` }), value => typeof value?.path === "string"),
+  "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))))
+});
+export { googleSearchConsoleProvider };