@prismatic-io/components-google-analytics-ga4 0.0.0-stage → 0.1.0

package/npm-dist/index.cjs

@@ -0,0 +1,1081 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+//#region src/constants.ts
+const LOOK_BACK_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const ANALYTICS_ENDPOINTS = {
+	adminv1beta: "https://analyticsadmin.googleapis.com/v1beta",
+	datav1beta: "https://analyticsdata.googleapis.com/v1beta"
+};
+const POLL_RESOURCE_CONFIG = {
+	accounts: { label: "Accounts" },
+	properties: { label: "Properties" }
+};
+const POLL_RESOURCE_KEYS = {
+	ACCOUNTS: "accounts",
+	PROPERTIES: "properties"
+};
+//#endregion
+//#region src/client.ts
+const createAnalyticsClient = ({ connection, endpointType, debug }) => {
+	const accessToken = connection.token?.access_token;
+	return (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: ANALYTICS_ENDPOINTS[endpointType],
+		headers: { Authorization: `Bearer ${accessToken}` },
+		debug
+	});
+};
+//#endregion
+//#region src/examplePayloads.ts
+const listAccountsExamplePayload = { data: { accounts: [{
+	name: "accounts/000000000",
+	createTime: "2012-11-20T15:12:07.864Z",
+	updateTime: "2015-08-11T21:08:55.416Z",
+	displayName: "Example Account",
+	regionCode: "US"
+}] } };
+const listPropertiesExamplePayload = { data: { properties: [{
+	name: "properties/111111111",
+	parent: "accounts/000000000",
+	createTime: "2022-02-02T04:40:59.611Z",
+	updateTime: "2022-02-02T04:40:59.611Z",
+	displayName: "www.example.com",
+	industryCategory: "OTHER",
+	timeZone: "America/Chicago",
+	currencyCode: "USD",
+	serviceLevel: "GOOGLE_ANALYTICS_STANDARD",
+	account: "accounts/000000000",
+	propertyType: "PROPERTY_TYPE_ORDINARY"
+}] } };
+const getPropertyExamplePayload = { data: {
+	name: "properties/111111111",
+	parent: "accounts/000000000",
+	createTime: "2022-02-02T04:40:59.611Z",
+	updateTime: "2022-02-02T04:40:59.611Z",
+	displayName: "www.example.com",
+	industryCategory: "OTHER",
+	timeZone: "America/Chicago",
+	currencyCode: "USD",
+	serviceLevel: "GOOGLE_ANALYTICS_STANDARD",
+	account: "accounts/000000000",
+	propertyType: "PROPERTY_TYPE_ORDINARY"
+} };
+const runReportExamplePayload = { data: {
+	dimensionHeaders: [{ name: "pageTitle" }],
+	metricHeaders: [{
+		name: "sessions",
+		type: "TYPE_INTEGER"
+	}],
+	rows: [{
+		dimensionValues: [{ value: "My Example Page | My Website" }],
+		metricValues: [{ value: "9" }]
+	}, {
+		dimensionValues: [{ value: "A blog post | My Blog" }],
+		metricValues: [{ value: "3" }]
+	}],
+	rowCount: 2,
+	metadata: {
+		currencyCode: "USD",
+		timeZone: "America/Chicago"
+	},
+	kind: "analyticsData#runReport"
+} };
+const sendMeasurementProtocolEventsExamplePayload = { data: { message: "Event Sent Successfully" } };
+const listAccountsDataSourceExamplePayload = { result: [{
+	key: "accounts/000000000",
+	label: "My Account 1"
+}, {
+	key: "accounts/000000001",
+	label: "My Account 2"
+}] };
+const pollChangesTriggerExamplePayload = { payload: {
+	headers: {},
+	queryParameters: {},
+	rawBody: { data: null },
+	body: { data: {
+		created: [{
+			name: "accounts/000000001",
+			createTime: "2026-08-13T09:15:22.101Z",
+			updateTime: "2026-08-13T09:15:22.101Z",
+			displayName: "Newly Created Account",
+			regionCode: "US"
+		}],
+		updated: [{
+			name: "accounts/000000000",
+			createTime: "2012-11-20T15:12:07.864Z",
+			updateTime: "2026-08-13T11:42:05.338Z",
+			displayName: "Example Account",
+			regionCode: "US"
+		}]
+	} },
+	pathFragment: "",
+	webhookUrls: {},
+	webhookApiKeys: {},
+	invokeUrl: "",
+	executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElk",
+	customer: {
+		id: "testCustomerId",
+		name: "Test Customer",
+		externalId: "testExternalId"
+	},
+	instance: {
+		id: "testInstanceId",
+		name: "Test Instance"
+	},
+	user: {
+		id: "testUserId",
+		email: "user@example.com",
+		name: "Test User",
+		externalId: "testUserExternalId"
+	},
+	integration: {
+		id: "testIntegrationId",
+		name: "Test Integration",
+		versionSequenceId: "1",
+		externalVersion: ""
+	},
+	flow: {
+		id: "testFlowId",
+		name: "Test Flow",
+		stableId: "testFlowStableId"
+	},
+	startedAt: "2026-08-13T00:00:00.000Z",
+	globalDebug: false
+} };
+//#endregion
+//#region src/util.ts
+const toOptionalString = (input) => {
+	return input ? _prismatic_io_spectral.util.types.toString(input) : void 0;
+};
+const pollResourceModel = Object.entries(POLL_RESOURCE_CONFIG).map(([value, { label }]) => ({
+	label,
+	value
+}));
+const paginateRecords = async (client, url, params, fetchAll, propertyKey) => {
+	const records = { [propertyKey]: [] };
+	const pageSize = params.pageSize ? _prismatic_io_spectral.util.types.toNumber(params.pageSize) : 200;
+	const { data } = await client.get(url, { params: {
+		...params,
+		pageSize
+	} });
+	data[propertyKey] = data[propertyKey] ?? [];
+	records[propertyKey] = data[propertyKey];
+	let nextPageToken = data.nextPageToken || "";
+	if (fetchAll && nextPageToken) {
+		while (nextPageToken) {
+			const response = await client.get(url, { params: {
+				...params,
+				pageSize,
+				pageToken: nextPageToken
+			} });
+			records[propertyKey] = records[propertyKey].concat(response.data[propertyKey] ?? []);
+			nextPageToken = response.data.nextPageToken || "";
+		}
+		return records;
+	}
+	return data;
+};
+const resolvePollingRecordChanges = (data) => {
+	const changesObject = data ?? {};
+	return [...(changesObject.created ?? []).map((record) => ({
+		changeType: "created",
+		record
+	})), ...(changesObject.updated ?? []).map((record) => ({
+		changeType: "updated",
+		record
+	}))];
+};
+const filterByTimestamp = (records, lastPolledAt, isBackfill, showNewRecords, showUpdatedRecords) => {
+	const lastPolledAtDate = new Date(lastPolledAt);
+	const created = [];
+	const updated = [];
+	for (const record of records) {
+		const { createTime, updateTime } = record;
+		const createdAtDate = typeof createTime === "string" ? new Date(createTime) : null;
+		const updatedAtDate = typeof updateTime === "string" ? new Date(updateTime) : null;
+		const isNew = createdAtDate !== null && createdAtDate > lastPolledAtDate;
+		const isUpdated = !isNew && updatedAtDate !== null && updatedAtDate > lastPolledAtDate;
+		if (isNew && (isBackfill || showNewRecords)) created.push(record);
+		else if (isUpdated && (isBackfill || showUpdatedRecords)) updated.push(record);
+	}
+	return {
+		created,
+		updated
+	};
+};
+const lookBackDateClean = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim();
+	if (!str) return "";
+	if (!LOOK_BACK_DATE_PATTERN.test(str)) throw new Error("Look-back Date must be in YYYY-MM-DD format.");
+	const parts = str.split("-");
+	const year = _prismatic_io_spectral.util.types.toNumber(parts[0]);
+	const month = _prismatic_io_spectral.util.types.toNumber(parts[1]);
+	const day = _prismatic_io_spectral.util.types.toNumber(parts[2]);
+	const parsed = new Date(year, month - 1, day);
+	if (parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) throw new Error(`Look-back Date "${str}" is not a valid calendar date.`);
+	if (parsed > /* @__PURE__ */ new Date()) throw new Error("Look-back Date cannot be a future date.");
+	return str;
+};
+//#endregion
+//#region src/inputs.ts
+const cleanId = (idType, id) => {
+	if (id.startsWith(idType)) return id;
+	else return `${idType}/${id}`;
+};
+const pageToken = (0, _prismatic_io_spectral.input)({
+	label: "Page Token",
+	type: "string",
+	required: false,
+	example: "CjwKCAjwpdqkBhB-EiwA4Kk0u3bXgYx5mXo3nZl6e7jYz1hA0r8D6Gq2b8g7fX9WlX1Jf4bJpQ8YhoCjvsQAvD_BwE",
+	placeholder: "Enter a page token",
+	comments: "If a previous response was truncated, the response includes a `nextPageToken`. To retrieve the next page of results, set this parameter to the value of `nextPageToken` from the previous response.",
+	clean: toOptionalString
+});
+const pageSize = (0, _prismatic_io_spectral.input)({
+	label: "Page Size",
+	type: "string",
+	required: false,
+	example: "100",
+	placeholder: "Enter a page size",
+	comments: `The maximum number of resources contained in the underlying API response. The API may return fewer values in a page, even if there are additional values to return. If unspecified, 200 is requested, which is also the maximum.`,
+	clean: toOptionalString
+});
+const connectionInput = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true
+});
+const propertyIdInput = (0, _prismatic_io_spectral.input)({
+	label: "Property ID",
+	type: "string",
+	required: true,
+	example: "properties/111111111",
+	placeholder: "Enter a property ID",
+	comments: "The unique identifier for the GA4 property, in properties/NNNNNNNNN form. A bare numeric ID is accepted and normalized.",
+	dataSource: "listProperties",
+	clean: (value) => cleanId("properties", _prismatic_io_spectral.util.types.toString(value))
+});
+const appInstanceId = (0, _prismatic_io_spectral.input)({
+	label: "App Instance ID",
+	comments: "The unique identifier assigned to an app installation on a device. Sent as app_instance_id in the Measurement Protocol payload.",
+	type: "string",
+	required: true,
+	example: "12345678901234567890123456789012",
+	placeholder: "Enter an app instance ID",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const events = (0, _prismatic_io_spectral.input)({
+	label: "Events To Send",
+	comments: "The events to send to Google Analytics",
+	type: "code",
+	language: "json",
+	required: true,
+	example: JSON.stringify([{
+		name: "campaign_details",
+		params: {
+			campaign_id: "google_1234",
+			campaign: "Summer_fun",
+			source: "google",
+			medium: "cpc",
+			term: "summer+travel",
+			content: "logolink",
+			session_id: "123",
+			engagement_time_msec: "100"
+		}
+	}])
+});
+const apiSecret = (0, _prismatic_io_spectral.input)({
+	label: "API Secret",
+	type: "password",
+	required: true,
+	example: "Str5ahciR5SJtWClz1mkRA",
+	placeholder: "Enter an API secret",
+	comments: "The Measurement Protocol API secret. Generate one in the Google Analytics UI under Admin > Data Streams > Measurement Protocol API secrets.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const firebaseAppId = (0, _prismatic_io_spectral.input)({
+	label: "Firebase App ID",
+	type: "string",
+	required: true,
+	example: "1:123456789012:web:1234567890123456789012",
+	placeholder: "1:123456789012:web:1234567890123456789012",
+	comments: "The Firebase App ID, found in the Firebase console under Project Settings > General > Your Apps > App ID",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const accountId = (0, _prismatic_io_spectral.input)({
+	label: "Account ID",
+	type: "string",
+	required: true,
+	example: "accounts/000000000",
+	placeholder: "Enter an account ID",
+	comments: "The unique identifier for the GA4 account that owns the properties, in accounts/NNNNNNNNN form.",
+	dataSource: "listAccounts",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	type: "boolean",
+	required: false,
+	comments: "When true, retrieves all pages of results.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const { debugRequest: _, ...restInputs } = _prismatic_io_spectral_http.inputs;
+const rawRequestInputs = {
+	connection: connectionInput,
+	baseUrl: (0, _prismatic_io_spectral.input)({
+		label: "Base URL",
+		type: "string",
+		required: true,
+		clean: _prismatic_io_spectral.util.types.toString,
+		model: Object.values(ANALYTICS_ENDPOINTS).map((endpoint) => ({
+			label: endpoint,
+			value: endpoint
+		}))
+	}),
+	...restInputs,
+	url: {
+		...restInputs.url,
+		comments: "Input the path only (/accounts), the base URL comes from the Base URL input. For example, to connect to the selected base URL followed by /accounts, only /accounts is entered in this field.",
+		example: "/accounts"
+	}
+};
+const pagination = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Page and page-size controls.",
+	inputs: {
+		pageSize,
+		pageToken
+	}
+});
+const listAccountsInputs = {
+	fetchAll,
+	pagination,
+	connection: connectionInput
+};
+const listPropertiesInputs = {
+	accountId,
+	fetchAll,
+	pagination,
+	connection: connectionInput
+};
+const getPropertyInputs = {
+	accountId: {
+		...accountId,
+		required: false
+	},
+	propertyId: propertyIdInput,
+	connection: connectionInput
+};
+const pollResourceType = (0, _prismatic_io_spectral.input)({
+	label: "Resource Type",
+	type: "string",
+	required: true,
+	model: pollResourceModel,
+	comments: "The Google Analytics GA4 resource type to poll for new or updated records.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const showNewRecords = (0, _prismatic_io_spectral.input)({
+	label: "Show New Records",
+	type: "boolean",
+	required: false,
+	default: "true",
+	comments: "When true, newly created records are included in the trigger output.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const showUpdatedRecords = (0, _prismatic_io_spectral.input)({
+	label: "Show Updated Records",
+	type: "boolean",
+	required: false,
+	default: "true",
+	comments: "When true, records that were modified after the last poll are included in the trigger output.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const lookBackDate = (0, _prismatic_io_spectral.input)({
+	label: "Look-back Date",
+	placeholder: "Enter look-back date (YYYY-MM-DD)",
+	type: "string",
+	required: false,
+	comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each record modified on or after this date once, ignoring the visibility filters.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+const pollChangesInputs = {
+	connection: {
+		...connectionInput,
+		comments: "The Google Analytics GA4 connection to use."
+	},
+	pollResourceType,
+	accountId: {
+		...accountId,
+		required: false,
+		placeholder: "Enter the account ID (e.g., accounts/000000000)",
+		comments: "The unique identifier for the Google Analytics account. Required when the Resource Type is 'Properties'."
+	},
+	showNewRecords,
+	showUpdatedRecords,
+	lookBackDate
+};
+const listAccountsOutputSchema = {
+	type: "object",
+	properties: {
+		accounts: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					displayName: { type: "string" },
+					regionCode: { type: "string" },
+					createTime: {
+						type: "string",
+						format: "date-time"
+					},
+					updateTime: {
+						type: "string",
+						format: "date-time"
+					},
+					deleted: { type: "boolean" },
+					gmpOrganization: { type: "string" }
+				},
+				required: []
+			}
+		},
+		nextPageToken: { type: "string" }
+	},
+	required: ["accounts"]
+};
+const propertySchema = {
+	type: "object",
+	properties: {
+		name: { type: "string" },
+		parent: { type: "string" },
+		account: { type: "string" },
+		displayName: { type: "string" },
+		propertyType: {
+			type: "string",
+			enum: [
+				"PROPERTY_TYPE_UNSPECIFIED",
+				"PROPERTY_TYPE_ORDINARY",
+				"PROPERTY_TYPE_SUBPROPERTY",
+				"PROPERTY_TYPE_ROLLUP"
+			]
+		},
+		industryCategory: {
+			type: "string",
+			enum: [
+				"INDUSTRY_CATEGORY_UNSPECIFIED",
+				"AUTOMOTIVE",
+				"BUSINESS_AND_INDUSTRIAL_MARKETS",
+				"FINANCE",
+				"HEALTHCARE",
+				"TECHNOLOGY",
+				"TRAVEL",
+				"OTHER",
+				"ARTS_AND_ENTERTAINMENT",
+				"BEAUTY_AND_FITNESS",
+				"BOOKS_AND_LITERATURE",
+				"FOOD_AND_DRINK",
+				"GAMES",
+				"HOBBIES_AND_LEISURE",
+				"HOME_AND_GARDEN",
+				"INTERNET_AND_TELECOM",
+				"LAW_AND_GOVERNMENT",
+				"NEWS",
+				"ONLINE_COMMUNITIES",
+				"PEOPLE_AND_SOCIETY",
+				"PETS_AND_ANIMALS",
+				"REAL_ESTATE",
+				"REFERENCE",
+				"SCIENCE",
+				"SPORTS",
+				"JOBS_AND_EDUCATION",
+				"SHOPPING"
+			]
+		},
+		serviceLevel: {
+			type: "string",
+			enum: [
+				"SERVICE_LEVEL_UNSPECIFIED",
+				"GOOGLE_ANALYTICS_STANDARD",
+				"GOOGLE_ANALYTICS_360"
+			]
+		},
+		timeZone: { type: "string" },
+		currencyCode: { type: "string" },
+		createTime: {
+			type: "string",
+			format: "date-time"
+		},
+		updateTime: {
+			type: "string",
+			format: "date-time"
+		},
+		deleteTime: {
+			type: "string",
+			format: "date-time"
+		},
+		expireTime: {
+			type: "string",
+			format: "date-time"
+		}
+	},
+	required: []
+};
+const listPropertiesOutputSchema = {
+	type: "object",
+	properties: {
+		properties: {
+			type: "array",
+			items: propertySchema
+		},
+		nextPageToken: { type: "string" }
+	},
+	required: ["properties"]
+};
+const getPropertyOutputSchema = propertySchema;
+const rowSchema = {
+	type: "object",
+	properties: {
+		dimensionValues: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: { value: { type: "string" } },
+				required: [],
+				additionalProperties: true
+			}
+		},
+		metricValues: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: { value: { type: "string" } },
+				required: [],
+				additionalProperties: true
+			}
+		}
+	},
+	required: []
+};
+const quotaStatusSchema = {
+	type: "object",
+	properties: {
+		consumed: {
+			type: "integer",
+			format: "int32"
+		},
+		remaining: {
+			type: "integer",
+			format: "int32"
+		}
+	},
+	required: []
+};
+const runReportOutputSchema = {
+	type: "object",
+	properties: {
+		kind: { type: "string" },
+		dimensionHeaders: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: { name: { type: "string" } },
+				required: []
+			}
+		},
+		metricHeaders: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					type: {
+						type: "string",
+						enum: [
+							"METRIC_TYPE_UNSPECIFIED",
+							"TYPE_INTEGER",
+							"TYPE_FLOAT",
+							"TYPE_SECONDS",
+							"TYPE_MILLISECONDS",
+							"TYPE_MINUTES",
+							"TYPE_HOURS",
+							"TYPE_STANDARD",
+							"TYPE_CURRENCY",
+							"TYPE_FEET",
+							"TYPE_MILES",
+							"TYPE_METERS",
+							"TYPE_KILOMETERS"
+						]
+					}
+				},
+				required: []
+			}
+		},
+		rows: {
+			type: "array",
+			items: rowSchema
+		},
+		totals: {
+			type: "array",
+			items: rowSchema
+		},
+		maximums: {
+			type: "array",
+			items: rowSchema
+		},
+		minimums: {
+			type: "array",
+			items: rowSchema
+		},
+		rowCount: {
+			type: "integer",
+			format: "int32"
+		},
+		metadata: {
+			type: "object",
+			properties: {
+				currencyCode: { type: "string" },
+				timeZone: { type: "string" },
+				emptyReason: { type: "string" },
+				dataLossFromOtherRow: { type: "boolean" },
+				subjectToThresholding: { type: "boolean" },
+				samplingMetadatas: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							samplesReadCount: {
+								type: "string",
+								format: "int64"
+							},
+							samplingSpaceSize: {
+								type: "string",
+								format: "int64"
+							}
+						},
+						required: []
+					}
+				},
+				schemaRestrictionResponse: {
+					type: "object",
+					properties: { activeMetricRestrictions: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								metricName: { type: "string" },
+								restrictedMetricTypes: {
+									type: "array",
+									items: {
+										type: "string",
+										enum: [
+											"RESTRICTED_METRIC_TYPE_UNSPECIFIED",
+											"COST_DATA",
+											"REVENUE_DATA"
+										]
+									}
+								}
+							},
+							required: []
+						}
+					} },
+					required: []
+				}
+			},
+			required: []
+		},
+		propertyQuota: {
+			type: "object",
+			properties: {
+				tokensPerDay: quotaStatusSchema,
+				tokensPerHour: quotaStatusSchema,
+				concurrentRequests: quotaStatusSchema,
+				serverErrorsPerProjectPerHour: quotaStatusSchema,
+				potentiallyThresholdedRequestsPerHour: quotaStatusSchema,
+				tokensPerProjectPerHour: quotaStatusSchema
+			},
+			required: []
+		}
+	},
+	required: []
+};
+const sendMeasurementProtocolEventsOutputSchema = {
+	type: "object",
+	properties: { message: { type: "string" } },
+	required: ["message"]
+};
+var accounts_default$1 = { listAccounts: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Accounts",
+		description: "Return a list of accounts accessible by the caller"
+	},
+	inputs: listAccountsInputs,
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: listAccountsOutputSchema
+	}),
+	performSafety: "notAllowed",
+	perform: async (context, { connection, fetchAll, pagination }) => {
+		return { data: await paginateRecords(createAnalyticsClient({
+			connection,
+			endpointType: "adminv1beta",
+			debug: context.debug.enabled
+		}), "/accounts", {
+			pageSize: pagination.pageSize,
+			pageToken: pagination.pageToken
+		}, fetchAll, "accounts") };
+	},
+	examplePerform: async () => ({ ...listAccountsExamplePayload }),
+	examplePayload: listAccountsExamplePayload
+}) };
+//#endregion
+//#region src/consts.ts
+const GOOGLE_ANALYTICS_COLLECT_EVENTS_URL = "https://www.google-analytics.com";
+var measurementEvents_default = { sendMeasurementProtocolEvents: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Send Measurement Protocol Events",
+		description: "Sends Measurement Protocol Events to the Google Analytics GA4 account."
+	},
+	performSafety: "notAllowed",
+	perform: async (_context, { firebaseAppId, events, appInstanceId, apiSecret }) => {
+		const params = {
+			firebase_app_id: firebaseAppId,
+			api_secret: apiSecret
+		};
+		await (0, _prismatic_io_spectral_http.createClient)({ baseUrl: GOOGLE_ANALYTICS_COLLECT_EVENTS_URL }).post("/mp/collect", {
+			app_instance_id: appInstanceId,
+			events
+		}, { params });
+		return { data: { message: "Event Sent Successfully" } };
+	},
+	examplePerform: async () => ({ ...sendMeasurementProtocolEventsExamplePayload }),
+	inputs: {
+		firebaseAppId,
+		appInstanceId,
+		apiSecret,
+		events
+	},
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: sendMeasurementProtocolEventsOutputSchema
+	}),
+	examplePayload: sendMeasurementProtocolEventsExamplePayload
+}) };
+//#endregion
+//#region src/actions/properties.ts
+const listProperties$1 = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Properties",
+		description: "List Google Analytics GA4 properties for an account"
+	},
+	inputs: listPropertiesInputs,
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: listPropertiesOutputSchema
+	}),
+	performSafety: "notAllowed",
+	perform: async (context, { connection, accountId, pagination, fetchAll }) => {
+		return { data: await paginateRecords(createAnalyticsClient({
+			connection,
+			endpointType: "adminv1beta",
+			debug: context.debug.enabled
+		}), "/properties", {
+			filter: `parent:${accountId}`,
+			pageSize: pagination.pageSize,
+			pageToken: pagination.pageToken
+		}, fetchAll, "properties") };
+	},
+	examplePerform: async (_context, { accountId }) => {
+		const properties = listPropertiesExamplePayload.data.properties;
+		return { data: {
+			...listPropertiesExamplePayload.data,
+			properties: properties.map((property) => ({
+				...property,
+				parent: accountId,
+				account: accountId
+			}))
+		} };
+	},
+	examplePayload: listPropertiesExamplePayload
+});
+var properties_default$1 = {
+	getProperty: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Property",
+			description: "Get property by ID"
+		},
+		inputs: getPropertyInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getPropertyOutputSchema
+		}),
+		performSafety: "safe",
+		perform: async (context, params) => {
+			const { data } = await createAnalyticsClient({
+				connection: params.connection,
+				endpointType: "adminv1beta",
+				debug: context.debug.enabled
+			}).get(params.propertyId);
+			return { data };
+		},
+		examplePayload: getPropertyExamplePayload
+	}),
+	listProperties: listProperties$1,
+	runReport: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Run Report",
+			description: "Run a customized report on Google Analytics event data."
+		},
+		inputs: {
+			connection: connectionInput,
+			accountId: {
+				...accountId,
+				required: false
+			},
+			propertyId: propertyIdInput,
+			requestBody: (0, _prismatic_io_spectral.input)({
+				label: "Request Body",
+				type: "code",
+				language: "json",
+				required: true,
+				comments: "See [Google Analytics API documentation](https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport) for details on what dimensions, metrics, etc., can be specified.",
+				default: JSON.stringify({
+					dimensions: [{ name: "pageTitle" }],
+					metrics: [{ name: "sessions" }],
+					dateRanges: [{
+						startDate: "7daysAgo",
+						endDate: "yesterday"
+					}],
+					dimensionFilter: { notExpression: { filter: {
+						fieldName: "pageTitle",
+						stringFilter: { value: "My Homepage" }
+					} } }
+				}, null, 2),
+				clean: _prismatic_io_spectral.util.types.toObject
+			})
+		},
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: runReportOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (context, params) => {
+			const { data } = await createAnalyticsClient({
+				connection: params.connection,
+				endpointType: "datav1beta",
+				debug: context.debug.enabled
+			}).post(`${params.propertyId}:runReport`, params.requestBody);
+			return { data };
+		},
+		examplePerform: async (_context, { requestBody }) => {
+			const { dimensions, metrics } = requestBody;
+			const example = runReportExamplePayload.data;
+			const dimensionHeaders = dimensions?.length ? dimensions.map(({ name }) => ({ name })) : example.dimensionHeaders;
+			const metricHeaders = metrics?.length ? metrics.map(({ name }) => ({ name })) : example.metricHeaders;
+			return { data: {
+				...example,
+				dimensionHeaders,
+				metricHeaders,
+				rows: example.rows.map((row) => ({
+					dimensionValues: dimensionHeaders.map((_header, index) => row.dimensionValues[index] ?? row.dimensionValues[0]),
+					metricValues: metricHeaders.map((_header, index) => row.metricValues[index] ?? row.metricValues[0])
+				}))
+			} };
+		},
+		examplePayload: runReportExamplePayload
+	})
+};
+var rawRequest_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send raw HTTP request to Google Analytics GA4"
+	},
+	inputs: rawRequestInputs,
+	performSafety: "notAllowed",
+	perform: async (context, { connection, baseUrl, ...restInputs }) => {
+		const { data } = await (0, _prismatic_io_spectral_http.sendRawRequest)(baseUrl, {
+			...restInputs,
+			debugRequest: context.debug.enabled
+		}, { Authorization: `Bearer ${connection.token?.access_token}` });
+		return { data };
+	}
+}) };
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...accounts_default$1,
+	...properties_default$1,
+	...rawRequest_default,
+	...measurementEvents_default
+};
+var connections_default = [(0, _prismatic_io_spectral.oauth2Connection)({
+	oauth2Type: _prismatic_io_spectral.OAuth2Type.AuthorizationCode,
+	key: "oauth2",
+	display: {
+		label: "OAuth 2.0",
+		description: "OAuth 2.0 connection for Google Analytics GA4",
+		icons: { oauth2ConnectionIconPath: "oauth-button.png" }
+	},
+	inputs: {
+		authorizeUrl: {
+			label: "Authorize URL",
+			placeholder: "Authorize URL",
+			type: "string",
+			required: true,
+			shown: false,
+			comments: "The OAuth 2.0 Authorization URL for Google Calendar",
+			default: "https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&prompt=consent"
+		},
+		tokenUrl: {
+			label: "Token URL",
+			placeholder: "Token URL",
+			type: "string",
+			required: true,
+			shown: false,
+			comments: "The OAuth 2.0 Token URL for Google Analytics",
+			default: "https://oauth2.googleapis.com/token"
+		},
+		scopes: {
+			label: "Scopes",
+			placeholder: "Scopes",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "A space-delimited set of one or more scopes to get the user's permission to access.",
+			default: "https://www.googleapis.com/auth/analytics https://www.googleapis.com/auth/analytics.manage.users https://www.googleapis.com/auth/analytics.edit https://www.googleapis.com/auth/analytics.readonly"
+		},
+		clientId: {
+			label: "Client ID",
+			placeholder: "Client ID",
+			type: "string",
+			required: true,
+			comments: "Provide a string value for the client Id of your OAuth 2.0 application.",
+			shown: true
+		},
+		clientSecret: {
+			label: "Client Secret",
+			placeholder: "Client Secret",
+			type: "password",
+			comments: "Provide a string value for the client secret of your OAuth 2.0 application.",
+			required: true,
+			shown: true
+		}
+	}
+})];
+var accounts_default = { listAccounts: (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "List Accounts",
+		description: "Return a list of accounts accessible by the caller."
+	},
+	dataSourceType: "picklist",
+	inputs: { connection: connectionInput },
+	perform: async (_context, params) => {
+		return { result: ((await paginateRecords(createAnalyticsClient({
+			connection: params.connection,
+			endpointType: "adminv1beta"
+		}), "/accounts", {}, true, "accounts")).accounts || []).map((account) => ({
+			key: account.name,
+			label: account.displayName
+		})) };
+	},
+	examplePayload: listAccountsDataSourceExamplePayload
+}) };
+var properties_default = { listProperties: (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "List Properties",
+		description: "List Google Analytics GA4 properties for an account."
+	},
+	inputs: {
+		connection: connectionInput,
+		accountId: {
+			...accountId,
+			dataSource: void 0
+		}
+	},
+	dataSourceType: "picklist",
+	perform: async (_context, params) => {
+		return { result: (await paginateRecords(createAnalyticsClient({
+			connection: params.connection,
+			endpointType: "adminv1beta"
+		}), "/properties", { filter: `parent:${params.accountId}` }, true, "properties")).properties.map((property) => ({
+			key: property.name,
+			label: `${property.displayName} - ${property.name}`
+		})) };
+	}
+}) };
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	...accounts_default,
+	...properties_default
+};
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = { pollChangesTrigger: (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New and Updated Records",
+		description: "Retrieves existing and ongoing records in Google Analytics GA4. Load history once, check for changes on a schedule, or both."
+	},
+	inputs: pollChangesInputs,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: { resolveItems: (_context, { payload }) => resolvePollingRecordChanges(payload.body.data) },
+	perform: async (context, payload, params) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const state = context.polling.getState();
+		const isBackfill = !state?.lastPolledAt && Boolean(params.lookBackDate);
+		const lastPolledAt = state?.lastPolledAt ?? (params.lookBackDate || now);
+		const client = createAnalyticsClient({
+			connection: params.connection,
+			endpointType: "adminv1beta",
+			debug: context.debug.enabled
+		});
+		let allRecords;
+		if (params.pollResourceType === POLL_RESOURCE_KEYS.ACCOUNTS) allRecords = (await paginateRecords(client, "/accounts", { pageSize: 200 }, true, "accounts")).accounts;
+		else if (params.pollResourceType === POLL_RESOURCE_KEYS.PROPERTIES) {
+			if (!params.accountId) throw new Error("Account ID is required when polling Properties. Select an account in the trigger configuration.");
+			allRecords = (await paginateRecords(client, "/properties", {
+				pageSize: 200,
+				filter: `parent:${params.accountId}`
+			}, true, "properties")).properties;
+		} else throw new Error(`Unsupported resource type: ${params.pollResourceType}`);
+		const { created, updated } = filterByTimestamp(allRecords, lastPolledAt, isBackfill, params.showNewRecords, params.showUpdatedRecords);
+		const totalMatched = created.length + updated.length;
+		if (context.debug.enabled) context.logger.debug(`Polled ${allRecords.length} ${params.pollResourceType} records, ${created.length} created, ${updated.length} updated since last poll.`);
+		context.polling.setState({ lastPolledAt: now });
+		return {
+			payload: {
+				...payload,
+				body: { data: {
+					created,
+					updated
+				} }
+			},
+			polledNoChanges: totalMatched === 0
+		};
+	},
+	examplePayload: pollChangesTriggerExamplePayload
+}) };
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "google-analytics-ga4",
+	documentationUrl: "https://prismatic.io/docs/components/google-analytics-ga4/",
+	public: true,
+	display: {
+		label: "Google Analytics - GA4",
+		category: "Application Connectors",
+		description: "Manage Google Analytics GA4 accounts and data",
+		iconPath: "icon.png"
+	},
+	actions: actions_default,
+	triggers: triggers_default,
+	dataSources: dataSources_default,
+	connections: connections_default,
+	hooks: { error: _prismatic_io_spectral_http.handleErrors }
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;