@useairfoil/producer-shopify 0.0.1 → 0.2.0

package/dist/src-DqmiLrYS.js

@@ -0,0 +1,984 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { n as manifest, t as ShopifyConfigDef } from "./manifest-BFfx2LkS.js";
+import { Auth, Connector, ConnectorError, Cursor, Fetch, Metrics, Resource, Telemetry, Webhook } from "@useairfoil/connector-kit";
+import { Clock, Config, Context, Data, Duration, Effect, Layer, Option, Random, Redacted, Schedule, Schema, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse, HttpServerResponse } from "effect/unstable/http";
+import * as Schema$1 from "effect/Schema";
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+//#region src/auth.ts
+var ShopifyAuthError = class extends Data.TaggedError("ShopifyAuthError") {};
+var ShopifyAuth = class extends Context.Service()("@useairfoil/producer-shopify/ShopifyAuth") {};
+const TokenResponseSchema = Schema.Struct({
+	access_token: Schema.String,
+	expires_in: Schema.Number
+});
+const ErrorResponseSchema = Schema.Struct({ error: Schema.optional(Schema.String) });
+const normalizedShopDomain = (shopDomain) => shopDomain.replace(/^https?:\/\//i, "").replace(/\/+$/g, "");
+const errorFor = (reason) => {
+	switch (reason) {
+		case "shop_not_permitted": return new ShopifyAuthError({
+			reason,
+			message: "The Shopify app and store must belong to the same Shopify organization"
+		});
+		case "invalid_client": return new ShopifyAuthError({
+			reason,
+			message: "The Shopify client ID or client secret is invalid"
+		});
+		case "exchange_failed": return new ShopifyAuthError({
+			reason,
+			message: "Shopify authentication failed"
+		});
+	}
+};
+const decodeRejectedResponse = (response) => HttpClientResponse.schemaBodyJson(ErrorResponseSchema)(response).pipe(Effect.map((body) => {
+	switch (body.error) {
+		case "shop_not_permitted": return "shop_not_permitted";
+		case "invalid_client": return "invalid_client";
+		default: return "exchange_failed";
+	}
+}), Effect.catch(() => Effect.succeed("exchange_failed")));
+const make$2 = Effect.fnUntraced(function* (config) {
+	const client = yield* HttpClient.HttpClient;
+	const endpoint = `https://${normalizedShopDomain(config.shopDomain)}/admin/oauth/access_token`;
+	return yield* Auth.makeTokenCache({ acquire: Effect.scoped(Effect.gen(function* () {
+		const request = HttpClientRequest.post(endpoint).pipe(HttpClientRequest.bodyUrlParams({
+			grant_type: "client_credentials",
+			client_id: config.clientId,
+			client_secret: Redacted.value(config.clientSecret)
+		}));
+		const response = yield* client.execute(request).pipe(Effect.mapError(() => errorFor("exchange_failed")));
+		const successfulResponse = yield* HttpClientResponse.filterStatusOk(response).pipe(Effect.catchTag("HttpClientError", () => decodeRejectedResponse(response).pipe(Effect.flatMap((reason) => Effect.fail(errorFor(reason))))));
+		const body = yield* HttpClientResponse.schemaBodyJson(TokenResponseSchema)(successfulResponse).pipe(Effect.mapError(() => errorFor("exchange_failed")));
+		return {
+			value: Redacted.make(body.access_token),
+			expiresIn: Duration.seconds(body.expires_in)
+		};
+	})) });
+});
+const layer$2 = (config) => Layer.effect(ShopifyAuth)(make$2(config));
+
+//#endregion
+//#region src/schemas.ts
+const PageInfoSchema = Schema$1.Struct({
+	hasNextPage: Schema$1.Boolean,
+	endCursor: Schema$1.NullOr(Schema$1.String)
+});
+const ProductStatusSchema = Schema$1.Literals([
+	"ACTIVE",
+	"ARCHIVED",
+	"DRAFT",
+	"UNLISTED"
+]);
+const RestProductStatusSchema = Schema$1.Literals([
+	"active",
+	"archived",
+	"draft"
+]);
+const ProductVariantInventoryPolicySchema = Schema$1.Literals(["CONTINUE", "DENY"]);
+const RestProductVariantInventoryPolicySchema = Schema$1.Literals(["continue", "deny"]);
+const ProductFeaturedMediaSchema = Schema$1.Any;
+const ProductOptionSchema = Schema$1.Struct({
+	id: Schema$1.String,
+	name: Schema$1.String,
+	position: Schema$1.Number,
+	values: Schema$1.Array(Schema$1.String)
+});
+const ProductVariantSchema = Schema$1.Struct({
+	id: Schema$1.String,
+	legacyResourceId: Schema$1.String,
+	title: Schema$1.String,
+	sku: Schema$1.NullOr(Schema$1.String),
+	barcode: Schema$1.NullOr(Schema$1.String),
+	price: Schema$1.String,
+	compareAtPrice: Schema$1.NullOr(Schema$1.String),
+	inventoryPolicy: ProductVariantInventoryPolicySchema,
+	taxable: Schema$1.Boolean,
+	createdAt: Schema$1.String,
+	updatedAt: Schema$1.String
+});
+const ProductWebhookImageSchema = Schema$1.Struct({
+	src: Schema$1.String,
+	alt: Schema$1.NullOr(Schema$1.String)
+});
+const ProductWebhookOptionSchema = Schema$1.Struct({
+	id: Schema$1.Number,
+	name: Schema$1.String,
+	position: Schema$1.Number,
+	values: Schema$1.Array(Schema$1.String)
+});
+const ProductWebhookVariantSchema = Schema$1.Struct({
+	admin_graphql_api_id: Schema$1.String,
+	id: Schema$1.Number,
+	title: Schema$1.String,
+	price: Schema$1.Union([Schema$1.String, Schema$1.Number]),
+	inventory_policy: RestProductVariantInventoryPolicySchema,
+	compare_at_price: Schema$1.NullOr(Schema$1.Union([Schema$1.String, Schema$1.Number])),
+	created_at: Schema$1.String,
+	updated_at: Schema$1.String,
+	taxable: Schema$1.Boolean,
+	barcode: Schema$1.NullOr(Schema$1.String),
+	sku: Schema$1.NullOr(Schema$1.String)
+});
+const ProductWebhookVariantGidSchema = Schema$1.Struct({
+	admin_graphql_api_id: Schema$1.String,
+	updated_at: Schema$1.String
+});
+const ProductSchema = Schema$1.Struct({
+	id: Schema$1.String,
+	legacyResourceId: Schema$1.String,
+	title: Schema$1.String,
+	handle: Schema$1.String,
+	descriptionHtml: Schema$1.String,
+	productType: Schema$1.String,
+	vendor: Schema$1.String,
+	status: ProductStatusSchema,
+	tags: Schema$1.Array(Schema$1.String),
+	createdAt: Schema$1.String,
+	updatedAt: Schema$1.String,
+	publishedAt: Schema$1.NullOr(Schema$1.String),
+	templateSuffix: Schema$1.NullOr(Schema$1.String),
+	featuredMedia: Schema$1.NullOr(ProductFeaturedMediaSchema),
+	options: Schema$1.Array(ProductOptionSchema),
+	variants: Schema$1.Array(ProductVariantSchema)
+});
+const ProductWebhookPayloadSchema = Schema$1.Struct({
+	id: Schema$1.Number,
+	admin_graphql_api_id: Schema$1.String,
+	body_html: Schema$1.NullOr(Schema$1.String),
+	created_at: Schema$1.NullOr(Schema$1.String),
+	handle: Schema$1.String,
+	image: Schema$1.optional(Schema$1.NullOr(ProductWebhookImageSchema)),
+	images: Schema$1.optional(Schema$1.Array(Schema$1.Any)),
+	options: Schema$1.Array(ProductWebhookOptionSchema),
+	product_type: Schema$1.String,
+	published_at: Schema$1.NullOr(Schema$1.String),
+	published_scope: Schema$1.optional(Schema$1.String),
+	status: RestProductStatusSchema,
+	tags: Schema$1.String,
+	template_suffix: Schema$1.NullOr(Schema$1.String),
+	title: Schema$1.String,
+	updated_at: Schema$1.String,
+	variants: Schema$1.Array(ProductWebhookVariantSchema),
+	variant_gids: Schema$1.Array(ProductWebhookVariantGidSchema),
+	vendor: Schema$1.String
+});
+const ProductDeleteWebhookPayloadSchema = Schema$1.Struct({ id: Schema$1.Number });
+const ProductEventSchema = Schema$1.Union([Schema$1.Struct({
+	_tag: Schema$1.Literal("upsert"),
+	payload: ProductWebhookPayloadSchema
+}), Schema$1.Struct({
+	_tag: Schema$1.Literal("delete"),
+	id: Schema$1.String,
+	version: Schema$1.String
+})]);
+const MoneySchema = Schema$1.Struct({
+	amount: Schema$1.String,
+	currency_code: Schema$1.String
+});
+const MoneyBagSchema = Schema$1.Struct({
+	shop_money: MoneySchema,
+	presentment_money: MoneySchema
+});
+const CartLineItemSchema = Schema$1.Struct({
+	id: Schema$1.Union([Schema$1.String, Schema$1.Number]),
+	properties: Schema$1.NullOr(Schema$1.Unknown),
+	quantity: Schema$1.Number,
+	variant_id: Schema$1.Union([Schema$1.String, Schema$1.Number]),
+	key: Schema$1.String,
+	discounted_price: Schema$1.String,
+	discounts: Schema$1.Array(Schema$1.Unknown),
+	gift_card: Schema$1.Boolean,
+	grams: Schema$1.Number,
+	line_price: Schema$1.String,
+	original_line_price: Schema$1.String,
+	original_price: Schema$1.String,
+	price: Schema$1.String,
+	product_id: Schema$1.Union([Schema$1.String, Schema$1.Number]),
+	sku: Schema$1.NullOr(Schema$1.String),
+	taxable: Schema$1.Boolean,
+	title: Schema$1.String,
+	total_discount: Schema$1.String,
+	vendor: Schema$1.String,
+	discounted_price_set: MoneyBagSchema,
+	line_price_set: MoneyBagSchema,
+	original_line_price_set: MoneyBagSchema,
+	price_set: MoneyBagSchema,
+	total_discount_set: MoneyBagSchema,
+	parent_relationship: Schema$1.NullOr(Schema$1.Unknown)
+});
+const CartWebhookPayloadSchema = Schema$1.Struct({
+	id: Schema$1.String,
+	token: Schema$1.String,
+	line_items: Schema$1.Array(CartLineItemSchema),
+	note: Schema$1.NullOr(Schema$1.String),
+	updated_at: Schema$1.String,
+	created_at: Schema$1.String
+});
+const CartEventSchema = Schema$1.Struct({
+	id: Schema$1.String,
+	token: Schema$1.String,
+	topic: Schema$1.Literals(["carts/create", "carts/update"]),
+	lineItems: Schema$1.Array(CartLineItemSchema),
+	note: Schema$1.NullOr(Schema$1.String),
+	updatedAt: Schema$1.String,
+	createdAt: Schema$1.String
+});
+const WebhookPayloadSchema = Schema$1.Unknown;
+const splitTags = (value) => {
+	if (value.trim() === "") return [];
+	return value.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+};
+const normalizeProductStatus = (status) => {
+	switch (status) {
+		case "active": return "ACTIVE";
+		case "archived": return "ARCHIVED";
+		case "draft": return "DRAFT";
+	}
+};
+const normalizeInventoryPolicy = (policy) => {
+	switch (policy) {
+		case "continue": return "CONTINUE";
+		case "deny": return "DENY";
+	}
+};
+const normalizeProductOption = (restOption) => {
+	return {
+		id: `gid://shopify/ProductOption/${restOption.id}`,
+		name: restOption.name,
+		position: restOption.position,
+		values: restOption.values
+	};
+};
+const normalizeProductVariant = (restVariant) => {
+	return {
+		id: restVariant.admin_graphql_api_id,
+		legacyResourceId: String(restVariant.id),
+		title: restVariant.title,
+		sku: restVariant.sku,
+		barcode: restVariant.barcode,
+		price: String(restVariant.price),
+		compareAtPrice: restVariant.compare_at_price === null ? null : String(restVariant.compare_at_price),
+		inventoryPolicy: normalizeInventoryPolicy(restVariant.inventory_policy),
+		taxable: restVariant.taxable,
+		createdAt: restVariant.created_at,
+		updatedAt: restVariant.updated_at
+	};
+};
+const normalizeProductFeaturedMedia = (image) => {
+	if (image === null || image === void 0) return null;
+	return { image: {
+		url: image.src,
+		altText: image.alt
+	} };
+};
+const ShopifyNormalize = {
+	productWebhook: (payload) => ({
+		id: payload.admin_graphql_api_id,
+		legacyResourceId: String(payload.id),
+		title: payload.title,
+		handle: payload.handle,
+		descriptionHtml: payload.body_html ?? "",
+		productType: payload.product_type,
+		vendor: payload.vendor,
+		status: normalizeProductStatus(payload.status),
+		tags: splitTags(payload.tags),
+		createdAt: payload.created_at,
+		updatedAt: payload.updated_at,
+		publishedAt: payload.published_at,
+		templateSuffix: payload.template_suffix,
+		featuredMedia: normalizeProductFeaturedMedia(payload.image),
+		options: payload.options.map(normalizeProductOption),
+		variants: payload.variants.map(normalizeProductVariant)
+	}),
+	cartWebhook: (payload, topic) => ({
+		id: payload.id,
+		token: payload.token,
+		topic,
+		lineItems: payload.line_items,
+		note: payload.note,
+		updatedAt: payload.updated_at,
+		createdAt: payload.created_at
+	})
+};
+
+//#endregion
+//#region src/throttle.ts
+const ThrottleStatusSchema = Schema.Struct({
+	maximumAvailable: Schema.Number,
+	currentlyAvailable: Schema.Number,
+	restoreRate: Schema.Number
+});
+const GraphQLErrorSchema = Schema.Struct({ extensions: Schema.optional(Schema.Struct({ code: Schema.optional(Schema.String) })) });
+const GraphQLEnvelopeSchema = Schema.Struct({
+	errors: Schema.optional(Schema.Array(GraphQLErrorSchema)),
+	extensions: Schema.optional(Schema.Struct({ cost: Schema.optional(Schema.Struct({
+		requestedQueryCost: Schema.optional(Schema.Number),
+		throttleStatus: Schema.optional(ThrottleStatusSchema)
+	})) }))
+});
+const decodeEnvelope = Schema.decodeUnknownOption(GraphQLEnvelopeSchema);
+const readThrottleCost = (body) => decodeEnvelope(body).pipe(Option.flatMap((envelope) => {
+	const cost = envelope.extensions?.cost;
+	const status = cost?.throttleStatus;
+	const requestedQueryCost = cost?.requestedQueryCost;
+	return status === void 0 || requestedQueryCost === void 0 ? Option.none() : Option.some({
+		requestedQueryCost,
+		status
+	});
+}), Option.getOrUndefined);
+const retryableCodes = new Set(["THROTTLED", "INTERNAL_SERVER_ERROR"]);
+/** Retries only when every GraphQL error is transient. */
+const retryableErrorCode = (body) => decodeEnvelope(body).pipe(Option.flatMap((envelope) => {
+	const codes = envelope.errors?.map((error) => error.extensions?.code) ?? [];
+	if (!(codes.length > 0 && codes.every((code) => code !== void 0 && retryableCodes.has(code)))) return Option.none();
+	return Option.some(codes.includes("THROTTLED") ? "THROTTLED" : "INTERNAL_SERVER_ERROR");
+}), Option.getOrUndefined);
+const backoff$1 = (baseDelay, attempt) => Random.nextBetween(.8, 1.2).pipe(Effect.map((jitter) => Duration.times(baseDelay, 2 ** attempt * jitter)));
+/** Uses Shopify's cost deficit for throttling and backoff for internal errors. */
+const retryDelay = (code, body, attempt, options) => {
+	if (code === "INTERNAL_SERVER_ERROR") return backoff$1(options.baseDelay, attempt);
+	const cost = readThrottleCost(body);
+	if (cost === void 0 || cost.status.restoreRate <= 0) return backoff$1(options.baseDelay, attempt);
+	const deficitMillis = Math.max(0, cost.requestedQueryCost - cost.status.currentlyAvailable) / cost.status.restoreRate * 1e3;
+	return Effect.succeed(Duration.max(Duration.millis(Math.ceil(deficitMillis)), options.baseDelay));
+};
+
+//#endregion
+//#region src/transient-retry.ts
+const parseRetryAfter = (header, atMillis) => {
+	if (header === void 0 || header.trim() === "") return void 0;
+	const seconds = Number(header);
+	if (Number.isFinite(seconds)) return Duration.seconds(Math.max(seconds, 0));
+	const parsedDate = Date.parse(header);
+	return Number.isNaN(parsedDate) ? void 0 : Duration.millis(Math.max(parsedDate - atMillis, 0));
+};
+const otherTransientStatuses = new Set([
+	408,
+	500,
+	502,
+	503,
+	504
+]);
+const backoff = (baseDelay, attempt) => Random.nextBetween(.8, 1.2).pipe(Effect.map((jitter) => Duration.times(baseDelay, 2 ** attempt * jitter)));
+const delayFor = (response, attempt, options) => {
+	if (response.status !== 429) return backoff(options.baseDelay, attempt);
+	return Clock.currentTimeMillis.pipe(Effect.map((now) => parseRetryAfter(response.headers["retry-after"], now) ?? options.retryAfterFallback));
+};
+const retryReason = (status) => status === 429 ? "rate_limit" : status === 408 ? "timeout" : "server_error";
+/** Retries transient responses and honors Shopify's `Retry-After` header on 429. */
+const withTransientRetry = (client, options) => {
+	const loop = (effect, remaining, attempt) => Effect.flatMap(effect, (response) => {
+		if (!(response.status === 429 || otherTransientStatuses.has(response.status)) || remaining <= 0) return Effect.succeed(response);
+		return delayFor(response, attempt, options).pipe(Effect.tap(() => Metrics.recordApiRetry({
+			connector: manifest.name,
+			reason: retryReason(response.status)
+		})), Effect.flatMap(Effect.sleep), Effect.flatMap(() => loop(effect, remaining - 1, attempt + 1)));
+	});
+	return HttpClient.transform(client, (effect) => loop(effect, options.maxRetries, 0));
+};
+
+//#endregion
+//#region src/api.ts
+var api_exports = /* @__PURE__ */ __export({
+	ShopifyApiClient: () => ShopifyApiClient,
+	layer: () => layer$1,
+	layerConfig: () => layerConfig$1,
+	make: () => make$1
+});
+var ShopifyApiClient = class extends Context.Service()("@useairfoil/producer-shopify/ShopifyApiClient") {};
+const ProductsQuery = `#graphql
+query AirfoilProducts($first: Int!, $after: String) {
+  products(first: $first, after: $after, sortKey: UPDATED_AT, reverse: true) {
+    nodes {
+      id
+      legacyResourceId
+      title
+      handle
+      descriptionHtml
+      productType
+      vendor
+      status
+      tags
+      createdAt
+      updatedAt
+      publishedAt
+      templateSuffix
+      featuredMedia {
+        ... on MediaImage {
+          image {
+            url
+            altText
+          }
+        }
+      }
+      options(first: 100) {
+        id
+        name
+        position
+        values
+      }
+      variants(first: 25) {
+        nodes {
+          id
+          legacyResourceId
+          title
+          sku
+          barcode
+          price
+          compareAtPrice
+          inventoryPolicy
+          taxable
+          createdAt
+          updatedAt
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+`;
+const ProductByIdQuery = `#graphql
+query AirfoilProductById($id: ID!) {
+  product(id: $id) {
+    id
+    legacyResourceId
+    title
+    handle
+    descriptionHtml
+    productType
+    vendor
+    status
+    tags
+    createdAt
+    updatedAt
+    publishedAt
+    templateSuffix
+    featuredMedia {
+      ... on MediaImage {
+        image {
+          url
+          altText
+        }
+      }
+    }
+    options(first: 100) {
+      id
+      name
+      position
+      values
+    }
+    variants(first: 25) {
+      nodes {
+        id
+        legacyResourceId
+        title
+        sku
+        barcode
+        price
+        compareAtPrice
+        inventoryPolicy
+        taxable
+        createdAt
+        updatedAt
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+}
+`;
+const ProductVariantsQuery = `#graphql
+query AirfoilProductVariants($id: ID!, $first: Int!, $after: String) {
+  product(id: $id) {
+    variants(first: $first, after: $after) {
+      nodes {
+        id
+        legacyResourceId
+        title
+        sku
+        barcode
+        price
+        compareAtPrice
+        inventoryPolicy
+        taxable
+        createdAt
+        updatedAt
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+}
+`;
+const ProductsAccessQuery = `#graphql
+query AirfoilProductsAccess {
+  products(first: 1) {
+    nodes {
+      id
+    }
+  }
+}
+`;
+const ShopIdentityQuery = `#graphql
+query AirfoilShopIdentity {
+  shop {
+    id
+  }
+}
+`;
+const ShopIdentitySchema = Schema.Struct({ shop: Schema.Struct({ id: Schema.String }) });
+const ProductsAccessSchema = Schema.Struct({ products: Schema.Struct({ nodes: Schema.Array(Schema.Struct({ id: Schema.String })) }) });
+const LegacyResourceIdSchema = Schema.Union([Schema.String, Schema.Number]);
+const GraphQLProductVariantNodeSchema = Schema.Struct({
+	id: Schema.String,
+	legacyResourceId: LegacyResourceIdSchema,
+	title: Schema.String,
+	sku: Schema.NullOr(Schema.String),
+	barcode: Schema.NullOr(Schema.String),
+	price: Schema.String,
+	compareAtPrice: Schema.NullOr(Schema.String),
+	inventoryPolicy: ProductVariantInventoryPolicySchema,
+	taxable: Schema.Boolean,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const GraphQLProductNodeSchema = Schema.Struct({
+	id: Schema.String,
+	legacyResourceId: LegacyResourceIdSchema,
+	title: Schema.String,
+	handle: Schema.String,
+	descriptionHtml: Schema.String,
+	productType: Schema.String,
+	vendor: Schema.String,
+	status: ProductStatusSchema,
+	tags: Schema.Array(Schema.String),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	publishedAt: Schema.NullOr(Schema.String),
+	templateSuffix: Schema.NullOr(Schema.String),
+	featuredMedia: Schema.NullOr(Schema.Any),
+	options: Schema.Array(ProductOptionSchema),
+	variants: Schema.Struct({
+		nodes: Schema.Array(GraphQLProductVariantNodeSchema),
+		pageInfo: PageInfoSchema
+	})
+});
+const GraphQLProductsDataSchema = Schema.Struct({ products: Schema.Struct({
+	nodes: Schema.Array(GraphQLProductNodeSchema),
+	pageInfo: PageInfoSchema
+}) });
+const GraphQLProductByIdDataSchema = Schema.Struct({ product: Schema.NullOr(GraphQLProductNodeSchema) });
+const GraphQLProductVariantsDataSchema = Schema.Struct({ product: Schema.NullOr(Schema.Struct({ variants: Schema.Struct({
+	nodes: Schema.Array(GraphQLProductVariantNodeSchema),
+	pageInfo: PageInfoSchema
+}) })) });
+const normalizeProductNode = (node, variants) => ({
+	id: node.id,
+	legacyResourceId: String(node.legacyResourceId),
+	title: node.title,
+	handle: node.handle,
+	descriptionHtml: node.descriptionHtml,
+	productType: node.productType,
+	vendor: node.vendor,
+	status: node.status,
+	tags: node.tags,
+	createdAt: node.createdAt,
+	updatedAt: node.updatedAt,
+	publishedAt: node.publishedAt,
+	templateSuffix: node.templateSuffix,
+	featuredMedia: node.featuredMedia,
+	options: node.options,
+	variants: variants.map((variant) => ({
+		...variant,
+		legacyResourceId: String(variant.legacyResourceId)
+	}))
+});
+const graphqlEndpoint = (config) => {
+	return `https://${config.shopDomain.replace(/^https?:\/\//i, "").replace(/\/+$/g, "")}/admin/api/${config.apiVersion}/graphql.json`;
+};
+const hasGraphqlErrors = (body) => {
+	if (typeof body !== "object" || body === null) return false;
+	const errors = body.errors;
+	return Array.isArray(errors) && errors.length > 0;
+};
+const summarizeBody = (body) => {
+	try {
+		return JSON.stringify(body);
+	} catch {
+		return String(body);
+	}
+};
+const make$1 = Effect.fnUntraced(function* (config) {
+	const auth = yield* ShopifyAuth;
+	const retryBaseDelay = Duration.millis(config.retryBaseDelayMs);
+	const graphqlRetryBaseDelay = Duration.millis(config.graphqlRetryBaseDelayMs);
+	const requestTimeout = Duration.seconds(config.requestTimeoutSeconds);
+	const transportRetrySchedule = Schedule.exponential(retryBaseDelay).pipe(Schedule.jittered, Schedule.upTo({ times: config.transportMaxRetries }), Schedule.tap(() => Metrics.recordApiRetry({
+		connector: manifest.name,
+		reason: "transport"
+	})));
+	const client = (yield* HttpClient.HttpClient).pipe(HttpClient.mapRequestEffect((request) => auth.get.pipe(Effect.map((token) => HttpClientRequest.setHeader(request, "X-Shopify-Access-Token", Redacted.value(token))))), HttpClient.mapRequest(HttpClientRequest.acceptJson), (c) => withTransientRetry(c, {
+		maxRetries: config.responseMaxRetries,
+		baseDelay: retryBaseDelay,
+		retryAfterFallback: Duration.seconds(config.retryAfterFallbackSeconds)
+	}), HttpClient.retryTransient({
+		retryOn: "errors-only",
+		schedule: transportRetrySchedule
+	}));
+	const endpoint = graphqlEndpoint(config);
+	const fetchGraphQL = (options) => {
+		const attempt = (remainingRetries) => Effect.gen(function* () {
+			const request = yield* HttpClientRequest.post(endpoint).pipe(HttpClientRequest.bodyJson({
+				query: options.query,
+				variables: options.variables ?? {}
+			}), Effect.mapError((cause) => new ConnectorError({
+				message: "Failed to encode Shopify GraphQL request",
+				cause
+			})));
+			const { body, status } = yield* Effect.scoped(client.execute(request).pipe(Effect.tapError((error) => Telemetry.annotateError("api_http", error)), Effect.mapError((error) => {
+				if (error._tag === "ShopifyAuthError") return new ConnectorError({
+					message: error.message,
+					cause: error
+				});
+				return new ConnectorError({
+					message: "Shopify GraphQL request failed",
+					cause: error
+				});
+			}), Effect.flatMap((response) => response.json.pipe(Effect.tapError((error) => Telemetry.annotateError("api_json", error)), Effect.mapError((error) => new ConnectorError({
+				message: "Shopify GraphQL returned invalid JSON",
+				cause: error
+			})), Effect.map((body$1) => ({
+				body: body$1,
+				status: response.status
+			}))))));
+			if (status < 200 || status >= 300) {
+				const error = {
+					status,
+					body,
+					operationName: options.operationName
+				};
+				yield* Effect.logWarning("Shopify GraphQL returned non-2xx status").pipe(Effect.annotateLogs({
+					operationName: options.operationName,
+					status,
+					body: summarizeBody(body)
+				}));
+				yield* Telemetry.annotateError("api_status", error);
+				return yield* Effect.fail(new ConnectorError({
+					message: "Shopify GraphQL returned non-2xx status",
+					cause: error
+				}));
+			}
+			if (hasGraphqlErrors(body)) {
+				const retryableCode = retryableErrorCode(body);
+				if (retryableCode !== void 0 && remainingRetries > 0) {
+					const attemptIndex = config.graphqlMaxRetries - remainingRetries;
+					const wait = yield* retryDelay(retryableCode, body, attemptIndex, { baseDelay: graphqlRetryBaseDelay });
+					yield* Effect.logWarning("Shopify GraphQL request returned a retryable error, retrying").pipe(Effect.annotateLogs({
+						operationName: options.operationName,
+						code: retryableCode,
+						remainingRetries,
+						waitMillis: Duration.toMillis(wait)
+					}));
+					yield* Metrics.recordApiRetry({
+						connector: manifest.name,
+						reason: retryableCode === "THROTTLED" ? "rate_limit" : "server_error"
+					});
+					yield* Effect.sleep(wait);
+					return yield* attempt(remainingRetries - 1);
+				}
+				yield* Effect.logWarning("Shopify GraphQL returned errors").pipe(Effect.annotateLogs({
+					operationName: options.operationName,
+					body: summarizeBody(body)
+				}));
+				yield* Telemetry.annotateError("api_graphql", body);
+				return yield* Effect.fail(new ConnectorError({
+					message: "Shopify GraphQL returned errors",
+					cause: body
+				}));
+			}
+			const data = typeof body === "object" && body !== null ? body.data : void 0;
+			return yield* Schema.decodeUnknownEffect(options.schema)(data).pipe(Effect.tapError((error) => Telemetry.annotateError("api_decode", error)), Effect.mapError((error) => new ConnectorError({
+				message: "Shopify GraphQL response schema decode failed",
+				cause: error
+			})));
+		}).pipe(Effect.withSpan(Telemetry.SpanName.apiFetch, {
+			kind: "client",
+			attributes: { [Telemetry.Attr.apiPath]: `graphql:${options.operationName}` }
+		}));
+		return attempt(config.graphqlMaxRetries).pipe(Effect.timeout(requestTimeout), Effect.mapError((error) => error instanceof ConnectorError ? error : new ConnectorError({
+			message: "Shopify GraphQL request timed out",
+			cause: error
+		})));
+	};
+	const nextPageCursor = (pageInfo) => {
+		if (!pageInfo.hasNextPage) return Effect.succeed(Option.none());
+		if (pageInfo.endCursor === null) return Effect.fail(new ConnectorError({ message: "Shopify GraphQL pageInfo.endCursor is required when hasNextPage is true" }));
+		return Effect.succeed(Option.some(pageInfo.endCursor));
+	};
+	const fetchRemainingProductVariants = (productId, initialCursor) => Stream.paginate(initialCursor, (after) => fetchGraphQL({
+		operationName: "AirfoilProductVariants",
+		query: ProductVariantsQuery,
+		variables: {
+			id: productId,
+			first: 100,
+			after
+		},
+		schema: GraphQLProductVariantsDataSchema
+	}).pipe(Effect.flatMap((data) => {
+		if (data.product === null) return Effect.fail(new ConnectorError({ message: "Shopify product disappeared while fetching variants" }));
+		const variants = data.product.variants;
+		return nextPageCursor(variants.pageInfo).pipe(Effect.map((cursor) => [variants.nodes, cursor]));
+	}))).pipe(Stream.runCollect);
+	const loadProductVariants = (node) => nextPageCursor(node.variants.pageInfo).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.succeed(node.variants.nodes),
+		onSome: (cursor) => fetchRemainingProductVariants(node.id, cursor).pipe(Effect.map((remaining) => [...node.variants.nodes, ...remaining]))
+	})));
+	const fetchProducts = (options) => fetchGraphQL({
+		operationName: "AirfoilProducts",
+		query: ProductsQuery,
+		variables: {
+			first: options.first,
+			after: options.after ?? null
+		},
+		schema: GraphQLProductsDataSchema
+	}).pipe(Effect.flatMap((data) => nextPageCursor(data.products.pageInfo).pipe(Effect.andThen(Effect.forEach(data.products.nodes, (node) => loadProductVariants(node).pipe(Effect.map((variants) => normalizeProductNode(node, variants))))), Effect.map((items) => ({
+		items,
+		endCursor: data.products.pageInfo.endCursor,
+		hasMore: data.products.pageInfo.hasNextPage
+	})))));
+	const fetchProductById = (id) => fetchGraphQL({
+		operationName: "AirfoilProductById",
+		query: ProductByIdQuery,
+		variables: { id },
+		schema: GraphQLProductByIdDataSchema
+	}).pipe(Effect.flatMap((data) => {
+		const node = data.product;
+		if (node === null) return Effect.fail(new ConnectorError({ message: "Shopify product not found while refreshing from webhook" }));
+		return loadProductVariants(node).pipe(Effect.map((variants) => normalizeProductNode(node, variants)));
+	}));
+	return {
+		checkConnection: fetchGraphQL({
+			operationName: "AirfoilShopIdentity",
+			query: ShopIdentityQuery,
+			schema: ShopIdentitySchema
+		}).pipe(Effect.asVoid),
+		checkProductsAccess: fetchGraphQL({
+			operationName: "AirfoilProductsAccess",
+			query: ProductsAccessQuery,
+			schema: ProductsAccessSchema
+		}).pipe(Effect.asVoid),
+		fetchGraphQL,
+		fetchProducts,
+		fetchProductById
+	};
+});
+const layer$1 = (config) => Layer.effect(ShopifyApiClient)(make$1(config));
+const layerConfig$1 = (config) => Layer.effect(ShopifyApiClient)(Config.unwrap(config).pipe(Effect.flatMap(make$1)));
+
+//#endregion
+//#region src/connector.ts
+var connector_exports = /* @__PURE__ */ __export({
+	ShopifyConfigDef: () => ShopifyConfigDef,
+	ShopifyConnector: () => ShopifyConnector,
+	layer: () => layer,
+	layerConfig: () => layerConfig,
+	make: () => make,
+	manifest: () => manifest
+});
+const verifyWebhookSignature = (options) => Effect.try({
+	try: () => {
+		if (!options.signature) throw new Error("Missing x-shopify-hmac-sha256 header");
+		const digest = createHmac("sha256", options.secret).update(Buffer.from(options.rawBody)).digest();
+		const provided = Buffer.from(options.signature, "base64");
+		if (provided.length !== digest.length || !timingSafeEqual(digest, provided)) throw new Error("Invalid Shopify webhook signature");
+	},
+	catch: (cause) => new ConnectorError({
+		message: "Shopify webhook verification failed",
+		cause
+	})
+});
+const decodeWebhookPayload = (schema) => Schema.decodeUnknownEffect(schema);
+const make = Effect.fnUntraced(function* (config) {
+	const api = yield* ShopifyApiClient;
+	const Products = Resource.entity({
+		name: "products",
+		schema: ProductSchema,
+		key: "id",
+		version: "updatedAt",
+		check: api.checkProductsAccess,
+		backfill: Fetch.page({
+			pageCursor: Cursor.string(),
+			cutoff: Cursor.isoDateTime(),
+			fetch: ({ pageCursor, cutoff }) => api.fetchProducts({
+				first: 50,
+				after: typeof pageCursor === "string" ? pageCursor : void 0
+			}).pipe(Effect.map((page) => ({
+				mutations: page.items.filter((row) => Date.parse(row.updatedAt) <= Date.parse(String(cutoff))).map(Resource.upsert),
+				nextPageCursor: page.endCursor ?? void 0,
+				hasMore: page.hasMore
+			})))
+		}),
+		webhook: Resource.webhook({
+			schema: ProductEventSchema,
+			handler: ({ payload }) => {
+				if (payload._tag === "delete") return Effect.succeed([Resource.delete({
+					key: `gid://shopify/Product/${payload.id}`,
+					version: payload.version
+				})]);
+				const product = payload.payload;
+				if (product.created_at !== null && product.variants.length === product.variant_gids.length) return Effect.succeed([Resource.upsert(ShopifyNormalize.productWebhook({
+					...product,
+					created_at: product.created_at
+				}))]);
+				return api.fetchProductById(product.admin_graphql_api_id).pipe(Effect.map((row) => [Resource.upsert(row)]));
+			}
+		})
+	});
+	const CartEvents = Resource.entity({
+		name: "cart_events",
+		schema: CartEventSchema,
+		key: "id",
+		version: "updatedAt",
+		check: api.checkConnection,
+		webhook: Resource.webhook({
+			schema: Schema.Struct({
+				...CartWebhookPayloadSchema.fields,
+				topic: Schema.Literals(["carts/create", "carts/update"])
+			}),
+			handler: ({ payload }) => Effect.succeed([Resource.upsert(ShopifyNormalize.cartWebhook(payload, payload.topic))])
+		})
+	});
+	const webhookRoute = Webhook.route({
+		path: "/webhooks/shopify",
+		ackMode: "after-publish",
+		schema: Schema.Unknown,
+		handler: ({ request, rawBody, payload: json, to }) => Effect.gen(function* () {
+			const verificationError = yield* verifyWebhookSignature({
+				rawBody,
+				signature: request.headers["x-shopify-hmac-sha256"] ?? null,
+				secret: Redacted.value(config.webhookSecret)
+			}).pipe(Effect.match({
+				onFailure: (error) => error,
+				onSuccess: () => void 0
+			}));
+			if (verificationError) return HttpServerResponse.jsonUnsafe({
+				ok: false,
+				error: verificationError.message
+			}, { status: 401 });
+			const topic = request.headers["x-shopify-topic"] ?? "";
+			switch (topic) {
+				case "products/create":
+				case "products/update": {
+					const payload = yield* decodeWebhookPayload(ProductWebhookPayloadSchema)(json).pipe(Effect.mapError((cause) => new ConnectorError({
+						message: `Invalid Shopify webhook payload for ${topic}`,
+						cause
+					})), Effect.match({
+						onFailure: (error) => ({
+							_tag: "Error",
+							error
+						}),
+						onSuccess: (value) => ({
+							_tag: "Success",
+							value
+						})
+					}));
+					if (payload._tag === "Error") return HttpServerResponse.jsonUnsafe({
+						ok: false,
+						error: payload.error.message
+					}, { status: 400 });
+					yield* to(Products, {
+						_tag: "upsert",
+						payload: payload.value
+					});
+					break;
+				}
+				case "products/delete": {
+					const triggeredAt = request.headers["x-shopify-triggered-at"];
+					if (!triggeredAt) return HttpServerResponse.jsonUnsafe({
+						ok: false,
+						error: "Missing x-shopify-triggered-at header"
+					}, { status: 400 });
+					const payload = yield* decodeWebhookPayload(ProductDeleteWebhookPayloadSchema)(json).pipe(Effect.mapError((cause) => new ConnectorError({
+						message: "Invalid Shopify webhook payload for products/delete",
+						cause
+					})), Effect.match({
+						onFailure: (error) => ({
+							_tag: "Error",
+							error
+						}),
+						onSuccess: (value) => ({
+							_tag: "Success",
+							value
+						})
+					}));
+					if (payload._tag === "Error") return HttpServerResponse.jsonUnsafe({
+						ok: false,
+						error: payload.error.message
+					}, { status: 400 });
+					yield* to(Products, {
+						_tag: "delete",
+						id: String(payload.value.id),
+						version: triggeredAt
+					});
+					break;
+				}
+				case "carts/create":
+				case "carts/update": {
+					const payload = yield* decodeWebhookPayload(CartWebhookPayloadSchema)(json).pipe(Effect.mapError((cause) => new ConnectorError({
+						message: `Invalid Shopify webhook payload for ${topic}`,
+						cause
+					})), Effect.match({
+						onFailure: (error) => ({
+							_tag: "Error",
+							error
+						}),
+						onSuccess: (value) => ({
+							_tag: "Success",
+							value
+						})
+					}));
+					if (payload._tag === "Error") return HttpServerResponse.jsonUnsafe({
+						ok: false,
+						error: payload.error.message
+					}, { status: 400 });
+					yield* to(CartEvents, {
+						...payload.value,
+						topic
+					});
+					break;
+				}
+				default: yield* Effect.logWarning("Ignoring unknown Shopify webhook topic").pipe(Effect.annotateLogs({ topic }));
+			}
+			return HttpServerResponse.jsonUnsafe({ ok: true });
+		})
+	});
+	return Connector.define({
+		name: "producer-shopify",
+		title: "Shopify",
+		resources: [Products, CartEvents],
+		webhooks: [webhookRoute]
+	});
+});
+var ShopifyConnector = class extends Context.Service()("@useairfoil/producer-shopify/ShopifyConnector") {};
+const layer = (config) => {
+	const authLayer = layer$2(config);
+	const apiLayer = layer$1(config).pipe(Layer.provide(authLayer));
+	return Layer.effect(ShopifyConnector)(make(config).pipe(Effect.annotateLogs({ component: "producer-shopify" }))).pipe(Layer.provide(apiLayer));
+};
+const layerConfig = (config) => Layer.unwrap(Config.unwrap(config).pipe(Effect.map(layer)));
+
+//#endregion
+export { ProductWebhookPayloadSchema as _, CartEventSchema as a, MoneyBagSchema as c, ProductDeleteWebhookPayloadSchema as d, ProductOptionSchema as f, ProductVariantSchema as g, ProductVariantInventoryPolicySchema as h, api_exports as i, MoneySchema as l, ProductStatusSchema as m, connector_exports as n, CartLineItemSchema as o, ProductSchema as p, layerConfig as r, CartWebhookPayloadSchema as s, ShopifyConnector as t, PageInfoSchema as u, ShopifyNormalize as v, WebhookPayloadSchema as y };
+//# sourceMappingURL=src-DqmiLrYS.js.map