@easypayment/medusa-paypal 0.2.6 → 0.2.8

package/src/api/store/paypal/create-order/route.ts

@@ -5,6 +5,7 @@ import {
   assertPayPalCurrencySupported,
   normalizeCurrencyCode,
 } from "../../../../modules/paypal/utils/currencies"
+import { getPayPalAccessToken } from "../../../../modules/paypal/utils/paypal-auth"
 import type PayPalModuleService from "../../../../modules/paypal/service"
 import { isPayPalProviderId } from "../../../../modules/paypal/utils/provider-ids"
 
@@ -12,38 +13,6 @@ type Body = {
   cart_id: string
 }
 
-async function getPayPalApiBase(environment: string) {
-  return environment === "live"
-    ? "https://api-m.paypal.com"
-    : "https://api-m.sandbox.paypal.com"
-}
-
-async function getPayPalAccessToken(opts: {
-  environment: string
-  client_id: string
-  client_secret: string
-}) {
-  const base = await getPayPalApiBase(opts.environment)
-  const auth = Buffer.from(`${opts.client_id}:${opts.client_secret}`).toString("base64")
-
-  const resp = await fetch(`${base}/v1/oauth2/token`, {
-    method: "POST",
-    headers: {
-      Authorization: `Basic ${auth}`,
-      "Content-Type": "application/x-www-form-urlencoded",
-    },
-    body: "grant_type=client_credentials",
-  })
-
-  const text = await resp.text()
-  if (!resp.ok) {
-    throw new Error(`PayPal token error (${resp.status}): ${text}`)
-  }
-
-  const json = JSON.parse(text)
-  return { accessToken: String(json.access_token), base }
-}
-
 function resolveIdempotencyKey(req: MedusaRequest, suffix: string, fallback: string) {
   const header =
     req.headers["idempotency-key"] ||
@@ -78,6 +47,7 @@ async function attachPayPalOrderToSession(
     }
 
     await paymentSessionService.update(paypalSession.id, {
+      amount: paypalSession.amount,
       data: {
         ...(paypalSession.data || {}),
         paypal: {

package/src/api/store/paypal/settings/route.ts

@@ -5,7 +5,14 @@ export async function GET(req: MedusaRequest, res: MedusaResponse) {
   const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
   try {
     const settings = await paypal.getSettings()
-    return res.json(settings)
+    const data = (settings?.data || {}) as Record<string, any>
+    const additionalSettings = (data.additional_settings || {}) as Record<string, any>
+    const advancedCard = (data.advanced_card_payments || {}) as Record<string, any>
+
+    return res.json({
+      paymentAction: additionalSettings.paymentAction === "authorize" ? "authorize" : "capture",
+      advancedCardEnabled: advancedCard.enabled === true,
+    })
   } catch (e: any) {
     return res.status(500).json({ message: e?.message || "Failed to load PayPal settings" })
   }

package/src/api/store/paypal-complete/route.ts

@@ -1,65 +1,76 @@
-import type { MedusaRequest, MedusaResponse } from "@medusajs/framework"
-import { Pool } from "pg"
-
-/**
- * POST /store/paypal-complete
- * Body: { cart_id, order_id, capture_id }
- *
- * Directly sets the PayPal payment session to "authorized" in the DB.
- * The frontend then calls placeOrder() which handles cart completion + redirect.
- */
-export async function POST(req: MedusaRequest, res: MedusaResponse) {
-  const { cart_id, order_id, capture_id } = req.body as {
-    cart_id?: string
-    order_id?: string
-    capture_id?: string
-  }
-
-  if (!cart_id) {
-    return res.status(400).json({ error: "cart_id is required" })
-  }
-
-  const pool = new Pool({ connectionString: process.env.DATABASE_URL })
-
-  try {
-    const { rows } = await pool.query(
-      `UPDATE payment_session
-       SET status = 'authorized',
-           data   = data || $1::jsonb
-       WHERE id = (
-         SELECT ps.id
-         FROM payment_session ps
-         JOIN payment_collection pc ON ps.payment_collection_id = pc.id
-         JOIN cart_payment_collection cpc ON cpc.payment_collection_id = pc.id
-         WHERE cpc.cart_id = $2
-           AND ps.provider_id LIKE '%paypal%'
-         ORDER BY ps.created_at DESC
-         LIMIT 1
-       )
-       RETURNING id, status`,
-      [
-        JSON.stringify({
-          paypal: {
-            order_id: order_id ?? null,
-            capture_id: capture_id ?? null,
-          },
-          authorized_at: new Date().toISOString(),
-        }),
-        cart_id,
-      ]
-    )
-
-    console.log("[paypal-complete] session authorized:", rows)
-
-    if (!rows.length) {
-      return res.status(400).json({ error: "No PayPal payment session found for cart" })
-    }
-
-    return res.json({ success: true, session_id: rows[0].id })
-  } catch (e: any) {
-    console.error("[paypal-complete] error:", e?.message || e)
-    return res.status(500).json({ error: e?.message || "Internal error" })
-  } finally {
-    await pool.end()
-  }
-}
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type { IPaymentModuleService } from "@medusajs/framework/types"
+import { Modules } from "@medusajs/framework/utils"
+import type PayPalModuleService from "../../../modules/paypal/service"
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const { cart_id } = req.body as { cart_id: string }
+
+  if (!cart_id) {
+    return res.status(400).json({ error: "cart_id is required" })
+  }
+
+  try {
+    // Step 1 — read paymentAction from DB settings (same pattern as capture-order)
+    const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+    const settings = await paypal.getSettings().catch(() => ({}))
+    const settingsData =
+      settings && typeof settings === "object" && "data" in settings
+        ? ((settings as { data?: Record<string, any> }).data ?? {})
+        : {}
+    const additionalSettings = (settingsData.additional_settings || {}) as Record<string, any>
+    const paymentAction =
+      typeof additionalSettings.paymentAction === "string"
+        ? additionalSettings.paymentAction
+        : "capture"
+
+    // "authorize" mode → session status = "authorized"
+    // "capture" mode  → session status = "captured"
+    const sessionStatus = paymentAction === "authorize" ? "authorized" : "captured"
+    const timestampKey = paymentAction === "authorize" ? "authorized_at" : "captured_at"
+
+    // Step 2 — find the PayPal session for this cart
+    const query = req.scope.resolve("query")
+    const { data: carts } = await query.graph({
+      entity: "cart",
+      fields: [
+        "id",
+        "payment_collection.payment_sessions.id",
+        "payment_collection.payment_sessions.data",
+        "payment_collection.payment_sessions.provider_id",
+        "payment_collection.payment_sessions.created_at",
+        "payment_collection.payment_sessions.amount",  
+        "payment_collection.payment_sessions.currency_code",
+      ],
+      filters: { id: cart_id },
+    })
+
+    const sessions = carts?.[0]?.payment_collection?.payment_sessions || []
+    const session = sessions
+      .filter((s: any) => String(s.provider_id || "").includes("paypal"))
+      .sort(
+        (a: any, b: any) =>
+          new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime()
+      )[0]
+
+    if (!session) {
+      return res.status(400).json({ error: "No PayPal payment session found for cart" })
+    }
+
+    // Step 3 — update session with correct status + amount
+    const paymentModule = req.scope.resolve(Modules.PAYMENT) as IPaymentModuleService
+    await (paymentModule as any).updatePaymentSession({
+      id: session.id,
+      data: { ...(session.data || {}), [timestampKey]: new Date().toISOString() },
+      status: sessionStatus as any,
+      amount: session.amount, 
+      currency_code: session.currency_code,
+    })
+
+    console.log(`[paypal-complete] session ${sessionStatus}:`, session.id)
+    return res.json({ success: true, session_id: session.id })
+  } catch (e: any) {
+    console.error("[paypal-complete] error:", e?.message || e)
+    return res.status(500).json({ error: e?.message || "Internal error" })
+  }
+}

package/src/jobs/paypal-reconcile.ts

@@ -1,5 +1,8 @@
 import type { MedusaContainer } from "@medusajs/framework/types"
+import { Modules } from "@medusajs/framework/utils"
 import type PayPalModuleService from "../modules/paypal/service"
+import { PAYPAL_MODULE } from "../modules/paypal"
+import { PAYPAL_PROVIDER_IDS } from "../modules/paypal/utils/provider-ids"
 
 const STATUS_MAP: Record<string, "pending" | "authorized" | "captured" | "canceled"> = {
   CREATED: "pending",
@@ -10,11 +13,20 @@ const STATUS_MAP: Record<string, "pending" | "authorized" | "captured" | "cancel
 }
 
 export default async function paypalReconcile(container: MedusaContainer) {
-  const paymentSessionService = container.resolve("payment_session") as any
-  const paypal = container.resolve<PayPalModuleService>("paypal_onboarding")
+  // FIX 3a: was container.resolve("payment_session") as any
+  // Modules.PAYMENT is the official typed constant for the Medusa payment module.
+  // listPaymentSessions and updatePaymentSession are methods on the payment module service.
+  const paymentModule = container.resolve(Modules.PAYMENT) as any
 
-  const sessions = await paymentSessionService.list({
-    provider_id: ["pp_paypal_paypal", "pp_paypal_card_paypal_card"],
+  // FIX 3b: was container.resolve<PayPalModuleService>("paypal_onboarding")
+  // PAYPAL_MODULE is the exported constant from modules/paypal/index.ts
+  const paypal = container.resolve<PayPalModuleService>(PAYPAL_MODULE)
+
+  // FIX 3c: was ["pp_paypal_paypal", "pp_paypal_card_paypal_card"]
+  // PAYPAL_PROVIDER_IDS is the exported array from modules/paypal/utils/provider-ids.ts
+  // If the provider IDs ever change in one place, this file updates automatically.
+  const sessions = await paymentModule.listPaymentSessions({
+    provider_id: [...PAYPAL_PROVIDER_IDS],
     status: ["pending", "authorized"],
   })
 
@@ -66,8 +78,11 @@ export default async function paypalReconcile(container: MedusaContainer) {
         })
       }
 
-      await paymentSessionService.update(session.id, {
+      // FIX 3d: was paymentSessionService.update(session.id, { ... })
+      // updatePaymentSession is the correct method name on the payment module service.
+      await paymentModule.updatePaymentSession(session.id, {
         status,
+        amount: session.amount,
         data: {
           ...(session.data || {}),
           paypal: {
@@ -132,4 +147,4 @@ export default async function paypalReconcile(container: MedusaContainer) {
 export const config = {
   name: "paypal-reconcile",
   schedule: "*/15 * * * *",
-}
+}

package/src/modules/paypal/payment-provider/card-service.ts

@@ -56,11 +56,36 @@ class PayPalAdvancedCardProvider extends AbstractPaymentProvider<Options> {
     const container = this.container as {
       resolve<T>(key: string): T
     }
-    return container.resolve<PayPalModuleService>("paypal_onboarding")
+    try {
+      return container.resolve<PayPalModuleService>("paypal_onboarding")
+    } catch {
+      return null as any
+    }
   }
 
   private async resolveSettings() {
     const paypal = this.resolvePayPalService()
+    if (!paypal) {
+      try {
+        const { Pool: _SettingsPool } = require("pg")
+        const _sPool = new _SettingsPool({ connectionString: process.env.DATABASE_URL })
+        const _sResult = await _sPool
+          .query("SELECT data FROM paypal_settings ORDER BY created_at DESC LIMIT 1")
+          .finally(() => _sPool.end())
+        const _sData = _sResult.rows[0]?.data || {}
+        return {
+          additionalSettings: (_sData.additional_settings || {}) as Record<string, any>,
+          advancedCardSettings: (_sData.advanced_card_payments || {}) as Record<string, any>,
+          apiDetails: (_sData.api_details || {}) as Record<string, any>,
+        }
+      } catch {
+        return {
+          additionalSettings: {} as Record<string, any>,
+          advancedCardSettings: {} as Record<string, any>,
+          apiDetails: {} as Record<string, any>,
+        }
+      }
+    }
     const settings = await paypal.getSettings().catch(() => ({}))
     const data =
       settings && typeof settings === "object" && "data" in settings
@@ -83,12 +108,37 @@ class PayPalAdvancedCardProvider extends AbstractPaymentProvider<Options> {
 
   private async getPayPalAccessToken() {
     const paypal = this.resolvePayPalService()
-    const creds = await paypal.getActiveCredentials()
+    let client_id: string
+    let client_secret: string
+    let environment: string
+
+    if (!paypal) {
+      const { Pool: _FbPool } = require("pg")
+      const _fbPool = new _FbPool({ connectionString: process.env.DATABASE_URL })
+      const _fbResult = await _fbPool
+        .query(
+          "SELECT metadata, environment, seller_client_id, seller_client_secret FROM paypal_connection WHERE status='connected' ORDER BY created_at DESC LIMIT 1"
+        )
+        .finally(() => _fbPool.end())
+      const _fbRow = _fbResult.rows[0]
+      if (!_fbRow) throw new Error("No active PayPal connection found in DB")
+      environment = _fbRow.environment || "sandbox"
+      const _fbCreds = (_fbRow.metadata?.credentials?.[environment]) || {}
+      client_id = _fbCreds.client_id || _fbRow.seller_client_id
+      client_secret = _fbCreds.client_secret || _fbRow.seller_client_secret
+      console.info("[PayPal Card] getPayPalAccessToken fallback via DB for env:", environment)
+    } else {
+      const creds = await paypal.getActiveCredentials()
+      client_id = creds.client_id
+      client_secret = creds.client_secret
+      environment = creds.environment
+    }
+
     const base =
-      creds.environment === "live"
+      environment === "live"
         ? "https://api-m.paypal.com"
         : "https://api-m.sandbox.paypal.com"
-    const auth = Buffer.from(`${creds.client_id}:${creds.client_secret}`).toString("base64")
+    const auth = Buffer.from(`${client_id}:${client_secret}`).toString("base64")
 
     const resp = await fetch(`${base}/v1/oauth2/token`, {
       method: "POST",

package/src/modules/paypal/payment-provider/service.ts

@@ -64,25 +64,36 @@ class PayPalPaymentProvider extends AbstractPaymentProvider<Options> {
     }
   }
 
-  private async resolveSettings() {
-    const paypal = this.resolvePayPalService()
+async resolveSettings() {
+    const paypal = this.resolvePayPalService();
     if (!paypal) {
-      return {
-        additionalSettings: {},
-        apiDetails: {},
-      }
+        try {
+            const { Pool: _SettingsPool } = require("pg")
+            const _sPool = new _SettingsPool({ connectionString: process.env.DATABASE_URL })
+            const _sResult = await _sPool
+                .query("SELECT data FROM paypal_settings ORDER BY created_at DESC LIMIT 1")
+                .finally(() => _sPool.end())
+            const _sData = _sResult.rows[0]?.data || {}
+            return {
+                additionalSettings: (_sData.additional_settings || {}) as Record<string, unknown>,
+                apiDetails: (_sData.api_details || {}) as Record<string, unknown>,
+            }
+        } catch {
+            return {
+                additionalSettings: {} as Record<string, unknown>,
+                apiDetails: {} as Record<string, unknown>,
+            }
+        }
     }
-
     const settings = await paypal.getSettings().catch(() => ({}))
-    const data =
-      settings && typeof settings === "object" && "data" in settings
-        ? ((settings as { data?: Record<string, any> }).data ?? {})
+    const data = settings && typeof settings === "object" && "data" in settings
+        ? ((settings as any).data ?? {})
         : {}
     return {
-      additionalSettings: (data.additional_settings || {}) as Record<string, any>,
-      apiDetails: (data.api_details || {}) as Record<string, any>,
+        additionalSettings: (data.additional_settings || {}) as Record<string, unknown>,
+        apiDetails: (data.api_details || {}) as Record<string, unknown>,
     }
-  }
+}
 
   private async resolveCurrencyOverride() {
     const { apiDetails } = await this.resolveSettings()
@@ -426,13 +437,29 @@ class PayPalPaymentProvider extends AbstractPaymentProvider<Options> {
     const { data, amount, currencyCode } = await this.normalizePaymentData(input)
 
     const existingPayPal = (data.paypal || {}) as Record<string, any>
-    if (existingPayPal.capture_id || existingPayPal.authorized_at) {
-      console.info("[PayPal] authorizePayment: already captured, returning authorized")
-      return {
-        status: "authorized",
-        data: { ...(input.data || {}), authorized_at: new Date().toISOString() },
-      }
-    }
+if (
+  existingPayPal.capture_id ||
+  existingPayPal.authorization_id ||
+  (data as any).authorized_at ||
+  (data as any).captured_at
+) {
+  const { additionalSettings } = await this.resolveSettings()
+  const paymentAction =
+    typeof additionalSettings.paymentAction === "string"
+      ? additionalSettings.paymentAction
+      : "capture"
+  const returnStatus = paymentAction === "authorize" ? "authorized" : "captured"
+  console.info("[PayPal] authorizePayment: already processed, returning", returnStatus)
+  return {
+    status: returnStatus,
+    data: {
+      ...(input.data || {}),
+      ...(paymentAction === "authorize"
+        ? { authorized_at: new Date().toISOString() }
+        : { captured_at: new Date().toISOString() }),
+    },
+  }
+}
 
 
     const requestId = this.getIdempotencyKey(input, "authorize")

package/src/modules/paypal/service.ts

@@ -236,7 +236,9 @@ class PayPalModuleService extends MedusaService({
     let json: any = {}
     try {
       json = text ? JSON.parse(text) : {}
-    } catch {}
+    } catch (e: any) {
+      console.warn("[PayPal] Failed to parse response JSON — using empty object:", e?.message)
+    }
 
     if (!resp.ok) {
       throw new Error(
@@ -548,7 +550,9 @@ class PayPalModuleService extends MedusaService({
     let tokenJson: any = {}
     try {
       tokenJson = tokenText ? JSON.parse(tokenText) : {}
-    } catch {}
+    } catch (e: any) {
+      console.warn("[PayPal] Failed to parse token response JSON:", e?.message)
+    }
 
     if (!tokenRes.ok) {
       throw new Error(
@@ -583,7 +587,9 @@ class PayPalModuleService extends MedusaService({
     let credJson: any = {}
     try {
       credJson = credText ? JSON.parse(credText) : {}
-    } catch {}
+    } catch (e: any) {
+      console.warn("[PayPal] Failed to parse token response JSON:", e?.message)
+    }
 
     if (!credRes.ok) {
       throw new Error(
@@ -1032,12 +1038,41 @@ class PayPalModuleService extends MedusaService({
     return { data: (row?.data || {}) as Record<string, any> }
   }
 
+  /**
+   * Deep-merge patch into current settings.
+   * Nested objects (additional_settings, api_details, etc.) are merged,
+   * not replaced.
+   */
+  private deepMerge(
+    target: Record<string, any>,
+    source: Record<string, any>
+  ): Record<string, any> {
+    const result = { ...target }
+    for (const key of Object.keys(source)) {
+      const sv = source[key]
+      const tv = target[key]
+      if (
+        sv !== null &&
+        typeof sv === "object" &&
+        !Array.isArray(sv) &&
+        tv !== null &&
+        typeof tv === "object" &&
+        !Array.isArray(tv)
+      ) {
+        result[key] = this.deepMerge(tv, sv)
+      } else {
+        result[key] = sv
+      }
+    }
+    return result
+  }
+
   async saveSettings(patch: Record<string, any>) {
     const rows = await this.listPayPalSettings({})
     const row = rows?.[0]
     const current = (row?.data || {}) as Record<string, any>
 
-    const next = { ...current, ...patch }
+    const next = this.deepMerge(current, patch)
 
     if (!row) {
       const created = await this.createPayPalSettings({ data: next })

package/src/modules/paypal/utils/paypal-auth.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared PayPal API authentication helpers.
+ * Import these instead of copying into each route.
+ */
+export function getPayPalApiBase(environment: string): string {
+  return environment === "live"
+    ? "https://api-m.paypal.com"
+    : "https://api-m.sandbox.paypal.com"
+}
+
+export async function getPayPalAccessToken(opts: {
+  environment: string
+  client_id: string
+  client_secret: string
+}): Promise<{ accessToken: string; base: string }> {
+  const base = getPayPalApiBase(opts.environment)
+  const auth = Buffer.from(`${opts.client_id}:${opts.client_secret}`).toString("base64")
+  const resp = await fetch(`${base}/v1/oauth2/token`, {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${auth}`,
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: "grant_type=client_credentials",
+  })
+  const text = await resp.text()
+  if (!resp.ok) {
+    throw new Error(`PayPal token error (${resp.status}): ${text}`)
+  }
+  const json = JSON.parse(text)
+  return { accessToken: String(json.access_token), base }
+}

package/src/modules/paypal/webhook-processor.ts

@@ -1,6 +1,8 @@
 import type { MedusaContainer } from "@medusajs/framework/types"
+import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
 import type PayPalModuleService from "./service"
 import { isPayPalProviderId } from "./utils/provider-ids"
+import { PAYPAL_MODULE } from "./index"
 
 export const EVENT_STATUS_MAP: Record<string, "authorized" | "captured" | "canceled" | "error"> = {
   "CHECKOUT.ORDER.APPROVED": "authorized",
@@ -125,7 +127,9 @@ async function resolveDisputeOrderId(
   orderId?: string | null,
   cartId?: string | null
 ) {
-  const query = container.resolve("query") as any
+  // FIX 4a: was container.resolve("query") as any
+  // ContainerRegistrationKeys.QUERY is the official typed constant for the Medusa query helper
+  const query = container.resolve(ContainerRegistrationKeys.QUERY)
   const cleanedOrderId = orderId?.trim()
   const cleanedCartId = cartId?.trim()
 
@@ -188,15 +192,22 @@ async function updatePaymentSession(
   status: string,
   data: Record<string, unknown>
 ) {
-  const paymentCollectionService = container.resolve("payment_collection") as any
-  const paymentSessionService = container.resolve("payment_session") as any
+  // FIX 4b: was container.resolve("payment_collection") as any
+  //         and container.resolve("payment_session") as any
+  // Modules.PAYMENT is the official typed constant that resolves the Medusa payment module.
+  // It gives access to both payment collections and payment sessions through one service.
+  const paymentModule = container.resolve(Modules.PAYMENT) as any
+
+  const pc = await paymentModule.retrievePaymentCollectionByCartId?.(cartId).catch(() => null)
+    ?? await paymentModule.listPaymentCollections({ cart_id: cartId })
+        .then((r: any[]) => r?.[0] ?? null)
+        .catch(() => null)
 
-  const pc = await paymentCollectionService.retrieveByCartId(cartId).catch(() => null)
   if (!pc?.id) {
     return
   }
 
-  const sessions = await paymentSessionService.list({ payment_collection_id: pc.id })
+  const sessions = await paymentModule.listPaymentSessions({ payment_collection_id: pc.id })
   const paypalSession = sessions?.find((s: any) => isPayPalProviderId(s.provider_id))
   if (!paypalSession) {
     return
@@ -210,7 +221,7 @@ async function updatePaymentSession(
     ? mergeRefunds(existingRefunds, incomingRefunds)
     : existingRefunds
 
-  await paymentSessionService.update(paypalSession.id, {
+  await paymentModule.updatePaymentSession(paypalSession.id, {
     status,
     data: {
       ...existingData,
@@ -239,7 +250,10 @@ export async function processPayPalWebhookEvent(
     payload: Record<string, any>
   }
 ) {
-  const paypal = container.resolve<PayPalModuleService>("paypal_onboarding")
+  // FIX 4c: was container.resolve<PayPalModuleService>("paypal_onboarding")
+  // PAYPAL_MODULE is the exported constant from ./index.ts — value is "paypal_onboarding"
+  // Using the constant means if the key ever changes, this file updates automatically.
+  const paypal = container.resolve<PayPalModuleService>(PAYPAL_MODULE)
   const resource = normalizeResource(input.payload)
   const { orderId, captureId, refundId, cartId } = extractIdentifiers(resource)
   const disputeDetails =
@@ -310,4 +324,4 @@ export async function processPayPalWebhookEvent(
     disputeId: disputeDetails?.disputeId,
     resource,
   }
-}
+}

package/tsconfig.json

@@ -17,7 +17,7 @@
     "allowSyntheticDefaultImports": true,
     "resolveJsonModule": true,
     "skipLibCheck": true,
-    "strict": false
+    "strict": true
   },
   "include": [
     "src/**/*.ts",