prompt editorial workflow fixes

Author: chad-syntax

.nvmrc

@@ -1 +1 @@
-22.13.1
+22.14.0

src/app/actions/prompts.ts

@@ -2,6 +2,8 @@
 
 import { createClient } from '@/lib/supabase/server';
 import { Database } from '@/app/__generated__/supabase.types';
+import { compareSemanticVersions, incrementVersion } from '@/utils/versioning';
+import { SEMVER_PATTERN } from '@/app/constants';
 
 type CreatePromptVersionOptions = {
   promptId: number;
@@ -261,3 +263,202 @@ export async function createPrompt(options: CreatePromptOptions) {
     throw error;
   }
 }
+
+type CreatePromptWithDraftVersionOptions = {
+  name: string;
+  projectId: number;
+};
+
+export async function createPromptWithDraftVersion(
+  options: CreatePromptWithDraftVersionOptions
+) {
+  const { name, projectId } = options;
+  const supabase = await createClient();
+
+  try {
+    // Generate a slug from the name
+    const slug = name
+      .toLowerCase()
+      .replace(/\s+/g, '-')
+      .replace(/[^a-z0-9-]/g, '');
+
+    // Create a new prompt
+    const { data: promptData, error: promptError } = await supabase
+      .from('prompts')
+      .insert({
+        name,
+        project_id: projectId,
+        slug,
+      })
+      .select('id, uuid')
+      .single();
+
+    if (promptError || !promptData) {
+      throw new Error('Failed to create prompt: ' + promptError?.message);
+    }
+
+    const newPromptId = promptData.id;
+    const newPromptUuid = promptData.uuid;
+
+    // Create a new draft version
+    const { data: versionData, error: versionError } = await supabase
+      .from('prompt_versions')
+      .insert({
+        prompt_id: newPromptId,
+        content: '',
+        config: { model: 'openrouter/auto' },
+        status: 'DRAFT',
+        version: '0.0.1',
+      })
+      .select('id, uuid')
+      .single();
+
+    if (versionError || !versionData) {
+      // If we failed to create a version, delete the prompt to avoid orphans
+      await supabase.from('prompts').delete().eq('id', newPromptId);
+      throw new Error(
+        'Failed to create prompt version: ' + versionError?.message
+      );
+    }
+
+    return {
+      promptUuid: newPromptUuid,
+      versionUuid: versionData.uuid,
+    };
+  } catch (error) {
+    console.error('Error creating prompt with draft version:', error);
+    throw error;
+  }
+}
+
+type CreateDraftVersionOptions = {
+  promptId: number;
+  promptUuid: string;
+  latestVersion: string;
+  customVersion?: string;
+  versionType?: 'major' | 'minor' | 'patch';
+};
+
+export async function createDraftVersion(options: CreateDraftVersionOptions) {
+  const {
+    promptId,
+    promptUuid,
+    latestVersion,
+    customVersion,
+    versionType = 'patch',
+  } = options;
+  const supabase = await createClient();
+
+  try {
+    // First, get ALL versions for this prompt to find existing versions
+    const { data: allVersions, error: versionsError } = await supabase
+      .from('prompt_versions')
+      .select('version')
+      .eq('prompt_id', promptId);
+
+    if (versionsError) {
+      throw new Error('Failed to fetch versions: ' + versionsError.message);
+    }
+
+    // Determine the new version number
+    let newVersion: string;
+
+    if (customVersion) {
+      // If a custom version is provided, use it but verify it doesn't already exist
+      const versionExists = allVersions?.some(
+        (v) => v.version === customVersion
+      );
+      if (versionExists) {
+        throw new Error(
+          `Version ${customVersion} already exists for this prompt`
+        );
+      }
+
+      // Validate semantic versioning pattern
+      if (!SEMVER_PATTERN.test(customVersion)) {
+        throw new Error(
+          'Version must follow semantic versioning (e.g., 1.0.0)'
+        );
+      }
+
+      newVersion = customVersion;
+    } else {
+      // Find the highest version number
+      let highestVersion = latestVersion;
+      if (allVersions && allVersions.length > 0) {
+        highestVersion = allVersions.reduce((highest, current) => {
+          return compareSemanticVersions(current.version, highest) > 0
+            ? current.version
+            : highest;
+        }, latestVersion);
+      }
+
+      // Calculate new version number based on the highest version
+      newVersion = incrementVersion(highestVersion, versionType);
+    }
+
+    // Get latest version to copy content
+    const { data: latestVersionData, error: latestVersionError } =
+      await supabase
+        .from('prompt_versions')
+        .select('content, config, prompt_variables(*)')
+        .eq('prompt_id', promptId)
+        .eq('version', latestVersion)
+        .single();
+
+    if (latestVersionError || !latestVersionData) {
+      throw new Error(
+        'Failed to find latest version: ' + latestVersionError?.message
+      );
+    }
+
+    // Create new draft version
+    const { data: newVersionData, error: newVersionError } = await supabase
+      .from('prompt_versions')
+      .insert({
+        prompt_id: promptId,
+        content: latestVersionData.content,
+        config: latestVersionData.config,
+        status: 'DRAFT',
+        version: newVersion,
+      })
+      .select('id, uuid')
+      .single();
+
+    if (newVersionError || !newVersionData) {
+      throw new Error(
+        'Failed to create new version: ' + newVersionError?.message
+      );
+    }
+
+    // Copy variables from the latest version
+    if (
+      latestVersionData.prompt_variables &&
+      latestVersionData.prompt_variables.length > 0
+    ) {
+      const variablesToInsert = latestVersionData.prompt_variables.map(
+        (variable: any) => ({
+          prompt_version_id: newVersionData.id,
+          name: variable.name,
+          type: variable.type,
+          required: variable.required,
+        })
+      );
+
+      const { error: variablesError } = await supabase
+        .from('prompt_variables')
+        .insert(variablesToInsert);
+
+      if (variablesError) {
+        throw new Error(
+          'Failed to copy prompt variables: ' + variablesError.message
+        );
+      }
+    }
+
+    return { versionUuid: newVersionData.uuid };
+  } catch (error) {
+    console.error('Error creating draft version:', error);
+    throw error;
+  }
+}

src/app/api/[apiVersion]/promptVersion/[promptVersionUuid]/compile/route.tsx

@@ -0,0 +1,73 @@
+import {
+  compilePrompt,
+  getMissingVariables,
+  getPromptVersionByUuid,
+} from '@/lib/prompts';
+import { createClient } from '@/lib/supabase/server';
+import { NextResponse } from 'next/server';
+
+type RequestBody = {
+  variables: Record<string, string | number | boolean>;
+};
+
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ promptVersionUuid: string }> }
+) {
+  const { promptVersionUuid } = await params;
+
+  if (!promptVersionUuid) {
+    return NextResponse.json(
+      { error: 'Prompt Version UUID is required' },
+      { status: 400 }
+    );
+  }
+
+  const supabase = await createClient();
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  // Fetch the prompt from Supabase
+  const promptVersion = await getPromptVersionByUuid(promptVersionUuid);
+
+  if (!promptVersion) {
+    return NextResponse.json(
+      { error: 'Prompt version not found' },
+      { status: 404 }
+    );
+  }
+
+  const variables = promptVersion.prompt_variables || [];
+
+  let body: RequestBody;
+  try {
+    body = await request.json();
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Invalid request body' },
+      { status: 400 }
+    );
+  }
+
+  const missingVariables = getMissingVariables(variables, body.variables);
+
+  if (missingVariables.length > 0) {
+    return NextResponse.json(
+      {
+        error: 'Missing required variables',
+        missingVariables,
+      },
+      { status: 400 }
+    );
+  }
+
+  const compiledPrompt = compilePrompt(promptVersion.content, body.variables);
+
+  return NextResponse.json({ compiledPrompt }, { status: 200 });
+}