chuvsu-js 5.1.1 → 5.1.2

package/dist/tt/client.js

@@ -123,6 +123,8 @@ export class TimetableClient {
         for (let attempt = 0; attempt < 4; attempt++) {
             const expectedRevision = this._repository.revision;
             const result = mutate(this._repository);
+            if (this._repository.revision === expectedRevision)
+                return result;
             if (!this.repositoryAdapter)
                 return result;
             if (await this.repositoryAdapter.compareAndSet(expectedRevision, this._repository.export())) {
@@ -363,17 +365,18 @@ export class TimetableClient {
             period,
             days: await this.fetchOwnerSchedule(resolvedOwner, period, context.academicYearStartYear),
         })));
-        for (const result of results) {
-            const currentOwner = this.resolveOwner(resolvedOwner);
-            const snapshot = createScheduleSourceSnapshot({
-                sourceKey: this.sourceKey(currentOwner, result.period, context.academicYearStartYear),
-                owner: currentOwner,
-                academicYearStartYear: context.academicYearStartYear,
-                period: result.period,
-                days: result.days,
-            });
-            await this.mutateRepository((repository) => repository.ingest(snapshot));
-        }
+        await this.mutateRepository((repository) => {
+            for (const result of results) {
+                const currentOwner = this.resolveOwner(resolvedOwner);
+                repository.ingest(createScheduleSourceSnapshot({
+                    sourceKey: this.sourceKey(currentOwner, result.period, context.academicYearStartYear),
+                    owner: currentOwner,
+                    academicYearStartYear: context.academicYearStartYear,
+                    period: result.period,
+                    days: result.days,
+                }));
+            }
+        });
         return new Schedule(this._repository, this.resolveOwner(resolvedOwner), context.academicYearStartYear, { period: periods.length === 1 ? periods[0] : context.period });
     }
     async getGroupSchedule(groupId, options) {

package/dist/tt/domain/repository.d.ts

@@ -8,6 +8,8 @@ export declare class TimetableRepository {
     private readonly links;
     private readonly seriesRecords;
     private readonly occurrenceRecords;
+    private readonly recordIdsByBucket;
+    private readonly recordIdsByOwner;
     private _revision;
     constructor(opts?: {
         idGenerator?: LessonIdGenerator;
@@ -39,6 +41,14 @@ export declare class TimetableRepository {
     private addClaim;
     private findPriorTarget;
     private findCanonicalTarget;
+    private addRecordToBucket;
+    private ownerReferenceKeys;
+    private claimOwnerKeys;
+    private addClaimOwnerKeys;
+    private removeRecordOwnerIndex;
+    private rebuildRecordOwnerIndex;
+    private removeRecordIndexes;
+    private recordsForOwner;
     private aggregateSubstitutions;
     private aggregateSeries;
     private aggregateOccurrence;

package/dist/tt/domain/repository.js

@@ -8,6 +8,12 @@ function claimKey(sourceKey, observationKey) {
 function sourceObservationKey(sourceKey, observationKey) {
     return claimKey(sourceKey, observationKey);
 }
+function canonicalBucketKey(observation, source) {
+    const prefix = `${source.academicYearStartYear}:${source.period}:${observation.kind}:${normalizeScheduleText(observation.subject)}`;
+    return observation.kind === "series"
+        ? `${prefix}:${observation.recurrence.weekday}:${recurrenceWeeks(observation)}`
+        : `${prefix}:${observation.date}`;
+}
 function sameDate(a, b) {
     return a === b;
 }
@@ -144,6 +150,13 @@ function deserializeSource(source) {
         observations: source.observations.map(deserializeObservation),
     };
 }
+function sameSourceContent(left, right) {
+    return left.sourceKey === right.sourceKey &&
+        left.academicYearStartYear === right.academicYearStartYear &&
+        left.period === right.period &&
+        JSON.stringify(left.owner) === JSON.stringify(right.owner) &&
+        JSON.stringify(left.observations) === JSON.stringify(right.observations);
+}
 function sourceRef(claim) {
     return {
         sourceKey: claim.source.sourceKey,
@@ -267,6 +280,8 @@ export class TimetableRepository {
     links = new Map();
     seriesRecords = new Map();
     occurrenceRecords = new Map();
+    recordIdsByBucket = new Map();
+    recordIdsByOwner = new Map();
     _revision = 0;
     constructor(opts) {
         this.idGenerator = opts?.idGenerator ?? new RandomLessonIdGenerator();
@@ -297,6 +312,17 @@ export class TimetableRepository {
         this.validateSource(incoming);
         this.rememberSourceEntities(incoming);
         const prior = this.sources.get(incoming.sourceKey);
+        if (prior && sameSourceContent(prior, incoming)) {
+            const links = incoming.observations.map((observation) => this.links.get(sourceObservationKey(incoming.sourceKey, observation.key)));
+            return {
+                revision: this._revision,
+                seriesIds: links.flatMap((link) => link?.kind === "series" ? [link.id] : []),
+                lessonIds: links.flatMap((link) => link?.kind === "occurrence" ? [link.id] : []),
+                created: 0,
+                updated: incoming.observations.length,
+                removedObservations: 0,
+            };
+        }
         const priorClaims = new Map();
         if (prior) {
             for (const observation of prior.observations) {
@@ -365,7 +391,7 @@ export class TimetableRepository {
     }
     getSeries(opts) {
         const values = [];
-        for (const record of this.seriesRecords.values()) {
+        for (const record of this.recordsForOwner(this.seriesRecords, opts?.owner)) {
             if (record.claims.size === 0)
                 continue;
             const value = this.aggregateSeries(record);
@@ -387,7 +413,7 @@ export class TimetableRepository {
     }
     getDirectOccurrences(opts) {
         const values = [];
-        for (const record of this.occurrenceRecords.values()) {
+        for (const record of this.recordsForOwner(this.occurrenceRecords, opts?.owner)) {
             if (record.claims.size === 0)
                 continue;
             const value = this.aggregateOccurrence(record);
@@ -450,6 +476,8 @@ export class TimetableRepository {
         this.links.clear();
         this.seriesRecords.clear();
         this.occurrenceRecords.clear();
+        this.recordIdsByBucket.clear();
+        this.recordIdsByOwner.clear();
         this._directory = new TimetableDirectory(snapshot.directory);
         this._revision = snapshot.revision;
         for (const source of sources) {
@@ -601,12 +629,16 @@ export class TimetableRepository {
     }
     pruneEmptyRecords() {
         for (const [id, record] of this.seriesRecords) {
-            if (record.claims.size === 0)
+            if (record.claims.size === 0) {
+                this.removeRecordIndexes(record);
                 this.seriesRecords.delete(id);
+            }
         }
         for (const [id, record] of this.occurrenceRecords) {
-            if (record.claims.size === 0)
+            if (record.claims.size === 0) {
+                this.removeRecordIndexes(record);
                 this.occurrenceRecords.delete(id);
+            }
         }
     }
     removeClaim(sourceKey, observationKey) {
@@ -616,25 +648,39 @@ export class TimetableRepository {
         const record = link.kind === "series"
             ? this.seriesRecords.get(link.id)
             : this.occurrenceRecords.get(link.id);
-        record?.claims.delete(claimKey(sourceKey, observationKey));
+        if (!record)
+            return;
+        record.claims.delete(claimKey(sourceKey, observationKey));
+        this.rebuildRecordOwnerIndex(record);
     }
     addClaim(link, source, observation) {
         const key = claimKey(source.sourceKey, observation.key);
+        const bucketKey = canonicalBucketKey(observation, source);
         if (link.kind === "series" && observation.kind === "series") {
             let record = this.seriesRecords.get(link.id);
             if (!record) {
-                record = { id: link.id, claims: new Map() };
+                record = { id: link.id, claims: new Map(), bucketKey, ownerKeys: new Set() };
                 this.seriesRecords.set(link.id, record);
+                this.addRecordToBucket(record);
+            }
+            if (record.bucketKey !== bucketKey) {
+                throw new Error(`Incompatible timetable series link: ${link.id}`);
             }
             record.claims.set(key, { source, observation });
+            this.addClaimOwnerKeys(record, source, observation);
         }
         if (link.kind === "occurrence" && observation.kind === "occurrence") {
             let record = this.occurrenceRecords.get(link.id);
             if (!record) {
-                record = { id: link.id, claims: new Map() };
+                record = { id: link.id, claims: new Map(), bucketKey, ownerKeys: new Set() };
                 this.occurrenceRecords.set(link.id, record);
+                this.addRecordToBucket(record);
+            }
+            if (record.bucketKey !== bucketKey) {
+                throw new Error(`Incompatible timetable occurrence link: ${link.id}`);
             }
             record.claims.set(key, { source, observation });
+            this.addClaimOwnerKeys(record, source, observation);
         }
     }
     findPriorTarget(observation, prior, usedTargets) {
@@ -657,12 +703,18 @@ export class TimetableRepository {
         return best && best.score >= 55 && !tied ? best.link : undefined;
     }
     findCanonicalTarget(observation, source, usedTargets) {
-        const records = observation.kind === "series"
-            ? this.seriesRecords.values()
-            : this.occurrenceRecords.values();
+        const recordMap = observation.kind === "series"
+            ? this.seriesRecords
+            : this.occurrenceRecords;
+        const candidateIds = this.recordIdsByBucket.get(canonicalBucketKey(observation, source));
+        if (!candidateIds)
+            return undefined;
         let best;
         let second = Number.NEGATIVE_INFINITY;
-        for (const record of records) {
+        for (const id of candidateIds) {
+            const record = recordMap.get(id);
+            if (!record)
+                continue;
             if (usedTargets.has(record.id) || record.claims.size === 0)
                 continue;
             let recordScore = Number.NEGATIVE_INFINITY;
@@ -686,6 +738,102 @@ export class TimetableRepository {
             return undefined;
         return { kind: observation.kind, id: best.id };
     }
+    addRecordToBucket(record) {
+        let ids = this.recordIdsByBucket.get(record.bucketKey);
+        if (!ids) {
+            ids = new Set();
+            this.recordIdsByBucket.set(record.bucketKey, ids);
+        }
+        ids.add(record.id);
+    }
+    ownerReferenceKeys(kind, value) {
+        const resolved = kind === "group"
+            ? this.directory.resolveGroup(value)
+            : kind === "teacher"
+                ? this.directory.resolveTeacher(value)
+                : this.directory.resolveRoom(value);
+        const keys = new Set();
+        for (const reference of [value, resolved]) {
+            if (reference.id != null)
+                keys.add(`${kind}:id:${reference.id}`);
+            const name = normalizeScheduleText(reference.name);
+            if (name)
+                keys.add(`${kind}:name:${name}`);
+        }
+        return [...keys];
+    }
+    claimOwnerKeys(source, observation) {
+        const keys = new Set();
+        const add = (kind, value) => {
+            for (const key of this.ownerReferenceKeys(kind, value))
+                keys.add(key);
+        };
+        if (source.owner.type === "group")
+            add("group", source.owner.group);
+        if (source.owner.type === "teacher")
+            add("teacher", source.owner.teacher);
+        if (source.owner.type === "room")
+            add("room", source.owner.room);
+        for (const value of observation.groups.values)
+            add("group", value.group);
+        for (const value of observation.teachers.values)
+            add("teacher", value);
+        for (const value of observation.rooms.values)
+            add("room", value);
+        return keys;
+    }
+    addClaimOwnerKeys(record, source, observation) {
+        for (const key of this.claimOwnerKeys(source, observation)) {
+            record.ownerKeys.add(key);
+            let ids = this.recordIdsByOwner.get(key);
+            if (!ids) {
+                ids = new Set();
+                this.recordIdsByOwner.set(key, ids);
+            }
+            ids.add(record.id);
+        }
+    }
+    removeRecordOwnerIndex(record) {
+        for (const key of record.ownerKeys) {
+            const ids = this.recordIdsByOwner.get(key);
+            ids?.delete(record.id);
+            if (ids?.size === 0)
+                this.recordIdsByOwner.delete(key);
+        }
+        record.ownerKeys.clear();
+    }
+    rebuildRecordOwnerIndex(record) {
+        this.removeRecordOwnerIndex(record);
+        for (const claim of record.claims.values()) {
+            this.addClaimOwnerKeys(record, claim.source, claim.observation);
+        }
+    }
+    removeRecordIndexes(record) {
+        const bucketIds = this.recordIdsByBucket.get(record.bucketKey);
+        bucketIds?.delete(record.id);
+        if (bucketIds?.size === 0)
+            this.recordIdsByBucket.delete(record.bucketKey);
+        this.removeRecordOwnerIndex(record);
+    }
+    recordsForOwner(records, owner) {
+        if (!owner)
+            return records.values();
+        const kind = owner.type;
+        const reference = owner.type === "group"
+            ? owner.group
+            : owner.type === "teacher"
+                ? owner.teacher
+                : owner.room;
+        const ids = new Set();
+        for (const key of this.ownerReferenceKeys(kind, reference)) {
+            for (const id of this.recordIdsByOwner.get(key) ?? [])
+                ids.add(id);
+        }
+        return [...ids].flatMap((id) => {
+            const record = records.get(id);
+            return record ? [record] : [];
+        });
+    }
     aggregateSubstitutions(claims) {
         const byDate = new Map();
         for (const substitution of claims.flatMap((value) => value.observation.substitutions ?? [])) {

package/docs/v5-migration.md

@@ -281,6 +281,12 @@ const snapshot = await client.exportRepository();
 вместе со всеми когда-либо загруженными расписаниями, а восстановление требует
 повторной агрегации связей.
 
+Начиная с 5.1.2 поиск совпадающих занятий и выборка расписания владельца используют
+внутренние индексы, одинаковые повторные снимки не меняют ревизию, а периоды одного
+запроса сохраняются одной транзакцией адаптера. Это исключает полный обход
+репозитория из обычного пути запроса; `exportRepository()` по-прежнему имеет цену,
+пропорциональную размеру полного снимка, и не должен вызываться на клиентском пути.
+
 Для API, SSR и офлайн-кеша материализуйте только готовое расписание владельца:
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chuvsu-js",
-  "version": "5.1.1",
+  "version": "5.1.2",
   "description": "Библиотека для расписания и личного кабинета ЧГУ им. И. Н. Ульянова",
   "type": "module",
   "main": "dist/index.js",