@seedprotocol/sdk 0.3.1 → 0.3.3

package/dist/src/getItems.ts

@@ -1,70 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,355 +0,0 @@
-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
-}