@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/publishDraftGraph-DBWAN72w.js

@@ -1,505 +0,0 @@
-import { L as BaseDb, m as metadata, ae as getItemModelScope, M as ModelPropertyDataTypes, R as resolveModelRecord, E as properties, p as models, n as normalizeDataType, s as seeds, ad as ZERO_BYTES32, q as normalizeRelationPropertyValue, r as resolveSeedIdsFromRefString, l as isPublishedSeedRef } from './index-rOTW-2QZ.js';
-import { M as METADATA_LATEST_FIRST_ORDER_SQL, N as isVersionRevoked, L as parseListPropertyValueFromStorage } from './Item-CG5IhPtL.js';
-import './errors-CS3nDpUU.js';
-import { getPropertySchema } from './property-C85DCD7K.js';
-import { eq, sql, and } from 'drizzle-orm';
-import { upperFirst, camelCase } from 'lodash-es';
-import { isPlaceholderUid } from '@seedprotocol/eas';
-import { f as findSeedRowsByUid } from './findSeedRowsByUid-CuQmK7An.js';
-import 'pluralize';
-
-/**
- * Points each property whose context holds a published row's uid at the property's newest row when
- * that row is a draft, clearing the uid. Publish skips a property with a uid in patch mode, so an
- * edit the context missed (another tab's write, a metadata update the live query dropped while the
- * property was saving) would never attest. The context takes the row's value too, the way the
- * change feed sets it, so the payload attests the value of the row it names (audit 1.1).
- */
-const reconcilePropertyDraftRows = async (item) => {
-    const stale = item.properties.filter((property) => property.uid && property.localId);
-    const seedLocalId = item.seedLocalId;
-    if (stale.length === 0 || !seedLocalId)
-        return;
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return;
-    const rows = await appDb
-        .select({
-        localId: metadata.localId,
-        uid: metadata.uid,
-        propertyName: metadata.propertyName,
-        propertyValue: metadata.propertyValue,
-        refResolvedValue: metadata.refResolvedValue,
-    })
-        .from(metadata)
-        .where(eq(metadata.seedLocalId, seedLocalId))
-        .orderBy(sql.raw(METADATA_LATEST_FIRST_ORDER_SQL));
-    for (const property of stale) {
-        // The context's row gives the stored property name (relations and lists store a variant).
-        const current = rows.find((row) => row.localId === property.localId);
-        if (!current?.propertyName)
-            continue;
-        const newest = rows.find((row) => row.propertyName === current.propertyName);
-        if (!newest?.localId || newest.localId === current.localId || !isPlaceholderUid(newest.uid))
-            continue;
-        // As in the change feed: an ItemStorage row pointing at its file holds no content to show.
-        const contentInFile = property.propertyDef?.storageType === 'ItemStorage' &&
-            newest.propertyValue == null &&
-            !!newest.refResolvedValue;
-        property.getService().send({
-            type: 'updateContext',
-            localId: newest.localId,
-            uid: undefined,
-            propertyValue: newest.propertyValue,
-            ...(contentInFile ? {} : { renderValue: newest.propertyValue }),
-            refResolvedValue: newest.refResolvedValue || undefined,
-        });
-    }
-};
-
-const matchesDataType = (actual, expected) => normalizeDataType(actual) === expected;
-async function resolvePropertyDef(modelName, propertyName, scope) {
-    const schema = await getPropertySchema(modelName, propertyName, scope);
-    if (schema)
-        return schema;
-    const db = BaseDb.getAppDb();
-    if (!db)
-        return undefined;
-    try {
-        const normalizedModelName = upperFirst(camelCase(modelName));
-        const modelRecord = await resolveModelRecord(normalizedModelName, scope, db);
-        const modelRecords = modelRecord ? [modelRecord] : [];
-        if (modelRecords.length === 0 || !modelRecords[0].id)
-            return undefined;
-        const propertyRecords = await db
-            .select()
-            .from(properties)
-            .where(and(eq(properties.modelId, modelRecords[0].id), eq(properties.name, propertyName)))
-            .limit(1);
-        if (propertyRecords.length === 0)
-            return undefined;
-        const propRecord = propertyRecords[0];
-        let refModelName;
-        if (propRecord.refModelId != null) {
-            const refModelRows = await db
-                .select({ name: models.name })
-                .from(models)
-                .where(eq(models.id, propRecord.refModelId))
-                .limit(1);
-            refModelName = refModelRows[0]?.name ?? undefined;
-        }
-        return {
-            dataType: propRecord.dataType,
-            ref: refModelName ?? undefined,
-            refValueType: propRecord.refValueType || undefined,
-            storageType: propRecord.storageType || undefined,
-            localStorageDir: propRecord.localStorageDir || undefined,
-            filenameSuffix: propRecord.filenameSuffix || undefined,
-            required: propRecord.required ?? undefined,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-const getSegmentedItemProperties = async (item) => {
-    const itemBasicProperties = [];
-    const itemRelationProperties = [];
-    const itemListProperties = [];
-    const itemUploadProperties = [];
-    const itemImageProperties = [];
-    const itemStorageProperties = [];
-    let itemStorageTransactionProperty;
-    let itemScope;
-    // Publish decides from each property's uid; it must name the property's newest row.
-    await reconcilePropertyDraftRows(item);
-    for (const itemProperty of item.properties) {
-        let propertyDef = itemProperty.propertyDef;
-        // When propertyDef is missing (e.g. external app, Model not registered), resolve inline
-        // so properties are not skipped and metadata attestations can be created
-        if (!propertyDef && item.modelName) {
-            itemScope ?? (itemScope = await getItemModelScope(item));
-            const resolved = await resolvePropertyDef(item.modelName, itemProperty.propertyName, itemScope);
-            if (resolved) {
-                itemProperty.getService().send({ type: 'updateContext', propertyRecordSchema: resolved });
-                propertyDef = resolved;
-            }
-            else {
-                // Last resort: Model and DB don't have schema. Use Text so property routes to
-                // itemBasicProperties and can be attested (covers title, description, etc.)
-                const fallbackDef = { dataType: 'Text' };
-                itemProperty.getService().send({ type: 'updateContext', propertyRecordSchema: fallbackDef });
-                propertyDef = fallbackDef;
-            }
-        }
-        if (!propertyDef) {
-            continue;
-        }
-        const isItemStorage = propertyDef.storageType &&
-            propertyDef.storageType === 'ItemStorage';
-        const isStorageTransaction = itemProperty.propertyName === 'storageTransactionId' ||
-            itemProperty.propertyName === 'storage_transaction_id';
-        const isStorageSeedType = matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.Image) ||
-            matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.File) ||
-            matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.Html) ||
-            matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.Json) ||
-            (matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.Relation) &&
-                (matchesDataType(propertyDef.refValueType, ModelPropertyDataTypes.Image) ||
-                    matchesDataType(propertyDef.refValueType, ModelPropertyDataTypes.File) ||
-                    matchesDataType(propertyDef.refValueType, ModelPropertyDataTypes.Html) ||
-                    matchesDataType(propertyDef.refValueType, ModelPropertyDataTypes.Json)));
-        if (isStorageSeedType) {
-            itemImageProperties.push(itemProperty);
-            if (matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.Relation)) {
-                itemRelationProperties.push(itemProperty);
-            }
-            continue;
-        }
-        if (matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.Relation)) {
-            itemRelationProperties.push(itemProperty);
-            continue;
-        }
-        if (matchesDataType(propertyDef.dataType, ModelPropertyDataTypes.List)) {
-            // List-of-relations: ref present, goes to processListProperty
-            // List-of-primitives: ref absent, treat as basic property
-            const listRef = propertyDef.ref || propertyDef.refModelName;
-            if (listRef) {
-                itemListProperties.push(itemProperty);
-            }
-            else {
-                itemBasicProperties.push(itemProperty);
-            }
-            continue;
-        }
-        if (isItemStorage) {
-            itemStorageProperties.push(itemProperty);
-            continue;
-        }
-        if (isStorageTransaction) {
-            itemStorageTransactionProperty = { itemProperty, childProperties: [] };
-            continue;
-        }
-        itemBasicProperties.push(itemProperty);
-    }
-    if (itemStorageTransactionProperty && itemStorageProperties.length > 0) {
-        itemStorageTransactionProperty.childProperties = itemStorageProperties;
-    }
-    if (itemStorageTransactionProperty) {
-        itemUploadProperties.push(itemStorageTransactionProperty);
-    }
-    return {
-        itemBasicProperties,
-        itemRelationProperties,
-        itemListProperties,
-        itemUploadProperties,
-        itemImageProperties,
-    };
-};
-
-/**
- * The items one internal read loads (a publish payload build, a publish walk). `getItem` and
- * `Item.find` take a cache hold on each item they return; `release()` drops this read's holds, so
- * an item nobody else holds stops instead of staying loaded for the session. A read that hands
- * none of these items to its caller releases them when it is done.
- */
-class ItemLoads {
-    constructor() {
-        this.held = [];
-    }
-    async getItem(params) {
-        // Dynamic imports: getItem and Item import the publish readers that use this
-        const { getItem } = await import('./getItem-Uha3_H0t.js');
-        return this.keep(await getItem(params));
-    }
-    async find(params) {
-        const _mod_0 = await import('./Item-CG5IhPtL.js');
-        const _ns_0 = _mod_0.av;
-        const { Item } = _ns_0;
-        return this.keep(await Item.find(params));
-    }
-    /** Adds an item the caller loaded (one hold) to the holds `release()` drops. */
-    keep(item) {
-        if (item)
-            this.held.push(item);
-        return item;
-    }
-    /** Drops every hold this read took, except one hold on each item in `except`, which passes to the caller. */
-    release(except = []) {
-        const kept = new Set(except);
-        for (const item of this.held.splice(0)) {
-            if (kept.delete(item))
-                continue;
-            try {
-                item.unload();
-            }
-            catch {
-                // Already stopped
-            }
-        }
-    }
-}
-/** Runs `read` with `loads`, or with its own ItemLoads released when `read` settles. */
-async function withItemLoads(loads, read) {
-    const own = new ItemLoads();
-    try {
-        return await read(own);
-    }
-    finally {
-        own.release();
-    }
-}
-
-/**
- * True when the item's seed attestation was revoked (`seeds.revoked_at` set, by unpublish or EAS
- * sync). Such a seed can't take new versions: publishing again creates a new seed attestation
- * (see "Republishing" in docs/ATTESTATION_REVOCATION.md).
- */
-const isSeedRevoked = async (seedLocalId) => {
-    if (!seedLocalId)
-        return false;
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return false;
-    const [row] = await appDb
-        .select({ revokedAt: seeds.revokedAt })
-        .from(seeds)
-        .where(eq(seeds.localId, seedLocalId))
-        .limit(1);
-    return isVersionRevoked(row?.revokedAt);
-};
-
-const selectSeed = {
-    seedLocalId: seeds.localId,
-    seedUid: seeds.uid,
-    revokedAt: seeds.revokedAt,
-    type: seeds.type,
-};
-/**
- * The local seed row a relation/list/image ref points at, by local id or uid. A uid resolves as
- * {@link findSeedRowsByUid} resolves it (the order EAS sync matches seeds in): the old uid of a seed
- * that was unpublished and published again resolves to that seed, through its old version rows.
- * Null when nothing local matches (e.g. a published uid with no local copy).
- */
-const findRelatedSeedRow = async ({ seedLocalId, seedUid, }) => {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return null;
-    if (seedLocalId) {
-        const [row] = await appDb.select(selectSeed).from(seeds).where(eq(seeds.localId, seedLocalId)).limit(1);
-        if (row?.seedLocalId)
-            return row;
-    }
-    if (!seedUid || seedUid === ZERO_BYTES32)
-        return null;
-    const row = (await findSeedRowsByUid([seedUid])).get(seedUid);
-    return row?.localId
-        ? { seedLocalId: row.localId, seedUid: row.uid, revokedAt: row.revokedAt, type: row.type }
-        : null;
-};
-/** The seed is attested and its attestation is live. */
-const isLivePublishedSeed = (row) => !!row?.seedUid && row.seedUid !== ZERO_BYTES32 && !isVersionRevoked(row.revokedAt);
-/** The seed was attested and that attestation was revoked (unpublished). */
-const isUnpublishedSeed = (row) => !!row?.seedUid && row.seedUid !== ZERO_BYTES32 && isVersionRevoked(row.revokedAt);
-/** Model a relation/list/image property points at, from its definition. */
-function relatedModelNameFromDef(propertyDef) {
-    const def = propertyDef;
-    if (!def)
-        return undefined;
-    const dataType = normalizeDataType(def.dataType);
-    if (dataType === ModelPropertyDataTypes.Image)
-        return 'Image';
-    if (dataType === ModelPropertyDataTypes.File)
-        return 'File';
-    if (dataType === ModelPropertyDataTypes.Html)
-        return 'Html';
-    return def.ref ?? def.refModelName;
-}
-/**
- * Name of the item's Html property whose value is the Html seed `htmlSeedLocalId`: the property
- * that refers to the images embedded in that Html (htmlEmbeddedImageCoPublish rows).
- */
-function htmlPropertyNameForHtmlSeed(item, htmlSeedLocalId) {
-    const want = htmlSeedLocalId.trim();
-    for (const p of item.properties ?? []) {
-        if (normalizeDataType(p.propertyDef?.dataType) !== ModelPropertyDataTypes.Html)
-            continue;
-        const snap = p.getService().getSnapshot();
-        const value = 'context' in snap ? snap.context.propertyValue : undefined;
-        if (typeof value === 'string' && value.trim() === want)
-            return p.propertyName;
-    }
-    return 'html';
-}
-
-/**
- * The draft items a publish of an item carries along, and how it walks to them.
- *
- * A publish attests the item and every draft item (no seed uid yet) reachable from it through
- * relation and list-of-relation properties, each with its full property set. Already-published
- * targets are referenced by their current uid and not walked into; revoked ones stop the publish
- * (RelatedItemUnpublishedError). getPublishPayload, getPublishUploads, getPublishUploadData (publish
- * package), summarizePublishWork and the Html-embedded image co-publish all walk this graph in the
- * same order: depth first, properties in item order (relations, then lists), list members in order.
- *
- * Cycles: an item can only attest the uid of a seed published before it in the same publish, so a
- * ref back to an item still being walked (an ancestor that gets a new seed in this publish) can't be
- * attested. Such a property is deferred: left out of this publish (it keeps no uid, so the next
- * publish of its item attests it, with the target's uid). For A ↔ B reached from A, A attests B's
- * uid and B's relation to A is deferred.
- */
-/** Relation properties that point at model items (not Image/File/Html/Json storage seeds). */
-function draftWalkProperties(segmented) {
-    const storage = new Set(segmented.itemImageProperties);
-    return {
-        relationProperties: segmented.itemRelationProperties.filter((p) => !storage.has(p)),
-        listProperties: segmented.itemListProperties,
-    };
-}
-const propertyContext = (prop) => {
-    const snapshot = prop.getService().getSnapshot();
-    return snapshot && 'context' in snapshot
-        ? (snapshot.context ?? null)
-        : null;
-};
-/** Seed refs held by a relation property (one) or a list property (each member). */
-function propertySeedRefs(prop, isList) {
-    const context = propertyContext(prop);
-    if (!context)
-        return [];
-    let value = context.propertyValue;
-    if (isList) {
-        if (typeof value === 'string')
-            value = parseListPropertyValueFromStorage(value);
-        const arr = Array.isArray(value) ? value : value != null ? [value] : [];
-        return arr
-            .map((v) => v && typeof v === 'object'
-            ? normalizeRelationPropertyValue(v.seedLocalId ??
-                v.localId ??
-                v.seedUid ??
-                v.uid)
-            : normalizeRelationPropertyValue(v))
-            .filter((v) => !!v);
-    }
-    const ref = normalizeRelationPropertyValue(value);
-    return ref ? [ref] : [];
-}
-const isZeroUid = (uid) => !uid || uid === ZERO_BYTES32;
-/** The item gets a new seed attestation in this publish: a draft, or a revoked seed published again. */
-async function getsNewSeed(item) {
-    return isZeroUid(item.seedUid) || (await isSeedRevoked(item.seedLocalId));
-}
-/** Would the publish attest this property (so walk its refs)? Same rule as getPublishPayload. */
-function walksProperty(prop, forceFullSnapshot) {
-    if (prop.uid && !forceFullSnapshot)
-        return false;
-    const ctx = propertyContext(prop);
-    const value = ctx?.propertyValue;
-    return value != null && value !== '' && !(Array.isArray(value) && value.length === 0);
-}
-async function loadItem(seedLocalId, loads) {
-    try {
-        return await loads.getItem({ seedLocalId });
-    }
-    catch {
-        return undefined;
-    }
-}
-async function getPublishDraftGraph(root, options) {
-    const forceFullSnapshot = options?.forceFullSnapshot === true;
-    const strict = options?.strict === true;
-    const loads = options?.loads ?? new ItemLoads();
-    const drafts = [];
-    const deferredProperties = new Set();
-    const backReferences = new Map();
-    const visited = new Set([root.seedLocalId]);
-    const inProgress = new Set();
-    if (await getsNewSeed(root))
-        inProgress.add(root.seedLocalId);
-    /** Draft target of a ref, or undefined (published, revoked, unknown). */
-    const draftTarget = async (prop, ref, isList) => {
-        const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(ref);
-        if (!seedLocalId && !seedUid) {
-            if (strict && !isList) {
-                throw new Error(`Invalid relation value for ${prop.propertyName}: expected local seed id or 0x uid`);
-            }
-            return undefined;
-        }
-        const row = await findRelatedSeedRow({ seedLocalId, seedUid });
-        const targetLocalId = row?.seedLocalId ?? seedLocalId;
-        if (!targetLocalId)
-            return undefined;
-        // An item getting a new seed in this publish, still being walked (also the root when it is a
-        // revoked seed published again): a back edge, whatever its current uid.
-        if (inProgress.has(targetLocalId))
-            return { seedLocalId: targetLocalId };
-        // Published (live or revoked): referenced by uid / reported, never walked into.
-        if (row && !isZeroUid(row.seedUid))
-            return undefined;
-        if (visited.has(targetLocalId))
-            return { seedLocalId: targetLocalId };
-        const item = await loadItem(targetLocalId, loads);
-        if (!item) {
-            if (strict && !isList && !isPublishedSeedRef(ref)) {
-                throw new Error(`No relatedItem found for ${prop.propertyName}`);
-            }
-            return undefined;
-        }
-        if (!isZeroUid(item.seedUid))
-            return undefined;
-        return { seedLocalId: targetLocalId, item };
-    };
-    const visit = async (item) => {
-        const segmented = await getSegmentedItemProperties(item);
-        const { relationProperties, listProperties } = draftWalkProperties(segmented);
-        const walk = async (prop, isList) => {
-            if (!walksProperty(prop, forceFullSnapshot))
-                return;
-            const targets = [];
-            for (const ref of propertySeedRefs(prop, isList)) {
-                const t = await draftTarget(prop, ref, isList);
-                if (t)
-                    targets.push(t);
-            }
-            const back = targets.filter((t) => inProgress.has(t.seedLocalId)).map((t) => t.seedLocalId);
-            if (back.length > 0) {
-                deferredProperties.add(prop);
-                backReferences.set(prop, new Set(back));
-            }
-            for (const t of targets) {
-                if (!t.item || visited.has(t.seedLocalId))
-                    continue;
-                visited.add(t.seedLocalId);
-                inProgress.add(t.seedLocalId);
-                await visit(t.item);
-                inProgress.delete(t.seedLocalId);
-                drafts.push({ item: t.item, via: prop, viaList: isList });
-            }
-        };
-        for (const prop of relationProperties)
-            await walk(prop, false);
-        for (const prop of listProperties)
-            await walk(prop, true);
-    };
-    try {
-        await visit(root);
-    }
-    catch (err) {
-        if (!options?.loads)
-            loads.release();
-        throw err;
-    }
-    if (!options?.loads)
-        loads.release(drafts.map((d) => d.item));
-    return { drafts, deferredProperties, backReferences };
-}
-
-var publishDraftGraph = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    draftWalkProperties: draftWalkProperties,
-    getPublishDraftGraph: getPublishDraftGraph,
-    getsNewSeed: getsNewSeed,
-    propertySeedRefs: propertySeedRefs
-});
-
-export { ItemLoads as I, getSegmentedItemProperties as a, isUnpublishedSeed as b, isLivePublishedSeed as c, draftWalkProperties as d, findRelatedSeedRow as f, getPublishDraftGraph as g, htmlPropertyNameForHtmlSeed as h, isSeedRevoked as i, publishDraftGraph as p, relatedModelNameFromDef as r, withItemLoads as w };
-//# sourceMappingURL=publishDraftGraph-DBWAN72w.js.map