Merge pull request #119 from gadget-inc/usage-sub-ts

Usage sub TS migration

Author: DevAOC

shopify/usage-subscription-template/.gitignore

@@ -206,7 +206,8 @@ sketch
 # .pnp.*
 
 # Shopify
-shopify.app.toml
+extensions/**/dist
+extensions/**/node_modules
 
 # Miscellaneous
 .gadget/

shopify/usage-subscription-template/.ignore

@@ -1,5 +1,6 @@
 # Shopify
-shopify.app.toml
+extensions/**/dist
+extensions/**/node_modules
 
 # Miscellaneous
 **/.DS_*

shopify/usage-subscription-template/README-DEV.md

@@ -1,26 +1,21 @@
-import {
-  ActionOptions,
-  BillingPeriodTrackingGlobalActionContext,
-} from "gadget-server";
+import { ActionOptions } from "gadget-server";
 import { DateTime } from "luxon";
 
 /**
- * @param { BillingPeriodTrackingGlobalActionContext } context
- *
  * Features of this global action:
  * - Runs on a cron trigger (schedule) every 5 minutes
  * - Paginating to fetch all shops where the billingPeriodEnd date has passed
  * - Creates a usage charge for previous billing period overages
  * - Sets the shop billing period information to track the next period
  */
-export async function run({ params, logger, api, connections }) {
+export const run: ActionRun = async ({ params, logger, api, connections }) => {
   let shops = await api.shopifyShop.findMany({
     filter: {
       billingPeriodEnd: {
         lessThanOrEqual: new Date(),
       },
       state: {
-        inState: "installed",
+        inState: "created.installed",
       },
       planId: {
         isSet: true,
@@ -31,7 +26,6 @@ export async function run({ params, logger, api, connections }) {
       name: true,
       billingPeriodEnd: true,
       usagePlanId: true,
-      currency: true,
       overage: true,
       activeSubscriptionId: true,
       plan: {
@@ -46,21 +40,23 @@ export async function run({ params, logger, api, connections }) {
 
   while (shops.hasNextPage) {
     shops = await shops.nextPage();
-    allShops = allShops.concat(shops);
+    allShops.push(...shops);
   }
 
   for (const shop of allShops) {
+    if (!shop.name) continue;
+
     await api.enqueue(
       api.chargeShop,
       {
         shop: {
           id: shop.id,
-          currency: shop.currency,
           overage: shop.overage,
           activeSubscriptionId: shop.activeSubscriptionId,
           usagePlanId: shop.usagePlanId,
           plan: {
-            price: shop.plan.pricePerOrder,
+            price: shop?.plan?.pricePerOrder ?? 0,
+            currency: shop?.plan?.currency ?? "CAD",
           },
         },
       },
@@ -75,18 +71,21 @@ export async function run({ params, logger, api, connections }) {
 
     // Updating billing period information
     await api.internal.shopifyShop.update(shop.id, {
-      billingPeriodStart: DateTime.fromJSDate(new Date(shop.billingPeriodEnd))
+      billingPeriodStart: DateTime.fromJSDate(
+        new Date(shop.billingPeriodEnd ?? new Date())
+      )
         .plus({ milliseconds: 1 })
         .toJSDate(),
-      billingPeriodEnd: DateTime.fromJSDate(new Date(shop.billingPeriodEnd))
+      billingPeriodEnd: DateTime.fromJSDate(
+        new Date(shop.billingPeriodEnd ?? new Date())
+      )
         .plus({ days: 30 })
         .toJSDate(),
     });
   }
-}
+};
 
-/** @type { ActionOptions } */
-export const options = {
+export const options: ActionOptions = {
   timeoutMS: 900000,
   triggers: {
     api: true,

shopify/usage-subscription-template/api/actions/billingPeriodTracking.js renamed to shopify/usage-subscription-template/api/actions/billingPeriodTracking.ts

@@ -1,25 +1,45 @@
-import { ActionOptions, ChargeShopGlobalActionContext } from "gadget-server";
+import { ActionOptions } from "gadget-server";
 import { getCappedAmount } from "../../utilities";
-
-/**
- * @param { ChargeShopGlobalActionContext } context
- */
-export async function run({ params, logger, api, connections }) {
-  const { shop, order } = params;
+import type { SubscriptionLineItems } from "../models/shopifyShop/actions/subscribe";
+
+export const run: ActionRun = async ({ params, logger, api, connections }) => {
+  const {
+    shop,
+    order,
+  }: {
+    shop?: {
+      id?: string;
+      overage?: number;
+      activeSubscriptionId?: string;
+      usagePlanId?: string;
+      plan?: {
+        price?: number;
+        currency?: string;
+      };
+    };
+    order?: {
+      email?: string;
+    };
+  } = params;
+
+  if (!shop || !shop.id || !shop.activeSubscriptionId)
+    throw new Error("Missing required shop data");
 
   // Creating an instance of the Shopify Admin API
-  const shopify = await connections.shopify.forShopId(shop.id);
+  const shopify = await connections.shopify.forShopId(shop?.id);
 
   // Returning early if the shop is uninstalled and no Shopify instance is created
   if (!shopify)
     return logger.warn({
       message: "BILLING - Shop uninstalled",
-      shopId: shop.id,
+      shopId: shop?.id,
     });
 
   // Fetching the amount used in the period
-  const { amountUsedInPeriod } = await api.shopifyShop.findOne(shop.id, {
-    amountUsedInPeriod: true,
+  const { amountUsedInPeriod } = await api.shopifyShop.findOne(shop?.id, {
+    select: {
+      amountUsedInPeriod: true,
+    },
   });
 
   let remainder = 0;
@@ -37,31 +57,33 @@ export async function run({ params, logger, api, connections }) {
   if (!subscription)
     return logger.warn({
       message: "BILLING - No subscription found for the shop",
-      shopId: shop.id,
+      shopId: shop?.id,
     });
 
   // Pulling out the capped amount from the active subscription
-  const cappedAmount = getCappedAmount(subscription);
+  const cappedAmount = getCappedAmount(
+    subscription.lineItems as SubscriptionLineItems
+  );
 
   if (!cappedAmount)
     return logger.warn({
       message: "BILLING - No capped amount found for the shop",
-      shopId: shop.id,
+      shopId: shop?.id,
     });
 
   // Initially setting the price to the plan price and adding the overage amount if they exist
-  let price = shop.plan?.price + (shop.overage || 0) || 0;
+  let price = shop?.plan?.price ?? 0 + (shop?.overage ?? 0);
 
   // Returning early if the amount used in the period is greater than or equal to the capped amount
-  if (amountUsedInPeriod >= cappedAmount) {
+  if (amountUsedInPeriod && (amountUsedInPeriod as number) >= cappedAmount) {
     // Modifying the overage amount of the current shop
-    return await api.internal.shopifyShop.update(shop.id, {
+    return await api.internal.shopifyShop.update(shop?.id, {
       overage: price,
     });
   }
 
   // Calculating the available amount
-  const availableAmount = cappedAmount - amountUsedInPeriod;
+  const availableAmount = cappedAmount - ((amountUsedInPeriod as number) ?? 0);
 
   // Setting a remainder if the price is greater than the available amount
   if (price >= availableAmount) {
@@ -77,22 +99,21 @@ export async function run({ params, logger, api, connections }) {
           id
         }
         userErrors {
-          field
           message
         }
       }
     }`,
     {
-      description: shop.overage
-        ? `Charge of ${price} ${shop.currency} ${
-            order.email ? `for order placed by ${order.email}` : ""
+      description: shop?.overage
+        ? `Charge of ${price} ${shop?.plan?.currency} ${
+            order?.email ? `for order placed by ${order?.email}` : ""
           }, with overages from the previous billing period`
-        : `Charge of ${price} ${shop.currency} for order placed by ${order.email}`,
+        : `Charge of ${price} ${shop?.plan?.currency} for order placed by ${order?.email}`,
       price: {
         amount: price,
-        currencyCode: shop.currency,
+        currencyCode: shop?.plan?.currency,
       },
-      subscriptionLineItemId: shop.usagePlanId,
+      subscriptionLineItemId: shop?.usagePlanId,
     }
   );
 
@@ -104,21 +125,20 @@ export async function run({ params, logger, api, connections }) {
   await api.internal.usageRecord.create({
     id: result.appUsageRecordCreate.appUsageRecord.id.split("/")[4],
     price,
-    currency: shop.currency,
+    currency: shop?.plan?.currency,
     shop: {
-      _link: shop.id,
+      _link: shop?.id,
     },
   });
 
   // Updating the overage amount if there is a remainder
   if (remainder)
-    await api.internal.shopifyShop.update(shop.id, {
+    await api.internal.shopifyShop.update(shop?.id, {
       overage: remainder,
     });
-}
+};
 
-/** @type { ActionOptions } */
-export const options = {};
+export const options: ActionOptions = {};
 
 export const params = {
   shop: {
@@ -133,9 +153,6 @@ export const params = {
       usagePlanId: {
         type: "string",
       },
-      currency: {
-        type: "string",
-      },
       overage: {
         type: "number",
       },
@@ -145,6 +162,9 @@ export const params = {
           price: {
             type: "number",
           },
+          currency: {
+            type: "string",
+          },
         },
       },
     },