@managemint-solutions/sdk 0.36.0 → 0.38.0

package/dist/leave/working-days.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWithinPeriod = exports.leavePeriodFor = exports.addOneYearMinusDay = exports.countWorkingDays = exports.isWorkingDay = exports.eachDate = exports.todayInJohannesburg = exports.toIsoDate = exports.LEAVE_TIME_ZONE = void 0;
+// The calendar arithmetic behind leave: which days of a request count, and which leave year a
+// date belongs to. Pure functions over `YYYY-MM-DD` strings - the columns are `date`, so a
+// request never carries a time and nothing here depends on the caller's clock zone.
+/**
+ * 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.
+ */
+exports.LEAVE_TIME_ZONE = 'Africa/Johannesburg';
+/** Saturday and Sunday. Not configurable yet - a working-week setting is a later feature. */
+const WEEKEND_DAYS = new Set([0, 6]);
+const pad = (value) => String(value).padStart(2, '0');
+/** A `Date` at UTC midnight of a `YYYY-MM-DD` string (a longer ISO string is cut to its date). */
+const parseIsoDate = (value) => {
+    const [year, month, day] = value.slice(0, 10).split('-').map(Number);
+    return new Date(Date.UTC(year, month - 1, day));
+};
+/** The `YYYY-MM-DD` of a `Date`'s UTC calendar day. */
+const toIsoDate = (date) => `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
+exports.toIsoDate = toIsoDate;
+/** Today's calendar date in `LEAVE_TIME_ZONE`. */
+const todayInJohannesburg = (now = new Date()) => 
+// en-CA is the locale whose short date is already YYYY-MM-DD.
+new Intl.DateTimeFormat('en-CA', {
+    timeZone: exports.LEAVE_TIME_ZONE,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+}).format(now);
+exports.todayInJohannesburg = todayInJohannesburg;
+/** Every calendar date from `start` to `end` inclusive; empty when `end` is before `start`. */
+const eachDate = (start, end) => {
+    const dates = [];
+    const last = end.slice(0, 10);
+    for (const cursor = parseIsoDate(start); (0, exports.toIsoDate)(cursor) <= last; cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+        dates.push((0, exports.toIsoDate)(cursor));
+    }
+    return dates;
+};
+exports.eachDate = eachDate;
+/** Monday to Friday and not one of the organization's holidays. */
+const isWorkingDay = (isoDate, holidays) => !WEEKEND_DAYS.has(parseIsoDate(isoDate).getUTCDay()) && !holidays.has(isoDate.slice(0, 10));
+exports.isWorkingDay = isWorkingDay;
+/**
+ * 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.
+ */
+const countWorkingDays = (start, end, holidays, isHalfDay = false) => {
+    const working = (0, exports.eachDate)(start, end).filter((date) => (0, exports.isWorkingDay)(date, holidays)).length;
+    return isHalfDay ? working * 0.5 : working;
+};
+exports.countWorkingDays = countWorkingDays;
+/** The day before the same date next year - the end of a period that starts on `isoDate`. */
+const addOneYearMinusDay = (isoDate) => {
+    const date = parseIsoDate(isoDate);
+    date.setUTCFullYear(date.getUTCFullYear() + 1);
+    date.setUTCDate(date.getUTCDate() - 1);
+    return (0, exports.toIsoDate)(date);
+};
+exports.addOneYearMinusDay = addOneYearMinusDay;
+/**
+ * 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.
+ */
+const leavePeriodFor = (date, startMonth) => {
+    const parsed = parseIsoDate(date);
+    const year = parsed.getUTCMonth() + 1 >= startMonth ? parsed.getUTCFullYear() : parsed.getUTCFullYear() - 1;
+    const period_start = (0, exports.toIsoDate)(new Date(Date.UTC(year, startMonth - 1, 1)));
+    return { period_start, period_end: (0, exports.addOneYearMinusDay)(period_start) };
+};
+exports.leavePeriodFor = leavePeriodFor;
+const isWithinPeriod = (date, period) => {
+    const day = date.slice(0, 10);
+    return day >= period.period_start && day <= period.period_end;
+};
+exports.isWithinPeriod = isWithinPeriod;

package/dist/permissions/dto.d.ts

@@ -12,6 +12,18 @@ export declare class UpdatePermissionsDto implements UpdatePermissionsDtoType {
     readonly read_tasks: boolean;
     readonly update_tasks: boolean;
     readonly delete_tasks: boolean;
+    readonly create_leave: boolean;
+    readonly read_leave: boolean;
+    readonly update_leave: boolean;
+    readonly delete_leave: boolean;
+    readonly create_leave_types: boolean;
+    readonly read_leave_types: boolean;
+    readonly update_leave_types: boolean;
+    readonly delete_leave_types: boolean;
+    readonly create_leave_requests: boolean;
+    readonly read_leave_requests: boolean;
+    readonly update_leave_requests: boolean;
+    readonly delete_leave_requests: boolean;
     readonly read_invoices: boolean;
     readonly create_users: boolean;
     readonly read_users: boolean;

package/dist/permissions/dto.js

@@ -42,30 +42,18 @@ class UpdatePermissionsDto {
     // readonly update_documents!: boolean;
     // @IsBoolean({ message: 'Delete Documents must be a boolean' })
     // readonly delete_documents!: boolean;
-    // @IsBoolean({ message: 'Create Leave must be a boolean' })
-    // readonly create_leave!: boolean;
-    // @IsBoolean({ message: 'Read Leave must be a boolean' })
-    // readonly read_leave!: boolean;
-    // @IsBoolean({ message: 'Update Leave must be a boolean' })
-    // readonly update_leave!: boolean;
-    // @IsBoolean({ message: 'Delete Leave must be a boolean' })
-    // readonly delete_leave!: boolean;
-    // @IsBoolean({ message: 'Create Leave Types must be a boolean' })
-    // readonly create_leave_types!: boolean;
-    // @IsBoolean({ message: 'Read Leave Types must be a boolean' })
-    // readonly read_leave_types!: boolean;
-    // @IsBoolean({ message: 'Update Leave Types must be a boolean' })
-    // readonly update_leave_types!: boolean;
-    // @IsBoolean({ message: 'Delete Leave Types must be a boolean' })
-    // readonly delete_leave_types!: boolean;
-    // @IsBoolean({ message: 'Create Leave Requests must be a boolean' })
-    // readonly create_leave_requests!: boolean;
-    // @IsBoolean({ message: 'Read Leave Requests must be a boolean' })
-    // readonly read_leave_requests!: boolean;
-    // @IsBoolean({ message: 'Update Leave Requests must be a boolean' })
-    // readonly update_leave_requests!: boolean;
-    // @IsBoolean({ message: 'Delete Leave Requests must be a boolean' })
-    // readonly delete_leave_requests!: boolean;
+    create_leave;
+    read_leave;
+    update_leave;
+    delete_leave;
+    create_leave_types;
+    read_leave_types;
+    update_leave_types;
+    delete_leave_types;
+    create_leave_requests;
+    read_leave_requests;
+    update_leave_requests;
+    delete_leave_requests;
     // @IsBoolean({ message: 'Create Invoices must be a boolean' })
     // readonly create_invoices!: boolean;
     read_invoices;
@@ -164,6 +152,54 @@ __decorate([
     (0, class_validator_1.IsBoolean)({ message: 'Delete Tasks must be a boolean' }),
     __metadata("design:type", Boolean)
 ], UpdatePermissionsDto.prototype, "delete_tasks", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Create Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "create_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Read Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "read_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Update Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "update_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Delete Leave must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "delete_leave", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Create Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "create_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Read Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "read_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Update Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "update_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Delete Leave Types must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "delete_leave_types", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Create Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "create_leave_requests", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Read Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "read_leave_requests", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Update Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "update_leave_requests", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)({ message: 'Delete Leave Requests must be a boolean' }),
+    __metadata("design:type", Boolean)
+], UpdatePermissionsDto.prototype, "delete_leave_requests", void 0);
 __decorate([
     (0, class_validator_1.IsBoolean)({ message: 'Read Invoices must be a boolean' }),
     __metadata("design:type", Boolean)

package/dist/public-holidays/dto.d.ts

@@ -0,0 +1,4 @@
+import type { GetPublicHolidaysDto as GetPublicHolidaysDtoType } from '@managemint-solutions/entities/public-holidays/dto';
+export declare class GetPublicHolidaysDto implements GetPublicHolidaysDtoType {
+    readonly year?: number | null;
+}

package/dist/public-holidays/dto.js

@@ -0,0 +1,30 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPublicHolidaysDto = void 0;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const validators_1 = require("../validators");
+// class-validator version of the shared DTO type from @managemint-solutions/entities.
+// The class `implements` its entities type so the wire contract cannot drift.
+class GetPublicHolidaysDto {
+    year;
+}
+exports.GetPublicHolidaysDto = GetPublicHolidaysDto;
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, validators_1.IsNullable)(),
+    (0, class_transformer_1.Transform)(({ value }) => (value ? Number(value) : value), { toClassOnly: true }),
+    (0, class_validator_1.IsInt)({ message: 'Year must be a whole number' }),
+    (0, class_validator_1.Min)(2000, { message: 'Year must be 2000 or later' }),
+    (0, class_validator_1.Max)(2100, { message: 'Year must be 2100 or earlier' }),
+    __metadata("design:type", Object)
+], GetPublicHolidaysDto.prototype, "year", void 0);

package/dist/public-holidays/index.d.ts

@@ -0,0 +1,21 @@
+import type { PublicHolidayEntity } from '@managemint-solutions/entities/public-holidays';
+import type { TypedSupabaseClient } from '../client';
+import type { GetPublicHolidaysDto } from './dto';
+export * from './dto';
+/**
+ * The public-holiday calendar. Global, like configs: every signed-in caller reads the same
+ * rows (the READ policy is `true` - there is no tenant on them), so this hangs off the user
+ * client with no auth context, and nothing writes them but Scott in Supabase Studio.
+ */
+export declare class PublicHolidaysResource {
+    private readonly supabase;
+    constructor(supabase: TypedSupabaseClient);
+    /** The calendar in date order, or one calendar year of it. */
+    list(query: GetPublicHolidaysDto): Promise<PublicHolidayEntity[]>;
+    /**
+     * The dates between `start` and `end` (inclusive) that are a day off for everyone - the input
+     * to leave's working-day count. A faith-specific holiday (`religion` set) is on the calendar
+     * but does not shorten a request, since nothing yet says which employees observe it.
+     */
+    datesBetween(start: string, end: string): Promise<Set<string>>;
+}

package/dist/public-holidays/index.js

@@ -0,0 +1,63 @@
+"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.PublicHolidaysResource = void 0;
+const errors_1 = require("../errors");
+__exportStar(require("./dto"), exports);
+const PUBLIC_HOLIDAY_SELECT = 'mms_id, created_at, name, date, religion, notes';
+/**
+ * The public-holiday calendar. Global, like configs: every signed-in caller reads the same
+ * rows (the READ policy is `true` - there is no tenant on them), so this hangs off the user
+ * client with no auth context, and nothing writes them but Scott in Supabase Studio.
+ */
+class PublicHolidaysResource {
+    supabase;
+    constructor(supabase) {
+        this.supabase = supabase;
+    }
+    /** The calendar in date order, or one calendar year of it. */
+    async list(query) {
+        let holidaysQuery = this.supabase
+            .from('public_holidays')
+            .select(PUBLIC_HOLIDAY_SELECT)
+            .order('date')
+            .order('name');
+        if (query.year) {
+            holidaysQuery = holidaysQuery.gte('date', `${query.year}-01-01`).lte('date', `${query.year}-12-31`);
+        }
+        const { data, error } = await holidaysQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []);
+    }
+    /**
+     * The dates between `start` and `end` (inclusive) that are a day off for everyone - the input
+     * to leave's working-day count. A faith-specific holiday (`religion` set) is on the calendar
+     * but does not shorten a request, since nothing yet says which employees observe it.
+     */
+    async datesBetween(start, end) {
+        const { data, error } = await this.supabase
+            .from('public_holidays')
+            .select('date')
+            .is('religion', null)
+            .gte('date', start)
+            .lte('date', end);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return new Set((data ?? []).map((row) => row.date));
+    }
+}
+exports.PublicHolidaysResource = PublicHolidaysResource;

package/dist/users/index.d.ts

@@ -26,6 +26,8 @@ export declare class UsersResource {
      * client — it needs no service role.
      */
     identityById(userId?: string | null): Promise<UserIdentity | null>;
+    /** The users who report to `managerId` - the direct reports a leave approver may act on. */
+    idsManagedBy(managerId: string): Promise<string[]>;
     /** Seats in use. Counts rows rather than fetching them. */
     activeCount(): Promise<number>;
     isActive(userId: string): Promise<boolean>;

package/dist/users/index.js

@@ -92,6 +92,17 @@ class UsersResource {
             throw (0, errors_1.mapPostgrestError)(error);
         return data;
     }
+    /** The users who report to `managerId` - the direct reports a leave approver may act on. */
+    async idsManagedBy(managerId) {
+        const { data, error } = await this.supabase
+            .from('users')
+            .select('mms_id')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('manager_id', managerId);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []).map((row) => row.mms_id);
+    }
     /** Seats in use. Counts rows rather than fetching them. */
     async activeCount() {
         const { count, error } = await this.supabase

package/dist/validators.d.ts

@@ -1,4 +1,12 @@
 import { ValidationOptions } from 'class-validator';
+/** A real `YYYY-MM-DD` - the only date shape a `date` column's DTO accepts. */
+export declare const isCalendarDate: (value: unknown) => value is string;
+/**
+ * Calendar dates, `YYYY-MM-DD` and nothing more, for the leave and public-holiday columns
+ * that are `date`: a timestamp would leave the day to whoever's time zone did the
+ * conversion. Stricter on purpose than the `@IsDateString` the timestamp columns use.
+ */
+export declare const IsCalendarDate: (options?: ValidationOptions) => PropertyDecorator;
 export declare function IsNullable(validationOptions?: ValidationOptions): PropertyDecorator;
 /**
  * An empty string from a cleared form field means "none". It becomes null before validation,

package/dist/validators.js

@@ -1,9 +1,41 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsCalendarDate = exports.isCalendarDate = void 0;
 exports.IsNullable = IsNullable;
 exports.EmptyToNull = EmptyToNull;
 const class_validator_1 = require("class-validator");
 const class_transformer_1 = require("class-transformer");
+const CALENDAR_DATE = /^\d{4}-\d{2}-\d{2}$/;
+/** A real `YYYY-MM-DD` - the only date shape a `date` column's DTO accepts. */
+const isCalendarDate = (value) => {
+    if (typeof value !== 'string' || !CALENDAR_DATE.test(value))
+        return false;
+    const [year, month, day] = value.split('-').map(Number);
+    const parsed = new Date(Date.UTC(year, month - 1, day));
+    return (parsed.getUTCFullYear() === year && parsed.getUTCMonth() === month - 1 && parsed.getUTCDate() === day);
+};
+exports.isCalendarDate = isCalendarDate;
+let CalendarDateConstraint = class CalendarDateConstraint {
+    validate(value) {
+        return (0, exports.isCalendarDate)(value);
+    }
+};
+CalendarDateConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'isCalendarDate' })
+], CalendarDateConstraint);
+/**
+ * Calendar dates, `YYYY-MM-DD` and nothing more, for the leave and public-holiday columns
+ * that are `date`: a timestamp would leave the day to whoever's time zone did the
+ * conversion. Stricter on purpose than the `@IsDateString` the timestamp columns use.
+ */
+const IsCalendarDate = (options) => (0, class_validator_1.Validate)(CalendarDateConstraint, options);
+exports.IsCalendarDate = IsCalendarDate;
 function IsNullable(validationOptions) {
     return (0, class_validator_1.ValidateIf)((_object, value) => value !== null, validationOptions);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@managemint-solutions/sdk",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "description": "Typed Supabase data-access SDK for ManageMint Solutions",
   "license": "UNLICENSED",
   "author": "Scott Bebington <scottbebington@gmail.com>",
@@ -51,7 +51,7 @@
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@managemint-solutions/entities": "^1.20.0"
+    "@managemint-solutions/entities": "^1.22.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",