@burdenoff/be-sdk 2026.510.79

package/dist/chunk-2SD5L2F2.js

@@ -0,0 +1,816 @@
+import { withWorkspaceContextSync, withWorkspaceContext, setWorkspaceContext, injectWhereWorkspaceId, getWorkspaceContext, addWorkspaceExtension } from './chunk-GTEMQXCA.js';
+import { addGraphExtension } from './chunk-TKBD2ONF.js';
+import { getGraphEventEmitter } from './chunk-ELLX3K54.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { Pool } from 'pg';
+import { createRequire } from 'module';
+
+// src/prisma/index.ts
+var prisma_exports = {};
+__export(prisma_exports, {
+  PrismaClientWrapper: () => PrismaClientWrapper,
+  addWorkspaceExtension: () => addWorkspaceExtension,
+  buildContextWhereClause: () => buildContextWhereClause,
+  buildContextWhereConditions: () => buildContextWhereConditions,
+  checkDatabaseHealth: () => checkDatabaseHealth,
+  configurePrismaLogging: () => configurePrismaLogging,
+  contextMatches: () => contextMatches,
+  createConnectionPool: () => createConnectionPool,
+  createContextFromSDK: () => createContextFromSDK,
+  createDatabaseClient: () => createDatabaseClient,
+  createDatabaseClientFromEnv: () => createDatabaseClientFromEnv,
+  createPrismaAdapter: () => createPrismaAdapter,
+  createPrismaClient: () => createPrismaClient,
+  extractFieldsFromModel: () => extractFieldsFromModel,
+  getAllModelNames: () => getAllModelNames,
+  getDatabaseManager: () => getDatabaseManager,
+  getDatabaseProductName: () => getDatabaseProductName,
+  getDatabaseStats: () => getDatabaseStats,
+  getDatabaseVersion: () => getDatabaseVersion,
+  getDb: () => getDb,
+  getModelFields: () => getModelFields,
+  getWorkspaceContext: () => getWorkspaceContext,
+  hasModel: () => hasModel,
+  initializeDatabase: () => initializeDatabase,
+  initializeDatabaseWithConfig: () => initializeDatabaseWithConfig,
+  injectWhereWorkspaceId: () => injectWhereWorkspaceId,
+  isDatabaseInitialized: () => isDatabaseInitialized,
+  loadGeneratedFields: () => loadGeneratedFields,
+  mergeContext: () => mergeContext,
+  parseContext: () => parseContext,
+  resetDatabaseManager: () => resetDatabaseManager,
+  setWorkspaceContext: () => setWorkspaceContext,
+  testConnection: () => testConnection,
+  toContextJson: () => toContextJson,
+  withWorkspaceContext: () => withWorkspaceContext,
+  withWorkspaceContextSync: () => withWorkspaceContextSync
+});
+function createConnectionPool(config) {
+  return new Pool({
+    connectionString: config.databaseUrl,
+    max: config.maxConnections ?? 20,
+    idleTimeoutMillis: config.idleTimeoutMillis ?? 3e4,
+    connectionTimeoutMillis: config.connectionTimeoutMillis ?? 1e4
+  });
+}
+__name(createConnectionPool, "createConnectionPool");
+function createPrismaAdapter(pool) {
+  return new PrismaPg(pool);
+}
+__name(createPrismaAdapter, "createPrismaAdapter");
+function configurePrismaLogging(client, config) {
+  const isDevelopment = process.env["NODE_ENV"] === "development";
+  const slowQueryThreshold = config.slowQueryThreshold ?? (isDevelopment ? 100 : 500);
+  if (config.enableQueryLogging ?? isDevelopment) {
+    client.$on("query", (e) => {
+      if ("query" in e && "duration" in e) {
+        if (e.duration > slowQueryThreshold) {
+          logger.warn("[Prisma] Slow query detected", {
+            query: e.query.substring(0, 200) + (e.query.length > 200 ? "..." : ""),
+            params: e.params,
+            duration: `${e.duration}ms`
+          });
+        } else {
+          logger.debug("[Prisma] Query", {
+            query: e.query.substring(0, 100) + (e.query.length > 100 ? "..." : ""),
+            duration: `${e.duration}ms`
+          });
+        }
+      }
+    });
+  }
+  client.$on("error", (e) => {
+    if ("message" in e) {
+      logger.error("[Prisma] Database error", {
+        message: e.message,
+        target: e.target
+      });
+    }
+  });
+  client.$on("warn", (e) => {
+    if ("message" in e) {
+      logger.warn("[Prisma] Database warning", {
+        message: e.message,
+        target: e.target
+      });
+    }
+  });
+  return client;
+}
+__name(configurePrismaLogging, "configurePrismaLogging");
+var PrismaClientWrapper = class {
+  static {
+    __name(this, "PrismaClientWrapper");
+  }
+  client;
+  pool;
+  connectionState = {
+    isConnected: false,
+    attempts: 0
+  };
+  isDisconnecting = false;
+  constructor(client, pool, config) {
+    this.client = client;
+    this.pool = pool;
+    configurePrismaLogging(this.client, config);
+  }
+  /**
+  * Get the Prisma client instance
+  */
+  getClient() {
+    return this.client;
+  }
+  /**
+  * Get the connection pool
+  */
+  getPool() {
+    return this.pool;
+  }
+  /**
+  * Get connection state
+  */
+  getConnectionState() {
+    return {
+      ...this.connectionState
+    };
+  }
+  /**
+  * Connect to database with retry logic
+  */
+  async connect(retries = 5, delay = 1e3) {
+    if (this.connectionState.isConnected) {
+      logger.info("[Prisma] Already connected to database");
+      return;
+    }
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      this.connectionState.attempts = attempt;
+      try {
+        await this.client.$connect();
+        this.connectionState.isConnected = true;
+        this.connectionState.lastConnectedAt = /* @__PURE__ */ new Date();
+        this.connectionState.lastError = void 0;
+        logger.info("[Prisma] Successfully connected to database");
+        return;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.connectionState.lastError = errorMessage;
+        logger.error(`[Prisma] Connection attempt ${attempt}/${retries} failed`, {
+          error: errorMessage
+        });
+        if (attempt === retries) {
+          logger.error("[Prisma] Max connection retries reached");
+          throw error;
+        }
+        const waitTime = delay * Math.pow(2, attempt - 1);
+        logger.info(`[Prisma] Retrying in ${waitTime}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+      }
+    }
+  }
+  /**
+  * Gracefully disconnect from database
+  */
+  async disconnect() {
+    if (this.isDisconnecting) {
+      logger.debug("[Prisma] Disconnect already in progress, skipping");
+      return;
+    }
+    if (!this.connectionState.isConnected) {
+      logger.info("[Prisma] Database already disconnected");
+      return;
+    }
+    this.isDisconnecting = true;
+    try {
+      await this.client.$disconnect();
+      await this.pool.end();
+      this.connectionState.isConnected = false;
+      logger.info("[Prisma] Successfully disconnected from database");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("Called end on pool more than once")) {
+        logger.debug("[Prisma] Pool already ended, ignoring duplicate end call");
+        this.connectionState.isConnected = false;
+        return;
+      }
+      logger.error("[Prisma] Error disconnecting from database", {
+        error: errorMessage
+      });
+      throw error;
+    } finally {
+      this.isDisconnecting = false;
+    }
+  }
+  /**
+  * Register graceful shutdown handlers
+  */
+  registerShutdownHandlers() {
+    const shutdownHandler = /* @__PURE__ */ __name(async (signal) => {
+      logger.info(`[Prisma] Received ${signal}, starting graceful shutdown...`);
+      try {
+        await this.disconnect();
+        process.exit(0);
+      } catch (error) {
+        logger.error("[Prisma] Error during graceful shutdown", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        process.exit(1);
+      }
+    }, "shutdownHandler");
+    process.on("SIGINT", () => void shutdownHandler("SIGINT"));
+    process.on("SIGTERM", () => void shutdownHandler("SIGTERM"));
+    process.on("beforeExit", () => void this.disconnect());
+  }
+};
+function createPrismaClient(PrismaClientConstructor, config) {
+  const isDevelopment = process.env["NODE_ENV"] === "development";
+  const pool = createConnectionPool(config);
+  const adapter = createPrismaAdapter(pool);
+  const logLevels = config.logLevels ?? (isDevelopment ? [
+    {
+      emit: "event",
+      level: "query"
+    },
+    {
+      emit: "event",
+      level: "info"
+    },
+    {
+      emit: "event",
+      level: "warn"
+    },
+    {
+      emit: "event",
+      level: "error"
+    }
+  ] : [
+    {
+      emit: "event",
+      level: "warn"
+    },
+    {
+      emit: "event",
+      level: "error"
+    }
+  ]);
+  const client = new PrismaClientConstructor({
+    adapter,
+    log: logLevels
+  });
+  return new PrismaClientWrapper(client, pool, config);
+}
+__name(createPrismaClient, "createPrismaClient");
+
+// src/prisma/factory.ts
+function createDatabaseClient(PrismaClientConstructor, config) {
+  const { productName, enableGraphExtension = process.env["GRAPH_MIDDLEWARE_ENABLED"] !== "false", graphEventEmitter, enableWorkspaceExtension = process.env["WORKSPACE_EXTENSION_ENABLED"] !== "false", workspaceExtensionConfig, registerShutdownHandlers = true, ...prismaConfig } = config;
+  const wrapper = createPrismaClient(PrismaClientConstructor, prismaConfig);
+  const baseClient = wrapper.getClient();
+  let extendedClient;
+  if (enableGraphExtension) {
+    const eventEmitter = graphEventEmitter ?? getGraphEventEmitter();
+    const graphConfig = {
+      enabled: true,
+      productName,
+      eventEmitter
+    };
+    extendedClient = addGraphExtension(baseClient, graphConfig);
+    logger.info("[Database] Graph extension enabled", {
+      productName
+    });
+  } else {
+    extendedClient = baseClient;
+    logger.info("[Database] Graph extension disabled");
+  }
+  if (enableWorkspaceExtension) {
+    extendedClient = addWorkspaceExtension(extendedClient, workspaceExtensionConfig);
+    logger.info("[Database] Workspace extension enabled", {
+      productName
+    });
+  } else {
+    logger.info("[Database] Workspace extension disabled");
+  }
+  const db = extendedClient;
+  db["client"] = db;
+  if (registerShutdownHandlers) {
+    wrapper.registerShutdownHandlers();
+    logger.debug("[Database] Shutdown handlers registered");
+  }
+  return {
+    db,
+    wrapper,
+    connect: /* @__PURE__ */ __name((retries, delay) => wrapper.connect(retries, delay), "connect"),
+    disconnect: /* @__PURE__ */ __name(() => wrapper.disconnect(), "disconnect")
+  };
+}
+__name(createDatabaseClient, "createDatabaseClient");
+function createDatabaseClientFromEnv(PrismaClientConstructor, productName, overrides) {
+  const databaseUrl = process.env["DATABASE_URL"];
+  if (!databaseUrl) {
+    throw new Error("DATABASE_URL environment variable is required");
+  }
+  const isDevelopment = process.env["NODE_ENV"] === "development";
+  const config = {
+    productName,
+    databaseUrl,
+    maxConnections: parseInt(process.env["DATABASE_MAX_CONNECTIONS"] || "20", 10),
+    idleTimeoutMillis: parseInt(process.env["DATABASE_IDLE_TIMEOUT"] || "30000", 10),
+    connectionTimeoutMillis: parseInt(process.env["DATABASE_CONNECTION_TIMEOUT"] || "10000", 10),
+    enableQueryLogging: isDevelopment,
+    slowQueryThreshold: isDevelopment ? 100 : 500,
+    ...overrides
+  };
+  return createDatabaseClient(PrismaClientConstructor, config);
+}
+__name(createDatabaseClientFromEnv, "createDatabaseClientFromEnv");
+
+// src/prisma/manager.ts
+var state = {
+  initialized: false,
+  productName: null,
+  client: null
+};
+function initializeDatabase(PrismaClientConstructor, productName, config) {
+  if (state.initialized) {
+    if (state.productName !== productName) {
+      throw new Error(`Database already initialized for product "${state.productName}". Cannot reinitialize for "${productName}".`);
+    }
+    logger.debug("[DatabaseManager] Already initialized, returning existing client", {
+      productName
+    });
+    return state.client;
+  }
+  const client = createDatabaseClientFromEnv(PrismaClientConstructor, productName, config);
+  state.initialized = true;
+  state.productName = productName;
+  state.client = client;
+  logger.info("[DatabaseManager] Database initialized", {
+    productName
+  });
+  return client;
+}
+__name(initializeDatabase, "initializeDatabase");
+function initializeDatabaseWithConfig(PrismaClientConstructor, config) {
+  const { productName } = config;
+  if (state.initialized) {
+    if (state.productName !== productName) {
+      throw new Error(`Database already initialized for product "${state.productName}". Cannot reinitialize for "${productName}".`);
+    }
+    logger.debug("[DatabaseManager] Already initialized, returning existing client", {
+      productName
+    });
+    return state.client;
+  }
+  const client = createDatabaseClient(PrismaClientConstructor, config);
+  state.initialized = true;
+  state.productName = productName;
+  state.client = client;
+  logger.info("[DatabaseManager] Database initialized with custom config", {
+    productName
+  });
+  return client;
+}
+__name(initializeDatabaseWithConfig, "initializeDatabaseWithConfig");
+function getDb() {
+  if (!state.initialized || !state.client) {
+    throw new Error("Database not initialized. Call initializeDatabase() at application startup before using getDb().");
+  }
+  return state.client.db;
+}
+__name(getDb, "getDb");
+function getDatabaseManager() {
+  if (!state.initialized || !state.client) {
+    throw new Error("Database not initialized. Call initializeDatabase() at application startup before using getDatabaseManager().");
+  }
+  return state.client;
+}
+__name(getDatabaseManager, "getDatabaseManager");
+function isDatabaseInitialized() {
+  return state.initialized;
+}
+__name(isDatabaseInitialized, "isDatabaseInitialized");
+function getDatabaseProductName() {
+  return state.productName;
+}
+__name(getDatabaseProductName, "getDatabaseProductName");
+async function resetDatabaseManager() {
+  if (state.client) {
+    try {
+      await state.client.disconnect();
+    } catch (error) {
+      logger.warn("[DatabaseManager] Error during disconnect on reset", {
+        error
+      });
+    }
+  }
+  state.initialized = false;
+  state.productName = null;
+  state.client = null;
+  logger.debug("[DatabaseManager] Database manager reset");
+}
+__name(resetDatabaseManager, "resetDatabaseManager");
+
+// src/prisma/health.ts
+async function checkDatabaseHealth(client) {
+  try {
+    const start = Date.now();
+    await client.$queryRaw`SELECT 1`;
+    const latency = Date.now() - start;
+    return {
+      healthy: true,
+      latency
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error("[Prisma] Health check failed", {
+      error: errorMessage
+    });
+    return {
+      healthy: false,
+      error: errorMessage
+    };
+  }
+}
+__name(checkDatabaseHealth, "checkDatabaseHealth");
+async function testConnection(client) {
+  try {
+    await client.$queryRaw`SELECT 1`;
+    return true;
+  } catch (error) {
+    logger.error("[Prisma] Connection test failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+__name(testConnection, "testConnection");
+async function getDatabaseVersion(client) {
+  try {
+    const result = await client.$queryRaw`SELECT version()`;
+    return result[0]?.version ?? null;
+  } catch (error) {
+    logger.error("[Prisma] Failed to get database version", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+__name(getDatabaseVersion, "getDatabaseVersion");
+async function getDatabaseStats(client) {
+  const [health, version] = await Promise.all([
+    checkDatabaseHealth(client),
+    getDatabaseVersion(client)
+  ]);
+  return {
+    health,
+    version,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+__name(getDatabaseStats, "getDatabaseStats");
+var requireFn = createRequire(import.meta.url);
+function loadGeneratedFields(generatedFieldsPath) {
+  try {
+    const generated = requireFn(generatedFieldsPath);
+    return generated.default || generated;
+  } catch (error) {
+    logger.error("[Prisma] Failed to load generated fields", {
+      error: error instanceof Error ? error.message : String(error),
+      path: generatedFieldsPath
+    });
+    throw new Error(`Failed to load generated fields from ${generatedFieldsPath}`);
+  }
+}
+__name(loadGeneratedFields, "loadGeneratedFields");
+function extractFieldsFromModel(modelName, modelFieldsMap, options = {}) {
+  const modelFields = modelFieldsMap[modelName];
+  if (!modelFields) {
+    throw new Error(`Model "${modelName}" not found in generated fields. Available models: ${Object.keys(modelFieldsMap).join(", ")}`);
+  }
+  const { excludeFields = [], includeRelations = false, customFilter } = options;
+  let fields = [
+    ...modelFields.fields
+  ];
+  if (includeRelations) {
+    fields = [
+      ...fields,
+      ...modelFields.relations
+    ];
+  }
+  const excluded = [];
+  if (excludeFields.length > 0) {
+    fields = fields.filter((field) => {
+      if (excludeFields.includes(field)) {
+        excluded.push(field);
+        return false;
+      }
+      return true;
+    });
+  }
+  if (customFilter) {
+    fields = fields.filter((fieldName) => {
+      const isRelation = modelFields.relations.includes(fieldName);
+      const shouldInclude = customFilter({
+        name: fieldName,
+        type: "unknown",
+        isRelation
+      });
+      if (!shouldInclude) {
+        excluded.push(fieldName);
+      }
+      return shouldInclude;
+    });
+  }
+  return {
+    fields,
+    metadata: {
+      totalFields: modelFields.fields.length + modelFields.relations.length,
+      excludedCount: excluded.length,
+      excludedFields: excluded,
+      relationFields: modelFields.relations.length
+    }
+  };
+}
+__name(extractFieldsFromModel, "extractFieldsFromModel");
+function getModelFields(modelName, modelFieldsMap, includeRelations = false) {
+  const result = extractFieldsFromModel(modelName, modelFieldsMap, {
+    includeRelations
+  });
+  return result.fields;
+}
+__name(getModelFields, "getModelFields");
+function hasModel(modelName, modelFieldsMap) {
+  return modelName in modelFieldsMap;
+}
+__name(hasModel, "hasModel");
+function getAllModelNames(modelFieldsMap) {
+  return Object.keys(modelFieldsMap);
+}
+__name(getAllModelNames, "getAllModelNames");
+
+// src/prisma/context.ts
+function buildContextWhereClause(contextFilter) {
+  if (!contextFilter) {
+    return void 0;
+  }
+  const conditions = [];
+  if (contextFilter.workspaceId != null) {
+    conditions.push({
+      path: [
+        "workspaceId"
+      ],
+      equals: contextFilter.workspaceId
+    });
+  }
+  if (contextFilter.userId != null) {
+    conditions.push({
+      path: [
+        "userId"
+      ],
+      equals: contextFilter.userId
+    });
+  }
+  if (contextFilter.projectId != null) {
+    conditions.push({
+      path: [
+        "projectId"
+      ],
+      equals: contextFilter.projectId
+    });
+  }
+  if (contextFilter.appId != null) {
+    conditions.push({
+      path: [
+        "appId"
+      ],
+      equals: contextFilter.appId
+    });
+  }
+  if (contextFilter.productId != null) {
+    conditions.push({
+      path: [
+        "productId"
+      ],
+      equals: contextFilter.productId
+    });
+  }
+  if (contextFilter.organizationId != null) {
+    conditions.push({
+      path: [
+        "organizationId"
+      ],
+      equals: contextFilter.organizationId
+    });
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return conditions[0];
+}
+__name(buildContextWhereClause, "buildContextWhereClause");
+function buildContextWhereConditions(contextFilter) {
+  if (!contextFilter) {
+    return [];
+  }
+  const conditions = [];
+  if (contextFilter.workspaceId != null) {
+    conditions.push({
+      context: {
+        path: [
+          "workspaceId"
+        ],
+        equals: contextFilter.workspaceId
+      }
+    });
+  }
+  if (contextFilter.userId != null) {
+    conditions.push({
+      context: {
+        path: [
+          "userId"
+        ],
+        equals: contextFilter.userId
+      }
+    });
+  }
+  if (contextFilter.projectId != null) {
+    conditions.push({
+      context: {
+        path: [
+          "projectId"
+        ],
+        equals: contextFilter.projectId
+      }
+    });
+  }
+  if (contextFilter.appId != null) {
+    conditions.push({
+      context: {
+        path: [
+          "appId"
+        ],
+        equals: contextFilter.appId
+      }
+    });
+  }
+  if (contextFilter.productId != null) {
+    conditions.push({
+      context: {
+        path: [
+          "productId"
+        ],
+        equals: contextFilter.productId
+      }
+    });
+  }
+  if (contextFilter.organizationId != null) {
+    conditions.push({
+      context: {
+        path: [
+          "organizationId"
+        ],
+        equals: contextFilter.organizationId
+      }
+    });
+  }
+  return conditions;
+}
+__name(buildContextWhereConditions, "buildContextWhereConditions");
+function toContextJson(contextInput) {
+  if (!contextInput) {
+    return void 0;
+  }
+  const context = {};
+  if (contextInput.workspaceId != null) {
+    context["workspaceId"] = contextInput.workspaceId;
+  }
+  if (contextInput.userId != null) {
+    context["userId"] = contextInput.userId;
+  }
+  if (contextInput.projectId != null) {
+    context["projectId"] = contextInput.projectId;
+  }
+  if (contextInput.appId != null) {
+    context["appId"] = contextInput.appId;
+  }
+  if (contextInput.productId != null) {
+    context["productId"] = contextInput.productId;
+  }
+  if (contextInput.organizationId != null) {
+    context["organizationId"] = contextInput.organizationId;
+  }
+  if (contextInput.custom != null) {
+    context["custom"] = contextInput.custom;
+  }
+  if (Object.keys(context).length === 0) {
+    return void 0;
+  }
+  return context;
+}
+__name(toContextJson, "toContextJson");
+function filterNullValues(obj) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== null) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+__name(filterNullValues, "filterNullValues");
+function mergeContextField(merged, fieldName, fieldValue) {
+  if (fieldValue === void 0) {
+    return;
+  }
+  if (fieldValue === null) {
+    delete merged[fieldName];
+  } else {
+    merged[fieldName] = fieldValue;
+  }
+}
+__name(mergeContextField, "mergeContextField");
+function mergeContext(existingContext, newContext) {
+  if (!newContext) {
+    if (!existingContext) {
+      return void 0;
+    }
+    if (typeof existingContext === "object" && !Array.isArray(existingContext)) {
+      const filtered = filterNullValues(existingContext);
+      return Object.keys(filtered).length > 0 ? filtered : void 0;
+    }
+    return existingContext;
+  }
+  if (!existingContext || typeof existingContext !== "object" || Array.isArray(existingContext)) {
+    return toContextJson(newContext);
+  }
+  const merged = filterNullValues(existingContext);
+  mergeContextField(merged, "workspaceId", newContext.workspaceId);
+  mergeContextField(merged, "userId", newContext.userId);
+  mergeContextField(merged, "projectId", newContext.projectId);
+  mergeContextField(merged, "appId", newContext.appId);
+  mergeContextField(merged, "productId", newContext.productId);
+  mergeContextField(merged, "organizationId", newContext.organizationId);
+  mergeContextField(merged, "custom", newContext.custom);
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+__name(mergeContext, "mergeContext");
+function parseContext(contextJson) {
+  if (!contextJson || typeof contextJson !== "object" || Array.isArray(contextJson)) {
+    return null;
+  }
+  const ctx = contextJson;
+  return {
+    workspaceId: typeof ctx["workspaceId"] === "string" ? ctx["workspaceId"] : null,
+    userId: typeof ctx["userId"] === "string" ? ctx["userId"] : null,
+    projectId: typeof ctx["projectId"] === "string" ? ctx["projectId"] : null,
+    appId: typeof ctx["appId"] === "string" ? ctx["appId"] : null,
+    productId: typeof ctx["productId"] === "string" ? ctx["productId"] : null,
+    organizationId: typeof ctx["organizationId"] === "string" ? ctx["organizationId"] : null,
+    custom: typeof ctx["custom"] === "object" ? ctx["custom"] : null
+  };
+}
+__name(parseContext, "parseContext");
+function contextMatches(context, filter) {
+  if (!context) {
+    return false;
+  }
+  if (filter.workspaceId != null && context.workspaceId !== filter.workspaceId) {
+    return false;
+  }
+  if (filter.userId != null && context.userId !== filter.userId) {
+    return false;
+  }
+  if (filter.projectId != null && context.projectId !== filter.projectId) {
+    return false;
+  }
+  if (filter.appId != null && context.appId !== filter.appId) {
+    return false;
+  }
+  if (filter.productId != null && context.productId !== filter.productId) {
+    return false;
+  }
+  if (filter.organizationId != null && context.organizationId !== filter.organizationId) {
+    return false;
+  }
+  return true;
+}
+__name(contextMatches, "contextMatches");
+function createContextFromSDK(sdkContext) {
+  return {
+    workspaceId: sdkContext.workspaceId ?? null,
+    userId: sdkContext.userId ?? null,
+    projectId: sdkContext.projectId ?? null,
+    appId: sdkContext.appId ?? null,
+    productId: sdkContext.productId ?? null,
+    organizationId: sdkContext.organizationId ?? null
+  };
+}
+__name(createContextFromSDK, "createContextFromSDK");
+
+export { PrismaClientWrapper, buildContextWhereClause, buildContextWhereConditions, checkDatabaseHealth, configurePrismaLogging, contextMatches, createConnectionPool, createContextFromSDK, createDatabaseClient, createDatabaseClientFromEnv, createPrismaAdapter, createPrismaClient, extractFieldsFromModel, getAllModelNames, getDatabaseManager, getDatabaseProductName, getDatabaseStats, getDatabaseVersion, getDb, getModelFields, hasModel, initializeDatabase, initializeDatabaseWithConfig, isDatabaseInitialized, loadGeneratedFields, mergeContext, parseContext, prisma_exports, resetDatabaseManager, testConnection, toContextJson };
+//# sourceMappingURL=chunk-2SD5L2F2.js.map
+//# sourceMappingURL=chunk-2SD5L2F2.js.map