@lenne.tech/nest-server 12.1.1 → 12.3.0

package/dist/core/modules/sync/core-sync.service.d.ts

@@ -0,0 +1,143 @@
+import { HttpException, Logger, OnApplicationBootstrap, OnModuleDestroy, Type } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import type { ISync } from '../../common/interfaces/server-options.interface.js';
+import type { DataStore } from '../../common/persistence/data-store.interface.js';
+import type { LockStore } from '../../common/persistence/lock-store.interface.js';
+import { type SyncAccessListener, type SyncRecordChange, type SyncRecordMove } from '../../common/persistence/sync-access.registry.js';
+import { type SyncConflictStrategy, type SyncIdFormat, type SyncOperationRoles } from '../../common/persistence/sync-model.js';
+import { CoreRedisService } from '../../common/services/core-redis.service.js';
+import { CrudService } from '../../common/services/crud.service.js';
+import { RateLimitStore } from '../../common/services/rate-limit-store.js';
+import { CoreSyncHintService, type SyncHintEvent } from './core-sync-hints.service.js';
+import { type SyncCursorPosition, type SyncCursorState } from './core-sync-cursor.js';
+import { getSyncServiceOptions, type SyncFieldStrategy } from './core-sync.decorators.js';
+import { CoreSyncMutationStore } from './core-sync-mutation.store.js';
+import { CoreSyncStateStore } from './core-sync-state.store.js';
+import type { ISyncPullResult, ISyncPushItem, ISyncPushResult, ISyncRecord, SyncResyncReason } from './interfaces/core-sync.interfaces.js';
+export declare class SyncResyncRequiredException extends HttpException {
+    readonly reason: SyncResyncReason;
+    constructor(reason: SyncResyncReason);
+}
+export interface SyncModelRegistration {
+    createInput: Type<any>;
+    fieldStrategies: Readonly<Record<string, SyncFieldStrategy>>;
+    idFormat: SyncIdFormat;
+    model: Type<any>;
+    name: string;
+    order: 'clock' | 'seq';
+    roles: Readonly<Required<SyncOperationRoles>>;
+    scope: readonly string[];
+    service: CrudService<any>;
+    store: DataStore<any>;
+    strategy: SyncConflictStrategy;
+    tenantScoped: boolean;
+    updateInput: Type<any>;
+}
+interface SyncAccessState {
+    epochs: string;
+    fingerprint: string;
+    user: string;
+}
+export declare class CoreSyncService implements OnApplicationBootstrap, OnModuleDestroy, SyncAccessListener {
+    protected readonly discoveryService: DiscoveryService;
+    protected readonly moduleRef: ModuleRef;
+    protected readonly redisService?: CoreRedisService;
+    protected readonly hintService?: CoreSyncHintService;
+    protected readonly logger: Logger;
+    protected readonly models: Map<string, SyncModelRegistration>;
+    protected readonly mutationStore: CoreSyncMutationStore;
+    protected readonly stateStore: CoreSyncStateStore;
+    protected cursorKey?: Buffer;
+    protected rateLimitStore?: RateLimitStore;
+    protected purgeTimer?: ReturnType<typeof setInterval>;
+    protected purgeRunning?: Promise<unknown>;
+    protected readonly purgeOwner: string;
+    protected purgeIntervalMs: number;
+    constructor(mutations: DataStore<any>, states: DataStore<any>, discoveryService: DiscoveryService, moduleRef: ModuleRef, redisService?: CoreRedisService, hintService?: CoreSyncHintService);
+    protected get config(): ISync;
+    onApplicationBootstrap(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    getModels(): ReadonlyMap<string, SyncModelRegistration>;
+    protected resolveCursorSecret(): string;
+    protected discoverModels(): SyncModelRegistration[];
+    protected resolveRegistration(service: unknown, options: NonNullable<ReturnType<typeof getSyncServiceOptions>>): SyncModelRegistration;
+    protected registration(model: string): SyncModelRegistration;
+    pull(model: string, query: {
+        cursor?: unknown;
+        limit?: unknown;
+    }, currentUser: any): Promise<ISyncPullResult>;
+    protected continuedCursor(registration: SyncModelRegistration, cursor: unknown, access: SyncAccessState): Promise<SyncCursorState>;
+    protected pullLimit(value: unknown): number;
+    protected readClock(registration: SyncModelRegistration): Promise<{
+        now: number;
+        windowMs: number;
+    }>;
+    protected readPositions(registration: SyncModelRegistration, position: SyncCursorPosition, count: number): Promise<any[]>;
+    protected comparePositions(registration: SyncModelRegistration, a: any, b: any): number;
+    protected readContents(registration: SyncModelRegistration, ids: string[], currentUser: any): Promise<Map<string, any>>;
+    protected readSystemFields(registration: SyncModelRegistration, ids: string[]): Promise<Map<string, any>>;
+    protected systemFields(registration: SyncModelRegistration): string[];
+    protected positionOf(registration: SyncModelRegistration, raw: any): SyncCursorPosition;
+    protected toSyncRecord(registration: SyncModelRegistration, record: any, raw: any, currentUser: any): ISyncRecord | undefined;
+    protected accessState(registration: SyncModelRegistration, currentUser: any): Promise<SyncAccessState>;
+    push(model: string, body: unknown, currentUser: any): Promise<{
+        results: ISyncPushResult[];
+    }>;
+    protected heldBackItem(registration: SyncModelRegistration, item: ISyncPushItem, reason: 'refused' | 'retry', currentUser: any): Promise<ISyncPushResult>;
+    protected pushItems(body: unknown): ISyncPushItem[];
+    protected pushItem(registration: SyncModelRegistration, item: ISyncPushItem, currentUser: any): Promise<ISyncPushResult>;
+    protected repeatedResult(registration: SyncModelRegistration, item: ISyncPushItem, outcome: {
+        code?: string;
+        status: string;
+        version?: number;
+    }, currentUser: any): Promise<ISyncPushResult>;
+    protected applyItem(registration: SyncModelRegistration, item: ISyncPushItem, currentUser: any): Promise<ISyncPushResult>;
+    protected applyCreate(registration: SyncModelRegistration, item: ISyncPushItem, currentUser: any): Promise<ISyncPushResult>;
+    protected applyUpdate(registration: SyncModelRegistration, item: ISyncPushItem, currentUser: any): Promise<ISyncPushResult>;
+    protected resolveUpdateConflict(registration: SyncModelRegistration, item: ISyncPushItem, input: Record<string, unknown>, currentUser: any): Promise<ISyncPushResult>;
+    protected applyDelete(registration: SyncModelRegistration, item: ISyncPushItem, current: ISyncRecord | undefined, currentUser: any): Promise<ISyncPushResult>;
+    protected applyCustom(registration: SyncModelRegistration, item: ISyncPushItem, currentUser: any): Promise<ISyncPushResult>;
+    protected reapply(registration: SyncModelRegistration, item: ISyncPushItem, input: Record<string, unknown>, status: 'applied' | 'merged', currentUser: any): Promise<ISyncPushResult>;
+    protected reapplyDelete(registration: SyncModelRegistration, item: ISyncPushItem, currentUser: any): Promise<ISyncPushResult>;
+    protected currentConflict(registration: SyncModelRegistration, item: ISyncPushItem, currentUser: any): Promise<ISyncPushResult>;
+    protected update(registration: SyncModelRegistration, id: string, input: Record<string, unknown>, expectedVersion: number, currentUser: any): Promise<unknown>;
+    protected remove(registration: SyncModelRegistration, id: string, expectedVersion: number, currentUser: any): Promise<unknown>;
+    protected findVisible(registration: SyncModelRegistration, id: string, currentUser: any): Promise<ISyncRecord | undefined>;
+    protected validateInput(inputType: Type<any>, data: unknown): Promise<Record<string, unknown>>;
+    protected writeFailure(registration: SyncModelRegistration, item: ISyncPushItem, error: unknown, currentUser: any): Promise<ISyncPushResult>;
+    rateLimit(kind: 'pull' | 'push', currentUser: any): Promise<number | undefined>;
+    protected getRateLimitStore(): RateLimitStore;
+    assertPushRequest(request: any): void;
+    protected isTrustedOrigin(origin: string): boolean;
+    bumpAccessEpoch(model: string, tenantId: string | undefined, userId?: string): Promise<void>;
+    recordMoved(move: SyncRecordMove): Promise<void>;
+    tenantInvalidated(tenantId: string): Promise<void>;
+    advanceHorizon(model: string, at: Date): Promise<void>;
+    recordChanged(change: SyncRecordChange): void;
+    notifyChange(model: string, tenantIds?: readonly string[]): void;
+    hintsEnabled(channel: 'graphql' | 'sse'): boolean;
+    protected hintFilter(currentUser: any, models?: readonly string[]): Promise<(hint: SyncHintEvent) => boolean>;
+    protected hintPayload(hint: SyncHintEvent): {
+        at: Date;
+        model: string;
+    };
+    openHintStream(request: any, response: any, currentUser: any, models?: readonly string[]): Promise<void>;
+    hintIterator(currentUser: any, models?: readonly string[]): Promise<AsyncIterableIterator<{
+        syncHint: {
+            at: Date;
+            model: string;
+        };
+    }>>;
+    protected tombstoneDays(): false | number;
+    protected schedulePurge(): void;
+    protected leasedPurge(): Promise<void>;
+    protected purgeLeaseStore(): Promise<LockStore | undefined>;
+    purgeTombstones(options?: {
+        before?: Date;
+        model?: string;
+    }): Promise<Record<string, number>>;
+    protected purgeModel(registration: SyncModelRegistration, before: Date): Promise<number>;
+    protected resync(reason: SyncResyncReason): never;
+    protected storeCall<T>(call: () => Promise<T>): Promise<T>;
+}
+export {};