@chronicle.app/linkedin 0.3.0

package/dist/connectors/LinkedInTransformer.js

@@ -0,0 +1,473 @@
+import { ChronicleTransformer, selfAgent } from '@chronicle.app/etl';
+import { profileUrl } from './fields.js';
+const SOURCE = 'linkedin';
+/**
+ * The one transformer for every file in the export.
+ *
+ * Two decisions run through all of it:
+ *
+ * **People key on the vanity slug.** LinkedIn never puts a member's numeric id
+ * in an export, so `/in/<slug>` is the only identifier there is. It is
+ * user-changeable, which makes it an imperfect key — but it is a real one, and
+ * the alternative is keying strangers on their display name. Each person also
+ * carries their profile URL, which mints the portable url-namespace identity
+ * that merges them with the same page seen from anywhere else.
+ *
+ * **Only what LinkedIn wrote gets written.** Where the export has no id, the
+ * key is built from the natural fields LinkedIn did provide (an organization's
+ * name, a conversation's id, a skill's name) — never from a value invented
+ * here.
+ */
+export default class LinkedInTransformer extends ChronicleTransformer {
+    async transform(record) {
+        switch (record.extraction.recordType) {
+            case 'profile': {
+                return this.buildProfile(record);
+            }
+            case 'positions': {
+                return this.buildPosition(record);
+            }
+            case 'education': {
+                return this.buildEducation(record);
+            }
+            case 'connections': {
+                return this.buildConnection(record);
+            }
+            case 'endorsements': {
+                return this.buildEndorsement(record);
+            }
+            case 'follows': {
+                return this.buildFollow(record);
+            }
+            case 'messages': {
+                return this.buildMessage(record);
+            }
+            case 'learning': {
+                return this.buildLearning(record);
+            }
+            default: {
+                return [];
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // The profile
+    // ---------------------------------------------------------------------------
+    /**
+     * Your own profile, carried by the `UpdateAction` that sighted it.
+     *
+     * The store takes actions, not loose entities, so a standing fact needs an
+     * occurrence to arrive on — the same carrier the Obsidian plugin uses for a
+     * note's subject. Its timestamp is when LinkedIn compiled the export, which
+     * is genuinely when the profile read this way, so a second import of the same
+     * directory restates the identical sighting rather than adding a new one.
+     *
+     * Everything here also rides every other record as the acting agent, so this
+     * matters most for the export that has nothing else in it.
+     */
+    buildProfile(record) {
+        const sightedAt = record.extraction.assertedAt;
+        const update = {
+            '@type': 'UpdateAction',
+            '@key': ['@type', 'source', 'object.handle', 'timestamp'],
+            source: SOURCE,
+            agent: this.self(record),
+            object: this.self(record),
+            ...(sightedAt && { timestamp: sightedAt }),
+        };
+        return [update];
+    }
+    // ---------------------------------------------------------------------------
+    // Work and school — a bounded span, told as its two boundaries
+    // ---------------------------------------------------------------------------
+    /**
+     * A job as a `JoinAction`/`LeaveAction` pair over the employer, carrying a
+     * `Tenure` as their shared result. The pair is what the fold turns into a
+     * `memberOf` run across the span; the employer is the boundary's object,
+     * never a property on the tenure.
+     *
+     * The boundaries key on the tenure and the employer, never on the date. A
+     * position whose start month you fix in a later export then revises the run
+     * you already have, instead of appearing beside it as a second job.
+     */
+    buildPosition(record) {
+        const data = record.data;
+        if (!data.company || !data.startedOn)
+            return [];
+        const employer = this.organization(data.company);
+        const tenure = {
+            '@type': 'Tenure',
+            '@key': ['@type', 'source', 'role', 'action.object.name'],
+            source: SOURCE,
+            ...(data.title && { role: data.title }),
+            ...(data.description && { description: data.description }),
+        };
+        return this.episode('JoinAction', 'LeaveAction', record, employer, tenure, data);
+    }
+    /** Schooling, in the same shape as a job: two boundaries around an `Enrollment`. */
+    buildEducation(record) {
+        const data = record.data;
+        if (!data.school || !data.startedOn)
+            return [];
+        const school = this.organization(data.school);
+        const description = [data.notes, data.activities].filter(Boolean).join('\n\n');
+        const enrollment = {
+            '@type': 'Enrollment',
+            '@key': ['@type', 'source', 'degree', 'action.object.name'],
+            source: SOURCE,
+            ...(data.degree && { degree: data.degree }),
+            ...(description && { description }),
+        };
+        return this.episode('JoinAction', 'LeaveAction', record, school, enrollment, data);
+    }
+    /** The opener, plus the closer when the span has actually ended. */
+    episode(opener, closer, record, object, result, dates) {
+        const agent = this.self(record);
+        const boundary = (type, timestamp) => ({
+            '@type': type,
+            '@key': ['@type', 'source', 'result.role', 'result.degree', 'object.name'],
+            source: SOURCE,
+            agent,
+            object,
+            timestamp,
+            result,
+        });
+        const actions = [boundary(opener, dates.startedOn)];
+        if (dates.finishedOn)
+            actions.push(boundary(closer, dates.finishedOn));
+        return actions;
+    }
+    // ---------------------------------------------------------------------------
+    // The network
+    // ---------------------------------------------------------------------------
+    /**
+     * A connection, as a dated `FollowAction` onto the other person.
+     *
+     * **This is the closest verb the ontology has, and it is not an exact fit.**
+     * A LinkedIn connection is mutual and consented; a follow is neither. What
+     * makes it defensible is that connecting on LinkedIn *does* create a follow,
+     * in both directions — so the edge recorded here is real, just not the whole
+     * of what happened. Only your side is written: this is your archive, and
+     * inventing the reciprocal edge would double every connection on the timeline
+     * to say something the row never said.
+     */
+    buildConnection(record) {
+        const data = record.data;
+        const person = this.person({
+            handle: data.handle,
+            name: data.name,
+            email: data.email,
+            // LinkedIn's own one-line descriptor of them — the title it prints under
+            // their name. Their current job, sighted now, not a dated appointment.
+            description: data.position,
+            company: data.company,
+        });
+        if (!person)
+            return [];
+        const follow = {
+            '@type': 'FollowAction',
+            '@key': ['@type', 'source', 'agent.handle', 'object.handle', 'object.name'],
+            source: SOURCE,
+            agent: this.self(record),
+            object: person,
+            ...(data.connectedOn && { timestamp: data.connectedOn }),
+        };
+        return [follow];
+    }
+    /**
+     * Following an organization — the one place `FollowAction` means exactly what
+     * it says. LinkedIn files topic pages ("Scrum", "Web Development") in the
+     * same list as real employers and gives none of them an id, so the name is
+     * both the label and the key.
+     */
+    buildFollow(record) {
+        const data = record.data;
+        if (!data.organization)
+            return [];
+        const follow = {
+            '@type': 'FollowAction',
+            '@key': ['@type', 'source', 'agent.handle', 'object.name'],
+            source: SOURCE,
+            agent: this.self(record),
+            object: this.organization(data.organization),
+            ...(data.followedAt && { timestamp: data.followedAt }),
+        };
+        return [follow];
+    }
+    /**
+     * An endorsement: one person vouching that another has a skill.
+     *
+     * `RespondAction` is the schema's verb for a reaction that carries a payload
+     * — the endorsement's payload being *which* skill — so the skill rides the
+     * result `Response` as its body and its `about`, and the action itself points
+     * at the person. A plain `LikeAction` would lose the skill, which is the only
+     * interesting part.
+     *
+     * The response keys through `action.*` onto both parties. Without that, one
+     * endorser vouching for the same skill for two different people would collapse
+     * into a single response shared by both endorsements.
+     */
+    buildEndorsement(record) {
+        const data = record.data;
+        if (!data.skill)
+            return [];
+        const other = this.person({
+            handle: data.otherHandle,
+            name: data.otherName,
+        });
+        if (!other)
+            return [];
+        const self = this.self(record);
+        const endorser = data.direction === 'given' ? self : other;
+        const endorsee = data.direction === 'given' ? other : self;
+        const skill = {
+            '@type': 'DefinedTerm',
+            '@key': ['@type', 'source', 'name'],
+            source: SOURCE,
+            name: data.skill,
+        };
+        const endorsement = {
+            '@type': 'RespondAction',
+            '@key': ['@type', 'source', 'agent.handle', 'object.handle', 'result.body'],
+            source: SOURCE,
+            agent: endorser,
+            object: endorsee,
+            ...(data.endorsedAt && { timestamp: data.endorsedAt }),
+            result: {
+                '@type': 'Response',
+                '@key': ['@type', 'source', 'action.agent.handle', 'action.object.handle', 'body'],
+                source: SOURCE,
+                body: data.skill,
+                author: [endorser],
+                about: [skill],
+            },
+        };
+        return [endorsement];
+    }
+    // ---------------------------------------------------------------------------
+    // Messages
+    // ---------------------------------------------------------------------------
+    /**
+     * One message, in the conversation LinkedIn assigned it to.
+     *
+     * The `Thread` is the only thing in the whole export with a first-class id, so
+     * it keys on that id and the messages hang off it with `isPartOf`.
+     *
+     * **Individual messages have no id.** LinkedIn ships the conversation, the
+     * moment, the sender, and the text — nothing more — so the message keys on
+     * that natural tuple and the action keys on the same. The cost is visible and
+     * accepted: two messages with identical text from one person in one thread
+     * resolve to a single `Message`, though their sends stay two distinct
+     * `MessageAction`s at their own timestamps.
+     */
+    buildMessage(record) {
+        const data = record.data;
+        if (!data.conversationId || !data.sentAt)
+            return [];
+        const thread = {
+            '@type': 'Thread',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: SOURCE,
+            sourceId: data.conversationId,
+            ...(data.conversationTitle && { name: data.conversationTitle }),
+        };
+        const sender = this.party(data.sender, record);
+        const recipients = (data.recipients ?? []).flatMap(party => this.party(party, record) ?? []);
+        const message = {
+            '@type': 'Message',
+            '@key': ['@type', 'source', 'isPartOf[*].sourceId', 'author[*].handle', 'name', 'body'],
+            source: SOURCE,
+            isPartOf: [thread],
+            ...(data.subject && { name: data.subject }),
+            ...(data.content && { body: data.content }),
+            ...(sender && { author: [sender] }),
+            ...(recipients.length > 0 && { recipient: recipients }),
+        };
+        const sent = {
+            '@type': 'MessageAction',
+            '@key': [
+                '@type',
+                'source',
+                'timestamp',
+                'object.isPartOf[*].sourceId',
+                'agent.handle',
+                'agent.name',
+            ],
+            source: SOURCE,
+            timestamp: data.sentAt,
+            ...(sender && { agent: sender }),
+            object: message,
+        };
+        return [sent];
+    }
+    // ---------------------------------------------------------------------------
+    // LinkedIn Learning
+    // ---------------------------------------------------------------------------
+    /**
+     * A course, and whichever of the three things the row records about it: you
+     * watched it, you finished it, you saved it. LinkedIn gives courses no id, so
+     * the title is the key — it is what the export identifies them by.
+     *
+     * The saved flag has no date of its own. The bookmark is emitted undated
+     * rather than borrowed from the watch, which happened at a different moment.
+     */
+    buildLearning(record) {
+        const data = record.data;
+        if (!data.title)
+            return [];
+        const agent = this.self(record);
+        const course = {
+            '@type': 'CreativeWork',
+            '@key': ['@type', 'source', 'name'],
+            source: SOURCE,
+            name: data.title,
+            ...(data.description && { description: data.description }),
+            ...(data.contentType && { sourceFormat: data.contentType.toLowerCase() }),
+        };
+        const actions = [];
+        if (data.watchedAt) {
+            actions.push({
+                '@type': 'WatchAction',
+                '@key': ['@type', 'source', 'object.name', 'timestamp'],
+                source: SOURCE,
+                agent,
+                object: course,
+                timestamp: data.watchedAt,
+            });
+        }
+        if (data.completedAt) {
+            actions.push({
+                '@type': 'CompleteAction',
+                '@key': ['@type', 'source', 'object.name', 'timestamp'],
+                source: SOURCE,
+                agent,
+                object: course,
+                timestamp: data.completedAt,
+            });
+        }
+        if (data.saved) {
+            // The export says the course is saved, not when it was saved, so the
+            // bookmark carries no occurrence. It still needs a sighting: an
+            // occurrence-less claim is otherwise timeless, which the inbox drain
+            // refuses rather than stamping drain-time. The sighting is the export's
+            // own compile time, so a re-import restates it instead of re-sighting it.
+            const sightedAt = record.extraction.assertedAt;
+            actions.push({
+                '@type': 'BookmarkAction',
+                '@key': ['@type', 'source', 'object.name'],
+                source: SOURCE,
+                agent,
+                object: course,
+                ...(sightedAt && { '@assertedAt': sightedAt }),
+            });
+        }
+        return actions;
+    }
+    // ---------------------------------------------------------------------------
+    // Shared nodes
+    // ---------------------------------------------------------------------------
+    /**
+     * The account owner.
+     *
+     * The handle comes from the export when it names one — see the extractor's
+     * note on reading it off an outgoing invitation — and otherwise the self falls
+     * back to `selfAgent`'s per-source singleton. Either way `@me` merges it onto
+     * the one person, and the primary email rides as a `sameAs` in the `email`
+     * namespace, where the mail and messaging plugins already key their people. A
+     * shared email is evidence of one person; a shared display name is not.
+     */
+    self(record) {
+        const account = (record.context?.accountInfo ?? {});
+        const sameAs = account.email
+            ? [
+                {
+                    '@type': 'Person',
+                    '@key': ['@type', 'source', 'handle'],
+                    source: 'email',
+                    handle: account.email,
+                    ...(account.name && { name: account.name }),
+                },
+            ]
+            : [];
+        return {
+            ...selfAgent({
+                source: SOURCE,
+                handle: account.handle,
+                name: account.name,
+                sameAs,
+            }),
+            ...(account.handle && { url: profileUrl(account.handle) }),
+            ...(account.headline && { description: account.headline }),
+        };
+    }
+    /**
+     * Another member. Returns nothing when LinkedIn identified them neither by
+     * slug nor by name — a row about nobody in particular is not a person.
+     *
+     * With a slug, the key is that slug and the profile URL comes along, which
+     * also mints the url-namespace identity every other source can meet them at.
+     * Without one, the display name is all that is left; it is a weak key and two
+     * namesakes will merge, but dropping the row entirely would lose a real
+     * relationship over a missing field.
+     */
+    person(fields) {
+        if (!fields.handle && !fields.name)
+            return undefined;
+        const sameAs = fields.email
+            ? [
+                {
+                    '@type': 'Person',
+                    '@key': ['@type', 'source', 'handle'],
+                    source: 'email',
+                    handle: fields.email,
+                    ...(fields.name && { name: fields.name }),
+                },
+            ]
+            : undefined;
+        return {
+            '@type': 'Person',
+            '@key': fields.handle ? ['@type', 'source', 'handle'] : ['@type', 'source', 'name'],
+            source: SOURCE,
+            ...(fields.handle && {
+                handle: fields.handle,
+                url: profileUrl(fields.handle),
+            }),
+            ...(fields.name && { name: fields.name }),
+            ...(fields.description && { description: fields.description }),
+            ...(fields.company && { memberOf: [this.organization(fields.company)] }),
+            ...(sameAs && { sameAs }),
+        };
+    }
+    /**
+     * A message party, which is a person LinkedIn may have declined to name.
+     *
+     * You are a party to every message in your own export, so a party whose slug
+     * is your own resolves to the self node rather than to a stranger who happens
+     * to share your key. Both spellings key identically and would merge anyway;
+     * this way the `@me` edge is on the node from the start, so messages alone
+     * are enough to place you even if the profile record never runs.
+     */
+    party(party, record) {
+        if (!party)
+            return undefined;
+        const account = (record.context?.accountInfo ?? {});
+        if (party.handle && party.handle === account.handle)
+            return this.self(record);
+        return this.person({ handle: party.handle, name: party.name });
+    }
+    /**
+     * An organization, keyed on its name. LinkedIn puts no company id anywhere in
+     * an export — not in the positions, not in the follows — so the name is the
+     * only identifier available, and two different companies sharing a name will
+     * merge. Recorded here rather than worked around: the alternative is a
+     * fabricated id, which would be worse and less honest.
+     */
+    organization(name) {
+        return {
+            '@type': 'Organization',
+            '@key': ['@type', 'source', 'name'],
+            source: SOURCE,
+            name,
+        };
+    }
+}

package/dist/connectors/archive/LinkedInArchiveConnectionsExtractor.d.ts

@@ -0,0 +1,48 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Connections.csv` — everyone you are connected to, with the day it happened,
+ * newest-first.
+ *
+ * The email column is nearly always blank: LinkedIn only releases a
+ * connection's address when they opted into sharing it. The rows that do carry
+ * one are worth keeping — an email is a portable identity that merges this
+ * person with the one your mail archive already knows.
+ *
+ * `snapshot`, because a row is two things at once. "Connected On" is a real
+ * past event and stays where LinkedIn put it. Their company and title are
+ * whatever they are *today* — back-dating those to a connection made in 2010
+ * would claim they worked there then, which is a claim the export never made.
+ */
+export declare class LinkedInArchiveConnectionsExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchiveConnectionsExtractor> {
+    static description: string;
+    static recordTypes: string[];
+    static temporality: "snapshot";
+    static defaultTransformer: typeof LinkedInTransformer;
+    static schema: import("zod").ZodObject<{
+        since: import("zod").ZodOptional<import("zod").ZodDate>;
+        until: import("zod").ZodOptional<import("zod").ZodDate>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    } & {
+        input: import("zod").ZodString;
+        'profile-url': import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    /** The connection's profile URL — LinkedIn's own id for them, and stable per export. */
+    keyOf(record: Record): string | null;
+    extract(): AsyncGenerator<Record>;
+    determineCount(): Promise<number>;
+}
+//# sourceMappingURL=LinkedInArchiveConnectionsExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveConnectionsExtractor.js

@@ -0,0 +1,66 @@
+import { memberName, parseDayDate, profileHandle, profileUrl } from '../fields.js';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Connections.csv` — everyone you are connected to, with the day it happened,
+ * newest-first.
+ *
+ * The email column is nearly always blank: LinkedIn only releases a
+ * connection's address when they opted into sharing it. The rows that do carry
+ * one are worth keeping — an email is a portable identity that merges this
+ * person with the one your mail archive already knows.
+ *
+ * `snapshot`, because a row is two things at once. "Connected On" is a real
+ * past event and stays where LinkedIn put it. Their company and title are
+ * whatever they are *today* — back-dating those to a connection made in 2010
+ * would claim they worked there then, which is a claim the export never made.
+ */
+export class LinkedInArchiveConnectionsExtractor extends LinkedInArchiveExtractor {
+    static description = 'Connections';
+    static recordTypes = ['connections'];
+    static temporality = 'snapshot';
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    /** The connection's profile URL — LinkedIn's own id for them, and stable per export. */
+    keyOf(record) {
+        return record.data.url ?? null;
+    }
+    async *extract() {
+        const rows = await this.readCsv('Connections.csv');
+        const connections = rows
+            .map(row => {
+            const handle = profileHandle(row.URL);
+            const name = memberName([row['First Name'], row['Last Name']]
+                .map(part => part?.trim())
+                .filter(Boolean)
+                .join(' '));
+            return {
+                handle,
+                name: name || undefined,
+                url: handle ? profileUrl(handle) : undefined,
+                email: row['Email Address']?.trim() || undefined,
+                company: row.Company?.trim() || undefined,
+                position: row.Position?.trim() || undefined,
+                connectedOn: parseDayDate(row['Connected On']),
+            };
+        })
+            // A row with neither a profile URL nor a name names nobody.
+            .filter(connection => connection.handle || connection.name)
+            .sort((a, b) => ((a.connectedOn ?? '') < (b.connectedOn ?? '') ? 1 : -1));
+        let count = 0;
+        for (const connection of connections) {
+            if (this.shouldStopExtracting(count))
+                break;
+            if (!this.withinWindow(connection.connectedOn))
+                continue;
+            yield this.createRecordWithArchiveContext({
+                ...connection,
+                occurredAt: connection.connectedOn,
+            });
+            count++;
+        }
+    }
+    async determineCount() {
+        return (await this.readCsv('Connections.csv')).length;
+    }
+}

package/dist/connectors/archive/LinkedInArchiveEducationExtractor.d.ts

@@ -0,0 +1,36 @@
+import { Record } from '@chronicle.app/etl';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Education.csv` — schools attended, newest-first. `snapshot` for the same
+ * reason as positions: the dates are real, the degree text is a re-read.
+ */
+export declare class LinkedInArchiveEducationExtractor extends LinkedInArchiveExtractor<typeof LinkedInArchiveEducationExtractor> {
+    static description: string;
+    static recordTypes: string[];
+    static temporality: "snapshot";
+    static defaultTransformer: typeof LinkedInTransformer;
+    static schema: import("zod").ZodObject<{
+        since: import("zod").ZodOptional<import("zod").ZodDate>;
+        until: import("zod").ZodOptional<import("zod").ZodDate>;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    } & {
+        input: import("zod").ZodString;
+        'profile-url': import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        input: string;
+        'profile-url'?: string | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    extract(): AsyncGenerator<Record>;
+    determineCount(): Promise<number>;
+}
+//# sourceMappingURL=LinkedInArchiveEducationExtractor.d.ts.map

package/dist/connectors/archive/LinkedInArchiveEducationExtractor.js

@@ -0,0 +1,43 @@
+import { parseCoarseDate } from '../fields.js';
+import LinkedInTransformer from '../LinkedInTransformer.js';
+import { LinkedInArchiveExtractor } from './LinkedInArchiveExtractor.js';
+/**
+ * `Education.csv` — schools attended, newest-first. `snapshot` for the same
+ * reason as positions: the dates are real, the degree text is a re-read.
+ */
+export class LinkedInArchiveEducationExtractor extends LinkedInArchiveExtractor {
+    static description = 'Education history';
+    static recordTypes = ['education'];
+    static temporality = 'snapshot';
+    static defaultTransformer = LinkedInTransformer;
+    static schema = LinkedInArchiveExtractor.schema;
+    async *extract() {
+        const rows = await this.readCsv('Education.csv');
+        const enrollments = rows
+            .map(row => ({
+            school: row['School Name']?.trim(),
+            degree: row['Degree Name']?.trim(),
+            notes: row.Notes?.trim(),
+            activities: row.Activities?.trim(),
+            startedOn: parseCoarseDate(row['Start Date']),
+            finishedOn: parseCoarseDate(row['End Date']),
+        }))
+            .filter(enrollment => enrollment.school && enrollment.startedOn)
+            .sort((a, b) => (a.startedOn < b.startedOn ? 1 : -1));
+        let count = 0;
+        for (const enrollment of enrollments) {
+            if (this.shouldStopExtracting(count))
+                break;
+            if (!this.withinWindow(enrollment.startedOn))
+                continue;
+            yield this.createRecordWithArchiveContext({
+                ...enrollment,
+                occurredAt: enrollment.startedOn,
+            });
+            count++;
+        }
+    }
+    async determineCount() {
+        return (await this.readCsv('Education.csv')).length;
+    }
+}