@wildo-ai/saas-backend-lib 1.1.2 → 1.1.4

package/dist/esm/security/authentications/services/anonymous-session.backend.service.d.ts

@@ -16,12 +16,40 @@ import type { RateLimitBackendService } from '../../../errors/services/rate-limi
 import type { Request, Response } from 'express';
 export interface TranspositionResult {
     transposedTypes: ResourceType[];
+    /**
+     * Resource types whose anonymous rows were DELETED because the resource declares
+     * `ResourceTranspositionPolicy.DISCARD` — the conversion's other terminal outcome.
+     *
+     * A separate bucket rather than a second meaning for `transposedTypes`: "the account now owns
+     * these rows" and "these rows no longer exist" are opposite facts about the visitor's data, and a
+     * log line or a support answer built from the merged list would be wrong for half its members.
+     * Both nonetheless count as PROGRESS for the status arithmetic — see {@link
+     * AnonymousSessionBackendService.transposeOwnership}.
+     */
+    discardedTypes: ResourceType[];
     failedTypes: {
         resourceType: ResourceType;
         error: string;
     }[];
     status: AnonymousUserTranspositionStatus;
 }
+/**
+ * What one pass of {@link AnonymousSessionBackendService.reconcileIncompleteTranspositions} did.
+ *
+ * `sessionsRepaired` counts sessions this pass MOVED something for OR whose stamp it corrected;
+ * `sessionsStillIncomplete` counts sessions that still have rows the account cannot see after the
+ * pass — the population a human should look at, because a repeatedly-failing type is a defect, not
+ * a transient.
+ */
+export interface TranspositionReconciliationResult {
+    candidatesExamined: number;
+    sessionsRepaired: number;
+    sessionsStillIncomplete: number;
+    resourceTypesTransposed: number;
+    /** Resource types whose leftover anonymous rows this pass DELETED under a `DISCARD` policy. */
+    resourceTypesDiscarded: number;
+    errors: number;
+}
 export declare class AnonymousSessionBackendService {
     private readonly logger;
     private readonly errorBuilder;
@@ -143,6 +171,135 @@ export declare class AnonymousSessionBackendService {
      * If the userType does not support anonymous sessions, returns an empty result.
      */
     transposeOwnership(anonymousUserId: string, authenticatedUserId: string, userType: string): Promise<TranspositionResult>;
+    /**
+     * Move every still-anonymous row this session owns onto the authenticated user, one resource type
+     * at a time. Shared by the CONVERSION pass ({@link transposeOwnership}) and the RECONCILIATION
+     * pass ({@link reconcileIncompleteTranspositions}) so the two can never drift into two different
+     * notions of what a transposition is.
+     *
+     * ### The idempotency contract, and why it is STRUCTURAL rather than a flag
+     * Every read goes through {@link listAnonymousRecords}, which filters `{ anonymousUserId, userId:
+     * null }`. The write flips a row to `{ userId: <account>, anonymousUserId: null }`. So a row that
+     * has already moved is invisible to every subsequent pass, per resource type, with no bookkeeping
+     * anywhere: re-running this method can only ever act on rows that genuinely have not moved yet.
+     *
+     * That is deliberate. A "which types have I already done?" marker on the AnonymousUser row would
+     * be a second ledger next to the data it describes, and it would be written by exactly the
+     * best-effort write whose failure created the split in the first place. The data answers the
+     * question; nothing else needs to.
+     *
+     * ### Why a per-type failure is still SWALLOWED here
+     * One resource type failing must not lose the others — a visitor whose draft notes move but whose
+     * lead capture does not is strictly better off than one where neither moved because the first
+     * throw aborted the loop. That reasoning was always sound. What was missing is what happens
+     * NEXT, and that is now {@link reconcileIncompleteTranspositions} rather than a status stamp
+     * nobody reads.
+     *
+     * @param applyReplacePolicy honour `ResourceTranspositionPolicy.REPLACE` (delete the account's
+     *   existing rows of that type before moving the anonymous ones). TRUE only on the conversion
+     *   pass. On a reconciliation pass it MUST be false: REPLACE expresses "the anonymous draft wins
+     *   over whatever the account had AT THE MOMENT OF CONVERSION", and re-applying it hours or days
+     *   later would delete rows the user authored *after* converting — turning a repair into data
+     *   loss, which is far worse than the residual it would fix.
+     *
+     *   The residual, stated plainly: if the REPLACE delete itself failed at conversion time, the
+     *   reconciliation moves the anonymous rows in ADD fashion, so the account ends up holding both
+     *   sets. That is visible, non-destructive and recoverable by the user; the alternative is not.
+     *   Rejected alternative: record "REPLACE was applied for type T" durably and let the reconcile
+     *   consult it — that is precisely the second ledger this design refuses, and it would be written
+     *   by the same fallible pass.
+     *
+     * ### DISCARD DELETES, and it deletes on BOTH passes — unlike REPLACE
+     * `DISCARD` used to `continue` past the type entirely, which left its rows carrying
+     * `{ anonymousUserId, userId: null }` FOREVER: the conversion had already set `convertedToUserId`,
+     * so the cleanup batch's phase 1 (`{ convertedToUserId: null }`) could no longer see the session,
+     * and phase 2 deletes only the `ANONYMOUS_USERS` anchor row. After the retention window the anchor
+     * was gone and the rows remained, pointing at an identity that no longer exists — an orphan with a
+     * dangling foreign key, and no population definition by which any later sweep could find it.
+     *
+     * So the delete happens HERE, at conversion time, where the anchor still exists and the population
+     * is exactly "the rows this list just returned". The rejected alternative was a later sweep, which
+     * would have to recognise the same rows AFTER phase 2 removed the only thing that names them —
+     * a recognition problem that deleting at conversion makes unnecessary.
+     *
+     * It is deliberately NOT gated on `applyReplacePolicy`, and the asymmetry with REPLACE is the
+     * whole reason that flag exists in the first place. REPLACE deletes the ACCOUNT's rows, so
+     * re-applying it later destroys work the user did after converting. DISCARD deletes the ANONYMOUS
+     * rows — rows the account has never been able to see and that the resource declared it never wants
+     * carried over. Deleting them a day late is the same act, not a destructive one, so a
+     * reconciliation pass may and must finish a DISCARD the conversion could not.
+     *
+     * A DISCARD failure is recorded in `failedTypes` and the loop continues — the same treatment as
+     * every other per-type failure, and for the stronger reason: this runs inside a live conversion,
+     * and a conversion that half-runs (the user cannot complete sign-in) is worse than a row that
+     * survives until the next reconciliation pass, which will retry it before phase 2 can retire the
+     * anchor.
+     */
+    private applyOwnershipTransposition;
+    /**
+     * Write the conversion outcome onto the AnonymousUser row: `convertedToUserId` (WHICH account the
+     * session became) and `transpositionStatus` (how far the move got).
+     *
+     * ### This write REFUSES. It is the one step here that may not be best effort.
+     * Every other failure in a transposition is survivable because the DATA still says what happened:
+     * a row that moved carries the account's `userId`, a row that did not still carries the
+     * `anonymousUserId`. `convertedToUserId` is different — it is the ONLY place the anon→account
+     * mapping is ever recorded. Lose it and no later pass can know which account the leftover rows
+     * were supposed to reach, so a recoverable partial becomes permanent.
+     *
+     * It is not merely unrecoverable, it is actively destructive: `cleanupExpiredSessions` selects
+     * `{ convertedToUserId: null, createdAt < 48h }` and DELETES that session's remaining anonymous
+     * rows. So a swallowed failure here schedules the visitor's un-moved rows for deletion two days
+     * later, silently — the exact "record that it stopped and never revisit it" shape this method now
+     * refuses to produce.
+     *
+     * Throwing costs the caller nothing it was relying on. Both triggers
+     * (`handleAnonymousTransposition` / `...ForTokenExchange` in the authentication controller) already
+     * wrap the call in a non-blocking catch, so the authentication response is unaffected — and
+     * because their `clearSessionCookie` sits AFTER the call, a throw also KEEPS the continuity cookie,
+     * which is precisely the retry channel: the next login presents the same session handle and the
+     * whole transposition runs again, idempotently (see `applyOwnershipTransposition`).
+     *
+     * Deliberately NOT routed through `updateAsSystem` (unlike the ownership transposition writes).
+     * `convertedToUserId` and `transpositionStatus` are ordinary fields — neither `.isBackendOnly()`
+     * nor context-auto-populated FK names — so they survive the strict-DTO parse; there is nothing for
+     * the primitive to re-attach. Migrating would only add a fail-closed opt-in and an audit row for
+     * no correctness gain, so the plain internal-EC handler stays. (ANONYMOUS_USERS opts into
+     * `systemAccessPolicy.create` only.)
+     */
+    private recordTranspositionOutcome;
+    /**
+     * Finish the transpositions that stopped part-way, instead of leaving the stamp that says they
+     * did. Runs as phase 0 of the anonymous-session cleanup batch — before the deletion phases, which
+     * is the whole point: the batch that would otherwise walk past these rows repairs them first.
+     *
+     * ### What it is looking for
+     * A converted session whose data is still SPLIT: some rows on the account, some still carrying
+     * `{ anonymousUserId, userId: null }` because a resource type threw during the conversion pass.
+     * The account cannot see those rows, and nothing was ever going to come back for them.
+     *
+     * ### Why the candidate query keys on the stamp but the REPAIR keys on the data
+     * The stamp is a cheap INDEX into the population, not the authority. `{ convertedToUserId != null,
+     * transpositionStatus != COMPLETE }` is a superset of the genuinely-split sessions: after the
+     * conversion pass, `convertedToUserId` and `transpositionStatus` are written by ONE update, so a
+     * row that names an account always carries a stamp, and a stamp that is not COMPLETE means at
+     * least one type failed at that time. What the stamp cannot tell us is whether the split is
+     * STILL there — a transient repository error may since have cleared, and (before this method
+     * existed) a fully-successful move could be left stamped PENDING by a status write that failed on
+     * its own. So the stamp only selects who to LOOK at; `applyOwnershipTransposition` reads the rows
+     * and decides. A session that turns out to be whole gets its stamp corrected to COMPLETE, which
+     * is how the stamp-only split heals and how the candidate set stays small.
+     *
+     * ### The population this can NEVER repair, stated so nobody looks for it
+     * A session whose conversion-time status write failed BEFORE this change has `convertedToUserId:
+     * null`, and the account it converted into was never written down anywhere. It is indistinguishable
+     * from a visitor who never signed up, and its leftover rows were deleted by the 48h cleanup. There
+     * is no backfill for those; {@link recordTranspositionOutcome} refusing is what stops new ones.
+     */
+    reconcileIncompleteTranspositions(options?: {
+        batchSize?: number;
+        maxIterations?: number;
+    }): Promise<TranspositionReconciliationResult>;
     /**
      * Transpose ownership of `INBOUND_CONTACTS` rows owned by the given
      * anonymous user to the now-authenticated user (Phase 0.5, Q-E=B).
@@ -195,6 +352,45 @@ export declare class AnonymousSessionBackendService {
      */
     private listAnonymousRecords;
     private reassignOwnership;
+    /**
+     * Delete a known id set of a resource's rows, as the internal super-admin.
+     *
+     * THE single delete primitive of this service: the `DISCARD` transposition arm, the `REPLACE`
+     * pre-delete and the expired-session cleanup all route through it, so "how does this service
+     * delete rows it owns" has one answer and one place to fix.
+     *
+     * ### It resolves the operation it can actually serve, and that is not decoration
+     * `isAnonymizable` is NOW validated at config time to require a SERVICE-RESOLVABLE delete — either
+     * `DELETE_MANY` or `DELETE`, a disjunction chosen to mirror exactly what this method probes for, so
+     * the guard and the resolver cannot disagree. That was NOT true when this method was written: the
+     * factory then required only LIST and UPDATE_MANY, the two ADD needs, and said nothing about
+     * deletion at all. Measured 2026-09-09: `draftNotes`, the only
+     * `isAnonymizable` resource in this repository, declares `DELETE` and not `DELETE_MANY`. So the
+     * previous unconditional `getServiceOperationPathDefault(resourceType, DELETE_MANY)` threw
+     * `RESOURCES_REGISTRY_OPERATION_PATH_NOT_FOUND` for it — which means the cleanup batch's phase 1
+     * has never been able to delete an expired anonymous draft note: the per-session catch counted an
+     * error, the `ANONYMOUS_USERS` row was never removed, and the same session was retried on every
+     * run forever. A DISCARD sweep built on the same unconditional call would have shipped equally
+     * dead.
+     *
+     * The boot guard now refuses that configuration, so the fallback below is no longer the only thing
+     * standing between an anonymizable resource and a cleanup that cannot run. Keep BOTH: the guard
+     * decides what may be DECLARED, this decides which of the two declared shapes to CALL.
+     *
+     * So: prefer `DELETE_MANY` when the resource declares a SERVICE-RESOLVABLE default for it, and
+     * fall back to per-row `DELETE` otherwise. The probe is
+     * {@link isServiceResolvableDefaultOperation} — the very predicate
+     * `getServiceOperationPathDefault` admits on — so the probe and the resolver cannot disagree
+     * (`try/catch` around the throwing resolver would also have "worked" and would have swallowed a
+     * genuine registry corruption as a fallback). If NEITHER resolves, the `DELETE` lookup throws and
+     * names the resource and the operation, which is the right outcome: a resource that can be
+     * created anonymously and can never be deleted is a configuration defect, not a case to swallow.
+     *
+     * Per-row DELETE is the same trade `transposeInboundContactsOwnership` already documents: one
+     * anonymous session owns a handful of rows, so the round trips are cheap, and requiring an
+     * application to publish a bulk-delete surface it does not want is the worse price.
+     */
+    private deleteOwnedRecords;
     private deleteExistingUserRecords;
     /**
      * Cleanup expired, unconverted anonymous sessions and their owned resources.
@@ -211,6 +407,7 @@ export declare class AnonymousSessionBackendService {
         usersArchived: number;
         convertedUsersCleaned: number;
         errors: number;
+        transpositionsReconciled: TranspositionReconciliationResult;
     }>;
     private getAnonymizableResourceTypes;
     private hashIp;

package/dist/esm/security/authentications/services/anonymous-session.backend.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anonymous-session.backend.service.d.ts","sourceRoot":"","sources":["../../../../../../src/security/authentications/services/anonymous-session.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,EAAE,uBAAuB,EAAE,MAAM,sEAAsE,CAAC;AAC/G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAElG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kEAAkE,CAAC;AACnH,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,6FAA6F,CAAC;AACzJ,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iFAAiF,CAAC;AAClI,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAChI,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,+EAA+E,CAAC;AAC3I,OAAO,EAKL,gCAAgC,EAUhC,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+DAA+D,CAAC;AAG7G,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEjD,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,YAAY,EAAE,CAAC;IAChC,WAAW,EAAE;QAAE,YAAY,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7D,MAAM,EAAE,gCAAgC,CAAC;CAC1C;AAED,qBACa,8BAA8B;IAKJ,OAAO,CAAC,QAAQ,CAAC,MAAM;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;IAChC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAChB,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IACpB,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACtD,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IASrC,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAlBtF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+D;gBAGlC,MAAM,EAAE,aAAa,EACR,YAAY,EAAE,0BAA0B,EAC3C,aAAa,EAAE,uBAAuB,EACxB,uBAAuB,EAAE,qCAAqC,EACrE,iBAAiB,EAAE,+BAA+B,EACpC,uBAAuB,EAAE,qCAAqC,EAC5E,gBAAgB,EAAE,uBAAuB,EAS7C,mBAAmB,EAAE,0BAA0B;IAKlH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,mBAAmB,CAAC,eAAe,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IA8D9F;;;;;;;OAOG;IACH,gBAAgB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM;IASjD;;;;;;;OAOG;IACH,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;IA2B9D;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,+BAA+B,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA+B7E;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAUpD;;;;;;;OAOG;IACH,kBAAkB,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;IAQvC;;;;;;;OAOG;IACG,kBAAkB,CACtB,eAAe,EAAE,MAAM,EACvB,mBAAmB,EAAE,MAAM,EAC3B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,mBAAmB,CAAC;IA4H/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;YACW,iCAAiC;IA8B/C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;YACW,oBAAoB;YAiBpB,iBAAiB;YAcjB,yBAAyB;IAuBvC;;;OAGG;IACG,sBAAsB,CAAC,OAAO,CAAC,EAAE;QACrC,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,oBAAoB,CAAC,EAAE,MAAM,CAAC;KAC/B,GAAG,OAAO,CAAC;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,qBAAqB,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IA4I1I,OAAO,CAAC,4BAA4B;IAYpC,OAAO,CAAC,MAAM;IAId;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,kCAAkC;CA2C3C"}
+{"version":3,"file":"anonymous-session.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/security/authentications/services/anonymous-session.backend.service.ts"],"names":[],"mappings":"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"}