@develemit/commerce-server 0.4.0 → 0.6.0

package/dist/index.js

@@ -28,6 +28,9 @@ var InvalidCursorError = class extends Error {
   }
 };
 var PG_TIMESTAMP = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d+)?[+-]\d{2}(:?\d{2})?$/;
+function isCursorTimestamp(at) {
+  return PG_TIMESTAMP.test(at) || !Number.isNaN(Date.parse(at));
+}
 function encodeCursor({ at, key }) {
   return Buffer.from(`${at}|${key}`).toString("base64url");
 }
@@ -677,7 +680,7 @@ var adminPlugin = async (app, { db, currency, authorize, storage }) => {
       if (!part) throw new InvalidImageError("An image file is required");
       const bytes = await part.toBuffer();
       const fields = part.fields;
-      const alt = typeof fields.alt?.value === "string" ? fields.alt.value : void 0;
+      const alt = typeof fields.alt?.value === "string" ? productImagePatchSchema.parse({ alt: fields.alt.value }).alt : void 0;
       const product = await addProductImage(db, storage, req.params.id, {
         bytes,
         alt
@@ -1146,7 +1149,8 @@ function conditions(filter) {
     );
   }
   if (filter.after) {
-    const { createdAt, id } = filter.after;
+    const { id } = filter.after;
+    const createdAt = sql5`${filter.after.createdAt}::timestamptz`;
     parts.push(
       or3(
         lt2(orders.createdAt, createdAt),
@@ -1168,7 +1172,8 @@ async function selectOrderPage(db, filter) {
     totalCents: sql5`${orders.subtotalCents} - ${orders.discountCents} + ${orders.shippingCents}`,
     currency: orders.currency,
     itemCount,
-    createdAt: orders.createdAt
+    createdAt: orders.createdAt,
+    createdAtKey: sql5`${orders.createdAt}::text`
   }).from(orders).where(conditions(filter)).orderBy(desc(orders.createdAt), desc(orders.id)).limit(filter.limit);
 }
 async function findOrderRefunds(db, orderId) {
@@ -1385,9 +1390,9 @@ function isOrderId(value) {
 function decodeOrderCursor(raw) {
   const { at, key } = decodeCursor(
     raw,
-    (c) => isOrderId(c.key) && !Number.isNaN(+new Date(c.at))
+    (c) => isOrderId(c.key) && isCursorTimestamp(c.at)
   );
-  return { createdAt: new Date(at), id: key };
+  return { createdAt: at, id: key };
 }
 async function listAdminOrders(db, query) {
   const rows = await selectOrderPage(db, {
@@ -1400,8 +1405,16 @@ async function listAdminOrders(db, query) {
   const page = rows.slice(0, query.limit);
   const last = page[page.length - 1];
   return {
-    items: page.map((r) => ({ ...r, createdAt: r.createdAt.toISOString() })),
-    nextCursor: rows.length > query.limit && last ? encodeCursor({ at: last.createdAt.toISOString(), key: last.id }) : null
+    items: page.map((r) => ({
+      id: r.id,
+      status: r.status,
+      email: r.email,
+      totalCents: r.totalCents,
+      currency: r.currency,
+      itemCount: r.itemCount,
+      createdAt: r.createdAt.toISOString()
+    })),
+    nextCursor: rows.length > query.limit && last ? encodeCursor({ at: last.createdAtKey, key: last.id }) : null
   };
 }
 async function getAdminOrder(db, id) {
@@ -1565,7 +1578,8 @@ function listConditions(filter) {
   if (filter.status) parts.push(statusCondition(filter.status, filter.now));
   if (filter.q) parts.push(ilike3(discounts.code, `${escapeLike3(filter.q)}%`));
   if (filter.after) {
-    const { createdAt, id } = filter.after;
+    const { id } = filter.after;
+    const createdAt = sql8`${filter.after.createdAt}::timestamptz`;
     parts.push(
       or5(
         lt3(discounts.createdAt, createdAt),
@@ -1589,7 +1603,10 @@ var withCounts = {
   totalRedemptions: redemptionCount()
 };
 async function selectDiscountPage(db, filter) {
-  return db.select(withCounts).from(discounts).where(listConditions(filter)).orderBy(desc2(discounts.createdAt), desc2(discounts.id)).limit(filter.limit);
+  return db.select({
+    ...withCounts,
+    createdAtKey: sql8`${discounts.createdAt}::text`
+  }).from(discounts).where(listConditions(filter)).orderBy(desc2(discounts.createdAt), desc2(discounts.id)).limit(filter.limit);
 }
 async function findDiscountById(db, id, options = {}) {
   const query = db.select(withCounts).from(discounts).where(eq8(discounts.id, id));
@@ -2178,9 +2195,9 @@ function toDiscount(row) {
 function decodeDiscountCursor(raw) {
   const { at, key } = decodeCursor(
     raw,
-    (c) => isDiscountId(c.key) && !Number.isNaN(+new Date(c.at))
+    (c) => isDiscountId(c.key) && isCursorTimestamp(c.at)
   );
-  return { createdAt: new Date(at), id: key };
+  return { createdAt: at, id: key };
 }
 async function listAdminDiscounts(db, query, now = /* @__PURE__ */ new Date()) {
   const rows = await selectDiscountPage(db, {
@@ -2194,7 +2211,7 @@ async function listAdminDiscounts(db, query, now = /* @__PURE__ */ new Date()) {
   const last = page[page.length - 1];
   return {
     items: page.map(toDiscount),
-    nextCursor: rows.length > query.limit && last ? encodeCursor({ at: last.createdAt.toISOString(), key: last.id }) : null
+    nextCursor: rows.length > query.limit && last ? encodeCursor({ at: last.createdAtKey, key: last.id }) : null
   };
 }
 async function getAdminDiscount(db, id) {
@@ -2219,9 +2236,15 @@ async function createDiscount(db, input) {
   if (!id) throw new DiscountCodeTakenError(data.code);
   return getAdminDiscount(db, id);
 }
+function sameValue(a, b) {
+  if (typeof a === "string" && typeof b === "string") {
+    return a.toUpperCase() === b.toUpperCase();
+  }
+  return a === b;
+}
 function changedLockedFields(row, patch) {
   return LOCKED_AFTER_USE.filter(
-    (field) => patch[field] !== void 0 && patch[field] !== row[field]
+    (field) => patch[field] !== void 0 && !sameValue(patch[field], row[field])
   );
 }
 function assertCoherent(row, patch) {
@@ -2333,6 +2356,27 @@ var adminDiscountsPlugin = async (app, { db, authorize }) => {
   );
 };
 
+// src/orders/dev-checkout.ts
+function assertDevCheckoutAllowed() {
+  if (process.env.NODE_ENV === "production") {
+    throw new Error("devCheckout is not allowed when NODE_ENV=production");
+  }
+}
+var devCheckoutRoutes = async (app, { db, payment, urls, hooks }) => {
+  assertDevCheckoutAllowed();
+  app.get("/checkout/dev/:sessionId/complete", async (req, reply) => {
+    const { sessionId } = req.params;
+    if (!payment.sessions.some((s) => s.id === sessionId)) {
+      return reply.code(404).send({ error: "SESSION_NOT_FOUND" });
+    }
+    const expire = req.query.outcome === "expired";
+    const { rawBody, signature } = expire ? payment.expired(sessionId) : payment.completed(sessionId);
+    const event = await payment.verifyWebhook(rawBody, signature);
+    await handlePaymentEvent(db, event, hooks, req.log);
+    return reply.redirect(expire ? urls.cancel : urls.success(sessionId), 302);
+  });
+};
+
 // src/orders/routes.ts
 import {
   checkoutConflictSchema,
@@ -2597,6 +2641,119 @@ var ordersPlugin = async (app, { db, ...settings }) => {
   });
 };
 
+// src/payment/fake-gateway.ts
+import { createHmac, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
+function createFakeGateway({
+  secret = "fake-webhook-secret"
+} = {}) {
+  const sessions = [];
+  const refunds = [];
+  const refundCalls = [];
+  let pendingFailure;
+  let sessionUrl;
+  let pendingRefundFailure;
+  const hmac = (body) => createHmac("sha256", secret).update(body).digest("hex");
+  function sign(event) {
+    const rawBody = Buffer.from(JSON.stringify(event));
+    return { rawBody, signature: hmac(rawBody) };
+  }
+  return {
+    kind: "fake",
+    useSessionUrl(build) {
+      sessionUrl = build;
+    },
+    sessions,
+    refunds,
+    refundCalls,
+    async createCheckoutSession(input) {
+      if (pendingFailure) {
+        const err = pendingFailure;
+        pendingFailure = void 0;
+        throw err;
+      }
+      const id = `fake_cs_${randomUUID3()}`;
+      sessions.push({ ...input, id });
+      return {
+        id,
+        url: sessionUrl?.(id) ?? input.successUrl.replace(SESSION_ID_PLACEHOLDER, id)
+      };
+    },
+    async verifyWebhook(rawBody, signature) {
+      const expected = Buffer.from(hmac(rawBody));
+      const given = Buffer.from(signature ?? "");
+      if (given.length !== expected.length || !timingSafeEqual(given, expected)) {
+        throw new WebhookSignatureError();
+      }
+      return JSON.parse(rawBody.toString("utf8"));
+    },
+    async refund(input) {
+      refundCalls.push(input);
+      if (pendingRefundFailure) {
+        const err = pendingRefundFailure;
+        pendingRefundFailure = void 0;
+        throw err;
+      }
+      const prior = refunds.find(
+        (r) => r.idempotencyKey === input.idempotencyKey
+      );
+      if (prior) return { gatewayRefundId: prior.gatewayRefundId };
+      const gatewayRefundId = `fake_re_${refunds.length + 1}_${input.sessionId}`;
+      refunds.push({ ...input, gatewayRefundId });
+      return { gatewayRefundId };
+    },
+    failNextSession(error = new Error("Fake gateway failure")) {
+      pendingFailure = error;
+    },
+    failNextRefund(error = new RefundRejectedError("Fake refund failure")) {
+      pendingRefundFailure = error;
+    },
+    failNextRefundUncertain(error = new Error("Fake refund timeout")) {
+      pendingRefundFailure = error;
+    },
+    completed(sessionId, details = {}) {
+      return sign({
+        id: `fake_evt_${randomUUID3()}`,
+        type: "checkout.completed",
+        sessionId,
+        ...details
+      });
+    },
+    asyncPaid(sessionId) {
+      return sign({
+        id: `fake_evt_${randomUUID3()}`,
+        type: "checkout.async_paid",
+        sessionId
+      });
+    },
+    asyncFailed(sessionId) {
+      return sign({
+        id: `fake_evt_${randomUUID3()}`,
+        type: "checkout.async_failed",
+        sessionId
+      });
+    },
+    expired(sessionId) {
+      return sign({
+        id: `fake_evt_${randomUUID3()}`,
+        type: "checkout.expired",
+        sessionId
+      });
+    },
+    refunded(sessionId, refunds2) {
+      return sign({
+        id: `fake_evt_${randomUUID3()}`,
+        type: "payment.refunded",
+        sessionId,
+        refunds: refunds2
+      });
+    },
+    sign
+  };
+}
+function isFakeGateway(gateway) {
+  return gateway.kind === "fake";
+}
+
 // src/plugin.ts
 var commercePlugin = async (app, {
   db,
@@ -2607,7 +2764,8 @@ var commercePlugin = async (app, {
   hooks,
   admin,
   categoryLabels,
-  catalogCache
+  catalogCache,
+  devCheckout
 }) => {
   app.get("/health", async () => ({ status: "ok" }));
   await app.register(catalogPlugin, {
@@ -2633,6 +2791,16 @@ var commercePlugin = async (app, {
     shippingCountries,
     hooks
   });
+  if (devCheckout) {
+    assertDevCheckoutAllowed();
+    if (isFakeGateway(payment)) {
+      const apiUrl = typeof devCheckout === "object" ? devCheckout.apiUrl : "";
+      payment.useSessionUrl(
+        (id) => `${apiUrl ?? ""}${app.prefix}/checkout/dev/${id}/complete`
+      );
+      await app.register(devCheckoutRoutes, { db, payment, urls, hooks });
+    }
+  }
   if (admin) {
     await app.register(adminOrdersPlugin, {
       db,
@@ -2765,12 +2933,13 @@ async function refundedEvent(stripe, event) {
     refunds: refunds.filter((refund) => refund.status !== "failed").map(toRefundEvent)
   };
 }
-function createCoupon(stripe, { discount, currency }) {
+function createCoupon(stripe, { discount, currency, expiresAt }) {
   return stripe.coupons.create({
     amount_off: discount.amountCents,
     currency: currency.toLowerCase(),
     duration: "once",
     max_redemptions: 1,
+    redeem_by: Math.floor(expiresAt.getTime() / 1e3),
     name: discount.code
   });
 }
@@ -2868,111 +3037,6 @@ function createStripeGateway({
   };
 }
 
-// src/payment/fake-gateway.ts
-import { createHmac, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
-function createFakeGateway({
-  secret = "fake-webhook-secret"
-} = {}) {
-  const sessions = [];
-  const refunds = [];
-  const refundCalls = [];
-  let pendingFailure;
-  let pendingRefundFailure;
-  const hmac = (body) => createHmac("sha256", secret).update(body).digest("hex");
-  function sign(event) {
-    const rawBody = Buffer.from(JSON.stringify(event));
-    return { rawBody, signature: hmac(rawBody) };
-  }
-  return {
-    sessions,
-    refunds,
-    refundCalls,
-    async createCheckoutSession(input) {
-      if (pendingFailure) {
-        const err = pendingFailure;
-        pendingFailure = void 0;
-        throw err;
-      }
-      const id = `fake_cs_${randomUUID3()}`;
-      sessions.push({ ...input, id });
-      return {
-        id,
-        url: input.successUrl.replace(SESSION_ID_PLACEHOLDER, id)
-      };
-    },
-    async verifyWebhook(rawBody, signature) {
-      const expected = Buffer.from(hmac(rawBody));
-      const given = Buffer.from(signature ?? "");
-      if (given.length !== expected.length || !timingSafeEqual(given, expected)) {
-        throw new WebhookSignatureError();
-      }
-      return JSON.parse(rawBody.toString("utf8"));
-    },
-    async refund(input) {
-      refundCalls.push(input);
-      if (pendingRefundFailure) {
-        const err = pendingRefundFailure;
-        pendingRefundFailure = void 0;
-        throw err;
-      }
-      const prior = refunds.find(
-        (r) => r.idempotencyKey === input.idempotencyKey
-      );
-      if (prior) return { gatewayRefundId: prior.gatewayRefundId };
-      const gatewayRefundId = `fake_re_${refunds.length + 1}_${input.sessionId}`;
-      refunds.push({ ...input, gatewayRefundId });
-      return { gatewayRefundId };
-    },
-    failNextSession(error = new Error("Fake gateway failure")) {
-      pendingFailure = error;
-    },
-    failNextRefund(error = new RefundRejectedError("Fake refund failure")) {
-      pendingRefundFailure = error;
-    },
-    failNextRefundUncertain(error = new Error("Fake refund timeout")) {
-      pendingRefundFailure = error;
-    },
-    completed(sessionId, details = {}) {
-      return sign({
-        id: `fake_evt_${randomUUID3()}`,
-        type: "checkout.completed",
-        sessionId,
-        ...details
-      });
-    },
-    asyncPaid(sessionId) {
-      return sign({
-        id: `fake_evt_${randomUUID3()}`,
-        type: "checkout.async_paid",
-        sessionId
-      });
-    },
-    asyncFailed(sessionId) {
-      return sign({
-        id: `fake_evt_${randomUUID3()}`,
-        type: "checkout.async_failed",
-        sessionId
-      });
-    },
-    expired(sessionId) {
-      return sign({
-        id: `fake_evt_${randomUUID3()}`,
-        type: "checkout.expired",
-        sessionId
-      });
-    },
-    refunded(sessionId, refunds2) {
-      return sign({
-        id: `fake_evt_${randomUUID3()}`,
-        type: "payment.refunded",
-        sessionId,
-        refunds: refunds2
-      });
-    },
-    sign
-  };
-}
-
 // src/hold-sweeper.ts
 async function sweepExpiredHolds(db) {
   await db.transaction(async (tx) => {
@@ -2987,6 +3051,89 @@ function startHoldSweeper(db, { intervalMs = 6e4, onError } = {}) {
   return { stop: () => clearInterval(timer) };
 }
 
+// src/emails/order-lines.ts
+var defaultLabels = {
+  subtotal: "Subtotal",
+  discount: (code) => code ? `Discount (${code})` : "Discount",
+  shipping: (label) => label ? `Shipping (${label})` : "Shipping",
+  total: "Total"
+};
+var escapes = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => escapes[c]);
+}
+function addressLines(order) {
+  const a = order.shippingAddress;
+  if (!a) return void 0;
+  const lines = [
+    a.name,
+    a.line1,
+    a.line2,
+    [a.city, a.state, a.postalCode].filter(Boolean).join(" "),
+    a.country
+  ].filter((l) => Boolean(l));
+  return lines.length ? lines : void 0;
+}
+function textBlock(lines) {
+  return lines.map((l) => `${l.label}  ${l.amount}`).join("\n");
+}
+function htmlRows(lines) {
+  return lines.map(
+    (l) => `<tr><td>${escapeHtml(l.label)}</td><td align="right">${escapeHtml(l.amount)}</td></tr>`
+  ).join("");
+}
+function orderEmailLines(order, options = {}) {
+  const locale = options.locale ?? "en-US";
+  const labels = { ...defaultLabels, ...options.labels };
+  const money = (cents) => new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: order.currency
+  }).format(cents / 100);
+  const items = order.items.map((i) => ({
+    label: `${i.name} \xD7 ${i.quantity}`,
+    amount: money(i.priceCents * i.quantity)
+  }));
+  const subtotal = {
+    label: labels.subtotal,
+    amount: money(order.subtotalCents)
+  };
+  const discount = order.discountCents > 0 ? {
+    label: labels.discount(order.discountCode),
+    amount: `-${money(order.discountCents)}`
+  } : void 0;
+  const shipping = {
+    label: labels.shipping(order.shippingLabel),
+    amount: money(order.shippingCents)
+  };
+  const total = { label: labels.total, amount: money(order.totalCents) };
+  const address = addressLines(order);
+  const totals = [subtotal, ...discount ? [discount] : [], shipping, total];
+  return {
+    items,
+    subtotal,
+    discount,
+    shipping,
+    total,
+    address,
+    text: {
+      items: textBlock(items),
+      totals: textBlock(totals),
+      address: address?.join("\n") ?? ""
+    },
+    html: {
+      items: htmlRows(items),
+      totals: htmlRows(totals),
+      address: address?.map((l) => `<p>${escapeHtml(l)}</p>`).join("") ?? ""
+    }
+  };
+}
+
 // src/db/migrate.ts
 import path from "path";
 import { fileURLToPath } from "url";
@@ -3064,17 +3211,132 @@ function createMemoryStorage(baseUrl = "memory://") {
     }
   };
 }
+
+// src/storage/disk.ts
+import { createReadStream, createWriteStream } from "fs";
+import { mkdir, realpath, rm, stat } from "fs/promises";
+import path2 from "path";
+import { pipeline } from "stream/promises";
+var contentTypes = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".avif": "image/avif"
+};
+function hasTraversalSegment(key) {
+  return key.split(/[\\/]/).some((segment) => segment === "..");
+}
+function decodesToTraversal(key) {
+  try {
+    return hasTraversalSegment(decodeURIComponent(key));
+  } catch {
+    return true;
+  }
+}
+function isInside(root, target) {
+  return target.startsWith(root + path2.sep);
+}
+function resolveKey(dir, key) {
+  if (!key || key.includes("\0") || path2.isAbsolute(key)) return null;
+  if (hasTraversalSegment(key) || decodesToTraversal(key)) return null;
+  const root = path2.resolve(dir);
+  const target = path2.resolve(root, key);
+  return isInside(root, target) ? target : null;
+}
+async function realInside(dir, target) {
+  const [root, real] = await Promise.all([
+    realpath(dir),
+    realpath(target)
+  ]).catch(() => [null, null]);
+  return root && real && isInside(root, real) ? real : null;
+}
+function createDiskStorage(options) {
+  const { dir, publicUrl } = options;
+  const base = publicUrl.replace(/\/+$/, "");
+  return {
+    async put(key, stream) {
+      const target = resolveKey(dir, key);
+      if (!target)
+        throw new Error(`Invalid storage key: ${JSON.stringify(key)}`);
+      await mkdir(path2.dirname(target), { recursive: true });
+      if (!await realInside(dir, path2.dirname(target)).catch(() => null)) {
+        throw new Error(`Invalid storage key: ${JSON.stringify(key)}`);
+      }
+      await pipeline(stream, createWriteStream(target));
+      return { key, url: `${base}/${key}` };
+    },
+    async delete(key) {
+      const target = resolveKey(dir, key);
+      if (!target)
+        throw new Error(`Invalid storage key: ${JSON.stringify(key)}`);
+      if (!await realInside(dir, path2.dirname(target)).catch(() => null))
+        return;
+      await rm(target, { force: true });
+    }
+  };
+}
+async function openStoredFile(dir, key) {
+  const target = resolveKey(dir, key);
+  if (!target) return null;
+  const real = await realInside(dir, target);
+  if (!real) return null;
+  const info = await stat(real).catch(() => null);
+  if (!info?.isFile()) return null;
+  const contentType = contentTypes[path2.extname(real).toLowerCase()];
+  return { stream: createReadStream(real), contentType, size: info.size };
+}
+
+// src/payment/resolve.ts
+function resolvePayment(env = process.env) {
+  const secretKey = env.STRIPE_SECRET_KEY || void 0;
+  const webhookSecret = env.STRIPE_WEBHOOK_SECRET || void 0;
+  if (!secretKey !== !webhookSecret) {
+    throw new Error(
+      "Set STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET together, or neither"
+    );
+  }
+  if (env.PAYMENT_GATEWAY === "stripe" && !secretKey) {
+    throw new Error("PAYMENT_GATEWAY=stripe needs the Stripe keys");
+  }
+  if (env.PAYMENT_GATEWAY === "fake" || !secretKey) {
+    if (env.NODE_ENV === "production") {
+      throw new Error(
+        "The fake payment gateway is not allowed in production; set the Stripe keys"
+      );
+    }
+    return createFakeGateway();
+  }
+  return createStripeGateway({ secretKey, webhookSecret });
+}
+function checkoutUrls(webUrl, {
+  successPath = "/checkout/success",
+  cancelPath = "/shop"
+} = {}) {
+  const base = webUrl.replace(/\/+$/, "");
+  return {
+    success: (sessionId) => `${base}${successPath}?session_id=${encodeURIComponent(sessionId)}`,
+    cancel: `${base}${cancelPath}`
+  };
+}
 export {
   ProductNotFoundError,
   SESSION_ID_PLACEHOLDER,
   WebhookSignatureError,
   catalogPlugin,
+  checkoutUrls,
   commercePlugin,
   commerceSchema,
+  createDiskStorage,
   createFakeGateway,
   createMemoryStorage,
   createStripeGateway,
+  isFakeGateway,
+  openStoredFile,
+  orderEmailLines,
   ordersPlugin,
+  resolvePayment,
   runCommerceMigrations,
   seedProducts,
   seedShippingRates,