@useairfoil/producer-shopify 0.2.0 → 0.2.1

package/src/schemas.ts

@@ -1,319 +0,0 @@
-import * as Schema from "effect/Schema";
-
-export const PageInfoSchema = Schema.Struct({
-  hasNextPage: Schema.Boolean,
-  endCursor: Schema.NullOr(Schema.String),
-});
-
-export const ProductStatusSchema = Schema.Literals(["ACTIVE", "ARCHIVED", "DRAFT", "UNLISTED"]);
-
-export const RestProductStatusSchema = Schema.Literals(["active", "archived", "draft"]);
-
-export const ProductVariantInventoryPolicySchema = Schema.Literals(["CONTINUE", "DENY"]);
-
-export const RestProductVariantInventoryPolicySchema = Schema.Literals(["continue", "deny"]);
-
-export const ProductFeaturedMediaSchema = Schema.Any;
-
-export const ProductOptionSchema = Schema.Struct({
-  id: Schema.String,
-  name: Schema.String,
-  position: Schema.Number,
-  values: Schema.Array(Schema.String),
-});
-
-export const ProductVariantSchema = Schema.Struct({
-  id: Schema.String,
-  legacyResourceId: Schema.String,
-  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,
-});
-
-export const ProductWebhookImageSchema = Schema.Struct({
-  src: Schema.String,
-  alt: Schema.NullOr(Schema.String),
-});
-
-export const ProductWebhookOptionSchema = Schema.Struct({
-  id: Schema.Number,
-  name: Schema.String,
-  position: Schema.Number,
-  values: Schema.Array(Schema.String),
-});
-
-export const ProductWebhookVariantSchema = Schema.Struct({
-  admin_graphql_api_id: Schema.String,
-  id: Schema.Number,
-  title: Schema.String,
-  price: Schema.Union([Schema.String, Schema.Number]),
-  inventory_policy: RestProductVariantInventoryPolicySchema,
-  compare_at_price: Schema.NullOr(Schema.Union([Schema.String, Schema.Number])),
-  created_at: Schema.String,
-  updated_at: Schema.String,
-  taxable: Schema.Boolean,
-  barcode: Schema.NullOr(Schema.String),
-  sku: Schema.NullOr(Schema.String),
-});
-
-export const ProductWebhookVariantGidSchema = Schema.Struct({
-  admin_graphql_api_id: Schema.String,
-  updated_at: Schema.String,
-});
-
-export const ProductSchema = Schema.Struct({
-  id: Schema.String,
-  legacyResourceId: Schema.String,
-  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(ProductFeaturedMediaSchema),
-  options: Schema.Array(ProductOptionSchema),
-  variants: Schema.Array(ProductVariantSchema),
-});
-
-export const ProductWebhookPayloadSchema = Schema.Struct({
-  id: Schema.Number,
-  admin_graphql_api_id: Schema.String,
-  body_html: Schema.NullOr(Schema.String),
-  created_at: Schema.NullOr(Schema.String),
-  handle: Schema.String,
-  image: Schema.optional(Schema.NullOr(ProductWebhookImageSchema)),
-  images: Schema.optional(Schema.Array(Schema.Any)),
-  options: Schema.Array(ProductWebhookOptionSchema),
-  product_type: Schema.String,
-  published_at: Schema.NullOr(Schema.String),
-  published_scope: Schema.optional(Schema.String),
-  status: RestProductStatusSchema,
-  tags: Schema.String,
-  template_suffix: Schema.NullOr(Schema.String),
-  title: Schema.String,
-  updated_at: Schema.String,
-  variants: Schema.Array(ProductWebhookVariantSchema),
-  variant_gids: Schema.Array(ProductWebhookVariantGidSchema),
-  vendor: Schema.String,
-});
-
-export const ProductDeleteWebhookPayloadSchema = Schema.Struct({
-  id: Schema.Number,
-});
-
-export const ProductEventSchema = Schema.Union([
-  Schema.Struct({
-    _tag: Schema.Literal("upsert"),
-    payload: ProductWebhookPayloadSchema,
-  }),
-  Schema.Struct({
-    _tag: Schema.Literal("delete"),
-    id: Schema.String,
-    version: Schema.String,
-  }),
-]);
-
-export const MoneySchema = Schema.Struct({
-  amount: Schema.String,
-  currency_code: Schema.String,
-});
-
-export const MoneyBagSchema = Schema.Struct({
-  shop_money: MoneySchema,
-  presentment_money: MoneySchema,
-});
-
-export const CartLineItemSchema = Schema.Struct({
-  id: Schema.Union([Schema.String, Schema.Number]),
-  properties: Schema.NullOr(Schema.Unknown),
-  quantity: Schema.Number,
-  variant_id: Schema.Union([Schema.String, Schema.Number]),
-  key: Schema.String,
-  discounted_price: Schema.String,
-  discounts: Schema.Array(Schema.Unknown),
-  gift_card: Schema.Boolean,
-  grams: Schema.Number,
-  line_price: Schema.String,
-  original_line_price: Schema.String,
-  original_price: Schema.String,
-  price: Schema.String,
-  product_id: Schema.Union([Schema.String, Schema.Number]),
-  sku: Schema.NullOr(Schema.String),
-  taxable: Schema.Boolean,
-  title: Schema.String,
-  total_discount: Schema.String,
-  vendor: Schema.String,
-  discounted_price_set: MoneyBagSchema,
-  line_price_set: MoneyBagSchema,
-  original_line_price_set: MoneyBagSchema,
-  price_set: MoneyBagSchema,
-  total_discount_set: MoneyBagSchema,
-  parent_relationship: Schema.NullOr(Schema.Unknown),
-});
-
-export const CartWebhookPayloadSchema = Schema.Struct({
-  id: Schema.String,
-  token: Schema.String,
-  line_items: Schema.Array(CartLineItemSchema),
-  note: Schema.NullOr(Schema.String),
-  updated_at: Schema.String,
-  created_at: Schema.String,
-});
-
-export const CartEventSchema = Schema.Struct({
-  id: Schema.String,
-  token: Schema.String,
-  topic: Schema.Literals(["carts/create", "carts/update"]),
-  lineItems: Schema.Array(CartLineItemSchema),
-  note: Schema.NullOr(Schema.String),
-  updatedAt: Schema.String,
-  createdAt: Schema.String,
-});
-
-export const WebhookPayloadSchema = Schema.Unknown;
-
-const splitTags = (value: string): ReadonlyArray<string> => {
-  if (value.trim() === "") {
-    return [];
-  }
-  return value
-    .split(",")
-    .map((tag) => tag.trim())
-    .filter((tag) => tag.length > 0);
-};
-
-const normalizeProductStatus = (status: RestProductStatus): ProductStatus => {
-  switch (status) {
-    case "active":
-      return "ACTIVE";
-    case "archived":
-      return "ARCHIVED";
-    case "draft":
-      return "DRAFT";
-  }
-};
-
-const normalizeInventoryPolicy = (
-  policy: RestProductVariantInventoryPolicy,
-): ProductVariantInventoryPolicy => {
-  switch (policy) {
-    case "continue":
-      return "CONTINUE";
-    case "deny":
-      return "DENY";
-  }
-};
-
-const normalizeProductOption = (restOption: ProductWebhookOption): ProductOption => {
-  return {
-    id: `gid://shopify/ProductOption/${restOption.id}`,
-    name: restOption.name,
-    position: restOption.position,
-    values: restOption.values,
-  };
-};
-
-const normalizeProductVariant = (restVariant: ProductWebhookVariant): ProductVariant => {
-  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: ProductWebhookImage | null | undefined,
-): ProductFeaturedMedia | null => {
-  if (image === null || image === undefined) {
-    return null;
-  }
-
-  return {
-    image: {
-      url: image.src,
-      altText: image.alt,
-    },
-  };
-};
-
-export const ShopifyNormalize = {
-  productWebhook: (payload: ProductWebhookPayload & { readonly created_at: string }): Product => ({
-    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: CartWebhookPayload,
-    topic: "carts/create" | "carts/update",
-  ): CartEvent => ({
-    id: payload.id,
-    token: payload.token,
-    topic,
-    lineItems: payload.line_items,
-    note: payload.note,
-    updatedAt: payload.updated_at,
-    createdAt: payload.created_at,
-  }),
-} as const;
-
-export type PageInfo = Schema.Schema.Type<typeof PageInfoSchema>;
-export type ProductStatus = Schema.Schema.Type<typeof ProductStatusSchema>;
-export type RestProductStatus = Schema.Schema.Type<typeof RestProductStatusSchema>;
-export type ProductVariantInventoryPolicy = Schema.Schema.Type<
-  typeof ProductVariantInventoryPolicySchema
->;
-export type RestProductVariantInventoryPolicy = Schema.Schema.Type<
-  typeof RestProductVariantInventoryPolicySchema
->;
-export type ProductFeaturedMedia = Schema.Schema.Type<typeof ProductFeaturedMediaSchema>;
-export type ProductOption = Schema.Schema.Type<typeof ProductOptionSchema>;
-export type ProductVariant = Schema.Schema.Type<typeof ProductVariantSchema>;
-export type ProductWebhookImage = Schema.Schema.Type<typeof ProductWebhookImageSchema>;
-export type ProductWebhookOption = Schema.Schema.Type<typeof ProductWebhookOptionSchema>;
-export type ProductWebhookVariant = Schema.Schema.Type<typeof ProductWebhookVariantSchema>;
-export type ProductWebhookVariantGid = Schema.Schema.Type<typeof ProductWebhookVariantGidSchema>;
-export type Product = Schema.Schema.Type<typeof ProductSchema>;
-export type ProductWebhookPayload = Schema.Schema.Type<typeof ProductWebhookPayloadSchema>;
-export type ProductDeleteWebhookPayload = Schema.Schema.Type<
-  typeof ProductDeleteWebhookPayloadSchema
->;
-export type Money = Schema.Schema.Type<typeof MoneySchema>;
-export type MoneyBag = Schema.Schema.Type<typeof MoneyBagSchema>;
-export type CartLineItem = Schema.Schema.Type<typeof CartLineItemSchema>;
-export type CartWebhookPayload = Schema.Schema.Type<typeof CartWebhookPayloadSchema>;
-export type CartEvent = Schema.Schema.Type<typeof CartEventSchema>;
-export type WebhookPayload = Schema.Schema.Type<typeof WebhookPayloadSchema>;

package/src/throttle.ts

@@ -1,89 +0,0 @@
-// Shopify reports GraphQL throttling in HTTP 200 responses.
-// https://shopify.dev/docs/api/usage/limits
-import { Duration, Effect, Option, Random, Schema } from "effect";
-
-const ThrottleStatusSchema = Schema.Struct({
-  maximumAvailable: Schema.Number,
-  currentlyAvailable: Schema.Number,
-  restoreRate: Schema.Number,
-});
-
-export type ThrottleStatus = Schema.Schema.Type<typeof ThrottleStatusSchema>;
-
-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: unknown,
-): { readonly requestedQueryCost: number; readonly status: ThrottleStatus } | undefined =>
-  decodeEnvelope(body).pipe(
-    Option.flatMap((envelope) => {
-      const cost = envelope.extensions?.cost;
-      const status = cost?.throttleStatus;
-      const requestedQueryCost = cost?.requestedQueryCost;
-      return status === undefined || requestedQueryCost === undefined
-        ? Option.none()
-        : Option.some({ requestedQueryCost, status });
-    }),
-    Option.getOrUndefined,
-  );
-
-const retryableCodes = new Set(["THROTTLED", "INTERNAL_SERVER_ERROR"]);
-
-export type RetryableErrorCode = "THROTTLED" | "INTERNAL_SERVER_ERROR";
-
-/** Retries only when every GraphQL error is transient. */
-export const retryableErrorCode = (body: unknown): RetryableErrorCode | undefined =>
-  decodeEnvelope(body).pipe(
-    Option.flatMap((envelope) => {
-      const codes = envelope.errors?.map((error) => error.extensions?.code) ?? [];
-      const allRetryable =
-        codes.length > 0 && codes.every((code) => code !== undefined && retryableCodes.has(code));
-      if (!allRetryable) return Option.none<RetryableErrorCode>();
-      return Option.some<RetryableErrorCode>(
-        codes.includes("THROTTLED") ? "THROTTLED" : "INTERNAL_SERVER_ERROR",
-      );
-    }),
-    Option.getOrUndefined,
-  );
-
-const backoff = (baseDelay: Duration.Duration, attempt: number): Effect.Effect<Duration.Duration> =>
-  Random.nextBetween(0.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. */
-export const retryDelay = (
-  code: RetryableErrorCode,
-  body: unknown,
-  attempt: number,
-  options: { readonly baseDelay: Duration.Duration },
-): Effect.Effect<Duration.Duration> => {
-  if (code === "INTERNAL_SERVER_ERROR") return backoff(options.baseDelay, attempt);
-  const cost = readThrottleCost(body);
-  if (cost === undefined || cost.status.restoreRate <= 0) {
-    return backoff(options.baseDelay, attempt);
-  }
-  const deficitMillis =
-    (Math.max(0, cost.requestedQueryCost - cost.status.currentlyAvailable) /
-      cost.status.restoreRate) *
-    1000;
-  return Effect.succeed(Duration.max(Duration.millis(Math.ceil(deficitMillis)), options.baseDelay));
-};

package/src/transient-retry.ts

@@ -1,74 +0,0 @@
-import { Metrics } from "@useairfoil/connector-kit";
-import { Clock, Duration, Effect, Random } from "effect";
-import { HttpClient, HttpClientResponse } from "effect/unstable/http";
-
-import { manifest } from "./manifest";
-
-const parseRetryAfter = (
-  header: string | undefined,
-  atMillis: number,
-): Duration.Duration | undefined => {
-  if (header === undefined || header.trim() === "") return undefined;
-  const seconds = Number(header);
-  if (Number.isFinite(seconds)) return Duration.seconds(Math.max(seconds, 0));
-  const parsedDate = Date.parse(header);
-  return Number.isNaN(parsedDate) ? undefined : Duration.millis(Math.max(parsedDate - atMillis, 0));
-};
-
-const otherTransientStatuses = new Set([408, 500, 502, 503, 504]);
-
-const backoff = (baseDelay: Duration.Duration, attempt: number): Effect.Effect<Duration.Duration> =>
-  Random.nextBetween(0.8, 1.2).pipe(
-    Effect.map((jitter) => Duration.times(baseDelay, 2 ** attempt * jitter)),
-  );
-
-const delayFor = (
-  response: HttpClientResponse.HttpClientResponse,
-  attempt: number,
-  options: {
-    readonly baseDelay: Duration.Duration;
-    readonly retryAfterFallback: Duration.Duration;
-  },
-): Effect.Effect<Duration.Duration> => {
-  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: number): Metrics.ApiRetryReason =>
-  status === 429 ? "rate_limit" : status === 408 ? "timeout" : "server_error";
-
-/** Retries transient responses and honors Shopify's `Retry-After` header on 429. */
-export const withTransientRetry = <E, R>(
-  client: HttpClient.HttpClient.With<E, R>,
-  options: {
-    readonly maxRetries: number;
-    readonly baseDelay: Duration.Duration;
-    readonly retryAfterFallback: Duration.Duration;
-  },
-): HttpClient.HttpClient.With<E, R> => {
-  const loop = (
-    effect: Effect.Effect<HttpClientResponse.HttpClientResponse, E, R>,
-    remaining: number,
-    attempt: number,
-  ): Effect.Effect<HttpClientResponse.HttpClientResponse, E, R> =>
-    Effect.flatMap(effect, (response) => {
-      const isRetryable = response.status === 429 || otherTransientStatuses.has(response.status);
-      if (!isRetryable || 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));
-};