@useairfoil/producer-shopify 0.2.0 → 0.2.1

package/src/main.ts

@@ -1,20 +1,20 @@
 import { NodeRuntime, NodeServices } from "@effect/platform-node";
 import { Effect, Layer } from "effect";
-import { Command } from "effect/unstable/cli";
-import { FetchHttpClient } from "effect/unstable/http";
+import { Command } from "effect/cli";
+import { FetchHttpClient } from "effect/http";
 
 import packageJson from "../package.json";
+import { createTableCommand } from "./create-table";
+import { demoCommand } from "./demo";
 import { sandboxCommand } from "./sandbox";
 import { startCommand } from "./start";
 
 const BootstrapLayer = Layer.mergeAll(FetchHttpClient.layer, NodeServices.layer);
 
 const program = Command.make("producer-shopify", {}, () => Effect.void).pipe(
-  Command.withSubcommands([startCommand, sandboxCommand]),
+  Command.withSubcommands([startCommand, sandboxCommand, createTableCommand, demoCommand]),
 );
 
-Command.run(program, { version: packageJson.version }).pipe(
-  Effect.provide(BootstrapLayer),
-  Effect.scoped,
-  NodeRuntime.runMain,
-);
+const cli = Command.run(program, { version: packageJson.version });
+
+NodeRuntime.runMain(cli.pipe(Effect.provide(BootstrapLayer), Effect.scoped));

package/src/manifest.ts

@@ -5,11 +5,6 @@ export const ShopifyConfigDef = Manifest.defineConfig({
     runtimeKey: "SHOPIFY_SHOP_DOMAIN",
     description: "Shopify shop domain, for example example.myshopify.com.",
   }),
-  apiVersion: Manifest.string({
-    runtimeKey: "SHOPIFY_API_VERSION",
-    description: "Shopify Admin API version used in GraphQL endpoint URLs.",
-    default: "2026-07",
-  }),
   clientId: Manifest.string({
     runtimeKey: "SHOPIFY_CLIENT_ID",
     description: "Client ID for the merchant-owned Shopify Dev Dashboard app.",
@@ -18,55 +13,6 @@ export const ShopifyConfigDef = Manifest.defineConfig({
     runtimeKey: "SHOPIFY_CLIENT_SECRET",
     description: "Client secret for the merchant-owned Shopify Dev Dashboard app.",
   }),
-  responseMaxRetries: Manifest.number({
-    runtimeKey: "SHOPIFY_RESPONSE_MAX_RETRIES",
-    description: "Maximum retries for temporary HTTP responses.",
-    default: 5,
-    integer: true,
-    minimum: 0,
-  }),
-  transportMaxRetries: Manifest.number({
-    runtimeKey: "SHOPIFY_TRANSPORT_MAX_RETRIES",
-    description: "Maximum retries for connection and transport failures.",
-    default: 5,
-    integer: true,
-    minimum: 0,
-  }),
-  graphqlMaxRetries: Manifest.number({
-    runtimeKey: "SHOPIFY_GRAPHQL_MAX_RETRIES",
-    description: "Maximum retries for temporary GraphQL errors.",
-    default: 5,
-    integer: true,
-    minimum: 0,
-  }),
-  retryBaseDelayMs: Manifest.number({
-    runtimeKey: "SHOPIFY_RETRY_BASE_DELAY_MS",
-    description: "Initial delay for HTTP and transport retries.",
-    default: 200,
-    integer: true,
-    minimum: 1,
-  }),
-  graphqlRetryBaseDelayMs: Manifest.number({
-    runtimeKey: "SHOPIFY_GRAPHQL_RETRY_BASE_DELAY_MS",
-    description: "Initial delay for temporary GraphQL errors.",
-    default: 500,
-    integer: true,
-    minimum: 1,
-  }),
-  retryAfterFallbackSeconds: Manifest.number({
-    runtimeKey: "SHOPIFY_RETRY_AFTER_FALLBACK_SECONDS",
-    description: "Retry delay used when Shopify omits Retry-After.",
-    default: 1,
-    integer: true,
-    minimum: 1,
-  }),
-  requestTimeoutSeconds: Manifest.number({
-    runtimeKey: "SHOPIFY_REQUEST_TIMEOUT_SECONDS",
-    description: "Maximum request time including retries.",
-    default: 120,
-    integer: true,
-    minimum: 1,
-  }),
   webhookSecret: Manifest.secret({
     runtimeKey: "SHOPIFY_WEBHOOK_SECRET",
     description: "Shopify webhook HMAC secret.",
@@ -81,6 +27,9 @@ export const manifest = Manifest.define({
   config: ShopifyConfigDef.spec,
   resources: [
     { name: "products", capabilities: ["backfill", "webhook"] },
-    { name: "cart_events", capabilities: ["webhook"] },
+    { name: "carts", capabilities: ["webhook"] },
+    { name: "customers", capabilities: ["backfill", "webhook"] },
+    { name: "orders", capabilities: ["backfill", "webhook"] },
+    { name: "refunds", capabilities: ["backfill", "webhook"] },
   ],
 });

package/src/resources/carts/row.ts

@@ -0,0 +1,58 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import * as Schema from "effect/Schema";
+
+import { field, moneyBag } from "../shared";
+
+export const CartLineItemSchema = Schema.Struct({
+  id: Schema.String.pipe(field(102, "Unique cart line identifier.")),
+  properties: Schema.NullOr(Schema.String).pipe(
+    field(103, "Custom line properties stored as JSON."),
+  ),
+  quantity: Schema.Int.pipe(field(104, "Quantity of the cart line.")),
+  variantId: Schema.String.pipe(field(105, "Product variant identifier.")),
+  key: Schema.String.pipe(field(106, "Unique key for the cart line.")),
+  discountedPrice: Schema.String.pipe(field(107, "Price after discounts.")),
+  discounts: Schema.String.pipe(field(108, "Line discounts stored as JSON.")),
+  giftCard: Schema.Boolean.pipe(field(109, "Whether the line is a gift card.")),
+  grams: Schema.Int.pipe(field(110, "Weight of the line in grams.")),
+  linePrice: Schema.String.pipe(field(111, "Total price for the line.")),
+  originalLinePrice: Schema.String.pipe(field(112, "Line price before discounts.")),
+  originalPrice: Schema.String.pipe(field(113, "Unit price before discounts.")),
+  price: Schema.String.pipe(field(114, "Current unit price.")),
+  productId: Schema.String.pipe(field(115, "Product identifier.")),
+  sku: Schema.NullOr(Schema.String).pipe(field(116, "Stock keeping unit for the line.")),
+  taxable: Schema.Boolean.pipe(field(117, "Whether the line is taxable.")),
+  title: Schema.String.pipe(field(118, "Title of the cart line.")),
+  totalDiscount: Schema.String.pipe(field(119, "Total discount for the line.")),
+  vendor: Schema.String.pipe(field(120, "Vendor of the product.")),
+  discountedPriceSet: moneyBag(200).pipe(field(121, "Price after discounts.")),
+  linePriceSet: moneyBag(210).pipe(field(122, "Total price for the line.")),
+  originalLinePriceSet: moneyBag(220).pipe(field(123, "Line price before discounts.")),
+  priceSet: moneyBag(230).pipe(field(124, "Current unit price.")),
+  totalDiscountSet: moneyBag(240).pipe(field(125, "Total discount for the line.")),
+  parentRelationship: Schema.NullOr(Schema.String).pipe(
+    field(126, "Parent relationship stored as JSON."),
+  ),
+});
+
+export const CartSchema = Schema.Struct({
+  id: Schema.String.pipe(field(1, "Unique cart identifier.")),
+  token: Schema.String.pipe(field(2, "Token for the cart.")),
+  topic: Schema.Literals(["carts/create", "carts/update"]).pipe(
+    field(3, "Webhook topic that last changed the cart."),
+  ),
+  lineItems: Schema.Array(CartLineItemSchema.annotate({ fieldId: 101 })).pipe(
+    field(4, "Items in the cart."),
+  ),
+  note: Schema.NullOr(Schema.String).pipe(field(5, "Note added to the cart.")),
+  updatedAt: Schema.Date.pipe(field(6, "Time when the cart was last changed.")),
+  createdAt: Schema.Date.pipe(field(7, "Time when the cart was created.")),
+})
+  .annotate({
+    description: "Latest state of each cart in a Shopify store.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type CartLineItem = Schema.Schema.Type<typeof CartLineItemSchema>;
+
+export type Cart = Schema.Schema.Type<typeof CartSchema>;

package/src/resources/carts/webhook.ts

@@ -0,0 +1,98 @@
+import * as Schema from "effect/Schema";
+
+import type { Cart, CartLineItem } from "./row";
+
+import { RestMoneyBagSchema, fromRest, gid, normalizeAmount } from "../shared";
+
+const JsonStringSchema = Schema.flip(Schema.fromJsonString(Schema.Unknown));
+
+const CartWebhookLineItemSchema = Schema.Struct({
+  id: Schema.Number,
+  properties: Schema.Union([Schema.Null, JsonStringSchema]),
+  quantity: Schema.Int,
+  variant_id: Schema.Number,
+  key: Schema.String,
+  discounted_price: Schema.String,
+  discounts: JsonStringSchema,
+  gift_card: Schema.Boolean,
+  grams: Schema.Int,
+  line_price: Schema.String,
+  original_line_price: Schema.String,
+  original_price: Schema.String,
+  price: Schema.String,
+  product_id: Schema.Number,
+  sku: Schema.NullOr(Schema.String),
+  taxable: Schema.Boolean,
+  title: Schema.String,
+  total_discount: Schema.String,
+  vendor: Schema.String,
+  discounted_price_set: RestMoneyBagSchema,
+  line_price_set: RestMoneyBagSchema,
+  original_line_price_set: RestMoneyBagSchema,
+  price_set: RestMoneyBagSchema,
+  total_discount_set: RestMoneyBagSchema,
+  parent_relationship: Schema.Union([Schema.Null, JsonStringSchema]),
+});
+
+export const CartWebhookPayloadSchema = Schema.Struct({
+  id: Schema.String,
+  token: Schema.String,
+  line_items: Schema.Array(CartWebhookLineItemSchema),
+  note: Schema.NullOr(Schema.String),
+  updated_at: Schema.DateFromString,
+  created_at: Schema.DateFromString,
+});
+
+export const CartWebhookEventSchema = Schema.Struct({
+  id: Schema.String,
+  token: Schema.String,
+  line_items: Schema.Array(Schema.toType(CartWebhookLineItemSchema)),
+  note: Schema.NullOr(Schema.String),
+  updated_at: Schema.Date,
+  created_at: Schema.Date,
+  topic: Schema.Literals(["carts/create", "carts/update"]),
+});
+
+export type CartWebhookLineItem = Schema.Schema.Type<typeof CartWebhookLineItemSchema>;
+
+export type CartWebhookPayload = Schema.Schema.Type<typeof CartWebhookPayloadSchema>;
+
+export type CartWebhookEvent = Schema.Schema.Type<typeof CartWebhookEventSchema>;
+
+const normalizeCartLineItem = (item: CartWebhookLineItem): CartLineItem => ({
+  id: String(item.id),
+  properties: item.properties,
+  quantity: item.quantity,
+  variantId: gid("ProductVariant", item.variant_id),
+  key: item.key,
+  discountedPrice: normalizeAmount(item.discounted_price),
+  discounts: item.discounts,
+  giftCard: item.gift_card,
+  grams: item.grams,
+  linePrice: normalizeAmount(item.line_price),
+  originalLinePrice: normalizeAmount(item.original_line_price),
+  originalPrice: normalizeAmount(item.original_price),
+  price: normalizeAmount(item.price),
+  productId: gid("Product", item.product_id),
+  sku: item.sku,
+  taxable: item.taxable,
+  title: item.title,
+  totalDiscount: normalizeAmount(item.total_discount),
+  vendor: item.vendor,
+  discountedPriceSet: fromRest.money(item.discounted_price_set),
+  linePriceSet: fromRest.money(item.line_price_set),
+  originalLinePriceSet: fromRest.money(item.original_line_price_set),
+  priceSet: fromRest.money(item.price_set),
+  totalDiscountSet: fromRest.money(item.total_discount_set),
+  parentRelationship: item.parent_relationship,
+});
+
+export const fromCartWebhook = (payload: CartWebhookEvent): Cart => ({
+  id: payload.id,
+  token: payload.token,
+  topic: payload.topic,
+  lineItems: payload.line_items.map(normalizeCartLineItem),
+  note: payload.note ?? "",
+  updatedAt: payload.updated_at,
+  createdAt: payload.created_at,
+});

package/src/resources/customers/graphql.ts

@@ -0,0 +1,175 @@
+import * as Schema from "effect/Schema";
+
+import {
+  AddressFields,
+  GraphQLAddressSchema,
+  connection,
+  emptyText,
+  fromGraphQL,
+  normalizeAmount,
+  pageQuery,
+} from "../shared";
+import {
+  ConsentCollectedFromSchema,
+  type Customer,
+  CustomerStateSchema,
+  EmailMarketingStateSchema,
+  MarketingOptInLevelSchema,
+  ProductSubscriberStatusSchema,
+  SmsMarketingStateSchema,
+} from "./row";
+
+const CustomerAddressNodeFields = `id ${AddressFields}`;
+
+export const CustomerFields = `
+  id
+  legacyResourceId
+  firstName
+  lastName
+  displayName
+  note
+  state
+  verifiedEmail
+  taxExempt
+  taxExemptions
+  tags
+  locale
+  numberOfOrders
+  amountSpent { amount currencyCode }
+  lastOrder { id }
+  productSubscriberStatus
+  dataSaleOptOut
+  defaultEmailAddress { emailAddress marketingState marketingOptInLevel marketingUpdatedAt }
+  defaultPhoneNumber { phoneNumber }
+  smsMarketingConsent { marketingState marketingOptInLevel consentUpdatedAt consentCollectedFrom }
+  defaultAddress { id }
+  addressesV2(first: 25) {
+    nodes { ${CustomerAddressNodeFields} }
+    pageInfo { hasNextPage endCursor }
+  }
+  createdAt
+  updatedAt
+`;
+
+export const CustomerAddressesQuery = `#graphql
+query AirfoilCustomerAddresses($id: ID!, $first: Int!, $after: String) {
+  node: customer(id: $id) {
+    connection: addressesV2(first: $first, after: $after) {
+      nodes { ${CustomerAddressNodeFields} }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+}
+`;
+
+export const CustomerByIdQuery = `#graphql
+query AirfoilCustomerById($id: ID!) {
+  customer(id: $id) { ${CustomerFields} }
+}
+`;
+
+const GraphQLCustomerAddressSchema = Schema.Struct({
+  id: Schema.String,
+  ...GraphQLAddressSchema.fields,
+});
+
+export const GraphQLCustomerAddressesSchema = connection(GraphQLCustomerAddressSchema);
+
+export const GraphQLCustomerNodeSchema = Schema.Struct({
+  id: Schema.String,
+  legacyResourceId: Schema.String,
+  firstName: Schema.NullOr(Schema.String),
+  lastName: Schema.NullOr(Schema.String),
+  displayName: Schema.String,
+  note: Schema.NullOr(Schema.String),
+  state: CustomerStateSchema,
+  verifiedEmail: Schema.Boolean,
+  taxExempt: Schema.Boolean,
+  taxExemptions: Schema.Array(Schema.String),
+  tags: Schema.Array(Schema.String),
+  locale: Schema.String,
+  numberOfOrders: Schema.NumberFromString,
+  amountSpent: Schema.Struct({ amount: Schema.String, currencyCode: Schema.String }),
+  lastOrder: Schema.NullOr(Schema.Struct({ id: Schema.String })),
+  productSubscriberStatus: ProductSubscriberStatusSchema,
+  dataSaleOptOut: Schema.Boolean,
+  defaultEmailAddress: Schema.NullOr(
+    Schema.Struct({
+      emailAddress: Schema.String,
+      marketingState: EmailMarketingStateSchema,
+      marketingOptInLevel: Schema.NullOr(MarketingOptInLevelSchema),
+      marketingUpdatedAt: Schema.NullOr(Schema.DateFromString),
+    }),
+  ),
+  defaultPhoneNumber: Schema.NullOr(Schema.Struct({ phoneNumber: Schema.String })),
+  smsMarketingConsent: Schema.NullOr(
+    Schema.Struct({
+      marketingState: SmsMarketingStateSchema,
+      marketingOptInLevel: MarketingOptInLevelSchema,
+      consentUpdatedAt: Schema.NullOr(Schema.DateFromString),
+      consentCollectedFrom: Schema.NullOr(ConsentCollectedFromSchema),
+    }),
+  ),
+  defaultAddress: Schema.NullOr(Schema.Struct({ id: Schema.String })),
+  addressesV2: GraphQLCustomerAddressesSchema,
+  createdAt: Schema.DateFromString,
+  updatedAt: Schema.DateFromString,
+});
+
+export type GraphQLCustomerNode = Schema.Schema.Type<typeof GraphQLCustomerNodeSchema>;
+
+export type GraphQLCustomerAddress = Schema.Schema.Type<typeof GraphQLCustomerAddressSchema>;
+
+const addressId = (value: string): string => value.replace(/\?.*$/, "");
+
+export const normalizeCustomerNode = (
+  node: GraphQLCustomerNode,
+  addresses: ReadonlyArray<GraphQLCustomerAddress>,
+): Customer => ({
+  id: node.id,
+  legacyResourceId: node.legacyResourceId,
+  firstName: emptyText(node.firstName),
+  lastName: emptyText(node.lastName),
+  displayName: node.displayName,
+  email: node.defaultEmailAddress?.emailAddress ?? "",
+  emailMarketingState: node.defaultEmailAddress?.marketingState ?? null,
+  emailMarketingOptInLevel: node.defaultEmailAddress?.marketingOptInLevel ?? null,
+  emailMarketingUpdatedAt: node.defaultEmailAddress?.marketingUpdatedAt ?? null,
+  phone: node.defaultPhoneNumber?.phoneNumber ?? "",
+  smsMarketingState: node.smsMarketingConsent?.marketingState ?? null,
+  smsMarketingOptInLevel: node.smsMarketingConsent?.marketingOptInLevel ?? null,
+  smsMarketingUpdatedAt: node.smsMarketingConsent?.consentUpdatedAt ?? null,
+  smsMarketingCollectedFrom: node.smsMarketingConsent?.consentCollectedFrom ?? null,
+  note: emptyText(node.note),
+  state: node.state,
+  verifiedEmail: node.verifiedEmail,
+  taxExempt: node.taxExempt,
+  taxExemptions: node.taxExemptions,
+  tags: node.tags,
+  locale: node.locale,
+  numberOfOrders: node.numberOfOrders,
+  amountSpent: {
+    amount: normalizeAmount(node.amountSpent.amount),
+    currencyCode: node.amountSpent.currencyCode,
+  },
+  lastOrderId: node.lastOrder?.id ?? "",
+  productSubscriberStatus: node.productSubscriberStatus,
+  dataSaleOptOut: node.dataSaleOptOut,
+  defaultAddressId: node.defaultAddress === null ? "" : addressId(node.defaultAddress.id),
+  addresses: addresses.map(({ id, ...value }) => ({
+    id: addressId(id),
+    ...fromGraphQL.address(value),
+  })),
+  createdAt: node.createdAt,
+  updatedAt: node.updatedAt,
+});
+
+export const CustomersQuery = pageQuery("AirfoilCustomers", "customers", CustomerFields);
+
+export const GraphQLCustomersDataSchema = Schema.Struct({
+  customers: connection(GraphQLCustomerNodeSchema),
+});
+
+export const GraphQLCustomerByIdDataSchema = Schema.Struct({
+  customer: Schema.NullOr(GraphQLCustomerNodeSchema),
+});

package/src/resources/customers/row.ts

@@ -0,0 +1,112 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import * as Schema from "effect/Schema";
+
+import { address, field } from "../shared";
+
+export const CustomerStateSchema = Schema.Literals(["DECLINED", "DISABLED", "ENABLED", "INVITED"]);
+
+export const EmailMarketingStateSchema = Schema.Literals([
+  "INVALID",
+  "NOT_SUBSCRIBED",
+  "PENDING",
+  "REDACTED",
+  "SUBSCRIBED",
+  "UNSUBSCRIBED",
+]);
+
+export const SmsMarketingStateSchema = Schema.Literals([
+  "NOT_SUBSCRIBED",
+  "PENDING",
+  "SUBSCRIBED",
+  "UNSUBSCRIBED",
+  "REDACTED",
+]);
+
+export const MarketingOptInLevelSchema = Schema.Literals([
+  "SINGLE_OPT_IN",
+  "CONFIRMED_OPT_IN",
+  "UNKNOWN",
+]);
+
+export const ConsentCollectedFromSchema = Schema.Literals(["SHOPIFY", "OTHER"]);
+
+export const ProductSubscriberStatusSchema = Schema.Literals([
+  "ACTIVE",
+  "CANCELLED",
+  "EXPIRED",
+  "FAILED",
+  "NEVER_SUBSCRIBED",
+  "PAUSED",
+]);
+
+export const CustomerAddressSchema = Schema.Struct({
+  id: Schema.String.pipe(field(121, "Unique address identifier.")),
+  ...address(121).fields,
+});
+
+export const CustomerSchema = Schema.Struct({
+  id: Schema.String.pipe(field(1, "Unique customer identifier.")),
+  legacyResourceId: Schema.String.pipe(field(2, "Numeric customer identifier stored as text.")),
+  firstName: Schema.NullOr(Schema.String).pipe(field(3, "First name.")),
+  lastName: Schema.NullOr(Schema.String).pipe(field(4, "Last name.")),
+  displayName: Schema.String.pipe(field(5, "Full name shown in Shopify.")),
+  email: Schema.NullOr(Schema.String).pipe(field(6, "Default email address.")),
+  emailMarketingState: Schema.NullOr(EmailMarketingStateSchema).pipe(
+    field(7, "Email marketing consent state."),
+  ),
+  emailMarketingOptInLevel: Schema.NullOr(MarketingOptInLevelSchema).pipe(
+    field(8, "Email marketing opt-in level."),
+  ),
+  emailMarketingUpdatedAt: Schema.NullOr(Schema.Date).pipe(
+    field(9, "Time when email marketing consent last changed."),
+  ),
+  phone: Schema.NullOr(Schema.String).pipe(field(10, "Default phone number.")),
+  smsMarketingState: Schema.NullOr(SmsMarketingStateSchema).pipe(
+    field(11, "SMS marketing consent state."),
+  ),
+  smsMarketingOptInLevel: Schema.NullOr(MarketingOptInLevelSchema).pipe(
+    field(12, "SMS marketing opt-in level."),
+  ),
+  smsMarketingUpdatedAt: Schema.NullOr(Schema.Date).pipe(
+    field(13, "Time when SMS marketing consent last changed."),
+  ),
+  smsMarketingCollectedFrom: Schema.NullOr(ConsentCollectedFromSchema).pipe(
+    field(14, "Where SMS marketing consent was collected."),
+  ),
+  note: Schema.NullOr(Schema.String).pipe(field(15, "Merchant note about the customer.")),
+  state: CustomerStateSchema.pipe(field(16, "Customer account state.")),
+  verifiedEmail: Schema.Boolean.pipe(field(17, "Whether the email address is verified.")),
+  taxExempt: Schema.Boolean.pipe(field(18, "Whether the customer is exempt from tax.")),
+  taxExemptions: Schema.Array(Schema.String.annotate({ fieldId: 100 })).pipe(
+    field(19, "Tax exemptions that apply to the customer."),
+  ),
+  tags: Schema.Array(Schema.String.annotate({ fieldId: 101 })).pipe(
+    field(20, "Tags added to the customer."),
+  ),
+  locale: Schema.NullOr(Schema.String).pipe(field(21, "Customer language.")),
+  numberOfOrders: Schema.Int.pipe(field(22, "Number of orders the customer placed.")),
+  amountSpent: Schema.Struct({
+    amount: Schema.String.pipe(field(111, "Amount spent.")),
+    currencyCode: Schema.String.pipe(field(112, "Shop currency code.")),
+  }).pipe(field(23, "Total amount spent in the shop currency.")),
+  lastOrderId: Schema.NullOr(Schema.String).pipe(field(24, "Most recent order identifier.")),
+  productSubscriberStatus: Schema.NullOr(ProductSubscriberStatusSchema).pipe(
+    field(25, "Subscription status for products."),
+  ),
+  dataSaleOptOut: Schema.NullOr(Schema.Boolean).pipe(
+    field(26, "Whether the customer opted out of data sale."),
+  ),
+  defaultAddressId: Schema.NullOr(Schema.String).pipe(field(27, "Default address identifier.")),
+  addresses: Schema.Array(CustomerAddressSchema.annotate({ fieldId: 120 })).pipe(
+    field(28, "Saved addresses."),
+  ),
+  createdAt: Schema.Date.pipe(field(29, "Time when the customer was created.")),
+  updatedAt: Schema.Date.pipe(field(30, "Time when the customer was last changed.")),
+  _deleted: Schema.optional(Schema.Boolean).pipe(field(31, "Whether the customer was deleted.")),
+})
+  .annotate({
+    description: "Customers in a Shopify store.",
+  })
+  .pipe(Iceberg.identifier("id"));
+
+export type Customer = Schema.Schema.Type<typeof CustomerSchema>;

package/src/resources/customers/webhook.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+
+// Customer webhooks leave fields out, so the handler reads the customer again.
+
+export const CustomerWebhookPayloadSchema = Schema.Struct({
+  admin_graphql_api_id: Schema.String,
+  updated_at: Schema.DateFromString,
+});
+
+export const CustomerPurchaseSummaryPayloadSchema = Schema.Struct({
+  customerId: Schema.String,
+  occurredAt: Schema.DateFromString,
+});
+
+export const CustomerEmailConsentPayloadSchema = Schema.Struct({ customer_id: Schema.Number });
+
+export const CustomerSmsConsentPayloadSchema = Schema.Struct({ id: Schema.Number });
+
+export const CustomerTagsPayloadSchema = Schema.Struct({
+  customerId: Schema.String,
+  occurredAt: Schema.DateFromString,
+});
+
+export const CustomerDeleteWebhookPayloadSchema = Schema.Struct({ id: Schema.Number });
+
+export const CustomerEventSchema = Schema.Struct({
+  _tag: Schema.Literals(["refresh", "delete"]),
+  id: Schema.String,
+  version: Schema.Date,
+});