@lenne.tech/nest-server 12.1.0 → 12.2.0

package/dist/core/modules/sync/core-sync.module.js

@@ -0,0 +1,50 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CoreSyncModule_1;
+import { Module } from '@nestjs/common';
+import { PATH_METADATA } from '@nestjs/common/constants';
+import { DiscoveryModule } from '@nestjs/core';
+import { CorePersistenceModule } from '../../common/persistence/core-persistence.module.js';
+import { SYNC_DEFAULTS, SYNC_MUTATION_MODEL, SYNC_STATE_MODEL } from './core-sync.constants.js';
+import { CoreSyncController } from './core-sync.controller.js';
+import { CoreSyncHintsController } from './core-sync-hints.controller.js';
+import { CoreSyncHintService } from './core-sync-hints.service.js';
+import { SyncMutationSchema, SyncStateSchema } from './core-sync-infrastructure.models.js';
+import { CoreSyncResolver } from './core-sync.resolver.js';
+import { CoreSyncService } from './core-sync.service.js';
+let CoreSyncModule = CoreSyncModule_1 = class CoreSyncModule {
+    static forRoot(options = {}) {
+        const controller = options.controller ?? CoreSyncController;
+        const hintsController = options.hintsController ?? CoreSyncHintsController;
+        for (const routes of [hintsController, controller]) {
+            Reflect.defineMetadata(PATH_METADATA, options.path || SYNC_DEFAULTS.path, routes);
+        }
+        return {
+            controllers: [hintsController, controller],
+            exports: [CoreSyncHintService, CoreSyncService],
+            global: true,
+            imports: [
+                DiscoveryModule,
+                CorePersistenceModule.forFeature([
+                    { name: SYNC_MUTATION_MODEL, schema: SyncMutationSchema },
+                    { name: SYNC_STATE_MODEL, schema: SyncStateSchema },
+                ]),
+            ],
+            module: CoreSyncModule_1,
+            providers: [
+                CoreSyncHintService,
+                options.service ? { provide: CoreSyncService, useClass: options.service } : CoreSyncService,
+                ...(options.graphQlHints === false ? [] : [options.resolver ?? CoreSyncResolver]),
+            ],
+        };
+    }
+};
+CoreSyncModule = CoreSyncModule_1 = __decorate([
+    Module({})
+], CoreSyncModule);
+export { CoreSyncModule };
+//# sourceMappingURL=core-sync.module.js.map

package/dist/core/modules/sync/core-sync.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-sync.module.js","sourceRoot":"","sources":["../../../../src/core/modules/sync/core-sync.module.ts"],"names":[],"mappings":";;;;;;;AAAA,OAAO,EAAiB,MAAM,EAAQ,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qDAAqD,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAC3F,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAgClD,IAAM,cAAc,sBAApB,MAAM,cAAc;IACzB,MAAM,CAAC,OAAO,CAAC,UAAiC,EAAE;QAChD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,kBAAkB,CAAC;QAC5D,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,uBAAuB,CAAC;QAE3E,KAAK,MAAM,MAAM,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,EAAE,CAAC;YACnD,OAAO,CAAC,cAAc,CAAC,aAAa,EAAE,OAAO,CAAC,IAAI,IAAI,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACpF,CAAC;QACD,OAAO;YAGL,WAAW,EAAE,CAAC,eAAe,EAAE,UAAU,CAAC;YAC1C,OAAO,EAAE,CAAC,mBAAmB,EAAE,eAAe,CAAC;YAG/C,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE;gBACP,eAAe;gBACf,qBAAqB,CAAC,UAAU,CAAC;oBAC/B,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,kBAAkB,EAAE;oBACzD,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,eAAe,EAAE;iBACpD,CAAC;aACH;YACD,MAAM,EAAE,gBAAc;YACtB,SAAS,EAAE;gBACT,mBAAmB;gBACnB,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,eAAe;gBAC3F,GAAG,CAAC,OAAO,CAAC,YAAY,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,IAAI,gBAAgB,CAAC,CAAC;aAClF;SACF,CAAC;IACJ,CAAC;CACF,CAAA;AA/BY,cAAc;IAD1B,MAAM,CAAC,EAAE,CAAC;GACE,cAAc,CA+B1B"}

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

@@ -0,0 +1,9 @@
+import { CoreSyncService } from './core-sync.service.js';
+import { CoreSyncHintModel } from './models/core-sync-hint.model.js';
+export declare class CoreSyncResolver {
+    protected readonly syncService: CoreSyncService;
+    constructor(syncService: CoreSyncService);
+    syncHint(currentUser: any, models?: string[]): Promise<AsyncIterableIterator<{
+        syncHint: CoreSyncHintModel;
+    }>>;
+}

package/dist/core/modules/sync/core-sync.resolver.js

@@ -0,0 +1,46 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Args, Resolver, Subscription } from '@nestjs/graphql';
+import { GraphQLUser } from '../../common/decorators/graphql-user.decorator.js';
+import { Roles } from '../../common/decorators/roles.decorator.js';
+import { RoleEnum } from '../../common/enums/role.enum.js';
+import { CoreSyncService } from './core-sync.service.js';
+import { CoreSyncHintModel } from './models/core-sync-hint.model.js';
+let CoreSyncResolver = class CoreSyncResolver {
+    syncService;
+    constructor(syncService) {
+        this.syncService = syncService;
+    }
+    syncHint(currentUser, models) {
+        return this.syncService.hintIterator(currentUser, models);
+    }
+};
+__decorate([
+    Roles(RoleEnum.S_USER),
+    Subscription(() => CoreSyncHintModel, {
+        description: 'A hint whenever a synchronized model the subscriber may pull changes',
+        name: 'syncHint',
+    }),
+    __param(0, GraphQLUser()),
+    __param(1, Args('models', { description: 'Only these models (all when absent)', nullable: true, type: () => [String] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array]),
+    __metadata("design:returntype", Promise)
+], CoreSyncResolver.prototype, "syncHint", null);
+CoreSyncResolver = __decorate([
+    Resolver(),
+    Roles(RoleEnum.S_USER),
+    __metadata("design:paramtypes", [CoreSyncService])
+], CoreSyncResolver);
+export { CoreSyncResolver };
+//# sourceMappingURL=core-sync.resolver.js.map

package/dist/core/modules/sync/core-sync.resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-sync.resolver.js","sourceRoot":"","sources":["../../../../src/core/modules/sync/core-sync.resolver.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/D,OAAO,EAAE,WAAW,EAAE,MAAM,mDAAmD,CAAC;AAChF,OAAO,EAAE,KAAK,EAAE,MAAM,4CAA4C,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAa9D,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB;IACI;IAA/B,YAA+B,WAA4B;QAA5B,gBAAW,GAAX,WAAW,CAAiB;IAAG,CAAC;IAO/D,QAAQ,CACS,WAAgB,EAE/B,MAAiB;QAEjB,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IAC5D,CAAC;CACF,CAAA;AAPC;IALC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC;IACtB,YAAY,CAAC,GAAG,EAAE,CAAC,iBAAiB,EAAE;QACrC,WAAW,EAAE,sEAAsE;QACnF,IAAI,EAAE,UAAU;KACjB,CAAC;IAEC,WAAA,WAAW,EAAE,CAAA;IACb,WAAA,IAAI,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE,qCAAqC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;;;;gDAI9G;AAdU,gBAAgB;IAF5B,QAAQ,EAAE;IACV,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC;qCAEuB,eAAe;GADhD,gBAAgB,CAe5B"}

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

@@ -0,0 +1,142 @@
+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 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 {};