@useairfoil/producer-shopify 0.2.0 → 0.2.1

package/src/resources/orders/graphql.ts

@@ -0,0 +1,419 @@
+import * as Schema from "effect/Schema";
+
+import {
+  AddressFields,
+  DiscountAllocationFields,
+  GraphQLAddressSchema,
+  GraphQLAttributeSchema,
+  GraphQLDiscountAllocationSchema,
+  GraphQLMoneyBagSchema,
+  GraphQLTaxLineSchema,
+  MoneyBagFields,
+  type Nodes,
+  PageInfoFields,
+  TaxLineFields,
+  connection,
+  emptyText,
+  fromGraphQL,
+  idRef,
+  normalizeAmount,
+  pageQuery,
+} from "../shared";
+import {
+  DiscountAllocationMethodSchema,
+  type DiscountApplication,
+  type DiscountApplicationType,
+  DiscountTargetSelectionSchema,
+  DiscountTargetTypeSchema,
+  type Order,
+  OrderCancelReasonSchema,
+  OrderFinancialStatusSchema,
+} from "./row";
+
+const LineItemFields = `
+  id
+  name
+  title
+  variantTitle
+  sku
+  vendor
+  product { id }
+  variant { id }
+  quantity
+  currentQuantity
+  taxable
+  requiresShipping
+  isGiftCard
+  originalUnitPriceSet { ${MoneyBagFields} }
+  totalDiscountSet { ${MoneyBagFields} }
+  taxLines { ${TaxLineFields} }
+  discountAllocations { ${DiscountAllocationFields} }
+  customAttributes { key value }
+`;
+
+const ShippingLineFields = `
+  id
+  title
+  code
+  source
+  carrierIdentifier
+  phone
+  isRemoved
+  originalPriceSet { ${MoneyBagFields} }
+  discountedPriceSet { ${MoneyBagFields} }
+  currentDiscountedPriceSet { ${MoneyBagFields} }
+  taxLines { ${TaxLineFields} }
+  discountAllocations { ${DiscountAllocationFields} }
+`;
+
+const DiscountApplicationFields = `
+  __typename
+  index
+  allocationMethod
+  targetSelection
+  targetType
+  value {
+    __typename
+    ... on MoneyV2 { amount }
+    ... on PricingPercentageValue { percentage }
+  }
+  ... on DiscountCodeApplication { code }
+  ... on ManualDiscountApplication { title description }
+  ... on AutomaticDiscountApplication { title }
+  ... on ScriptDiscountApplication { title }
+`;
+
+export const OrderFields = `
+  id
+  legacyResourceId
+  name
+  email
+  phone
+  customer { id }
+  customerLocale
+  customerAcceptsMarketing
+  billingAddress { ${AddressFields} }
+  shippingAddress { ${AddressFields} }
+  note
+  customAttributes { key value }
+  tags
+  confirmationNumber
+  poNumber
+  sourceName
+  sourceIdentifier
+  app { id }
+  paymentGatewayNames
+  test
+  taxesIncluded
+  taxExempt
+  dutiesIncluded
+  estimatedTaxes
+  totalWeight
+  displayFinancialStatus
+  cancelReason
+  cancelledAt
+  closedAt
+  processedAt
+  createdAt
+  updatedAt
+  currencyCode
+  presentmentCurrencyCode
+  discountCodes
+  discountApplications(first: 25) { nodes { ${DiscountApplicationFields} } ${PageInfoFields} }
+  subtotalPriceSet { ${MoneyBagFields} }
+  currentSubtotalPriceSet { ${MoneyBagFields} }
+  totalDiscountsSet { ${MoneyBagFields} }
+  currentTotalDiscountsSet { ${MoneyBagFields} }
+  totalShippingPriceSet { ${MoneyBagFields} }
+  currentShippingPriceSet { ${MoneyBagFields} }
+  totalTaxSet { ${MoneyBagFields} }
+  currentTotalTaxSet { ${MoneyBagFields} }
+  originalTotalDutiesSet { ${MoneyBagFields} }
+  currentTotalDutiesSet { ${MoneyBagFields} }
+  totalPriceSet { ${MoneyBagFields} }
+  currentTotalPriceSet { ${MoneyBagFields} }
+  taxLines { ${TaxLineFields} }
+  shippingLines(first: 25, includeRemovals: true) { nodes { ${ShippingLineFields} } ${PageInfoFields} }
+  lineItems(first: 50) { nodes { ${LineItemFields} } ${PageInfoFields} }
+`;
+
+const orderConnectionQuery = (name: string, selection: string) => `#graphql
+query ${name}($id: ID!, $first: Int!, $after: String) {
+  node: order(id: $id) {
+    connection: ${selection}
+  }
+}
+`;
+
+export const OrderLineItemsQuery = orderConnectionQuery(
+  "AirfoilOrderLineItems",
+  `lineItems(first: $first, after: $after) { nodes { ${LineItemFields} } ${PageInfoFields} }`,
+);
+
+export const OrderShippingLinesQuery = orderConnectionQuery(
+  "AirfoilOrderShippingLines",
+  `shippingLines(first: $first, after: $after, includeRemovals: true) { nodes { ${ShippingLineFields} } ${PageInfoFields} }`,
+);
+
+export const OrderDiscountApplicationsQuery = orderConnectionQuery(
+  "AirfoilOrderDiscountApplications",
+  `discountApplications(first: $first, after: $after) { nodes { ${DiscountApplicationFields} } ${PageInfoFields} }`,
+);
+
+export const GraphQLLineItemsSchema = connection(
+  Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    title: Schema.String,
+    variantTitle: Schema.NullOr(Schema.String),
+    sku: Schema.NullOr(Schema.String),
+    vendor: Schema.NullOr(Schema.String),
+    product: idRef,
+    variant: idRef,
+    quantity: Schema.Int,
+    currentQuantity: Schema.Int,
+    taxable: Schema.Boolean,
+    requiresShipping: Schema.Boolean,
+    isGiftCard: Schema.Boolean,
+    originalUnitPriceSet: GraphQLMoneyBagSchema,
+    totalDiscountSet: GraphQLMoneyBagSchema,
+    taxLines: Schema.Array(GraphQLTaxLineSchema),
+    discountAllocations: Schema.Array(GraphQLDiscountAllocationSchema),
+    customAttributes: Schema.Array(GraphQLAttributeSchema),
+  }),
+);
+
+export const GraphQLShippingLinesSchema = connection(
+  Schema.Struct({
+    id: Schema.NullOr(Schema.String),
+    title: Schema.String,
+    code: Schema.NullOr(Schema.String),
+    source: Schema.NullOr(Schema.String),
+    carrierIdentifier: Schema.NullOr(Schema.String),
+    phone: Schema.NullOr(Schema.String),
+    isRemoved: Schema.Boolean,
+    originalPriceSet: GraphQLMoneyBagSchema,
+    discountedPriceSet: GraphQLMoneyBagSchema,
+    currentDiscountedPriceSet: GraphQLMoneyBagSchema,
+    taxLines: Schema.Array(GraphQLTaxLineSchema),
+    discountAllocations: Schema.Array(GraphQLDiscountAllocationSchema),
+  }),
+);
+
+const discountApplicationBase = {
+  index: Schema.Int,
+  allocationMethod: DiscountAllocationMethodSchema,
+  targetSelection: DiscountTargetSelectionSchema,
+  targetType: DiscountTargetTypeSchema,
+  value: Schema.Union([
+    Schema.Struct({ __typename: Schema.Literal("MoneyV2"), amount: Schema.String }),
+    Schema.Struct({
+      __typename: Schema.Literal("PricingPercentageValue"),
+      percentage: Schema.Number,
+    }),
+  ]),
+};
+
+export const GraphQLDiscountApplicationsSchema = connection(
+  Schema.Union([
+    Schema.Struct({
+      __typename: Schema.Literal("DiscountCodeApplication"),
+      code: Schema.String,
+      ...discountApplicationBase,
+    }),
+    Schema.Struct({
+      __typename: Schema.Literal("ManualDiscountApplication"),
+      title: Schema.String,
+      description: Schema.NullOr(Schema.String),
+      ...discountApplicationBase,
+    }),
+    Schema.Struct({
+      __typename: Schema.Literals(["AutomaticDiscountApplication", "ScriptDiscountApplication"]),
+      title: Schema.String,
+      ...discountApplicationBase,
+    }),
+  ]),
+);
+
+export const GraphQLOrderNodeSchema = Schema.Struct({
+  id: Schema.String,
+  legacyResourceId: Schema.String,
+  name: Schema.String,
+  email: Schema.NullOr(Schema.String),
+  phone: Schema.NullOr(Schema.String),
+  customer: idRef,
+  customerLocale: Schema.NullOr(Schema.String),
+  customerAcceptsMarketing: Schema.Boolean,
+  billingAddress: Schema.NullOr(GraphQLAddressSchema),
+  shippingAddress: Schema.NullOr(GraphQLAddressSchema),
+  note: Schema.NullOr(Schema.String),
+  customAttributes: Schema.Array(GraphQLAttributeSchema),
+  tags: Schema.Array(Schema.String),
+  confirmationNumber: Schema.NullOr(Schema.String),
+  poNumber: Schema.NullOr(Schema.String),
+  sourceName: Schema.NullOr(Schema.String),
+  sourceIdentifier: Schema.NullOr(Schema.String),
+  app: idRef,
+  paymentGatewayNames: Schema.Array(Schema.String),
+  test: Schema.Boolean,
+  taxesIncluded: Schema.Boolean,
+  taxExempt: Schema.Boolean,
+  dutiesIncluded: Schema.Boolean,
+  estimatedTaxes: Schema.Boolean,
+  totalWeight: Schema.NullOr(Schema.NumberFromString),
+  displayFinancialStatus: Schema.NullOr(OrderFinancialStatusSchema),
+  cancelReason: Schema.NullOr(OrderCancelReasonSchema),
+  cancelledAt: Schema.NullOr(Schema.DateFromString),
+  closedAt: Schema.NullOr(Schema.DateFromString),
+  processedAt: Schema.DateFromString,
+  createdAt: Schema.DateFromString,
+  updatedAt: Schema.DateFromString,
+  currencyCode: Schema.String,
+  presentmentCurrencyCode: Schema.String,
+  discountCodes: Schema.Array(Schema.String),
+  discountApplications: GraphQLDiscountApplicationsSchema,
+  subtotalPriceSet: Schema.NullOr(GraphQLMoneyBagSchema),
+  currentSubtotalPriceSet: GraphQLMoneyBagSchema,
+  totalDiscountsSet: Schema.NullOr(GraphQLMoneyBagSchema),
+  currentTotalDiscountsSet: GraphQLMoneyBagSchema,
+  totalShippingPriceSet: GraphQLMoneyBagSchema,
+  currentShippingPriceSet: GraphQLMoneyBagSchema,
+  totalTaxSet: Schema.NullOr(GraphQLMoneyBagSchema),
+  currentTotalTaxSet: GraphQLMoneyBagSchema,
+  originalTotalDutiesSet: Schema.NullOr(GraphQLMoneyBagSchema),
+  currentTotalDutiesSet: Schema.NullOr(GraphQLMoneyBagSchema),
+  totalPriceSet: GraphQLMoneyBagSchema,
+  currentTotalPriceSet: GraphQLMoneyBagSchema,
+  taxLines: Schema.Array(GraphQLTaxLineSchema),
+  shippingLines: GraphQLShippingLinesSchema,
+  lineItems: GraphQLLineItemsSchema,
+});
+
+export type GraphQLOrderNode = Schema.Schema.Type<typeof GraphQLOrderNodeSchema>;
+
+const discountApplicationType = {
+  DiscountCodeApplication: "DISCOUNT_CODE",
+  ManualDiscountApplication: "MANUAL",
+  AutomaticDiscountApplication: "AUTOMATIC",
+  ScriptDiscountApplication: "SCRIPT",
+} as const satisfies Record<string, DiscountApplicationType>;
+
+export const fromOrderNode = (
+  node: GraphQLOrderNode,
+  nested: {
+    readonly discountApplications: Nodes<typeof GraphQLDiscountApplicationsSchema>;
+    readonly shippingLines: Nodes<typeof GraphQLShippingLinesSchema>;
+    readonly lineItems: Nodes<typeof GraphQLLineItemsSchema>;
+  },
+): Order => ({
+  id: node.id,
+  legacyResourceId: node.legacyResourceId,
+  name: node.name,
+  email: emptyText(node.email),
+  phone: emptyText(node.phone),
+  customerId: node.customer?.id ?? "",
+  customerLocale: emptyText(node.customerLocale),
+  customerAcceptsMarketing: node.customerAcceptsMarketing,
+  billingAddress: node.billingAddress ? fromGraphQL.address(node.billingAddress) : null,
+  shippingAddress: node.shippingAddress ? fromGraphQL.address(node.shippingAddress) : null,
+  note: emptyText(node.note),
+  customAttributes: node.customAttributes,
+  tags: node.tags,
+  confirmationNumber: emptyText(node.confirmationNumber),
+  poNumber: emptyText(node.poNumber),
+  sourceName: emptyText(node.sourceName),
+  sourceIdentifier: emptyText(node.sourceIdentifier),
+  appId: node.app?.id ?? "",
+  paymentGatewayNames: node.paymentGatewayNames,
+  test: node.test,
+  taxesIncluded: node.taxesIncluded,
+  taxExempt: node.taxExempt,
+  dutiesIncluded: node.dutiesIncluded,
+  estimatedTaxes: node.estimatedTaxes,
+  totalWeight: node.totalWeight,
+  displayFinancialStatus: node.displayFinancialStatus,
+  cancelReason: node.cancelReason,
+  cancelledAt: node.cancelledAt,
+  closedAt: node.closedAt,
+  processedAt: node.processedAt,
+  createdAt: node.createdAt,
+  updatedAt: node.updatedAt,
+  currencyCode: node.currencyCode,
+  presentmentCurrencyCode: node.presentmentCurrencyCode,
+  discountCodes: node.discountCodes,
+  discountApplications: nested.discountApplications.map(
+    (application): DiscountApplication => ({
+      index: application.index,
+      type: discountApplicationType[application.__typename],
+      code: application.__typename === "DiscountCodeApplication" ? application.code : null,
+      title: application.__typename === "DiscountCodeApplication" ? null : application.title,
+      description:
+        application.__typename === "ManualDiscountApplication" ? application.description : null,
+      allocationMethod: application.allocationMethod,
+      targetSelection: application.targetSelection,
+      targetType: application.targetType,
+      valueType: application.value.__typename === "MoneyV2" ? "FIXED_AMOUNT" : "PERCENTAGE",
+      value:
+        application.value.__typename === "MoneyV2"
+          ? normalizeAmount(application.value.amount)
+          : normalizeAmount(String(application.value.percentage)),
+    }),
+  ),
+  subtotalPriceSet: node.subtotalPriceSet ? fromGraphQL.money(node.subtotalPriceSet) : null,
+  currentSubtotalPriceSet: fromGraphQL.money(node.currentSubtotalPriceSet),
+  totalDiscountsSet: node.totalDiscountsSet ? fromGraphQL.money(node.totalDiscountsSet) : null,
+  currentTotalDiscountsSet: fromGraphQL.money(node.currentTotalDiscountsSet),
+  totalShippingPriceSet: fromGraphQL.money(node.totalShippingPriceSet),
+  currentShippingPriceSet: fromGraphQL.money(node.currentShippingPriceSet),
+  totalTaxSet: node.totalTaxSet ? fromGraphQL.money(node.totalTaxSet) : null,
+  currentTotalTaxSet: fromGraphQL.money(node.currentTotalTaxSet),
+  originalTotalDutiesSet: node.originalTotalDutiesSet
+    ? fromGraphQL.money(node.originalTotalDutiesSet)
+    : null,
+  currentTotalDutiesSet: node.currentTotalDutiesSet
+    ? fromGraphQL.money(node.currentTotalDutiesSet)
+    : null,
+  totalPriceSet: fromGraphQL.money(node.totalPriceSet),
+  currentTotalPriceSet: fromGraphQL.money(node.currentTotalPriceSet),
+  taxLines: node.taxLines.map(fromGraphQL.taxLine),
+  shippingLines: nested.shippingLines.map((line) => ({
+    id: line.id,
+    title: line.title,
+    code: line.code,
+    source: line.source,
+    carrierIdentifier: line.carrierIdentifier,
+    phone: line.phone,
+    isRemoved: line.isRemoved,
+    originalPriceSet: fromGraphQL.money(line.originalPriceSet),
+    discountedPriceSet: fromGraphQL.money(line.discountedPriceSet),
+    currentDiscountedPriceSet: fromGraphQL.money(line.currentDiscountedPriceSet),
+    taxLines: line.taxLines.map(fromGraphQL.taxLine),
+    discountAllocations: line.discountAllocations.map(fromGraphQL.discountAllocation),
+  })),
+  lineItems: nested.lineItems.map((item) => ({
+    id: item.id,
+    name: item.name,
+    title: item.title,
+    variantTitle: item.variantTitle,
+    sku: item.sku,
+    vendor: item.vendor,
+    productId: item.product?.id ?? null,
+    variantId: item.variant?.id ?? null,
+    quantity: item.quantity,
+    currentQuantity: item.currentQuantity,
+    taxable: item.taxable,
+    requiresShipping: item.requiresShipping,
+    isGiftCard: item.isGiftCard,
+    originalUnitPriceSet: fromGraphQL.money(item.originalUnitPriceSet),
+    totalDiscountSet: fromGraphQL.money(item.totalDiscountSet),
+    taxLines: item.taxLines.map(fromGraphQL.taxLine),
+    discountAllocations: item.discountAllocations.map(fromGraphQL.discountAllocation),
+    customAttributes: item.customAttributes,
+  })),
+});
+
+export const OrdersQuery = pageQuery("AirfoilOrders", "orders", OrderFields);
+
+export const GraphQLOrdersDataSchema = Schema.Struct({
+  orders: connection(GraphQLOrderNodeSchema),
+});

package/src/resources/orders/row.ts

@@ -0,0 +1,180 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import * as Schema from "effect/Schema";
+
+import { address, attributes, discountAllocations, field, moneyBag, taxLines } from "../shared";
+
+export const OrderCancelReasonSchema = Schema.Literals([
+  "CUSTOMER",
+  "DECLINED",
+  "FRAUD",
+  "INVENTORY",
+  "STAFF",
+  "OTHER",
+]);
+
+export const OrderFinancialStatusSchema = Schema.Literals([
+  "PENDING",
+  "AUTHORIZED",
+  "PARTIALLY_PAID",
+  "PARTIALLY_REFUNDED",
+  "VOIDED",
+  "PAID",
+  "REFUNDED",
+  "EXPIRED",
+]);
+
+export const DiscountApplicationTypeSchema = Schema.Literals([
+  "DISCOUNT_CODE",
+  "MANUAL",
+  "AUTOMATIC",
+  "SCRIPT",
+]);
+
+// Shopify deprecated ONE but still returns it for older orders.
+export const DiscountAllocationMethodSchema = Schema.Literals(["ACROSS", "EACH", "ONE"]);
+
+export const DiscountTargetSelectionSchema = Schema.Literals(["ALL", "ENTITLED", "EXPLICIT"]);
+
+export const DiscountTargetTypeSchema = Schema.Literals(["LINE_ITEM", "SHIPPING_LINE"]);
+
+export const DiscountValueTypeSchema = Schema.Literals(["PERCENTAGE", "FIXED_AMOUNT"]);
+
+export const DiscountApplicationSchema = Schema.Struct({
+  index: Schema.Int.pipe(field(161, "Position used by discount allocations.")),
+  type: DiscountApplicationTypeSchema.pipe(field(162, "How the discount was applied.")),
+  code: Schema.NullOr(Schema.String).pipe(field(163, "Discount code.")),
+  title: Schema.NullOr(Schema.String).pipe(field(164, "Discount title.")),
+  description: Schema.NullOr(Schema.String).pipe(field(165, "Manual discount description.")),
+  allocationMethod: DiscountAllocationMethodSchema.pipe(field(166, "How the value is split.")),
+  targetSelection: DiscountTargetSelectionSchema.pipe(field(167, "Which lines are targeted.")),
+  targetType: DiscountTargetTypeSchema.pipe(field(168, "Kind of lines targeted.")),
+  valueType: DiscountValueTypeSchema.pipe(field(169, "Whether the value is a percent.")),
+  value: Schema.String.pipe(field(170, "Percent or amount in the customer currency.")),
+});
+
+export const ShippingLineSchema = Schema.Struct({
+  id: Schema.NullOr(Schema.String).pipe(field(501, "Unique shipping line identifier.")),
+  title: Schema.String.pipe(field(502, "Shipping method title.")),
+  code: Schema.NullOr(Schema.String).pipe(field(503, "Shipping rate code.")),
+  source: Schema.NullOr(Schema.String).pipe(field(504, "Source of the shipping rate.")),
+  carrierIdentifier: Schema.NullOr(Schema.String).pipe(field(505, "Carrier service identifier.")),
+  phone: Schema.NullOr(Schema.String).pipe(field(506, "Phone number for the shipping line.")),
+  isRemoved: Schema.Boolean.pipe(field(507, "Whether the line was removed by an edit.")),
+  originalPriceSet: moneyBag(520).pipe(field(508, "Price before discounts.")),
+  discountedPriceSet: moneyBag(530).pipe(field(509, "Price after discounts.")),
+  currentDiscountedPriceSet: moneyBag(540).pipe(
+    field(510, "Price after discounts, edits, and refunds."),
+  ),
+  taxLines: taxLines(550).pipe(field(511, "Taxes on the shipping line.")),
+  discountAllocations: discountAllocations(570).pipe(field(512, "Discounts on the line.")),
+});
+
+export const OrderLineItemSchema = Schema.Struct({
+  id: Schema.String.pipe(field(601, "Unique line item identifier.")),
+  name: Schema.String.pipe(field(602, "Product and variant name.")),
+  title: Schema.String.pipe(field(603, "Product title.")),
+  variantTitle: Schema.NullOr(Schema.String).pipe(field(604, "Variant title.")),
+  sku: Schema.NullOr(Schema.String).pipe(field(605, "Stock keeping unit.")),
+  vendor: Schema.NullOr(Schema.String).pipe(field(606, "Product vendor.")),
+  productId: Schema.NullOr(Schema.String).pipe(field(607, "Product identifier.")),
+  variantId: Schema.NullOr(Schema.String).pipe(field(608, "Product variant identifier.")),
+  quantity: Schema.Int.pipe(field(609, "Quantity when the order was placed.")),
+  currentQuantity: Schema.Int.pipe(field(610, "Quantity after removals and refunds.")),
+  taxable: Schema.Boolean.pipe(field(611, "Whether the line item is taxable.")),
+  requiresShipping: Schema.Boolean.pipe(field(612, "Whether the line item needs shipping.")),
+  isGiftCard: Schema.Boolean.pipe(field(613, "Whether the line item is a gift card.")),
+  originalUnitPriceSet: moneyBag(630).pipe(field(614, "Unit price before discounts.")),
+  totalDiscountSet: moneyBag(640).pipe(field(615, "Total discount on the line.")),
+  taxLines: taxLines(650).pipe(field(616, "Taxes on the line.")),
+  discountAllocations: discountAllocations(670).pipe(field(617, "Discounts on the line.")),
+  customAttributes: attributes(690).pipe(field(618, "Custom line properties.")),
+});
+
+export const OrderSchema = Schema.Struct({
+  id: Schema.String.pipe(field(1, "Unique order identifier.")),
+  legacyResourceId: Schema.String.pipe(field(2, "Numeric order identifier stored as text.")),
+  name: Schema.String.pipe(field(3, "Order name shown to the merchant.")),
+  email: Schema.NullOr(Schema.String).pipe(field(4, "Email used for the order.")),
+  phone: Schema.NullOr(Schema.String).pipe(field(5, "Phone used for the order.")),
+  customerId: Schema.NullOr(Schema.String).pipe(field(6, "Customer identifier.")),
+  customerLocale: Schema.NullOr(Schema.String).pipe(field(7, "Customer language.")),
+  customerAcceptsMarketing: Schema.Boolean.pipe(field(8, "Whether the buyer accepts marketing.")),
+  billingAddress: Schema.NullOr(address(100)).pipe(field(9, "Billing address.")),
+  shippingAddress: Schema.NullOr(address(120)).pipe(field(10, "Shipping address.")),
+  note: Schema.NullOr(Schema.String).pipe(field(11, "Order note.")),
+  customAttributes: attributes(140).pipe(field(12, "Custom order attributes.")),
+  tags: Schema.Array(Schema.String.annotate({ fieldId: 150 })).pipe(
+    field(13, "Tags added to the order."),
+  ),
+  confirmationNumber: Schema.NullOr(Schema.String).pipe(field(14, "Confirmation number.")),
+  poNumber: Schema.NullOr(Schema.String).pipe(field(15, "Purchase order number.")),
+  sourceName: Schema.NullOr(Schema.String).pipe(field(16, "Channel that created the order.")),
+  sourceIdentifier: Schema.NullOr(Schema.String).pipe(field(17, "Identifier from the source.")),
+  appId: Schema.NullOr(Schema.String).pipe(field(18, "App that created the order.")),
+  paymentGatewayNames: Schema.Array(Schema.String.annotate({ fieldId: 152 })).pipe(
+    field(19, "Payment gateways used."),
+  ),
+  test: Schema.Boolean.pipe(field(20, "Whether the order is a test order.")),
+  taxesIncluded: Schema.Boolean.pipe(field(21, "Whether prices include taxes.")),
+  taxExempt: Schema.Boolean.pipe(field(22, "Whether the order is exempt from tax.")),
+  dutiesIncluded: Schema.Boolean.pipe(field(23, "Whether prices include duties.")),
+  estimatedTaxes: Schema.Boolean.pipe(field(24, "Whether taxes are estimates.")),
+  totalWeight: Schema.NullOr(Schema.Int).pipe(field(25, "Total weight in grams.")),
+  displayFinancialStatus: Schema.NullOr(OrderFinancialStatusSchema).pipe(
+    field(26, "Payment status of the order."),
+  ),
+  cancelReason: Schema.NullOr(OrderCancelReasonSchema).pipe(
+    field(27, "Reason the order was cancelled."),
+  ),
+  cancelledAt: Schema.NullOr(Schema.Date).pipe(field(28, "Time when the order was cancelled.")),
+  closedAt: Schema.NullOr(Schema.Date).pipe(field(29, "Time when the order was closed.")),
+  processedAt: Schema.Date.pipe(field(30, "Time when the order was processed.")),
+  createdAt: Schema.Date.pipe(field(31, "Time when the order was created.")),
+  updatedAt: Schema.Date.pipe(field(32, "Time when the order was last changed.")),
+  currencyCode: Schema.String.pipe(field(33, "Shop currency code.")),
+  presentmentCurrencyCode: Schema.String.pipe(field(34, "Customer currency code.")),
+  discountCodes: Schema.Array(Schema.String.annotate({ fieldId: 151 })).pipe(
+    field(35, "Discount codes used."),
+  ),
+  discountApplications: Schema.Array(DiscountApplicationSchema.annotate({ fieldId: 160 })).pipe(
+    field(36, "Discounts applied to the order."),
+  ),
+  subtotalPriceSet: Schema.NullOr(moneyBag(200)).pipe(
+    field(37, "Subtotal when the order was placed."),
+  ),
+  currentSubtotalPriceSet: moneyBag(210).pipe(field(38, "Subtotal after edits and refunds.")),
+  totalDiscountsSet: Schema.NullOr(moneyBag(220)).pipe(
+    field(39, "Discounts when the order was placed."),
+  ),
+  currentTotalDiscountsSet: moneyBag(230).pipe(field(40, "Discounts after edits and refunds.")),
+  totalShippingPriceSet: moneyBag(240).pipe(field(41, "Shipping when the order was placed.")),
+  currentShippingPriceSet: moneyBag(250).pipe(field(42, "Shipping after edits and refunds.")),
+  totalTaxSet: Schema.NullOr(moneyBag(260)).pipe(field(43, "Tax when the order was placed.")),
+  currentTotalTaxSet: moneyBag(270).pipe(field(44, "Tax after edits and refunds.")),
+  originalTotalDutiesSet: Schema.NullOr(moneyBag(280)).pipe(
+    field(45, "Duties when the order was placed."),
+  ),
+  currentTotalDutiesSet: Schema.NullOr(moneyBag(290)).pipe(
+    field(46, "Duties after edits and refunds."),
+  ),
+  totalPriceSet: moneyBag(300).pipe(field(47, "Total when the order was placed.")),
+  currentTotalPriceSet: moneyBag(310).pipe(field(48, "Total after edits and refunds.")),
+  taxLines: taxLines(400).pipe(field(49, "Taxes when the order was placed.")),
+  shippingLines: Schema.Array(ShippingLineSchema.annotate({ fieldId: 500 })).pipe(
+    field(50, "Shipping lines, including removed ones."),
+  ),
+  lineItems: Schema.Array(OrderLineItemSchema.annotate({ fieldId: 600 })).pipe(
+    field(51, "Line items in the order."),
+  ),
+  _deleted: Schema.optional(Schema.Boolean).pipe(field(52, "Whether the order was deleted.")),
+})
+  .annotate({
+    description: "Orders in a Shopify store.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type Order = Schema.Schema.Type<typeof OrderSchema>;
+
+export type DiscountApplication = Schema.Schema.Type<typeof DiscountApplicationSchema>;
+
+export type DiscountApplicationType = Schema.Schema.Type<typeof DiscountApplicationTypeSchema>;