@managemint-solutions/sdk 0.39.0 → 0.40.0

package/dist/timesheets/timesheets.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimesheetsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const enum_2 = require("@managemint-solutions/entities/timesheets/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const working_days_1 = require("../leave/working-days");
+const transforms_1 = require("../transforms");
+const timesheet_entries_1 = require("./timesheet-entries");
+const weeks_1 = require("./weeks");
+const TIMESHEET_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 (*),
+        week_start,
+        status,
+        submitted_at,
+        reviewed_by:user_profiles!reviewed_by (*),
+        reviewed_at,
+        review_note
+      `;
+class TimesheetsResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'timesheets',
+            entityType: enum_1.AuditTrailEntityType.TIMESHEETS,
+        });
+    }
+    async list(query, options = {}) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        let timesheetsQuery = this.supabase
+            .from('timesheets')
+            .select(TIMESHEET_SELECT, { count: 'estimated' })
+            .eq('organization_id', this.auth.organization_id)
+            .order('week_start', { ascending: false })
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (options.userIds) {
+            timesheetsQuery = timesheetsQuery.in('user_id', options.userIds);
+        }
+        if (query.user_id) {
+            timesheetsQuery = timesheetsQuery.eq('user_id', query.user_id);
+        }
+        if (query.status) {
+            timesheetsQuery = timesheetsQuery.eq('status', query.status);
+        }
+        if (query.week_start) {
+            timesheetsQuery = timesheetsQuery.eq('week_start', query.week_start);
+        }
+        const { data, error, count } = await timesheetsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const rows = await this.withTotals((data ?? []));
+        return (0, transforms_1.toMmsList)(rows, page, pageSize, count);
+    }
+    /** The week with its entries, by date then start time. */
+    async getById(timesheetId) {
+        const summary = await this.summaryById(timesheetId);
+        const { data, error } = await this.supabase
+            .from('timesheet_entries')
+            .select(timesheet_entries_1.TIMESHEET_ENTRY_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('timesheet_id', timesheetId)
+            .order('date')
+            .order('start_time');
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return { ...summary, entries: (data ?? []).map(timesheet_entries_1.withClockTimes) };
+    }
+    /**
+     * The week of `userId` starting on `weekStart`, or null when no entry has opened it yet. One
+     * row per user and Monday (the table's unique key), so there is at most one.
+     */
+    async findFor(userId, weekStart) {
+        const { data, error } = await this.supabase
+            .from('timesheets')
+            .select('mms_id, status, week_start')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('user_id', userId)
+            .eq('week_start', weekStart)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    /** Opens a week as a draft. A second opener of the same week hits the unique key - the SDK's 409. */
+    async create(input) {
+        const row = await this.table.insert({
+            user_id: input.user_id,
+            week_start: input.week_start,
+            status: enum_2.TimesheetStatus.DRAFT,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.summaryById(row.mms_id);
+    }
+    /**
+     * Sends a draft or rejected week for review, clearing the previous decision. Resolves to null
+     * when the week was no longer in either state - submitted twice from two tabs, say.
+     */
+    async submit(timesheetId) {
+        const now = new Date().toISOString();
+        const row = await this.table.updateWhere(timesheetId, (query) => query.in('status', [enum_2.TimesheetStatus.DRAFT, enum_2.TimesheetStatus.REJECTED]), {
+            status: enum_2.TimesheetStatus.SUBMITTED,
+            submitted_at: now,
+            reviewed_by: null,
+            reviewed_at: null,
+            review_note: null,
+            last_updated_by: this.auth.mms_id,
+            updated_at: now,
+        });
+        return row ? this.summaryById(timesheetId) : null;
+    }
+    /**
+     * Approves or rejects a submitted week. Resolves to null when the week was no longer
+     * submitted - another reviewer got there first - so the caller can say so instead of
+     * overwriting their decision.
+     */
+    async review(timesheetId, input) {
+        const now = new Date().toISOString();
+        const row = await this.table.updateWhere(timesheetId, (query) => query.eq('status', enum_2.TimesheetStatus.SUBMITTED), {
+            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.summaryById(timesheetId) : null;
+    }
+    /**
+     * The ids of `userIds`' approved weeks that could hold an entry dated `dateFrom`..`dateTo` -
+     * the weeks starting from the Monday of `dateFrom` up to `dateTo`. The report keeps only the
+     * entries of these weeks.
+     */
+    async approvedIds(userIds, dateFrom, dateTo) {
+        if (userIds.length === 0)
+            return new Set();
+        const rows = await (0, transforms_1.allRows)((from, to) => this.supabase
+            .from('timesheets')
+            .select('mms_id')
+            .eq('organization_id', this.auth.organization_id)
+            .in('user_id', userIds)
+            .eq('status', enum_2.TimesheetStatus.APPROVED)
+            .gte('week_start', (0, weeks_1.weekStartOf)(dateFrom))
+            .lte('week_start', dateTo)
+            .order('mms_id')
+            .range(from, to));
+        return new Set(rows.map((row) => row.mms_id));
+    }
+    async summaryById(timesheetId) {
+        const { data, error } = await this.supabase
+            .from('timesheets')
+            .select(TIMESHEET_SELECT)
+            .eq('mms_id', timesheetId)
+            .eq('organization_id', this.auth.organization_id)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const [row] = await this.withTotals([data]);
+        return row;
+    }
+    /**
+     * Adds `week_end` and the totals to each row from one query over the entries of these weeks.
+     * Nothing is stored: a total is always what the entries add up to.
+     */
+    async withTotals(rows) {
+        if (rows.length === 0)
+            return [];
+        const timesheetIds = rows.map((row) => row.mms_id);
+        const entries = await (0, transforms_1.allRows)((from, to) => this.supabase
+            .from('timesheet_entries')
+            .select('timesheet_id, duration_minutes')
+            .eq('organization_id', this.auth.organization_id)
+            .in('timesheet_id', timesheetIds)
+            .order('mms_id')
+            .range(from, to));
+        return rows.map((row) => {
+            const mine = entries.filter((entry) => entry.timesheet_id === row.mms_id);
+            return {
+                ...row,
+                week_end: (0, working_days_1.shiftDays)(row.week_start, 6),
+                total_minutes: mine.reduce((total, entry) => total + Number(entry.duration_minutes), 0),
+                entry_count: mine.length,
+            };
+        });
+    }
+}
+exports.TimesheetsResource = TimesheetsResource;

package/dist/timesheets/weeks.d.ts

@@ -0,0 +1,7 @@
+/** The Monday of the week containing `isoDate` (a Sunday belongs to the week before it). */
+export declare const weekStartOf: (isoDate: string) => string;
+/**
+ * The minutes from `start` to `end` on one day; `end` may be `24:00` for midnight. Zero or
+ * negative when the end is not after the start - the caller rejects that, so it is not clamped.
+ */
+export declare const minutesBetween: (start: string, end: string) => number;

package/dist/timesheets/weeks.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minutesBetween = exports.weekStartOf = void 0;
+const working_days_1 = require("../leave/working-days");
+// The calendar arithmetic behind timesheets: which Monday-to-Sunday week a date belongs to, and
+// how long an entry is. Pure functions over `YYYY-MM-DD` and `HH:MM` strings - the columns are
+// `date` and `time`, so nothing here depends on the caller's clock zone.
+/** The Monday of the week containing `isoDate` (a Sunday belongs to the week before it). */
+const weekStartOf = (isoDate) => {
+    const date = (0, working_days_1.parseIsoDate)(isoDate);
+    // getUTCDay: 0 = Sunday .. 6 = Saturday; Monday is 0 days back, Sunday 6.
+    const daysSinceMonday = (date.getUTCDay() + 6) % 7;
+    date.setUTCDate(date.getUTCDate() - daysSinceMonday);
+    return (0, working_days_1.toIsoDate)(date);
+};
+exports.weekStartOf = weekStartOf;
+const toMinutes = (clockTime) => {
+    const [hours, minutes] = clockTime.split(':').map(Number);
+    return hours * 60 + minutes;
+};
+/**
+ * The minutes from `start` to `end` on one day; `end` may be `24:00` for midnight. Zero or
+ * negative when the end is not after the start - the caller rejects that, so it is not clamped.
+ */
+const minutesBetween = (start, end) => toMinutes(end) - toMinutes(start);
+exports.minutesBetween = minutesBetween;

package/dist/transforms.d.ts

@@ -1,3 +1,4 @@
+import type { PostgrestError } from '@supabase/supabase-js';
 import type { MmsList } from '@managemint-solutions/entities/common';
 /**
  * The `client_id` / `project_id` list filters accept either a plain UUID v7 or the base64-JSON
@@ -55,3 +56,15 @@ export declare const restoredPatch: (by: string) => {
     restored_at: string;
     restored_by: string;
 };
+/** The most rows one PostgREST response carries (Supabase's `max-rows`); past it a result is cut short silently. */
+export declare const ROW_CAP = 1000;
+/**
+ * Every row of a query that may outgrow one response, fetched in pages of `ROW_CAP`. `build`
+ * returns the query for one page's `.range(from, to)`; the walk stops at the first short page.
+ * The callers are the unpaged reads a job or a rollup makes - a rollover pass, a report, the
+ * per-page totals - never a list the api pages itself.
+ */
+export declare const allRows: <T>(build: (from: number, to: number) => PromiseLike<{
+    data: unknown;
+    error: PostgrestError | null;
+}>) => Promise<T[]>;

package/dist/transforms.js

@@ -2,7 +2,8 @@
 // Small conversions shared by the DTOs' `@Transform`s, the resources' write payloads, their
 // select strings and their list results.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoredPatch = exports.deletedPatch = exports.unarchivedPatch = exports.archivedPatch = exports.toMmsList = exports.USER_PROFILE_EMBED = exports.toDateInput = exports.orIlike = exports.ilikeContains = exports.parseEntityIdFilter = void 0;
+exports.allRows = exports.ROW_CAP = exports.restoredPatch = exports.deletedPatch = exports.unarchivedPatch = exports.archivedPatch = exports.toMmsList = exports.USER_PROFILE_EMBED = exports.toDateInput = exports.orIlike = exports.ilikeContains = exports.parseEntityIdFilter = void 0;
+const errors_1 = require("./errors");
 // v7, to match the `mms_id` columns these filters compare against - `public.uuidv7()` is the
 // default on every table. This is the gate in front of `@IsUUID('7')`, so a stricter version
 // here would null the id out before validation ever saw it, and a looser one would let a value
@@ -110,3 +111,25 @@ const restoredPatch = (by) => ({
     restored_by: by,
 });
 exports.restoredPatch = restoredPatch;
+/** The most rows one PostgREST response carries (Supabase's `max-rows`); past it a result is cut short silently. */
+exports.ROW_CAP = 1000;
+/**
+ * Every row of a query that may outgrow one response, fetched in pages of `ROW_CAP`. `build`
+ * returns the query for one page's `.range(from, to)`; the walk stops at the first short page.
+ * The callers are the unpaged reads a job or a rollup makes - a rollover pass, a report, the
+ * per-page totals - never a list the api pages itself.
+ */
+const allRows = async (build) => {
+    const rows = [];
+    for (let offset = 0;; offset += exports.ROW_CAP) {
+        const { data, error } = await build(offset, offset + exports.ROW_CAP - 1);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const page = (data ?? []);
+        rows.push(...page);
+        if (page.length < exports.ROW_CAP)
+            break;
+    }
+    return rows;
+};
+exports.allRows = allRows;

package/dist/users/dto.d.ts

@@ -38,6 +38,7 @@ export declare class UpdateUserDto implements UpdateUserDtoType {
     readonly end_date?: string | null;
     readonly job_title?: string | null;
     readonly manager_id?: string | null;
+    readonly secondary_manager_id?: string | null;
     readonly social_facebook?: string | null;
     readonly social_linkedin?: string | null;
     readonly social_twitter?: string | null;

package/dist/users/dto.js

@@ -137,6 +137,7 @@ class UpdateUserDto {
     end_date;
     job_title;
     manager_id;
+    secondary_manager_id;
     social_facebook;
     social_linkedin;
     social_twitter;
@@ -209,6 +210,12 @@ __decorate([
     (0, class_validator_1.IsUUID)('4', { message: 'Invalid manager ID format' }),
     __metadata("design:type", Object)
 ], UpdateUserDto.prototype, "manager_id", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, validators_1.IsNullable)(),
+    (0, class_validator_1.IsUUID)('4', { message: 'Invalid secondary manager ID format' }),
+    __metadata("design:type", Object)
+], UpdateUserDto.prototype, "secondary_manager_id", void 0);
 __decorate([
     (0, class_validator_1.IsOptional)(),
     (0, validators_1.EmptyToNull)(),

package/dist/users/index.d.ts

@@ -9,6 +9,7 @@ export * from './paths';
 export type UserRow = Record<string, unknown> & {
     mms_id: string;
     manager_id: string | null;
+    secondary_manager_id: string | null;
     created_by: string | null;
     last_updated_by: string | null;
 };
@@ -26,8 +27,14 @@ 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. */
+    /**
+     * The users who report to `managerId` - everyone naming them as primary or secondary
+     * manager, the direct reports a leave or timesheet approver may act on. One level, and
+     * `active` is not consulted: a deactivated report's history stays visible to their manager.
+     */
     idsManagedBy(managerId: string): Promise<string[]>;
+    /** The ids of every active member - who the leave rollover grants a new period to. */
+    activeIds(): 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,13 +92,28 @@ 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. */
+    /**
+     * The users who report to `managerId` - everyone naming them as primary or secondary
+     * manager, the direct reports a leave or timesheet approver may act on. One level, and
+     * `active` is not consulted: a deactivated report's history stays visible to their manager.
+     */
     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);
+            .or(`manager_id.eq.${managerId},secondary_manager_id.eq.${managerId}`);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []).map((row) => row.mms_id);
+    }
+    /** The ids of every active member - who the leave rollover grants a new period to. */
+    async activeIds() {
+        const { data, error } = await this.supabase
+            .from('users')
+            .select('mms_id')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('active', true);
         if (error)
             throw (0, errors_1.mapPostgrestError)(error);
         return (data ?? []).map((row) => row.mms_id);

package/dist/validators.d.ts

@@ -7,6 +7,16 @@ export declare const isCalendarDate: (value: unknown) => value is string;
  * conversion. Stricter on purpose than the `@IsDateString` the timestamp columns use.
  */
 export declare const IsCalendarDate: (options?: ValidationOptions) => PropertyDecorator;
+/** A wall-clock `HH:MM`; `24:00` as well when `allowEndOfDay` - a shift that ends at midnight. */
+export declare const isClockTime: (value: unknown, allowEndOfDay?: boolean) => value is string;
+/**
+ * Clock times, `HH:MM` and nothing more, for the timesheet columns that are `time`: a start is
+ * `00:00`..`23:59`, and an end may also be `24:00` (`allowEndOfDay`) so a shift can finish at
+ * midnight without crossing it. Seconds are never sent - the SDK trims them off on read.
+ */
+export declare const IsClockTime: ({ allowEndOfDay, ...options }?: ValidationOptions & {
+    allowEndOfDay?: boolean;
+}) => 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

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsCalendarDate = exports.isCalendarDate = void 0;
+exports.IsClockTime = exports.isClockTime = exports.IsCalendarDate = exports.isCalendarDate = void 0;
 exports.IsNullable = IsNullable;
 exports.EmptyToNull = EmptyToNull;
 const class_validator_1 = require("class-validator");
@@ -36,6 +36,26 @@ CalendarDateConstraint = __decorate([
  */
 const IsCalendarDate = (options) => (0, class_validator_1.Validate)(CalendarDateConstraint, options);
 exports.IsCalendarDate = IsCalendarDate;
+const CLOCK_TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+/** A wall-clock `HH:MM`; `24:00` as well when `allowEndOfDay` - a shift that ends at midnight. */
+const isClockTime = (value, allowEndOfDay = false) => typeof value === 'string' && (CLOCK_TIME.test(value) || (allowEndOfDay && value === '24:00'));
+exports.isClockTime = isClockTime;
+let ClockTimeConstraint = class ClockTimeConstraint {
+    validate(value, args) {
+        const [allowEndOfDay] = args.constraints;
+        return (0, exports.isClockTime)(value, allowEndOfDay);
+    }
+};
+ClockTimeConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'isClockTime' })
+], ClockTimeConstraint);
+/**
+ * Clock times, `HH:MM` and nothing more, for the timesheet columns that are `time`: a start is
+ * `00:00`..`23:59`, and an end may also be `24:00` (`allowEndOfDay`) so a shift can finish at
+ * midnight without crossing it. Seconds are never sent - the SDK trims them off on read.
+ */
+const IsClockTime = ({ allowEndOfDay = false, ...options } = {}) => (0, class_validator_1.Validate)(ClockTimeConstraint, [allowEndOfDay], options);
+exports.IsClockTime = IsClockTime;
 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.39.0",
+  "version": "0.40.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.22.0"
+    "@managemint-solutions/entities": "^1.23.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",