@lenne.tech/nest-server 12.1.0 → 12.2.0

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

@@ -0,0 +1,1208 @@
+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); }
+};
+var CoreSyncService_1;
+import { BadRequestException, ForbiddenException, HttpException, HttpStatus, Injectable, Logger, NotFoundException, Optional, ServiceUnavailableException, UnauthorizedException, } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { RoleEnum } from '../../common/enums/role.enum.js';
+import { getStringIds } from '../../common/helpers/db.helper.js';
+import { ensureWsConnectionCurrent, getWsConnection, noteWsConnectionTenant, registerWsConnection, } from '../../common/helpers/graphql-ws-connection.helper.js';
+import { buildCorsConfig, isCookiesEnabled, isProductionLikeEnv, resolveServerUrls, } from '../../common/helpers/cookies.helper.js';
+import { InjectStore } from '../../common/persistence/inject-store.decorator.js';
+import { getModelDescriptor } from '../../common/persistence/model-metadata.registry.js';
+import { isDuplicateIdError } from '../../common/persistence/mongoose-data-store.js';
+import { getPersistedModelOptions } from '../../common/persistence/persisted-model.decorator.js';
+import { CRON_LOCK_COLLECTION, cronMongoLocks, defaultSqlLockStore, } from '../../common/persistence/infrastructure-locks.js';
+import { getStoreToken } from '../../common/persistence/persistence.tokens.js';
+import { isSyncId, VersionConflictError } from '../../common/persistence/policies/sync.policy.js';
+import { allowedTenantIds, resolveTenantScope } from '../../common/persistence/policies/tenant.policy.js';
+import { DuplicateKeyError, QueryCastError, UnsupportedQueryError } from '../../common/persistence/sql/sql-errors.js';
+import { getSyncAccessListener, setSyncAccessListener, } from '../../common/persistence/sync-access.registry.js';
+import { SYNC_CLOCK_FIELD, SYNC_SEQUENCE_FIELD, } from '../../common/persistence/sync-model.js';
+import { MapAndValidatePipe } from '../../common/pipes/map-and-validate.pipe.js';
+import { ConfigService } from '../../common/services/config.service.js';
+import { getCronJobsInfrastructure } from '../../common/services/core-cron-jobs.registry.js';
+import { CoreRedisService } from '../../common/services/core-redis.service.js';
+import { CrudService } from '../../common/services/crud.service.js';
+import { InMemoryRateLimitStore, RedisRateLimitStore } from '../../common/services/rate-limit-store.js';
+import { RequestContext } from '../../common/services/request-context.service.js';
+import { ErrorCode } from '../error-code/error-codes.js';
+import { SYNC_CLAIM_TIMEOUT_MS, SYNC_DEFAULTS, SYNC_HINT_KEEPALIVE_MS, SYNC_MUTATION_MODEL, SYNC_PULL_LIMIT_CEILING, SYNC_PURGE_BATCH, SYNC_PURGE_INTERVAL_MS, SYNC_REAPPLY_ATTEMPTS, SYNC_STATE_MODEL, } from './core-sync.constants.js';
+import { CoreSyncHintService } from './core-sync-hints.service.js';
+import { decodeSyncCursor, deriveCursorKey, encodeSyncCursor, stableHash, } from './core-sync-cursor.js';
+import { getSyncFieldStrategies, getSyncServiceOptions } from './core-sync.decorators.js';
+import { CoreSyncMutationStore } from './core-sync-mutation.store.js';
+import { CoreSyncStateStore } from './core-sync-state.store.js';
+export class SyncResyncRequiredException extends HttpException {
+    reason;
+    constructor(reason) {
+        super({ code: 'SYNC_RESYNC_REQUIRED', message: ErrorCode.SYNC_RESYNC_REQUIRED, reason, statusCode: HttpStatus.GONE }, HttpStatus.GONE);
+        this.reason = reason;
+    }
+}
+const ADMIN_ONLY = Object.freeze([RoleEnum.ADMIN]);
+const OPERATIONS = ['create', 'delete', 'pull', 'update'];
+const MAX_MUTATION_ID_LENGTH = 128;
+const MAX_ID_LENGTH = 64;
+const SYSTEM_RECORD_FIELDS = new Set([
+    '__v',
+    '_id',
+    'deletedAt',
+    'id',
+    'updatedAt',
+    'version',
+    SYNC_CLOCK_FIELD,
+    SYNC_SEQUENCE_FIELD,
+]);
+let CoreSyncService = CoreSyncService_1 = class CoreSyncService {
+    discoveryService;
+    moduleRef;
+    redisService;
+    hintService;
+    logger = new Logger(CoreSyncService_1.name);
+    models = new Map();
+    mutationStore;
+    stateStore;
+    cursorKey;
+    rateLimitStore;
+    purgeTimer;
+    purgeRunning;
+    purgeOwner = `sync-purge:${process.pid}:${Math.random().toString(36).slice(2)}`;
+    purgeIntervalMs = SYNC_PURGE_INTERVAL_MS;
+    constructor(mutations, states, discoveryService, moduleRef, redisService, hintService) {
+        this.discoveryService = discoveryService;
+        this.moduleRef = moduleRef;
+        this.redisService = redisService;
+        this.hintService = hintService;
+        const days = positiveNumber(this.config.retention?.mutationsDays, SYNC_DEFAULTS.mutationsDays);
+        this.mutationStore = new CoreSyncMutationStore(mutations, {
+            claimTimeoutMs: SYNC_CLAIM_TIMEOUT_MS,
+            retentionMs: days * 86_400_000,
+        });
+        this.stateStore = new CoreSyncStateStore(states);
+    }
+    get config() {
+        const value = ConfigService.configFastButReadOnly?.sync;
+        return value && typeof value === 'object' ? value : {};
+    }
+    async onApplicationBootstrap() {
+        this.cursorKey = deriveCursorKey(this.resolveCursorSecret());
+        for (const registration of this.discoverModels()) {
+            if (this.models.has(registration.name)) {
+                throw new Error(`Sync: two services declare @SyncService() for the model "${registration.name}"`);
+            }
+            this.models.set(registration.name, registration);
+        }
+        setSyncAccessListener(this);
+        if (this.models.size) {
+            this.logger.log(`Offline sync for ${[...this.models.keys()].join(', ')}`);
+            this.schedulePurge();
+        }
+        else {
+            this.logger.warn('Offline sync is configured, but no service declares @SyncService() — no model is offered');
+        }
+    }
+    async onModuleDestroy() {
+        if (getSyncAccessListener() === this) {
+            setSyncAccessListener(undefined);
+        }
+        if (this.purgeTimer) {
+            clearInterval(this.purgeTimer);
+            this.purgeTimer = undefined;
+        }
+        await this.purgeRunning?.catch(() => undefined);
+    }
+    getModels() {
+        return this.models;
+    }
+    resolveCursorSecret() {
+        const secret = this.config.cursorSecret || process.env.SECRETS_ENCRYPTION_KEY;
+        if (secret) {
+            return secret;
+        }
+        const env = ConfigService.configFastButReadOnly?.env;
+        if (isProductionLikeEnv(env)) {
+            throw new Error(`Sync: no sync.cursorSecret / SECRETS_ENCRYPTION_KEY set in "${env}" — pull cursors would be signed with a ` +
+                'known key');
+        }
+        this.logger.warn('No sync.cursorSecret / SECRETS_ENCRYPTION_KEY set — pull cursors are signed with an insecure development ' +
+            'default. Never run this in production (the boot refuses it there).');
+        return 'lt-nest-server-sync-cursor-dev-only-insecure-default';
+    }
+    discoverModels() {
+        const seen = new Set();
+        const registrations = [];
+        for (const wrapper of this.discoveryService.getProviders()) {
+            const instance = wrapper.instance;
+            const options = wrapper.metatype ? getSyncServiceOptions(wrapper.metatype) : undefined;
+            if (!options || !instance || seen.has(instance)) {
+                continue;
+            }
+            seen.add(instance);
+            registrations.push(this.resolveRegistration(instance, options));
+        }
+        return registrations;
+    }
+    resolveRegistration(service, options) {
+        const name = options.modelName ?? options.model?.name;
+        const label = `@SyncService() on ${service?.constructor?.name}`;
+        if (!(service instanceof CrudService)) {
+            throw new Error(`Sync: ${label} — the service must extend CrudService`);
+        }
+        if (!name || !options.createInput || !options.updateInput) {
+            throw new Error(`Sync: ${label} needs model, createInput and updateInput`);
+        }
+        let store;
+        try {
+            store = this.moduleRef.get(getStoreToken(name), { strict: false });
+        }
+        catch {
+            throw new Error(`Sync: ${label} — the model "${name}" is not registered with CorePersistenceModule.forFeature()`);
+        }
+        const order = store?.capabilities?.changeOrder;
+        if (!order) {
+            throw new Error(`Sync: ${label} — the model "${name}" is not synchronized (@PersistedModel({ sync }))`);
+        }
+        if (order === 'clock' && typeof store.changeClock !== 'function') {
+            throw new Error(`Sync: the store of "${name}" orders changes by clock but offers no changeClock()`);
+        }
+        const declared = getPersistedModelOptions(options.model)?.sync;
+        const declaration = declared && typeof declared === 'object' ? declared : {};
+        const strategy = declaration.strategy ?? 'reject';
+        if (strategy === 'custom' && typeof service.resolveSyncConflict !== 'function') {
+            throw new Error(`Sync: "${name}" declares strategy 'custom', but ${service.constructor.name} has no resolveSyncConflict()`);
+        }
+        const missing = OPERATIONS.filter((operation) => !declaration.roles?.[operation]?.length);
+        if (missing.length) {
+            this.logger.warn(`Sync: "${name}" declares no sync roles for ${missing.join(', ')} — open to ADMIN only. Declare them in ` +
+                '@PersistedModel({ sync: { roles } })');
+        }
+        const roles = Object.freeze(Object.fromEntries(OPERATIONS.map((operation) => [operation, Object.freeze([...(declaration.roles?.[operation] ?? ADMIN_ONLY)])])));
+        const descriptor = getModelDescriptor(name);
+        return {
+            createInput: options.createInput,
+            fieldStrategies: Object.freeze(getSyncFieldStrategies(options.model)),
+            idFormat: store.capabilities.idType,
+            model: options.model,
+            name,
+            order,
+            roles,
+            scope: descriptor?.sync?.scope ?? [],
+            service,
+            store,
+            strategy,
+            tenantScoped: !!descriptor?.tenantScoped,
+            updateInput: options.updateInput,
+        };
+    }
+    registration(model) {
+        const registration = typeof model === 'string' ? this.models.get(model) : undefined;
+        if (!registration) {
+            throw new NotFoundException(ErrorCode.SYNC_MODEL_NOT_FOUND);
+        }
+        return registration;
+    }
+    async pull(model, query, currentUser) {
+        const registration = this.registration(model);
+        await registration.service.checkRights(undefined, currentUser, { roles: [...registration.roles.pull] });
+        const limit = this.pullLimit(query.limit);
+        const access = await this.accessState(registration, currentUser);
+        const state = query.cursor === undefined || query.cursor === ''
+            ? undefined
+            : await this.continuedCursor(registration, query.cursor, access);
+        const clock = await this.readClock(registration);
+        const runStart = state?.runStart ?? clock.now;
+        const since = state ? state.since : runStart;
+        const position = state?.position ?? initialPosition(registration.order);
+        const rows = await this.readPositions(registration, position, limit + 1);
+        const page = rows.slice(0, limit);
+        const contents = await this.readContents(registration, page.map((row) => String(row.id)), currentUser);
+        const maxBytes = positiveNumber(this.config.pull?.maxBytes, SYNC_DEFAULTS.maxBytes);
+        const items = [];
+        let bytes = 2;
+        let consumed = 0;
+        let last = position;
+        for (const raw of page) {
+            const record = contents.get(String(raw.id));
+            const item = record ? this.toSyncRecord(registration, record, raw, currentUser) : undefined;
+            if (item) {
+                const size = Buffer.byteLength(JSON.stringify(item)) + 1;
+                if (items.length && bytes + size > maxBytes) {
+                    break;
+                }
+                items.push(item);
+                bytes += size;
+            }
+            consumed++;
+            last = this.positionOf(registration, raw);
+        }
+        const hasMore = consumed < rows.length;
+        const next = hasMore
+            ? { position: last, runStart, since }
+            :
+                {
+                    position: registration.order === 'seq' ? last : { at: runStart - clock.windowMs, id: '' },
+                    since: runStart,
+                };
+        const cursor = encodeSyncCursor({ ...next, epochs: access.epochs, fingerprint: access.fingerprint, model: registration.name, user: access.user }, this.cursorKey);
+        return { cursor, hasMore, items };
+    }
+    async continuedCursor(registration, cursor, access) {
+        const state = decodeSyncCursor(cursor, this.cursorKey);
+        if (!state ||
+            state.model !== registration.name ||
+            state.user !== access.user ||
+            'seq' in state.position !== (registration.order === 'seq')) {
+            this.resync('invalid');
+        }
+        if (state.fingerprint !== access.fingerprint || state.epochs !== access.epochs) {
+            this.resync('access');
+        }
+        const horizon = await this.stateStore.horizon(registration.name);
+        if (horizon && state.since < horizon.getTime()) {
+            this.resync('horizon');
+        }
+        return state;
+    }
+    pullLimit(value) {
+        const max = Math.min(positiveNumber(this.config.pull?.maxLimit, SYNC_DEFAULTS.maxLimit), SYNC_PULL_LIMIT_CEILING);
+        const fallback = Math.min(positiveNumber(this.config.pull?.defaultLimit, SYNC_DEFAULTS.pullLimit), max);
+        if (value === undefined || value === '') {
+            return fallback;
+        }
+        const limit = typeof value === 'number' ? value : typeof value === 'string' && /^\d+$/.test(value) ? Number(value) : NaN;
+        if (!Number.isInteger(limit) || limit < 1 || limit > max) {
+            throw new BadRequestException(`${ErrorCode.SYNC_INVALID_REQUEST}: limit must be an integer from 1 to ${max}`);
+        }
+        return limit;
+    }
+    async readClock(registration) {
+        if (registration.order !== 'clock') {
+            return { now: Date.now(), windowMs: 0 };
+        }
+        const clock = await this.storeCall(() => registration.store.changeClock());
+        const configured = this.config.pull?.windowSeconds;
+        const windowMs = typeof configured === 'number' && configured >= 0 ? configured * 1000 : clock.windowMs;
+        return { now: clock.now.getTime(), windowMs };
+    }
+    async readPositions(registration, position, count) {
+        let where;
+        let sort;
+        if ('seq' in position) {
+            where = { [SYNC_SEQUENCE_FIELD]: { $gt: position.seq } };
+            sort = { [SYNC_SEQUENCE_FIELD]: 1 };
+        }
+        else {
+            const at = new Date(position.at);
+            where = position.id
+                ? { $or: [{ [SYNC_CLOCK_FIELD]: { $gt: at } }, { id: { $gt: position.id }, [SYNC_CLOCK_FIELD]: at }] }
+                : { [SYNC_CLOCK_FIELD]: { $gte: at } };
+            sort = { [SYNC_CLOCK_FIELD]: 1, id: 1 };
+        }
+        const options = { includeTombstones: true, limit: count, select: this.systemFields(registration), sort };
+        const scope = registration.tenantScoped ? resolveTenantScope() : undefined;
+        const tenants = scope?.kind === 'tenants' ? [...new Set(scope.tenantIds.map(String))] : [];
+        if (!tenants.length) {
+            return this.storeCall(() => registration.store.find(where, options));
+        }
+        const pages = await Promise.all(tenants.map((tenantId) => this.storeCall(() => registration.store.find({ $and: [where, { tenantId }] }, options))));
+        return pages
+            .flat()
+            .sort((a, b) => this.comparePositions(registration, a, b))
+            .slice(0, count);
+    }
+    comparePositions(registration, a, b) {
+        if (registration.order === 'seq') {
+            return Number(a?.[SYNC_SEQUENCE_FIELD]) - Number(b?.[SYNC_SEQUENCE_FIELD]);
+        }
+        const at = new Date(a?.[SYNC_CLOCK_FIELD]).getTime() - new Date(b?.[SYNC_CLOCK_FIELD]).getTime();
+        if (at) {
+            return at;
+        }
+        const left = String(a?.id);
+        const right = String(b?.id);
+        return left < right ? -1 : left > right ? 1 : 0;
+    }
+    async readContents(registration, ids, currentUser) {
+        const result = new Map();
+        if (!ids.length) {
+            return result;
+        }
+        const records = await this.storeCall(() => registration.service.find({ filterQuery: { _id: { $in: ids } } }, { currentUser, includeTombstones: true, roles: [...registration.roles.pull] }));
+        for (const record of Array.isArray(records) ? records : []) {
+            result.set(String(recordId(record)), record);
+        }
+        return result;
+    }
+    async readSystemFields(registration, ids) {
+        const result = new Map();
+        if (!ids.length) {
+            return result;
+        }
+        const rows = await this.storeCall(() => registration.store.find({ id: { $in: ids } }, { includeTombstones: true, select: this.systemFields(registration) }));
+        for (const row of rows) {
+            result.set(String(row.id), row);
+        }
+        return result;
+    }
+    systemFields(registration) {
+        const fields = getModelDescriptor(registration.name)?.fields ?? {};
+        return [
+            'deletedAt',
+            'version',
+            registration.order === 'seq' ? SYNC_SEQUENCE_FIELD : SYNC_CLOCK_FIELD,
+            ...['tenantId', 'updatedAt'].filter((field) => field in fields),
+        ];
+    }
+    positionOf(registration, raw) {
+        if (registration.order === 'seq') {
+            return { seq: Number(raw?.[SYNC_SEQUENCE_FIELD]) };
+        }
+        return { at: new Date(raw?.[SYNC_CLOCK_FIELD]).getTime(), id: String(raw?.id) };
+    }
+    toSyncRecord(registration, record, raw, currentUser) {
+        if (!record || !raw) {
+            return undefined;
+        }
+        const checked = typeof record.securityCheck === 'function' ? record.securityCheck(currentUser, false) : record;
+        if (!checked) {
+            return undefined;
+        }
+        const plain = { ...checked };
+        const base = {
+            deletedAt: raw.deletedAt ? new Date(raw.deletedAt) : null,
+            id: String(raw.id),
+            ...(raw.updatedAt ? { updatedAt: new Date(raw.updatedAt) } : {}),
+            version: Number(raw.version),
+        };
+        if (base.deletedAt) {
+            if (registration.tenantScoped && raw.tenantId !== undefined && raw.tenantId !== null) {
+                base.tenantId = String(getStringIds(raw.tenantId));
+            }
+            for (const field of registration.scope) {
+                if (plain[field] !== undefined) {
+                    base[field] = getStringIds(plain[field]);
+                }
+            }
+            return base;
+        }
+        const data = {};
+        for (const [key, value] of Object.entries(plain)) {
+            if (!SYSTEM_RECORD_FIELDS.has(key) && value !== undefined && typeof value !== 'function') {
+                data[key] = value;
+            }
+        }
+        return { ...base, data };
+    }
+    async accessState(registration, currentUser) {
+        const context = RequestContext.get();
+        const user = String(getStringIds(currentUser?.id));
+        const scope = context?.tenantId
+            ? [context.tenantId]
+            : context?.tenantIds
+                ? [...context.tenantIds].map(String).sort()
+                : context?.isAdminBypass
+                    ? ['*']
+                    : [];
+        const fingerprint = stableHash([
+            user,
+            scope,
+            [...(Array.isArray(currentUser?.roles) ? currentUser.roles : [])].map(String).sort(),
+            context?.tenantRole ?? null,
+            !!(currentUser?.verified || currentUser?.verifiedAt || currentUser?.emailVerified),
+        ]);
+        const tenants = registration.tenantScoped && scope.length ? scope : ['-'];
+        const keys = tenants.flatMap((tenant) => [
+            CoreSyncStateStore.tenantEpochKey(registration.name, tenant),
+            ...(registration.scope.length ? [CoreSyncStateStore.userEpochKey(registration.name, tenant, user)] : []),
+        ]);
+        const epochs = await this.storeCall(() => this.stateStore.epochs(keys));
+        return { epochs: stableHash([...epochs.entries()].sort(([a], [b]) => a.localeCompare(b))), fingerprint, user };
+    }
+    async push(model, body, currentUser) {
+        const registration = this.registration(model);
+        const items = this.pushItems(body);
+        const results = [];
+        for (const item of items) {
+            results.push(await this.pushItem(registration, item, currentUser));
+        }
+        return { results };
+    }
+    pushItems(body) {
+        const invalid = (reason) => new BadRequestException(`${ErrorCode.SYNC_INVALID_REQUEST}: ${reason}`);
+        const items = body?.items;
+        if (!Array.isArray(items)) {
+            throw invalid('the body must be { "items": [ … ] }');
+        }
+        const max = positiveNumber(this.config.push?.maxItems, SYNC_DEFAULTS.maxItems);
+        if (items.length > max) {
+            throw invalid(`at most ${max} items per push`);
+        }
+        return items.map((item, index) => {
+            const at = `items[${index}]`;
+            if (!item || typeof item !== 'object' || Array.isArray(item)) {
+                throw invalid(`${at} must be an object`);
+            }
+            const { baseVersion, data, fields, id, mutationId, op } = item;
+            if (typeof mutationId !== 'string' || !mutationId || mutationId.length > MAX_MUTATION_ID_LENGTH) {
+                throw invalid(`${at}.mutationId must be a string of 1 to ${MAX_MUTATION_ID_LENGTH} characters`);
+            }
+            if (op !== 'upsert' && op !== 'delete') {
+                throw invalid(`${at}.op must be "upsert" or "delete"`);
+            }
+            if (typeof id !== 'string' || !id || id.length > MAX_ID_LENGTH) {
+                throw invalid(`${at}.id must be a string of 1 to ${MAX_ID_LENGTH} characters`);
+            }
+            if (baseVersion !== undefined && (!Number.isInteger(baseVersion) || baseVersion < 1)) {
+                throw invalid(`${at}.baseVersion must be a positive integer`);
+            }
+            if (op === 'upsert' && (!data || typeof data !== 'object' || Array.isArray(data))) {
+                throw invalid(`${at}.data must be an object`);
+            }
+            if (fields !== undefined && (!Array.isArray(fields) || fields.some((field) => typeof field !== 'string'))) {
+                throw invalid(`${at}.fields must be a list of field names`);
+            }
+            return {
+                ...(baseVersion === undefined ? {} : { baseVersion: baseVersion }),
+                ...(op === 'upsert' ? { data: data } : {}),
+                ...(fields === undefined ? {} : { fields: fields }),
+                id,
+                mutationId,
+                op,
+            };
+        });
+    }
+    async pushItem(registration, item, currentUser) {
+        if (!isSyncId(item.id, registration.idFormat)) {
+            return reply(item, 'rejected', { code: 'INVALID_ID' });
+        }
+        const key = CoreSyncMutationStore.key(registration.name, String(getStringIds(currentUser?.id)), item.id, item.mutationId);
+        let claim;
+        try {
+            claim = await this.mutationStore.claim(key);
+        }
+        catch (error) {
+            this.logger.warn(`Sync: mutation store unavailable (${error?.message ?? error})`);
+            return reply(item, 'retry');
+        }
+        if (claim.kind === 'busy') {
+            return reply(item, 'retry');
+        }
+        if (claim.kind === 'done') {
+            return this.repeatedResult(registration, item, claim.outcome, currentUser);
+        }
+        let result;
+        try {
+            result = await this.applyItem(registration, item, currentUser);
+        }
+        catch (error) {
+            this.logger.warn(`Sync: ${registration.name} ${item.id} not applied, client retries (${error?.message ?? error})`);
+            result = reply(item, 'retry');
+        }
+        try {
+            if (result.status === 'retry') {
+                await this.mutationStore.release(key);
+            }
+            else {
+                await this.mutationStore.complete(key, { code: result.code, status: result.status, version: result.version });
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Sync: outcome of a mutation not recorded (${error?.message ?? error})`);
+        }
+        return result;
+    }
+    async repeatedResult(registration, item, outcome, currentUser) {
+        const result = reply(item, outcome.status, {
+            ...(outcome.code ? { code: outcome.code } : {}),
+            ...(outcome.version === undefined ? {} : { version: outcome.version }),
+        });
+        if (outcome.status === 'conflict' || outcome.status === 'merged') {
+            const record = await this.findVisible(registration, item.id, currentUser).catch(() => undefined);
+            if (record) {
+                result.record = record;
+                result.version = record.version;
+            }
+        }
+        return result;
+    }
+    async applyItem(registration, item, currentUser) {
+        const current = await this.findVisible(registration, item.id, currentUser);
+        if (item.op === 'delete') {
+            return this.applyDelete(registration, item, current, currentUser);
+        }
+        if (item.baseVersion === undefined) {
+            return current ? conflict(item, current) : this.applyCreate(registration, item, currentUser);
+        }
+        if (!current) {
+            return reply(item, 'not_found');
+        }
+        if (current.deletedAt) {
+            return conflict(item, current);
+        }
+        return this.applyUpdate(registration, item, currentUser);
+    }
+    async applyCreate(registration, item, currentUser) {
+        let input;
+        try {
+            input = await this.validateInput(registration.createInput, item.data);
+        }
+        catch (error) {
+            return this.writeFailure(registration, item, error, currentUser);
+        }
+        if (registration.tenantScoped && resolveTenantScope().kind === 'tenants') {
+            return reply(item, 'rejected', { code: 'FORBIDDEN' });
+        }
+        try {
+            await registration.service.create(input, {
+                createId: item.id,
+                currentUser,
+                inputType: registration.createInput,
+                roles: [...registration.roles.create],
+            });
+            return reply(item, 'applied', { version: 1 });
+        }
+        catch (error) {
+            return this.writeFailure(registration, item, error, currentUser);
+        }
+    }
+    async applyUpdate(registration, item, currentUser) {
+        let input;
+        try {
+            input = await this.validateInput(registration.updateInput, item.data);
+        }
+        catch (error) {
+            return this.writeFailure(registration, item, error, currentUser);
+        }
+        try {
+            await this.update(registration, item.id, input, item.baseVersion, currentUser);
+            return reply(item, 'applied', { version: item.baseVersion + 1 });
+        }
+        catch (error) {
+            if (error instanceof VersionConflictError) {
+                return this.resolveUpdateConflict(registration, item, input, currentUser);
+            }
+            if (error instanceof NotFoundException) {
+                const now = await this.findVisible(registration, item.id, currentUser);
+                return now ? conflict(item, now) : reply(item, 'not_found');
+            }
+            return this.writeFailure(registration, item, error, currentUser);
+        }
+    }
+    async resolveUpdateConflict(registration, item, input, currentUser) {
+        switch (registration.strategy) {
+            case 'lww':
+                return this.reapply(registration, item, input, 'applied', currentUser);
+            case 'merge': {
+                const changed = (item.fields ?? Object.keys(item.data ?? {})).filter((field) => field in input);
+                if (changed.some((field) => registration.fieldStrategies[field] === 'reject')) {
+                    return this.currentConflict(registration, item, currentUser);
+                }
+                return this.reapply(registration, item, pick(input, changed), 'merged', currentUser);
+            }
+            case 'custom':
+                return this.applyCustom(registration, item, currentUser);
+            default:
+                return this.currentConflict(registration, item, currentUser);
+        }
+    }
+    async applyDelete(registration, item, current, currentUser) {
+        if (item.baseVersion === undefined) {
+            return reply(item, 'rejected', {
+                code: 'VALIDATION_FAILED',
+                details: [{ constraints: { isDefined: 'baseVersion is required for a delete' }, property: 'baseVersion' }],
+            });
+        }
+        if (!current) {
+            return reply(item, 'not_found');
+        }
+        if (current.deletedAt) {
+            return reply(item, 'applied', { version: current.version });
+        }
+        try {
+            await this.remove(registration, item.id, item.baseVersion, currentUser);
+            return reply(item, 'applied', { version: item.baseVersion + 1 });
+        }
+        catch (error) {
+            if (error instanceof VersionConflictError) {
+                switch (registration.strategy) {
+                    case 'lww':
+                        return this.reapplyDelete(registration, item, currentUser);
+                    case 'custom':
+                        return this.applyCustom(registration, item, currentUser);
+                    default:
+                        return this.currentConflict(registration, item, currentUser);
+                }
+            }
+            if (error instanceof NotFoundException) {
+                const now = await this.findVisible(registration, item.id, currentUser);
+                return now?.deletedAt ? reply(item, 'applied', { version: now.version }) : reply(item, 'not_found');
+            }
+            return this.writeFailure(registration, item, error, currentUser);
+        }
+    }
+    async applyCustom(registration, item, currentUser) {
+        const server = await this.findVisible(registration, item.id, currentUser);
+        if (!server) {
+            return reply(item, 'not_found');
+        }
+        if (server.deletedAt) {
+            return conflict(item, server);
+        }
+        const context = {
+            change: { baseVersion: item.baseVersion, data: item.data, fields: item.fields, op: item.op },
+            currentUser,
+            id: item.id,
+            model: registration.name,
+            server,
+        };
+        const resolution = await registration.service.resolveSyncConflict(context);
+        if (!resolution || 'refuse' in resolution) {
+            return reply(item, 'rejected', { code: 'CUSTOM_REFUSED' });
+        }
+        if ('delete' in resolution) {
+            return this.reapplyDelete(registration, item, currentUser);
+        }
+        let input;
+        try {
+            input = await this.validateInput(registration.updateInput, resolution.data);
+        }
+        catch (error) {
+            return this.writeFailure(registration, item, error, currentUser);
+        }
+        return this.reapply(registration, item, input, 'merged', currentUser);
+    }
+    async reapply(registration, item, input, status, currentUser) {
+        for (let attempt = 0; attempt < SYNC_REAPPLY_ATTEMPTS; attempt++) {
+            const current = await this.findVisible(registration, item.id, currentUser);
+            if (!current) {
+                return reply(item, 'not_found');
+            }
+            if (current.deletedAt) {
+                return conflict(item, current);
+            }
+            try {
+                await this.update(registration, item.id, input, current.version, currentUser);
+                if (status === 'applied') {
+                    return reply(item, 'applied', { version: current.version + 1 });
+                }
+                const record = await this.findVisible(registration, item.id, currentUser);
+                return reply(item, 'merged', { ...(record ? { record } : {}), version: current.version + 1 });
+            }
+            catch (error) {
+                if (!(error instanceof VersionConflictError) && !(error instanceof NotFoundException)) {
+                    return this.writeFailure(registration, item, error, currentUser);
+                }
+            }
+        }
+        return reply(item, 'retry');
+    }
+    async reapplyDelete(registration, item, currentUser) {
+        for (let attempt = 0; attempt < SYNC_REAPPLY_ATTEMPTS; attempt++) {
+            const current = await this.findVisible(registration, item.id, currentUser);
+            if (!current) {
+                return reply(item, 'not_found');
+            }
+            if (current.deletedAt) {
+                return reply(item, 'applied', { version: current.version });
+            }
+            try {
+                await this.remove(registration, item.id, current.version, currentUser);
+                return reply(item, 'applied', { version: current.version + 1 });
+            }
+            catch (error) {
+                if (!(error instanceof VersionConflictError) && !(error instanceof NotFoundException)) {
+                    return this.writeFailure(registration, item, error, currentUser);
+                }
+            }
+        }
+        return reply(item, 'retry');
+    }
+    async currentConflict(registration, item, currentUser) {
+        const current = await this.findVisible(registration, item.id, currentUser);
+        return current ? conflict(item, current) : reply(item, 'not_found');
+    }
+    update(registration, id, input, expectedVersion, currentUser) {
+        return registration.service.update(id, input, {
+            currentUser,
+            expectedVersion,
+            inputType: registration.updateInput,
+            roles: [...registration.roles.update],
+        });
+    }
+    remove(registration, id, expectedVersion, currentUser) {
+        return registration.service.delete(id, { currentUser, expectedVersion, roles: [...registration.roles.delete] });
+    }
+    async findVisible(registration, id, currentUser) {
+        const [raw] = (await this.readSystemFields(registration, [id])).values();
+        if (!raw) {
+            return undefined;
+        }
+        try {
+            const record = await registration.service.get(String(raw.id), {
+                currentUser,
+                includeTombstones: true,
+                roles: [...registration.roles.pull],
+            });
+            return this.toSyncRecord(registration, record, raw, currentUser);
+        }
+        catch (error) {
+            if (error instanceof NotFoundException ||
+                error instanceof ForbiddenException ||
+                error instanceof UnauthorizedException) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async validateInput(inputType, data) {
+        const value = await new MapAndValidatePipe().transform(data && typeof data === 'object' ? { ...data } : {}, { metatype: inputType, type: 'body' });
+        return { ...value };
+    }
+    async writeFailure(registration, item, error, currentUser) {
+        if ((error instanceof DuplicateKeyError && error.primaryKey) || isDuplicateIdError(error)) {
+            const now = await this.findVisible(registration, item.id, currentUser);
+            return now ? conflict(item, now) : reply(item, 'rejected', { code: 'ID_UNAVAILABLE' });
+        }
+        if (error instanceof ForbiddenException || error instanceof UnauthorizedException) {
+            return reply(item, 'rejected', { code: 'FORBIDDEN' });
+        }
+        if (error instanceof BadRequestException) {
+            const response = error.getResponse();
+            const details = error instanceof DuplicateKeyError
+                ? undefined
+                : response && typeof response === 'object'
+                    ? omit(response, ['error', 'statusCode'])
+                    : undefined;
+            return reply(item, 'rejected', { code: 'VALIDATION_FAILED', ...(details ? { details } : {}) });
+        }
+        if (error instanceof QueryCastError || error instanceof UnsupportedQueryError || isMongoDuplicate(error)) {
+            return reply(item, 'rejected', { code: 'VALIDATION_FAILED' });
+        }
+        throw error;
+    }
+    async rateLimit(kind, currentUser) {
+        const all = this.config.rateLimit;
+        const own = all === false ? false : all?.[kind];
+        if (own === false) {
+            return undefined;
+        }
+        const defaults = kind === 'pull' ? SYNC_DEFAULTS.rateLimitPull : SYNC_DEFAULTS.rateLimitPush;
+        const max = positiveNumber(own?.max, defaults.max);
+        const windowSeconds = positiveNumber(own?.windowSeconds, defaults.windowSeconds);
+        const hit = await this.getRateLimitStore().hit(`${kind}:${String(getStringIds(currentUser?.id))}`, windowSeconds);
+        return hit.count > max ? Math.max(1, hit.resetIn) : undefined;
+    }
+    getRateLimitStore() {
+        this.rateLimitStore ??= this.redisService?.enabled
+            ? new RedisRateLimitStore(this.redisService, 'sync')
+            : new InMemoryRateLimitStore(10_000);
+        return this.rateLimitStore;
+    }
+    assertPushRequest(request) {
+        const contentType = String(request?.headers?.['content-type'] ?? '');
+        if (!/^application\/json\b/i.test(contentType)) {
+            throw new BadRequestException(`${ErrorCode.SYNC_INVALID_REQUEST}: Content-Type must be application/json`);
+        }
+        const config = ConfigService.configFastButReadOnly ?? {};
+        if (!isCookiesEnabled(config.cookies)) {
+            return;
+        }
+        if (String(request?.headers?.['sec-fetch-site'] ?? '').toLowerCase() === 'cross-site') {
+            throw new ForbiddenException(ErrorCode.SYNC_ORIGIN_REFUSED);
+        }
+        const origin = request?.headers?.origin;
+        if (typeof origin === 'string' && origin && !this.isTrustedOrigin(origin)) {
+            throw new ForbiddenException(ErrorCode.SYNC_ORIGIN_REFUSED);
+        }
+    }
+    isTrustedOrigin(origin) {
+        const config = ConfigService.configFastButReadOnly ?? {};
+        const cors = buildCorsConfig(config);
+        if (cors.origin === true) {
+            return true;
+        }
+        const corsConfig = typeof config.cors === 'object' ? config.cors : {};
+        const { appUrl, baseUrl } = resolveServerUrls({
+            appUrl: config.appUrl,
+            baseUrl: config.baseUrl,
+            deriveAppUrl: corsConfig?.deriveAppUrl,
+            env: config.env,
+        });
+        const trusted = new Set(Array.isArray(cors.origin) ? cors.origin : []);
+        for (const url of [appUrl, baseUrl]) {
+            const value = originOf(url);
+            if (value) {
+                trusted.add(value);
+            }
+        }
+        return trusted.has(originOf(origin) ?? origin);
+    }
+    async bumpAccessEpoch(model, tenantId, userId) {
+        const tenant = tenantId ?? '-';
+        await this.stateStore.bump(userId
+            ? CoreSyncStateStore.userEpochKey(model, tenant, userId)
+            : CoreSyncStateStore.tenantEpochKey(model, tenant));
+    }
+    async recordMoved(move) {
+        if (!this.models.has(move.model)) {
+            return;
+        }
+        if (move.tenantChanged) {
+            await this.bumpAccessEpoch(move.model, move.tenantId);
+        }
+        for (const user of move.usersLost) {
+            await this.bumpAccessEpoch(move.model, move.tenantId, user);
+        }
+    }
+    async tenantInvalidated(tenantId) {
+        for (const registration of this.models.values()) {
+            if (registration.tenantScoped) {
+                await this.bumpAccessEpoch(registration.name, tenantId);
+            }
+        }
+    }
+    advanceHorizon(model, at) {
+        return this.stateStore.advanceHorizon(model, at);
+    }
+    recordChanged(change) {
+        this.notifyChange(change.model, change.tenantIds);
+    }
+    notifyChange(model, tenantIds = []) {
+        if (!this.models.has(model)) {
+            return;
+        }
+        this.hintService?.notify(model, tenantIds.length ? tenantIds : [undefined]);
+    }
+    hintsEnabled(channel) {
+        const hints = this.config.hints;
+        if (hints === false || !this.hintService?.enabled) {
+            return false;
+        }
+        if (hints && typeof hints === 'object' && hints[channel] === false) {
+            return false;
+        }
+        return channel === 'sse' || ConfigService.configFastButReadOnly?.graphQl !== false;
+    }
+    async hintFilter(currentUser, models) {
+        const everywhere = Symbol('everywhere');
+        const scopes = new Map();
+        const wanted = models?.length ? new Set(models) : undefined;
+        for (const registration of this.models.values()) {
+            if (wanted && !wanted.has(registration.name)) {
+                continue;
+            }
+            try {
+                await registration.service.checkRights(undefined, currentUser, { roles: [...registration.roles.pull] });
+            }
+            catch {
+                continue;
+            }
+            const tenants = registration.tenantScoped ? allowedTenantIds(registration.name) : undefined;
+            scopes.set(registration.name, tenants === undefined ? everywhere : [...tenants].map(String));
+        }
+        return (hint) => {
+            const scope = scopes.get(hint.model);
+            if (scope === undefined) {
+                return false;
+            }
+            return scope === everywhere || (!!hint.tenantId && scope.includes(hint.tenantId));
+        };
+    }
+    hintPayload(hint) {
+        return { at: new Date(hint.at), model: hint.model };
+    }
+    async openHintStream(request, response, currentUser, models) {
+        const accepts = await this.hintFilter(currentUser, models);
+        const context = RequestContext.get();
+        const carrier = {};
+        const closeListeners = [];
+        let closed = false;
+        let unsubscribe = () => undefined;
+        let keepalive;
+        const write = (chunk) => {
+            if (!closed) {
+                response.write(chunk);
+                response.flush?.();
+            }
+        };
+        const end = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            unsubscribe();
+            if (keepalive) {
+                clearInterval(keepalive);
+            }
+            for (const listener of closeListeners.splice(0)) {
+                listener();
+            }
+            response.end?.();
+        };
+        request?.once?.('close', end);
+        response.once?.('close', end);
+        registerWsConnection({
+            carrier,
+            reauthenticate: () => undefined,
+            socket: {
+                close: () => end(),
+                once: (event, listener) => {
+                    if (event === 'close') {
+                        closeListeners.push(listener);
+                    }
+                },
+            },
+            user: currentUser,
+        });
+        const connection = getWsConnection(carrier);
+        if (connection && context) {
+            noteWsConnectionTenant(connection, {
+                isAdminBypass: context.isAdminBypass,
+                tenantId: context.tenantId,
+                tenantIds: context.tenantIds,
+                tenantRole: context.tenantRole,
+            });
+        }
+        if (request?.destroyed || response?.destroyed || response?.writableEnded) {
+            end();
+            return;
+        }
+        response.status?.(200);
+        response.setHeader?.('Content-Type', 'text/event-stream; charset=utf-8');
+        response.setHeader?.('Cache-Control', 'no-cache, no-transform');
+        response.setHeader?.('Connection', 'keep-alive');
+        response.setHeader?.('X-Accel-Buffering', 'no');
+        response.flushHeaders?.();
+        write('retry: 3000\n: hints\n\n');
+        unsubscribe =
+            this.hintService?.subscribe((hint) => {
+                if (closed || !accepts(hint)) {
+                    return;
+                }
+                const deliver = () => write(`event: change\ndata: ${JSON.stringify(this.hintPayload(hint))}\n\n`);
+                if (!connection) {
+                    deliver();
+                    return;
+                }
+                void ensureWsConnectionCurrent(connection).then((current) => {
+                    if (current) {
+                        deliver();
+                    }
+                });
+            }) ?? unsubscribe;
+        keepalive = setInterval(() => {
+            if (response?.destroyed || response?.writableEnded) {
+                end();
+                return;
+            }
+            write(': keepalive\n\n');
+        }, SYNC_HINT_KEEPALIVE_MS);
+        keepalive.unref?.();
+    }
+    async hintIterator(currentUser, models) {
+        const accepts = await this.hintFilter(currentUser, models);
+        const queue = [];
+        const waiting = [];
+        let done = false;
+        const unsubscribe = this.hintService?.subscribe((hint) => {
+            if (done || !accepts(hint)) {
+                return;
+            }
+            const value = { syncHint: this.hintPayload(hint) };
+            const next = waiting.shift();
+            if (next) {
+                next({ done: false, value });
+            }
+            else if (queue.length < 100) {
+                queue.push(value);
+            }
+        }) ?? (() => undefined);
+        const finish = () => {
+            done = true;
+            unsubscribe();
+            for (const next of waiting.splice(0)) {
+                next({ done: true, value: undefined });
+            }
+            queue.length = 0;
+            return { done: true, value: undefined };
+        };
+        const iterator = {
+            next: () => {
+                if (done) {
+                    return Promise.resolve({ done: true, value: undefined });
+                }
+                const value = queue.shift();
+                return value ? Promise.resolve({ done: false, value }) : new Promise((resolve) => waiting.push(resolve));
+            },
+            return: () => Promise.resolve(finish()),
+            throw: (error) => {
+                finish();
+                return Promise.reject(error);
+            },
+            [Symbol.asyncIterator]() {
+                return iterator;
+            },
+        };
+        return iterator;
+    }
+    tombstoneDays() {
+        const value = this.config.retention?.tombstonesDays;
+        if (value === false) {
+            return false;
+        }
+        return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : SYNC_DEFAULTS.tombstonesDays;
+    }
+    schedulePurge() {
+        if (this.purgeTimer || this.tombstoneDays() === false) {
+            return;
+        }
+        const run = () => {
+            this.purgeRunning ??= this.leasedPurge().finally(() => {
+                this.purgeRunning = undefined;
+            });
+        };
+        run();
+        this.purgeTimer = setInterval(run, this.purgeIntervalMs);
+        this.purgeTimer.unref?.();
+    }
+    async leasedPurge() {
+        try {
+            const locks = await this.purgeLeaseStore();
+            const ttlSeconds = Math.max(1, Math.floor(this.purgeIntervalMs / 1000));
+            if (locks && !(await locks.tryAcquire('sync-purge', this.purgeOwner, ttlSeconds))) {
+                return;
+            }
+            await this.purgeTombstones();
+        }
+        catch (error) {
+            this.logger.warn(`Sync tombstone purge failed, trying again later: ${error?.message ?? error}`);
+        }
+    }
+    async purgeLeaseStore() {
+        if (this.redisService?.enabled) {
+            const client = this.redisService.getClient();
+            const key = (name) => this.redisService.key('sync-lock', name);
+            return {
+                release: async () => false,
+                renew: async () => false,
+                tryAcquire: async (name, owner, ttlSeconds) => (await client.set(key(name), owner, 'EX', ttlSeconds, 'NX')) === 'OK',
+            };
+        }
+        const sqlLocks = await defaultSqlLockStore('sync');
+        if (sqlLocks) {
+            return sqlLocks;
+        }
+        const connection = getCronJobsInfrastructure().connection;
+        return connection?.db ? cronMongoLocks(connection.db.collection(CRON_LOCK_COLLECTION)) : undefined;
+    }
+    async purgeTombstones(options = {}) {
+        const days = this.tombstoneDays();
+        if (!options.before && days === false) {
+            return {};
+        }
+        const before = options.before ?? new Date(Date.now() - days * 86_400_000);
+        const removed = {};
+        for (const registration of this.models.values()) {
+            if (options.model && registration.name !== options.model) {
+                continue;
+            }
+            await this.stateStore.advanceHorizon(registration.name, before);
+            removed[registration.name] = await this.purgeModel(registration, before);
+        }
+        const total = Object.values(removed).reduce((sum, count) => sum + count, 0);
+        if (total) {
+            this.logger.log(`Sync: ${total} tombstone(s) older than ${before.toISOString()} removed`);
+        }
+        return removed;
+    }
+    async purgeModel(registration, before) {
+        let removed = 0;
+        let after;
+        for (;;) {
+            const batch = await registration.store.find({ deletedAt: { $lt: before }, ...(after ? { id: { $gt: after } } : {}) }, { includeTombstones: true, limit: SYNC_PURGE_BATCH, select: ['id'], sort: { id: 1 } });
+            if (!batch.length) {
+                return removed;
+            }
+            removed += await registration.store.deleteMany({ deletedAt: { $lt: before }, id: { $in: batch.map((record) => record.id) } }, { hardDelete: true, includeTombstones: true });
+            if (batch.length < SYNC_PURGE_BATCH) {
+                return removed;
+            }
+            after = batch[batch.length - 1].id;
+        }
+    }
+    resync(reason) {
+        throw new SyncResyncRequiredException(reason);
+    }
+    async storeCall(call) {
+        try {
+            return await call();
+        }
+        catch (error) {
+            if (error instanceof HttpException) {
+                throw error;
+            }
+            this.logger.error(`Sync: store unavailable (${error?.message ?? error})`, error?.stack);
+            throw new ServiceUnavailableException(ErrorCode.SYNC_STORE_UNAVAILABLE);
+        }
+    }
+};
+CoreSyncService = CoreSyncService_1 = __decorate([
+    Injectable(),
+    __param(0, InjectStore(SYNC_MUTATION_MODEL)),
+    __param(1, InjectStore(SYNC_STATE_MODEL)),
+    __param(4, Optional()),
+    __param(5, Optional()),
+    __metadata("design:paramtypes", [Object, Object, DiscoveryService,
+        ModuleRef,
+        CoreRedisService,
+        CoreSyncHintService])
+], CoreSyncService);
+export { CoreSyncService };
+function reply(item, status, extra = {}) {
+    return { id: item.id, mutationId: item.mutationId, status, ...extra };
+}
+function conflict(item, record) {
+    return reply(item, 'conflict', { record, version: record.version });
+}
+function recordId(record) {
+    const id = record?.id ?? record?._id;
+    return id === undefined || id === null ? '' : String(getStringIds(id));
+}
+function initialPosition(order) {
+    return order === 'seq' ? { seq: 0 } : { at: 0, id: '' };
+}
+function pick(input, fields) {
+    return Object.fromEntries(fields.filter((field) => field in input).map((field) => [field, input[field]]));
+}
+function omit(value, keys) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !keys.includes(key)));
+}
+function positiveNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function originOf(url) {
+    if (!url) {
+        return undefined;
+    }
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:' ? parsed.origin : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isMongoDuplicate(error) {
+    return error?.code === 11000;
+}
+//# sourceMappingURL=core-sync.service.js.map