@happyvertical/smrt-timesheets 0.57.0 → 0.57.1

package/dist/chunks/{attendance-Cmk-6dTV.js → attendance-UY7sTXFx.js}

@@ -1,5 +1,5 @@
-import { i as ServiceTimeEntryCollection, o as parseTimesheetJson } from "./service-time-entry-DzQsRZc_.js";
-import { c as AttendanceSegmentCollection, d as persistAutoClose, f as persistCorrection, i as AttendancePunchCollection, l as deleteCorrection, n as AttendanceBreakCollection, o as AttendanceReplayCollection, r as AttendancePunch, s as AttendanceSegment, t as AttendanceBreak, u as isCorrectionWrite } from "./models-BCrk0kZQ.js";
+import { i as ServiceTimeEntryCollection, o as parseTimesheetJson } from "./service-time-entry-CWAVYIID.js";
+import { c as AttendanceSegmentCollection, d as persistAutoClose, f as persistCorrection, i as AttendancePunchCollection, l as deleteCorrection, n as AttendanceBreakCollection, o as AttendanceReplayCollection, r as AttendancePunch, s as AttendanceSegment, t as AttendanceBreak, u as isCorrectionWrite } from "./models-BJcnFMOL.js";
 import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, isEmbeddedDatabase, isPostgresDatabase, smrt, withEmbeddedWriteTransaction } from "@happyvertical/smrt-core";
 import { TenantScoped, getTenantId, tenantId, withTenant } from "@happyvertical/smrt-tenancy";
 //#region src/attendance/correction-models.ts
@@ -199,6 +199,7 @@ async function beginSegment(tx, punch, at, work) {
 	return tx.segments.create({
 		tenantId: punch.tenantId,
 		punchId: punch.id ?? void 0,
+		profileId: punch.profileId,
 		workRefType: work.workRefType,
 		workRefId: work.workRefId,
 		taskRefType: work.taskRefType ?? "",
@@ -713,6 +714,8 @@ var AttendanceService = class {
 			const deviceAt = new Date(tap.at);
 			let at = deviceAt;
 			let review = false;
+			let punchReview = true;
+			let offline = true;
 			if (options.resolveAt) {
 				const serverNow = this.date(options.now?.() ?? /* @__PURE__ */ new Date());
 				const resolved = await options.resolveAt({
@@ -725,6 +728,8 @@ var AttendanceService = class {
 				if (!resolved || !(resolved.at instanceof Date) || !Number.isFinite(resolved.at.getTime())) throw new Error("resolveAt must return a valid date.");
 				at = resolved.at;
 				review = resolved.reviewRequired === true;
+				punchReview = resolved.reviewRequired !== false;
+				offline = resolved.recordedOffline !== false;
 			}
 			let outcome;
 			try {
@@ -737,8 +742,8 @@ var AttendanceService = class {
 						replays: tx.replays
 					};
 					const { punch, segment } = await this.apply(inner, tap, at);
-					punch.recordedOffline = true;
-					punch.reviewRequired = true;
+					punch.recordedOffline ||= offline;
+					punch.reviewRequired ||= punchReview;
 					await punch.save();
 					if (segment && review) {
 						segment.reviewRequired = true;
@@ -774,6 +779,7 @@ var AttendanceService = class {
 };
 //#endregion
 //#region src/attendance/correction-service.ts
+var FOREVER = /* @__PURE__ */ new Date(864e13);
 var iso = (d) => d ? d.toISOString() : null;
 var punchState = (p) => ({
 	startedAt: iso(p.startedAt),
@@ -837,11 +843,16 @@ var AttendanceCorrectionService = class {
 	db;
 	options;
 	actor;
-	/** Change a closed punch's start and/or end. A reviewed punch no longer needs review. */
+	/**
+	* Change a closed punch's start and/or end. A reviewed punch no longer needs
+	* review. An open punch may change `startedAt` only: it cannot be closed
+	* here, and its start cannot move past its earliest break or segment.
+	*/
 	async correctPunch(input) {
 		return this.run(input, async (tx, subject, record) => {
-			const punch = await this.closedPunch(tx, subject, input.punchId);
+			const punch = await this.anyPunch(tx, subject, input.punchId);
 			const before = punchState(punch);
+			if (!punch.endedAt) return this.correctOpenStart(tx, subject, record, punch, input, before);
 			const startedAt = input.startedAt === void 0 ? punch.startedAt : instant(input.startedAt, "startedAt");
 			const endedAt = input.endedAt === void 0 ? punch.endedAt : instant(input.endedAt, "endedAt");
 			if (endedAt <= startedAt) throw new AttendanceConflict("A punch must end after it starts.");
@@ -872,8 +883,13 @@ var AttendanceCorrectionService = class {
 			return record("punch.corrected", punch, punch.id, before, punchState(punch));
 		});
 	}
-	/** Record a missed punch retroactively, as an already-closed interval. */
+	/**
+	* Record a missed punch retroactively: a closed interval, or with
+	* `{ open: true }` one that is still running, carrying its closed breaks and
+	* segments.
+	*/
 	async addPunch(input) {
+		if (input.open === true) return this.addOpenPunch(input);
 		return this.run(input, async (tx, subject, record) => {
 			const startedAt = instant(input.startedAt, "startedAt");
 			const endedAt = instant(input.endedAt, "endedAt");
@@ -905,13 +921,14 @@ var AttendanceCorrectionService = class {
 			return record("punch.added", punch, punch.id, null, punchState(punch));
 		});
 	}
-	/** Add a break to a closed punch, or change one (times and/or paid). */
+	/** Add a closed break to a punch, or change one (times and/or paid). */
 	async saveBreak(input) {
 		return this.run(input, async (tx, subject, record) => {
-			const punch = await this.closedPunch(tx, subject, input.punchId);
+			const punch = await this.anyPunch(tx, subject, input.punchId);
 			const children = await this.children(tx, punch);
 			const existing = input.breakId ? children.breaks.find((b) => b.id === input.breakId) : void 0;
 			if (input.breakId && !existing) throw new AttendanceConflict("Break not found in that punch.");
+			if (existing && !existing.endedAt) throw new AttendanceConflict("The open break is changed through AttendanceService.");
 			if (!existing && (input.startedAt === void 0 || input.endedAt === void 0)) throw new AttendanceConflict("A new break needs startedAt and endedAt.");
 			if (input.paid !== void 0 && typeof input.paid !== "boolean") throw new AttendanceConflict("paid must be boolean.");
 			const next = {
@@ -925,10 +942,7 @@ var AttendanceCorrectionService = class {
 				breaks: [...rest, next],
 				segments: children.segments
 			}));
-			await this.guard(tx, subject, [{
-				startsAt: punch.startedAt,
-				endsAt: punch.endedAt
-			}]);
+			await this.guard(tx, subject, [this.span(punch)]);
 			const entry = await this.editableEntry(tx, punch);
 			const before = existing ? breakState(existing) : null;
 			let target;
@@ -956,7 +970,7 @@ var AttendanceCorrectionService = class {
 			return record(existing ? "break.changed" : "break.added", punch, target.id, before, breakState(target));
 		});
 	}
-	/** Remove a break from a closed punch. */
+	/** Remove a closed break from a punch. */
 	async removeBreak(input) {
 		return this.run(input, async (tx, subject, record) => {
 			const [target] = await tx.breaks.list({
@@ -967,12 +981,10 @@ var AttendanceCorrectionService = class {
 				limit: 1
 			});
 			if (!target) throw new AttendanceConflict("Break not found.");
-			const punch = await this.closedPunch(tx, subject, target.punchId);
+			if (!target.endedAt) throw new AttendanceConflict("The open break is ended through AttendanceService.");
+			const punch = await this.anyPunch(tx, subject, target.punchId);
 			const children = await this.children(tx, punch);
-			await this.guard(tx, subject, [{
-				startsAt: punch.startedAt,
-				endsAt: punch.endedAt
-			}]);
+			await this.guard(tx, subject, [this.span(punch)]);
 			const entry = await this.editableEntry(tx, punch);
 			const before = breakState(target);
 			await deleteCorrection(target);
@@ -980,13 +992,14 @@ var AttendanceCorrectionService = class {
 			return record("break.removed", punch, target.id, before, null);
 		});
 	}
-	/** Add a work segment to a closed punch, or change one (times and/or work attribution). */
+	/** Add a closed work segment to a punch, or change one (times and/or work attribution). */
 	async saveSegment(input) {
 		return this.run(input, async (tx, subject, record) => {
-			const punch = await this.closedPunch(tx, subject, input.punchId);
+			const punch = await this.anyPunch(tx, subject, input.punchId);
 			const children = await this.children(tx, punch);
 			const existing = input.segmentId ? children.segments.find((s) => s.id === input.segmentId) : void 0;
 			if (input.segmentId && !existing) throw new AttendanceConflict("Work segment not found in that punch.");
+			if (existing && !existing.endedAt) throw new AttendanceConflict("The open work segment is changed through AttendanceService.");
 			if (!existing && (input.startedAt === void 0 || input.endedAt === void 0 || !input.work)) throw new AttendanceConflict("A new work segment needs startedAt, endedAt and work.");
 			if (input.work) validateAttendanceWork(input.work);
 			const next = {
@@ -998,10 +1011,7 @@ var AttendanceCorrectionService = class {
 				breaks: children.breaks,
 				segments: [...rest, next]
 			}));
-			await this.guard(tx, subject, [{
-				startsAt: punch.startedAt,
-				endsAt: punch.endedAt
-			}]);
+			await this.guard(tx, subject, [this.span(punch)]);
 			const before = existing ? segmentState(existing) : null;
 			let target;
 			if (existing) {
@@ -1019,6 +1029,7 @@ var AttendanceCorrectionService = class {
 				Object.assign(target, {
 					tenantId: subject.tenantId,
 					punchId: punch.id ?? void 0,
+					profileId: punch.profileId,
 					workRefType: input.work.workRefType,
 					workRefId: input.work.workRefId,
 					taskRefType: input.work.taskRefType ?? "",
@@ -1033,7 +1044,7 @@ var AttendanceCorrectionService = class {
 			return record(existing ? "segment.changed" : "segment.added", punch, target.id, before, segmentState(target));
 		});
 	}
-	/** Remove a work segment from a closed punch. */
+	/** Remove a closed work segment from a punch. */
 	async removeSegment(input) {
 		return this.run(input, async (tx, subject, record) => {
 			const [target] = await tx.segments.list({
@@ -1044,11 +1055,9 @@ var AttendanceCorrectionService = class {
 				limit: 1
 			});
 			if (!target) throw new AttendanceConflict("Work segment not found.");
-			const punch = await this.closedPunch(tx, subject, target.punchId);
-			await this.guard(tx, subject, [{
-				startsAt: punch.startedAt,
-				endsAt: punch.endedAt
-			}]);
+			if (!target.endedAt) throw new AttendanceConflict("The open work segment is stopped through AttendanceService.");
+			const punch = await this.anyPunch(tx, subject, target.punchId);
+			await this.guard(tx, subject, [this.span(punch)]);
 			const before = segmentState(target);
 			await deleteCorrection(target);
 			return record("segment.removed", punch, target.id, before, null);
@@ -1099,6 +1108,148 @@ var AttendanceCorrectionService = class {
 			orderBy: "created_at ASC"
 		})).filter((row) => row.acknowledgementRequired && !row.acknowledgedAt));
 	}
+	/** The range a correction touches, for period-lock checks: an open punch runs to now. */
+	span(punch) {
+		const now = /* @__PURE__ */ new Date();
+		return {
+			startsAt: punch.startedAt,
+			endsAt: punch.endedAt ?? (now > punch.startedAt ? now : punch.startedAt)
+		};
+	}
+	async openPunchOf(tx, subject) {
+		return (await tx.punches.list({
+			where: {
+				tenantId: subject.tenantId,
+				profileId: subject.profileId,
+				endedAt: null
+			},
+			limit: 1
+		})).length > 0;
+	}
+	async correctOpenStart(tx, subject, record, punch, input, before) {
+		if (input.endedAt !== void 0) throw new AttendanceConflict("An open punch cannot be closed by a correction; use AttendanceService.");
+		if (input.startedAt === void 0) throw new AttendanceConflict("An open punch is corrected by startedAt.");
+		const startedAt = instant(input.startedAt, "startedAt");
+		const children = await this.children(tx, punch);
+		validateLayout(this.layout(startedAt, null, children));
+		for (const other of await tx.punches.list({ where: {
+			tenantId: subject.tenantId,
+			profileId: subject.profileId
+		} })) if (other.id !== punch.id && overlapping({
+			start: startedAt.getTime(),
+			end: FOREVER.getTime()
+		}, {
+			start: other.startedAt.getTime(),
+			end: other.endedAt?.getTime() ?? FOREVER.getTime()
+		})) throw new AttendanceConflict("Punches must not overlap.");
+		const earliest = punch.startedAt < startedAt ? punch.startedAt : startedAt;
+		await this.guard(tx, subject, [{
+			startsAt: earliest,
+			endsAt: this.span(punch).endsAt
+		}]);
+		punch.startedAt = startedAt;
+		punch.reviewRequired = false;
+		await this.settle(tx, punch, children.breaks, null);
+		return record("punch.corrected", punch, punch.id, before, punchState(punch));
+	}
+	async addOpenPunch(input) {
+		return this.run(input, async (tx, subject, record) => {
+			const startedAt = instant(input.startedAt, "startedAt");
+			const meta = attendanceProvenance(input);
+			if (input.endedAt !== void 0) throw new AttendanceConflict("An open punch has no endedAt.");
+			if (await this.openPunchOf(tx, subject)) throw new AttendanceConflict("A punch is already open.", "punch_open");
+			const breaks = (input.breaks ?? []).map((b) => ({
+				startedAt: instant(b.startedAt, "startedAt"),
+				endedAt: instant(b.endedAt, "endedAt"),
+				paid: b.paid ?? false,
+				kind: attendanceLabel(b.kind, "kind")
+			}));
+			for (const b of input.breaks ?? []) if (b.paid !== void 0 && typeof b.paid !== "boolean") throw new AttendanceConflict("paid must be boolean.");
+			const segments = (input.segments ?? []).map((g) => {
+				validateAttendanceWork(g.work);
+				return {
+					startedAt: instant(g.startedAt, "startedAt"),
+					endedAt: instant(g.endedAt, "endedAt"),
+					work: g.work
+				};
+			});
+			validateLayout({
+				startsAt: startedAt.getTime(),
+				endsAt: FOREVER.getTime(),
+				breaks,
+				segments
+			});
+			for (const other of await tx.punches.list({ where: {
+				tenantId: subject.tenantId,
+				profileId: subject.profileId
+			} })) if (overlapping({
+				start: startedAt.getTime(),
+				end: FOREVER.getTime()
+			}, {
+				start: other.startedAt.getTime(),
+				end: other.endedAt?.getTime() ?? FOREVER.getTime()
+			})) throw new AttendanceConflict("Punches must not overlap.");
+			const now = /* @__PURE__ */ new Date();
+			await this.guard(tx, subject, [{
+				startsAt: startedAt,
+				endsAt: now > startedAt ? now : startedAt
+			}]);
+			const punch = await tx.punches.create({
+				tenantId: subject.tenantId,
+				profileId: subject.profileId,
+				startedAt,
+				...meta,
+				_insertOnly: true
+			});
+			for (const b of breaks) {
+				const row = await new AttendanceBreak({
+					db: tx.db,
+					id: crypto.randomUUID(),
+					_skipLoad: true
+				}).initialize();
+				Object.assign(row, {
+					tenantId: subject.tenantId,
+					punchId: punch.id ?? void 0,
+					...b
+				});
+				await persistCorrection(row);
+			}
+			const segmentStates = [];
+			for (const g of segments) {
+				const row = await new AttendanceSegment({
+					db: tx.db,
+					id: crypto.randomUUID(),
+					_skipLoad: true
+				}).initialize();
+				Object.assign(row, {
+					tenantId: subject.tenantId,
+					punchId: punch.id ?? void 0,
+					profileId: punch.profileId,
+					workRefType: g.work.workRefType,
+					workRefId: g.work.workRefId,
+					taskRefType: g.work.taskRefType ?? "",
+					taskRefId: g.work.taskRefId ?? "",
+					kind: g.work.kind ?? "",
+					description: g.work.description,
+					startedAt: g.startedAt,
+					endedAt: g.endedAt,
+					closedReason: "stop"
+				});
+				await persistCorrection(row);
+				segmentStates.push(segmentState(row));
+			}
+			return record("punch.added", punch, punch.id, null, {
+				...punchState(punch),
+				...breaks.length ? { breaks: breaks.map((b) => ({
+					startedAt: iso(b.startedAt),
+					endedAt: iso(b.endedAt),
+					paid: b.paid,
+					...b.kind ? { kind: b.kind } : {}
+				})) } : {},
+				...segmentStates.length ? { segments: segmentStates } : {}
+			});
+		});
+	}
 	attendance(subjectProfileId) {
 		return new AttendanceService(this.db, {
 			tenantId: this.actor.tenantId,
@@ -1153,7 +1304,7 @@ var AttendanceCorrectionService = class {
 		});
 		return this.read(id);
 	}
-	async closedPunch(tx, subject, punchId) {
+	async anyPunch(tx, subject, punchId) {
 		const [punch] = await tx.punches.list({
 			where: {
 				tenantId: subject.tenantId,
@@ -1163,7 +1314,6 @@ var AttendanceCorrectionService = class {
 			limit: 1
 		});
 		if (!punch) throw new AttendanceConflict("Punch not found for subject.");
-		if (!punch.endedAt) throw new AttendanceConflict("Only closed punches are corrected; use AttendanceService for an open one.");
 		return punch;
 	}
 	async children(tx, punch) {
@@ -1179,7 +1329,7 @@ var AttendanceCorrectionService = class {
 			where,
 			orderBy: "started_at ASC"
 		});
-		if (breaks.some((b) => !b.endedAt) || segments.some((s) => !s.endedAt)) throw new AttendanceConflict("Closed punch has an open break or segment.");
+		if (punch.endedAt && (breaks.some((b) => !b.endedAt) || segments.some((s) => !s.endedAt))) throw new AttendanceConflict("Closed punch has an open break or segment.");
 		return {
 			breaks,
 			segments
@@ -1188,15 +1338,15 @@ var AttendanceCorrectionService = class {
 	layout(startedAt, endedAt, children) {
 		return {
 			startsAt: startedAt.getTime(),
-			endsAt: endedAt.getTime(),
+			endsAt: endedAt ? endedAt.getTime() : FOREVER.getTime(),
 			breaks: children.breaks.map((b) => ({
 				startedAt: b.startedAt,
-				endedAt: b.endedAt,
+				endedAt: b.endedAt ?? FOREVER,
 				paid: b.paid
 			})),
 			segments: children.segments.map((s) => ({
 				startedAt: s.startedAt,
-				endedAt: s.endedAt
+				endedAt: s.endedAt ?? FOREVER
 			}))
 		};
 	}
@@ -1228,6 +1378,10 @@ var AttendanceCorrectionService = class {
 	}
 	/** Recompute the punch's durations from its breaks and persist it and its draft entry. */
 	async settle(tx, punch, breaks, entry) {
+		if (!punch.endedAt) {
+			await persistCorrection(punch);
+			return;
+		}
 		const unpaidMs = breaks.filter((b) => !b.paid).reduce((sum, b) => sum + b.endedAt.getTime() - b.startedAt.getTime(), 0);
 		punch.unpaidBreakSeconds = Math.round(unpaidMs / 1e3);
 		punch.durationSeconds = Math.round((punch.endedAt.getTime() - punch.startedAt.getTime() - unpaidMs) / 1e3);
@@ -1243,4 +1397,4 @@ var AttendanceCorrectionService = class {
 //#endregion
 export { continueSegment as a, openSegment as c, validateAttendanceWork as d, ATTENDANCE_CORRECTION_KINDS as f, closeOpenSegment as i, replaceSegment as l, AttendanceCorrectionCollection as m, AttendanceService as n, endSegment as o, AttendanceCorrection as p, beginSegment as r, listSegments as s, AttendanceCorrectionService as t, AttendanceConflict as u };
 
-//# sourceMappingURL=attendance-Cmk-6dTV.js.map
+//# sourceMappingURL=attendance-UY7sTXFx.js.map