next-workflow-builder 0.3.0

package/dist/chunk-7MUXUHEL.js

@@ -0,0 +1,66 @@
+import {
+  db,
+  workflows
+} from "./chunk-3MSAF2TH.js";
+
+// src/server/lib/metadata.ts
+import { eq } from "drizzle-orm";
+async function generateWorkflowMetadata({
+  params
+}) {
+  const { slug } = await params;
+  if (slug?.[0] !== "workflows" || !slug?.[1]) {
+    return null;
+  }
+  const workflowId = slug[1];
+  let title = "Workflow";
+  let isPublic = false;
+  try {
+    const workflow = await db.query.workflows.findFirst({
+      where: eq(workflows.id, workflowId),
+      columns: {
+        name: true,
+        visibility: true
+      }
+    });
+    if (workflow) {
+      isPublic = workflow.visibility === "public";
+      if (isPublic) {
+        title = workflow.name;
+      }
+    }
+  } catch {
+  }
+  const baseUrl = process.env.NEXT_PUBLIC_APP_URL || "https://workflow-builder.dev";
+  const workflowUrl = `${baseUrl}/workflows/${workflowId}`;
+  const ogImageUrl = isPublic ? `${baseUrl}/api/og/workflow/${workflowId}` : `${baseUrl}/og-default.png`;
+  return {
+    title: `${title} | AI Workflow Builder`,
+    description: `View and explore the "${title}" workflow built with AI Workflow Builder.`,
+    openGraph: {
+      title: `${title} | AI Workflow Builder`,
+      description: `View and explore the "${title}" workflow built with AI Workflow Builder.`,
+      type: "website",
+      url: workflowUrl,
+      siteName: "AI Workflow Builder",
+      images: [
+        {
+          url: ogImageUrl,
+          width: 1200,
+          height: 630,
+          alt: `${title} workflow visualization`
+        }
+      ]
+    },
+    twitter: {
+      card: "summary_large_image",
+      title: `${title} | AI Workflow Builder`,
+      description: `View and explore the "${title}" workflow built with AI Workflow Builder.`,
+      images: [ogImageUrl]
+    }
+  };
+}
+
+export {
+  generateWorkflowMetadata
+};

package/dist/chunk-BNYDOC3I.js

@@ -0,0 +1,169 @@
+import {
+  db,
+  integrations
+} from "./chunk-3MSAF2TH.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
+};