@seedprotocol/sdk 0.4.21 → 0.4.23

package/dist/syncDbWithEas-m-_3Ds7d.js

@@ -0,0 +1,582 @@
+import { camelCase, startCase } from 'lodash-es';
+import { p as BaseDb, ae as modelUids, A as models, X as toSnakeCase, s as seeds, ap as getAllAddressesFromDb, q as getGetAdditionalSyncAddresses, aq as getModelSchemasFromEas, ar as getSeedsFromSchemaUids, as as getItemVersionsFromEas, at as getItemPropertiesFromEas, au as pickLatestPropertyAttestationsByRefAndSchema, av as scheduleBulkFilesDownloadFromEasSync, aw as eventEmitter, ax as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, ay as generateId, az as escapeSqliteString, am as versions, a7 as BaseQueryClient, a5 as BaseEasClient, aA as GET_SEEDS, aB as GET_VERSIONS, aC as GET_PROPERTIES, ab as metadata, aD as setSchemaUidForSchemaDefinition, aE as parseEasRelationPropertyName, K as modelPropertiesToObject, ao as getPropertyIdForModelAndName } from './index-18lln0cM.js';
+import { eq, inArray, sql, and } from 'drizzle-orm';
+import pluralize from 'pluralize';
+import { u as updateSeedRevokedAt } from './updateSeedRevokedAt-BvAK-Rfh.js';
+import 'xstate';
+import 'drizzle-orm/sqlite-core';
+import 'nanoid';
+import 'nanoid-dictionary';
+import 'debug';
+import 'ethers';
+import '@sinclair/typebox';
+import 'drizzle-orm/casing';
+import 'rxjs';
+import 'arweave';
+import 'js-sha3';
+
+// Dynamic import to break circular dependency: Model -> BaseItem -> ... -> getModelSchemas -> Model
+// import { Model } from '@/Model/Model'
+const schemaStringToModelRecord = new Map();
+const getModelSchemas = async () => {
+    // Dynamic import to break circular dependency
+    const _mod_0 = await import('./index-18lln0cM.js');
+    const _ns_0 = _mod_0.cd;
+    const modelMod = _ns_0;
+    const { Model } = modelMod;
+    const allModels = await Model.all();
+    const modelRecords = [];
+    const appDb = BaseDb.getAppDb();
+    for (const model of allModels) {
+        const modelName = model.modelName;
+        if (!modelName)
+            continue;
+        const foundModelQuery = await appDb
+            .select({
+            id: models.id,
+            name: models.name,
+            uid: modelUids.uid,
+        })
+            .from(models)
+            .leftJoin(modelUids, eq(models.id, modelUids.modelId))
+            .where(eq(models.name, modelName))
+            .limit(1);
+        if (!foundModelQuery[0]) {
+            console.error(`[item/events] [syncDbWithEas] model ${modelName} not found in SDK DB`);
+            continue;
+        }
+        const foundModel = {
+            id: foundModelQuery[0].id,
+            name: foundModelQuery[0].name,
+            uid: foundModelQuery[0].uid,
+            tableName: pluralize(foundModelQuery[0].name).toLowerCase(),
+        };
+        modelRecords.push(foundModel);
+        if (modelName === 'Seed') {
+            continue;
+        }
+        const schemaString = `bytes32 ${toSnakeCase(modelName)}`;
+        schemaStringToModelRecord.set(schemaString, foundModel);
+    }
+    return {
+        schemaStringToModelRecord,
+        modelRecords,
+    };
+};
+
+const createSeeds = async (newSeeds) => {
+    const appDb = BaseDb.getAppDb();
+    const results = await appDb
+        .insert(seeds)
+        .values(newSeeds)
+        .returning({ uid: seeds.uid });
+    const newUids = results.reduce((acc, result) => {
+        if (result.uid) {
+            acc.push(result.uid);
+        }
+        return acc;
+    }, []);
+    return newUids;
+};
+
+const relationValuesToExclude = [
+    '0x0000000000000000000000000000000000000000000000000000000000000020',
+];
+const seedUidToLocalId = new Map();
+const seedUidToModelType = new Map();
+const relatedSeedUids = new Set();
+const versionUidToLocalId = new Map();
+const versionUidToSeedUid = new Map();
+const propertyUidToLocalId = new Map();
+const saveEasSeedsToDb = async ({ itemSeeds }) => {
+    const appDb = BaseDb.getAppDb();
+    const seedUids = itemSeeds.map((seed) => seed.id);
+    const existingSeedRecordsRows = await appDb
+        .select()
+        .from(seeds)
+        .where(inArray(seeds.uid, seedUids));
+    const existingSeedUids = new Set();
+    if (existingSeedRecordsRows && existingSeedRecordsRows.length > 0) {
+        for (const row of existingSeedRecordsRows) {
+            if (row.uid) {
+                existingSeedUids.add(row.uid);
+                if (row.localId) {
+                    seedUidToLocalId.set(row.uid, row.localId);
+                }
+                if (row.type) {
+                    seedUidToModelType.set(row.uid, row.type);
+                }
+            }
+        }
+    }
+    const newSeeds = itemSeeds.filter((seed) => !existingSeedUids.has(seed.id));
+    // Update existing seeds when attestations are revoked on EAS
+    const seedByUid = new Map(itemSeeds.map((s) => [s.id, s]));
+    for (const row of existingSeedRecordsRows) {
+        if (!row.uid || !row.localId)
+            continue;
+        const attestation = seedByUid.get(row.uid);
+        if (!attestation?.revoked)
+            continue;
+        if (row.revokedAt != null)
+            continue;
+        const revokedAt = attestation.revocationTime > 0
+            ? attestation.revocationTime
+            : Math.floor(Date.now() / 1000);
+        await updateSeedRevokedAt({ seedLocalId: row.localId, revokedAt });
+    }
+    if (newSeeds.length === 0) {
+        return { seedUidToLocalId, seedUids };
+    }
+    const newSeedsData = [];
+    for (let i = 0; i < newSeeds.length; i++) {
+        const seed = newSeeds[i];
+        seedUidToModelType.set(seed.id, seed.schema.schemaNames[0].name);
+        const seedLocalId = generateId();
+        seedUidToLocalId.set(seed.id, seedLocalId);
+        const attestationRaw = escapeSqliteString(JSON.stringify(seed));
+        const revokedAt = seed.revoked && seed.revocationTime != null && seed.revocationTime > 0
+            ? seed.revocationTime
+            : seed.revoked
+                ? Math.floor(Date.now() / 1000)
+                : undefined;
+        newSeedsData.push({
+            localId: seedLocalId,
+            uid: seed.id,
+            schemaUid: seed.schemaId,
+            type: seed.schema.schemaNames[0].name,
+            publisher: seed.attester,
+            createdAt: Date.now(),
+            attestationCreatedAt: seed.timeCreated * 1000,
+            attestationRaw,
+            ...(revokedAt !== undefined && { revokedAt }),
+        });
+        seedUidToLocalId.set(seed.id, seedLocalId);
+    }
+    const newSeedUids = await createSeeds(newSeedsData);
+    return { seedUids: newSeedUids };
+};
+const saveEasVersionsToDb = async ({ itemVersions }) => {
+    const versionUids = itemVersions.map((version) => version.id);
+    const appDb = BaseDb.getAppDb();
+    const existingVersionRecordsRows = await appDb
+        .select()
+        .from(versions)
+        .where(inArray(versions.uid, versionUids));
+    const existingVersionUids = new Set();
+    if (existingVersionRecordsRows && existingVersionRecordsRows.length > 0) {
+        for (const row of existingVersionRecordsRows) {
+            if (row.uid) {
+                existingVersionUids.add(row.uid);
+                if (row.localId) {
+                    versionUidToLocalId.set(row.uid, row.localId);
+                }
+                if (row.seedUid) {
+                    versionUidToSeedUid.set(row.uid, row.seedUid);
+                }
+            }
+        }
+    }
+    const newVersions = itemVersions.filter((version) => !existingVersionUids.has(version.id));
+    if (newVersions.length === 0) {
+        return { versionUidToLocalId, versionUids };
+    }
+    let insertVersionsQuery = `INSERT INTO versions (local_id, uid, seed_uid, seed_local_id, seed_type, created_at,
+                                                   attestation_created_at,
+                                                   attestation_raw, publisher)
+  VALUES `;
+    for (let i = 0; i < newVersions.length; i++) {
+        const version = newVersions[i];
+        versionUidToSeedUid.set(version.id, version.refUID);
+        const versionLocalId = generateId();
+        versionUidToLocalId.set(version.id, versionLocalId);
+        const seedUid = versionUidToSeedUid.get(version.id);
+        const seedLocalId = seedUidToLocalId.get(seedUid);
+        const seedType = seedUidToModelType.get(seedUid);
+        const attestationRaw = escapeSqliteString(JSON.stringify(version));
+        const publisher = escapeSqliteString(version.attester ?? '');
+        const valuesString = `('${versionLocalId}', '${version.id}', '${seedUid}', '${seedLocalId}', '${seedType}', ${Date.now()}, ${version.timeCreated * 1000}, '${attestationRaw}', '${publisher}')`;
+        if (i < newVersions.length - 1) {
+            insertVersionsQuery += valuesString + ', ';
+        }
+        if (i === newVersions.length - 1) {
+            insertVersionsQuery += valuesString + ';';
+        }
+        versionUidToLocalId.set(version.id, versionLocalId);
+    }
+    await appDb.run(sql.raw(insertVersionsQuery));
+    return { versionUids };
+};
+const createMetadataRecordsForStorageTransactionId = async (storageTransactionIdProperty, modelSchema) => {
+    // Early return if modelSchema is not provided
+    if (!modelSchema) {
+        console.warn('[item/events] [syncDbWithEas] modelSchema is undefined for storageTransactionIdProperty: ', storageTransactionIdProperty.id);
+        return;
+    }
+    // Validate and parse decodedDataJson
+    if (!storageTransactionIdProperty.decodedDataJson || storageTransactionIdProperty.decodedDataJson.trim() === '') {
+        console.warn('[item/events] [syncDbWithEas] empty decodedDataJson for storageTransactionIdProperty: ', storageTransactionIdProperty.id);
+        return;
+    }
+    let parsedData;
+    try {
+        parsedData = JSON.parse(storageTransactionIdProperty.decodedDataJson);
+    }
+    catch (error) {
+        console.warn('[item/events] [syncDbWithEas] failed to parse decodedDataJson for storageTransactionIdProperty: ', storageTransactionIdProperty.id, error);
+        return;
+    }
+    if (!Array.isArray(parsedData) || parsedData.length === 0 || !parsedData[0]?.value) {
+        console.warn('[item/events] [syncDbWithEas] invalid decodedDataJson structure for storageTransactionIdProperty: ', storageTransactionIdProperty.id);
+        return;
+    }
+    const attestationData = parsedData[0].value;
+    camelCase(attestationData.name);
+    const propertyValue = attestationData.value;
+    const itemStorageProperties = new Map();
+    for (const [_propertyName, propertyDef] of Object.entries(modelSchema)) {
+        if (propertyDef?.storageType && propertyDef.storageType === 'ItemStorage') {
+            itemStorageProperties.set(_propertyName, propertyDef);
+        }
+    }
+    if (itemStorageProperties.size === 0) {
+        return;
+    }
+    const appDb = BaseDb.getAppDb();
+    for (const [_propertyName, propertyDef] of itemStorageProperties.entries()) {
+        const existingMetadataRecordRows = await appDb
+            .select()
+            .from(metadata)
+            .where(and(eq(metadata.propertyName, _propertyName), eq(metadata.propertyValue, propertyValue), eq(metadata.versionUid, storageTransactionIdProperty.refUID)));
+        if (existingMetadataRecordRows && existingMetadataRecordRows.length > 0) {
+            continue;
+        }
+        const seedUid = versionUidToSeedUid.get(storageTransactionIdProperty.refUID);
+        const seedLocalId = seedUidToLocalId.get(seedUid);
+        const versionUid = storageTransactionIdProperty.refUID;
+        const versionLocalId = versionUidToLocalId.get(versionUid);
+        const modelType = seedUidToModelType.get(seedUid);
+        const propertyId = modelType != null
+            ? await getPropertyIdForModelAndName(modelType, _propertyName)
+            : null;
+        const propertyLocalId = generateId();
+        await appDb.insert(metadata).values({
+            localId: propertyLocalId,
+            propertyId: propertyId ?? undefined,
+            propertyName: _propertyName,
+            propertyValue,
+            localStorageDir: propertyDef.localStorageDir,
+            seedLocalId,
+            seedUid,
+            versionLocalId,
+            versionUid,
+            refValueType: 'file',
+            refResolvedValue: `${propertyValue}${propertyDef.filenameSuffix}`,
+            modelType: seedUidToModelType.get(seedUid),
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        });
+    }
+};
+/** Serialize property saves: concurrent `runSyncFromEas` used to hit `isSavingToDb` and return `{}` with no insert. */
+let saveEasPropertiesDbChain = Promise.resolve();
+const saveEasPropertiesToDbBody = async ({ itemProperties, itemSeeds, }) => {
+    const propertyUids = itemProperties.map((property) => property.id);
+    // Dynamic import to break circular dependency
+    const _mod_1 = await import('./index-18lln0cM.js');
+    const _ns_1 = _mod_1.cd;
+    const modelMod = _ns_1;
+    const { Model } = modelMod;
+    const allModels = await Model.all();
+    const models = Object.fromEntries(allModels.map(m => [m.modelName, m]));
+    const appDb = BaseDb.getAppDb();
+    const existingMetadataRecordsRows = await appDb
+        .select()
+        .from(metadata)
+        .where(inArray(metadata.uid, propertyUids));
+    const existingPropertyRecordsUids = new Set();
+    if (existingMetadataRecordsRows && existingMetadataRecordsRows.length > 0) {
+        for (const row of existingMetadataRecordsRows) {
+            if (row.uid) {
+                existingPropertyRecordsUids.add(row.uid);
+                if (row.localId) {
+                    propertyUidToLocalId.set(row.uid, row.localId);
+                }
+            }
+        }
+    }
+    const newProperties = itemProperties.filter((property) => !existingPropertyRecordsUids.has(property.id));
+    if (newProperties.length === 0) {
+        return { propertyUidToLocalId, propertyUids };
+    }
+    let insertPropertiesQuery = `INSERT INTO metadata (local_id, uid, schema_uid, property_id, property_name, property_value,
+                                                     eas_data_type, version_uid, version_local_id, seed_uid,
+                                                     seed_local_id, model_type, ref_value_type, ref_seed_type,
+                                                     ref_schema_uid,
+                                                     created_at, attestation_created_at, attestation_raw,
+                                                     local_storage_dir, ref_resolved_value, publisher)
+  VALUES `;
+    for (let i = 0; i < newProperties.length; i++) {
+        const property = newProperties[i];
+        const propertyLocalId = generateId();
+        // Validate and parse decodedDataJson
+        if (!property.decodedDataJson || property.decodedDataJson.trim() === '') {
+            console.warn('[item/events] [syncDbWithEas] empty decodedDataJson for property: ', property.id);
+            continue;
+        }
+        let parsedData;
+        try {
+            parsedData = JSON.parse(property.decodedDataJson);
+        }
+        catch (error) {
+            console.warn('[item/events] [syncDbWithEas] failed to parse decodedDataJson for property: ', property.id, error);
+            continue;
+        }
+        if (!Array.isArray(parsedData) || parsedData.length === 0 || !parsedData[0]?.value) {
+            console.warn('[item/events] [syncDbWithEas] invalid decodedDataJson structure for property: ', property.id);
+            continue;
+        }
+        const metadata = parsedData[0].value;
+        let propertyNameSnake = metadata.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 ((propertyNameSnake.endsWith('_id') ||
+            propertyNameSnake.endsWith('_ids')) &&
+            propertyNameSnake !== 'storage_transaction_id' &&
+            propertyNameSnake !== 'storage_provider_transaction_id') {
+            isRelation = true;
+            if (Array.isArray(metadata.value)) {
+                isList = true;
+                refValueType = 'list';
+                const result = parseEasRelationPropertyName(propertyNameSnake);
+                if (result) {
+                    propertyNameSnake = result.propertyName;
+                    refSeedType = result.modelName;
+                }
+                metadata.value.forEach((value) => {
+                    relatedSeedUids.add(value);
+                });
+            }
+            if (!isList) {
+                if (relationValuesToExclude.includes(metadata.value)) {
+                    continue;
+                }
+                relatedSeedUids.add(metadata.value);
+            }
+        }
+        let propertyValue = metadata.value;
+        if (typeof propertyValue !== 'string') {
+            propertyValue = JSON.stringify(propertyValue);
+        }
+        if (isRelation && !isList) {
+            const relatedSeed = itemSeeds.find((seed) => seed.id === metadata.value);
+            if (relatedSeed && relatedSeed.schema && relatedSeed.schema.schemaNames) {
+                refSeedType = relatedSeed.schema.schemaNames[0].name;
+                refSchemaUid = relatedSeed.schemaId;
+            }
+        }
+        if (isRelation && isList) {
+            const relatedSeeds = itemSeeds.filter((seed) => metadata.value.includes(seed.id));
+            if (relatedSeeds && relatedSeeds.length > 0) {
+                refSeedType = relatedSeeds[0].schema.schemaNames[0].name;
+                refSchemaUid = relatedSeeds[0].schemaId;
+            }
+        }
+        const propertyName = camelCase(propertyNameSnake);
+        propertyValue = escapeSqliteString(propertyValue);
+        const easDataType = metadata.type;
+        const versionUid = property.refUID;
+        const versionLocalId = versionUidToLocalId.get(versionUid);
+        const attestationCreatedAt = property.timeCreated * 1000;
+        const attestationRaw = escapeSqliteString(JSON.stringify(property));
+        const seedUid = versionUidToSeedUid.get(versionUid);
+        const seedLocalId = seedUidToLocalId.get(seedUid);
+        const modelType = seedUidToModelType.get(seedUid);
+        const modelName = startCase(modelType);
+        const model = models[modelName];
+        const modelSchema = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
+        if (propertyNameSnake === 'storage_transaction_id') {
+            await createMetadataRecordsForStorageTransactionId(property, modelSchema);
+        }
+        const propertyId = modelType != null
+            ? await getPropertyIdForModelAndName(modelType, propertyName)
+            : null;
+        const propertyIdSql = propertyId != null ? String(propertyId) : 'NULL';
+        const publisher = escapeSqliteString(property.attester ?? '');
+        const valuesString = `('${propertyLocalId}', '${property.id}', 
+                         '${property.schemaId}', ${propertyIdSql}, '${propertyName}', 
+                         '${propertyValue}', '${easDataType}', '${versionUid}', 
+                         '${versionLocalId}', '${seedUid}', '${seedLocalId}', 
+                         '${modelType}', ${refValueType ? `'${refValueType}'` : 'NULL'}, 
+                         ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                         ${refSchemaUid ? `'${refSchemaUid}'` : 'NULL'},
+                         ${Date.now()}, ${attestationCreatedAt}, '${attestationRaw}',
+                         ${'NULL'},
+                         ${'NULL'},
+                         '${publisher}')`;
+        if (i < newProperties.length - 1) {
+            insertPropertiesQuery += valuesString + ', ';
+        }
+        if (i === newProperties.length - 1) {
+            insertPropertiesQuery += valuesString + ';';
+        }
+        propertyUidToLocalId.set(property.id, propertyLocalId);
+    }
+    if (insertPropertiesQuery.endsWith('VALUES ')) {
+        return { propertyUids };
+    }
+    if (insertPropertiesQuery.endsWith(', ')) {
+        insertPropertiesQuery = insertPropertiesQuery.slice(0, -2) + ';';
+    }
+    await appDb.run(sql.raw(insertPropertiesQuery));
+    return { propertyUids };
+};
+const saveEasPropertiesToDb = (params) => {
+    const next = saveEasPropertiesDbChain.then(() => saveEasPropertiesToDbBody(params));
+    saveEasPropertiesDbChain = next.then(() => undefined, () => undefined);
+    return next;
+};
+const getRelatedSeedsAndVersions = async () => {
+    BaseQueryClient.getQueryClient();
+    const easClient = BaseEasClient.getEasClient();
+    const { itemSeeds } = await easClient.request(GET_SEEDS, {
+        where: {
+            id: {
+                in: Array.from(relatedSeedUids),
+            },
+        },
+    });
+    await saveEasSeedsToDb({ itemSeeds });
+    const { itemVersions } = await easClient.request(GET_VERSIONS, {
+        where: {
+            refUID: {
+                in: Array.from(relatedSeedUids),
+            },
+        },
+    });
+    await saveEasVersionsToDb({ itemVersions });
+    const relatedVersionUids = itemVersions.map((v) => v.id);
+    const { itemProperties } = await easClient.request(GET_PROPERTIES, {
+        where: {
+            refUID: {
+                in: relatedVersionUids,
+            },
+        },
+    });
+    await saveEasPropertiesToDb({
+        itemProperties,
+        itemSeeds,
+    });
+};
+/**
+ * Core sync logic: fetches item attestations from EAS for configured models and given addresses,
+ * then saves seeds, versions, and properties to the local DB.
+ * Uses owned + watched addresses from DB when addresses are not provided.
+ */
+const runSyncFromEas = async (options) => {
+    let addresses = options?.addresses ?? (await getAllAddressesFromDb());
+    const additionalGetter = getGetAdditionalSyncAddresses();
+    if (additionalGetter) {
+        const additional = await additionalGetter();
+        if (additional?.length) {
+            const seen = new Set(addresses.map((a) => a.toLowerCase()));
+            for (const addr of additional) {
+                if (addr && !seen.has(addr.toLowerCase())) {
+                    seen.add(addr.toLowerCase());
+                    addresses = [...addresses, addr];
+                }
+            }
+        }
+    }
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
+    const appDb = BaseDb.getAppDb();
+    const { schemaStringToModelRecord } = await getModelSchemas();
+    const modelSchemas = await getModelSchemasFromEas();
+    const schemaUids = [];
+    for (const modelSchema of modelSchemas) {
+        const foundModel = schemaStringToModelRecord.get(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
+            console.warn(`[item/events] [syncDbWithEas] Model not found for schema ${modelSchema.schema}, skipping`);
+            continue;
+        }
+        try {
+            await appDb
+                .insert(modelUids)
+                .values({
+                modelId: foundModel.id,
+                uid: modelSchema.id,
+            })
+                .onConflictDoNothing();
+        }
+        catch (err) {
+            // Model may have been deleted by test teardown or another process; skip to avoid unhandled rejection
+            const e = err;
+            const code = e?.code ?? e?.rawCode ?? e?.cause?.code ?? e?.cause?.rawCode;
+            if (code === 'SQLITE_CONSTRAINT_FOREIGNKEY' || code === 787) {
+                continue;
+            }
+            throw err;
+        }
+        schemaUids.push(modelSchema.id);
+    }
+    // If no schemas were found, skip the rest of the sync process
+    // This can happen when models exist but don't have schemas registered in EAS yet
+    if (schemaUids.length === 0) {
+        return;
+    }
+    const itemSeeds = await getSeedsFromSchemaUids({
+        schemaUids,
+        addresses,
+        excludeRevoked: false,
+    });
+    const { seedUids } = await saveEasSeedsToDb({
+        itemSeeds,
+    });
+    const itemVersions = await getItemVersionsFromEas({
+        seedUids,
+        excludeRevoked: false,
+    });
+    const { versionUids } = await saveEasVersionsToDb({
+        itemVersions,
+    });
+    const rawProperties = await getItemPropertiesFromEas({
+        versionUids,
+        excludeRevoked: false,
+    });
+    const itemProperties = pickLatestPropertyAttestationsByRefAndSchema(rawProperties);
+    await saveEasPropertiesToDb({
+        itemProperties,
+        itemSeeds,
+    });
+    await getRelatedSeedsAndVersions();
+    scheduleBulkFilesDownloadFromEasSync(addresses);
+    try {
+        const _mod_2 = await import('./index-18lln0cM.js');
+        const _ns_2 = _mod_2.ca;
+        const itemMod = _ns_2;
+        await itemMod.Item.rehydrateCachedItemsFromDbAfterEasSync();
+    }
+    catch (err) {
+        console.warn('[item/events] [syncDbWithEas] rehydrateCachedItemsFromDbAfterEasSync:', err);
+    }
+    eventEmitter.emit(EAS_SEED_DATA_SYNCED_TO_DB_EVENT);
+};
+
+export { runSyncFromEas };
+//# sourceMappingURL=syncDbWithEas-m-_3Ds7d.js.map