@jarwizz/create-jarshop 0.1.1 → 0.1.2

package/dist/template/src/plugins/jarshop-checkout/jarshop-checkout.plugin.ts

@@ -0,0 +1,813 @@
+import { Args, Mutation, Resolver } from "@nestjs/graphql";
+import { Query } from "@nestjs/graphql";
+import { Inject, Injectable } from "@nestjs/common";
+import { Allow, Permission } from "@vendure/core";
+import { createHash } from "node:crypto";
+import { parse } from "graphql";
+import type { Repository } from "typeorm";
+import {
+  ActiveOrderService,
+  Ctx,
+  CustomerService,
+  isGraphQlErrorResult,
+  Order,
+  OrderService,
+  PluginCommonModule,
+  ProductVariantService,
+  RequestContext,
+  ShippingMethodService,
+  Transaction,
+  TransactionalConnection,
+  VendurePlugin,
+} from "@vendure/core";
+import { CheckoutAttempt } from "./checkout-attempt.entity.js";
+import { JarShopConfirmationToken } from "./confirmation-token.entity.js";
+import {
+  canUseConfirmationToken,
+  createConfirmationToken,
+  hashConfirmationToken,
+} from "./confirmation.js";
+import { JarShopLegalConfiguration } from "./legal.entity.js";
+import { JarShopOrderEmailDelivery } from "./order-email-delivery.entity.js";
+import {
+  isOrderAvailableInChannel,
+  toOrderEmailDeliveryStatus,
+} from "./order-email-delivery-status.js";
+import { createPendingOrderEmailDelivery } from "./order-email-outbox.js";
+import {
+  JarShopOrderEmailWorker,
+  registerJarShopOrderEmailWorkerTask,
+} from "./order-email-worker.js";
+import { JarShopOrderConsent } from "./order-consent.entity.js";
+import {
+  compareCheckoutSnapshot,
+  validateShippingSelection,
+  type CheckoutCartSnapshot,
+  type ShippingAddressInput,
+} from "./shipping.js";
+
+const schema = parse(`
+  input JarShopCustomerInput {
+    emailAddress: String!
+    firstName: String!
+    lastName: String!
+    phoneNumber: String!
+  }
+  input JarShopAddressInput {
+    streetLine1: String!
+    streetLine2: String
+    city: String!
+    postalCode: String!
+    countryCode: String!
+    company: String
+  }
+  input JarShopCartSnapshotLineInput {
+    lineId: ID!
+    quantity: Int!
+    linePriceWithTax: Int!
+  }
+  input JarShopCartSnapshotInput {
+    currencyCode: String!
+    subtotalWithTax: Int!
+    lines: [JarShopCartSnapshotLineInput!]!
+  }
+  input JarShopPlaceOrderInput {
+    attemptId: String!
+    marketCode: String!
+    languageCode: String!
+    currencyCode: String!
+    customer: JarShopCustomerInput!
+    shippingAddress: JarShopAddressInput
+    billingAddress: JarShopAddressInput
+    cartSnapshot: JarShopCartSnapshotInput
+    shippingMethodCode: String!
+    paymentMethodCode: String!
+    termsAccepted: Boolean!
+  }
+  type JarShopPlaceOrderResult {
+    success: Boolean!
+    order: Order
+    orderId: ID
+    orderCode: String
+    totalWithTax: Int
+    currencyCode: String
+    state: String!
+    errorCode: String
+    message: String
+    affectedLineIds: [ID!]!
+    confirmationToken: String
+  }
+  type JarShopLegalConfiguration {
+    languageCode: String!
+    termsVersion: String!
+    termsUrl: String!
+    privacyVersion: String!
+    privacyUrl: String!
+  }
+  type JarShopOrderConfirmation {
+    orderId: ID!
+    orderCode: String!
+    state: String!
+    totalWithTax: Int!
+    currencyCode: String!
+  }
+  input JarShopLegalConfigurationInput {
+    languageCode: String!
+    termsVersion: String!
+    termsUrl: String!
+    privacyVersion: String!
+    privacyUrl: String!
+  }
+  extend type Query {
+    jarShopLegalConfiguration(languageCode: String!): JarShopLegalConfiguration
+    jarShopOrderConfirmation(token: String!): JarShopOrderConfirmation
+  }
+  extend type Mutation {
+    placeJarShopOrder(input: JarShopPlaceOrderInput!): JarShopPlaceOrderResult!
+    updateJarShopLegalConfiguration(input: JarShopLegalConfigurationInput!): JarShopLegalConfiguration!
+  }
+`);
+
+const adminSchema = parse(`
+  type JarShopLegalConfiguration {
+    languageCode: String!
+    termsVersion: String!
+    termsUrl: String!
+    privacyVersion: String!
+    privacyUrl: String!
+  }
+  input JarShopLegalConfigurationInput {
+    languageCode: String!
+    termsVersion: String!
+    termsUrl: String!
+    privacyVersion: String!
+    privacyUrl: String!
+  }
+  type JarShopOrderEmailDeliveryStatus {
+    deliveryId: ID!
+    orderId: ID!
+    kind: String!
+    status: String!
+    attemptCount: Int!
+    nextAttemptAt: DateTime!
+    sentAt: DateTime
+    lastErrorCode: String
+  }
+  extend type Query {
+    jarShopLegalConfiguration(languageCode: String!): JarShopLegalConfiguration
+    jarShopOrderEmailDeliveryStatus(orderId: ID!): JarShopOrderEmailDeliveryStatus
+  }
+  extend type Mutation {
+    updateJarShopLegalConfiguration(input: JarShopLegalConfigurationInput!): JarShopLegalConfiguration!
+  }
+`);
+
+type PlaceOrderInput = {
+  attemptId: string;
+  marketCode: string;
+  languageCode: string;
+  currencyCode: string;
+  customer: {
+    emailAddress: string;
+    firstName: string;
+    lastName: string;
+    phoneNumber: string;
+  };
+  shippingAddress?: ShippingAddressInput;
+  billingAddress?: ShippingAddressInput;
+  cartSnapshot?: CheckoutCartSnapshot;
+  shippingMethodCode: string;
+  paymentMethodCode: string;
+  termsAccepted: boolean;
+};
+
+type LegalConfigurationInput = {
+  languageCode: string;
+  termsVersion: string;
+  termsUrl: string;
+  privacyVersion: string;
+  privacyUrl: string;
+};
+
+@Injectable()
+@Resolver()
+class JarShopCheckoutResolver {
+  constructor(
+    @Inject(ActiveOrderService)
+    private readonly activeOrderService: ActiveOrderService,
+    @Inject(OrderService)
+    private readonly orderService: OrderService,
+    @Inject(CustomerService)
+    private readonly customerService: CustomerService,
+    @Inject(ShippingMethodService)
+    private readonly shippingMethodService: ShippingMethodService,
+    @Inject(ProductVariantService)
+    private readonly productVariantService: ProductVariantService,
+    @Inject(TransactionalConnection)
+    private readonly connection: TransactionalConnection,
+  ) {}
+
+  @Query()
+  async jarShopLegalConfiguration(
+    @Ctx() ctx: RequestContext,
+    @Args("languageCode") languageCode: string,
+  ) {
+    const repository = this.connection.getRepository(
+      ctx,
+      JarShopLegalConfiguration,
+    );
+    const configuration = await repository.findOne({
+      where: { channelId: Number(ctx.channelId), languageCode },
+    });
+    return configuration ? toLegalConfiguration(configuration) : null;
+  }
+
+  @Query()
+  async jarShopOrderConfirmation(
+    @Ctx() ctx: RequestContext,
+    @Args("token") token: string,
+  ) {
+    const repository = this.connection.getRepository(
+      ctx,
+      JarShopConfirmationToken,
+    );
+    const record = await repository.findOne({
+      where: { tokenHash: hashConfirmationToken(token) },
+    });
+    if (!record || record.expiresAt.getTime() <= Date.now()) return null;
+    const cookie = ctx.req?.headers.cookie ?? "";
+    const exchanged = cookie.includes(`jarshop-confirmation=${token}`);
+    if (
+      !canUseConfirmationToken({
+        expiresAt: record.expiresAt,
+        consumedAt: record.consumedAt,
+        cookieMatches: exchanged,
+      })
+    ) {
+      return null;
+    }
+    if (!record.consumedAt) {
+      record.consumedAt = new Date();
+      await repository.save(record);
+    }
+    const order = await this.orderService.findOne(ctx, record.orderId);
+    return order
+      ? {
+          orderId: order.id,
+          orderCode: order.code,
+          state: order.state,
+          totalWithTax: order.totalWithTax,
+          currencyCode: order.currencyCode,
+        }
+      : null;
+  }
+
+  @Mutation()
+  @Allow(Permission.UpdateSettings)
+  async updateJarShopLegalConfiguration(
+    @Ctx() ctx: RequestContext,
+    @Args("input") input: LegalConfigurationInput,
+  ) {
+    validateLegalConfigurationInput(input);
+    const repository = this.connection.getRepository(
+      ctx,
+      JarShopLegalConfiguration,
+    );
+    let configuration = await repository.findOne({
+      where: {
+        channelId: Number(ctx.channelId),
+        languageCode: input.languageCode,
+      },
+    });
+    configuration ??= repository.create({
+      channelId: Number(ctx.channelId),
+      languageCode: input.languageCode,
+    });
+    Object.assign(configuration, input);
+    return toLegalConfiguration(await repository.save(configuration));
+  }
+
+  @Mutation()
+  @Transaction()
+  async placeJarShopOrder(
+    @Ctx() ctx: RequestContext,
+    @Args("input") input: PlaceOrderInput,
+  ) {
+    const repository = this.connection.getRepository(ctx, CheckoutAttempt);
+    const inputHash = createHash("sha256")
+      .update(JSON.stringify(input))
+      .digest("hex");
+
+    const existingAttempt = await repository.findOne({
+      where: { attemptId: input.attemptId },
+    });
+    const insertResult = await repository
+      .createQueryBuilder()
+      .insert()
+      .values({
+        attemptId: input.attemptId,
+        marketCode: input.marketCode,
+        languageCode: input.languageCode,
+        status: "processing",
+        inputHash,
+        orderId: null,
+        errorCode: null,
+      })
+      .returning(["id"])
+      .orIgnore()
+      .execute();
+    const inserted =
+      !existingAttempt &&
+      (Boolean(insertResult?.identifiers?.length) ||
+        insertResult?.raw?.rowCount === 1 ||
+        (Array.isArray(insertResult?.raw) && insertResult.raw.length > 0));
+
+    let attempt = await repository.findOne({
+      where: { attemptId: input.attemptId },
+    });
+    if (!attempt) {
+      return failure("TEMPORARY_FAILURE", "Checkout attempt is not available");
+    }
+    if (attempt.inputHash !== inputHash) {
+      return failure(
+        "IDEMPOTENCY_CONFLICT",
+        "attemptId was already used with different input",
+      );
+    }
+    if (attempt.status === "completed" && attempt.orderId) {
+      const order = await this.orderService.findOne(ctx, attempt.orderId);
+      return order
+        ? success(order)
+        : failure("TEMPORARY_FAILURE", "Completed order is not available");
+    }
+    if (!inserted && attempt.status === "processing") {
+      for (let index = 0; index < 20; index += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        attempt = await repository.findOne({
+          where: { attemptId: input.attemptId },
+        });
+        if (attempt?.status === "completed" && attempt.orderId) {
+          const order = await this.orderService.findOne(ctx, attempt.orderId);
+          if (order) return success(order);
+        }
+      }
+      if (attempt?.status === "processing") {
+        return failure(
+          "TEMPORARY_FAILURE",
+          "Checkout is already being processed",
+        );
+      }
+    }
+    if (!attempt) {
+      return failure("TEMPORARY_FAILURE", "Checkout attempt is not available");
+    }
+
+    const activeOrderReference = await this.activeOrderService.getActiveOrder(
+      ctx,
+      undefined,
+    );
+    const activeOrder = activeOrderReference
+      ? await this.orderService.findOne(ctx, activeOrderReference.id)
+      : null;
+    if (!activeOrder || !activeOrder.lines?.length) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "EMPTY_ORDER",
+        "Cart is empty",
+      );
+    }
+    if (!input.termsAccepted) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "TERMS_NOT_ACCEPTED",
+        "Terms must be accepted",
+      );
+    }
+    const legalRepository = this.connection.getRepository(
+      ctx,
+      JarShopLegalConfiguration,
+    );
+    const legalConfiguration = await legalRepository.findOne({
+      where: {
+        channelId: Number(ctx.channelId),
+        languageCode: input.languageCode,
+      },
+    });
+    if (!legalConfiguration) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "TERMS_NOT_ACCEPTED",
+        "Legal configuration is not available for this locale",
+      );
+    }
+    const shippingValidation = validateShippingSelection(input);
+    if (!shippingValidation.ok) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        shippingValidation.errorCode,
+        shippingValidation.message,
+      );
+    }
+    if (input.cartSnapshot) {
+      const actualSnapshot: CheckoutCartSnapshot = {
+        currencyCode: activeOrder.currencyCode,
+        subtotalWithTax: activeOrder.subTotalWithTax,
+        lines: activeOrder.lines.map((line) => ({
+          lineId: String(line.id),
+          quantity: line.quantity,
+          linePriceWithTax: line.discountedLinePriceWithTax,
+        })),
+      };
+      const snapshot = compareCheckoutSnapshot(
+        input.cartSnapshot,
+        actualSnapshot,
+      );
+      if (!snapshot.ok) {
+        return await this.failAttempt(
+          repository,
+          attempt,
+          snapshot.errorCode,
+          snapshot.errorCode === "PRICE_CHANGED"
+            ? "Cart prices changed; review the refreshed totals before retrying"
+            : "Some cart items are no longer available in the requested quantity",
+          snapshot.affectedLineIds,
+        );
+      }
+    }
+    for (const line of activeOrder.lines) {
+      const variant = await this.productVariantService.getVariantByOrderLineId(
+        ctx,
+        line.id,
+      );
+      const available = await this.productVariantService.getSaleableStockLevel(
+        ctx,
+        variant,
+      );
+      if (available < line.quantity) {
+        return await this.failAttempt(
+          repository,
+          attempt,
+          "INSUFFICIENT_STOCK",
+          "Some cart items are no longer available in the requested quantity",
+          [String(line.id)],
+        );
+      }
+    }
+    const customer = await this.customerService.createOrUpdate(
+      ctx,
+      input.customer,
+      true,
+    );
+    if (isGraphQlErrorResult(customer)) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "CUSTOMER_ACCOUNT_EXISTS",
+        "An account already exists for this email; please log in or reset the password",
+      );
+    }
+    await this.orderService.addCustomerToOrder(ctx, activeOrder.id, customer);
+    if (input.shippingAddress) {
+      await this.orderService.setShippingAddress(
+        ctx,
+        activeOrder.id,
+        input.shippingAddress,
+      );
+    }
+    if (input.billingAddress) {
+      await this.orderService.setBillingAddress(
+        ctx,
+        activeOrder.id,
+        input.billingAddress,
+      );
+    }
+    const shippingMethods =
+      await this.shippingMethodService.getActiveShippingMethods(ctx);
+    const shippingMethod = shippingMethods.find(
+      (method) => method.code === input.shippingMethodCode,
+    );
+    if (!shippingMethod) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "SHIPPING_METHOD_INELIGIBLE",
+        "Selected shipping method is not available",
+      );
+    }
+    const shippingResult = await this.orderService.setShippingMethod(
+      ctx,
+      activeOrder.id,
+      [shippingMethod.id],
+    );
+    if (isGraphQlErrorResult(shippingResult)) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "SHIPPING_METHOD_INELIGIBLE",
+        "Selected shipping method is not eligible",
+      );
+    }
+    const paymentState = await this.orderService.transitionToState(
+      ctx,
+      activeOrder.id,
+      "ArrangingPayment",
+    );
+    if (isGraphQlErrorResult(paymentState)) {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "ORDER_STATE_INVALID",
+        "Order is not ready for payment",
+      );
+    }
+    if (input.paymentMethodCode !== "cod") {
+      return await this.failAttempt(
+        repository,
+        attempt,
+        "PAYMENT_METHOD_INELIGIBLE",
+        "Only cash on delivery is available in this slice",
+      );
+    }
+    const paymentResult = await this.orderService.addPaymentToOrder(
+      ctx,
+      activeOrder.id,
+      {
+        method: "dummy-payment-method",
+        metadata: { attemptId: input.attemptId, method: "cod" },
+      },
+    );
+    if (isGraphQlErrorResult(paymentResult)) {
+      const paymentErrorCode = paymentResult.errorCode;
+      return await this.failAttempt(
+        repository,
+        attempt,
+        paymentErrorCode === "INSUFFICIENT_STOCK_ERROR"
+          ? "INSUFFICIENT_STOCK"
+          : "TEMPORARY_FAILURE",
+        paymentErrorCode === "INSUFFICIENT_STOCK_ERROR"
+          ? "Some cart items are no longer available in the requested quantity"
+          : "Payment could not be authorized",
+      );
+    }
+    const consentRepository = this.connection.getRepository(
+      ctx,
+      JarShopOrderConsent,
+    );
+    await consentRepository.save(
+      consentRepository.create({
+        orderId: Number(paymentResult.id),
+        termsVersion: legalConfiguration.termsVersion,
+        termsUrl: legalConfiguration.termsUrl,
+        privacyUrl: legalConfiguration.privacyUrl,
+        acceptedAt: new Date(),
+      }),
+    );
+    const confirmation = createConfirmationToken();
+    const tokenRepository = this.connection.getRepository(
+      ctx,
+      JarShopConfirmationToken,
+    );
+    await tokenRepository.save(
+      tokenRepository.create({
+        tokenHash: confirmation.tokenHash,
+        orderId: Number(paymentResult.id),
+        expiresAt: confirmation.expiresAt,
+        consumedAt: null,
+      }),
+    );
+    const emailDeliveryRepository = this.connection.getRepository(
+      ctx,
+      JarShopOrderEmailDelivery,
+    );
+    await emailDeliveryRepository.save(
+      emailDeliveryRepository.create(
+        createPendingOrderEmailDelivery({
+          orderId: Number(paymentResult.id),
+          checkoutAttemptId: attempt.attemptId,
+          languageCode: input.languageCode,
+          confirmationToken: confirmation.token,
+        }),
+      ),
+    );
+    attempt.status = "completed";
+    attempt.orderId = Number(paymentResult.id);
+    attempt.errorCode = null;
+    await repository.save(attempt);
+    const placedOrder = await this.orderService.findOne(ctx, paymentResult.id);
+    return placedOrder
+      ? success(
+          placedOrder,
+          activeOrder.totalWithTax,
+          activeOrder.currencyCode,
+          confirmation.token,
+        )
+      : success(
+          paymentResult,
+          activeOrder.totalWithTax,
+          activeOrder.currencyCode,
+          confirmation.token,
+        );
+  }
+
+  private async failAttempt(
+    repository: Repository<CheckoutAttempt>,
+    attempt: CheckoutAttempt,
+    code: string,
+    message: string,
+    affectedLineIds: readonly string[] = [],
+  ) {
+    attempt.status = "failed";
+    attempt.errorCode = code;
+    await repository.save(attempt);
+    return failure(code, message, affectedLineIds);
+  }
+}
+
+@Injectable()
+@Resolver()
+class JarShopLegalAdminResolver {
+  constructor(
+    @Inject(TransactionalConnection)
+    private readonly connection: TransactionalConnection,
+  ) {}
+
+  @Query()
+  async jarShopLegalConfiguration(
+    @Ctx() ctx: RequestContext,
+    @Args("languageCode") languageCode: string,
+  ) {
+    const repository = this.connection.getRepository(
+      ctx,
+      JarShopLegalConfiguration,
+    );
+    const configuration = await repository.findOne({
+      where: { channelId: Number(ctx.channelId), languageCode },
+    });
+    return configuration ? toLegalConfiguration(configuration) : null;
+  }
+
+  @Query()
+  @Allow(Permission.ReadOrder)
+  async jarShopOrderEmailDeliveryStatus(
+    @Ctx() ctx: RequestContext,
+    @Args("orderId") orderId: string,
+  ) {
+    const parsedOrderId = parsePositiveOrderId(orderId);
+    if (parsedOrderId === undefined) return null;
+
+    const order = await this.connection
+      .getRepository(ctx, Order)
+      .findOne({ where: { id: parsedOrderId }, relations: ["channels"] });
+    if (
+      !order ||
+      !isOrderAvailableInChannel(
+        order.channels.map((channel) => channel.id),
+        ctx.channelId,
+      )
+    ) {
+      return null;
+    }
+
+    const delivery = await this.connection
+      .getRepository(ctx, JarShopOrderEmailDelivery)
+      .findOne({ where: { orderId: parsedOrderId } });
+    return delivery ? toOrderEmailDeliveryStatus(delivery) : null;
+  }
+
+  @Mutation()
+  @Allow(Permission.UpdateSettings)
+  async updateJarShopLegalConfiguration(
+    @Ctx() ctx: RequestContext,
+    @Args("input") input: LegalConfigurationInput,
+  ) {
+    validateLegalConfigurationInput(input);
+    const repository = this.connection.getRepository(
+      ctx,
+      JarShopLegalConfiguration,
+    );
+    let configuration = await repository.findOne({
+      where: {
+        channelId: Number(ctx.channelId),
+        languageCode: input.languageCode,
+      },
+    });
+    configuration ??= repository.create({
+      channelId: Number(ctx.channelId),
+      languageCode: input.languageCode,
+    });
+    Object.assign(configuration, input);
+    return toLegalConfiguration(await repository.save(configuration));
+  }
+}
+
+type OrderResult = {
+  id: string | number;
+  code: string;
+  totalWithTax?: number | null;
+  currencyCode?: string | null;
+  state: string;
+};
+
+function success(
+  order: OrderResult,
+  totalWithTax?: number,
+  currencyCode?: string,
+  confirmationToken?: string,
+) {
+  return {
+    success: true,
+    order,
+    orderId: order.id,
+    orderCode: order.code,
+    totalWithTax: order.totalWithTax ?? totalWithTax ?? 0,
+    currencyCode: order.currencyCode ?? currencyCode ?? "EUR",
+    state: order.state,
+    errorCode: null,
+    message: null,
+    affectedLineIds: [],
+    confirmationToken: confirmationToken ?? null,
+  };
+}
+
+function failure(
+  errorCode: string,
+  message: string,
+  affectedLineIds: readonly string[] = [],
+) {
+  return {
+    success: false,
+    order: null,
+    orderId: null,
+    orderCode: null,
+    state: "Failed",
+    errorCode,
+    message,
+    affectedLineIds,
+    confirmationToken: null,
+  };
+}
+
+function validateLegalConfigurationInput(input: LegalConfigurationInput): void {
+  if (!/^(sk|en)$/.test(input.languageCode)) {
+    throw new Error("languageCode must be sk or en");
+  }
+  if (!input.termsVersion.trim() || !input.privacyVersion.trim()) {
+    throw new Error("legal document versions are required");
+  }
+  for (const value of [input.termsUrl, input.privacyUrl]) {
+    const url = new URL(value);
+    if (url.protocol !== "https:") {
+      throw new Error("legal document URLs must use HTTPS");
+    }
+  }
+}
+
+function parsePositiveOrderId(orderId: string): number | undefined {
+  const parsedOrderId = Number(orderId);
+  return Number.isSafeInteger(parsedOrderId) && parsedOrderId > 0
+    ? parsedOrderId
+    : undefined;
+}
+
+function toLegalConfiguration(configuration: JarShopLegalConfiguration) {
+  return {
+    languageCode: configuration.languageCode,
+    termsVersion: configuration.termsVersion,
+    termsUrl: configuration.termsUrl,
+    privacyVersion: configuration.privacyVersion,
+    privacyUrl: configuration.privacyUrl,
+  };
+}
+
+/**
+ * JarShop's server-owned checkout seam.
+ *
+ * The resolver keeps the public checkout contract small while Vendure remains
+ * the authority for order state, pricing, stock and payment transitions.
+ */
+@VendurePlugin({
+  dashboard: "./dashboard/index.tsx",
+  imports: [PluginCommonModule],
+  providers: [JarShopOrderEmailWorker],
+  configuration: registerJarShopOrderEmailWorkerTask,
+  entities: [
+    CheckoutAttempt,
+    JarShopConfirmationToken,
+    JarShopLegalConfiguration,
+    JarShopOrderEmailDelivery,
+    JarShopOrderConsent,
+  ],
+  shopApiExtensions: {
+    schema,
+    resolvers: [JarShopCheckoutResolver],
+  },
+  adminApiExtensions: {
+    schema: adminSchema,
+    resolvers: [JarShopLegalAdminResolver],
+  },
+})
+export class JarShopCheckoutPlugin {}