@useairfoil/producer-shopify 0.2.0 → 0.2.2

package/src/resources/products/row.ts

@@ -0,0 +1,122 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import * as Schema from "effect/Schema";
+
+export const ProductStatusSchema = Schema.Literals(["ACTIVE", "ARCHIVED", "DRAFT", "UNLISTED"]);
+
+export const ProductVariantInventoryPolicySchema = Schema.Literals(["CONTINUE", "DENY"]);
+
+const ProductImageSchema = Schema.Struct({
+  url: Schema.String.pipe(Schema.annotateKey({ description: "URL of the image." })),
+  altText: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Alternative text for the image." }),
+  ),
+});
+
+export const ProductFeaturedMediaSchema = Schema.Struct({
+  image: Schema.NullOr(ProductImageSchema).pipe(
+    Schema.annotateKey({ description: "Image for the featured media." }),
+  ),
+});
+
+export const ProductOptionSchema = Schema.Struct({
+  id: Schema.String.pipe(Schema.annotateKey({ description: "Unique product option identifier." })),
+  name: Schema.String.pipe(Schema.annotateKey({ description: "Name of the product option." })),
+  position: Schema.Int.pipe(
+    Schema.annotateKey({ description: "Position of the option on the product." }),
+  ),
+  values: Schema.Array(Schema.String).pipe(
+    Schema.annotateKey({ description: "Values available for the option." }),
+  ),
+});
+
+export const ProductVariantSchema = Schema.Struct({
+  id: Schema.String.pipe(Schema.annotateKey({ description: "Unique product variant identifier." })),
+  legacyResourceId: Schema.String.pipe(
+    Schema.annotateKey({ description: "Numeric variant identifier stored as text." }),
+  ),
+  title: Schema.String.pipe(Schema.annotateKey({ description: "Display title of the variant." })),
+  sku: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Stock keeping unit for the variant." }),
+  ),
+  barcode: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Barcode for the variant." }),
+  ),
+  price: Schema.String.pipe(Schema.annotateKey({ description: "Price of the variant." })),
+  compareAtPrice: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Original price used for comparison." }),
+  ),
+  inventoryPolicy: ProductVariantInventoryPolicySchema.pipe(
+    Schema.annotateKey({ description: "Behavior when the variant is out of stock." }),
+  ),
+  taxable: Schema.Boolean.pipe(
+    Schema.annotateKey({ description: "Whether the variant is taxable." }),
+  ),
+  createdAt: Schema.Date.pipe(
+    Schema.annotateKey({ description: "Time when the variant was created." }),
+  ),
+  updatedAt: Schema.Date.pipe(
+    Schema.annotateKey({ description: "Time when the variant was last changed." }),
+  ),
+});
+
+export const ProductSchema = Schema.Struct({
+  id: Schema.String.pipe(Schema.annotateKey({ description: "Unique product identifier." })),
+  legacyResourceId: Schema.String.pipe(
+    Schema.annotateKey({ description: "Numeric product identifier stored as text." }),
+  ),
+  title: Schema.String.pipe(Schema.annotateKey({ description: "Title of the product." })),
+  handle: Schema.String.pipe(Schema.annotateKey({ description: "URL handle for the product." })),
+  descriptionHtml: Schema.String.pipe(
+    Schema.annotateKey({ description: "Product description as HTML." }),
+  ),
+  productType: Schema.String.pipe(
+    Schema.annotateKey({ description: "Merchant-defined product type." }),
+  ),
+  vendor: Schema.String.pipe(Schema.annotateKey({ description: "Vendor of the product." })),
+  status: ProductStatusSchema.pipe(Schema.annotateKey({ description: "Current product status." })),
+  tags: Schema.Array(Schema.String).pipe(
+    Schema.annotateKey({ description: "Tags added to the product." }),
+  ),
+  createdAt: Schema.Date.pipe(
+    Schema.annotateKey({ description: "Time when the product was created." }),
+  ),
+  updatedAt: Schema.Date.pipe(
+    Schema.annotateKey({ description: "Time when the product was last changed." }),
+  ),
+  publishedAt: Schema.NullOr(Schema.Date).pipe(
+    Schema.annotateKey({ description: "Time when the product was published." }),
+  ),
+  templateSuffix: Schema.NullOr(Schema.String).pipe(
+    Schema.annotateKey({ description: "Theme template suffix used by the product." }),
+  ),
+  featuredMedia: Schema.NullOr(ProductFeaturedMediaSchema).pipe(
+    Schema.annotateKey({ description: "Featured media for the product." }),
+  ),
+  options: Schema.Array(ProductOptionSchema).pipe(
+    Schema.annotateKey({ description: "Options for the product." }),
+  ),
+  variants: Schema.Array(ProductVariantSchema).pipe(
+    Schema.annotateKey({ description: "Variants of the product." }),
+  ),
+  _deleted: Schema.optional(Schema.Boolean).pipe(
+    Schema.annotateKey({ description: "Whether the product was deleted." }),
+  ),
+})
+  .annotate({
+    description: "Products in a Shopify store.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type ProductStatus = Schema.Schema.Type<typeof ProductStatusSchema>;
+
+export type ProductVariantInventoryPolicy = Schema.Schema.Type<
+  typeof ProductVariantInventoryPolicySchema
+>;
+
+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 Product = Schema.Schema.Type<typeof ProductSchema>;

package/src/resources/products/webhook.ts

@@ -0,0 +1,130 @@
+import * as Schema from "effect/Schema";
+
+import { gid, splitTags, upper } from "../shared";
+import {
+  type Product,
+  type ProductFeaturedMedia,
+  type ProductOption,
+  ProductStatusSchema,
+  type ProductVariant,
+  ProductVariantInventoryPolicySchema,
+} from "./row";
+
+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.Int,
+  values: Schema.Array(Schema.String),
+});
+
+export const ProductWebhookVariantSchema = Schema.Struct({
+  admin_graphql_api_id: Schema.String,
+  id: Schema.Number,
+  title: Schema.String,
+  price: Schema.String,
+  inventory_policy: upper(ProductVariantInventoryPolicySchema),
+  compare_at_price: Schema.NullOr(Schema.String),
+  created_at: Schema.DateFromString,
+  updated_at: Schema.DateFromString,
+  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.DateFromString,
+});
+
+export const ProductWebhookPayloadSchema = Schema.Struct({
+  id: Schema.Number,
+  admin_graphql_api_id: Schema.String,
+  body_html: Schema.NullOr(Schema.String),
+  created_at: Schema.DateFromString,
+  handle: Schema.String,
+  image: Schema.optional(Schema.NullOr(ProductWebhookImageSchema)),
+  options: Schema.Array(ProductWebhookOptionSchema),
+  product_type: Schema.String,
+  published_at: Schema.NullOr(Schema.DateFromString),
+  status: upper(ProductStatusSchema),
+  tags: Schema.String,
+  template_suffix: Schema.NullOr(Schema.String),
+  title: Schema.String,
+  updated_at: Schema.DateFromString,
+  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: Schema.toType(ProductWebhookPayloadSchema),
+    triggeredAt: Schema.Date,
+  }),
+  Schema.Struct({
+    _tag: Schema.Literal("delete"),
+    id: Schema.String,
+    version: Schema.Date,
+  }),
+]);
+
+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 ProductWebhookPayload = Schema.Schema.Type<typeof ProductWebhookPayloadSchema>;
+
+const normalizeProductOption = (option: ProductWebhookOption): ProductOption => ({
+  id: gid("ProductOption", option.id),
+  name: option.name,
+  position: option.position,
+  values: option.values,
+});
+
+const normalizeProductVariant = (variant: ProductWebhookVariant): ProductVariant => ({
+  id: variant.admin_graphql_api_id,
+  legacyResourceId: String(variant.id),
+  title: variant.title,
+  sku: variant.sku,
+  barcode: variant.barcode,
+  price: variant.price,
+  compareAtPrice: variant.compare_at_price,
+  inventoryPolicy: variant.inventory_policy,
+  taxable: variant.taxable,
+  createdAt: variant.created_at,
+  updatedAt: variant.updated_at,
+});
+
+const normalizeProductFeaturedMedia = (
+  image: ProductWebhookImage | null | undefined,
+): ProductFeaturedMedia | null =>
+  image === null || image === undefined ? null : { image: { url: image.src, altText: image.alt } };
+
+export const fromProductWebhook = (payload: ProductWebhookPayload): 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: 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),
+});

package/src/resources/refunds/graphql.ts

@@ -0,0 +1,196 @@
+import * as Schema from "effect/Schema";
+
+import {
+  GraphQLMoneyBagSchema,
+  MoneyBagFields,
+  type Nodes,
+  PageInfoFields,
+  connection,
+  fromGraphQL,
+  idRef,
+  normalizeAmount,
+  pageQuery,
+} from "../shared";
+import {
+  type Refund,
+  RestockTypeSchema,
+  TransactionKindSchema,
+  TransactionStatusSchema,
+} from "./row";
+
+const TransactionFields = `id kind status gateway test errorCode parentTransaction { id } createdAt processedAt amountSet { ${MoneyBagFields} }`;
+
+const RefundLineItemFields = `id lineItem { id } quantity restockType location { id } subtotalSet { ${MoneyBagFields} } totalTaxSet { ${MoneyBagFields} }`;
+
+const RefundShippingLineFields = `id shippingLine { id } subtotalAmountSet { ${MoneyBagFields} }`;
+
+const OrderAdjustmentFields = `id reason amountSet { ${MoneyBagFields} } taxAmountSet { ${MoneyBagFields} }`;
+
+export const RefundFields = `
+  id
+  legacyResourceId
+  note
+  createdAt
+  processedAt
+  duties { originalDuty { id } amountSet { ${MoneyBagFields} } }
+  transactions(first: 10) { nodes { ${TransactionFields} } ${PageInfoFields} }
+  refundLineItems(first: 50) { nodes { ${RefundLineItemFields} } ${PageInfoFields} }
+  refundShippingLines(first: 10) { nodes { ${RefundShippingLineFields} } ${PageInfoFields} }
+  orderAdjustments(first: 10) { nodes { ${OrderAdjustmentFields} } ${PageInfoFields} }
+`;
+
+const refundConnectionQuery = (name: string, selection: string) => `#graphql
+query ${name}($id: ID!, $first: Int!, $after: String) {
+  node: refund(id: $id) {
+    connection: ${selection}
+  }
+}
+`;
+
+export const RefundTransactionsQuery = refundConnectionQuery(
+  "AirfoilRefundTransactions",
+  `transactions(first: $first, after: $after) { nodes { ${TransactionFields} } ${PageInfoFields} }`,
+);
+
+export const RefundLineItemsQuery = refundConnectionQuery(
+  "AirfoilRefundLineItems",
+  `refundLineItems(first: $first, after: $after) { nodes { ${RefundLineItemFields} } ${PageInfoFields} }`,
+);
+
+export const RefundShippingLinesQuery = refundConnectionQuery(
+  "AirfoilRefundShippingLines",
+  `refundShippingLines(first: $first, after: $after) { nodes { ${RefundShippingLineFields} } ${PageInfoFields} }`,
+);
+
+export const RefundOrderAdjustmentsQuery = refundConnectionQuery(
+  "AirfoilRefundOrderAdjustments",
+  `orderAdjustments(first: $first, after: $after) { nodes { ${OrderAdjustmentFields} } ${PageInfoFields} }`,
+);
+
+export const GraphQLRefundTransactionsSchema = connection(
+  Schema.Struct({
+    id: Schema.String,
+    kind: TransactionKindSchema,
+    status: TransactionStatusSchema,
+    gateway: Schema.NullOr(Schema.String),
+    test: Schema.Boolean,
+    errorCode: Schema.NullOr(Schema.String),
+    parentTransaction: idRef,
+    createdAt: Schema.DateFromString,
+    processedAt: Schema.NullOr(Schema.DateFromString),
+    amountSet: GraphQLMoneyBagSchema,
+  }),
+);
+
+export const GraphQLRefundLineItemsSchema = connection(
+  Schema.Struct({
+    id: Schema.NullOr(Schema.String),
+    lineItem: Schema.Struct({ id: Schema.String }),
+    quantity: Schema.Int,
+    restockType: RestockTypeSchema,
+    location: idRef,
+    subtotalSet: GraphQLMoneyBagSchema,
+    totalTaxSet: GraphQLMoneyBagSchema,
+  }),
+);
+
+export const GraphQLRefundShippingLinesSchema = connection(
+  Schema.Struct({
+    id: Schema.String,
+    shippingLine: idRef,
+    subtotalAmountSet: GraphQLMoneyBagSchema,
+  }),
+);
+
+export const GraphQLOrderAdjustmentsSchema = connection(
+  Schema.Struct({
+    id: Schema.String,
+    reason: Schema.NullOr(Schema.String),
+    amountSet: GraphQLMoneyBagSchema,
+    taxAmountSet: GraphQLMoneyBagSchema,
+  }),
+);
+
+export const GraphQLRefundNodeSchema = Schema.Struct({
+  id: Schema.String,
+  legacyResourceId: Schema.String,
+  note: Schema.NullOr(Schema.String),
+  createdAt: Schema.NullOr(Schema.DateFromString),
+  processedAt: Schema.DateFromString,
+  duties: Schema.NullOr(
+    Schema.Array(Schema.Struct({ originalDuty: idRef, amountSet: GraphQLMoneyBagSchema })),
+  ),
+  transactions: GraphQLRefundTransactionsSchema,
+  refundLineItems: GraphQLRefundLineItemsSchema,
+  refundShippingLines: GraphQLRefundShippingLinesSchema,
+  orderAdjustments: GraphQLOrderAdjustmentsSchema,
+});
+
+export type GraphQLRefundNode = Schema.Schema.Type<typeof GraphQLRefundNodeSchema>;
+
+export const fromRefundNode = (
+  orderId: string,
+  node: GraphQLRefundNode,
+  nested: {
+    readonly transactions: Nodes<typeof GraphQLRefundTransactionsSchema>;
+    readonly refundLineItems: Nodes<typeof GraphQLRefundLineItemsSchema>;
+    readonly refundShippingLines: Nodes<typeof GraphQLRefundShippingLinesSchema>;
+    readonly orderAdjustments: Nodes<typeof GraphQLOrderAdjustmentsSchema>;
+  },
+): Refund => ({
+  id: node.id,
+  legacyResourceId: node.legacyResourceId,
+  orderId,
+  note: node.note ?? "",
+  createdAt: node.createdAt,
+  processedAt: node.processedAt,
+  transactions: nested.transactions.map((transaction) => ({
+    id: transaction.id,
+    kind: transaction.kind,
+    status: transaction.status,
+    amount: normalizeAmount(transaction.amountSet.presentmentMoney.amount),
+    currencyCode: transaction.amountSet.presentmentMoney.currencyCode,
+    gateway: transaction.gateway,
+    test: transaction.test,
+    errorCode: transaction.errorCode,
+    parentTransactionId: transaction.parentTransaction?.id ?? null,
+    createdAt: transaction.createdAt,
+    processedAt: transaction.processedAt,
+  })),
+  refundLineItems: nested.refundLineItems.map((item) => ({
+    id: item.id,
+    lineItemId: item.lineItem.id,
+    quantity: item.quantity,
+    restockType: item.restockType,
+    locationId: item.location?.id ?? null,
+    subtotalSet: fromGraphQL.money(item.subtotalSet),
+    totalTaxSet: fromGraphQL.money(item.totalTaxSet),
+  })),
+  refundShippingLines: nested.refundShippingLines.map((line) => ({
+    id: line.id,
+    shippingLineId: line.shippingLine?.id ?? null,
+    subtotalAmountSet: fromGraphQL.money(line.subtotalAmountSet),
+  })),
+  orderAdjustments: nested.orderAdjustments.map((adjustment) => ({
+    id: adjustment.id,
+    reason: adjustment.reason,
+    amountSet: fromGraphQL.money(adjustment.amountSet),
+    taxAmountSet: fromGraphQL.money(adjustment.taxAmountSet),
+  })),
+  duties: (node.duties ?? []).map((duty) => ({
+    dutyId: duty.originalDuty?.id ?? null,
+    amountSet: fromGraphQL.money(duty.amountSet),
+  })),
+});
+
+export const OrderRefundsQuery = pageQuery(
+  "AirfoilOrderRefunds",
+  "orders",
+  `id refunds { ${RefundFields} }`,
+);
+
+export const GraphQLOrderRefundsDataSchema = Schema.Struct({
+  orders: connection(
+    Schema.Struct({ id: Schema.String, refunds: Schema.Array(GraphQLRefundNodeSchema) }),
+  ),
+});

package/src/resources/refunds/row.ts

@@ -0,0 +1,137 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import * as Schema from "effect/Schema";
+
+import { moneyBag } from "../shared";
+
+export const TransactionKindSchema = Schema.Literals([
+  "SALE",
+  "CAPTURE",
+  "AUTHORIZATION",
+  "VOID",
+  "REFUND",
+  "CHANGE",
+  "EMV_AUTHORIZATION",
+  "SUGGESTED_REFUND",
+]);
+
+export const TransactionStatusSchema = Schema.Literals([
+  "SUCCESS",
+  "FAILURE",
+  "PENDING",
+  "ERROR",
+  "AWAITING_RESPONSE",
+  "UNKNOWN",
+]);
+
+export const RestockTypeSchema = Schema.Literals([
+  "RETURN",
+  "CANCEL",
+  "LEGACY_RESTOCK",
+  "NO_RESTOCK",
+]);
+
+export const RefundSchema = Schema.Struct({
+  id: Schema.String.pipe(Schema.annotateKey({ description: "Unique refund identifier." })),
+  legacyResourceId: Schema.String.pipe(
+    Schema.annotateKey({ description: "Numeric refund identifier stored as text." }),
+  ),
+  orderId: Schema.String.pipe(Schema.annotateKey({ description: "Refunded order identifier." })),
+  note: Schema.NullOr(Schema.String).pipe(Schema.annotateKey({ description: "Refund note." })),
+  createdAt: Schema.NullOr(Schema.Date).pipe(
+    Schema.annotateKey({ description: "Time when the refund was created." }),
+  ),
+  processedAt: Schema.Date.pipe(
+    Schema.annotateKey({ description: "Time when the refund was processed." }),
+  ),
+  transactions: Schema.Array(
+    Schema.Struct({
+      id: Schema.String.pipe(Schema.annotateKey({ description: "Unique transaction identifier." })),
+      kind: TransactionKindSchema.pipe(Schema.annotateKey({ description: "Kind of transaction." })),
+      status: TransactionStatusSchema.pipe(
+        Schema.annotateKey({ description: "Status reported for the transaction." }),
+      ),
+      amount: Schema.String.pipe(
+        Schema.annotateKey({ description: "Amount in the customer currency." }),
+      ),
+      currencyCode: Schema.String.pipe(
+        Schema.annotateKey({ description: "Customer currency code." }),
+      ),
+      gateway: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Payment gateway." }),
+      ),
+      test: Schema.Boolean.pipe(
+        Schema.annotateKey({ description: "Whether the transaction is a test." }),
+      ),
+      errorCode: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Gateway error code." }),
+      ),
+      parentTransactionId: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Transaction this one refunds." }),
+      ),
+      createdAt: Schema.Date.pipe(
+        Schema.annotateKey({ description: "Time when the transaction was created." }),
+      ),
+      processedAt: Schema.NullOr(Schema.Date).pipe(
+        Schema.annotateKey({ description: "Time when the transaction was processed." }),
+      ),
+    }),
+  ).pipe(Schema.annotateKey({ description: "Transactions that move the refunded money." })),
+  refundLineItems: Schema.Array(
+    Schema.Struct({
+      id: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Unique refund line item identifier." }),
+      ),
+      lineItemId: Schema.String.pipe(
+        Schema.annotateKey({ description: "Refunded order line item identifier." }),
+      ),
+      quantity: Schema.Int.pipe(Schema.annotateKey({ description: "Quantity refunded." })),
+      restockType: RestockTypeSchema.pipe(
+        Schema.annotateKey({ description: "How the items were restocked." }),
+      ),
+      locationId: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Restock location identifier." }),
+      ),
+      subtotalSet: moneyBag.pipe(Schema.annotateKey({ description: "Refunded subtotal." })),
+      totalTaxSet: moneyBag.pipe(Schema.annotateKey({ description: "Refunded tax." })),
+    }),
+  ).pipe(Schema.annotateKey({ description: "Refunded order line items." })),
+  refundShippingLines: Schema.Array(
+    Schema.Struct({
+      id: Schema.String.pipe(
+        Schema.annotateKey({ description: "Unique refund shipping line identifier." }),
+      ),
+      shippingLineId: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Refunded shipping line." }),
+      ),
+      subtotalAmountSet: moneyBag.pipe(
+        Schema.annotateKey({ description: "Refunded shipping amount." }),
+      ),
+    }),
+  ).pipe(Schema.annotateKey({ description: "Refunded shipping." })),
+  orderAdjustments: Schema.Array(
+    Schema.Struct({
+      id: Schema.String.pipe(
+        Schema.annotateKey({ description: "Unique order adjustment identifier." }),
+      ),
+      reason: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Reason for the adjustment." }),
+      ),
+      amountSet: moneyBag.pipe(Schema.annotateKey({ description: "Adjustment amount." })),
+      taxAmountSet: moneyBag.pipe(Schema.annotateKey({ description: "Tax on the adjustment." })),
+    }),
+  ).pipe(Schema.annotateKey({ description: "Refund discrepancy adjustments." })),
+  duties: Schema.Array(
+    Schema.Struct({
+      dutyId: Schema.NullOr(Schema.String).pipe(
+        Schema.annotateKey({ description: "Refunded duty identifier." }),
+      ),
+      amountSet: moneyBag.pipe(Schema.annotateKey({ description: "Refunded duty amount." })),
+    }),
+  ).pipe(Schema.annotateKey({ description: "Refunded duties." })),
+})
+  .annotate({
+    description: "Refunds on orders in a Shopify store.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type Refund = Schema.Schema.Type<typeof RefundSchema>;