@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/getItems.ts

@@ -0,0 +1,70 @@
+import { ItemData } from '@/types'
+import { and, eq, gt, isNotNull, isNull, or, SQL, sql } from 'drizzle-orm'
+import { seeds } from '@/seedSchema'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { getVersionData } from './subqueries/versionData'
+
+type GetItemsDataProps = {
+  modelName?: string
+  deleted?: boolean
+}
+
+type GetItemsData = (props: GetItemsDataProps) => Promise<ItemData[]>
+
+export const getItemsData: GetItemsData = async ({
+  modelName,
+  deleted,
+}): Promise<ItemData[]> => {
+  const appDb = BaseDb.getAppDb()
+
+  const conditions: SQL[] = []
+
+  if (modelName) {
+    conditions.push(eq(seeds.type, modelName.toLowerCase()))
+  }
+
+  if (deleted) {
+    conditions.push(
+      or(
+        isNotNull(seeds._markedForDeletion),
+        eq(seeds._markedForDeletion, 1),
+      ) as SQL,
+    )
+  }
+
+  if (!deleted) {
+    conditions.push(
+      or(
+        isNull(seeds._markedForDeletion),
+        eq(seeds._markedForDeletion, 0),
+      ) as SQL,
+    )
+  }
+
+  const versionData = getVersionData()
+
+  let query = appDb
+    .with(versionData)
+    .select({
+      seedLocalId: seeds.localId,
+      seedUid: seeds.uid,
+      schemaUid: seeds.schemaUid,
+      modelName: sql<string>`${modelName}`,
+      attestationCreatedAt: seeds.attestationCreatedAt,
+      versionsCount: versionData.versionsCount,
+      lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+      lastLocalUpdateAt: versionData.lastLocalUpdateAt,
+      latestVersionUid: versionData.latestVersionUid,
+      latestVersionLocalId: versionData.latestVersionLocalId,
+      createdAt: seeds.createdAt,
+    })
+    .from(seeds)
+    .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+    .where(and(gt(versionData.versionsCount, 0), ...conditions))
+    .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+    .groupBy(seeds.localId)
+
+  const itemsData = (await query) as ItemData[]
+
+  return itemsData
+}

package/dist/src/getMetadata.ts

@@ -0,0 +1,40 @@
+import { BaseDb } from '@/db/Db/BaseDb'
+import { and, eq, SQL } from 'drizzle-orm'
+import { metadata, MetadataType } from '@/seedSchema'
+
+type GetMetadataProps =
+  | {
+    storageTransactionId?: string
+  }
+  | undefined
+
+type GetMetadata = (
+  props: GetMetadataProps,
+) => Promise<MetadataType | undefined>
+
+export const getMetadata: GetMetadata = async (props) => {
+  const appDb = BaseDb.getAppDb()
+
+  let storageTransactionId: string | undefined
+  if (props) {
+    storageTransactionId = props.storageTransactionId
+  }
+
+  const whereClauses: SQL[] = []
+
+  if (storageTransactionId) {
+    whereClauses.push(eq(metadata.propertyName, 'storageTransactionId'))
+    whereClauses.push(eq(metadata.propertyValue, storageTransactionId))
+  }
+
+  const metadataRows = await appDb
+    .select()
+    .from(metadata)
+    .where(and(...whereClauses))
+
+  if (!metadataRows || metadataRows.length === 0) {
+    return
+  }
+
+  return metadataRows[0]
+}

package/dist/src/getModelSchemas.ts

@@ -0,0 +1,89 @@
+import { getModels } from '@/stores/modelClass'
+import { GetSchemasQuery, Schema } from '@/graphql/gql/graphql'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { models as modelsTable, modelUids } from '@/seedSchema'
+import { eq } from 'drizzle-orm'
+import pluralize from 'pluralize'
+import { toSnakeCase } from '@/helpers'
+import { GET_SCHEMAS } from '@/Item/queries'
+import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
+
+
+type GetModelSchemasReturn = {
+  modelSchemas: GetSchemasQuery
+  schemaStringToModelRecord: Map<string, Schema>
+  modelRecords: Record<string, unknown>
+}
+
+type GetModelSchemas = () => Promise<GetModelSchemasReturn>
+
+export const getModelSchemas: GetModelSchemas = async () => {
+  const models = getModels()
+  const modelRecords = [] as Record<string, unknown>[]
+
+  const schemaStringToModelRecord = new Map<string, Schema>()
+
+  const appDb = BaseDb.getAppDb()
+
+  const OR: Record<string, unknown>[] = []
+
+  for (const [modelName, _] of Object.entries(models)) {
+    const foundModelQuery = await appDb
+      .select({
+        id: modelsTable.id,
+        name: modelsTable.name,
+        uid: modelUids.uid,
+      })
+      .from(modelsTable)
+      .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
+      .where(eq(modelsTable.name, modelName))
+      .limit(1)
+
+    const foundModel: Schema = { ...foundModelQuery[0] }
+
+    if (!foundModel) {
+      console.error(
+        `[item/events] [syncDbWithEas] model ${modelName} not found in SDK DB`,
+      )
+      return
+    }
+
+    foundModel.tableName = pluralize(foundModel.name).toLowerCase()
+
+    modelRecords!.push(foundModel)
+
+    if (modelName === 'Seed' || modelName === 'Version') {
+      continue
+    }
+
+    const schemaString = `bytes32 ${toSnakeCase(modelName)}`
+
+    OR.push({
+      schema: {
+        equals: `bytes32 ${toSnakeCase(modelName)}`,
+      },
+    })
+
+    schemaStringToModelRecord.set(schemaString, foundModel)
+  }
+
+  const queryClient = BaseQueryClient.getQueryClient()
+  const easClient = BaseEasClient.getEasClient()
+
+  const modelSchemas = await queryClient.fetchQuery({
+    queryKey: [`getSchemasAllModels`],
+    queryFn: async () =>
+      easClient.request(GET_SCHEMAS, {
+        where: {
+          OR,
+        },
+      }),
+  })
+
+  return {
+    modelSchemas,
+    schemaStringToModelRecord,
+    modelRecords,
+  }
+}

package/dist/src/getPropertyData.ts

@@ -0,0 +1,50 @@
+import { PropertyData } from "@/types"
+import { BaseDb } from "@/db/Db/BaseDb"
+import { metadata, MetadataType } from "@/seedSchema"
+import { or, eq, and, sql } from "drizzle-orm"
+import { startCase } from "lodash-es"
+import { GetPropertyDataOptions } from "@/types/db"
+
+
+export const getPropertyData = async ({
+  propertyName,
+  seedLocalId,
+  seedUid,
+}: GetPropertyDataOptions): Promise<PropertyData | undefined> => {
+  const appDb = BaseDb.getAppDb()
+
+  const whereClauses: any[] = [
+    or(
+      eq(metadata.propertyName, propertyName),
+      eq(metadata.propertyName, propertyName + 'Id'),
+      eq(metadata.propertyName, propertyName + 'Ids'),
+    ),
+  ]
+
+  if (seedLocalId) {
+    whereClauses.push(eq(metadata.seedLocalId, seedLocalId))
+  }
+
+  if (seedUid) {
+    whereClauses.push(eq(metadata.seedUid, seedUid))
+  }
+
+  const rows = (await appDb
+    .select()
+    .from(metadata)
+    .where(and(...whereClauses))
+    .orderBy(
+      sql.raw(`COALESCE(attestation_created_at, created_at) DESC`),
+    )) as MetadataType[]
+
+  if (!rows || rows.length === 0) {
+    return
+  }
+
+  const row = rows[0]
+
+  return {
+    ...row,
+    modelName: startCase(row.modelType),
+  }
+} 

package/dist/src/getPublishPayload.ts

@@ -0,0 +1,355 @@
+import { getItem } from '@/db/read/getItem'
+import {
+  defaultAttestationData,
+  INTERNAL_DATA_TYPES,
+  VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+} from '@/helpers/constants'
+import {
+  AttestationRequest,
+  SchemaEncoder,
+  ZERO_BYTES32,
+} from '@ethereum-attestation-service/eas-sdk'
+
+import { getSchemaForItemProperty } from '@/helpers/getSchemaForItemProperty'
+import { toSnakeCase } from '@/helpers'
+import pluralize from 'pluralize'
+import { getSchemaUidForModel } from '@/db/read/getSchemaUidForModel'
+import { getSchemaUidForSchemaDefinition } from '@/stores/eas'
+import { getCorrectId } from '@/helpers'
+import { getSegmentedItemProperties } from '@/helpers/getSegmentedItemProperties'
+import { IItemProperty } from '@/interfaces'
+import { IItem } from '@/interfaces'
+import { BaseItem } from '@/Item/BaseItem'
+
+const getVersionUid = (item: IItem<any>) => {
+  let versionUid
+
+  if (
+    item.latestVersionUid &&
+    item.latestVersionUid !== 'NULL' &&
+    item.latestVersionUid !== 'undefined'
+  ) {
+    versionUid = item.latestVersionUid
+  }
+  return versionUid || ZERO_BYTES32
+}
+
+const getPropertyData = async (itemProperty: IItemProperty<any>) => {
+  const easDataType =
+    INTERNAL_DATA_TYPES[itemProperty.propertyDef!.dataType].eas
+
+  let schemaUid: string | undefined = itemProperty.schemaUid
+
+  const propertyNameForSchema = toSnakeCase(itemProperty.propertyName)
+
+  const schemaDef = `${easDataType} ${propertyNameForSchema}`
+
+  if (!schemaUid) {
+    schemaUid = getSchemaUidForSchemaDefinition(schemaDef)
+    if (!schemaUid) {
+      const schema = await getSchemaForItemProperty({
+        propertyName: 'version',
+        easDataType: 'bytes32',
+      })
+      if (schema) {
+        schemaUid = schema.id
+      }
+    }
+  }
+
+  return {
+    schemaUid,
+    easDataType,
+    schemaDef,
+    propertyNameForSchema,
+  }
+}
+
+const processBasicProperties = async (
+  itemBasicProperties: IItemProperty<any>[],
+  itemPublishData: PublishPayload,
+): Promise<PublishPayload> => {
+  for (const basicProperty of itemBasicProperties) {
+    const value = basicProperty.getService().getSnapshot().context.propertyValue
+
+    if (!value || basicProperty.uid) {
+      continue
+    }
+
+    const { schemaUid, easDataType, schemaDef } =
+      await getPropertyData(basicProperty)
+
+    const propertyNameForSchema = toSnakeCase(basicProperty.propertyName)
+
+    const data = [
+      {
+        name: propertyNameForSchema,
+        type: easDataType,
+        value,
+      },
+    ]
+
+    const dataEncoder = new SchemaEncoder(schemaDef)
+
+    const encodedData = dataEncoder.encodeData(data)
+
+    itemPublishData.listOfAttestations.push({
+      schema: schemaUid!,
+      data: [
+        {
+          ...defaultAttestationData,
+          data: encodedData,
+        },
+      ],
+    })
+  }
+
+  return itemPublishData
+}
+
+const processRelationProperty = async (
+  relationProperty: IItemProperty<any>,
+  multiPublishPayload: MultiPublishPayload,
+  uploadedTransactions: UploadedTransaction[],
+  originalSeedLocalId: string,
+): Promise<MultiPublishPayload> => {
+  const value = relationProperty.getService().getSnapshot()
+    .context.propertyValue
+  if (!value || relationProperty.uid) {
+    return multiPublishPayload
+  }
+
+  const { localId: seedLocalId, uid: seedUid } = getCorrectId(value)
+
+  const relatedItem = await getItem({
+    seedLocalId,
+    seedUid,
+  })
+
+  if (!relatedItem) {
+    throw new Error(
+      `No related item found for relation property: ${relationProperty.propertyName}`,
+    )
+  }
+
+  const versionUid = getVersionUid(relatedItem)
+
+  const seedSchemaUid = await getSchemaUidForModel(
+    relationProperty.propertyDef!.ref as string,
+  )
+
+  let publishPayload: PublishPayload = {
+    localId: relationProperty.localId,
+    seedIsRevocable: true,
+    versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+    seedUid: seedUid || ZERO_BYTES32,
+    seedSchemaUid,
+    versionUid,
+    listOfAttestations: [],
+    propertiesToUpdate: [
+      {
+        publishLocalId: originalSeedLocalId,
+        propertySchemaUid: relationProperty.schemaUid,
+      },
+    ],
+  }
+
+  const { itemBasicProperties, itemUploadProperties } =
+    getSegmentedItemProperties(relatedItem)
+
+  if (itemUploadProperties.length === 1) {
+    const uploadProperty = itemUploadProperties[0]
+    const itemProperty = uploadProperty.itemProperty
+    const transactionData = uploadedTransactions.find(
+      (transaction) => transaction.seedLocalId === relatedItem.seedLocalId,
+    )
+    if (transactionData) {
+      itemProperty.value = transactionData.txId
+      await itemProperty.save()
+      itemBasicProperties.push(itemProperty)
+    }
+  }
+
+  publishPayload = await processBasicProperties(
+    itemBasicProperties,
+    publishPayload,
+  )
+
+  multiPublishPayload.push(publishPayload)
+
+  return multiPublishPayload
+}
+
+const processListProperty = async (
+  listProperty: IItemProperty<any>,
+  multiPublishPayload: MultiPublishPayload,
+  originalSeedLocalId: string,
+): Promise<MultiPublishPayload> => {
+  let value = listProperty.getService().getSnapshot().context.propertyValue
+  if (!value || listProperty.uid) {
+    return multiPublishPayload
+  }
+
+  const singularPropertyName = pluralize.singular(listProperty.propertyName)
+  const propertyNameForSchema = `${singularPropertyName}${listProperty.propertyDef!.ref}Ids`
+  if (typeof value === 'string' && value.length === 66) {
+    value = [value]
+  }
+  if (typeof value === 'string' && value.length > 66) {
+    try {
+      value = JSON.parse(value)
+    } catch (error) {
+      value = value.split(',')
+    }
+  }
+
+  for (const seedId of value) {
+    const { localId: seedLocalId, uid: seedUid } = getCorrectId(seedId)
+
+    const relatedItem = await getItem({
+      seedLocalId,
+      seedUid,
+    })
+
+    if (!relatedItem) {
+      console.error(
+        `No related item found for list property: ${listProperty.propertyName}`,
+      )
+      continue
+    }
+
+    if (relatedItem.seedUid) {
+      return multiPublishPayload
+    }
+
+    const versionUid = getVersionUid(relatedItem)
+
+    const seedSchemaUid = await getSchemaUidForModel(
+      listProperty.propertyDef!.ref as string,
+    )
+
+    let publishPayload: PublishPayload = {
+      localId: relatedItem.seedLocalId,
+      seedIsRevocable: true,
+      versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+      seedUid: seedUid || ZERO_BYTES32,
+      seedSchemaUid,
+      versionUid,
+      listOfAttestations: [],
+      propertiesToUpdate: [
+        {
+          publishLocalId: originalSeedLocalId,
+          propertySchemaUid: listProperty.schemaUid,
+        },
+      ],
+    }
+
+    const { itemBasicProperties } = getSegmentedItemProperties(relatedItem)
+
+    publishPayload = await processBasicProperties(
+      itemBasicProperties,
+      publishPayload,
+    )
+
+    multiPublishPayload.push(publishPayload)
+  }
+
+  return multiPublishPayload
+}
+
+type PublishPayload = {
+  localId: string
+  seedIsRevocable: boolean
+  seedSchemaUid: string
+  seedUid: string
+  versionSchemaUid: string
+  versionUid: string
+  listOfAttestations: AttestationRequest[]
+  propertiesToUpdate: any[]
+}
+
+type MultiPublishPayload = PublishPayload[]
+
+type UploadedTransaction = {
+  txId: string
+  itemPropertyLocalId?: string
+  seedLocalId?: string
+  versionLocalId?: string
+  itemPropertyName?: string
+}
+
+export const getPublishPayload = async (
+  item: BaseItem<any>,
+  uploadedTransactions: UploadedTransaction[],
+): Promise<MultiPublishPayload> => {
+
+  let multiPublishPayload: MultiPublishPayload = []
+
+  // Each PublishPayload is generated from a Seed that needs publishing
+
+  // First we need to determine all Seeds to publish
+
+  // That means the Seed of the Item, plus any Seeds pointed to by Relations
+
+  let itemPublishData: PublishPayload = {
+    localId: item.seedLocalId,
+    seedUid: item.seedUid || ZERO_BYTES32,
+    seedIsRevocable: true,
+    seedSchemaUid: item.schemaUid,
+    versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+    versionUid: getVersionUid(item),
+    listOfAttestations: [],
+    propertiesToUpdate: [],
+  }
+
+  const {
+    itemBasicProperties,
+    itemRelationProperties,
+    itemListProperties,
+    itemUploadProperties,
+  } = getSegmentedItemProperties(item)
+
+  if (itemUploadProperties.length === 1) {
+    const uploadProperty = itemUploadProperties[0]
+    const itemProperty = uploadProperty.itemProperty
+    const transactionData = uploadedTransactions.find(
+      (transaction) => transaction.seedLocalId === item.seedLocalId,
+    )
+    if (transactionData) {
+      itemProperty.value = transactionData.txId
+      await itemProperty.save()
+      itemBasicProperties.push(itemProperty)
+    }
+  }
+
+  for (const relationProperty of itemRelationProperties) {
+    multiPublishPayload = await processRelationProperty(
+      relationProperty,
+      multiPublishPayload,
+      uploadedTransactions,
+      item.seedLocalId,
+    )
+    itemBasicProperties.push(relationProperty)
+  }
+
+  for (const listProperty of itemListProperties) {
+    multiPublishPayload = await processListProperty(
+      listProperty,
+      multiPublishPayload,
+      item.seedLocalId,
+    )
+    itemBasicProperties.push(listProperty)
+  }
+  
+  itemPublishData = await processBasicProperties(
+    itemBasicProperties,
+    itemPublishData,
+  )
+
+  multiPublishPayload.push(itemPublishData)
+
+
+  
+
+  return multiPublishPayload
+}