@managemint-solutions/sdk 0.36.0 → 0.37.0

package/dist/leave/index.js

@@ -0,0 +1,29 @@
+"use strict";
+// Leave, the first slice of the HR module: one resource per table, the DTOs the api validates
+// with, and the calendar arithmetic the api counts days with. The resources hang off
+// `SupabaseClient` as `leaveTypes`, `leaveEntitlements` and `leaveRequests`; the holiday
+// calendar the day count reads is its own resource, `publicHolidays` (src/public-holidays).
+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.LeaveRequestsResource = exports.LeaveEntitlementsResource = exports.LeaveTypesResource = void 0;
+__exportStar(require("./dto"), exports);
+__exportStar(require("./working-days"), exports);
+var leave_types_1 = require("./leave-types");
+Object.defineProperty(exports, "LeaveTypesResource", { enumerable: true, get: function () { return leave_types_1.LeaveTypesResource; } });
+var leave_entitlements_1 = require("./leave-entitlements");
+Object.defineProperty(exports, "LeaveEntitlementsResource", { enumerable: true, get: function () { return leave_entitlements_1.LeaveEntitlementsResource; } });
+var leave_requests_1 = require("./leave-requests");
+Object.defineProperty(exports, "LeaveRequestsResource", { enumerable: true, get: function () { return leave_requests_1.LeaveRequestsResource; } });

package/dist/leave/leave-entitlements.d.ts

@@ -0,0 +1,42 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { LeaveEntitlementEntity, LeavePeriod } from '@managemint-solutions/entities/leave';
+import type { AuthContext } from '../auth';
+import { type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+import type { GetLeaveEntitlementsDto, UpdateLeaveEntitlementDto } from './dto';
+/** What the request path needs of the entitlement covering a date: the period and the cap. */
+export type LeaveEntitlementCover = LeavePeriod & {
+    mms_id: string;
+    days_entitled: number;
+};
+/** The create input after the api has resolved the period defaults. */
+export type CreateLeaveEntitlementInput = LeavePeriod & {
+    user_id: string;
+    leave_type_id: string;
+    days_entitled: number;
+    notes?: string | null;
+};
+export declare class LeaveEntitlementsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuthContext, audit: AuditResource);
+    list(query: GetLeaveEntitlementsDto): Promise<MmsList<LeaveEntitlementEntity>>;
+    getById(leaveEntitlementId: string): Promise<LeaveEntitlementEntity>;
+    /**
+     * The entitlement of `userId` for `leaveTypeId` whose period contains `date`, or null when the
+     * type is not tracked for them then. The periods of one user and type cannot overlap (the
+     * table's exclusion constraint), so there is at most one.
+     */
+    findFor(userId: string, leaveTypeId: string, date: string): Promise<LeaveEntitlementCover | null>;
+    create(input: CreateLeaveEntitlementInput): Promise<LeaveEntitlementEntity>;
+    update(leaveEntitlementId: string, input: UpdateLeaveEntitlementDto): Promise<LeaveEntitlementEntity>;
+    /** Hard delete: the type simply becomes untracked for that user and period. */
+    remove(leaveEntitlementId: string): Promise<void>;
+    /**
+     * Adds the computed balance to each row from one query over the requests that could count
+     * against any of them - the approved and pending ones of these users and types, starting in
+     * the span the periods cover. Nothing is stored: a balance is always what the requests say.
+     */
+    private withBalances;
+}

package/dist/leave/leave-entitlements.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveEntitlementsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const enum_2 = require("@managemint-solutions/entities/leave/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const transforms_1 = require("../transforms");
+const LEAVE_ENTITLEMENT_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by (*),
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by (*),
+        user:user_profiles!user_id (*),
+        leave_type:leave_types!leave_type_id (
+          mms_id,
+          name
+        ),
+        period_start,
+        period_end,
+        days_entitled,
+        notes
+      `;
+class LeaveEntitlementsResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'leave_entitlements',
+            entityType: enum_1.AuditTrailEntityType.LEAVE_ENTITLEMENTS,
+        });
+    }
+    async list(query) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        let entitlementsQuery = this.supabase
+            .from('leave_entitlements')
+            .select(LEAVE_ENTITLEMENT_SELECT, { count: 'estimated' })
+            .eq('organization_id', this.auth.organization_id)
+            .order('period_start', { ascending: false })
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (query.user_id) {
+            entitlementsQuery = entitlementsQuery.eq('user_id', query.user_id);
+        }
+        if (query.leave_type_id) {
+            entitlementsQuery = entitlementsQuery.eq('leave_type_id', query.leave_type_id);
+        }
+        if (query.as_of) {
+            entitlementsQuery = entitlementsQuery.lte('period_start', query.as_of).gte('period_end', query.as_of);
+        }
+        const { data, error, count } = await entitlementsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const rows = await this.withBalances((data ?? []));
+        return (0, transforms_1.toMmsList)(rows, page, pageSize, count);
+    }
+    async getById(leaveEntitlementId) {
+        const { data, error } = await this.supabase
+            .from('leave_entitlements')
+            .select(LEAVE_ENTITLEMENT_SELECT)
+            .eq('mms_id', leaveEntitlementId)
+            .eq('organization_id', this.auth.organization_id)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const [row] = await this.withBalances([data]);
+        return row;
+    }
+    /**
+     * The entitlement of `userId` for `leaveTypeId` whose period contains `date`, or null when the
+     * type is not tracked for them then. The periods of one user and type cannot overlap (the
+     * table's exclusion constraint), so there is at most one.
+     */
+    async findFor(userId, leaveTypeId, date) {
+        const { data, error } = await this.supabase
+            .from('leave_entitlements')
+            .select('mms_id, period_start, period_end, days_entitled')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('user_id', userId)
+            .eq('leave_type_id', leaveTypeId)
+            .lte('period_start', date)
+            .gte('period_end', date)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        if (!data)
+            return null;
+        const cover = data;
+        return { ...cover, days_entitled: Number(cover.days_entitled) };
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            user_id: input.user_id,
+            leave_type_id: input.leave_type_id,
+            period_start: input.period_start,
+            period_end: input.period_end,
+            days_entitled: input.days_entitled,
+            notes: input.notes ?? null,
+            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(leaveEntitlementId, input) {
+        await this.table.update(leaveEntitlementId, {
+            days_entitled: input.days_entitled,
+            period_end: input.period_end,
+            notes: input.notes,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return this.getById(leaveEntitlementId);
+    }
+    /** Hard delete: the type simply becomes untracked for that user and period. */
+    async remove(leaveEntitlementId) {
+        await this.table.remove(leaveEntitlementId);
+    }
+    /**
+     * Adds the computed balance to each row from one query over the requests that could count
+     * against any of them - the approved and pending ones of these users and types, starting in
+     * the span the periods cover. Nothing is stored: a balance is always what the requests say.
+     */
+    async withBalances(rows) {
+        if (rows.length === 0)
+            return [];
+        const userIds = [...new Set(rows.map((row) => row.user.mms_id))];
+        const typeIds = [...new Set(rows.map((row) => row.leave_type.mms_id))];
+        const earliest = rows.map((row) => row.period_start).sort()[0];
+        const latest = rows.map((row) => row.period_end).sort().reverse()[0];
+        const { data, error } = await this.supabase
+            .from('leave_requests')
+            .select('user_id, leave_type_id, start_date, days, status')
+            .eq('organization_id', this.auth.organization_id)
+            .in('user_id', userIds)
+            .in('leave_type_id', typeIds)
+            .in('status', [enum_2.LeaveRequestStatus.APPROVED, enum_2.LeaveRequestStatus.PENDING])
+            .gte('start_date', earliest)
+            .lte('start_date', latest);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const requests = (data ?? []);
+        return rows.map((row) => {
+            const mine = requests.filter((request) => request.user_id === row.user.mms_id &&
+                request.leave_type_id === row.leave_type.mms_id &&
+                request.start_date >= row.period_start &&
+                request.start_date <= row.period_end);
+            const sum = (status) => mine
+                .filter((request) => request.status === status)
+                .reduce((total, request) => total + Number(request.days), 0);
+            const daysEntitled = Number(row.days_entitled);
+            const daysUsed = sum(enum_2.LeaveRequestStatus.APPROVED);
+            const daysPending = sum(enum_2.LeaveRequestStatus.PENDING);
+            return {
+                ...row,
+                days_entitled: daysEntitled,
+                days_used: daysUsed,
+                days_pending: daysPending,
+                days_remaining: daysEntitled - daysUsed - daysPending,
+            };
+        });
+    }
+}
+exports.LeaveEntitlementsResource = LeaveEntitlementsResource;

package/dist/leave/leave-requests.d.ts

@@ -0,0 +1,69 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { LeavePeriod, LeaveRequestEntity } from '@managemint-solutions/entities/leave';
+import { LeaveRequestStatus, LeaveReviewDecision } from '@managemint-solutions/entities/leave/enum';
+import type { AuthContext } from '../auth';
+import { type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+import type { GetLeaveRequestsDto } from './dto';
+/** A request as the api inserts it: the caller's own, with the days already counted. */
+export type CreateLeaveRequestRow = {
+    user_id: string;
+    leave_type_id: string;
+    start_date: string;
+    end_date: string;
+    is_half_day: boolean;
+    days: number;
+    reason: string | null;
+    status: LeaveRequestStatus;
+    /** Set on an auto-approved request; `reviewed_by` stays null to say nobody reviewed it. */
+    reviewed_at?: string | null;
+};
+/** The recounted fields of a pending request being edited. */
+export type UpdateLeaveRequestRow = {
+    leave_type_id: string;
+    start_date: string;
+    end_date: string;
+    is_half_day: boolean;
+    days: number;
+    reason: string | null;
+};
+export type ReviewLeaveRequestRow = {
+    status: LeaveReviewDecision;
+    reviewed_by: string;
+    review_note: string | null;
+};
+/** The lists share a filter set; `userIds` is the visibility the api resolved for the caller. */
+type ListOptions = {
+    userIds?: string[];
+};
+export declare class LeaveRequestsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuthContext, audit: AuditResource);
+    list(query: GetLeaveRequestsDto, options?: ListOptions): Promise<MmsList<LeaveRequestEntity>>;
+    getById(leaveRequestId: string): Promise<LeaveRequestEntity>;
+    /**
+     * Whether `userId` already has a live request touching any day of `start`..`end`. The readable
+     * half of the rule; the table's exclusion constraint is the half that survives a race.
+     */
+    overlaps(userId: string, start: string, end: string, excludeId?: string): Promise<boolean>;
+    /**
+     * The days of `userId`'s requests of `leaveTypeId` in `statuses` that start inside `period` -
+     * what an entitlement's balance is checked against. `excludeId` leaves out the request being
+     * edited or approved so it is not counted against itself.
+     */
+    sumDays(userId: string, leaveTypeId: string, period: LeavePeriod, statuses: LeaveRequestStatus[], excludeId?: string): Promise<number>;
+    create(input: CreateLeaveRequestRow): Promise<LeaveRequestEntity>;
+    /** Edits a request while it is still pending; null when it no longer is. */
+    update(leaveRequestId: string, input: UpdateLeaveRequestRow): Promise<LeaveRequestEntity | null>;
+    /**
+     * Approves or rejects a pending request. Resolves to null when the request was no longer
+     * pending - another reviewer got there first, or the requester cancelled - so the caller
+     * can say so instead of overwriting their decision.
+     */
+    review(leaveRequestId: string, input: ReviewLeaveRequestRow): Promise<LeaveRequestEntity | null>;
+    /** Cancels a pending or approved request; null when it was already closed. */
+    cancel(leaveRequestId: string, cancelledBy: string): Promise<LeaveRequestEntity | null>;
+}
+export {};

package/dist/leave/leave-requests.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveRequestsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const enum_2 = require("@managemint-solutions/entities/leave/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const transforms_1 = require("../transforms");
+const LEAVE_REQUEST_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by (*),
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by (*),
+        user:user_profiles!user_id (*),
+        leave_type:leave_types!leave_type_id (
+          mms_id,
+          name
+        ),
+        start_date,
+        end_date,
+        is_half_day,
+        days,
+        reason,
+        status,
+        reviewed_by:user_profiles!reviewed_by (*),
+        reviewed_at,
+        review_note,
+        cancelled_by:user_profiles!cancelled_by (*),
+        cancelled_at
+      `;
+/** The statuses that hold days: a pending request reserves them, an approved one uses them. */
+const LIVE_STATUSES = [enum_2.LeaveRequestStatus.PENDING, enum_2.LeaveRequestStatus.APPROVED];
+class LeaveRequestsResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'leave_requests',
+            entityType: enum_1.AuditTrailEntityType.LEAVE_REQUESTS,
+        });
+    }
+    async list(query, options = {}) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        let requestsQuery = this.supabase
+            .from('leave_requests')
+            .select(LEAVE_REQUEST_SELECT, { count: 'estimated' })
+            .eq('organization_id', this.auth.organization_id)
+            .order('start_date', { ascending: false })
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (options.userIds) {
+            requestsQuery = requestsQuery.in('user_id', options.userIds);
+        }
+        if (query.user_id) {
+            requestsQuery = requestsQuery.eq('user_id', query.user_id);
+        }
+        if (query.status) {
+            requestsQuery = requestsQuery.eq('status', query.status);
+        }
+        if (query.start_date_after) {
+            requestsQuery = requestsQuery.gte('start_date', query.start_date_after);
+        }
+        if (query.start_date_before) {
+            requestsQuery = requestsQuery.lte('start_date', query.start_date_before);
+        }
+        const { data, error, count } = await requestsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (0, transforms_1.toMmsList)(data, page, pageSize, count);
+    }
+    async getById(leaveRequestId) {
+        const { data, error } = await this.supabase
+            .from('leave_requests')
+            .select(LEAVE_REQUEST_SELECT)
+            .eq('mms_id', leaveRequestId)
+            .eq('organization_id', this.auth.organization_id)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    /**
+     * Whether `userId` already has a live request touching any day of `start`..`end`. The readable
+     * half of the rule; the table's exclusion constraint is the half that survives a race.
+     */
+    async overlaps(userId, start, end, excludeId) {
+        let overlapQuery = this.supabase
+            .from('leave_requests')
+            .select('mms_id', { count: 'exact', head: true })
+            .eq('organization_id', this.auth.organization_id)
+            .eq('user_id', userId)
+            .in('status', LIVE_STATUSES)
+            .lte('start_date', end)
+            .gte('end_date', start);
+        if (excludeId) {
+            overlapQuery = overlapQuery.neq('mms_id', excludeId);
+        }
+        const { count, error } = await overlapQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (count ?? 0) > 0;
+    }
+    /**
+     * The days of `userId`'s requests of `leaveTypeId` in `statuses` that start inside `period` -
+     * what an entitlement's balance is checked against. `excludeId` leaves out the request being
+     * edited or approved so it is not counted against itself.
+     */
+    async sumDays(userId, leaveTypeId, period, statuses, excludeId) {
+        let daysQuery = this.supabase
+            .from('leave_requests')
+            .select('days')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('user_id', userId)
+            .eq('leave_type_id', leaveTypeId)
+            .in('status', statuses)
+            .gte('start_date', period.period_start)
+            .lte('start_date', period.period_end);
+        if (excludeId) {
+            daysQuery = daysQuery.neq('mms_id', excludeId);
+        }
+        const { data, error } = await daysQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []).reduce((total, row) => total + Number(row.days), 0);
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            ...input,
+            reviewed_at: input.reviewed_at ?? null,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+    /** Edits a request while it is still pending; null when it no longer is. */
+    async update(leaveRequestId, input) {
+        const row = await this.table.updateWhere(leaveRequestId, (query) => query.eq('status', enum_2.LeaveRequestStatus.PENDING), {
+            ...input,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return row ? this.getById(leaveRequestId) : null;
+    }
+    /**
+     * Approves or rejects a pending request. Resolves to null when the request was no longer
+     * pending - another reviewer got there first, or the requester cancelled - so the caller
+     * can say so instead of overwriting their decision.
+     */
+    async review(leaveRequestId, input) {
+        const now = new Date().toISOString();
+        const row = await this.table.updateWhere(leaveRequestId, (query) => query.eq('status', enum_2.LeaveRequestStatus.PENDING), {
+            status: input.status,
+            reviewed_by: input.reviewed_by,
+            reviewed_at: now,
+            review_note: input.review_note,
+            last_updated_by: this.auth.mms_id,
+            updated_at: now,
+        });
+        return row ? this.getById(leaveRequestId) : null;
+    }
+    /** Cancels a pending or approved request; null when it was already closed. */
+    async cancel(leaveRequestId, cancelledBy) {
+        const now = new Date().toISOString();
+        const row = await this.table.updateWhere(leaveRequestId, (query) => query.in('status', LIVE_STATUSES), {
+            status: enum_2.LeaveRequestStatus.CANCELLED,
+            cancelled_by: cancelledBy,
+            cancelled_at: now,
+            last_updated_by: this.auth.mms_id,
+            updated_at: now,
+        });
+        return row ? this.getById(leaveRequestId) : null;
+    }
+}
+exports.LeaveRequestsResource = LeaveRequestsResource;

package/dist/leave/leave-types.d.ts

@@ -0,0 +1,21 @@
+import type { LeaveTypeEntity } from '@managemint-solutions/entities/leave';
+import type { AuthContext } from '../auth';
+import { type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+import type { CreateLeaveTypeDto, GetLeaveTypesDto, UpdateLeaveTypeDto } from './dto';
+export declare class LeaveTypesResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuthContext, audit: AuditResource);
+    /** Every type by name; `active` narrows to one side of the flag. Small enough not to page. */
+    list(query: GetLeaveTypesDto): Promise<LeaveTypeEntity[]>;
+    getById(leaveTypeId: string): Promise<LeaveTypeEntity>;
+    create(input: CreateLeaveTypeDto): Promise<LeaveTypeEntity>;
+    update(leaveTypeId: string, input: UpdateLeaveTypeDto): Promise<LeaveTypeEntity>;
+    /**
+     * Hard delete. The entitlement and request foreign keys are `on delete restrict`, so a type
+     * that has ever been used fails here with the SDK's 409 - deactivate it instead.
+     */
+    remove(leaveTypeId: string): Promise<void>;
+}

package/dist/leave/leave-types.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveTypesResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+// The public contract is the shared LeaveTypeEntity from @managemint-solutions/entities; the
+// casts at the returns declare the shape the select string produces (the columns are defined in
+// the api's supabase/migrations).
+const LEAVE_TYPE_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by (*),
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by (*),
+        name,
+        description,
+        default_days,
+        is_paid,
+        requires_approval,
+        active
+      `;
+class LeaveTypesResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'leave_types',
+            entityType: enum_1.AuditTrailEntityType.LEAVE_TYPES,
+        });
+    }
+    /** Every type by name; `active` narrows to one side of the flag. Small enough not to page. */
+    async list(query) {
+        let typesQuery = this.supabase
+            .from('leave_types')
+            .select(LEAVE_TYPE_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .order('name');
+        if (query.active !== undefined && query.active !== null) {
+            typesQuery = typesQuery.eq('active', query.active);
+        }
+        const { data, error } = await typesQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    async getById(leaveTypeId) {
+        const { data, error } = await this.supabase
+            .from('leave_types')
+            .select(LEAVE_TYPE_SELECT)
+            .eq('mms_id', leaveTypeId)
+            .eq('organization_id', this.auth.organization_id)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            name: input.name,
+            description: input.description,
+            default_days: input.default_days,
+            is_paid: input.is_paid,
+            requires_approval: input.requires_approval,
+            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(leaveTypeId, input) {
+        await this.table.update(leaveTypeId, {
+            name: input.name,
+            description: input.description,
+            default_days: input.default_days,
+            is_paid: input.is_paid,
+            requires_approval: input.requires_approval,
+            active: input.active,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return this.getById(leaveTypeId);
+    }
+    /**
+     * Hard delete. The entitlement and request foreign keys are `on delete restrict`, so a type
+     * that has ever been used fails here with the SDK's 409 - deactivate it instead.
+     */
+    async remove(leaveTypeId) {
+        await this.table.remove(leaveTypeId);
+    }
+}
+exports.LeaveTypesResource = LeaveTypesResource;

package/dist/leave/working-days.d.ts

@@ -0,0 +1,29 @@
+import type { LeavePeriod } from '@managemint-solutions/entities/leave';
+/**
+ * Where "today" is read for the cancel rule. Organizations carry no time zone yet, and every
+ * customer is South African; this is the one place to change when a column arrives.
+ */
+export declare const LEAVE_TIME_ZONE = "Africa/Johannesburg";
+/** The `YYYY-MM-DD` of a `Date`'s UTC calendar day. */
+export declare const toIsoDate: (date: Date) => string;
+/** Today's calendar date in `LEAVE_TIME_ZONE`. */
+export declare const todayInJohannesburg: (now?: Date) => string;
+/** Every calendar date from `start` to `end` inclusive; empty when `end` is before `start`. */
+export declare const eachDate: (start: string, end: string) => string[];
+/** Monday to Friday and not one of the organization's holidays. */
+export declare const isWorkingDay: (isoDate: string, holidays: ReadonlySet<string>) => boolean;
+/**
+ * The days a request is worth: the working days from `start` to `end` inclusive, halved for a
+ * half day. A half day is only meaningful on a single working day, so it yields 0.5 there and 0
+ * on a weekend or holiday - the caller rejects a zero either way.
+ */
+export declare const countWorkingDays: (start: string, end: string, holidays: ReadonlySet<string>, isHalfDay?: boolean) => number;
+/** The day before the same date next year - the end of a period that starts on `isoDate`. */
+export declare const addOneYearMinusDay: (isoDate: string) => string;
+/**
+ * The leave year containing `date` for an organization whose year starts on the first of
+ * `startMonth` (1-12, `organizations.leave_calendar_start_month`). A March start puts
+ * 2026-02-10 in the year that began 2025-03-01.
+ */
+export declare const leavePeriodFor: (date: string, startMonth: number) => LeavePeriod;
+export declare const isWithinPeriod: (date: string, period: LeavePeriod) => boolean;