@automate.ax/integration-contracts 0.105.0 → 0.109.0

package/src/cloudflare/schemas.ts

@@ -0,0 +1,359 @@
+import * as z from "zod"
+import { encodableSchema } from "@automate.ax/codec"
+
+const IDENTIFIER_SCHEMA = z.string().trim().min(1).max(32)
+const RESPONSE_INFO_SCHEMA = z.object({
+  code: z.number().optional(),
+  documentationUrl: z.string().optional(),
+  message: z.string(),
+  source: z.object({ pointer: z.string().optional() }).optional(),
+})
+
+export const CLOUDFLARE_PAGE_INFO_SCHEMA = z.object({
+  count: z.number().int().nonnegative().optional(),
+  page: z.number().int().positive().optional(),
+  perPage: z.number().int().positive().optional(),
+  totalCount: z.number().int().nonnegative().optional(),
+  totalPages: z.number().int().nonnegative().optional(),
+})
+
+export const CLOUDFLARE_ACCOUNT_SCHEMA = z.object({
+  id: IDENTIFIER_SCHEMA,
+  name: z.string().min(1),
+  settings: z
+    .object({
+      abuseContactEmail: z.string().nullable().optional(),
+      enforceTwoFactor: z.boolean().optional(),
+    })
+    .optional(),
+  type: z.enum(["enterprise", "standard"]).optional(),
+})
+
+export const CLOUDFLARE_ZONE_SCHEMA = z.object({
+  account: z.object({
+    id: IDENTIFIER_SCHEMA,
+    name: z.string().optional(),
+  }),
+  activatedOn: z.string().nullable().optional(),
+  createdOn: z.string(),
+  developmentMode: z.number(),
+  id: IDENTIFIER_SCHEMA,
+  meta: z.object({
+    cdnOnly: z.boolean().optional(),
+    customCertificateQuota: z.number().int().optional(),
+    dnsOnly: z.boolean().optional(),
+    foundationDns: z.boolean().optional(),
+    pageRuleQuota: z.number().int().optional(),
+    phishingDetected: z.boolean().optional(),
+    step: z.number().int().optional(),
+  }),
+  modifiedOn: z.string(),
+  name: z.string().min(1).max(253),
+  nameServers: z.string().array(),
+  originalDnshost: z.string().nullable().optional(),
+  originalNameServers: z.string().array().nullable().optional(),
+  originalRegistrar: z.string().nullable().optional(),
+  paused: z.boolean(),
+  status: z.enum(["active", "initializing", "moved", "pending"]),
+  type: z.enum(["full", "internal", "partial", "secondary"]),
+  vanityNameServers: z.string().array().optional(),
+})
+
+export const CLOUDFLARE_DNS_RECORD_TYPE_SCHEMA = z.enum([
+  "A",
+  "AAAA",
+  "CAA",
+  "CERT",
+  "CNAME",
+  "DNSKEY",
+  "DS",
+  "HTTPS",
+  "LOC",
+  "MX",
+  "NAPTR",
+  "NS",
+  "OPENPGPKEY",
+  "PTR",
+  "SMIMEA",
+  "SRV",
+  "SSHFP",
+  "SVCB",
+  "TLSA",
+  "TXT",
+  "URI",
+])
+
+export const CLOUDFLARE_DNS_RECORD_SCHEMA = z.object({
+  comment: z.string().nullable().optional(),
+  commentModifiedOn: z.string().nullable().optional(),
+  content: z.string(),
+  createdOn: z.string(),
+  data: z.record(z.string(), encodableSchema).optional(),
+  id: IDENTIFIER_SCHEMA,
+  meta: z.record(z.string(), encodableSchema).optional(),
+  modifiedOn: z.string(),
+  name: z.string().min(1).max(255),
+  priority: z.number().int().min(0).max(65_535).optional(),
+  proxiable: z.boolean(),
+  proxied: z.boolean(),
+  settings: z.record(z.string(), encodableSchema).optional(),
+  tags: z.string().array().optional(),
+  tagsModifiedOn: z.string().nullable().optional(),
+  ttl: z.number().int().nonnegative(),
+  type: CLOUDFLARE_DNS_RECORD_TYPE_SCHEMA,
+})
+
+export const CLOUDFLARE_HEALTH_CHECK_REGION_SCHEMA = z.enum([
+  "ALL_REGIONS",
+  "EEU",
+  "ENAM",
+  "IN",
+  "ME",
+  "NAF",
+  "NEAS",
+  "NSAM",
+  "OC",
+  "SAF",
+  "SEAS",
+  "SSAM",
+  "WEU",
+  "WNAM",
+])
+
+export const CLOUDFLARE_HTTP_HEALTH_CHECK_SCHEMA = z.object({
+  allowInsecure: z.boolean().optional(),
+  expectedBody: z.string().optional(),
+  expectedCodes: z.string().array().nullable().optional(),
+  followRedirects: z.boolean().optional(),
+  header: z.record(z.string(), z.string().array()).nullable().optional(),
+  method: z.enum(["GET", "HEAD"]).optional(),
+  path: z.string().optional(),
+  port: z.number().int().min(0).max(65_535).optional(),
+})
+
+export const CLOUDFLARE_TCP_HEALTH_CHECK_SCHEMA = z.object({
+  method: z.literal("connection_established").optional(),
+  port: z.number().int().min(0).max(65_535).optional(),
+})
+
+export const CLOUDFLARE_HEALTH_CHECK_SCHEMA = z.object({
+  address: z.string(),
+  checkRegions: CLOUDFLARE_HEALTH_CHECK_REGION_SCHEMA.array()
+    .nullable()
+    .optional(),
+  consecutiveFails: z.number().int().nonnegative().optional(),
+  consecutiveSuccesses: z.number().int().nonnegative().optional(),
+  createdOn: z.string().optional(),
+  description: z.string().optional(),
+  failureReason: z.string().optional(),
+  httpConfig: CLOUDFLARE_HTTP_HEALTH_CHECK_SCHEMA.nullable().optional(),
+  id: IDENTIFIER_SCHEMA.optional(),
+  interval: z.number().int().nonnegative().optional(),
+  modifiedOn: z.string().optional(),
+  name: z.string().regex(/^[A-Za-z0-9_-]+$/),
+  retries: z.number().int().nonnegative().optional(),
+  status: z.enum(["healthy", "suspended", "unknown", "unhealthy"]).optional(),
+  suspended: z.boolean().optional(),
+  tcpConfig: CLOUDFLARE_TCP_HEALTH_CHECK_SCHEMA.nullable().optional(),
+  timeout: z.number().int().nonnegative().optional(),
+  type: z.enum(["HTTP", "HTTPS", "TCP"]).optional(),
+})
+
+export const CLOUDFLARE_ALERT_TYPE_SCHEMA = z.enum([
+  "abuse_report_alert",
+  "access_custom_certificate_expiration_type",
+  "advanced_ddos_attack_l4_alert",
+  "advanced_ddos_attack_l7_alert",
+  "advanced_http_alert_error",
+  "bgp_hijack_notification",
+  "billing_usage_alert",
+  "block_notification_block_removed",
+  "block_notification_new_block",
+  "block_notification_review_rejected",
+  "bot_traffic_basic_alert",
+  "brand_protection_alert",
+  "brand_protection_digest",
+  "clickhouse_alert_fw_anomaly",
+  "clickhouse_alert_fw_ent_anomaly",
+  "cloudforce_one_request_notification",
+  "cni_maintenance_notification",
+  "custom_analytics",
+  "custom_bot_detection_alert",
+  "custom_ssl_certificate_event_type",
+  "dedicated_ssl_certificate_event_type",
+  "device_connectivity_anomaly_alert",
+  "dos_attack_l4",
+  "dos_attack_l7",
+  "expiring_service_token_alert",
+  "failing_logpush_job_disabled_alert",
+  "fbm_auto_advertisement",
+  "fbm_dosd_attack",
+  "fbm_volumetric_attack",
+  "health_check_status_notification",
+  "hostname_aop_custom_certificate_expiration_type",
+  "http_alert_edge_error",
+  "http_alert_origin_error",
+  "image_notification",
+  "image_resizing_notification",
+  "incident_alert",
+  "load_balancing_health_alert",
+  "load_balancing_pool_enablement_alert",
+  "logo_match_alert",
+  "magic_tunnel_health_check_event",
+  "magic_wan_tunnel_health",
+  "maintenance_event_notification",
+  "mtls_certificate_store_certificate_expiration_type",
+  "pages_event_alert",
+  "radar_notification",
+  "real_origin_monitoring",
+  "scriptmonitor_alert_new_code_change_detections",
+  "scriptmonitor_alert_new_hosts",
+  "scriptmonitor_alert_new_malicious_hosts",
+  "scriptmonitor_alert_new_malicious_scripts",
+  "scriptmonitor_alert_new_malicious_url",
+  "scriptmonitor_alert_new_max_length_resource_url",
+  "scriptmonitor_alert_new_resources",
+  "secondary_dns_all_primaries_failing",
+  "secondary_dns_primaries_failing",
+  "secondary_dns_warning",
+  "secondary_dns_zone_successfully_updated",
+  "secondary_dns_zone_validation_warning",
+  "security_insights_alert",
+  "sentinel_alert",
+  "stream_live_notifications",
+  "synthetic_test_latency_alert",
+  "synthetic_test_low_availability_alert",
+  "traffic_anomalies_alert",
+  "tunnel_health_event",
+  "tunnel_update_event",
+  "universal_ssl_event_type",
+  "web_analytics_metrics_update",
+  "zone_aop_custom_certificate_expiration_type",
+])
+
+const STRING_FILTER_SCHEMA = z.string().min(1).array().min(1)
+export const CLOUDFLARE_NOTIFICATION_FILTERS_SCHEMA = z.object({
+  actions: STRING_FILTER_SCHEMA.optional(),
+  affectedAsns: STRING_FILTER_SCHEMA.optional(),
+  affectedComponents: STRING_FILTER_SCHEMA.optional(),
+  affectedLocations: STRING_FILTER_SCHEMA.optional(),
+  airportCode: STRING_FILTER_SCHEMA.optional(),
+  alertTriggerPreferences: STRING_FILTER_SCHEMA.optional(),
+  alertTriggerPreferencesValue: STRING_FILTER_SCHEMA.optional(),
+  enabled: STRING_FILTER_SCHEMA.optional(),
+  environment: STRING_FILTER_SCHEMA.optional(),
+  event: STRING_FILTER_SCHEMA.optional(),
+  eventSource: STRING_FILTER_SCHEMA.optional(),
+  eventType: STRING_FILTER_SCHEMA.optional(),
+  groupBy: STRING_FILTER_SCHEMA.optional(),
+  healthCheckId: STRING_FILTER_SCHEMA.optional(),
+  incidentImpact: z
+    .enum([
+      "INCIDENT_IMPACT_CRITICAL",
+      "INCIDENT_IMPACT_MAJOR",
+      "INCIDENT_IMPACT_MINOR",
+      "INCIDENT_IMPACT_NONE",
+    ])
+    .array()
+    .min(1)
+    .optional(),
+  inputId: STRING_FILTER_SCHEMA.optional(),
+  insightClass: STRING_FILTER_SCHEMA.optional(),
+  limit: STRING_FILTER_SCHEMA.optional(),
+  logoTag: STRING_FILTER_SCHEMA.optional(),
+  megabitsPerSecond: STRING_FILTER_SCHEMA.optional(),
+  newHealth: STRING_FILTER_SCHEMA.optional(),
+  newStatus: STRING_FILTER_SCHEMA.optional(),
+  packetsPerSecond: STRING_FILTER_SCHEMA.optional(),
+  poolId: STRING_FILTER_SCHEMA.optional(),
+  popNames: STRING_FILTER_SCHEMA.optional(),
+  product: STRING_FILTER_SCHEMA.optional(),
+  projectId: STRING_FILTER_SCHEMA.optional(),
+  protocol: STRING_FILTER_SCHEMA.optional(),
+  queryTag: STRING_FILTER_SCHEMA.optional(),
+  requestsPerSecond: STRING_FILTER_SCHEMA.optional(),
+  selectors: STRING_FILTER_SCHEMA.optional(),
+  services: STRING_FILTER_SCHEMA.optional(),
+  slo: STRING_FILTER_SCHEMA.optional(),
+  status: STRING_FILTER_SCHEMA.optional(),
+  targetHostname: STRING_FILTER_SCHEMA.optional(),
+  targetIp: STRING_FILTER_SCHEMA.optional(),
+  targetZoneName: STRING_FILTER_SCHEMA.optional(),
+  trafficExclusions: z.literal("security_events").array().max(1).optional(),
+  tunnelId: STRING_FILTER_SCHEMA.optional(),
+  tunnelName: STRING_FILTER_SCHEMA.optional(),
+  type: STRING_FILTER_SCHEMA.optional(),
+  where: STRING_FILTER_SCHEMA.optional(),
+  zones: STRING_FILTER_SCHEMA.optional(),
+})
+
+export const CLOUDFLARE_NOTIFICATION_MECHANISMS_SCHEMA = z.object({
+  email: z.object({ id: z.email() }).array().optional(),
+  pagerduty: z
+    .object({ id: z.string().min(1) })
+    .array()
+    .optional(),
+  webhooks: z
+    .object({ id: z.string().min(1) })
+    .array()
+    .optional(),
+})
+
+export const CLOUDFLARE_NOTIFICATION_POLICY_SCHEMA = z.object({
+  alertInterval: z.string().optional(),
+  alertType: CLOUDFLARE_ALERT_TYPE_SCHEMA,
+  created: z.string().optional(),
+  description: z.string().optional(),
+  enabled: z.boolean(),
+  filters: CLOUDFLARE_NOTIFICATION_FILTERS_SCHEMA.optional(),
+  id: z.string().min(1).optional(),
+  mechanisms: CLOUDFLARE_NOTIFICATION_MECHANISMS_SCHEMA,
+  modified: z.string().optional(),
+  name: z.string().min(1),
+})
+
+export const CLOUDFLARE_AVAILABLE_ALERT_SCHEMA = z.object({
+  description: z.string().optional(),
+  displayName: z.string().optional(),
+  filterOptions: encodableSchema.optional(),
+  type: CLOUDFLARE_ALERT_TYPE_SCHEMA,
+})
+
+export const CLOUDFLARE_NOTIFICATION_HISTORY_SCHEMA = z.object({
+  alertBody: z.string().optional(),
+  alertType: z.string().optional(),
+  description: z.string().optional(),
+  id: z.string().optional(),
+  mechanism: z.string().optional(),
+  mechanismType: z.enum(["email", "pagerduty", "webhook"]).optional(),
+  name: z.string().optional(),
+  policyId: z.string().optional(),
+  sent: z.string().optional(),
+})
+
+export const CLOUDFLARE_DELETE_RESULT_SCHEMA = z.object({
+  id: z.string().min(1),
+})
+
+export const CLOUDFLARE_NOTIFICATION_WEBHOOK_SCHEMA = z.object({
+  createdAt: z.string().optional(),
+  id: z.string().min(1),
+  lastFailure: z.string().optional(),
+  lastSuccess: z.string().optional(),
+  name: z.string().optional(),
+  type: z
+    .enum([
+      "datadog",
+      "discord",
+      "feishu",
+      "gchat",
+      "generic",
+      "opsgenie",
+      "slack",
+      "splunk",
+    ])
+    .optional(),
+  url: z.string().optional(),
+})
+
+export const CLOUDFLARE_API_RESPONSE_INFO_SCHEMA = RESPONSE_INFO_SCHEMA

package/src/linear/api.ts

@@ -2,9 +2,10 @@ import type { JsonObject } from "type-fest"
 import * as z from "zod"
 
 const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql"
-const LINEAR_SECRET_SCHEMA = z.object({
-  accessToken: z.string().min(1),
-})
+const LINEAR_SECRET_SCHEMA = z.union([
+  z.object({ accessToken: z.string().min(1) }),
+  z.object({ apiKey: z.string().min(1) }),
+])
 const LINEAR_ERROR_SCHEMA = z.looseObject({
   extensions: z.record(z.string(), z.json()).optional(),
   message: z.string(),
@@ -94,10 +95,10 @@ export class LinearApiError extends Error {
  * action. OAuth access tokens are resolved by the platform and never exposed to
  * automation code.
  *
- * @param secret - Resolved Linear OAuth integration secret.
+ * @param secret - Resolved Linear OAuth or personal API-key secret.
  */
 export function getLinearApi(secret: Record<string, unknown>): LinearApi {
-  const { accessToken } = LINEAR_SECRET_SCHEMA.parse(secret)
+  const credential = LINEAR_SECRET_SCHEMA.parse(secret)
 
   return {
     graphql: async (document, options) => {
@@ -108,7 +109,10 @@ export function getLinearApi(secret: Record<string, unknown>): LinearApi {
         }),
         headers: {
           Accept: "application/json",
-          Authorization: `Bearer ${accessToken}`,
+          Authorization:
+            "accessToken" in credential
+              ? `Bearer ${credential.accessToken}`
+              : credential.apiKey,
           "Content-Type": "application/json",
         },
         method: "POST",