@seedprotocol/sdk 0.7.4-next.784.g879c6a3 → 0.7.4

package/dist/{syncDbWithEas-B-Ho0IOB.js → syncDbWithEas-CRpnkq00.js}

@@ -1,22 +1,21 @@
-import { E as BaseDb, r as modelUids, s as models, H as toSnakeCase, X as normalizePublisher, A as seeds, Y as getAllAddressesFromDb, Z as scheduleBulkFilesDownloadFromEasSync, _ as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, $ as generateId, a0 as normalizeHexAddress, C as versions, m as metadata, K as getPropertyIdForModelAndName, L as resolveItemModelFileId, a1 as getItemStoragePropertiesForModel } from './BasePathResolver-DxdS0wJ0.js';
-import { r as resolveModelForSyncedSeed, s as skipSeedOnAmbiguousModel } from './resolveModelForSyncedSeed-BTAeCOJE.js';
+import { E as BaseDb, r as modelUids, s as models, X as normalizePublisher, A as seeds, Y as getAllAddressesFromDb, Z as scheduleBulkFilesDownloadFromEasSync, _ as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, $ as generateId, a0 as normalizeHexAddress, C as versions, m as metadata, K as getPropertyIdForModelAndName, L as resolveItemModelFileId, n as normalizeDataType, a1 as listRelationEasPropertyName, a2 as easPropertyNameForPublish, a3 as toMetadataPropertyName, a4 as getItemStoragePropertiesForModel } from './BasePathResolver-DrzGVH9L.js';
+import { r as resolveModelForSyncedSeed, s as skipSeedOnAmbiguousModel } from './resolveModelForSyncedSeed-RUsgAZXG.js';
 import { camelCase } from 'lodash-es';
-import { getSeedsFromSchemaUids, getItemVersionsFromEas, partitionByRefAttester, getItemPropertiesFromEas, BaseEasClient, GET_SEEDS, pickLatestPropertyAttestationsByRefAndSchema, setSchemaUidForSchemaDefinition } from '@seedprotocol/eas';
-import { parseEasPropertyMetadata, parseEasRelationPropertyName } from '@seedprotocol/query';
+import { easName, matchEasName, getSeedsFromSchemaUids, getItemVersionsFromEas, partitionByRefAttester, getItemPropertiesFromEas, BaseEasClient, GET_SEEDS, pickLatestPropertyAttestationsByRefAndSchema, setSchemaUidForSchemaDefinition } from '@seedprotocol/eas';
+import pluralize from 'pluralize';
 import { eq, inArray, and, or, isNull, ne, isNotNull } from 'drizzle-orm';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
-import pluralize from 'pluralize';
-import { a as chunkValues, b as rowsPerInsert, d as getGetAdditionalSyncAddresses, s as selectInBatches, w as writeInBatches } from './Item-cq9VcsAY.js';
-import { u as updateSeedRevokedAt } from './updateSeedRevokedAt-IHXnJI-i.js';
-import { getModelSchemasFromEas } from './eas-D_6ptL_F.js';
-import { w as waitForEasReadChain, a as assertLocalDbChain } from './ClientManager-De-vKHGe.js';
-import { e as emitAcrossTabs } from './tabEvents-BTzckWrN.js';
+import { parseEasPropertyMetadata, parseEasRelationPropertyName } from '@seedprotocol/query';
+import { a as chunkValues, r as rowsPerInsert, b as getGetAdditionalSyncAddresses, s as selectInBatches, w as writeInBatches } from './Item-BUUFuywT.js';
+import { u as updateSeedRevokedAt } from './updateSeedRevokedAt-DtTPSzpM.js';
+import { getModelSchemasFromEas } from './eas-Dq5Kx_Nd.js';
+import { w as waitForEasReadChain, a as assertLocalDbChain } from './ClientManager-Dfu4jcgm.js';
+import { e as emitAcrossTabs } from './tabEvents-nBUq_1u1.js';
 import 'debug';
 import '@seedprotocol/arweave';
 import 'xstate';
 import '@sinclair/typebox';
 import 'drizzle-orm/sqlite-core';
-import 'drizzle-orm/casing';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
@@ -29,7 +28,7 @@ import 'rxjs';
 const schemaStringToModelRecord = new Map();
 const getModelSchemas = async () => {
     // Dynamic import to break circular dependency
-    const _mod_0 = await import('./errors-Cl8rbtKR.js');
+    const _mod_0 = await import('./errors-DdWbxb_n.js');
     const _ns_0 = _mod_0.h;
     const modelMod = _ns_0;
     const { Model } = modelMod;
@@ -65,12 +64,26 @@ const getModelSchemas = async () => {
         if (modelName === 'Seed') {
             continue;
         }
-        const schemaString = `bytes32 ${toSnakeCase(modelName)}`;
+        const schemaString = `bytes32 ${easName(modelName)}`;
         schemaStringToModelRecord.set(schemaString, foundModel);
     }
+    // One candidate per name: same-named models in several schemas share one EAS schema.
+    const byName = new Map();
+    for (const record of modelRecords) {
+        if (record.name !== 'Seed')
+            byName.set(record.name, record);
+    }
+    const candidates = [...byName.values()].map((record) => ({ value: record, name: record.name }));
+    const matchModelRecord = (schemaString) => {
+        if (!schemaString.startsWith('bytes32 '))
+            return undefined;
+        const match = matchEasName(schemaString.slice('bytes32 '.length), candidates);
+        return match.kind === 'match' ? match.value : undefined;
+    };
     return {
         schemaStringToModelRecord,
         modelRecords,
+        matchModelRecord,
     };
 };
 
@@ -132,22 +145,100 @@ const createSyncRunState = () => ({
 const isRelationPropertyName = (propertyNameSnake) => (propertyNameSnake.endsWith('_id') || propertyNameSnake.endsWith('_ids')) &&
     propertyNameSnake !== 'storage_transaction_id' &&
     propertyNameSnake !== 'storage_provider_transaction_id';
+const RELATION_DATA_TYPES = new Set(['Relation', 'Image', 'File', 'Html']);
+/**
+ * The local property an EAS property name stands for (ADR 0008): matched against the model's
+ * properties by the names publish writes for them (exact, then normalized, then fuzzy), not by
+ * reversing the EAS name. The row is stored under the name sync has always used for that property:
+ * a list relation's schema key, a single relation's `<key>Id`, anything else its key. A relation is
+ * whatever the local property is, whatever its EAS name ends in.
+ *
+ * With no model, or no matching property, the EAS name decides as before (`_id`/`_ids` are
+ * relations), so related seeds are still followed for discovery. Undefined: the name matches
+ * several local properties equally well, and the attestation is skipped.
+ */
+const resolveSyncedPropertyName = (easPropertyName, value, modelSchema) => {
+    const internal = easPropertyName === 'storage_transaction_id' || easPropertyName === 'storage_provider_transaction_id';
+    if (modelSchema && !internal) {
+        const candidates = Object.entries(modelSchema).map(([key, def]) => {
+            const dataType = normalizeDataType(def?.dataType);
+            const refValueType = normalizeDataType(def?.refValueType);
+            const isListRelation = !!listRelationEasPropertyName(key, def);
+            const isSingleRef = !isListRelation && (RELATION_DATA_TYPES.has(dataType) || RELATION_DATA_TYPES.has(refValueType));
+            return {
+                value: { key, def, isListRelation, isSingleRef },
+                name: easPropertyNameForPublish(key, { ...def, name: key }),
+                relation: isListRelation || isSingleRef,
+            };
+        });
+        const match = matchEasName(easPropertyName, candidates);
+        if (match.kind === 'ambiguous') {
+            console.warn(`[item/events] [syncDbWithEas] EAS property "${easPropertyName}" matches several local properties (${match.values
+                .map((v) => v.key)
+                .join(', ')}); skipping it`);
+            return undefined;
+        }
+        if (match.kind === 'match') {
+            const { key, def, isListRelation, isSingleRef } = match.value;
+            if (isListRelation) {
+                return { propertyName: key, isRelation: true, isList: true, refSeedType: def?.ref ? easName(def.ref) : undefined };
+            }
+            if (isSingleRef) {
+                return {
+                    propertyName: toMetadataPropertyName(key, def?.dataType, def?.refValueType),
+                    isRelation: true,
+                    isList: false,
+                };
+            }
+            return { propertyName: key, isRelation: false, isList: false };
+        }
+    }
+    if (!isRelationPropertyName(easPropertyName)) {
+        return { propertyName: camelCase(easPropertyName), isRelation: false, isList: false };
+    }
+    if (Array.isArray(value)) {
+        const parsed = parseEasRelationPropertyName(easPropertyName);
+        return {
+            propertyName: camelCase(parsed?.propertyName ?? easPropertyName),
+            isRelation: true,
+            isList: true,
+            refSeedType: parsed?.modelName,
+        };
+    }
+    return { propertyName: camelCase(easPropertyName), isRelation: true, isList: false };
+};
+/** The local model schema (properties object) of the seed a property attestation belongs to. */
+const modelSchemaForSyncedProperty = async (Model, property, state) => {
+    const seedUid = state.versionUidToSeedUid.get(property.refUID);
+    const modelType = seedUid ? state.seedUidToModelType.get(seedUid) : undefined;
+    if (modelType == null)
+        return undefined;
+    const seedLocalId = state.seedUidToLocalId.get(seedUid);
+    const model = await skipSeedOnAmbiguousModel({ seedLocalId, seedUid }, 'easSync.metadata', async () => resolveSyncedSeedModel(Model, modelType, { seedLocalId, seedUid }));
+    return model?.properties ? modelPropertiesToObject(model.properties) : undefined;
+};
 /**
  * Seed UIDs that relation properties point at. Collected from every property the run fetched, not
  * only newly stored ones, so related seeds are refreshed (new versions, revocations) on each sync.
  */
-const collectRelatedSeedUids = (properties, into) => {
+const collectRelatedSeedUids = async (properties, state) => {
+    const _mod_1 = await import('./errors-DdWbxb_n.js');
+    const _ns_1 = _mod_1.h;
+    const { Model } = _ns_1;
     for (const property of properties) {
         const parsed = parseEasPropertyMetadata(property.decodedDataJson);
         if (!parsed.ok)
             continue;
         const { name, value } = parsed.metadata;
-        if (!name || !isRelationPropertyName(name))
+        if (!name)
+            continue;
+        const modelSchema = await modelSchemaForSyncedProperty(Model, property, state);
+        if (!resolveSyncedPropertyName(name, value, modelSchema)?.isRelation)
             continue;
         const values = Array.isArray(value) ? value : [value];
         for (const v of values) {
             if (typeof v === 'string' && v && !relationValuesToExclude.includes(v))
-                into.add(v);
+                state.relatedSeedUids.add(v);
         }
     }
 };
@@ -182,6 +273,23 @@ const isSqlEscapedAttestationRaw = (stored, fresh) => {
     };
     return stored === JSON.stringify(withStoredRevocation).replace(/'/g, "''");
 };
+/**
+ * seeds.type for a seed whose EAS model name is `easModelName`: the type of the local model it
+ * matches (ADR 0008), so `htmlpage` from an older SDK is stored as `html_page`, the type local seeds
+ * of HTMLPage have. A name matching no local model, or several, is kept as it is.
+ */
+const localModelType = async (easModelName) => {
+    const _mod_2 = await import('./errors-DdWbxb_n.js');
+    const _ns_2 = _mod_2.h;
+    const { Model } = _ns_2;
+    try {
+        const model = Model.findByModelType(easModelName);
+        return model?.modelName ? easName(model.modelName) : easModelName;
+    }
+    catch {
+        return easModelName;
+    }
+};
 const saveEasSeedsToDb = async ({ itemSeeds, state }) => {
     const { seedUidToLocalId, seedUidToModelType } = state;
     const appDb = BaseDb.getAppDb();
@@ -234,7 +342,8 @@ const saveEasSeedsToDb = async ({ itemSeeds, state }) => {
     const newSeedsData = [];
     for (let i = 0; i < newSeeds.length; i++) {
         const seed = newSeeds[i];
-        seedUidToModelType.set(seed.id, seed.schema.schemaNames[0].name);
+        const modelType = await localModelType(seed.schema.schemaNames[0].name);
+        seedUidToModelType.set(seed.id, modelType);
         const seedLocalId = generateId();
         seedUidToLocalId.set(seed.id, seedLocalId);
         // createSeeds binds parameters: store the JSON as is.
@@ -243,14 +352,13 @@ const saveEasSeedsToDb = async ({ itemSeeds, state }) => {
         // EAS only knows the model by name; the seam may match it to a local model (not built yet).
         const modelFileId = await resolveModelForSyncedSeed({
             seedUid: seed.id,
-            modelType: seed.schema.schemaNames[0].name,
             schemaUid: seed.schemaId,
         });
         newSeedsData.push({
             localId: seedLocalId,
             uid: seed.id,
             schemaUid: seed.schemaId,
-            type: seed.schema.schemaNames[0].name,
+            type: modelType,
             ...(modelFileId && { modelFileId }),
             publisher: seed.attester ? normalizeHexAddress(seed.attester) : seed.attester,
             createdAt: Date.now(),
@@ -442,7 +550,7 @@ let saveEasPropertiesDbChain = Promise.resolve();
 const saveEasPropertiesToDbBody = async ({ fetchedProperties, itemSeeds, state, }) => {
     const itemProperties = pickLatestPropertyAttestationsByRefAndSchema(fetchedProperties, SYNC_CANONICAL_OPTIONS);
     const propertyUids = itemProperties.map((property) => property.id);
-    collectRelatedSeedUids(itemProperties, state.relatedSeedUids);
+    await collectRelatedSeedUids(itemProperties, state);
     const appDb = BaseDb.getAppDb();
     const storedRows = await selectInBatches(fetchedProperties.map((property) => property.id), (chunk) => appDb
         .select({ uid: metadata.uid, revokedAt: metadata.revokedAt })
@@ -569,9 +677,9 @@ const resolveSyncedSeedModel = async (Model, modelType, seed) => {
 const insertSyncedProperties = async ({ newProperties, itemSeeds, state, }) => {
     const { seedUidToLocalId, seedUidToModelType, versionUidToLocalId, versionUidToSeedUid } = state;
     // Dynamic import to break circular dependency
-    const _mod_1 = await import('./errors-Cl8rbtKR.js');
-    const _ns_1 = _mod_1.h;
-    const modelMod = _ns_1;
+    const _mod_3 = await import('./errors-DdWbxb_n.js');
+    const _ns_3 = _mod_3.h;
+    const modelMod = _ns_3;
     const { Model } = modelMod;
     // Loads every model into Model's cache, where resolveSyncedSeedModel looks them up.
     await Model.all();
@@ -596,37 +704,36 @@ const insertSyncedProperties = async ({ newProperties, itemSeeds, state, }) => {
             continue;
         }
         const propertyMetadata = parsed.metadata;
-        let propertyNameSnake = propertyMetadata.name;
+        const propertyNameSnake = propertyMetadata.name;
         if (!propertyNameSnake) {
             console.warn('[item/events] [syncDbWithEas] no propertyName found for property: ', property);
             continue;
         }
-        let isRelation = false;
-        let refValueType;
         let refSeedType;
         let refSchemaUid;
-        let isList = false;
         const schemaUid = property.schemaId;
         setSchemaUidForSchemaDefinition({
             text: propertyNameSnake,
             schemaUid,
         });
-        if (isRelationPropertyName(propertyNameSnake)) {
-            isRelation = true;
-            if (Array.isArray(propertyMetadata.value)) {
-                isList = true;
-                refValueType = 'list';
-                const result = parseEasRelationPropertyName(propertyNameSnake);
-                if (result) {
-                    propertyNameSnake = result.propertyName;
-                    refSeedType = result.modelName;
-                }
-            }
-            if (!isList) {
-                if (relationValuesToExclude.includes(propertyMetadata.value)) {
-                    continue;
-                }
-            }
+        const easDataType = propertyMetadata.type;
+        const versionUid = property.refUID;
+        const versionLocalId = versionUidToLocalId.get(versionUid);
+        const attestationCreatedAt = property.timeCreated * 1000;
+        const seedUid = versionUidToSeedUid.get(versionUid);
+        const seedLocalId = seedUidToLocalId.get(seedUid);
+        const modelType = seedUidToModelType.get(seedUid);
+        const modelSchema = await modelSchemaForSyncedProperty(Model, property, state);
+        // ADR 0008: the local property this EAS name stands for, and whether it's a relation.
+        const resolvedName = resolveSyncedPropertyName(propertyNameSnake, propertyMetadata.value, modelSchema);
+        if (!resolvedName)
+            continue;
+        const { propertyName, isRelation, isList } = resolvedName;
+        const refValueType = isRelation && isList ? 'list' : undefined;
+        if (isList)
+            refSeedType = resolvedName.refSeedType;
+        if (isRelation && !isList && relationValuesToExclude.includes(propertyMetadata.value)) {
+            continue;
         }
         let propertyValue = propertyMetadata.value;
         if (typeof propertyValue !== 'string') {
@@ -646,18 +753,6 @@ const insertSyncedProperties = async ({ newProperties, itemSeeds, state, }) => {
                 refSchemaUid = relatedSeeds[0].schemaId;
             }
         }
-        const propertyName = camelCase(propertyNameSnake);
-        const easDataType = propertyMetadata.type;
-        const versionUid = property.refUID;
-        const versionLocalId = versionUidToLocalId.get(versionUid);
-        const attestationCreatedAt = property.timeCreated * 1000;
-        const seedUid = versionUidToSeedUid.get(versionUid);
-        const seedLocalId = seedUidToLocalId.get(seedUid);
-        const modelType = seedUidToModelType.get(seedUid);
-        const model = modelType != null
-            ? await skipSeedOnAmbiguousModel({ seedLocalId, seedUid }, 'easSync.metadata', async () => resolveSyncedSeedModel(Model, modelType, { seedLocalId, seedUid }))
-            : undefined;
-        const modelSchema = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
         if (propertyNameSnake === 'storage_transaction_id') {
             await createMetadataRecordsForStorageTransactionId(property, modelSchema, state);
         }
@@ -811,11 +906,12 @@ const runSyncFromEas = async (options) => {
     // Never mix attestations from two chains in one local DB.
     await assertLocalDbChain();
     const appDb = BaseDb.getAppDb();
-    const { schemaStringToModelRecord } = await getModelSchemas();
+    const { matchModelRecord } = await getModelSchemas();
     const modelSchemas = await getModelSchemasFromEas();
     const schemaUids = [];
     for (const modelSchema of modelSchemas) {
-        const foundModel = schemaStringToModelRecord.get(modelSchema.schema);
+        // ADR 0008: matched by name, so seeds published under an older SDK's name are found too.
+        const foundModel = matchModelRecord(modelSchema.schema);
         if (!foundModel) {
             // Skip schemas that don't have a corresponding model in the user's config
             // This can happen with "bytes32 image" if there's no Image model defined
@@ -861,9 +957,9 @@ const runSyncFromEas = async (options) => {
     await getRelatedSeedsAndVersions(state);
     scheduleBulkFilesDownloadFromEasSync(addresses);
     try {
-        const _mod_2 = await import('./Item-cq9VcsAY.js');
-        const _ns_2 = _mod_2.a8;
-        const itemMod = _ns_2;
+        const _mod_4 = await import('./Item-BUUFuywT.js');
+        const _ns_4 = _mod_4.a6;
+        const itemMod = _ns_4;
         await itemMod.Item.rehydrateCachedItemsFromDbAfterEasSync();
     }
     catch (err) {
@@ -874,4 +970,4 @@ const runSyncFromEas = async (options) => {
 };
 
 export { VERSION_INSERT_BATCH, isSqlEscapedAttestationRaw, runSyncFromEas };
-//# sourceMappingURL=syncDbWithEas-B-Ho0IOB.js.map
+//# sourceMappingURL=syncDbWithEas-CRpnkq00.js.map