Integrate with Shopify

const SUBDOMAIN = process.env.MIGHTY_SUBDOMAIN;

let cached = { accessToken: null, expiresAt: 0 };
let refreshing = null;

export async function getAccessToken() {
  if (cached.accessToken && Date.now() < cached.expiresAt - 60_000) {
    return cached.accessToken;
  }

  // Refresh tokens rotate: the token you present is revoked as soon as it's
  // used. Share one in-flight refresh so concurrent callers don't each spend it.
  refreshing ??= refreshAccessToken().finally(() => {
    refreshing = null;
  });
  return refreshing;
}

async function refreshAccessToken() {
  const response = await fetch(`https://${SUBDOMAIN}.mn.co/oauth/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: await loadRefreshToken(), // from your encrypted store
      client_id: process.env.MIGHTY_CLIENT_ID,
      client_secret: process.env.MIGHTY_CLIENT_SECRET,
    }),
  });

  const token = await response.json();
  if (!response.ok) {
    // invalid_grant means a Host must run /mighty/connect again.
    throw new Error(`Mighty token refresh failed: ${token.error}`);
  }

  // Persist the rotated refresh token before handing out the new access token.
  if (token.refresh_token) await saveRefreshToken(token.refresh_token);
  cached = {
    accessToken: token.access_token,
    expiresAt: Date.now() + token.expires_in * 1000,
  };
  return cached.accessToken;
}

// Shopify product ID → Mighty access to grant
export const PRODUCT_ACCESS = {
  '8123456789012': { planId: 'UGF5bWVudFBsYW4tMTIz', memberType: 'LIMITED_MEMBER' },
  '8123456789013': { planId: 'UGF5bWVudFBsYW4tNDU2', memberType: 'FULL_MEMBER' },
};

export const CUSTOMER_TAG_ID = 'VGFnLTc4OQ=='; // optional

import crypto from 'node:crypto';
import express from 'express';
import { handleOrderPaid, handleRefund, handleOrderCancelled, NeedsReviewError } from './handlers.js';

const app = express();

function verifyShopify(req) {
  const received = Buffer.from(req.get('X-Shopify-Hmac-Sha256') ?? '', 'base64');
  const expected = crypto
    .createHmac('sha256', process.env.SHOPIFY_WEBHOOK_SECRET)
    .update(req.body) // raw Buffer, not parsed JSON
    .digest();
  return received.length === expected.length && crypto.timingSafeEqual(received, expected);
}

app.post('/shopify/webhooks', express.raw({ type: 'application/json' }), async (req, res) => {
  if (!verifyShopify(req)) return res.sendStatus(401);

  const topic = req.get('X-Shopify-Topic');
  const deliveryId = req.get('X-Shopify-Webhook-Id');
  const payload = JSON.parse(req.body.toString('utf8'));

  try {
    // Enqueueing is fast, so this still acknowledges well within Shopify's
    // timeout. Wait for it: a 200 you send before the job is queued can be
    // followed by a dropped job that Shopify never retries.
    await enqueue({ topic, deliveryId, payload }); // your job queue
    res.sendStatus(200);
  } catch (err) {
    console.error(err);
    res.sendStatus(500); // Shopify retries deliveries that don't get a 2xx.
  }
});

// Your queue worker
async function processJob({ topic, deliveryId, payload }) {
  if (await alreadyProcessed(deliveryId)) return;

  try {
    if (topic === 'orders/paid') await handleOrderPaid(payload);
    if (topic === 'refunds/create') await handleRefund(payload);
    if (topic === 'orders/cancelled') await handleOrderCancelled(payload);
  } catch (err) {
    if (err instanceof NeedsReviewError) {
      // Route to a person rather than retrying — retrying won't resolve it.
      await flagForReview({ topic, deliveryId, payload, reason: err.message });
    } else {
      throw err; // let your queue's retry policy handle transient failures
    }
  }

  await markProcessed(deliveryId);
}

import { getAccessToken } from './mighty-auth.js';

const ENDPOINT = `https://api.mn.co/networks/${process.env.MIGHTY_SUBDOMAIN}/graphql`;

export async function mighty(query, variables = {}) {
  const response = await fetch(ENDPOINT, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${await getAccessToken()}`,
      'Content-Type': 'application/json',
      'User-Agent': 'shopify-mighty-sync/1.0 (+https://integrations.example.com)',
    },
    body: JSON.stringify({ query, variables }),
  });

  const { data, errors } = await response.json();
  if (errors?.length) {
    const error = new Error(errors.map((e) => e.message).join('; '));
    error.codes = errors.map((e) => e.extensions?.code);
    throw error;
  }
  return data;
}

import { mighty } from './mighty.js';
import { PRODUCT_ACCESS, CUSTOMER_TAG_ID } from './config.js';

const MEMBER_BY_EMAIL = `
  query MemberByEmail($email: String!) {
    network { memberByEmail(email: $email) { id memberType } }
  }`;

const MEMBER_BY_ID = `
  query MemberById($id: ID!) {
    network { member(id: $id) { id memberType } }
  }`;

const CREATE_MEMBER = `
  mutation CreateMember($input: CreateMemberInput!) {
    createMember(input: $input) {
      member { id }
      errors
    }
  }`;

// Thrown for an order a person needs to look at instead of a retry fixing —
// for example, a member createMember can't find or create automatically.
export class NeedsReviewError extends Error {
  constructor(email, errors) {
    super(`Needs review (${email}): ${errors.join('; ')}`);
    this.name = 'NeedsReviewError';
  }
}

// Key saved member IDs by the Shopify customer ID when the order has one, or
// by normalized email otherwise. Some orders — draft orders, some POS sales —
// carry no customer object, so falling back to customer.id alone would key
// every one of those orders to the same undefined member.
function customerKey(customer) {
  if (customer?.id) return `shopify-customer:${customer.id}`;
  return `email:${customer?.email?.trim().toLowerCase()}`;
}

// A saved member ID's current member type, or null when they hold no current
// Network or Space membership. `member(id:)` raises NOT_FOUND for that case,
// same as for an ID it doesn't recognize at all.
async function currentMemberType(memberId) {
  try {
    const { network } = await mighty(MEMBER_BY_ID, { id: memberId });
    return network.member?.memberType ?? null;
  } catch (err) {
    if (err.codes?.includes('NOT_FOUND')) return null;
    throw err;
  }
}

// Returns the member's ID, their current member type, and the plan createMember
// granted, if any. `want.planId` is only used when creating a Limited Member.
async function findOrCreateMember(customer, want) {
  const key = customerKey(customer);
  const saved = await loadMemberId(key);
  if (saved) {
    // The member type only matters when the order needs a full member.
    if (want.memberType !== 'FULL_MEMBER') return { memberId: saved };

    const memberType = await currentMemberType(saved);
    if (memberType) return { memberId: saved, memberType };
    // No current Network or Space membership — for example, a removed full
    // member, or a Limited Member left with none after a refund. Fall through
    // to createMember below, which reuses this account and re-adds it.
  }

  if (!saved) {
    const { network } = await mighty(MEMBER_BY_EMAIL, { email: customer.email });
    if (network.memberByEmail) {
      await saveMemberId(key, network.memberByEmail.id);
      return { memberId: network.memberByEmail.id, memberType: network.memberByEmail.memberType };
    }
  }

  const limited = want.memberType === 'LIMITED_MEMBER';
  const { createMember } = await mighty(CREATE_MEMBER, {
    input: {
      email: customer.email,
      firstName: customer.first_name || 'Member',
      lastName: customer.last_name || '-',
      memberType: want.memberType,
      // A Limited Member receives the plan when created.
      planId: limited ? want.planId : undefined,
    },
  });

  if (createMember.errors.length) {
    // For example, "This person is already a member of this Network."
    throw new NeedsReviewError(customer.email, createMember.errors);
  }

  await saveMemberId(key, createMember.member.id);
  return {
    memberId: createMember.member.id,
    memberType: want.memberType,
    grantedPlanId: limited ? want.planId : undefined,
  };
}

const GRANT_PLAN = `
  mutation GrantPlan($input: CreatePaymentPlanMembershipInput!) {
    createPaymentPlanMembership(input: $input) {
      outcome
      errors
    }
  }`;

const TAG_MEMBER = `
  mutation TagMember($input: CreateTagMembershipsInput!) {
    createTagMemberships(input: $input) {
      outcome
      errors
    }
  }`;

export async function handleOrderPaid(order) {
  const customer = { ...order.customer, email: order.customer?.email ?? order.email };

  const grants = [];
  for (const item of order.line_items) {
    const access = PRODUCT_ACCESS[String(item.product_id)];
    if (!access) continue;

    // A retried orders/paid can arrive after refunds/create for the same
    // order. Don't re-grant a line item you've already revoked.
    if (await isLineItemRevoked(order.id, item.product_id)) continue;
    grants.push(access);
  }
  if (grants.length === 0) return;

  // Decide the member type once for the whole order, so the result doesn't
  // depend on line-item order: any FULL_MEMBER product makes a full member.
  const needsFull = grants.some((access) => access.memberType === 'FULL_MEMBER');
  const { memberId, memberType, grantedPlanId } = await findOrCreateMember(customer, {
    memberType: needsFull ? 'FULL_MEMBER' : 'LIMITED_MEMBER',
    planId: grants[0].planId,
  });

  for (const access of grants) {
    if (access.planId === grantedPlanId) continue; // createMember granted it
    const { createPaymentPlanMembership: grant } = await mighty(GRANT_PLAN, {
      input: { memberId, planId: access.planId },
    });
    if (grant.errors.length) throw new Error(grant.errors.join('; '));
    // outcome: SUBSCRIBED, or ALREADY_SUBSCRIBED on a retry
  }

  if (CUSTOMER_TAG_ID) {
    const { createTagMemberships: tag } = await mighty(TAG_MEMBER, {
      input: { tagId: CUSTOMER_TAG_ID, memberIds: [memberId] },
    });
    // SKIPPED_NO_MEMBERSHIP means the member holds no membership in the
    // Network or any of its Spaces — treat it as success, not an error.
    if (tag.errors.length) throw new Error(tag.errors.join('; '));
  }

  // The Mighty API has no mutation that promotes a Limited Member to a full
  // member. The plans are granted, so hand the promotion to a Host.
  if (needsFull && memberType === 'LIMITED_MEMBER') {
    throw new NeedsReviewError(customer.email, [
      'Limited Member bought a FULL_MEMBER product. Promote them to a full member in Network Admin.',
    ]);
  }
}

const REVOKE_PLAN = `
  mutation RevokePlan($input: DeletePaymentPlanMembershipInput!) {
    deletePaymentPlanMembership(input: $input) {
      outcome
      errors
    }
  }`;

async function revoke(orderId, customer, productIds) {
  const memberId = await loadMemberId(customerKey(customer));

  for (const productId of productIds) {
    const access = PRODUCT_ACCESS[String(productId)];
    if (!access) continue;

    // Record the line item as revoked even if there's no member yet, so a
    // late-arriving orders/paid for this order can't re-grant it.
    await markLineItemRevoked(orderId, productId);
    if (!memberId) continue;

    const { deletePaymentPlanMembership: result } = await mighty(REVOKE_PLAN, {
      input: { memberId, planId: access.planId },
    });
    if (result.errors.length) throw new Error(result.errors.join('; '));
    // outcome: REMOVED, or NOT_SUBSCRIBED if they no longer held it
  }
}

export async function handleRefund(refund) {
  const order = await loadOrder(refund.order_id); // from your records or the Shopify Admin API
  const customer = order.customer ?? { email: order.email };

  // Revoke a product only once every unit of it on the order is refunded.
  const fullyRefunded = [];
  for (const refundItem of refund.refund_line_items) {
    const productId = refundItem.line_item.product_id;
    if (!PRODUCT_ACCESS[String(productId)]) continue;

    // Keyed by the refund line item's ID, so a replayed delivery isn't counted twice.
    await recordRefundedQuantity(order.id, productId, refundItem.id, refundItem.quantity);
    const refunded = await totalRefundedQuantity(order.id, productId);
    const purchased = order.line_items
      .filter((item) => item.product_id === productId)
      .reduce((sum, item) => sum + item.quantity, 0);
    if (refunded >= purchased) fullyRefunded.push(productId);
  }

  await revoke(order.id, customer, fullyRefunded);
}

export async function handleOrderCancelled(order) {
  const customer = order.customer ?? { email: order.email };
  await revoke(order.id, customer, order.line_items.map((item) => item.product_id));
}