next-workflow-builder 0.5.0 → 0.7.0

package/dist/chunk-CKE7ETZL.js

@@ -1,169 +0,0 @@
-import {
-  db,
-  integrations
-} from "./chunk-PEVVELQ6.js";
-
-// src/server/db/integrations.ts
-import "server-only";
-import { and, eq, inArray } from "drizzle-orm";
-import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
-var ALGORITHM = "aes-256-gcm";
-var IV_LENGTH = 16;
-var ENCRYPTION_KEY_ENV = "INTEGRATION_ENCRYPTION_KEY";
-function getEncryptionKey() {
-  const keyHex = process.env[ENCRYPTION_KEY_ENV];
-  if (!keyHex) {
-    throw new Error(
-      `${ENCRYPTION_KEY_ENV} environment variable is required for encrypting integration credentials`
-    );
-  }
-  if (keyHex.length !== 64) {
-    throw new Error(
-      `${ENCRYPTION_KEY_ENV} must be a 64-character hex string (32 bytes)`
-    );
-  }
-  return Buffer.from(keyHex, "hex");
-}
-function encrypt(plaintext) {
-  const key = getEncryptionKey();
-  const iv = randomBytes(IV_LENGTH);
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-  let encrypted = cipher.update(plaintext, "utf8", "hex");
-  encrypted += cipher.final("hex");
-  const authTag = cipher.getAuthTag();
-  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
-}
-function decrypt(ciphertext) {
-  const key = getEncryptionKey();
-  const parts = ciphertext.split(":");
-  if (parts.length !== 3) {
-    throw new Error("Invalid encrypted data format");
-  }
-  const iv = Buffer.from(parts[0], "hex");
-  const authTag = Buffer.from(parts[1], "hex");
-  const encrypted = parts[2];
-  const decipher = createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(authTag);
-  let decrypted = decipher.update(encrypted, "hex", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
-}
-function encryptConfig(config) {
-  return encrypt(JSON.stringify(config));
-}
-function decryptConfig(encryptedConfig) {
-  try {
-    const decrypted = decrypt(encryptedConfig);
-    return JSON.parse(decrypted);
-  } catch (error) {
-    console.error("Failed to decrypt integration config:", error);
-    return {};
-  }
-}
-async function getIntegrations(userId, type) {
-  const conditions = [eq(integrations.userId, userId)];
-  if (type) {
-    conditions.push(eq(integrations.type, type));
-  }
-  const results = await db.select().from(integrations).where(and(...conditions));
-  return results.map((integration) => ({
-    ...integration,
-    config: decryptConfig(integration.config)
-  }));
-}
-async function getIntegration(integrationId, userId) {
-  const result = await db.select().from(integrations).where(
-    and(eq(integrations.id, integrationId), eq(integrations.userId, userId))
-  ).limit(1);
-  if (result.length === 0) {
-    return null;
-  }
-  return {
-    ...result[0],
-    config: decryptConfig(result[0].config)
-  };
-}
-async function getIntegrationById(integrationId) {
-  const result = await db.select().from(integrations).where(eq(integrations.id, integrationId)).limit(1);
-  if (result.length === 0) {
-    return null;
-  }
-  return {
-    ...result[0],
-    config: decryptConfig(result[0].config)
-  };
-}
-async function createIntegration(userId, name, type, config) {
-  const encryptedConfig = encryptConfig(config);
-  const [result] = await db.insert(integrations).values({
-    userId,
-    name,
-    type,
-    config: encryptedConfig
-  }).returning();
-  return {
-    ...result,
-    config
-  };
-}
-async function updateIntegration(integrationId, userId, updates) {
-  const updateData = {
-    updatedAt: /* @__PURE__ */ new Date()
-  };
-  if (updates.name !== void 0) {
-    updateData.name = updates.name;
-  }
-  if (updates.config !== void 0) {
-    updateData.config = encryptConfig(updates.config);
-  }
-  const [result] = await db.update(integrations).set(updateData).where(
-    and(eq(integrations.id, integrationId), eq(integrations.userId, userId))
-  ).returning();
-  if (!result) {
-    return null;
-  }
-  return {
-    ...result,
-    config: decryptConfig(result.config)
-  };
-}
-async function deleteIntegration(integrationId, userId) {
-  const result = await db.delete(integrations).where(
-    and(eq(integrations.id, integrationId), eq(integrations.userId, userId))
-  ).returning();
-  return result.length > 0;
-}
-function extractIntegrationIds(nodes) {
-  const integrationIds = [];
-  for (const node of nodes) {
-    const integrationId = node.data?.config?.integrationId;
-    if (integrationId && typeof integrationId === "string") {
-      integrationIds.push(integrationId);
-    }
-  }
-  return [...new Set(integrationIds)];
-}
-async function validateWorkflowIntegrations(nodes, userId) {
-  const integrationIds = extractIntegrationIds(nodes);
-  if (integrationIds.length === 0) {
-    return { valid: true };
-  }
-  const existingIntegrations = await db.select({ id: integrations.id, userId: integrations.userId }).from(integrations).where(inArray(integrations.id, integrationIds));
-  const invalidIds = existingIntegrations.filter((i) => i.userId !== userId).map((i) => i.id);
-  if (invalidIds.length > 0) {
-    return { valid: false, invalidIds };
-  }
-  return { valid: true };
-}
-
-export {
-  encrypt,
-  decrypt,
-  getIntegrations,
-  getIntegration,
-  getIntegrationById,
-  createIntegration,
-  updateIntegration,
-  deleteIntegration,
-  validateWorkflowIntegrations
-};