@useairfoil/producer-shopify 0.2.0 → 0.2.1

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,97 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import * as Schema from "effect/Schema";
+
+import { field, 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(field(1, "Unique refund identifier.")),
+  legacyResourceId: Schema.String.pipe(field(2, "Numeric refund identifier stored as text.")),
+  orderId: Schema.String.pipe(field(3, "Refunded order identifier.")),
+  note: Schema.NullOr(Schema.String).pipe(field(4, "Refund note.")),
+  createdAt: Schema.NullOr(Schema.Date).pipe(field(5, "Time when the refund was created.")),
+  processedAt: Schema.Date.pipe(field(6, "Time when the refund was processed.")),
+  transactions: Schema.Array(
+    Schema.Struct({
+      id: Schema.String.pipe(field(101, "Unique transaction identifier.")),
+      kind: TransactionKindSchema.pipe(field(102, "Kind of transaction.")),
+      status: TransactionStatusSchema.pipe(field(103, "Status reported for the transaction.")),
+      amount: Schema.String.pipe(field(104, "Amount in the customer currency.")),
+      currencyCode: Schema.String.pipe(field(105, "Customer currency code.")),
+      gateway: Schema.NullOr(Schema.String).pipe(field(106, "Payment gateway.")),
+      test: Schema.Boolean.pipe(field(107, "Whether the transaction is a test.")),
+      errorCode: Schema.NullOr(Schema.String).pipe(field(108, "Gateway error code.")),
+      parentTransactionId: Schema.NullOr(Schema.String).pipe(
+        field(109, "Transaction this one refunds."),
+      ),
+      createdAt: Schema.Date.pipe(field(110, "Time when the transaction was created.")),
+      processedAt: Schema.NullOr(Schema.Date).pipe(
+        field(111, "Time when the transaction was processed."),
+      ),
+    }).annotate({ fieldId: 100 }),
+  ).pipe(field(7, "Transactions that move the refunded money.")),
+  refundLineItems: Schema.Array(
+    Schema.Struct({
+      id: Schema.NullOr(Schema.String).pipe(field(201, "Unique refund line item identifier.")),
+      lineItemId: Schema.String.pipe(field(202, "Refunded order line item identifier.")),
+      quantity: Schema.Int.pipe(field(203, "Quantity refunded.")),
+      restockType: RestockTypeSchema.pipe(field(204, "How the items were restocked.")),
+      locationId: Schema.NullOr(Schema.String).pipe(field(205, "Restock location identifier.")),
+      subtotalSet: moneyBag(210).pipe(field(206, "Refunded subtotal.")),
+      totalTaxSet: moneyBag(220).pipe(field(207, "Refunded tax.")),
+    }).annotate({ fieldId: 200 }),
+  ).pipe(field(8, "Refunded order line items.")),
+  refundShippingLines: Schema.Array(
+    Schema.Struct({
+      id: Schema.String.pipe(field(301, "Unique refund shipping line identifier.")),
+      shippingLineId: Schema.NullOr(Schema.String).pipe(field(302, "Refunded shipping line.")),
+      subtotalAmountSet: moneyBag(310).pipe(field(303, "Refunded shipping amount.")),
+    }).annotate({ fieldId: 300 }),
+  ).pipe(field(9, "Refunded shipping.")),
+  orderAdjustments: Schema.Array(
+    Schema.Struct({
+      id: Schema.String.pipe(field(401, "Unique order adjustment identifier.")),
+      reason: Schema.NullOr(Schema.String).pipe(field(402, "Reason for the adjustment.")),
+      amountSet: moneyBag(410).pipe(field(403, "Adjustment amount.")),
+      taxAmountSet: moneyBag(420).pipe(field(404, "Tax on the adjustment.")),
+    }).annotate({ fieldId: 400 }),
+  ).pipe(field(10, "Refund discrepancy adjustments.")),
+  duties: Schema.Array(
+    Schema.Struct({
+      dutyId: Schema.NullOr(Schema.String).pipe(field(501, "Refunded duty identifier.")),
+      amountSet: moneyBag(510).pipe(field(502, "Refunded duty amount.")),
+    }).annotate({ fieldId: 500 }),
+  ).pipe(field(11, "Refunded duties.")),
+})
+  .annotate({
+    description: "Refunds on orders in a Shopify store.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type Refund = Schema.Schema.Type<typeof RefundSchema>;

package/src/resources/refunds/webhook.ts

@@ -0,0 +1,123 @@
+import * as Schema from "effect/Schema";
+
+import { RestMoneyBagSchema, fromRest, gid, normalizeAmount, upper } from "../shared";
+import {
+  type Refund,
+  RestockTypeSchema,
+  TransactionKindSchema,
+  TransactionStatusSchema,
+} from "./row";
+
+export const RefundWebhookPayloadSchema = Schema.Struct({
+  id: Schema.Number,
+  admin_graphql_api_id: Schema.String,
+  order_id: Schema.Number,
+  note: Schema.NullOr(Schema.String),
+  created_at: Schema.NullOr(Schema.DateFromString),
+  processed_at: Schema.DateFromString,
+  transactions: Schema.Array(
+    Schema.Struct({
+      admin_graphql_api_id: Schema.String,
+      kind: upper(TransactionKindSchema),
+      status: upper(TransactionStatusSchema),
+      amount: Schema.String,
+      currency: Schema.String,
+      gateway: Schema.NullOr(Schema.String),
+      test: Schema.Boolean,
+      error_code: Schema.NullOr(Schema.String),
+      parent_id: Schema.NullOr(Schema.Number),
+      created_at: Schema.DateFromString,
+      processed_at: Schema.NullOr(Schema.DateFromString),
+    }),
+  ),
+  refund_line_items: Schema.Array(
+    Schema.Struct({
+      id: Schema.Number,
+      line_item_id: Schema.Number,
+      quantity: Schema.Int,
+      restock_type: upper(RestockTypeSchema),
+      location_id: Schema.NullOr(Schema.Number),
+      subtotal_set: RestMoneyBagSchema,
+      total_tax_set: RestMoneyBagSchema,
+    }),
+  ),
+  refund_shipping_lines: Schema.Array(
+    Schema.Struct({
+      id: Schema.Number,
+      shipping_line_id: Schema.NullOr(Schema.Number),
+      subtotal_amount_set: RestMoneyBagSchema,
+    }),
+  ),
+  order_adjustments: Schema.Array(
+    Schema.Struct({
+      id: Schema.Number,
+      kind: Schema.NullOr(Schema.String),
+      reason: Schema.NullOr(Schema.String),
+      amount_set: RestMoneyBagSchema,
+      tax_amount_set: RestMoneyBagSchema,
+    }),
+  ),
+  duties: Schema.Array(
+    Schema.Struct({
+      duty_id: Schema.NullOr(Schema.Number),
+      amount_set: RestMoneyBagSchema,
+    }),
+  ),
+});
+
+export const RefundEventSchema = Schema.toType(RefundWebhookPayloadSchema);
+
+export type RefundWebhookPayload = Schema.Schema.Type<typeof RefundWebhookPayloadSchema>;
+
+export const fromRefundWebhook = (payload: RefundWebhookPayload): Refund => ({
+  id: payload.admin_graphql_api_id,
+  legacyResourceId: String(payload.id),
+  orderId: gid("Order", payload.order_id),
+  note: payload.note ?? "",
+  createdAt: payload.created_at,
+  processedAt: payload.processed_at,
+  // Webhooks only give transaction amounts in the customer currency.
+  transactions: payload.transactions.map((transaction) => ({
+    id: transaction.admin_graphql_api_id,
+    kind: transaction.kind,
+    status: transaction.status,
+    amount: normalizeAmount(transaction.amount),
+    currencyCode: transaction.currency,
+    gateway: transaction.gateway,
+    test: transaction.test,
+    errorCode: transaction.error_code?.toUpperCase() ?? null,
+    parentTransactionId:
+      transaction.parent_id === null ? null : gid("OrderTransaction", transaction.parent_id),
+    createdAt: transaction.created_at,
+    processedAt: transaction.processed_at,
+  })),
+  refundLineItems: payload.refund_line_items.map((item) => ({
+    id: gid("RefundLineItem", item.id),
+    lineItemId: gid("LineItem", item.line_item_id),
+    quantity: item.quantity,
+    restockType: item.restock_type,
+    locationId: item.location_id === null ? null : gid("Location", item.location_id),
+    subtotalSet: fromRest.money(item.subtotal_set),
+    totalTaxSet: fromRest.money(item.total_tax_set),
+  })),
+  refundShippingLines: payload.refund_shipping_lines.map((line) => ({
+    id: gid("RefundShippingLine", line.id),
+    shippingLineId:
+      line.shipping_line_id === null ? null : gid("ShippingLine", line.shipping_line_id),
+    subtotalAmountSet: fromRest.money(line.subtotal_amount_set),
+  })),
+  // Webhooks also list refunded shipping as an adjustment. GraphQL doesn't.
+  orderAdjustments: payload.order_adjustments
+    .filter((adjustment) => adjustment.kind !== "shipping_refund")
+    .map((adjustment) => ({
+      id: gid("OrderAdjustment", adjustment.id),
+      // Webhooks send text like "Refund discrepancy". GraphQL sends REFUND_DISCREPANCY.
+      reason: adjustment.reason?.toUpperCase().replaceAll(" ", "_") ?? null,
+      amountSet: fromRest.money(adjustment.amount_set),
+      taxAmountSet: fromRest.money(adjustment.tax_amount_set),
+    })),
+  duties: payload.duties.map((duty) => ({
+    dutyId: duty.duty_id === null ? null : gid("Duty", duty.duty_id),
+    amountSet: fromRest.money(duty.amount_set),
+  })),
+});