@kernhq/module-hr 0.16.0 → 0.17.0

package/dist/server/services/privacy.d.ts

@@ -0,0 +1,514 @@
+import { type Tx } from '@kernhq/kernel';
+import type { ErasureCaveat, ErasureRedaction, ErasureRetained, HrRetention, RetentionClass } from '../../contract/index.js';
+/**
+ * Subject access, erasure and retention.
+ *
+ * The whole file rests on one decision, and the rest follows from it: **erasure here is redaction,
+ * never deletion.** Three of this module's tables say why in their own comments — the ledger is
+ * append-only because a balance is the sum of it and nothing else, punches are append-only because
+ * an attendance record somebody can quietly rewrite is worth nothing in the dispute it exists for,
+ * and `employments` is effective-dated so that March is still answerable in June. Deleting an erased
+ * person's rows breaks all three at once, and answers a payroll audit with "she left, so we deleted
+ * her file". So every step below clears columns and leaves rows, and the report says which rows
+ * survived and on what basis.
+ *
+ * Two properties are load-bearing and both come out of how the predicates are written:
+ *
+ * - **Replayable.** Every step matches only rows that still have something to clear, so a second run
+ *   updates nothing and reports zero. A half-finished erasure is therefore finished by running it
+ *   again, which matters because the only alternative to a resumable erasure is a refused one.
+ * - **Previewable.** A step is a predicate plus a `set`; the dry run counts the predicate and the
+ *   real run counts it and then applies the set. The preview cannot drift from the thing it previews
+ *   because there is only one predicate, in one place — the same reason `accrual.preview` runs the
+ *   code the run runs.
+ */
+/**
+ * The pseudonym an erased person is shown under.
+ *
+ * `display_name` is `not null` and the contract's `Person.displayName` is `min(1)`, so there is no
+ * "no name" to write: something has to go in the column and it must not be a name. The employee
+ * number is the right thing when there is one — it is already a pseudonym, it is the join key a
+ * payslip carries, and it survives erasure for exactly that reason. Otherwise the front of the row's
+ * own uuid, which identifies the record without identifying the person.
+ *
+ * Not a localised label like "Erased employee": the database is not the place for a language, and a
+ * client that knows the row is a tombstone can render one. Knowing that needs `erasedAt` on the
+ * `Person` contract, which is a change to `models.ts`, `toPerson` and the client mock together.
+ */
+export declare const erasureDisplayName: (person: {
+    id: string;
+    employeeNo: string | null;
+}) => string;
+/**
+ * `person_history` fields whose recorded values are personal data.
+ *
+ * The trap this list exists for: `person_history` stores `from_value`/`to_value` as jsonb for every
+ * field, so a redacted `people` row sits beside a history row saying `personalEmail: null → "…"`.
+ * Redacting the record and leaving the trail is theatre.
+ *
+ * What is *not* here is as deliberate. `hiredOn`, `terminatedOn`, `status` and every employment
+ * field stay with their values, because those are the employment facts the erasure keeps on `people`
+ * and `employments` anyway — clearing their history while keeping the current value would leave the
+ * record self-contradictory for no gain. And `sensitive` rows already store only key names, never
+ * values (`sensitive.update` has always written it that way), so there is nothing in them to clear.
+ */
+export declare const REDACTED_HISTORY_FIELDS: readonly ["displayName", "workEmail", "personalEmail", "phone", "photoFileId", "timezone", "custom"];
+/** `custom.dietary` is as personal as `custom` itself; the writer records either spelling. */
+export declare const isRedactableHistoryField: (field: string) => boolean;
+/**
+ * Replace every occurrence of a person's name inside a JSON value.
+ *
+ * `approval_requests.chain` is a snapshot of the workflow as it stood when the request was raised,
+ * and a step in it can be named after the person it is about. Nulling the column is not an option —
+ * it is `not null` and it is the record of who had to sign — so the names come out and the structure
+ * stays.
+ *
+ * Substring rather than equality: a step called "Approval for Ayşe Demir" carries the name as much
+ * as one called "Ayşe Demir" does. Case-insensitive, and needles shorter than three characters are
+ * ignored, because a one-letter name would blank every string in the document.
+ *
+ * Reports whether anything changed, so the caller can skip the write — which is what makes an
+ * erasure replay report zero rows for this class rather than rewriting identical jsonb.
+ */
+export declare function scrubNames(value: unknown, needles: readonly string[], token: string): {
+    value: unknown;
+    changed: boolean;
+};
+/**
+ * Drop the `custom` values whose field definition is marked sensitive.
+ *
+ * A defect that predates this feature and lands in the middle of it: `custom_field_defs.sensitive`
+ * is declared, stored, editable and documented as "needs `hr.person.view_sensitive`, like a national
+ * identity number" — and nothing has ever read it. `toPerson` returns `custom` whole and `forViewer`
+ * nulls only the four personnel fields, so a field an administrator marked sensitive went to every
+ * holder of `hr.person.view`, which is a `member` default. That is the same failure as a permission
+ * key nothing asks about, one level down.
+ *
+ * Returns the object it was given when there is nothing to strip, so the common path — no sensitive
+ * fields defined, or a reader who holds the permission — allocates nothing.
+ */
+export declare function stripSensitiveCustom(custom: Record<string, unknown>, sensitiveKeys: ReadonlySet<string>): Record<string, unknown>;
+/** `YYYY-MM-DD`, `days` before `today`. The boundary a retention horizon is measured from. */
+export declare function retentionCutoff(days: number, today?: string): string;
+/** Every retention class, in the order a settings screen should show them. */
+export declare const RETENTION_CLASSES: readonly ["punchDetail", "punches", "attendanceDays", "leave", "personHistory", "personDocuments", "terminatedPeople", "sensitiveAccessLog"];
+/** Null everywhere: the shipped state, and the one this module refuses to guess a number for. */
+export declare const EMPTY_RETENTION: HrRetention;
+/**
+ * How many rows a subject-access section returns before it is cut.
+ *
+ * A cut is always named in `manifest.truncated` with its numbers — an export that silently omits is
+ * the same failure as an erasure that silently retains. The figures are sized off a five-year
+ * employee punching four times a day: about five thousand punches, eighteen hundred day sheets, two
+ * hundred and fifty ledger movements. Each cap is a few multiples of that, so a normal record is
+ * never cut and a pathological one does not take the process down with it.
+ */
+export declare const SECTION_CAPS: {
+    readonly employment: 500;
+    readonly offices: 500;
+    readonly history: 20000;
+    readonly documents: 1000;
+    readonly leaveRequests: 5000;
+    readonly leaveRequestDays: 20000;
+    readonly leaveLedger: 20000;
+    readonly punches: 40000;
+    readonly attendanceDays: 10000;
+    readonly regularizations: 2000;
+    readonly approvalsRaised: 2000;
+    readonly approverOn: 2000;
+    readonly decisions: 5000;
+    readonly delegations: 1000;
+    readonly accessLog: 5000;
+};
+export type BundleSection = keyof typeof SECTION_CAPS;
+export interface Truncation {
+    section: string;
+    returned: number;
+    cap: number;
+}
+export interface EraseOptions {
+    workspaceId: string;
+    personId: string;
+    dryRun: boolean;
+    reason: string | null;
+    keepNationalIdForAudit: boolean;
+    actorUserId: string | null;
+}
+export interface EraseResult {
+    erasedAt: Date | null;
+    displayName: string;
+    redacted: ErasureRedaction[];
+    kept: ErasureRetained[];
+    caveats: ErasureCaveat[];
+    filesRemaining: string[];
+}
+export declare class PrivacyService {
+    /** The stored horizons, defaulted. A workspace that has never set one gets nulls, not numbers. */
+    retention(tx: Tx, workspaceId: string): Promise<{
+        retention: HrRetention;
+        updatedAt: Date | null;
+        updatedBy: string | null;
+    }>;
+    /**
+     * Patch the horizons.
+     *
+     * A field left out is unchanged and a field sent as `null` goes back to "keep indefinitely", which
+     * is the same reading `core.settings.setModule` gives a partial write — a caller that has nothing
+     * to say about a class must not silently reset it.
+     */
+    setRetention(tx: Tx, workspaceId: string, patch: Partial<HrRetention>, actorUserId: string | null): Promise<{
+        retention: HrRetention;
+        updatedAt: Date | null;
+        updatedBy: string | null;
+    }>;
+    /**
+     * How much is already past each horizon — the dry run a retention screen shows before anything
+     * runs, and the only thing that reads these numbers today.
+     *
+     * Null for a class with no horizon set: there is nothing to be past. One query per class that has
+     * one, which is why the caller asks for this rather than getting it on every read.
+     *
+     * `attendanceDays` deliberately excludes locked days and `terminatedPeople` excludes anybody
+     * already erased, so the number is what a sweep *could* act on rather than what merely matches a
+     * date. A count that overstates is a count nobody trusts the second time they check it.
+     */
+    retentionCounts(tx: Tx, workspaceId: string, retention: HrRetention, today?: string): Promise<Record<RetentionClass, number | null>>;
+    /**
+     * Redact one person, or say what redacting them would do.
+     *
+     * Runs inside the caller's transaction, so the whole erasure commits or none of it does — a
+     * half-run erasure is worse than a refused one, and this is the only way to be sure there is no
+     * such state to be in.
+     */
+    erase(tx: Tx, opts: EraseOptions): Promise<EraseResult>;
+    private historyWhere;
+    private delegationWhere;
+    /**
+     * The approval requests this person raised: the English summary, the same sentence as data, and
+     * any name embedded in the snapshotted chain.
+     *
+     * Row by row rather than one `update`, because the chain is jsonb that has to be read to be
+     * scrubbed. The set is small — an approval request per leave request — and skipping rows that
+     * scrub to themselves is what keeps a replay at zero.
+     */
+    private redactApprovals;
+    /**
+     * Approver comments, on both paths.
+     *
+     * A comment is free text an approver wrote. On the subject's erasure it is somebody talking about
+     * the subject; on the approver's own erasure it is the approver's own speech. Both are personal
+     * data about the person being erased, so both are cleared — the decision itself, who made it and
+     * when, are the authorisation record and stay.
+     */
+    private redactDecisions;
+    /**
+     * The records that survive, counted, with the basis each survives under.
+     *
+     * `retentionHorizon` wins over the statutory reason wherever the workspace has actually set one:
+     * with a horizon in force, the horizon is the operative answer to "why is this still here", and
+     * the number the administrator typed is the thing they will recognise. Without one it falls back
+     * to what the record is — a wage, an entitlement, or an authorisation.
+     */
+    private keptClasses;
+    /**
+     * Every row HR holds about one person.
+     *
+     * Reads only — the sensitive decrypt and its access-log row are the caller's job, because that
+     * pairing lives in `PeopleService.readSensitive` and there must go on being exactly one place in
+     * this module that decrypts these columns.
+     *
+     * Each section fetches `cap + 1` rows so a cut is detectable without a second `count`, and every
+     * cut is reported. Nothing is dropped in silence.
+     */
+    subjectAccess(tx: Tx, workspaceId: string, personId: string): Promise<{
+        employment: {
+            id: string;
+            workspaceId: string;
+            personId: string;
+            effectiveFrom: string;
+            effectiveTo: string | null;
+            orgUnitId: string | null;
+            positionId: string | null;
+            legalEntityId: string | null;
+            costCenterId: string | null;
+            managerPersonId: string | null;
+            employmentType: string;
+            fte: string;
+            contractHoursWeek: string | null;
+            reason: string | null;
+            createdAt: Date;
+        }[];
+        offices: {
+            id: string;
+            workspaceId: string;
+            personId: string;
+            officeId: string;
+            isPrimary: boolean;
+            effectiveFrom: string;
+            effectiveTo: string | null;
+            reason: string | null;
+            createdAt: Date;
+        }[];
+        history: {
+            id: string;
+            workspaceId: string;
+            personId: string;
+            field: string;
+            from: unknown;
+            to: unknown;
+            at: Date;
+            actorId: string | null;
+            source: string;
+        }[];
+        documents: {
+            id: string;
+            workspaceId: string;
+            personId: string;
+            fileId: string;
+            name: string;
+            kind: string;
+            issuedOn: string | null;
+            expiresOn: string | null;
+            uploadedBy: string | null;
+            createdAt: Date;
+        }[];
+        leave: {
+            types: {
+                id: string;
+                workspaceId: string;
+                key: string;
+                name: string;
+                paid: boolean;
+                unit: string;
+                color: string | null;
+                icon: string | null;
+                requiresDocumentAfterDays: number | null;
+                countsWorkingDaysOnly: boolean;
+                allowNegative: boolean;
+                maxNegativeMinutes: number;
+                order: number;
+                archivedAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+            }[];
+            requests: {
+                id: string;
+                workspaceId: string;
+                personId: string;
+                leaveTypeId: string;
+                startsOn: string;
+                endsOn: string;
+                startPart: string;
+                endPart: string;
+                hours: string | null;
+                workingDays: string;
+                minutes: number;
+                status: string;
+                reason: string | null;
+                documentFileId: string | null;
+                approvalRequestId: string | null;
+                idempotencyKey: string | null;
+                decidedAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+            }[];
+            days: {
+                id: string;
+                workspaceId: string;
+                requestId: string;
+                personId: string;
+                date: string;
+                fraction: string;
+                counted: boolean;
+                status: string;
+            }[];
+            ledger: {
+                id: string;
+                workspaceId: string;
+                personId: string;
+                leaveTypeId: string;
+                kind: string;
+                amountMinutes: number;
+                effectiveOn: string;
+                periodYear: number;
+                requestId: string | null;
+                reversesEntryId: string | null;
+                policyHash: string | null;
+                reason: string | null;
+                createdBy: string | null;
+                createdAt: Date;
+            }[];
+        };
+        attendance: {
+            punches: {
+                id: string;
+                workspaceId: string;
+                personId: string;
+                direction: string;
+                at: Date;
+                clientReportedAt: Date | null;
+                skewMs: number | null;
+                businessDate: string;
+                timezone: string;
+                method: string;
+                officeId: string | null;
+                deviceId: string | null;
+                geo: Record<string, number> | null;
+                trust: string;
+                voidedByPunchId: string | null;
+                idempotencyKey: string | null;
+                note: string | null;
+                createdAt: Date;
+            }[];
+            days: {
+                id: string;
+                workspaceId: string;
+                personId: string;
+                businessDate: string;
+                scheduledMinutes: number;
+                workedMinutes: number;
+                breakMinutes: number;
+                overtimeMinutes: number;
+                beyondCapMinutes: number | null;
+                lateMinutes: number;
+                earlyLeaveMinutes: number;
+                status: string;
+                leaveRequestId: string | null;
+                anomalies: string[];
+                firstIn: Date | null;
+                lastOut: Date | null;
+                policyHash: string | null;
+                locked: boolean;
+                computedAt: Date;
+            }[];
+        };
+        regularizations: {
+            id: string;
+            workspaceId: string;
+            personId: string;
+            businessDate: string;
+            punchId: string | null;
+            proposed: Record<string, unknown>[];
+            reason: string;
+            status: string;
+            approvalRequestId: string | null;
+            appliedAt: Date | null;
+            createdAt: Date;
+        }[];
+        approvals: {
+            raised: {
+                id: string;
+                workspaceId: string;
+                subjectType: string;
+                subjectId: string;
+                summary: string;
+                summaryParams: Record<string, string | number> | null;
+                requesterPersonId: string | null;
+                chain: Record<string, unknown>;
+                status: string;
+                currentStep: number;
+                requestedBy: string | null;
+                requestedAt: Date;
+                decidedAt: Date | null;
+                version: number;
+            }[];
+            raisedSteps: {
+                id: string;
+                workspaceId: string;
+                requestId: string;
+                stepIndex: number;
+                name: string;
+                mode: string;
+                minApprovals: number;
+                approverIds: string[];
+                status: string;
+                dueAt: Date | null;
+                escalatedAt: Date | null;
+                onTimeout: string;
+                slaHours: number | null;
+                timeoutHandledAt: Date | null;
+                timeoutAction: string | null;
+            }[];
+            approverOn: {
+                id: string;
+                workspaceId: string;
+                requestId: string;
+                stepIndex: number;
+                name: string;
+                mode: string;
+                minApprovals: number;
+                approverIds: string[];
+                status: string;
+                dueAt: Date | null;
+                escalatedAt: Date | null;
+                onTimeout: string;
+                slaHours: number | null;
+                timeoutHandledAt: Date | null;
+                timeoutAction: string | null;
+            }[];
+            stepDecisions: {
+                id: string;
+                workspaceId: string;
+                stepId: string;
+                approverId: string;
+                onBehalfOfId: string | null;
+                decision: string;
+                comment: string | null;
+                source: string;
+                at: Date;
+            }[];
+            decisions: {
+                id: string;
+                workspaceId: string;
+                stepId: string;
+                approverId: string;
+                onBehalfOfId: string | null;
+                decision: string;
+                comment: string | null;
+                source: string;
+                at: Date;
+            }[];
+        };
+        delegations: {
+            given: {
+                id: string;
+                workspaceId: string;
+                fromPersonId: string;
+                toPersonId: string;
+                subjectType: string | null;
+                startsOn: string;
+                endsOn: string;
+                reason: string | null;
+                createdAt: Date;
+            }[];
+            received: {
+                id: string;
+                workspaceId: string;
+                fromPersonId: string;
+                toPersonId: string;
+                subjectType: string | null;
+                startsOn: string;
+                endsOn: string;
+                reason: string | null;
+                createdAt: Date;
+            }[];
+        };
+        accessLog: {
+            id: string;
+            workspaceId: string;
+            personId: string;
+            actorUserId: string;
+            actorPersonId: string | null;
+            fields: string[];
+            purpose: string | null;
+            via: string;
+            at: Date;
+        }[];
+        truncated: Truncation[];
+    }>;
+}
+/** The running total down an ordered ledger. "Why is my balance this number", answered in the file. */
+export declare const closingBalance: (ledger: ReadonlyArray<{
+    amountMinutes: number;
+}>) => number;
+//# sourceMappingURL=privacy.d.ts.map

package/dist/server/services/privacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy.d.ts","sourceRoot":"","sources":["../../../src/server/services/privacy.ts"],"names":[],"mappings":"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"}