@useairfoil/producer-shopify 0.2.0 → 0.2.2

package/dist/src-DqmiLrYS.js

@@ -1,984 +0,0 @@
-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