// Start transaction for atomic creation
    const result = await db.transaction(async (tx) => {
      const now = new Date();
      

    // Create species with call types (no transaction support in neon-http driver)
    const now = new Date();
    let result;
    
    try {

      const [createdSpecies] = await tx.insert(species).values(newSpecies).returning({

      const [createdSpecies] = await db.insert(species).values(newSpecies).returning({

      await tx.insert(speciesDataset).values({

      await db.insert(speciesDataset).values({

          const [createdCallType] = await tx.insert(callType).values({

          const [createdCallType] = await db.insert(callType).values({

      return {

      result = {

    });

    } catch (error) {
      console.error("Error creating species:", error);
      throw error;
    }

    // Create cluster with optional recording pattern in transaction
    const result = await db.transaction(async (tx) => {
      const now = new Date();
      let cyclicRecordingPatternId = null;

    // Create cluster with optional recording pattern (no transaction support in neon-http driver)
    const now = new Date();
    let cyclicRecordingPatternId = null;
    let result;

    try {

        const [createdPattern] = await tx.insert(cyclicRecordingPattern).values({

        const [createdPattern] = await db.insert(cyclicRecordingPattern).values({

      const [createdCluster] = await tx.insert(cluster).values(newCluster).returning({

      const [createdCluster] = await db.insert(cluster).values(newCluster).returning({

      return {

      result = {

    });

    } catch (error) {
      // If cluster creation failed and we created a recording pattern, we should clean it up
      // However, without transactions, this creates a potential orphaned record
      // In practice, orphaned recording patterns can be cleaned up separately
      console.error("Error creating cluster:", error);
      throw error;
    }

    // Update cluster with optional recording pattern changes in transaction
    const result = await db.transaction(async (tx) => {
      const currentPatternId = clusterRecord.cyclicRecordingPatternId;

    // Update cluster with optional recording pattern changes (no transaction support in neon-http driver)
    const currentPatternId = clusterRecord.cyclicRecordingPatternId;
    let result;

    try {

            await tx

            await db

            await tx

            await db

            await tx.insert(cyclicRecordingPattern).values({

            await db.insert(cyclicRecordingPattern).values({

      const [updatedCluster] = await tx

      const [updatedCluster] = await db

          const existingPattern = await tx

          const existingPattern = await db

      return {

      result = {

    });

    } catch (error) {
      console.error("Error updating cluster:", error);
      throw error;
    }

    // Soft delete cluster and hard delete associated recording pattern in transaction
    await db.transaction(async (tx) => {

    // Soft delete cluster and associated recording pattern (no transaction support in neon-http driver)
    try {

      await tx

      await db

        await tx

        await db

    });

    } catch (error) {
      console.error("Error deleting cluster:", error);
      throw error;
    }