feat(workday): block + tools + misc fixes

apps/sim/app/api/tools/workday/assign-onboarding/route.ts

@@ -0,0 +1,67 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { createWorkdaySoapClient, extractRefId, wdRef } from '@/tools/workday/soap'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('WorkdayAssignOnboardingAPI')
+
+const RequestSchema = z.object({
+  tenantUrl: z.string().min(1),
+  tenant: z.string().min(1),
+  username: z.string().min(1),
+  password: z.string().min(1),
+  workerId: z.string().min(1),
+  onboardingPlanId: z.string().min(1),
+  actionEventId: z.string().min(1),
+})
+
+export async function POST(request: NextRequest) {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const data = RequestSchema.parse(body)
+
+    const client = await createWorkdaySoapClient(
+      data.tenantUrl,
+      data.tenant,
+      'humanResources',
+      data.username,
+      data.password
+    )
+
+    const [result] = await client.Put_Onboarding_Plan_AssignmentAsync({
+      Onboarding_Plan_Assignment_Data: {
+        Onboarding_Plan_Reference: wdRef('Onboarding_Plan_ID', data.onboardingPlanId),
+        Person_Reference: wdRef('WID', data.workerId),
+        Action_Event_Reference: wdRef('Background_Check_ID', data.actionEventId),
+        Assignment_Effective_Moment: new Date().toISOString(),
+        Active: true,
+      },
+    })
+
+    return NextResponse.json({
+      success: true,
+      output: {
+        assignmentId: extractRefId(result?.Onboarding_Plan_Assignment_Reference),
+        workerId: data.workerId,
+        planId: data.onboardingPlanId,
+      },
+    })
+  } catch (error) {
+    logger.error(`[${requestId}] Workday assign onboarding failed`, { error })
+    return NextResponse.json(
+      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+      { status: 500 }
+    )
+  }
+}

apps/sim/app/api/tools/workday/change-job/route.ts

@@ -0,0 +1,94 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { createWorkdaySoapClient, extractRefId, wdRef } from '@/tools/workday/soap'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('WorkdayChangeJobAPI')
+
+const RequestSchema = z.object({
+  tenantUrl: z.string().min(1),
+  tenant: z.string().min(1),
+  username: z.string().min(1),
+  password: z.string().min(1),
+  workerId: z.string().min(1),
+  effectiveDate: z.string().min(1),
+  newPositionId: z.string().optional(),
+  newJobProfileId: z.string().optional(),
+  newLocationId: z.string().optional(),
+  newSupervisoryOrgId: z.string().optional(),
+  reason: z.string().min(1, 'Reason is required for job changes'),
+})
+
+export async function POST(request: NextRequest) {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const data = RequestSchema.parse(body)
+
+    const changeJobDetailData: Record<string, unknown> = {
+      Reason_Reference: wdRef('Change_Job_Subcategory_ID', data.reason),
+    }
+    if (data.newPositionId) {
+      changeJobDetailData.Position_Reference = wdRef('Position_ID', data.newPositionId)
+    }
+    if (data.newJobProfileId) {
+      changeJobDetailData.Job_Profile_Reference = wdRef('Job_Profile_ID', data.newJobProfileId)
+    }
+    if (data.newLocationId) {
+      changeJobDetailData.Location_Reference = wdRef('Location_ID', data.newLocationId)
+    }
+    if (data.newSupervisoryOrgId) {
+      changeJobDetailData.Supervisory_Organization_Reference = wdRef(
+        'Supervisory_Organization_ID',
+        data.newSupervisoryOrgId
+      )
+    }
+
+    const client = await createWorkdaySoapClient(
+      data.tenantUrl,
+      data.tenant,
+      'staffing',
+      data.username,
+      data.password
+    )
+
+    const [result] = await client.Change_JobAsync({
+      Business_Process_Parameters: {
+        Auto_Complete: true,
+        Run_Now: true,
+      },
+      Change_Job_Data: {
+        Worker_Reference: wdRef('Employee_ID', data.workerId),
+        Effective_Date: data.effectiveDate,
+        Change_Job_Detail_Data: changeJobDetailData,
+      },
+    })
+
+    const eventRef = result?.Event_Reference
+
+    return NextResponse.json({
+      success: true,
+      output: {
+        eventId: extractRefId(eventRef),
+        workerId: data.workerId,
+        effectiveDate: data.effectiveDate,
+      },
+    })
+  } catch (error) {
+    logger.error(`[${requestId}] Workday change job failed`, { error })
+    return NextResponse.json(
+      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+      { status: 500 }
+    )
+  }
+}

apps/sim/app/api/tools/workday/create-prehire/route.ts

@@ -0,0 +1,134 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { createWorkdaySoapClient, extractRefId, wdRef } from '@/tools/workday/soap'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('WorkdayCreatePrehireAPI')
+
+const RequestSchema = z.object({
+  tenantUrl: z.string().min(1),
+  tenant: z.string().min(1),
+  username: z.string().min(1),
+  password: z.string().min(1),
+  legalName: z.string().min(1),
+  email: z.string().optional(),
+  phoneNumber: z.string().optional(),
+  address: z.string().optional(),
+  countryCode: z.string().optional(),
+})
+
+export async function POST(request: NextRequest) {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const data = RequestSchema.parse(body)
+
+    if (!data.email && !data.phoneNumber && !data.address) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: 'At least one contact method (email, phone, or address) is required',
+        },
+        { status: 400 }
+      )
+    }
+
+    const parts = data.legalName.trim().split(/\s+/)
+    const firstName = parts[0] ?? ''
+    const lastName = parts.length > 1 ? parts.slice(1).join(' ') : ''
+
+    if (!lastName) {
+      return NextResponse.json(
+        { success: false, error: 'Legal name must include both a first name and last name' },
+        { status: 400 }
+      )
+    }
+
+    const client = await createWorkdaySoapClient(
+      data.tenantUrl,
+      data.tenant,
+      'staffing',
+      data.username,
+      data.password
+    )
+
+    const contactData: Record<string, unknown> = {}
+    if (data.email) {
+      contactData.Email_Address_Data = [
+        {
+          Email_Address: data.email,
+          Usage_Data: {
+            Type_Data: { Type_Reference: wdRef('Communication_Usage_Type_ID', 'WORK') },
+            Public: true,
+          },
+        },
+      ]
+    }
+    if (data.phoneNumber) {
+      contactData.Phone_Data = [
+        {
+          Phone_Number: data.phoneNumber,
+          Phone_Device_Type_Reference: wdRef('Phone_Device_Type_ID', 'Landline'),
+          Usage_Data: {
+            Type_Data: { Type_Reference: wdRef('Communication_Usage_Type_ID', 'WORK') },
+            Public: true,
+          },
+        },
+      ]
+    }
+    if (data.address) {
+      contactData.Address_Data = [
+        {
+          Formatted_Address: data.address,
+          Usage_Data: {
+            Type_Data: { Type_Reference: wdRef('Communication_Usage_Type_ID', 'WORK') },
+            Public: true,
+          },
+        },
+      ]
+    }
+
+    const [result] = await client.Put_ApplicantAsync({
+      Applicant_Data: {
+        Personal_Data: {
+          Name_Data: {
+            Legal_Name_Data: {
+              Name_Detail_Data: {
+                Country_Reference: wdRef('ISO_3166-1_Alpha-2_Code', data.countryCode ?? 'US'),
+                First_Name: firstName,
+                Last_Name: lastName,
+              },
+            },
+          },
+          Contact_Information_Data: contactData,
+        },
+      },
+    })
+
+    const applicantRef = result?.Applicant_Reference
+
+    return NextResponse.json({
+      success: true,
+      output: {
+        preHireId: extractRefId(applicantRef),
+        descriptor: applicantRef?.attributes?.Descriptor ?? null,
+      },
+    })
+  } catch (error) {
+    logger.error(`[${requestId}] Workday create prehire failed`, { error })
+    return NextResponse.json(
+      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+      { status: 500 }
+    )
+  }
+}

apps/sim/app/api/tools/workday/get-compensation/route.ts

@@ -0,0 +1,101 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { createWorkdaySoapClient, extractRefId, type WorkdayReference } from '@/tools/workday/soap'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('WorkdayGetCompensationAPI')
+
+const RequestSchema = z.object({
+  tenantUrl: z.string().min(1),
+  tenant: z.string().min(1),
+  username: z.string().min(1),
+  password: z.string().min(1),
+  workerId: z.string().min(1),
+})
+
+export async function POST(request: NextRequest) {
+  const requestId = generateRequestId()
+
+  try {
+    const authResult = await checkInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const data = RequestSchema.parse(body)
+
+    const client = await createWorkdaySoapClient(
+      data.tenantUrl,
+      data.tenant,
+      'humanResources',
+      data.username,
+      data.password
+    )
+
+    const [result] = await client.Get_WorkersAsync({
+      Request_References: {
+        Worker_Reference: {
+          ID: { attributes: { 'wd:type': 'Employee_ID' }, $value: data.workerId },
+        },
+      },
+      Response_Group: {
+        Include_Reference: true,
+        Include_Compensation: true,
+      },
+    })
+
+    const rawWorker = result?.Response_Data?.Worker
+    const workerData = (Array.isArray(rawWorker) ? rawWorker[0] : (rawWorker ?? null)) as Record<
+      string,
+      unknown
+    > | null
+    const workerInner = workerData?.Worker_Data as Record<string, unknown> | undefined
+    const compensationData = workerInner?.Compensation_Data as Record<string, unknown> | undefined
+
+    const mapPlan = (p: Record<string, unknown>) => ({
+      id: extractRefId(p.Compensation_Plan_Reference as WorkdayReference | undefined) ?? null,
+      planName:
+        (p.Compensation_Plan_Reference as Record<string, unknown> | undefined)?.attributes
+          ?.Descriptor ?? null,
+      amount: p.Amount ?? p.Per_Unit_Amount ?? p.Individual_Target_Amount ?? null,
+      currency: extractRefId(p.Currency_Reference as WorkdayReference | undefined) ?? null,
+      frequency: extractRefId(p.Frequency_Reference as WorkdayReference | undefined) ?? null,
+    })
+
+    const planTypes = [
+      'Employee_Base_Pay_Plan_Assignment_Data',
+      'Employee_Salary_Unit_Plan_Assignment_Data',
+      'Employee_Bonus_Plan_Assignment_Data',
+      'Employee_Allowance_Plan_Assignment_Data',
+      'Employee_Commission_Plan_Assignment_Data',
+      'Employee_Stock_Plan_Assignment_Data',
+      'Employee_Period_Salary_Plan_Assignment_Data',
+    ] as const
+
+    const compensationPlans: ReturnType<typeof mapPlan>[] = []
+    for (const planType of planTypes) {
+      const raw = compensationData?.[planType]
+      if (!raw) continue
+      const arr = Array.isArray(raw) ? raw : [raw]
+      for (const p of arr) {
+        compensationPlans.push(mapPlan(p as Record<string, unknown>))
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      output: { compensationPlans },
+    })
+  } catch (error) {
+    logger.error(`[${requestId}] Workday get compensation failed`, { error })
+    return NextResponse.json(
+      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+      { status: 500 }
+    )
+  }
+}