autopilot-core-sandbox 0.0.1

package/dist/dist/providers/JobsProvider.js

@@ -0,0 +1,863 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useJobsProvider = void 0;
+const react_1 = require("react");
+const Provider_1 = require("../Provider");
+const server_safe_1 = require("../server-safe");
+const helpers_1 = require("../server-safe/helpers");
+const JobFunctions_1 = require("../server-safe/JobFunctions");
+const TagFunctions_1 = require("../server-safe/TagFunctions");
+const trash_1 = require("../server-safe/trash");
+const LogHandler_1 = require("../utils/LogHandler");
+const RECURRING_TEMPLATE_PAGE_SIZE = 500;
+const useJobsProvider = () => {
+    const { supabase, debugMode } = (0, Provider_1.useAutopilotProvider)();
+    const fetchRecurringJobTemplates = (0, react_1.useCallback)(async (companyId) => {
+        const recurringRows = [];
+        let from = 0;
+        while (true) {
+            const { data, error } = await supabase
+                .from('job_recurring')
+                .select('*, job_user_recurring(*)')
+                .eq('company_id', companyId)
+                .is('deleted_at', null)
+                .order('id', { ascending: true })
+                .range(from, from + RECURRING_TEMPLATE_PAGE_SIZE - 1);
+            if (error) {
+                (0, LogHandler_1.captureErrorException)('error fetching recurring templates', error);
+                throw error;
+            }
+            const page = data ?? [];
+            recurringRows.push(...page);
+            if (page.length < RECURRING_TEMPLATE_PAGE_SIZE)
+                break;
+            from += RECURRING_TEMPLATE_PAGE_SIZE;
+        }
+        return recurringRows.map((jobRecurring) => ({
+            ...jobRecurring,
+            job_user: jobRecurring.job_user_recurring,
+        }));
+    }, [supabase]);
+    const createJob = (0, react_1.useCallback)(async (jobData, schedule, tags, rrule) => {
+        const companyId = jobData.company_id;
+        if (jobData.estimate_id) {
+            const { data: existingJob, error: existingJobError } = await supabase
+                .from('job')
+                .select('id')
+                .eq('estimate_id', jobData.estimate_id)
+                .is('deleted_at', null)
+                .maybeSingle();
+            if (existingJobError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('createJob DUPLICATE CHECK ERROR: ', existingJobError);
+                throw existingJobError;
+            }
+            if (existingJob) {
+                throw new Error('A job already exists for this estimate');
+            }
+        }
+        if (!schedule?.length) {
+            throw new Error('createJob requires at least one schedule');
+        }
+        const { data: taxRate, error: taxRateError } = await supabase
+            .from('tax_rate')
+            .select()
+            .eq('company_id', companyId)
+            .eq('is_default', true);
+        if (taxRateError) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('createJob TAX RATE ERROR: ', taxRateError);
+            throw taxRateError;
+        }
+        let taxRateId = null;
+        if (taxRate && taxRate[0]?.id) {
+            taxRateId = taxRate[0].id;
+        }
+        let jobRecurringId = jobData.job_recurring_id ?? null;
+        if (rrule) {
+            const recurringData = {
+                address_id: jobData.address_id,
+                client_id: jobData.client_id,
+                company_id: companyId,
+                start_time: schedule[0].start_time,
+                end_time: schedule[0].end_time,
+                job_source: jobData.job_source,
+                job_type: jobData.type,
+                notes: jobData.notes,
+                rrule,
+                tax_rate_id: jobData.tax_rate_id,
+            };
+            const { data: recurringJob, error: recurringError } = await supabase
+                .from('job_recurring')
+                .insert(recurringData)
+                .select()
+                .single();
+            if (recurringError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('createJob JOB-RECURRING ERROR', recurringError);
+                throw recurringError;
+            }
+            if (!recurringJob)
+                throw new Error('Missing job_recurring somehow');
+            jobRecurringId = recurringJob.id;
+            const recurringUsers = schedule[0].job_user ?? [];
+            if (recurringUsers.length > 0) {
+                const { error: jobUserRecurringError } = await supabase
+                    .from('job_user_recurring')
+                    .insert(recurringUsers.map((user) => ({
+                    job_recurring_id: jobRecurringId,
+                    user_id: user.id,
+                    company_id: companyId,
+                })));
+                if (jobUserRecurringError) {
+                    if (debugMode)
+                        (0, LogHandler_1.captureErrorException)('createJob JOB-USER ERROR', jobUserRecurringError);
+                    throw jobUserRecurringError;
+                }
+            }
+            const arrayOfJobs = await (0, helpers_1.createRecurringInstances)({
+                recurringJobId: jobRecurringId,
+                recurringData,
+                supabase: supabase,
+            });
+            if (!arrayOfJobs[0]?.job)
+                throw new Error(`createRecurringInstances didn't return any jobs`);
+            const completeNewJob = arrayOfJobs[0]?.job;
+            return completeNewJob;
+        }
+        const { data, error } = await supabase
+            .from('job')
+            .insert({
+            ...jobData,
+            job_number: undefined,
+            tax_rate_id: taxRateId,
+            job_recurring_id: jobRecurringId,
+        })
+            .select(`
+        *,
+        client: client_id (*),
+        address: address_id (*),
+        tax_rate: tax_rate_id(*),
+        items: job_item(*),
+        discounts: job_discount(*),
+        payments: payment(*)
+        `)
+            .single();
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('createJob CLIENT-JOB ERROR', error);
+            throw error;
+        }
+        let jobScheduleData = [];
+        if (data && schedule && schedule.length > 0) {
+            const { data: insertedSchedules, error: scheduleError } = await supabase
+                .from('job_schedule')
+                .insert(schedule.map(({ job_user, ...task }) => ({
+                ...task,
+                job_id: data.id,
+                company_id: companyId,
+            })))
+                .select();
+            if (scheduleError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('createJob JOB-SCHEDULE ERROR', scheduleError);
+                throw scheduleError;
+            }
+            jobScheduleData = await Promise.all(insertedSchedules.map(async (s, i) => {
+                const users = schedule[i]?.job_user ?? [];
+                await Promise.all(users.map((user) => supabase
+                    .from('job_user')
+                    .insert({
+                    job_id: data.id,
+                    user_id: user.id,
+                    company_id: companyId,
+                    job_schedule_id: s.id,
+                })
+                    .then(({ error: jobUserError }) => {
+                    if (jobUserError) {
+                        if (debugMode)
+                            (0, LogHandler_1.captureErrorException)('createJob JOB-USER ERROR', jobUserError);
+                        throw jobUserError;
+                    }
+                })));
+                return { ...s, job_user: users };
+            }));
+        }
+        if (data && tags) {
+            await Promise.all(tags.map((tag) => (0, TagFunctions_1.createJobTagLinkFunction)({
+                companyId,
+                jobId: data.id,
+                jobRecurringId: data.job_recurring_id,
+                tag,
+            }, {
+                supabase: supabase,
+                debugMode,
+                captureErrorException: LogHandler_1.captureErrorException,
+                captureLogging: LogHandler_1.captureLogging,
+            })));
+        }
+        if (debugMode)
+            (0, LogHandler_1.captureLogging)('createJob CLIENT-JOB DATA', data);
+        (0, helpers_1.assertNonEmpty)(jobScheduleData, `createJob produced no schedules for job ${data.id}`);
+        const { job_payment_status, amount_due, total_amount } = (0, server_safe_1.calculateJobPaymentStatus)({
+            ...data,
+            job_schedule: jobScheduleData,
+        });
+        return {
+            ...data,
+            job_schedule: jobScheduleData,
+            job_payment_status,
+            amount_due,
+            total_amount,
+        };
+    }, [debugMode, supabase]);
+    const fetchJob = (0, react_1.useCallback)(async (companyId, jobId) => {
+        return (0, JobFunctions_1.fetchJobFunction)({ companyId, jobId }, { supabase: supabase, debugMode, captureErrorException: LogHandler_1.captureErrorException });
+    }, [debugMode, supabase]);
+    const updateJob = (0, react_1.useCallback)(async (jobId, jobDetails, recurringMode) => {
+        if (Object.keys(jobDetails).length > 0) {
+            const { error } = await supabase
+                .from('job')
+                .update(jobDetails)
+                .eq('id', jobId);
+            if (error) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('updateJob ERROR', error);
+                throw error;
+            }
+        }
+        const { data, error: fetchError } = await supabase
+            .from('job')
+            .select()
+            .eq('id', jobId)
+            .single();
+        if (fetchError) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('updateJob FETCH ERROR', fetchError);
+            throw fetchError;
+        }
+        if (recurringMode === 'this_and_future' && data.job_recurring_id) {
+            const recurringUpdates = {};
+            if ('notes' in jobDetails)
+                recurringUpdates.notes = jobDetails.notes;
+            if ('address_id' in jobDetails)
+                recurringUpdates.address_id = jobDetails.address_id;
+            if ('job_source' in jobDetails)
+                recurringUpdates.job_source = jobDetails.job_source;
+            if ('type' in jobDetails)
+                recurringUpdates.job_type = jobDetails.type;
+            if ('tax_rate_id' in jobDetails)
+                recurringUpdates.tax_rate_id = jobDetails.tax_rate_id;
+            if (Object.keys(recurringUpdates).length > 0) {
+                const { error: recurringError } = await supabase
+                    .from('job_recurring')
+                    .update(recurringUpdates)
+                    .eq('id', data.job_recurring_id);
+                if (recurringError) {
+                    if (debugMode)
+                        (0, LogHandler_1.captureErrorException)('updateJob RECURRING ERROR', recurringError);
+                    throw recurringError;
+                }
+            }
+            const futureSchedules = await (0, helpers_1.getFutureSchedules)(jobId, data.job_recurring_id, supabase, debugMode, LogHandler_1.captureErrorException);
+            const futureJobIds = [...new Set(futureSchedules.map((s) => s.job_id))];
+            if (futureJobIds.length > 0 && Object.keys(jobDetails).length > 0) {
+                const { error: futureJobsError } = await supabase
+                    .from('job')
+                    .update(jobDetails)
+                    .in('id', futureJobIds);
+                if (futureJobsError) {
+                    if (debugMode)
+                        (0, LogHandler_1.captureErrorException)('updateJob FUTURE JOBS ERROR', futureJobsError);
+                    throw futureJobsError;
+                }
+            }
+        }
+        if (debugMode)
+            (0, LogHandler_1.captureLogging)('updateJob DATA', data);
+        return data;
+    }, [supabase, debugMode]);
+    const updateJobSchedule = (0, react_1.useCallback)(async (jobId, scheduleId, updates, recurringMode) => {
+        const { error } = await supabase
+            .from('job_schedule')
+            .update(updates)
+            .eq('id', scheduleId);
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('updateJobSchedule ERROR', error);
+            throw error;
+        }
+        if (recurringMode === 'this_and_future') {
+            const { data: job, error: jobFetchError } = await supabase
+                .from('job')
+                .select('job_recurring_id')
+                .eq('id', jobId)
+                .single();
+            if (jobFetchError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('updateJobSchedule JOB FETCH ERROR', jobFetchError);
+                throw jobFetchError;
+            }
+            if (job.job_recurring_id) {
+                const recurringUpdates = {};
+                if (updates.start_time)
+                    recurringUpdates.start_time = updates.start_time;
+                if (updates.end_time)
+                    recurringUpdates.end_time = updates.end_time;
+                if (Object.keys(recurringUpdates).length > 0) {
+                    const { error: recurringError } = await supabase
+                        .from('job_recurring')
+                        .update(recurringUpdates)
+                        .eq('id', job.job_recurring_id);
+                    if (recurringError) {
+                        if (debugMode)
+                            (0, LogHandler_1.captureErrorException)('updateJobSchedule RECURRING ERROR', recurringError);
+                        throw recurringError;
+                    }
+                }
+                const futureSchedules = await (0, helpers_1.getFutureSchedules)(jobId, job.job_recurring_id, supabase, debugMode, LogHandler_1.captureErrorException);
+                if (futureSchedules.length > 0) {
+                    const hasTimeChange = updates.start_time || updates.end_time;
+                    if (hasTimeChange) {
+                        const results = await Promise.all(futureSchedules.map((schedule) => {
+                            const patchedUpdates = {};
+                            if (updates.start_time) {
+                                patchedUpdates.start_time = (0, helpers_1.applyTimeToDate)(schedule.start_time, updates.start_time);
+                            }
+                            if (updates.end_time) {
+                                patchedUpdates.end_time = (0, helpers_1.applyTimeToDate)(schedule.end_time, updates.end_time);
+                            }
+                            if (updates.status) {
+                                patchedUpdates.status = updates.status;
+                            }
+                            return supabase
+                                .from('job_schedule')
+                                .update(patchedUpdates)
+                                .eq('id', schedule.id);
+                        }));
+                        const failedResult = results.find((r) => r.error);
+                        if (failedResult?.error) {
+                            if (debugMode)
+                                (0, LogHandler_1.captureErrorException)('updateJobSchedule FUTURE TIME ERROR', failedResult.error);
+                            throw failedResult.error;
+                        }
+                    }
+                    else {
+                        const { error: batchError } = await supabase
+                            .from('job_schedule')
+                            .update(updates)
+                            .in('id', futureSchedules.map((s) => s.id));
+                        if (batchError) {
+                            if (debugMode)
+                                (0, LogHandler_1.captureErrorException)('updateJobSchedule FUTURE BATCH ERROR', batchError);
+                            throw batchError;
+                        }
+                    }
+                }
+            }
+        }
+    }, [supabase, debugMode]);
+    const createJobSchedule = (0, react_1.useCallback)(async (jobId, schedule) => {
+        const { job_user, ...scheduleFields } = schedule;
+        const { data, error } = await supabase
+            .from('job_schedule')
+            .insert({
+            ...scheduleFields,
+            job_id: jobId,
+        })
+            .select()
+            .single();
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('createJobSchedule ERROR', error);
+            throw error;
+        }
+        const users = job_user ?? [];
+        if (users.length > 0) {
+            const { error: jobUserError } = await supabase.from('job_user').insert(users.map((user) => ({
+                job_id: jobId,
+                user_id: user.id,
+                company_id: scheduleFields.company_id,
+                job_schedule_id: data.id,
+            })));
+            if (jobUserError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('createJobSchedule JOB-USER ERROR', jobUserError);
+                throw jobUserError;
+            }
+        }
+        if (debugMode)
+            (0, LogHandler_1.captureLogging)('createJobSchedule DATA', data);
+        return { ...data, job_user: users };
+    }, [supabase, debugMode]);
+    const deleteJobSchedule = (0, react_1.useCallback)(async (jobId, scheduleId) => {
+        const { count, error: countError } = await supabase
+            .from('job_schedule')
+            .select('id', { count: 'exact', head: true })
+            .eq('job_id', jobId);
+        if (countError) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('deleteJobSchedule COUNT ERROR', countError);
+            throw countError;
+        }
+        if ((count ?? 0) <= 1) {
+            throw new Error('Cannot delete all schedules — a job must have at least one');
+        }
+        const { error } = await supabase
+            .from('job_schedule')
+            .delete()
+            .eq('job_id', jobId)
+            .eq('id', scheduleId);
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('deleteJobSchedule ERROR', error);
+            throw error;
+        }
+    }, [supabase, debugMode]);
+    const deleteJob = (0, react_1.useCallback)(async (jobId, jobRecurringId, recurringMode) => {
+        try {
+            await (0, trash_1.trashDeleteEntity)(supabase, 'job', jobId, jobRecurringId && recurringMode === 'this_and_future'
+                ? 'this_and_future'
+                : undefined);
+        }
+        catch (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('deleteJob ERROR', error);
+            throw error;
+        }
+    }, [supabase, debugMode]);
+    const deleteJobs = (0, react_1.useCallback)(async (jobs) => {
+        const hasRecurring = jobs.some((job) => job.job_recurring_id);
+        if (hasRecurring) {
+            throw new Error('Recurring jobs must be deleted individually.');
+        }
+        try {
+            await (0, trash_1.trashDeleteEntities)(supabase, 'job', jobs.map((job) => job.id));
+        }
+        catch (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('deleteJobs ERROR', error);
+            throw error;
+        }
+    }, [supabase, debugMode]);
+    const addJobUser = (0, react_1.useCallback)(async (jobId, jobScheduleId, userId, companyId, jobRecurringId, recurringMode) => {
+        const propagatedRecurringId = recurringMode === 'this_and_future' ? jobRecurringId : undefined;
+        const { data: existing, error: existingError } = await supabase
+            .from('job_user')
+            .select()
+            .eq('user_id', userId)
+            .eq('job_schedule_id', jobScheduleId)
+            .maybeSingle();
+        if (existingError) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('addJobUser existing assignment check ERROR', existingError);
+            throw existingError;
+        }
+        if (existing && !propagatedRecurringId)
+            return existing;
+        let jobUser = existing;
+        if (!jobUser) {
+            const { data: insertData, error: insertError } = await supabase
+                .from('job_user')
+                .insert({
+                job_id: jobId,
+                user_id: userId,
+                company_id: companyId,
+                job_schedule_id: jobScheduleId,
+            })
+                .select()
+                .single();
+            if (insertError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('addJobUser insert ERROR', insertError);
+                throw insertError;
+            }
+            jobUser = insertData;
+        }
+        if (propagatedRecurringId) {
+            const { data: existingRecurring, error: existingRecurringError } = await supabase
+                .from('job_user_recurring')
+                .select('id')
+                .eq('user_id', userId)
+                .eq('job_recurring_id', propagatedRecurringId)
+                .maybeSingle();
+            if (existingRecurringError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('addJobUser recurring check ERROR', existingRecurringError);
+                throw existingRecurringError;
+            }
+            if (!existingRecurring) {
+                const { error: recurringError } = await supabase
+                    .from('job_user_recurring')
+                    .insert({
+                    user_id: userId,
+                    company_id: companyId,
+                    job_recurring_id: propagatedRecurringId,
+                });
+                if (recurringError) {
+                    if (debugMode)
+                        (0, LogHandler_1.captureErrorException)('addJobUser insert ERROR', recurringError);
+                    throw recurringError;
+                }
+            }
+            const futureSchedules = await (0, helpers_1.getFutureSchedules)(jobId, propagatedRecurringId, supabase, debugMode, LogHandler_1.captureErrorException);
+            if (futureSchedules.length > 0) {
+                const unassignedSchedules = futureSchedules.filter((schedule) => !schedule.job_user.some((user) => user.id === userId));
+                if (unassignedSchedules.length > 0) {
+                    const { error: futureError } = await supabase
+                        .from('job_user')
+                        .insert(unassignedSchedules.map((schedule) => ({
+                        job_id: schedule.job_id,
+                        user_id: userId,
+                        company_id: companyId,
+                        job_schedule_id: schedule.id,
+                    })));
+                    if (futureError) {
+                        if (debugMode)
+                            (0, LogHandler_1.captureErrorException)('addJobUser future insert ERROR', futureError);
+                        throw futureError;
+                    }
+                }
+            }
+        }
+        if (debugMode)
+            (0, LogHandler_1.captureLogging)('addJobUser DATA', jobUser);
+        return jobUser;
+    }, [supabase, debugMode]);
+    const removeJobUser = (0, react_1.useCallback)(async (jobId, jobScheduleId, userId, companyId, jobRecurringId, recurringMode) => {
+        const { error } = await supabase
+            .from('job_user')
+            .delete()
+            .eq('user_id', userId)
+            .eq('company_id', companyId)
+            .eq('job_schedule_id', jobScheduleId);
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('removeJobUser ERROR', error);
+            throw error;
+        }
+        if (jobRecurringId && recurringMode === 'this_and_future') {
+            const { error: recurringError } = await supabase
+                .from('job_user_recurring')
+                .delete()
+                .eq('user_id', userId)
+                .eq('job_recurring_id', jobRecurringId);
+            if (recurringError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('removeJobUser recurring ERROR', recurringError);
+                throw recurringError;
+            }
+            const futureSchedules = await (0, helpers_1.getFutureSchedules)(jobId, jobRecurringId, supabase, debugMode, LogHandler_1.captureErrorException);
+            if (futureSchedules.length > 0) {
+                const assignedScheduleIds = futureSchedules
+                    .filter((schedule) => schedule.job_user.some((user) => user.id === userId))
+                    .map((schedule) => schedule.id);
+                if (assignedScheduleIds.length > 0) {
+                    const { error: futureError } = await supabase
+                        .from('job_user')
+                        .delete()
+                        .eq('user_id', userId)
+                        .in('job_schedule_id', assignedScheduleIds);
+                    if (futureError) {
+                        if (debugMode)
+                            (0, LogHandler_1.captureErrorException)('removeJobUser future delete ERROR', futureError);
+                        throw futureError;
+                    }
+                }
+            }
+        }
+    }, [supabase, debugMode]);
+    const addNewJobItem = (0, react_1.useCallback)(async (companyId, jobItemData, jobId, invoiceId, markJobUnpaidUpfront, jobRecurringId, recurringMode) => {
+        let realJobId;
+        let realInvoiceId;
+        if (!jobId && !invoiceId)
+            throw new Error('Requires jobId or invoiceId');
+        if (jobId) {
+            realJobId = jobId;
+            const { data, error } = await supabase
+                .from('invoice')
+                .select('id')
+                .eq('job_id', jobId);
+            if (data) {
+                if (data[0]?.id)
+                    realInvoiceId = data[0]?.id;
+            }
+            if (error)
+                throw new Error('error fetching invoice_id from job_id');
+        }
+        else if (invoiceId) {
+            realInvoiceId = invoiceId;
+            const { data, error } = await supabase
+                .from('invoice')
+                .select('job_id')
+                .eq('id', invoiceId);
+            if (data) {
+                if (data[0]?.job_id)
+                    realJobId = data[0]?.job_id;
+            }
+            if (error)
+                throw new Error('error fetching job_id on invoice');
+        }
+        if (markJobUnpaidUpfront && realJobId) {
+            const { error: jobUpdateError } = await supabase
+                .from('job')
+                .update({ unpaid_upfront: true })
+                .eq('id', realJobId);
+            if (jobUpdateError)
+                throw new Error('error updating job unpaid_upfront = true');
+        }
+        let jobItemRecurringId;
+        if (jobRecurringId && recurringMode === 'this_and_future') {
+            const { data: recurringData, error: recurringInsertError } = await supabase
+                .from('job_item_recurring')
+                .insert({
+                company_id: companyId,
+                job_recurring_id: jobRecurringId,
+                item_name: jobItemData.item_name,
+                item_cost: jobItemData.item_cost,
+                item_price: jobItemData.item_price,
+                quantity: jobItemData.quantity,
+                taxable: jobItemData.taxable,
+                description: jobItemData.description,
+                payment_upfront: jobItemData.payment_upfront,
+            })
+                .select()
+                .single();
+            if (recurringInsertError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('addNewJobItem recurring insert ERROR', recurringInsertError);
+                throw recurringInsertError;
+            }
+            jobItemRecurringId = recurringData.id;
+        }
+        const { data, error } = await supabase
+            .from('job_item')
+            .insert({
+            ...jobItemData,
+            job_id: realJobId,
+            invoice_id: realInvoiceId,
+            company_id: companyId,
+            job_item_recurring_id: jobItemRecurringId,
+        })
+            .select()
+            .single();
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('addNewJobItem ERROR', error);
+            throw error;
+        }
+        if (jobRecurringId &&
+            recurringMode === 'this_and_future' &&
+            jobItemRecurringId &&
+            realJobId) {
+            const futureSchedules = await (0, helpers_1.getFutureSchedules)(realJobId, jobRecurringId, supabase, debugMode, LogHandler_1.captureErrorException);
+            if (futureSchedules.length > 0) {
+                const futureJobIds = Array.from(new Set(futureSchedules.map((schedule) => schedule.job_id)));
+                if (futureJobIds.length > 0) {
+                    const { data: futureInvoices, error: futureInvoiceError } = await supabase
+                        .from('invoice')
+                        .select('id, job_id')
+                        .in('job_id', futureJobIds);
+                    if (futureInvoiceError) {
+                        if (debugMode)
+                            (0, LogHandler_1.captureErrorException)('addNewJobItem future invoice fetch ERROR', futureInvoiceError);
+                        throw futureInvoiceError;
+                    }
+                    const invoiceByJobId = new Map((futureInvoices ?? []).map((inv) => [inv.job_id, inv.id]));
+                    const { error: futureError } = await supabase
+                        .from('job_item')
+                        .insert(futureJobIds.map((futureJobId) => ({
+                        ...jobItemData,
+                        job_id: futureJobId,
+                        invoice_id: invoiceByJobId.get(futureJobId) ?? null,
+                        company_id: companyId,
+                        job_item_recurring_id: jobItemRecurringId,
+                    })));
+                    if (futureError) {
+                        if (debugMode)
+                            (0, LogHandler_1.captureErrorException)('addNewJobItem future insert ERROR', futureError);
+                        throw futureError;
+                    }
+                }
+            }
+        }
+        if (debugMode)
+            (0, LogHandler_1.captureLogging)('addNewJobItem DATA', data);
+        return data;
+    }, [supabase, debugMode]);
+    const updateJobItem = (0, react_1.useCallback)(async (itemData, jobId, jobRecurringId, recurringMode, jobItemRecurringId) => {
+        const { data, error } = await supabase
+            .from('job_item')
+            .update(itemData)
+            .eq('id', itemData.id)
+            .select()
+            .single();
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('updateJobItem ERROR', error);
+            throw error;
+        }
+        if (jobRecurringId &&
+            recurringMode === 'this_and_future' &&
+            jobItemRecurringId) {
+            const propagatedFields = {
+                item_name: itemData.item_name,
+                item_cost: itemData.item_cost,
+                item_price: itemData.item_price,
+                quantity: itemData.quantity,
+                taxable: itemData.taxable,
+                description: itemData.description,
+                payment_upfront: itemData.payment_upfront,
+            };
+            const { error: recurringError } = await supabase
+                .from('job_item_recurring')
+                .update(propagatedFields)
+                .eq('id', jobItemRecurringId);
+            if (recurringError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('updateJobItem recurring ERROR', recurringError);
+                throw recurringError;
+            }
+            if (jobId) {
+                const futureSchedules = await (0, helpers_1.getFutureSchedules)(jobId, jobRecurringId, supabase, debugMode, LogHandler_1.captureErrorException);
+                if (futureSchedules.length > 0) {
+                    const futureJobIds = Array.from(new Set(futureSchedules.map((schedule) => schedule.job_id)));
+                    if (futureJobIds.length > 0) {
+                        const { error: futureError } = await supabase
+                            .from('job_item')
+                            .update(propagatedFields)
+                            .eq('job_item_recurring_id', jobItemRecurringId)
+                            .in('job_id', futureJobIds);
+                        if (futureError) {
+                            if (debugMode)
+                                (0, LogHandler_1.captureErrorException)('updateJobItem future update ERROR', futureError);
+                            throw futureError;
+                        }
+                    }
+                }
+            }
+        }
+        if (debugMode)
+            (0, LogHandler_1.captureLogging)('updateJobItem DATA', data);
+        return data;
+    }, [supabase, debugMode]);
+    const deleteJobItem = (0, react_1.useCallback)(async (jobItemId, jobRecurringId, recurringMode) => {
+        let jobItemRecurringIdForRecurring;
+        let jobIdForRecurring;
+        if (jobRecurringId && recurringMode === 'this_and_future') {
+            const { data: existing, error: fetchError } = await supabase
+                .from('job_item')
+                .select('job_item_recurring_id, job_id')
+                .eq('id', jobItemId)
+                .single();
+            if (fetchError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('deleteJobItem fetch ERROR', fetchError);
+                throw fetchError;
+            }
+            jobItemRecurringIdForRecurring = existing?.job_item_recurring_id;
+            jobIdForRecurring = existing?.job_id;
+        }
+        const { error } = await supabase
+            .from('job_item')
+            .delete()
+            .eq('id', jobItemId);
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('deleteJobItem ERROR', error);
+            throw error;
+        }
+        if (jobRecurringId &&
+            recurringMode === 'this_and_future' &&
+            jobItemRecurringIdForRecurring) {
+            const { error: recurringError } = await supabase
+                .from('job_item_recurring')
+                .delete()
+                .eq('id', jobItemRecurringIdForRecurring);
+            if (recurringError) {
+                if (debugMode)
+                    (0, LogHandler_1.captureErrorException)('deleteJobItem recurring ERROR', recurringError);
+                throw recurringError;
+            }
+            if (jobIdForRecurring) {
+                const futureSchedules = await (0, helpers_1.getFutureSchedules)(jobIdForRecurring, jobRecurringId, supabase, debugMode, LogHandler_1.captureErrorException);
+                if (futureSchedules.length > 0) {
+                    const futureJobIds = Array.from(new Set(futureSchedules.map((schedule) => schedule.job_id)));
+                    if (futureJobIds.length > 0) {
+                        const { error: futureError } = await supabase
+                            .from('job_item')
+                            .delete()
+                            .eq('job_item_recurring_id', jobItemRecurringIdForRecurring)
+                            .in('job_id', futureJobIds);
+                        if (futureError) {
+                            if (debugMode)
+                                (0, LogHandler_1.captureErrorException)('deleteJobItem future delete ERROR', futureError);
+                            throw futureError;
+                        }
+                    }
+                }
+            }
+        }
+    }, [supabase, debugMode]);
+    const deleteJobItemsByJob = (0, react_1.useCallback)(async (jobId) => {
+        const { error } = await supabase
+            .from('job_item')
+            .delete()
+            .eq('job_id', jobId);
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('deleteJobItemsByJob ERROR', error);
+            throw error;
+        }
+    }, [supabase, debugMode]);
+    const deleteOrphanJobItemsByInvoice = (0, react_1.useCallback)(async (invoiceId) => {
+        const { error } = await supabase
+            .from('job_item')
+            .delete()
+            .eq('invoice_id', invoiceId)
+            .is('job_id', null);
+        if (error) {
+            if (debugMode)
+                (0, LogHandler_1.captureErrorException)('deleteOrphanJobItemsByInvoice ERROR', error);
+            throw error;
+        }
+    }, [supabase, debugMode]);
+    const value = (0, react_1.useMemo)(() => ({
+        fetchRecurringJobTemplates,
+        createJob,
+        fetchJob,
+        updateJob,
+        createJobSchedule,
+        updateJobSchedule,
+        deleteJobSchedule,
+        deleteJob,
+        deleteJobs,
+        addJobUser,
+        removeJobUser,
+        addNewJobItem,
+        updateJobItem,
+        deleteJobItem,
+        deleteJobItemsByJob,
+        deleteOrphanJobItemsByInvoice,
+    }), [
+        fetchRecurringJobTemplates,
+        createJob,
+        fetchJob,
+        updateJob,
+        createJobSchedule,
+        updateJobSchedule,
+        deleteJobSchedule,
+        deleteJob,
+        deleteJobs,
+        addJobUser,
+        removeJobUser,
+        addNewJobItem,
+        updateJobItem,
+        deleteJobItem,
+        deleteJobItemsByJob,
+        deleteOrphanJobItemsByInvoice,
+    ]);
+    return value;
+};
+exports.useJobsProvider = useJobsProvider;
+//# sourceMappingURL=JobsProvider.js.map