@keystrokehq/segment 0.0.15 → 0.0.16-integration-id-canonicalization.0

package/dist/{integration-DWeMeBqQ.d.mts → segment.credential-set-BgROtI_9.d.mts}

@@ -1,32 +1,13 @@
-import * as _keystrokehq_integration_authoring_official0 from "@keystrokehq/integration-authoring/official";
+import { CredentialSet } from "@keystrokehq/core";
 import { z } from "zod";
-import * as _keystrokehq_core0 from "@keystrokehq/core";
 import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
 
-//#region src/integration.d.ts
+//#region src/credential-sets/segment.credential-set.d.ts
 declare const segmentRegionSchema: z.ZodEnum<{
   us: "us";
   eu: "eu";
 }>;
-declare const segmentOfficialIntegration: {
-  id: "segment";
-  name: string;
-  description: string;
-  credentialType: "manual";
-  auth: z.ZodObject<{
-    SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
-    SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
-      us: "us";
-      eu: "eu";
-    }>>;
-    SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
-    SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
-    SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
-    SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
-    SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>;
-};
-declare const segmentBundle: _keystrokehq_integration_authoring_official0.OfficialIntegrationBundle<"segment", z.ZodObject<{
+declare const segmentAuthSchema: z.ZodObject<{
   SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
   SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
     us: "us";
@@ -37,8 +18,12 @@ declare const segmentBundle: _keystrokehq_integration_authoring_official0.Offici
   SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
   SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
   SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-declare const segment: _keystrokehq_core0.CredentialSet<"keystroke:segment", z.ZodObject<{
+}, z.core.$strip>;
+/**
+ * Segment integration — manual credential model spanning Public API, Tracking
+ * API, and Profile API surfaces on a single connection.
+ */
+declare const segmentCredentialSet: CredentialSet<"segment", z.ZodObject<{
   SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
   SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
     us: "us";
@@ -49,8 +34,24 @@ declare const segment: _keystrokehq_core0.CredentialSet<"keystroke:segment", z.Z
   SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
   SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
   SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-type SegmentCredentials = InferCredentialSetAuth<typeof segment>;
+}, z.core.$strip>, {
+  id: string;
+  kind: "manual";
+  label: string;
+  input: z.ZodObject<{
+    SEGMENT_PUBLIC_API_TOKEN: z.ZodString;
+    SEGMENT_REGION: z.ZodDefault<z.ZodEnum<{
+      us: "us";
+      eu: "eu";
+    }>>;
+    SEGMENT_DEFAULT_WRITE_KEY: z.ZodOptional<z.ZodString>;
+    SEGMENT_WRITE_KEYS_JSON: z.ZodOptional<z.ZodString>;
+    SEGMENT_PROFILE_API_TOKEN: z.ZodOptional<z.ZodString>;
+    SEGMENT_PROFILE_SPACE_ID: z.ZodOptional<z.ZodString>;
+    SEGMENT_WEBHOOK_SHARED_SECRET: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}[]>;
+type SegmentCredentials = InferCredentialSetAuth<typeof segmentCredentialSet>;
 type SegmentRegion = z.infer<typeof segmentRegionSchema>;
 //#endregion
-export { segmentOfficialIntegration as a, segmentBundle as i, SegmentRegion as n, segment as r, SegmentCredentials as t };
+export { segmentRegionSchema as a, segmentCredentialSet as i, SegmentRegion as n, segmentAuthSchema as r, SegmentCredentials as t };

package/dist/{triggers.d.mts → triggers/index.d.mts}

@@ -1,11 +1,77 @@
-import { r as segment } from "./integration-DWeMeBqQ.mjs";
-import { SegmentAudienceSyncEvent, SegmentDeletionRegulationEvent, SegmentDestinationCreatedEvent, SegmentFunctionVersionEvent, SegmentReverseEtlRunEvent, SegmentSourceCreatedEvent, SegmentTrackingPlanViolationEvent } from "./events.mjs";
-import { IntegrationTriggerBindingOptions } from "@keystrokehq/integration-authoring";
+import { i as segmentCredentialSet } from "../segment.credential-set-BgROtI_9.mjs";
 import { BoundTrigger } from "@keystrokehq/core";
+import { z } from "zod";
 import { PollingTriggerManifest } from "@keystrokehq/core/trigger";
 
-//#region src/triggers.d.ts
-type SegmentCredentialSets = readonly [typeof segment];
+//#region src/events/index.d.ts
+declare const segmentReverseEtlRunEventSchema: z.ZodObject<{
+  runId: z.ZodString;
+  modelId: z.ZodString;
+  status: z.ZodEnum<{
+    IN_PROGRESS: "IN_PROGRESS";
+    SUCCEEDED: "SUCCEEDED";
+    FAILED: "FAILED";
+  }>;
+  startedAt: z.ZodOptional<z.ZodString>;
+  finishedAt: z.ZodOptional<z.ZodString>;
+  error: z.ZodOptional<z.ZodString>;
+  raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type SegmentReverseEtlRunEvent = z.infer<typeof segmentReverseEtlRunEventSchema>;
+declare const segmentFunctionVersionEventSchema: z.ZodObject<{
+  functionId: z.ZodString;
+  versionId: z.ZodString;
+  createdAt: z.ZodOptional<z.ZodString>;
+  raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type SegmentFunctionVersionEvent = z.infer<typeof segmentFunctionVersionEventSchema>;
+declare const segmentAudienceSyncEventSchema: z.ZodObject<{
+  syncId: z.ZodString;
+  audienceId: z.ZodString;
+  spaceId: z.ZodString;
+  status: z.ZodEnum<{
+    success: "success";
+    partial: "partial";
+    failed: "failed";
+  }>;
+  finishedAt: z.ZodOptional<z.ZodString>;
+  raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type SegmentAudienceSyncEvent = z.infer<typeof segmentAudienceSyncEventSchema>;
+declare const segmentSourceCreatedEventSchema: z.ZodObject<{
+  sourceId: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type SegmentSourceCreatedEvent = z.infer<typeof segmentSourceCreatedEventSchema>;
+declare const segmentDestinationCreatedEventSchema: z.ZodObject<{
+  destinationId: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type SegmentDestinationCreatedEvent = z.infer<typeof segmentDestinationCreatedEventSchema>;
+declare const segmentTrackingPlanViolationEventSchema: z.ZodObject<{
+  violationId: z.ZodString;
+  eventName: z.ZodOptional<z.ZodString>;
+  trackingPlanId: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  messageId: z.ZodOptional<z.ZodString>;
+  raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type SegmentTrackingPlanViolationEvent = z.infer<typeof segmentTrackingPlanViolationEventSchema>;
+declare const segmentDeletionRegulationEventSchema: z.ZodObject<{
+  regulationId: z.ZodString;
+  regulationType: z.ZodOptional<z.ZodString>;
+  finishedAt: z.ZodOptional<z.ZodString>;
+  raw: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type SegmentDeletionRegulationEvent = z.infer<typeof segmentDeletionRegulationEventSchema>;
+//#endregion
+//#region src/triggers/polling.d.ts
+type SegmentCredentialSets = readonly [typeof segmentCredentialSet];
 type SegmentPollingBindingOptions<TEvent, TOutput = TEvent> = IntegrationTriggerBindingOptions<TEvent, TOutput> & {
   readonly schedule?: string;
 };
@@ -41,4 +107,4 @@ declare const polling: Readonly<{
   deletionRegulationCompleted: typeof deletionRegulationCompleted;
 }>;
 //#endregion
-export { AudienceSyncPollParams, FunctionVersionPollParams, ReverseEtlRunPollParams, audienceSyncCompleted, deletionRegulationCompleted, destinationCreated, functionsDeploymentCompleted, polling, reverseEtlRunFailed, reverseEtlRunStarted, reverseEtlRunSucceeded, sourceCreated, trackingPlanViolationDetected };
+export { type AudienceSyncPollParams, type FunctionVersionPollParams, type ReverseEtlRunPollParams, audienceSyncCompleted, deletionRegulationCompleted, destinationCreated, functionsDeploymentCompleted, polling, reverseEtlRunFailed, reverseEtlRunStarted, reverseEtlRunSucceeded, sourceCreated, trackingPlanViolationDetected };

package/dist/{triggers.mjs → triggers/index.mjs}

@@ -1,19 +1,198 @@
-import { t as segment } from "./integration-CliT2xe3.mjs";
-import { createSegmentClient } from "./client.mjs";
-import { segmentAudienceSyncEventSchema, segmentDeletionRegulationEventSchema, segmentDestinationCreatedEventSchema, segmentFunctionVersionEventSchema, segmentReverseEtlRunEventSchema, segmentSourceCreatedEventSchema, segmentTrackingPlanViolationEventSchema } from "./events.mjs";
-import { createPollingTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+import { n as segmentCredentialSet } from "../segment.credential-set-BTTrkHO7.mjs";
+import { a as segmentLooseObjectSchema } from "../common-DUU0airJ.mjs";
+import { t as createSegmentClient } from "../client-DQfeZzLR.mjs";
+import { z } from "zod";
+import { pollingTrigger } from "@keystrokehq/core/trigger";
 
-//#region src/triggers.ts
+//#region ../../packages/integration-authoring/dist/index.mjs
+const IntegrationConfigSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional()
+});
+function resolveMetadata(metadata, defaults) {
+	return {
+		id: metadata?.id ?? defaults.defaultId,
+		description: metadata?.description ?? defaults.defaultDescription
+	};
+}
+function resolveAuthorPayload(payload, mapPayload) {
+	if (!mapPayload) return payload;
+	return mapPayload(payload);
+}
+function createIntegrationTriggerBindingFactory(config) {
+	const bind = (options) => {
+		const resolvedMetadata = resolveMetadata(options, config);
+		const baseTrigger = config.createBaseTrigger(resolvedMetadata);
+		const userTransform = options?.transform;
+		return baseTrigger({ transform: userTransform || config.mapPayload ? (runtimePayload, request) => {
+			const authorPayload = resolveAuthorPayload(runtimePayload, config.mapPayload);
+			if (authorPayload === null) throw new Error(`Trigger "${resolvedMetadata.id}" mapPayload returned null after the trigger filter passed; tighten the trigger filter schema.`);
+			if (!userTransform) return authorPayload;
+			return userTransform(authorPayload, request);
+		} : void 0 });
+	};
+	return Object.freeze(bind);
+}
+function createPollingTriggerBindingFactory(config) {
+	return createIntegrationTriggerBindingFactory({
+		defaultId: config.defaultId,
+		defaultDescription: config.defaultDescription,
+		mapPayload: config.mapPayload,
+		createBaseTrigger: (metadata) => pollingTrigger({
+			id: metadata.id,
+			description: metadata.description,
+			schedule: config.schedule,
+			response: config.response,
+			poll: config.poll,
+			...config.credentialSets ? { credentialSets: config.credentialSets } : {},
+			...config.filter ? { filter: config.filter } : {}
+		})
+	});
+}
+
+//#endregion
+//#region src/events/index.ts
+/**
+* segment/events.ts
+*
+* Curated trigger-event schemas. Segment does not publish a unified webhook
+* event catalog — each destination shape (Webhook destination, Monitoring
+* alert webhook, Functions runtime webhook) carries its own body. We define
+* the author-visible shapes here and parse the raw payload into them in
+* `triggers.ts`.
+*/
+/** Loose envelope a Segment Webhook destination delivers for Engage
+* audiences: the destination wraps the Engage event as a Segment "track"
+* call with properties carrying audience state. */
+const segmentAudienceWebhookEnvelopeSchema = segmentLooseObjectSchema({
+	type: z.string().optional(),
+	event: z.string().optional(),
+	userId: z.string().optional(),
+	anonymousId: z.string().optional(),
+	messageId: z.string().optional(),
+	timestamp: z.string().optional(),
+	traits: z.record(z.string(), z.unknown()).optional(),
+	properties: z.record(z.string(), z.unknown()).optional(),
+	context: z.record(z.string(), z.unknown()).optional()
+});
+/** Monitoring alert webhook envelope (fired for delivery-failure spikes,
+* function invocation errors, etc.). */
+const segmentMonitoringAlertEnvelopeSchema = segmentLooseObjectSchema({
+	id: z.string().optional(),
+	subscriptionId: z.string().optional(),
+	eventType: z.string().optional(),
+	severity: z.string().optional(),
+	firedAt: z.string().optional(),
+	message: z.string().optional(),
+	sourceId: z.string().optional(),
+	destinationId: z.string().optional(),
+	functionId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+const segmentAudienceEventSchema = z.object({
+	type: z.enum(["entered", "exited"]),
+	audienceKey: z.string(),
+	userId: z.string().optional(),
+	anonymousId: z.string().optional(),
+	profileId: z.string().optional(),
+	traits: z.record(z.string(), z.unknown()).optional(),
+	properties: z.record(z.string(), z.unknown()).optional(),
+	messageId: z.string().optional(),
+	timestamp: z.string().optional(),
+	raw: segmentAudienceWebhookEnvelopeSchema
+});
+const segmentComputedTraitEventSchema = z.object({
+	traitKey: z.string(),
+	value: z.unknown(),
+	userId: z.string().optional(),
+	profileId: z.string().optional(),
+	messageId: z.string().optional(),
+	timestamp: z.string().optional(),
+	raw: segmentAudienceWebhookEnvelopeSchema
+});
+const segmentMonitoringEventSchema = z.object({
+	alertId: z.string(),
+	eventType: z.string(),
+	severity: z.string().optional(),
+	firedAt: z.string().optional(),
+	sourceId: z.string().optional(),
+	destinationId: z.string().optional(),
+	functionId: z.string().optional(),
+	message: z.string().optional(),
+	raw: segmentMonitoringAlertEnvelopeSchema
+});
+const segmentReverseEtlRunEventSchema = z.object({
+	runId: z.string(),
+	modelId: z.string(),
+	status: z.enum([
+		"IN_PROGRESS",
+		"SUCCEEDED",
+		"FAILED"
+	]),
+	startedAt: z.string().optional(),
+	finishedAt: z.string().optional(),
+	error: z.string().optional(),
+	raw: z.record(z.string(), z.unknown())
+});
+const segmentFunctionVersionEventSchema = z.object({
+	functionId: z.string(),
+	versionId: z.string(),
+	createdAt: z.string().optional(),
+	raw: z.record(z.string(), z.unknown())
+});
+const segmentAudienceSyncEventSchema = z.object({
+	syncId: z.string(),
+	audienceId: z.string(),
+	spaceId: z.string(),
+	status: z.enum([
+		"success",
+		"partial",
+		"failed"
+	]),
+	finishedAt: z.string().optional(),
+	raw: z.record(z.string(), z.unknown())
+});
+const segmentSourceCreatedEventSchema = z.object({
+	sourceId: z.string(),
+	name: z.string().optional(),
+	createdAt: z.string().optional(),
+	raw: z.record(z.string(), z.unknown())
+});
+const segmentDestinationCreatedEventSchema = z.object({
+	destinationId: z.string(),
+	name: z.string().optional(),
+	sourceId: z.string().optional(),
+	createdAt: z.string().optional(),
+	raw: z.record(z.string(), z.unknown())
+});
+const segmentTrackingPlanViolationEventSchema = z.object({
+	violationId: z.string(),
+	eventName: z.string().optional(),
+	trackingPlanId: z.string().optional(),
+	sourceId: z.string().optional(),
+	messageId: z.string().optional(),
+	raw: z.record(z.string(), z.unknown())
+});
+const segmentDeletionRegulationEventSchema = z.object({
+	regulationId: z.string(),
+	regulationType: z.string().optional(),
+	finishedAt: z.string().optional(),
+	raw: z.record(z.string(), z.unknown())
+});
+
+//#endregion
+//#region src/triggers/polling.ts
 function buildPollingBinding(definition, options) {
 	const schedule = options?.schedule ?? definition.defaultSchedule;
 	return createPollingTriggerBindingFactory({
 		defaultId: definition.defaultId,
 		defaultDescription: definition.defaultDescription,
 		schedule,
-		credentialSets: [segment],
+		credentialSets: [segmentCredentialSet],
 		response: definition.eventSchema,
 		poll: async (ctx) => {
-			const credentials = ctx.credentials["keystroke:segment"];
+			const credentials = ctx.credentials.segment;
 			return definition.poll(credentials, ctx.lastPolledAt);
 		}
 	})({