@oneclick.dev/cms-core-modules 0.0.73 → 0.0.75

package/dist/server-handlers.mjs

@@ -0,0 +1,898 @@
+import { createRouter as v, defineEventHandler as y, createError as h, getRouterParam as U, getQuery as f } from "h3";
+import "vue";
+function $(w) {
+  const { initFirebase: S, normalizeTimestamps: A } = w, l = v();
+  async function m(d) {
+    const { supabase: c, instanceId: g } = d.context.module, { data: e, error: o } = await c.from("project_modules").select("config").eq("id", g).single();
+    if (o || !e?.config)
+      throw h({ statusCode: 500, statusMessage: "Failed to load module config." });
+    const n = e.config, t = n.project, s = n.productCollection || "products";
+    if (!t)
+      throw h({ statusCode: 400, statusMessage: "Products module has no Firebase integration configured." });
+    return { firebase: await S(d, t), collection: s };
+  }
+  return l.get("/products", y(async (d) => {
+    try {
+      const { firebase: c, collection: g } = await m(d);
+      return (await c.firestore().collection(g).get()).docs.map((o) => A({
+        id: o.id,
+        ...o.data()
+      }));
+    } catch (c) {
+      throw console.error("Products handler — list error:", c), h({
+        statusCode: c.statusCode || 500,
+        statusMessage: c.statusMessage || "Failed to list products"
+      });
+    }
+  })), l.get("/products/:productId", y(async (d) => {
+    const c = U(d, "productId");
+    if (!c)
+      throw h({ statusCode: 400, statusMessage: "Product ID is required." });
+    try {
+      const { firebase: g, collection: e } = await m(d), o = await g.firestore().collection(e).doc(c).get();
+      if (!o.exists)
+        throw h({ statusCode: 404, statusMessage: "Product not found." });
+      return A({
+        id: o.id,
+        ...o.data()
+      });
+    } catch (g) {
+      throw console.error("Products handler — get error:", g), h({
+        statusCode: g.statusCode || 500,
+        statusMessage: g.statusMessage || "Failed to get product"
+      });
+    }
+  })), l.get("/empty-stock", y(async (d) => {
+    const g = f(d).category;
+    try {
+      const { firebase: e, collection: o } = await m(d);
+      let n = e.firestore().collection(o).where("stock", "==", 0);
+      g && (n = n.where("collections", "array-contains", g));
+      const s = (await n.get()).docs.map((a) => A({
+        id: a.id,
+        ...a.data()
+      }));
+      return {
+        count: s.length,
+        products: s.map((a) => ({
+          id: a.id,
+          title: a.title,
+          slug: a.slug,
+          stock: a.stock,
+          price: a.price,
+          currency: a.currency,
+          status: a.status
+        }))
+      };
+    } catch (e) {
+      throw console.error("Products handler — empty-stock error:", e), h({
+        statusCode: e.statusCode || 500,
+        statusMessage: e.statusMessage || "Failed to query empty stock"
+      });
+    }
+  })), l.handler;
+}
+function G(w) {
+  const { initFirebase: S, normalizeTimestamps: A } = w, l = v();
+  async function m(c) {
+    const { supabase: g, instanceId: e } = c.context.module, { data: o, error: n } = await g.from("project_modules").select("config").eq("id", e).single();
+    if (n || !o?.config)
+      throw h({ statusCode: 500, statusMessage: "Failed to load module config." });
+    const t = o.config, s = t.project, a = t.reservationsCollection || "bookings_orders", r = t.agendaCollection || "agendas";
+    if (!s)
+      throw h({ statusCode: 400, statusMessage: "Appointments module has no Firebase integration configured." });
+    return { firebase: await S(c, s), reservationsCollection: a, agendaCollection: r };
+  }
+  function d(c) {
+    return (c.reservations || []).map((e) => ({
+      orderId: c.id,
+      reservationId: e.id,
+      customerInfo: c.customerInfo,
+      date: e.date,
+      startTime: e.timeslot?.startTime,
+      endTime: e.timeslot?.endTime,
+      spots: e.spots,
+      status: c.status,
+      reservationStatus: e.status,
+      resourceId: e.resourceId,
+      reservationPrice: e.totalPrice,
+      reservationBasePrice: e.basePrice,
+      reservationAddOnsPrice: e.addOnsPrice,
+      pricingOption: e.pricingOption,
+      amountDue: c.amountDue,
+      amountPaid: c.amountPaid,
+      createdAt: c.createdAt
+    }));
+  }
+  return l.get("/appointments", y(async (c) => {
+    const g = f(c), e = Math.min(Number(g.quantity) || 20, 100);
+    try {
+      const { firebase: o, reservationsCollection: n } = await m(c), s = (await o.firestore().collection(n).orderBy("createdAt", "desc").limit(e).get()).docs.flatMap(
+        (a) => d(A({ id: a.id, ...a.data() }))
+      );
+      return {
+        count: s.length,
+        appointments: s
+      };
+    } catch (o) {
+      throw console.error("Appointments handler — list error:", o), h({
+        statusCode: o.statusCode || 500,
+        statusMessage: o.statusMessage || "Failed to list appointments"
+      });
+    }
+  })), l.get("/appointments/find", y(async (c) => {
+    const g = f(c), e = (g.name || "").toLowerCase().trim(), o = (g.email || "").toLowerCase().trim(), n = g.date;
+    try {
+      const { firebase: t, reservationsCollection: s } = await m(c);
+      let a = t.firestore().collection(s);
+      o && (a = a.where("customerInfo.email", "==", o));
+      let i = (await a.orderBy("createdAt", "desc").limit(200).get()).docs.flatMap(
+        (u) => d(A({ id: u.id, ...u.data() }))
+      );
+      return n && (i = i.filter((u) => u.date === n)), e && (i = i.filter((u) => {
+        const p = (u.customerInfo?.firstName || "").toLowerCase(), D = (u.customerInfo?.lastName || "").toLowerCase();
+        return p.includes(e) || D.includes(e) || `${p} ${D}`.includes(e);
+      })), {
+        count: i.length,
+        appointments: i
+      };
+    } catch (t) {
+      throw console.error("Appointments handler — find error:", t), h({
+        statusCode: t.statusCode || 500,
+        statusMessage: t.statusMessage || "Failed to find appointments"
+      });
+    }
+  })), l.get("/appointments/:appointmentId", y(async (c) => {
+    const g = U(c, "appointmentId");
+    if (!g)
+      throw h({ statusCode: 400, statusMessage: "Appointment ID is required." });
+    try {
+      const { firebase: e, reservationsCollection: o } = await m(c);
+      console.log("Fetching appointment with ID:", g, o);
+      const n = await e.firestore().collection(o).doc(g).get();
+      if (!n.exists)
+        throw h({ statusCode: 404, statusMessage: "Appointment not found." });
+      const t = A({ id: n.id, ...n.data() });
+      return {
+        ...t,
+        reservations: d(t)
+      };
+    } catch (e) {
+      throw console.error("Appointments handler — get error:", e), h({
+        statusCode: e.statusCode || 500,
+        statusMessage: e.statusMessage || "Failed to get appointment"
+      });
+    }
+  })), l.handler;
+}
+const M = "https://analyticsdata.googleapis.com/v1beta", F = [
+  "https://www.googleapis.com/auth/analytics.readonly",
+  "https://www.googleapis.com/auth/webmasters.readonly"
+], T = "https://searchconsole.googleapis.com/webmasters/v3";
+function x(w) {
+  const { decrypt: S, getGoogleAccessToken: A } = w, l = v();
+  async function m(e) {
+    const { supabase: o, instanceId: n } = e.context.module, { data: t, error: s } = await o.from("project_modules").select("config").eq("id", n).single();
+    if (s || !t?.config)
+      throw h({ statusCode: 500, statusMessage: "Failed to load module config." });
+    const a = t.config, r = a.propertyId, i = a.serviceAccount, u = a.siteUrl || "";
+    if (!i)
+      throw h({ statusCode: 400, statusMessage: "No Google Service Account configured for this module." });
+    if (!r)
+      throw h({ statusCode: 400, statusMessage: "No GA4 Property ID configured for this module." });
+    const { data: p, error: D } = await o.from("integrations").select("config").eq("id", i).single();
+    let C = p?.config;
+    if (D || !C) {
+      const { data: q, error: b } = await o.from("agency_integrations").select("config").eq("id", i).single();
+      if (b || !q?.config)
+        throw h({ statusCode: 500, statusMessage: "Failed to load Google Service Account credentials." });
+      C = q.config;
+    }
+    const R = S(C.clientEmail), P = S(C.privateKey), k = S(C.projectId);
+    return { accessToken: await A(
+      { clientEmail: R, privateKey: P, projectId: k },
+      F
+    ), propertyId: r, siteUrl: u };
+  }
+  async function d(e, o, n) {
+    const t = await fetch(`${M}/properties/${o}:runReport`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${e}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(n)
+    });
+    if (!t.ok) {
+      const s = await t.json().catch(() => ({}));
+      throw console.error("GA4 runReport failed:", s), h({
+        statusCode: t.status,
+        statusMessage: s?.error?.message || "GA4 API request failed"
+      });
+    }
+    return t.json();
+  }
+  l.get(
+    "/report",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = s.match(/^(\d+)daysAgo$/), i = r ? parseInt(r[1], 10) : 30, u = `${i * 2}daysAgo`, p = `${i + 1}daysAgo`, D = [
+        { name: "sessions" },
+        { name: "totalUsers" },
+        { name: "screenPageViews" },
+        { name: "bounceRate" },
+        { name: "averageSessionDuration" },
+        { name: "newUsers" },
+        { name: "engagementRate" },
+        { name: "sessionsPerUser" },
+        { name: "screenPageViewsPerSession" }
+      ];
+      let C, R = !0;
+      try {
+        C = await d(o, n, {
+          dateRanges: [
+            { startDate: s, endDate: a, name: "current" },
+            { startDate: u, endDate: p, name: "previous" }
+          ],
+          dimensions: [{ name: "date" }],
+          metrics: D,
+          metricAggregations: ["TOTAL"],
+          orderBys: [{ dimension: { dimensionName: "date" } }]
+        });
+      } catch {
+        R = !1, C = await d(o, n, {
+          dateRanges: [{ startDate: s, endDate: a }],
+          dimensions: [{ name: "date" }],
+          metrics: D,
+          metricAggregations: ["TOTAL"],
+          orderBys: [{ dimension: { dimensionName: "date" } }]
+        });
+      }
+      return V(C, R);
+    })
+  ), l.get(
+    "/realtime",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = await fetch(
+        `${M}/properties/${n}:runRealtimeReport`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${o}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            dimensions: [{ name: "unifiedScreenName" }],
+            metrics: [{ name: "activeUsers" }],
+            orderBys: [{ metric: { metricName: "activeUsers" }, desc: !0 }],
+            limit: 5
+          })
+        }
+      );
+      if (!t.ok) {
+        const i = await t.json().catch(() => ({}));
+        throw h({ statusCode: t.status, statusMessage: i?.error?.message || "Realtime API failed" });
+      }
+      const s = await t.json(), a = (s?.rows || []).reduce(
+        (i, u) => i + parseInt(u.metricValues?.[0]?.value || "0", 10),
+        0
+      ), r = (s?.rows || []).map((i) => ({
+        page: i.dimensionValues?.[0]?.value || "(not set)",
+        activeUsers: parseInt(i.metricValues?.[0]?.value || "0", 10)
+      }));
+      return { activeUsers: a, activePages: r };
+    })
+  ), l.get(
+    "/top-pages",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = parseInt(t.limit || "10", 10), i = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "pagePath" }],
+        metrics: [
+          { name: "screenPageViews" },
+          { name: "totalUsers" },
+          { name: "averageSessionDuration" }
+        ],
+        orderBys: [{ metric: { metricName: "screenPageViews" }, desc: !0 }],
+        limit: r * 2
+        // fetch extra to account for duplicates before aggregation
+      }), u = I(i, "pagePath"), p = /* @__PURE__ */ new Map();
+      for (const C of u.rows) {
+        const R = C.pagePath.toLowerCase().replace(/\/+$/, ""), P = p.get(R);
+        if (P) {
+          P.screenPageViews += C.screenPageViews || 0, P.totalUsers += C.totalUsers || 0;
+          const k = P.screenPageViews;
+          k > 0 && (P.averageSessionDuration = (P.averageSessionDuration * (k - (C.screenPageViews || 0)) + (C.averageSessionDuration || 0) * (C.screenPageViews || 0)) / k);
+        } else
+          p.set(R, { ...C });
+      }
+      return { rows: [...p.values()].sort((C, R) => (R.screenPageViews || 0) - (C.screenPageViews || 0)).slice(0, r), rowCount: u.rowCount };
+    })
+  ), l.get(
+    "/top-sources",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "sessionSource" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 10
+      });
+      return I(r, "sessionSource");
+    })
+  ), l.get(
+    "/devices",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "deviceCategory" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }]
+      });
+      return I(r, "deviceCategory");
+    })
+  ), l.get(
+    "/countries",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "country" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 10
+      });
+      return I(r, "country");
+    })
+  ), l.get(
+    "/acquisition/channels",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "sessionDefaultChannelGroup" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "newUsers" },
+          { name: "engagementRate" },
+          { name: "averageSessionDuration" },
+          { name: "screenPageViewsPerSession" },
+          { name: "conversions" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 15
+      });
+      return I(r, "sessionDefaultChannelGroup");
+    })
+  ), l.get(
+    "/acquisition/source-medium",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "sessionSourceMedium" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "newUsers" },
+          { name: "bounceRate" },
+          { name: "averageSessionDuration" },
+          { name: "conversions" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 20
+      });
+      return I(r, "sessionSourceMedium");
+    })
+  ), l.get(
+    "/acquisition/referrals",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "sessionSource" }],
+        dimensionFilter: {
+          filter: {
+            fieldName: "sessionMedium",
+            stringFilter: { value: "referral" }
+          }
+        },
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "engagementRate" },
+          { name: "averageSessionDuration" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 20
+      });
+      return I(r, "sessionSource");
+    })
+  ), l.get(
+    "/acquisition/campaigns",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "sessionCampaignName" }],
+        dimensionFilter: {
+          notExpression: {
+            filter: {
+              fieldName: "sessionCampaignName",
+              stringFilter: { value: "(not set)" }
+            }
+          }
+        },
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "conversions" },
+          { name: "engagementRate" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 20
+      });
+      return I(r, "sessionCampaignName");
+    })
+  ), l.get(
+    "/content/all-pages",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = parseInt(t.limit || "50", 10), i = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "pagePath" }],
+        metrics: [
+          { name: "screenPageViews" },
+          { name: "totalUsers" },
+          { name: "averageSessionDuration" },
+          { name: "bounceRate" },
+          { name: "engagementRate" },
+          { name: "sessions" },
+          { name: "userEngagementDuration" }
+        ],
+        orderBys: [{ metric: { metricName: "screenPageViews" }, desc: !0 }],
+        limit: r
+      });
+      return I(i, "pagePath");
+    })
+  ), l.get(
+    "/content/landing-pages",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "landingPagePlusQueryString" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "bounceRate" },
+          { name: "averageSessionDuration" },
+          { name: "screenPageViews" },
+          { name: "engagementRate" }
+        ],
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 30
+      });
+      return I(r, "landingPagePlusQueryString");
+    })
+  ), l.get(
+    "/content/exit-pages",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "pagePath" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "screenPageViews" },
+          { name: "totalUsers" },
+          { name: "bounceRate" }
+        ],
+        orderBys: [{ metric: { metricName: "screenPageViews" }, desc: !0 }],
+        limit: 20
+      }), i = I(r, "pagePath");
+      return i.rows = i.rows.map((u) => ({
+        ...u,
+        exitRate: u.bounceRate || 0
+      })), i;
+    })
+  ), l.get(
+    "/content/search-terms",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n, siteUrl: t } = await m(e), s = f(e), a = s.startDate || "30daysAgo", r = s.endDate || "today";
+      if (t)
+        try {
+          const p = `${T}/sites/${encodeURIComponent(t)}/searchAnalytics/query`;
+          console.log("[GA Module] Attempting Search Console query for site:", t);
+          const D = await fetch(
+            p,
+            {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${o}`,
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                startDate: c(a),
+                endDate: c(r),
+                dimensions: ["query"],
+                rowLimit: 30
+              })
+            }
+          );
+          if (D.ok) {
+            const R = ((await D.json()).rows || []).map((P) => ({
+              query: P.keys[0],
+              clicks: P.clicks,
+              impressions: P.impressions,
+              ctr: P.ctr,
+              position: P.position
+            }));
+            if (R.length > 0)
+              return console.log(`[GA Module] Search Console returned ${R.length} keyword rows`), {
+                rows: R,
+                rowCount: R.length,
+                source: "search_console"
+              };
+            console.log("[GA Module] Search Console returned 0 rows, falling through");
+          } else {
+            const C = await D.text().catch(() => "");
+            console.error(`[GA Module] Search Console API error (${D.status}):`, C);
+          }
+        } catch (p) {
+          console.error("[GA Module] Search Console request failed:", p?.message || p);
+        }
+      else
+        console.log("[GA Module] No siteUrl configured, skipping Search Console");
+      try {
+        const p = await d(o, n, {
+          dateRanges: [{ startDate: a, endDate: r }],
+          dimensions: [{ name: "sessionGoogleAdsQuery" }],
+          metrics: [
+            { name: "sessions" },
+            { name: "totalUsers" },
+            { name: "engagementRate" }
+          ],
+          dimensionFilter: {
+            andGroup: {
+              expressions: [
+                {
+                  notExpression: {
+                    filter: {
+                      fieldName: "sessionGoogleAdsQuery",
+                      stringFilter: { value: "(not set)" }
+                    }
+                  }
+                },
+                {
+                  notExpression: {
+                    filter: {
+                      fieldName: "sessionGoogleAdsQuery",
+                      stringFilter: { value: "(not provided)" }
+                    }
+                  }
+                }
+              ]
+            }
+          },
+          orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+          limit: 30
+        }), D = I(p, "sessionGoogleAdsQuery");
+        if (D.rows.length > 0)
+          return { ...D, source: "google_ads" };
+      } catch {
+      }
+      const i = await d(o, n, {
+        dateRanges: [{ startDate: a, endDate: r }],
+        dimensions: [{ name: "landingPagePlusQueryString" }],
+        metrics: [
+          { name: "sessions" },
+          { name: "totalUsers" },
+          { name: "engagementRate" }
+        ],
+        dimensionFilter: {
+          andGroup: {
+            expressions: [
+              {
+                filter: {
+                  fieldName: "sessionMedium",
+                  stringFilter: {
+                    matchType: "EXACT",
+                    value: "organic"
+                  }
+                }
+              },
+              {
+                notExpression: {
+                  filter: {
+                    fieldName: "landingPagePlusQueryString",
+                    stringFilter: { value: "(not set)" }
+                  }
+                }
+              }
+            ]
+          }
+        },
+        orderBys: [{ metric: { metricName: "sessions" }, desc: !0 }],
+        limit: 30
+      });
+      return { ...I(i, "landingPagePlusQueryString"), source: "organic_landing_pages" };
+    })
+  ), l.get(
+    "/audience/overview",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "newVsReturning" }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" },
+          { name: "engagementRate" },
+          { name: "averageSessionDuration" },
+          { name: "screenPageViewsPerSession" }
+        ],
+        metricAggregations: ["TOTAL"]
+      });
+      return I(r, "newVsReturning");
+    })
+  ), l.get(
+    "/audience/technology",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = t.dimension || "browser", u = ["browser", "operatingSystem", "screenResolution"].includes(r) ? r : "browser", p = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: u }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" },
+          { name: "engagementRate" }
+        ],
+        orderBys: [{ metric: { metricName: "totalUsers" }, desc: !0 }],
+        limit: 10
+      });
+      return I(p, u);
+    })
+  ), l.get(
+    "/audience/languages",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "language" }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" }
+        ],
+        orderBys: [{ metric: { metricName: "totalUsers" }, desc: !0 }],
+        limit: 15
+      });
+      return I(r, "language");
+    })
+  ), l.get(
+    "/audience/hours",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "dayOfWeekName" }, { name: "hour" }],
+        metrics: [{ name: "sessions" }],
+        orderBys: [
+          { dimension: { dimensionName: "dayOfWeekName" } },
+          { dimension: { dimensionName: "hour" } }
+        ],
+        limit: 168
+        // 7 days × 24 hours
+      });
+      return N(r, ["dayOfWeekName", "hour"]);
+    })
+  ), l.get(
+    "/audience/cities",
+    y(async (e) => {
+      const { accessToken: o, propertyId: n } = await m(e), t = f(e), s = t.startDate || "30daysAgo", a = t.endDate || "today", r = await d(o, n, {
+        dateRanges: [{ startDate: s, endDate: a }],
+        dimensions: [{ name: "city" }, { name: "country" }],
+        metrics: [
+          { name: "totalUsers" },
+          { name: "sessions" }
+        ],
+        dimensionFilter: {
+          notExpression: {
+            filter: {
+              fieldName: "city",
+              stringFilter: { value: "(not set)" }
+            }
+          }
+        },
+        orderBys: [{ metric: { metricName: "totalUsers" }, desc: !0 }],
+        limit: 20
+      });
+      return N(r, ["city", "country"]);
+    })
+  );
+  function c(e) {
+    const o = e.match(/^(\d+)daysAgo$/);
+    if (o) {
+      const n = /* @__PURE__ */ new Date();
+      return n.setDate(n.getDate() - parseInt(o[1], 10)), n.toISOString().slice(0, 10);
+    }
+    if (e === "today") return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (e === "yesterday") {
+      const n = /* @__PURE__ */ new Date();
+      return n.setDate(n.getDate() - 1), n.toISOString().slice(0, 10);
+    }
+    return e;
+  }
+  async function g(e, o, n) {
+    const t = `${T}/sites/${encodeURIComponent(o)}/searchAnalytics/query`, s = await fetch(t, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${e}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(n)
+    });
+    if (!s.ok) {
+      const a = await s.json().catch(() => ({}));
+      throw h({
+        statusCode: s.status,
+        statusMessage: a?.error?.message || "Search Console API request failed"
+      });
+    }
+    return s.json();
+  }
+  return l.get(
+    "/seo/keywords",
+    y(async (e) => {
+      const { accessToken: o, siteUrl: n } = await m(e);
+      if (!n)
+        throw h({ statusCode: 400, statusMessage: "Search Console Site URL is not configured. Add it in module settings." });
+      const t = f(e), s = c(t.startDate || "30daysAgo"), a = c(t.endDate || "today"), r = Math.min(parseInt(t.limit) || 50, 100), i = await g(o, n, {
+        startDate: s,
+        endDate: a,
+        dimensions: ["query"],
+        rowLimit: r
+      });
+      return {
+        rows: (i.rows || []).map((u) => ({
+          query: u.keys[0],
+          clicks: u.clicks,
+          impressions: u.impressions,
+          ctr: u.ctr,
+          position: u.position
+        })),
+        rowCount: i.rows?.length || 0
+      };
+    })
+  ), l.get(
+    "/seo/pages",
+    y(async (e) => {
+      const { accessToken: o, siteUrl: n } = await m(e);
+      if (!n)
+        throw h({ statusCode: 400, statusMessage: "Search Console Site URL is not configured." });
+      const t = f(e), s = c(t.startDate || "30daysAgo"), a = c(t.endDate || "today"), r = Math.min(parseInt(t.limit) || 50, 100), i = await g(o, n, {
+        startDate: s,
+        endDate: a,
+        dimensions: ["page"],
+        rowLimit: r
+      });
+      return {
+        rows: (i.rows || []).map((u) => ({
+          page: u.keys[0],
+          clicks: u.clicks,
+          impressions: u.impressions,
+          ctr: u.ctr,
+          position: u.position
+        })),
+        rowCount: i.rows?.length || 0
+      };
+    })
+  ), l.get(
+    "/seo/trends",
+    y(async (e) => {
+      const { accessToken: o, siteUrl: n } = await m(e);
+      if (!n)
+        throw h({ statusCode: 400, statusMessage: "Search Console Site URL is not configured." });
+      const t = f(e), s = c(t.startDate || "30daysAgo"), a = c(t.endDate || "today"), i = ((await g(o, n, {
+        startDate: s,
+        endDate: a,
+        dimensions: ["date"],
+        rowLimit: 500
+      })).rows || []).map((p) => ({
+        date: p.keys[0],
+        clicks: p.clicks,
+        impressions: p.impressions,
+        ctr: p.ctr,
+        position: p.position
+      })).sort((p, D) => p.date.localeCompare(D.date)), u = i.reduce(
+        (p, D) => ({
+          clicks: p.clicks + D.clicks,
+          impressions: p.impressions + D.impressions
+        }),
+        { clicks: 0, impressions: 0 }
+      );
+      return u.ctr = u.impressions > 0 ? u.clicks / u.impressions : 0, u.avgPosition = i.length > 0 ? i.reduce((p, D) => p + D.position, 0) / i.length : 0, { rows: i, totals: u, rowCount: i.length };
+    })
+  ), l.get(
+    "/seo/query-pages",
+    y(async (e) => {
+      const { accessToken: o, siteUrl: n } = await m(e);
+      if (!n)
+        throw h({ statusCode: 400, statusMessage: "Search Console Site URL is not configured." });
+      const t = f(e), s = c(t.startDate || "30daysAgo"), a = c(t.endDate || "today"), r = await g(o, n, {
+        startDate: s,
+        endDate: a,
+        dimensions: ["query", "page"],
+        rowLimit: 100
+      });
+      return {
+        rows: (r.rows || []).map((i) => ({
+          query: i.keys[0],
+          page: i.keys[1],
+          clicks: i.clicks,
+          impressions: i.impressions,
+          ctr: i.ctr,
+          position: i.position
+        })),
+        rowCount: r.rows?.length || 0
+      };
+    })
+  ), l.handler;
+}
+function V(w, S = !0) {
+  const A = (w.metricHeaders || []).map((s) => s.name), m = (w.dimensionHeaders || []).map((s) => s.name).indexOf("date"), d = [];
+  (w.rows || []).forEach((s) => {
+    const a = m >= 0 ? s.dimensionValues[m]?.value : s.dimensionValues[0]?.value;
+    if (!a || a.length < 8) return;
+    const i = { date: `${a.slice(0, 4)}-${a.slice(4, 6)}-${a.slice(6, 8)}` };
+    A.forEach((u, p) => {
+      i[u] = parseFloat(s.metricValues[p]?.value || "0");
+    }), d.push(i);
+  });
+  const c = {}, g = {};
+  w.totals && w.totals.length >= 2 ? A.forEach((s, a) => {
+    c[s] = parseFloat(w.totals[0]?.metricValues?.[a]?.value || "0"), g[s] = parseFloat(w.totals[1]?.metricValues?.[a]?.value || "0");
+  }) : w.totals && w.totals.length === 1 && A.forEach((s, a) => {
+    c[s] = parseFloat(w.totals[0]?.metricValues?.[a]?.value || "0");
+  });
+  const e = {};
+  A.forEach((s) => {
+    const a = c[s] || 0, r = g[s];
+    r !== void 0 && r !== 0 ? e[s] = (a - r) / r * 100 : e[s] = null;
+  });
+  const o = /* @__PURE__ */ new Map();
+  for (const s of d)
+    o.has(s.date) || o.set(s.date, s);
+  const n = Array.from(o.values()).sort((s, a) => s.date.localeCompare(a.date)), t = S && w.totals && w.totals.length >= 2 ? n.slice(-Math.ceil(n.length / 2)) : n;
+  return {
+    rows: t,
+    totals: c,
+    previousTotals: g,
+    changes: e,
+    rowCount: t.length
+  };
+}
+function I(w, S) {
+  const A = (w.metricHeaders || []).map((m) => m.name), l = (w.rows || []).map((m) => {
+    const d = {
+      [S]: m.dimensionValues[0].value
+    };
+    return A.forEach((c, g) => {
+      d[c] = parseFloat(m.metricValues[g].value);
+    }), d;
+  });
+  return { rows: l, rowCount: w.rowCount || l.length };
+}
+function N(w, S) {
+  const A = (w.metricHeaders || []).map((m) => m.name), l = (w.rows || []).map((m) => {
+    const d = {};
+    return S.forEach((c, g) => {
+      d[c] = m.dimensionValues[g]?.value || "";
+    }), A.forEach((c, g) => {
+      d[c] = parseFloat(m.metricValues[g].value);
+    }), d;
+  });
+  return { rows: l, rowCount: w.rowCount || l.length };
+}
+export {
+  G as appointments,
+  x as googleAnalytics,
+  $ as products
+};