@managemint-solutions/sdk 0.42.0 → 0.44.0

package/dist/leads/index.js

@@ -0,0 +1,413 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeadsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/leads/enum");
+const enum_2 = require("@managemint-solutions/entities/additional-details/enum");
+const enum_3 = require("@managemint-solutions/entities/notes/enum");
+const enum_4 = require("@managemint-solutions/entities/status/enum");
+const enum_5 = require("@managemint-solutions/entities/supporting-files/enum");
+const enum_6 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const paths_1 = require("../supporting-files/paths");
+const transforms_1 = require("../transforms");
+const won_1 = require("./won");
+__exportStar(require("./dto"), exports);
+// The public contract is the shared LeadSummary / LeadEntity from @managemint-solutions/entities;
+// the casts at the returns declare the shape the select strings below produce (the columns are
+// defined in the api's supabase/migrations).
+const LEAD_LIST_SELECT = `
+        mms_id,
+        created_at,
+        name,
+        contact_person,
+        email,
+        status:statuses!status_id (
+          mms_id,
+          colour,
+          label,
+          is_complete,
+          is_fail,
+          is_triage,
+          is_won
+        ),
+        assigned_to:user_profiles!assigned_to_id (*),
+        estimated_value_minor,
+        follow_up_date,
+        created_by:user_profiles!created_by (*)
+      `;
+const LEAD_DETAIL_SELECT = `
+        mms_id,
+        created_at,
+        name,
+        contact_person,
+        email,
+        phone,
+        status:statuses!status_id (
+          mms_id,
+          label,
+          colour,
+          is_complete,
+          is_fail,
+          is_triage,
+          is_won
+        ),
+        assigned_to:user_profiles!assigned_to_id ${transforms_1.USER_PROFILE_EMBED},
+        source,
+        estimated_value_minor,
+        follow_up_date,
+        lost_reason,
+        converted_client:client_profiles!converted_client_id (*),
+        converted_at,
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by ${transforms_1.USER_PROFILE_EMBED},
+        created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED},
+        archived,
+        archived_at,
+        archived_by:user_profiles!archived_by ${transforms_1.USER_PROFILE_EMBED},
+        unarchived_at,
+        unarchived_by:user_profiles!unarchived_by ${transforms_1.USER_PROFILE_EMBED},
+        deleted,
+        deleted_at,
+        deleted_by:user_profiles!deleted_by ${transforms_1.USER_PROFILE_EMBED},
+        restored_at,
+        restored_by:user_profiles!restored_by ${transforms_1.USER_PROFILE_EMBED}
+      `;
+// What `convert` reads of the lead: what the client and its additional details are made from,
+// the two flags that refuse it, and the organization's currency for the estimated value.
+const LEAD_CONVERT_SELECT = 'name, email, phone, contact_person, source, estimated_value_minor, deleted, converted_client_id, organization:organizations!organization_id ( currency )';
+/** How a source reads in the "Lead source" additional detail the convert writes. */
+const LEAD_SOURCE_LABELS = {
+    [enum_1.LeadSource.REFERRAL]: 'Referral',
+    [enum_1.LeadSource.WEBSITE]: 'Website',
+    [enum_1.LeadSource.SOCIAL_MEDIA]: 'Social media',
+    [enum_1.LeadSource.EVENT]: 'Event',
+    [enum_1.LeadSource.COLD_OUTREACH]: 'Cold outreach',
+    [enum_1.LeadSource.EXISTING_CLIENT]: 'Existing client',
+    [enum_1.LeadSource.OTHER]: 'Other',
+};
+/** Storage bucket every supporting file lives in (as in SupportingFilesResource). */
+const SUPPORTING_FILES_BUCKET = 'supporting-files';
+const refuse = (status, message) => new errors_1.SupabaseClientError({ status, error: 'Database Error', message });
+class LeadsResource {
+    supabase;
+    auth;
+    audit;
+    additionalDetails;
+    table;
+    constructor(supabase, auth, audit, additionalDetails) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.audit = audit;
+        this.additionalDetails = additionalDetails;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'leads',
+            entityType: enum_6.AuditTrailEntityType.LEADS,
+        });
+    }
+    async list(query) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        const trimmedSearch = query.search?.trim();
+        // `order`/`range` return `this`, so the builder stays a filter builder and the conditional
+        // filters below can be reassigned onto it without a cast.
+        let leadsQuery = this.supabase
+            .from('leads')
+            .select(LEAD_LIST_SELECT, { count: 'estimated' })
+            .eq('organization_id', this.auth.organization_id)
+            .eq('archived', query.archive)
+            .eq('deleted', false)
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (trimmedSearch) {
+            leadsQuery = leadsQuery.or((0, transforms_1.orIlike)(['name', 'contact_person', 'email'], trimmedSearch));
+        }
+        if (query.assigned_to_id) {
+            leadsQuery = leadsQuery.eq('assigned_to_id', query.assigned_to_id);
+        }
+        if (query.created_after) {
+            leadsQuery = leadsQuery.gte('created_at', query.created_after);
+        }
+        if (query.created_before) {
+            leadsQuery = leadsQuery.lte('created_at', query.created_before);
+        }
+        if (query.status_id_in && query.status_id_in.length > 0) {
+            leadsQuery = leadsQuery.in('status_id', query.status_id_in);
+        }
+        // "No status OR not one of these", as tasks: a lead with no status is not won, so it stays in
+        // the open view. The ids are `@IsUUID('7')`-validated by the DTO, so interpolating them is
+        // safe.
+        if (query.status_id_not_in && query.status_id_not_in.length > 0) {
+            leadsQuery = leadsQuery.or(`status_id.is.null,status_id.not.in.(${query.status_id_not_in.join(',')})`);
+        }
+        const { data, error, count } = await leadsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (0, transforms_1.toMmsList)(data, page, pageSize, count);
+    }
+    async getById(leadId) {
+        const { data, error } = await this.supabase
+            .from('leads')
+            .select(LEAD_DETAIL_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('mms_id', leadId)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        // A soft-deleted lead keeps its audit trail but gives up its details. The client it became
+        // stays, so a converted lead can still point at it.
+        if (data.deleted) {
+            return {
+                ...data,
+                name: '',
+                contact_person: null,
+                email: '',
+                phone: '',
+                status: null,
+                assigned_to: null,
+                source: null,
+                estimated_value_minor: null,
+                follow_up_date: null,
+                lost_reason: null,
+            };
+        }
+        return data;
+    }
+    async create(input) {
+        const lostReason = await this.lostReasonFor(input.status_id ?? null, input.lost_reason);
+        const row = await this.table.insert({
+            ...input,
+            // Omitted means the creator owns the lead; an explicit null leaves it unassigned.
+            assigned_to_id: input.assigned_to_id === undefined ? this.auth.mms_id : input.assigned_to_id,
+            lost_reason: lostReason,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+    async update(leadId, input) {
+        // A Won lead is final. An update that leaves the status out keeps the lead's own, and the
+        // rules are checked against that one.
+        const { data, error } = await this.supabase
+            .from('leads')
+            .select('status_id, converted_client_id')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('mms_id', leadId)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const current = data;
+        if (current.converted_client_id) {
+            throw refuse(400, 'This lead is Won and can no longer be changed');
+        }
+        const statusId = input.status_id === undefined ? current.status_id : input.status_id;
+        const lostReason = await this.lostReasonFor(statusId, input.lost_reason);
+        await this.table.update(leadId, {
+            ...input,
+            lost_reason: lostReason,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return this.getById(leadId);
+    }
+    async archive(leadId) {
+        await (0, won_1.refuseWonLead)(this.supabase, this.auth.organization_id, leadId);
+        await this.table.transition(leadId, enum_6.AuditTrailAction.ARCHIVE, (0, transforms_1.archivedPatch)(this.auth.mms_id));
+        return this.getById(leadId);
+    }
+    async unarchive(leadId) {
+        await (0, won_1.refuseWonLead)(this.supabase, this.auth.organization_id, leadId);
+        await this.table.transition(leadId, enum_6.AuditTrailAction.UNARCHIVE, (0, transforms_1.unarchivedPatch)(this.auth.mms_id));
+        return this.getById(leadId);
+    }
+    async restore(leadId) {
+        await this.table.transition(leadId, enum_6.AuditTrailAction.RESTORE, (0, transforms_1.restoredPatch)(this.auth.mms_id));
+        return this.getById(leadId);
+    }
+    /** Soft delete - the row stays, flagged `deleted`, and `restore()` brings it back. A Won lead cannot be deleted. */
+    async remove(leadId) {
+        await (0, won_1.refuseWonLead)(this.supabase, this.auth.organization_id, leadId);
+        await this.table.transition(leadId, enum_6.AuditTrailAction.DELETE, (0, transforms_1.deletedPatch)(this.auth.mms_id));
+    }
+    /**
+     * Turns the lead into a client: the client is created from the lead's name, email and phone
+     * with the status the caller picked, the lead's contact person, source and estimated value
+     * become additional details on it, the lead's notes, additional details and files move to it,
+     * and the lead moves to Won with `converted_client_id` and `converted_at` set. It is not
+     * deleted - it stays as a record of the deal, and from then on it cannot be changed
+     * (`refuseWonLead`). The list hides Won leads by default.
+     *
+     * There is no transaction across these writes (PostgREST and Storage cannot share one). A
+     * failure after the client is created leaves that client and a lead that is still not
+     * converted, holding whatever had not moved yet. Running the convert again is safe: step (a)
+     * only refuses a lead that finished converting, and steps (d) and (e) only touch rows still on
+     * the lead, so nothing is moved twice - but it makes a second client, and the first one (with
+     * whatever had already moved to it) is left for someone to tidy up or delete.
+     *
+     * Converting needs only `update_leads`: `clients` is the service-role clients resource
+     * acting for the caller (`forOrganization(org, user).clientsOnBehalfOfUser()`), so the
+     * client is created, and read back, without the caller holding any clients permission.
+     */
+    async convert(leadId, input, clients) {
+        // (a) The lead, in this organization, not deleted and not converted already.
+        const { data, error } = await this.supabase
+            .from('leads')
+            .select(LEAD_CONVERT_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('mms_id', leadId)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const lead = data;
+        if (lead?.converted_client_id) {
+            throw refuse(400, 'This lead has already been converted');
+        }
+        if (!lead || lead.deleted) {
+            throw refuse(404, 'Lead not found');
+        }
+        // (b) The client, service-role for the caller, audited as their INSERT.
+        const client = await clients.create({
+            name: lead.name,
+            email: lead.email,
+            phone: lead.phone,
+            status_id: input.client_status_id,
+            contract_client: false,
+            contracted_hours: null,
+        });
+        const clientId = client.mms_id;
+        // (c) The lead fields a client has no column for, as additional details - only those set.
+        const details = [];
+        if (lead.contact_person) {
+            details.push({ key: 'Contact person', value: lead.contact_person });
+        }
+        if (lead.source) {
+            details.push({ key: 'Lead source', value: LEAD_SOURCE_LABELS[lead.source] ?? lead.source });
+        }
+        if (lead.estimated_value_minor !== null) {
+            const amount = (lead.estimated_value_minor / 100).toFixed(2);
+            details.push({
+                key: 'Estimated value',
+                value: lead.organization?.currency ? `${amount} ${lead.organization.currency}` : amount,
+            });
+        }
+        for (const detail of details) {
+            await this.additionalDetails.create(enum_2.AdditionalDetailsEntityTypes.CLIENT, clientId, {
+                key: detail.key,
+                value: detail.value,
+                type: enum_2.AdditionalDetailsTypes.Text,
+                copyable: false,
+            });
+        }
+        // (d) The lead's notes and additional details now hang off the client.
+        const moves = [
+            ['notes', enum_3.NotesEntityTypes.LEAD, enum_3.NotesEntityTypes.CLIENT],
+            ['additional_details', enum_2.AdditionalDetailsEntityTypes.LEAD, enum_2.AdditionalDetailsEntityTypes.CLIENT],
+        ];
+        for (const [table, fromType, toType] of moves) {
+            const { error: moveError } = await this.supabase
+                .from(table)
+                .update({ entity_type: toType, entity_id: clientId })
+                .eq('organization_id', this.auth.organization_id)
+                .eq('entity_type', fromType)
+                .eq('entity_id', leadId);
+            if (moveError)
+                throw (0, errors_1.mapPostgrestError)(moveError);
+        }
+        // (e) Each supporting file: the object moves to the client's folder, then its row follows.
+        // An object already missing from storage is skipped - there is nothing to move - and its row
+        // stays on the lead.
+        const { data: files, error: filesError } = await this.supabase
+            .from('supporting_files')
+            .select('mms_id, name, extension')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('entity_type', enum_5.SupportingFilesEntityTypes.LEAD)
+            .eq('entity_id', leadId);
+        if (filesError)
+            throw (0, errors_1.mapPostgrestError)(filesError);
+        for (const file of files) {
+            const { error: storageError } = await this.supabase.storage
+                .from(SUPPORTING_FILES_BUCKET)
+                .move((0, paths_1.storagePath)(this.auth.organization_id, enum_5.SupportingFilesEntityTypes.LEAD, leadId, file.name, file.extension), (0, paths_1.storagePath)(this.auth.organization_id, enum_5.SupportingFilesEntityTypes.CLIENT, clientId, file.name, file.extension));
+            if (storageError) {
+                if (storageError.status === 404 || storageError.statusCode === '404')
+                    continue;
+                throw (0, errors_1.mapStorageError)(storageError);
+            }
+            const { error: rowError } = await this.supabase
+                .from('supporting_files')
+                .update({ entity_type: enum_5.SupportingFilesEntityTypes.CLIENT, entity_id: clientId })
+                .eq('organization_id', this.auth.organization_id)
+                .eq('mms_id', file.mms_id);
+            if (rowError)
+                throw (0, errors_1.mapPostgrestError)(rowError);
+        }
+        // (f) The lead moves to its organization's Won status (`is_won`, one per organization, when
+        // it has one) and is linked to the client it became, audited as an UPDATE. It is not deleted.
+        const { data: won, error: wonError } = await this.supabase
+            .from('statuses')
+            .select('mms_id')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('is_won', true)
+            .maybeSingle();
+        if (wonError)
+            throw (0, errors_1.mapPostgrestError)(wonError);
+        await this.table.update(leadId, {
+            ...(won && { status_id: won.mms_id, lost_reason: null }),
+            converted_client_id: clientId,
+            converted_at: new Date().toISOString(),
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        // (g) The client as the clients resource reads it.
+        return clients.getById(clientId);
+    }
+    /**
+     * The two status rules, checked before anything is written, and the lost reason the write
+     * stores. A lead reaches its Won status (`is_won`) only by converting, so choosing it is
+     * refused (a converted lead is not updated at all). A fail status needs a lost reason; any
+     * other status, or none, clears it.
+     */
+    async lostReasonFor(statusId, lostReason) {
+        if (!statusId)
+            return null;
+        const { data, error } = await this.supabase
+            .from('statuses')
+            .select('is_fail, is_won')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('entity_type', enum_4.StatusEntityTypes.LEAD)
+            .eq('mms_id', statusId)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        // A status that is not one of this organization's lead statuses is not a fail status; the
+        // leads status trigger refuses it on the write.
+        const status = data;
+        if (status?.is_won) {
+            throw refuse(400, 'Convert the lead to a client to mark it Won');
+        }
+        if (!status?.is_fail)
+            return null;
+        const reason = lostReason?.trim();
+        if (!reason) {
+            throw refuse(400, 'Give a reason when marking a lead as lost');
+        }
+        return reason;
+    }
+}
+exports.LeadsResource = LeadsResource;

package/dist/leads/won.d.ts

@@ -0,0 +1,7 @@
+import type { TypedSupabaseClient } from '../client';
+/**
+ * A converted lead is Won and final: its fields, its lifecycle and what hangs off it (notes,
+ * additional details, supporting files) no longer change. Throws 400 when the lead is converted;
+ * a missing lead is left to the write that follows.
+ */
+export declare function refuseWonLead(supabase: TypedSupabaseClient, organizationId: string, leadId: string): Promise<void>;

package/dist/leads/won.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refuseWonLead = refuseWonLead;
+const errors_1 = require("../errors");
+/**
+ * A converted lead is Won and final: its fields, its lifecycle and what hangs off it (notes,
+ * additional details, supporting files) no longer change. Throws 400 when the lead is converted;
+ * a missing lead is left to the write that follows.
+ */
+async function refuseWonLead(supabase, organizationId, leadId) {
+    const { data, error } = await supabase
+        .from('leads')
+        .select('converted_client_id')
+        .eq('organization_id', organizationId)
+        .eq('mms_id', leadId)
+        .maybeSingle();
+    if (error)
+        throw (0, errors_1.mapPostgrestError)(error);
+    if (data?.converted_client_id) {
+        throw new errors_1.SupabaseClientError({
+            status: 400,
+            error: 'Database Error',
+            message: 'This lead is Won and can no longer be changed',
+        });
+    }
+}

package/dist/notes/index.js

@@ -15,9 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotesResource = void 0;
-const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const enum_1 = require("@managemint-solutions/entities/notes/enum");
+const enum_2 = require("@managemint-solutions/entities/audit-trail/enum");
 const audit_1 = require("../audit");
 const errors_1 = require("../errors");
+const won_1 = require("../leads/won");
 __exportStar(require("./dto"), exports);
 // The public contract is the shared NoteEntity from @managemint-solutions/entities; the casts at
 // the returns declare the shape the select string below produces (the columns are defined in the
@@ -32,7 +34,7 @@ class NotesResource {
         this.auth = auth;
         this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
             table: 'notes',
-            entityType: enum_1.AuditTrailEntityType.NOTES,
+            entityType: enum_2.AuditTrailEntityType.NOTES,
         });
     }
     async getById(noteId) {
@@ -59,6 +61,9 @@ class NotesResource {
         return data;
     }
     async create(entity, entityId, input) {
+        if (entity === enum_1.NotesEntityTypes.LEAD) {
+            await (0, won_1.refuseWonLead)(this.supabase, this.auth.organization_id, entityId);
+        }
         const row = await this.table.insert({
             content: input.content,
             entity_type: entity,

package/dist/permissions/dto.d.ts

@@ -1,5 +1,9 @@
 import type { UpdatePermissionsDto as UpdatePermissionsDtoType } from '@managemint-solutions/entities/users/permissions/dto';
 export declare class UpdatePermissionsDto implements UpdatePermissionsDtoType {
+    readonly create_leads: boolean;
+    readonly read_leads: boolean;
+    readonly update_leads: boolean;
+    readonly delete_leads: boolean;
     readonly create_clients: boolean;
     readonly read_clients: boolean;
     readonly update_clients: boolean;

package/dist/permissions/dto.js

@@ -14,6 +14,10 @@ const class_validator_1 = require("class-validator");
 class UpdatePermissionsDto {
     // @IsBoolean({ message: 'View Dashboard must be a boolean' })
     // readonly view_dashboard!: boolean;
+    create_leads;
+    read_leads;
+    update_leads;
+    delete_leads;
     create_clients;
     read_clients;
     update_clients;
@@ -108,6 +112,22 @@ class UpdatePermissionsDto {
     read_logs;
 }
 exports.UpdatePermissionsDto = UpdatePermissionsDto;
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Create Leads must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "create_leads", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Read Leads must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "read_leads", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Update Leads must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "update_leads", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Delete Leads must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "delete_leads", void 0);
 __decorate([
     (0, class_validator_1.IsBoolean)({ message: 'Create Clients must be a boolean' }),
     __metadata("design:type", Boolean)

package/dist/projects/index.js

@@ -35,7 +35,8 @@ const PROJECT_LIST_SELECT = `
           label,
           is_complete,
           is_fail,
-          is_triage
+          is_triage,
+          is_won
         ),
         created_by:user_profiles!created_by (*),
         manager:user_profiles!manager_id (*),
@@ -52,7 +53,8 @@ const PROJECT_DETAIL_SELECT = `
           colour,
           is_complete,
           is_fail,
-          is_triage
+          is_triage,
+          is_won
         ),
         has_budget,
         start_date,

package/dist/service-client/index.d.ts

@@ -2,6 +2,7 @@ import { AuditResource, type AuditActor, type AuditedTable, type AuditedTableOpt
 import type { TypedSupabaseClient } from '../client';
 import { BillingResource } from '../billing';
 import { InvoicesResource } from '../billing/invoices';
+import { ClientsResource } from '../clients';
 import { ConfigsResource } from '../configs';
 import { FeatureRequestsResource } from '../feature-requests';
 import { LeaveEntitlementsResource, LeaveRequestsResource, LeaveTypesResource } from '../leave';
@@ -45,6 +46,12 @@ export declare class SupabaseOrganizationScope {
      * subscriptions and both webhook handler services.
      */
     table(options: AuditedTableOptions): AuditedTable;
+    /**
+     * Clients written service-role on a user's behalf: converting a lead needs only
+     * `update_leads`, so the client it becomes is created here rather than through the caller's
+     * own client, and is still attributed to that user. The scope must carry the user.
+     */
+    clientsOnBehalfOfUser(): ClientsResource;
 }
 /**
  * The client for work that has no caller and no RLS context to run under: inbound webhooks

package/dist/service-client/index.js

@@ -6,6 +6,7 @@ const audit_1 = require("../audit");
 const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
 const billing_1 = require("../billing");
 const invoices_1 = require("../billing/invoices");
+const clients_1 = require("../clients");
 const configs_1 = require("../configs");
 const feature_requests_1 = require("../feature-requests");
 const leave_1 = require("../leave");
@@ -60,6 +61,17 @@ class SupabaseOrganizationScope {
     table(options) {
         return (0, audit_1.auditedTable)(this.supabase, this.actor, this.audit, options);
     }
+    /**
+     * Clients written service-role on a user's behalf: converting a lead needs only
+     * `update_leads`, so the client it becomes is created here rather than through the caller's
+     * own client, and is still attributed to that user. The scope must carry the user.
+     */
+    clientsOnBehalfOfUser() {
+        const { mms_id, organization_id } = this.actor;
+        if (!mms_id)
+            throw new Error('clientsOnBehalfOfUser needs a user actor');
+        return new clients_1.ClientsResource(this.supabase, { mms_id, organization_id }, this.audit);
+    }
 }
 exports.SupabaseOrganizationScope = SupabaseOrganizationScope;
 /**

package/dist/statuses/index.d.ts

@@ -1,6 +1,6 @@
 import type { StatusEntity } from '@managemint-solutions/entities/status';
 import type { AddStatusDto, UpdateStatusDto } from '@managemint-solutions/entities/status/dto';
-import { StatusEntityTypes } from '@managemint-solutions/entities/status/enum';
+import type { StatusEntityTypes } from '@managemint-solutions/entities/status/enum';
 import type { AuthContext } from '../auth';
 import { type AuditResource } from '../audit';
 import type { TypedSupabaseClient } from '../client';
@@ -13,5 +13,12 @@ export declare class StatusesResource {
     list(entity: StatusEntityTypes): Promise<StatusEntity[]>;
     create(input: AddStatusDto): Promise<StatusEntity>;
     update(statusId: string, input: UpdateStatusDto): Promise<StatusEntity>;
+    /** The Won status cannot be deleted. Every other status can. */
     remove(statusId: string): Promise<void>;
+    /**
+     * Whether the status is this organization's Won lead status (`is_won`), where converting a
+     * lead moves it. Won is fixed: it cannot be edited or deleted. Every other status - a lead
+     * status the organization marks complete included - is ordinary.
+     */
+    private isWon;
 }

package/dist/statuses/index.js

@@ -19,10 +19,11 @@ const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
 const audit_1 = require("../audit");
 const errors_1 = require("../errors");
 __exportStar(require("./dto"), exports);
+const refuseWon = (message) => new errors_1.SupabaseClientError({ status: 400, error: 'Database Error', message });
 // The public contract is the shared StatusEntity from @managemint-solutions/entities; the
 // `as StatusEntity` casts declare the shape the select string below produces (the columns are
 // defined in the api's supabase/migrations).
-const STATUS_SELECT = 'mms_id, label, colour, is_complete, is_fail, is_triage';
+const STATUS_SELECT = 'mms_id, label, colour, is_complete, is_fail, is_triage, is_won';
 // The audited write returns the whole row; the wire shape is the STATUS_SELECT columns.
 const toStatus = (row) => ({
     mms_id: row.mms_id,
@@ -31,6 +32,7 @@ const toStatus = (row) => ({
     is_complete: row.is_complete,
     is_fail: row.is_fail,
     is_triage: row.is_triage,
+    is_won: row.is_won,
 });
 class StatusesResource {
     supabase;
@@ -66,6 +68,9 @@ class StatusesResource {
         return toStatus(row);
     }
     async update(statusId, input) {
+        if (await this.isWon(statusId)) {
+            throw refuseWon('The Won status is fixed and cannot be changed');
+        }
         const row = await this.table.update(statusId, {
             label: input.label,
             colour: input.colour,
@@ -75,8 +80,28 @@ class StatusesResource {
         });
         return toStatus(row);
     }
+    /** The Won status cannot be deleted. Every other status can. */
     async remove(statusId) {
+        if (await this.isWon(statusId)) {
+            throw refuseWon('The Won status is fixed and cannot be deleted');
+        }
         await this.table.remove(statusId);
     }
+    /**
+     * Whether the status is this organization's Won lead status (`is_won`), where converting a
+     * lead moves it. Won is fixed: it cannot be edited or deleted. Every other status - a lead
+     * status the organization marks complete included - is ordinary.
+     */
+    async isWon(statusId) {
+        const { data, error } = await this.supabase
+            .from('statuses')
+            .select('is_won')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('mms_id', statusId)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return !!data?.is_won;
+    }
 }
 exports.StatusesResource = StatusesResource;