@anton.andrusenko/shopify-mcp-admin 2.1.1 → 2.1.2

package/dist/chunk-UXI33LQD.js

@@ -0,0 +1,208 @@
+import {
+  log
+} from "./chunk-QXLLD2A7.js";
+
+// src/db/client.ts
+import { PrismaClient } from "@prisma/client";
+import { PrismaClient as PrismaClient2 } from "@prisma/client";
+var prismaInstance = null;
+function getPrismaClient() {
+  if (!prismaInstance) {
+    log.debug("Creating new Prisma client instance");
+    prismaInstance = new PrismaClient({
+      log: process.env.DEBUG === "true" ? ["query", "info", "warn", "error"] : ["error"]
+    });
+  }
+  return prismaInstance;
+}
+async function disconnectPrisma() {
+  if (prismaInstance) {
+    log.debug("Disconnecting Prisma client");
+    await prismaInstance.$disconnect();
+    prismaInstance = null;
+  }
+}
+var prisma = getPrismaClient();
+
+// src/session/store.ts
+var SessionStore = class {
+  cleanupInterval = null;
+  prisma = getPrismaClient();
+  SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+  // 24 hours
+  /**
+   * Retrieve session data by session ID
+   * @param sessionId - Unique session identifier
+   * @returns SessionData if valid and not expired, null otherwise
+   */
+  async get(sessionId) {
+    try {
+      const session = await this.prisma.tenantSession.findUnique({
+        where: { id: sessionId },
+        select: {
+          tenantId: true,
+          expiresAt: true
+        }
+      });
+      if (!session) {
+        return null;
+      }
+      const expiresAt = session.expiresAt.getTime();
+      if (expiresAt < Date.now()) {
+        await this.prisma.tenantSession.delete({
+          where: { id: sessionId }
+        }).catch(() => {
+        });
+        return null;
+      }
+      return {
+        tenantId: session.tenantId,
+        expiresAt
+      };
+    } catch (error) {
+      log.error("Failed to retrieve session", error instanceof Error ? error : void 0);
+      return null;
+    }
+  }
+  /**
+   * Store session data with automatic 24-hour expiration
+   * @param sessionId - Unique session identifier
+   * @param data - Session data (tenantId)
+   */
+  async set(sessionId, data) {
+    const expiresAt = new Date(Date.now() + this.SESSION_TTL_MS);
+    try {
+      await this.prisma.tenantSession.upsert({
+        where: { id: sessionId },
+        update: {
+          expiresAt
+        },
+        create: {
+          id: sessionId,
+          tenantId: data.tenantId,
+          expiresAt
+        }
+      });
+    } catch (error) {
+      log.error("Failed to store session", error instanceof Error ? error : void 0);
+      throw error;
+    }
+  }
+  /**
+   * Delete a specific session
+   * @param sessionId - Session identifier to delete
+   */
+  async delete(sessionId) {
+    try {
+      await this.prisma.tenantSession.delete({
+        where: { id: sessionId }
+      });
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code !== "P2025") {
+        log.error("Failed to delete session", error instanceof Error ? error : void 0);
+      }
+    }
+  }
+  /**
+   * Delete all sessions for a specific tenant
+   * Used when a tenant changes their password for security
+   * @param tenantId - Tenant identifier
+   */
+  async deleteByTenantId(tenantId) {
+    try {
+      await this.prisma.tenantSession.deleteMany({
+        where: { tenantId }
+      });
+      log.debug(`Deleted all sessions for tenant ${tenantId}`);
+    } catch (error) {
+      log.error("Failed to delete tenant sessions", error instanceof Error ? error : void 0);
+      throw error;
+    }
+  }
+  /**
+   * Remove all expired sessions from the store
+   */
+  async cleanup() {
+    try {
+      const result = await this.prisma.tenantSession.deleteMany({
+        where: {
+          expiresAt: {
+            lt: /* @__PURE__ */ new Date()
+          }
+        }
+      });
+      if (result.count > 0) {
+        log.debug(`Cleaned up ${result.count} expired sessions`);
+      }
+    } catch (error) {
+      log.error("Session cleanup failed", error instanceof Error ? error : void 0);
+    }
+  }
+  /**
+   * Start automatic cleanup task (runs every 10 minutes)
+   * @returns Timer handle for cleanup task
+   */
+  startCleanup() {
+    if (this.cleanupInterval) {
+      return this.cleanupInterval;
+    }
+    this.cleanupInterval = setInterval(
+      () => {
+        this.cleanup().catch((error) => {
+          log.error("Background session cleanup error", error instanceof Error ? error : void 0);
+        });
+      },
+      10 * 60 * 1e3
+    );
+    this.cleanupInterval.unref();
+    log.info("Session cleanup background task started (runs every 10 minutes)");
+    return this.cleanupInterval;
+  }
+  /**
+   * Stop the automatic cleanup task
+   */
+  stopCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+      log.info("Session cleanup background task stopped");
+    }
+  }
+  /**
+   * Get the number of active sessions (for testing/monitoring)
+   */
+  async size() {
+    try {
+      return await this.prisma.tenantSession.count({
+        where: {
+          expiresAt: {
+            gte: /* @__PURE__ */ new Date()
+          }
+        }
+      });
+    } catch (error) {
+      log.error("Failed to count sessions", error instanceof Error ? error : void 0);
+      return 0;
+    }
+  }
+  /**
+   * Clear all sessions (for testing)
+   */
+  async clear() {
+    try {
+      await this.prisma.tenantSession.deleteMany();
+    } catch (error) {
+      log.error("Failed to clear sessions", error instanceof Error ? error : void 0);
+      throw error;
+    }
+  }
+};
+var sessionStore = new SessionStore();
+
+export {
+  getPrismaClient,
+  disconnectPrisma,
+  prisma,
+  SessionStore,
+  sessionStore
+};