rivet-design 0.17.4 → 0.18.0

package/dist/storage/profiles/ProfileRecords.js

@@ -0,0 +1,659 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileRecords = void 0;
+const design_profile_1 = require("../../types/design-profile");
+const crypto_1 = require("crypto");
+const path_1 = __importDefault(require("path"));
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("../library/database");
+const migrations_1 = require("./migrations");
+const schema_1 = require("./schema");
+const design_profile_2 = require("../../types/design-profile");
+const MAX_FAILURE_MESSAGE_LENGTH = 2000;
+const INITIAL_RETRY_MS = 60_000;
+const MAX_BACKOFF_MS = 15 * 60_000;
+const MIN_RETRY_MS = 1000;
+const MAX_BACKOFF_EXPONENT = 4;
+const MAX_DATE_MS = 8_640_000_000_000_000;
+const identity = (...parts) => (0, crypto_1.createHash)('sha256').update(JSON.stringify(parts)).digest('hex');
+class ProfileRecords {
+    directory;
+    db;
+    isClosed = false;
+    constructor(directory, db) {
+        this.directory = directory;
+        this.db = db;
+    }
+    static async open({ root, accountId, }) {
+        if (!accountId.trim())
+            throw new Error('A signed-in account is required for profiles');
+        const directory = ProfileRecords.directoryFor({ root, accountId });
+        const db = await (0, database_1.openDurableDatabase)({
+            databasePath: path_1.default.join(directory, 'profile.sqlite'),
+            schema: migrations_1.PROFILE_SCHEMA,
+            migrations: migrations_1.PROFILE_MIGRATIONS,
+        });
+        db.insert(schema_1.profile)
+            .values({ singleton: 1, id: (0, crypto_1.randomUUID)(), isEnabled: false, revision: 1 })
+            .onConflictDoNothing()
+            .run();
+        return new ProfileRecords(directory, db);
+    }
+    static directoryFor({ root, accountId, }) {
+        if (!accountId.trim())
+            throw new Error('A signed-in account is required for profiles');
+        return path_1.default.join(root, 'profiles', identity(accountId));
+    }
+    profile() {
+        const record = this.db.select().from(schema_1.profile).get();
+        if (!record)
+            throw new Error('Profile metadata is missing');
+        return record;
+    }
+    setEnabled(isEnabled) {
+        this.db.update(schema_1.profile).set({ isEnabled }).run();
+    }
+    sources() {
+        return this.db
+            .select()
+            .from(schema_1.sources)
+            .where((0, drizzle_orm_1.isNull)(schema_1.sources.removedAt))
+            .orderBy(schema_1.sources.id)
+            .all();
+    }
+    addSource(input) {
+        const value = design_profile_2.ProfileSourceInputSchema.parse(input);
+        const id = identity(value.provider, value.remoteId);
+        this.db
+            .insert(schema_1.sources)
+            .values({ ...value, id, isIncluded: true })
+            .onConflictDoUpdate({
+            target: schema_1.sources.id,
+            set: { title: value.title, url: value.url ?? null, removedAt: null },
+        })
+            .run();
+        return this.source(id);
+    }
+    source(id) {
+        const source = this.db
+            .select()
+            .from(schema_1.sources)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.sources.id, id), (0, drizzle_orm_1.isNull)(schema_1.sources.removedAt)))
+            .get();
+        if (!source)
+            throw new Error('Unknown profile source');
+        return source;
+    }
+    setSourceIncluded({ sourceId, isIncluded, }) {
+        this.source(sourceId);
+        (0, database_1.transaction)(this.db, () => {
+            this.db
+                .update(schema_1.sources)
+                .set({ isIncluded })
+                .where((0, drizzle_orm_1.eq)(schema_1.sources.id, sourceId))
+                .run();
+            this.bump();
+        });
+    }
+    removeSource(sourceId) {
+        this.source(sourceId);
+        (0, database_1.transaction)(this.db, () => {
+            const affected = this.references(sourceId);
+            this.db
+                .update(schema_1.sources)
+                .set({ removedAt: new Date().toISOString() })
+                .where((0, drizzle_orm_1.eq)(schema_1.sources.id, sourceId))
+                .run();
+            this.db
+                .update(schema_1.importJobs)
+                .set({ state: 'paused' })
+                .where((0, drizzle_orm_1.eq)(schema_1.importJobs.sourceId, sourceId))
+                .run();
+            this.db
+                .delete(schema_1.memberships)
+                .where((0, drizzle_orm_1.eq)(schema_1.memberships.sourceId, sourceId))
+                .run();
+            affected.forEach((reference) => this.queueOrphan(reference));
+            this.bump();
+        });
+    }
+    saveReference({ sourceId, reference, }) {
+        return (0, database_1.transaction)(this.db, () => this.writeReference(sourceId, reference));
+    }
+    references(sourceId) {
+        const ids = this.db
+            .select({ id: schema_1.memberships.referenceId })
+            .from(schema_1.memberships)
+            .where(sourceId ? (0, drizzle_orm_1.eq)(schema_1.memberships.sourceId, sourceId) : undefined);
+        return this.db
+            .select()
+            .from(schema_1.references)
+            .where((0, drizzle_orm_1.inArray)(schema_1.references.id, ids))
+            .orderBy(schema_1.references.id)
+            .all()
+            .map(({ id, revision, body }) => ({ ...body, id, revision }));
+    }
+    reference(id) {
+        const row = this.db
+            .select()
+            .from(schema_1.references)
+            .where((0, drizzle_orm_1.eq)(schema_1.references.id, id))
+            .get();
+        return row ? { ...row.body, id: row.id, revision: row.revision } : null;
+    }
+    saveObservation(input) {
+        const value = design_profile_2.ProfileObservationSchema.parse(input);
+        (0, database_1.transaction)(this.db, () => {
+            const reference = this.reference(value.referenceId);
+            if (!reference || reference.revision !== value.revision)
+                throw new Error('Observation revision is no longer current');
+            this.db
+                .insert(schema_1.observations)
+                .values({
+                referenceId: value.referenceId,
+                revision: value.revision,
+                body: value,
+            })
+                .onConflictDoUpdate({
+                target: schema_1.observations.referenceId,
+                set: { revision: value.revision, body: value },
+            })
+                .run();
+            this.queue(reference, 'upsert');
+            this.bump();
+        });
+    }
+    observation(referenceId) {
+        const row = this.db
+            .select()
+            .from(schema_1.observations)
+            .where((0, drizzle_orm_1.eq)(schema_1.observations.referenceId, referenceId))
+            .get();
+        return row?.revision === this.reference(referenceId)?.revision
+            ? (row?.body ?? null)
+            : null;
+    }
+    candidates(hits) {
+        return hits.flatMap(({ referenceId, revision }) => {
+            const reference = this.reference(referenceId);
+            const observation = this.observation(referenceId);
+            const eligible = this.db
+                .select({ source: schema_1.sources })
+                .from(schema_1.memberships)
+                .innerJoin(schema_1.sources, (0, drizzle_orm_1.eq)(schema_1.sources.id, schema_1.memberships.sourceId))
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.memberships.referenceId, referenceId), (0, drizzle_orm_1.eq)(schema_1.sources.isIncluded, true), (0, drizzle_orm_1.isNull)(schema_1.sources.removedAt)))
+                .all();
+            if (!reference ||
+                !observation ||
+                reference.revision !== revision ||
+                !eligible.length)
+                return [];
+            return [
+                {
+                    reference,
+                    observation,
+                    sources: eligible.map(({ source }) => ({
+                        ...source,
+                        url: source.url ?? undefined,
+                    })),
+                },
+            ];
+        });
+    }
+    pendingIndex(limit = 100) {
+        return this.db
+            .select()
+            .from(schema_1.indexWork)
+            .where((0, drizzle_orm_1.eq)(schema_1.indexWork.state, 'pending'))
+            .orderBy(schema_1.indexWork.referenceId)
+            .limit(limit)
+            .all();
+    }
+    coverage(sourceId) {
+        const items = this.references(sourceId);
+        const receipts = new Map(this.db
+            .select()
+            .from(schema_1.indexWork)
+            .all()
+            .map((work) => [work.referenceId, work]));
+        return {
+            references: items.length,
+            downloaded: items.filter((item) => item.media.length > 0 &&
+                item.media.length >= (item.remoteImages?.length ?? 0)).length,
+            unsupported: items.filter((item) => item.unsupportedReason).length,
+            failed: new Set(this.failures()
+                .filter((failure) => items.some((item) => item.id === failure.referenceId))
+                .map((failure) => failure.referenceId)).size,
+            analyzed: items.filter((item) => this.observation(item.id)).length,
+            indexed: items.filter((item) => {
+                const work = receipts.get(item.id);
+                return (work?.state === 'indexed' &&
+                    work.operation === 'upsert' &&
+                    work.revision === item.revision &&
+                    this.observation(item.id));
+            }).length,
+            pendingIndex: sourceId
+                ? items.filter((item) => receipts.get(item.id)?.state === 'pending')
+                    .length
+                : [...receipts.values()].filter((item) => item.state === 'pending')
+                    .length,
+        };
+    }
+    reindex(runtime) {
+        return (0, database_1.transaction)(this.db, () => {
+            const activeIds = new Set(this.references().map((item) => item.id));
+            const work = new Map(this.db
+                .select()
+                .from(schema_1.indexWork)
+                .all()
+                .map((item) => [item.referenceId, item]));
+            let upserts = 0;
+            let deletions = 0;
+            for (const row of this.db.select().from(schema_1.references).all()) {
+                const reference = { ...row.body, id: row.id, revision: row.revision };
+                const operation = activeIds.has(row.id) && this.observation(row.id)
+                    ? 'upsert'
+                    : 'delete';
+                if (operation === 'upsert')
+                    upserts += 1;
+                else
+                    deletions += 1;
+                const pending = work.get(row.id);
+                if (pending?.state === 'pending' &&
+                    pending.operation === operation &&
+                    pending.revision === row.revision)
+                    continue;
+                this.queue(reference, operation);
+            }
+            this.queueIndex(runtime);
+            return { upserts, deletions };
+        });
+    }
+    rebuild() {
+        return this.db.select().from(schema_1.indexRebuild).get() ?? null;
+    }
+    queueIndex(runtime) {
+        const job = { id: (0, crypto_1.randomUUID)(), runtime };
+        this.db
+            .insert(schema_1.indexRebuild)
+            .values({ singleton: 1, ...job })
+            .onConflictDoUpdate({ target: schema_1.indexRebuild.singleton, set: job })
+            .run();
+    }
+    completeRebuild(id) {
+        this.db.delete(schema_1.indexRebuild).where((0, drizzle_orm_1.eq)(schema_1.indexRebuild.id, id)).run();
+    }
+    acknowledgeIndex(work) {
+        return (0, database_1.transaction)(this.db, () => {
+            const current = this.db
+                .select()
+                .from(schema_1.indexWork)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.indexWork.referenceId, work.referenceId), (0, drizzle_orm_1.eq)(schema_1.indexWork.id, work.id)))
+                .get();
+            if (!current ||
+                current.revision !== work.revision ||
+                current.operation !== work.operation)
+                return false;
+            if (work.operation === 'delete')
+                this.db.delete(schema_1.indexWork).where((0, drizzle_orm_1.eq)(schema_1.indexWork.id, work.id)).run();
+            else
+                this.db
+                    .update(schema_1.indexWork)
+                    .set({ state: 'indexed', engineId: work.engineId })
+                    .where((0, drizzle_orm_1.eq)(schema_1.indexWork.id, work.id))
+                    .run();
+            return true;
+        });
+    }
+    saveLocalImport(input) {
+        if (input.source.provider !== input.reference.provider ||
+            input.source.remoteId !== input.reference.remoteId)
+            throw new Error('Local reference identity must match its source');
+        return (0, database_1.transaction)(this.db, () => {
+            const source = this.addSource(input.source);
+            const job = this.writeImport({
+                sourceId: source.id,
+                runtime: input.runtime,
+            });
+            this.writeReference(source.id, input.reference, job.id);
+            this.db
+                .update(schema_1.importJobs)
+                .set({ isEnumerated: true, enumerated: 1, total: 1 })
+                .where((0, drizzle_orm_1.eq)(schema_1.importJobs.id, job.id))
+                .run();
+            const savedJob = this.jobs().find((item) => item.id === job.id);
+            if (!savedJob)
+                throw new Error('Saved profile import is missing');
+            return { source, job: savedJob };
+        });
+    }
+    startImport({ sourceId, runtime, }) {
+        this.source(sourceId);
+        const existing = this.jobs().find((job) => job.sourceId === sourceId && job.state === 'pending');
+        if (existing)
+            return existing;
+        return (0, database_1.transaction)(this.db, () => this.writeImport({ sourceId, runtime }));
+    }
+    writeImport({ sourceId, runtime, }) {
+        const id = (0, crypto_1.randomUUID)();
+        this.db
+            .update(schema_1.importJobs)
+            .set({ state: 'superseded' })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.importJobs.sourceId, sourceId), (0, drizzle_orm_1.ne)(schema_1.importJobs.state, 'complete')))
+            .run();
+        this.db
+            .insert(schema_1.importJobs)
+            .values({
+            id,
+            sourceId,
+            runtime,
+            state: 'pending',
+            enumerated: 0,
+            updatedAt: new Date().toISOString(),
+        })
+            .run();
+        const job = this.jobs().find((item) => item.id === id);
+        if (!job)
+            throw new Error('Started profile import is missing');
+        return job;
+    }
+    jobs() {
+        const cooldowns = this.db.select().from(schema_1.providerCooldowns).all();
+        const providers = new Map(this.db
+            .select()
+            .from(schema_1.sources)
+            .all()
+            .map((source) => [source.id, source.provider]));
+        return this.db
+            .select()
+            .from(schema_1.importJobs)
+            .orderBy(schema_1.importJobs.updatedAt, schema_1.importJobs.id)
+            .all()
+            .map((job) => ({
+            ...job,
+            retryAt: cooldowns.find((cooldown) => job.state === 'pending' &&
+                cooldown.provider === providers.get(job.sourceId) &&
+                Date.parse(cooldown.retryAt) > Date.now())?.retryAt ?? null,
+        }));
+    }
+    deferImport({ id, retryAfterMs }) {
+        const job = this.jobs().find((item) => item.id === id);
+        if (!job)
+            throw new Error('Unknown profile import');
+        const source = this.db
+            .select()
+            .from(schema_1.sources)
+            .where((0, drizzle_orm_1.eq)(schema_1.sources.id, job.sourceId))
+            .get();
+        if (!source)
+            throw new Error('Profile import source is missing');
+        if (!(0, design_profile_1.isRemoteProfileProvider)(source.provider))
+            throw new Error('Only connected providers support rate-limit deferral');
+        const previous = this.db
+            .select()
+            .from(schema_1.providerCooldowns)
+            .where((0, drizzle_orm_1.eq)(schema_1.providerCooldowns.provider, source.provider))
+            .get();
+        const now = Date.now();
+        const isRecent = previous && Date.parse(previous.retryAt) >= now - MAX_BACKOFF_MS;
+        const attempts = isRecent
+            ? Math.min(previous.attempts + 1, MAX_BACKOFF_EXPONENT + 1)
+            : 1;
+        const backoff = Math.min(MAX_BACKOFF_MS, INITIAL_RETRY_MS * 2 ** (attempts - 1));
+        const guidance = retryAfterMs !== undefined &&
+            Number.isFinite(retryAfterMs) &&
+            retryAfterMs >= 0 &&
+            retryAfterMs <= MAX_DATE_MS - now
+            ? retryAfterMs
+            : backoff;
+        const retryAt = new Date(Math.max(previous ? Date.parse(previous.retryAt) : now, now + Math.max(MIN_RETRY_MS, guidance))).toISOString();
+        return (0, database_1.transaction)(this.db, () => {
+            const cooldown = { provider: source.provider, retryAt, attempts };
+            this.db
+                .insert(schema_1.providerCooldowns)
+                .values(cooldown)
+                .onConflictDoUpdate({
+                target: schema_1.providerCooldowns.provider,
+                set: cooldown,
+            })
+                .run();
+            this.db
+                .update(schema_1.importJobs)
+                .set({
+                error: 'Waiting for the provider rate limit; retry is scheduled automatically',
+                updatedAt: new Date(now).toISOString(),
+            })
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.importJobs.id, id), (0, drizzle_orm_1.eq)(schema_1.importJobs.state, 'pending')))
+                .run();
+            return cooldown;
+        });
+    }
+    updateJob({ id, state, error = null, }) {
+        const job = this.jobs().find((item) => item.id === id);
+        if (!job || job.state === 'superseded')
+            throw new Error('Import job is no longer active');
+        if (state === 'complete' &&
+            (job.state !== 'pending' ||
+                !job.isEnumerated ||
+                this.failures(id).length ||
+                this.references(job.sourceId).some((reference) => !reference.unsupportedReason && !this.observation(reference.id))))
+            throw new Error('Import has unfinished references');
+        this.db
+            .update(schema_1.importJobs)
+            .set({ state, error, updatedAt: new Date().toISOString() })
+            .where((0, drizzle_orm_1.eq)(schema_1.importJobs.id, id))
+            .run();
+    }
+    failures(jobId) {
+        return this.db
+            .select({ failure: schema_1.referenceFailures })
+            .from(schema_1.referenceFailures)
+            .innerJoin(schema_1.references, (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.references.id, schema_1.referenceFailures.referenceId), (0, drizzle_orm_1.eq)(schema_1.references.revision, schema_1.referenceFailures.revision)))
+            .innerJoin(schema_1.importJobs, (0, drizzle_orm_1.eq)(schema_1.importJobs.id, schema_1.referenceFailures.jobId))
+            .innerJoin(schema_1.memberships, (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.memberships.sourceId, schema_1.importJobs.sourceId), (0, drizzle_orm_1.eq)(schema_1.memberships.referenceId, schema_1.references.id)))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.ne)(schema_1.importJobs.state, 'superseded'), jobId ? (0, drizzle_orm_1.eq)(schema_1.referenceFailures.jobId, jobId) : undefined))
+            .all()
+            .map(({ failure }) => failure);
+    }
+    saveFailure(input) {
+        const job = this.jobs().find((item) => item.id === input.jobId);
+        const reference = job &&
+            this.references(job.sourceId).find((item) => item.id === input.referenceId);
+        if (!reference || reference.revision !== input.revision)
+            throw new Error('Failed reference revision is no longer current');
+        if (job?.state !== 'pending')
+            throw new Error('Import job is not pending');
+        const values = {
+            ...input,
+            error: input.error.slice(0, MAX_FAILURE_MESSAGE_LENGTH),
+            updatedAt: new Date().toISOString(),
+        };
+        this.db
+            .insert(schema_1.referenceFailures)
+            .values({ ...values, attempts: 1 })
+            .onConflictDoUpdate({
+            target: [
+                schema_1.referenceFailures.jobId,
+                schema_1.referenceFailures.referenceId,
+                schema_1.referenceFailures.stage,
+            ],
+            set: { ...values, attempts: (0, drizzle_orm_1.sql) `${schema_1.referenceFailures.attempts} + 1` },
+        })
+            .run();
+    }
+    clearFailure(referenceId, stage) {
+        this.db
+            .delete(schema_1.referenceFailures)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.referenceFailures.referenceId, referenceId), (0, drizzle_orm_1.eq)(schema_1.referenceFailures.stage, stage)))
+            .run();
+    }
+    saveImportPage({ jobId, references: items, cursor, isComplete, total, remoteId, title, }) {
+        if (isComplete !== (cursor === null))
+            throw new Error('Import page has inconsistent exhaustion metadata');
+        const validated = items.map((item) => design_profile_2.ProfileReferenceInputSchema.parse(item));
+        (0, database_1.transaction)(this.db, () => {
+            const job = this.jobs().find((item) => item.id === jobId);
+            if (!job || job.state !== 'pending' || job.isEnumerated)
+                throw new Error('Import job is not pending');
+            const source = this.source(job.sourceId);
+            if (remoteId &&
+                source.resolvedRemoteId &&
+                source.resolvedRemoteId !== remoteId)
+                throw new Error('Provider source identity changed; reconnect the intended source');
+            if (cursor &&
+                this.db
+                    .select()
+                    .from(schema_1.importCursors)
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.importCursors.jobId, jobId), (0, drizzle_orm_1.eq)(schema_1.importCursors.cursor, cursor)))
+                    .get())
+                throw new Error('Provider returned a repeated page cursor');
+            for (const item of validated)
+                this.writeReference(job.sourceId, item, job.id);
+            const enumerated = this.db
+                .select({ value: (0, drizzle_orm_1.count)() })
+                .from(schema_1.memberships)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.memberships.sourceId, job.sourceId), (0, drizzle_orm_1.eq)(schema_1.memberships.seenJobId, job.id)))
+                .get()?.value;
+            if (enumerated === undefined)
+                throw new Error('Profile import coverage is unavailable');
+            const expected = total ?? job.total;
+            if (isComplete && expected !== null && enumerated !== expected)
+                throw new Error(`Import coverage mismatch: enumerated ${enumerated} of ${expected}; refresh the source to enumerate again`);
+            if (cursor)
+                this.db.insert(schema_1.importCursors).values({ jobId, cursor }).run();
+            if (remoteId)
+                this.db
+                    .update(schema_1.sources)
+                    .set({ resolvedRemoteId: remoteId, ...(title ? { title } : {}) })
+                    .where((0, drizzle_orm_1.eq)(schema_1.sources.id, job.sourceId))
+                    .run();
+            if (isComplete) {
+                const unseen = this.db
+                    .select()
+                    .from(schema_1.memberships)
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.memberships.sourceId, job.sourceId), (0, drizzle_orm_1.or)((0, drizzle_orm_1.isNull)(schema_1.memberships.seenJobId), (0, drizzle_orm_1.ne)(schema_1.memberships.seenJobId, job.id))))
+                    .all();
+                unseen.forEach((membership) => {
+                    this.db
+                        .delete(schema_1.memberships)
+                        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.memberships.sourceId, job.sourceId), (0, drizzle_orm_1.eq)(schema_1.memberships.referenceId, membership.referenceId)))
+                        .run();
+                    const reference = this.reference(membership.referenceId);
+                    if (reference)
+                        this.queueOrphan(reference);
+                });
+            }
+            this.db
+                .update(schema_1.importJobs)
+                .set({
+                cursor,
+                enumerated,
+                total: total ?? job.total,
+                state: 'pending',
+                isEnumerated: isComplete,
+                updatedAt: new Date().toISOString(),
+            })
+                .where((0, drizzle_orm_1.eq)(schema_1.importJobs.id, job.id))
+                .run();
+            this.bump();
+        });
+    }
+    close() {
+        if (!this.isClosed) {
+            this.isClosed = true;
+            (0, database_1.closeDatabase)(this.db);
+        }
+    }
+    bump() {
+        this.db
+            .update(schema_1.profile)
+            .set({ revision: (0, drizzle_orm_1.sql) `${schema_1.profile.revision} + 1` })
+            .run();
+    }
+    queueOrphan(reference) {
+        const membership = this.db
+            .select()
+            .from(schema_1.memberships)
+            .where((0, drizzle_orm_1.eq)(schema_1.memberships.referenceId, reference.id))
+            .get();
+        if (!membership)
+            this.queue(reference, 'delete');
+    }
+    queue(reference, operation) {
+        const value = {
+            id: (0, crypto_1.randomUUID)(),
+            referenceId: reference.id,
+            revision: reference.revision,
+            operation,
+            state: 'pending',
+        };
+        this.db
+            .insert(schema_1.indexWork)
+            .values(value)
+            .onConflictDoUpdate({ target: schema_1.indexWork.referenceId, set: value })
+            .run();
+    }
+    writeReference(sourceId, input, seenJobId) {
+        this.source(sourceId);
+        const body = design_profile_2.ProfileReferenceInputSchema.parse(input);
+        const id = identity(body.provider, body.remoteId);
+        const current = this.db
+            .select()
+            .from(schema_1.references)
+            .where((0, drizzle_orm_1.eq)(schema_1.references.id, id))
+            .get();
+        if (!body.media.length &&
+            body.remoteImages?.length &&
+            JSON.stringify(body.remoteImages) ===
+                JSON.stringify(current?.body.remoteImages) &&
+            JSON.stringify(body.remoteImageRepresentations) ===
+                JSON.stringify(current?.body.remoteImageRepresentations)) {
+            body.media = current?.body.media ?? [];
+        }
+        const contentHash = identity(JSON.stringify(body));
+        const isChanged = current?.contentHash !== contentHash;
+        const revision = (current?.revision ?? 0) + (isChanged ? 1 : 0);
+        if (isChanged) {
+            this.db
+                .insert(schema_1.references)
+                .values({ id, revision, contentHash, body })
+                .onConflictDoUpdate({
+                target: schema_1.references.id,
+                set: { revision, contentHash, body },
+            })
+                .run();
+            this.db
+                .delete(schema_1.observations)
+                .where((0, drizzle_orm_1.eq)(schema_1.observations.referenceId, id))
+                .run();
+            if (current)
+                this.queue({ ...body, id, revision }, 'delete');
+            this.bump();
+        }
+        const set = seenJobId ? { seenJobId } : { referenceId: id };
+        this.db
+            .insert(schema_1.memberships)
+            .values({ sourceId, referenceId: id, seenJobId })
+            .onConflictDoUpdate({
+            target: [schema_1.memberships.sourceId, schema_1.memberships.referenceId],
+            set,
+        })
+            .run();
+        const work = this.db
+            .select()
+            .from(schema_1.indexWork)
+            .where((0, drizzle_orm_1.eq)(schema_1.indexWork.referenceId, id))
+            .get();
+        if (!isChanged &&
+            this.observation(id) &&
+            (!work || work.operation === 'delete')) {
+            this.queue({ ...body, id, revision }, 'upsert');
+        }
+        return { ...body, id, revision };
+    }
+}
+exports.ProfileRecords = ProfileRecords;
+//# sourceMappingURL=ProfileRecords.js.map