@rapidmx/activesync-plugin 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/types/jobs/EasDeviceStateCleanupJob.d.ts

@@ -12,8 +12,12 @@ import { DeviceSyncState } from "../models/DeviceSyncState.js";
  */
 export declare abstract class EasDeviceStateCleanupJob<D extends DeviceSyncState> extends BackgroundService {
     protected abstract deviceSyncStateClass: any;
+    protected abstract collectionStateClass: any;
+    protected abstract collectionChunkClass: any;
     private _objectFactory?;
     private deviceSyncStateRepo?;
+    private collectionStateRepo?;
+    private collectionChunkRepo?;
     private scheduleExpr;
     private batchSize;
     private deviceTtlDays;
@@ -22,5 +26,16 @@ export declare abstract class EasDeviceStateCleanupJob<D extends DeviceSyncState
     init(): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void> | void;
+    /**
+     * The query value matching rows whose boolean flag isn't set (`false`, `null` or unset) - used for
+     * `remoteWipeRequested` and `blocked`. MongoDB's
+     * `$ne: true` already matches a missing/`null` field; `EasDeviceStateCleanupJobSQL` overrides this, since SQL's
+     * `!=` never matches `NULL`.
+     */
+    protected noPendingWipeQueryValue(): any;
     run(): Promise<void>;
+    /** Purges the device's per-collection `Sync` state rows (`EasCollectionState`) before the device row itself,
+     * so a forgotten device leaves nothing behind - deleted first, so a failure here leaves the device row in place
+     * for the next run to retry. */
+    private deleteCollectionStates;
 }

package/dist/types/jobs/mongo/EasDeviceStateCleanupJobMongo.d.ts

@@ -2,4 +2,6 @@ import { EasDeviceStateCleanupJob } from "../EasDeviceStateCleanupJob.js";
 import { DeviceSyncStateMongo } from "../../models/mongo/DeviceSyncStateMongo.js";
 export declare class EasDeviceStateCleanupJobMongo extends EasDeviceStateCleanupJob<DeviceSyncStateMongo> {
     protected deviceSyncStateClass: any;
+    protected collectionStateClass: any;
+    protected collectionChunkClass: any;
 }

package/dist/types/jobs/sql/EasDeviceStateCleanupJobSQL.d.ts

@@ -2,4 +2,8 @@ import { EasDeviceStateCleanupJob } from "../EasDeviceStateCleanupJob.js";
 import { DeviceSyncStateSQL } from "../../models/sql/DeviceSyncStateSQL.js";
 export declare class EasDeviceStateCleanupJobSQL extends EasDeviceStateCleanupJob<DeviceSyncStateSQL> {
     protected deviceSyncStateClass: any;
+    protected collectionStateClass: any;
+    protected collectionChunkClass: any;
+    /** SQL's `column != true` is never true for a `NULL` column, so "no pending wipe" needs an explicit `IS NULL`. */
+    protected noPendingWipeQueryValue(): any;
 }

package/dist/types/models/DeviceSyncState.d.ts

@@ -10,11 +10,14 @@ export interface DeviceSyncState extends BaseEntity {
     deviceType: string;
     /** The EAS provisioning policy key most recently acknowledged by the device. */
     policyKey?: string;
-    /** The per-folder EAS `SyncKey` cursor, keyed by `Folder.uid`. */
+    /** EAS `SyncKey` cursors kept on the device row - today only the folder hierarchy's (`FolderSync`, under the
+     * `"$foldersync"` key). `Sync` collections keep theirs in `EasCollectionState`; entries keyed by a `Folder.uid`
+     * are left over from before that and are no longer read. */
     folderSyncKeys: Record<string, string>;
     /** The EAS `Class` (`"Email"`, `"Contacts"`, ...) most recently synced for a folder, keyed by `Folder.uid` -
      * lets a `Sync` request omit `Class` after its first request for a collection, per [MS-ASCMD], without the
-     * server losing track of which entity type that collection holds. */
+     * server losing track of which entity type that collection holds. No longer read or written: superseded by
+     * `EasCollectionState.collectionClass`; kept so existing rows still load. */
     folderCollectionClasses: Record<string, string>;
     lastSyncAt?: Date;
     provisioned: boolean;
@@ -27,4 +30,12 @@ export interface DeviceSyncState extends BaseEntity {
     remoteWipeAccountOnly?: boolean;
     /** When the device most recently acknowledged a remote wipe request. */
     remoteWipeAcknowledgedAt?: Date;
+    /** `true` once the device has acknowledged a remote wipe: every further request carrying this row's `DeviceId`
+     * (including a fresh `Provision`) is refused until an administrator clears the flag
+     * (`BaseDeviceSyncStateRoute.unblock`), so a client can't acknowledge the wipe and then simply provision again under
+     * the same id. **The block is per `DeviceId`, not per physical device or credential**: `DeviceId` is chosen by the
+     * client, so a client that ignores the wipe and sends a different `DeviceId` with the same user's token pairs as a
+     * new device. Cutting a device off entirely means revoking the account's tokens/password, which this plugin
+     * doesn't do. */
+    blocked?: boolean;
 }

package/dist/types/models/EasCollectionChunk.d.ts

@@ -0,0 +1,20 @@
+import type { BaseEntity } from "@rapidrest/service-core";
+/**
+ * One fixed-size slice of the `ServerId`s a device holds for a `Sync` collection (see
+ * `EasCollectionState.chunked`). A large collection's held set is split across these rows instead of one array on
+ * the state row, so no single document approaches MongoDB's 16 MB limit and a round rewrites only the chunks its
+ * own additions/removals touched rather than the whole set.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export interface EasCollectionChunk extends BaseEntity {
+    /** The caller's own `Mailbox` (the device's account), as on `EasCollectionState`. */
+    mailboxUid: string;
+    deviceId: string;
+    /** The `Folder.uid` of the collection. */
+    folderUid: string;
+    /** Position of the chunk within the collection - unique per (mailbox, device, folder). */
+    chunkIndex: number;
+    /** The `ServerId`s this chunk holds (at most `HELD_CHUNK_SIZE`). */
+    ids: string[];
+}

package/dist/types/models/EasCollectionState.d.ts

@@ -0,0 +1,79 @@
+import type { BaseEntity } from "@rapidrest/service-core";
+/**
+ * The sync state of one round of a `Sync` collection, as it stood *before* that round was applied - kept so a
+ * client that never received a response (a dropped connection) can retry with the `SyncKey` it still holds, per
+ * [MS-ASCMD]'s "the server MUST accept the previous SyncKey" rule, and so re-sent `Add`s are not created twice.
+ * Only the round's delta against `serverIds` is kept (`addedIds`/`removedIds`), never a second full copy.
+ */
+export interface EasCollectionRound {
+    /** The `SyncKey` the client sent for the round - accepting it again replays the round from this state. */
+    syncKey: string;
+    cursorDate: string;
+    cursorUid: string;
+    moveCursorDate: string;
+    moveCursorUid: string;
+    /** Item uids the round added to `serverIds` (removed again when the round is replayed). */
+    addedIds: string[];
+    /** Item uids the round removed from `serverIds` (restored when the round is replayed). */
+    removedIds: string[];
+    /** `echoes` as they stood before the round. */
+    echoes: Record<string, string>;
+    /** `recent` as it stood before the round (absent on rows written before it existed). */
+    recent?: Record<string, string>;
+    /** `reconcileCursor` as it stood before the round. */
+    reconcileCursor?: string;
+    /** Each client `ClientId` with the `ServerId` created for it during the round, so a replayed `Add` is answered with
+     * the same item instead of creating a duplicate. A list rather than a map: `ClientId` is client-chosen text, never
+     * safe as a document/object key. */
+    clientIds: {
+        clientId: string;
+        serverId: string;
+    }[];
+}
+/**
+ * Per-device state of one EAS `Sync` collection (a folder), separate from `DeviceSyncState` so that concurrent
+ * `Sync` requests for different folders of one device never contend for the same row, and so a large item set
+ * never bloats the device row every other command reads.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export interface EasCollectionState extends BaseEntity {
+    /** The caller's own `Mailbox` (the device's account) - not necessarily the folder's owner for a shared folder. */
+    mailboxUid: string;
+    deviceId: string;
+    /** The `Folder.uid` this collection syncs (the EAS `CollectionId`). */
+    folderUid: string;
+    /** The EAS `Class` (`"Email"`, `"Contacts"`, ...) of the collection, so later requests may omit `Class`. */
+    collectionClass: string;
+    /** The `SyncKey` most recently issued for this collection. */
+    syncKey: string;
+    /** Position in the folder's own `(dateModified, uid)` change stream. */
+    cursorDate: Date;
+    cursorUid: string;
+    /** Position in the mailbox-wide stream of items outside this folder, which is how items moved out of the
+     * folder (or deleted after being moved) are found and reported as `Delete`s. */
+    moveCursorDate: Date;
+    moveCursorUid: string;
+    /** The `ServerId`s the device currently holds for this collection, while the set is small. Decides `Add` vs
+     * `Change` for a changed item and whether a removed item needs a `Delete` at all. Empty once `chunked`. */
+    serverIds: string[];
+    /** `true` once the held set has outgrown `serverIds` and lives in `EasCollectionChunk` rows instead. Stays set
+     * until the collection is restarted with `SyncKey 0`. */
+    chunked?: boolean;
+    /** Item uid -> `dateModified` (ISO) of the rows the folder stream processed within the overlap window before
+     * the cursor. The folder stream re-reads that window every round (a row committed out of order by another
+     * replica can carry a timestamp the cursor already passed), and a row still matching its entry here was
+     * already reported. */
+    recent?: Record<string, string>;
+    /** The last held `ServerId` checked against the store by the periodic reconcile (`""` = start over), which
+     * finds items that vanished without a trace in either change stream (hard purges). */
+    reconcileCursor?: string;
+    /** Item uid -> the `dateModified` (ISO) the device's own write left on it. A changed row whose `dateModified`
+     * still equals this value is the device's own `Add`/`Change` and is not echoed back. Entries are pruned once
+     * `cursorDate` passes them. */
+    echoes: Record<string, string>;
+    /** The `FilterType` the collection was synced with (`undefined` = no filter). */
+    filterType?: string;
+    /** See `EasCollectionRound`. */
+    previous?: EasCollectionRound;
+}

package/dist/types/models/mongo/DeviceSyncStateMongo.d.ts

@@ -18,5 +18,6 @@ export declare class DeviceSyncStateMongo extends BaseMongoEntity implements Dev
     remoteWipeRequested?: boolean;
     remoteWipeAccountOnly?: boolean;
     remoteWipeAcknowledgedAt?: Date;
+    blocked?: boolean;
     constructor(other?: Partial<DeviceSyncStateMongo>);
 }

package/dist/types/models/mongo/EasCollectionChunkMongo.d.ts

@@ -0,0 +1,16 @@
+import { BaseMongoEntity } from "@rapidrest/service-core";
+import type { EasCollectionChunk } from "../EasCollectionChunk.js";
+/**
+ * Implementation of the `EasCollectionChunk` interface for storage in a MongoDB database. If SQL is desired,
+ * please use `models.sql.EasCollectionChunkSQL` instead.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class EasCollectionChunkMongo extends BaseMongoEntity implements EasCollectionChunk {
+    mailboxUid: string;
+    deviceId: string;
+    folderUid: string;
+    chunkIndex: number;
+    ids: string[];
+    constructor(other?: Partial<EasCollectionChunkMongo>);
+}

package/dist/types/models/mongo/EasCollectionStateMongo.d.ts

@@ -0,0 +1,27 @@
+import { BaseMongoEntity } from "@rapidrest/service-core";
+import type { EasCollectionRound, EasCollectionState } from "../EasCollectionState.js";
+/**
+ * Implementation of the `EasCollectionState` interface for storage in a MongoDB database. If SQL is desired,
+ * please use `models.sql.EasCollectionStateSQL` instead.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class EasCollectionStateMongo extends BaseMongoEntity implements EasCollectionState {
+    mailboxUid: string;
+    deviceId: string;
+    folderUid: string;
+    collectionClass: string;
+    syncKey: string;
+    cursorDate: Date;
+    cursorUid: string;
+    moveCursorDate: Date;
+    moveCursorUid: string;
+    serverIds: string[];
+    echoes: Record<string, string>;
+    chunked?: boolean;
+    recent?: Record<string, string>;
+    reconcileCursor?: string;
+    filterType?: string;
+    previous?: EasCollectionRound;
+    constructor(other?: Partial<EasCollectionStateMongo>);
+}

package/dist/types/models/sql/DeviceSyncStateSQL.d.ts

@@ -18,5 +18,6 @@ export declare class DeviceSyncStateSQL extends BaseEntity implements DeviceSync
     remoteWipeRequested?: boolean;
     remoteWipeAccountOnly?: boolean;
     remoteWipeAcknowledgedAt?: Date;
+    blocked?: boolean;
     constructor(other?: Partial<DeviceSyncStateSQL>);
 }

package/dist/types/models/sql/EasCollectionChunkSQL.d.ts

@@ -0,0 +1,16 @@
+import { BaseEntity } from "@rapidrest/service-core";
+import type { EasCollectionChunk } from "../EasCollectionChunk.js";
+/**
+ * Implementation of the `EasCollectionChunk` interface for storage in a SQL database. If MongoDB is desired,
+ * please use `models.mongo.EasCollectionChunkMongo` instead.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class EasCollectionChunkSQL extends BaseEntity implements EasCollectionChunk {
+    mailboxUid: string;
+    deviceId: string;
+    folderUid: string;
+    chunkIndex: number;
+    ids: string[];
+    constructor(other?: Partial<EasCollectionChunkSQL>);
+}

package/dist/types/models/sql/EasCollectionStateSQL.d.ts

@@ -0,0 +1,27 @@
+import { BaseEntity } from "@rapidrest/service-core";
+import type { EasCollectionRound, EasCollectionState } from "../EasCollectionState.js";
+/**
+ * Implementation of the `EasCollectionState` interface for storage in a SQL database. If MongoDB is desired,
+ * please use `models.mongo.EasCollectionStateMongo` instead.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class EasCollectionStateSQL extends BaseEntity implements EasCollectionState {
+    mailboxUid: string;
+    deviceId: string;
+    folderUid: string;
+    collectionClass: string;
+    syncKey: string;
+    cursorDate: Date;
+    cursorUid: string;
+    moveCursorDate: Date;
+    moveCursorUid: string;
+    serverIds: string[];
+    echoes: Record<string, string>;
+    chunked?: boolean;
+    recent?: Record<string, string>;
+    reconcileCursor?: string;
+    filterType?: string;
+    previous?: EasCollectionRound;
+    constructor(other?: Partial<EasCollectionStateSQL>);
+}

package/dist/types/mongo.d.ts

@@ -7,4 +7,6 @@
 export { EasRouteMongo } from "./mongo/EasRouteMongo.js";
 export { DeviceSyncStateRouteMongo } from "./mongo/DeviceSyncStateRouteMongo.js";
 export { DeviceSyncStateMongo } from "./models/mongo/DeviceSyncStateMongo.js";
+export { EasCollectionStateMongo } from "./models/mongo/EasCollectionStateMongo.js";
+export { EasCollectionChunkMongo } from "./models/mongo/EasCollectionChunkMongo.js";
 export { EasDeviceStateCleanupJobMongo } from "./jobs/mongo/EasDeviceStateCleanupJobMongo.js";

package/dist/types/sql.d.ts

@@ -7,4 +7,6 @@
 export { EasRouteSQL } from "./sql/EasRouteSQL.js";
 export { DeviceSyncStateRouteSQL } from "./sql/DeviceSyncStateRouteSQL.js";
 export { DeviceSyncStateSQL } from "./models/sql/DeviceSyncStateSQL.js";
+export { EasCollectionStateSQL } from "./models/sql/EasCollectionStateSQL.js";
+export { EasCollectionChunkSQL } from "./models/sql/EasCollectionChunkSQL.js";
 export { EasDeviceStateCleanupJobSQL } from "./jobs/sql/EasDeviceStateCleanupJobSQL.js";