@seedprotocol/sdk 0.1.129 → 0.2.1

package/dist/src/getItemData.ts

@@ -0,0 +1,99 @@
+import { GetItemData, ItemData } from "@/types"
+import debug from "debug"
+import { BaseDb } from "../BaseDb"
+import { and, eq, getTableColumns, gt, SQL, sql } from "drizzle-orm"
+import { getItemProperties } from "./getItemProperties"
+import { getVersionData } from "./subqueries/versionData"
+import { seeds } from "@/seedSchema"
+import { getSeedData } from "./getSeedData"
+
+const logger = debug('app:db:read:getItemData')
+
+export const getItemData: GetItemData = async ({
+  modelName,
+  seedLocalId,
+  seedUid,
+}) => {
+  if (!seedLocalId && !seedUid) {
+    throw new Error('[db/queries] [getItem] no seedLocalId or seedUid')
+  }
+
+  if (seedUid && !seedLocalId) {
+    const seedData = await getSeedData({ seedUid })
+    if (!seedData) {
+      logger('[db/queries] [getItem] no seedData seedUid', seedUid)
+      return
+    }
+    seedLocalId = seedData.localId
+  }
+
+  const appDb = BaseDb.getAppDb()
+
+  const { localId, uid, ...rest } = getTableColumns(seeds)
+
+  const whereClauses: SQL[] = []
+
+  if (modelName) {
+    whereClauses.push(eq(seeds.type, modelName.toLowerCase()))
+  }
+
+  if (seedUid) {
+    whereClauses.push(eq(seeds.uid, seedUid))
+  }
+
+  if (seedLocalId && !seedUid) {
+    whereClauses.push(eq(seeds.localId, seedLocalId))
+  }
+
+  const versionData = getVersionData()
+
+  const itemDataRows = await appDb
+    .with(versionData)
+    .select({
+      ...rest,
+      seedLocalId: seeds.localId,
+      seedUid: seeds.uid,
+      versionsCount: versionData.versionsCount,
+      lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+      latestVersionUid: versionData.latestVersionUid,
+      latestVersionLocalId: versionData.latestVersionLocalId,
+    })
+    .from(seeds)
+    .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+    .where(and(...whereClauses, gt(versionData.versionsCount, 0)))
+    .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+    .groupBy(seeds.localId) as ItemData[]
+
+  if (!itemDataRows || itemDataRows.length === 0) {
+    logger('[db/queries] [getItemDataFromDb] no itemDataRows')
+    return
+  }
+
+  let itemData = itemDataRows[0] as ItemData & { [key: string]: any }
+
+  const propertiesData = await getItemProperties({
+    seedLocalId,
+    seedUid: itemData.seedUid || undefined,
+  })
+
+  if (!propertiesData || propertiesData.length === 0) {
+    return itemData
+  }
+
+  for (const propertyData of propertiesData) {
+    const propertyName = propertyData.propertyName
+
+    let propertyValue = propertyData.propertyValue
+
+    if (propertyName.endsWith('Id') || propertyName.endsWith('Ids')) {
+      if (propertyData.refSeedType) {
+        const propertyNameVariant = propertyName.replace(/Ids?$/, '')
+        itemData[propertyNameVariant] = propertyValue
+      }
+    }
+
+    itemData[propertyName] = propertyValue
+  }
+
+  if (itemData) return itemData
+}

package/dist/src/getItemProperties.ts

@@ -1,24 +1,15 @@
-import { PropertyData } from '@/types'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
-import { metadata, seeds, versions } from '@/shared/seedSchema'
+import { GetItemProperties, PropertyData } from '@/types'
+import { metadata, seeds, versions } from '@/seedSchema'
 import { and, eq, getTableColumns, isNotNull, isNull, SQL } from 'drizzle-orm'
+import { BaseDb } from '@/db/BaseDb'
 
-type GetPropertiesForSeedProps = {
-  seedLocalId?: string
-  seedUid?: string
-  edited?: boolean
-}
-
-type GetItemProperties = (
-  props: GetPropertiesForSeedProps,
-) => Promise<PropertyData[]>
 
 export const getItemProperties: GetItemProperties = async ({
   seedLocalId,
   seedUid,
   edited,
 }) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const whereClauses: SQL[] = [isNotNull(metadata.propertyName)]
 
@@ -62,5 +53,14 @@ export const getItemProperties: GetItemProperties = async ({
     .where(and(...whereClauses))
     .groupBy(metadata.propertyName)
 
-  return propertiesData
+  return propertiesData.map(data => ({
+    ...data,
+    localId: data.localId || '',
+    uid: data.uid || '',
+    propertyName: data.propertyName || '',
+    propertyValue: data.propertyValue || '',
+    schemaUid: data.schemaUid || '',
+    modelType: data.modelType || '',
+    seedLocalId: data.seedLocalId || '',
+  })) as PropertyData[]
 }

package/dist/src/getItemProperty.ts

@@ -1,5 +1,5 @@
-import { getAppDb } from '@/browser/db/sqlWasmClient'
-import { metadata, MetadataType } from '@/shared/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
+import { metadata, MetadataType } from '@/seedSchema'
 import { and, eq, getTableColumns } from 'drizzle-orm'
 
 type GetItemPropertyProps = Partial<MetadataType>
@@ -9,7 +9,7 @@ type GetItemPropertyData = (
 ) => Promise<Partial<MetadataType>>
 
 export const getItemPropertyData: GetItemPropertyData = async (props) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const whereClauses = []
 

package/dist/src/getItems.ts

@@ -1,7 +1,7 @@
 import { ItemData } from '@/types'
 import { and, eq, gt, isNotNull, isNull, or, SQL, sql } from 'drizzle-orm'
-import { seeds } from '@/shared/seedSchema'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { seeds } from '@/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
 import { getVersionData } from './subqueries/versionData'
 
 type GetItemsDataProps = {
@@ -15,7 +15,7 @@ export const getItemsData: GetItemsData = async ({
   modelName,
   deleted,
 }): Promise<ItemData[]> => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const conditions: SQL[] = []
 

package/dist/src/getMetadata.ts

@@ -1,11 +1,11 @@
-import { getAppDb } from '@/browser/db'
+import { BaseDb } from '@/db/BaseDb'
 import { and, eq, SQL } from 'drizzle-orm'
-import { metadata, MetadataType } from '@/shared/seedSchema'
+import { metadata, MetadataType } from '@/seedSchema'
 
 type GetMetadataProps =
   | {
-      storageTransactionId?: string
-    }
+    storageTransactionId?: string
+  }
   | undefined
 
 type GetMetadata = (
@@ -13,7 +13,7 @@ type GetMetadata = (
 ) => Promise<MetadataType | undefined>
 
 export const getMetadata: GetMetadata = async (props) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   let storageTransactionId: string | undefined
   if (props) {

package/dist/src/getModelSchemas.ts

@@ -1,18 +1,24 @@
-import { getModels } from '@/browser/stores/modelClass'
-import { GetSchemasQuery, Schema } from '@/browser/gql/graphql'
-import { getAppDb } from '../sqlWasmClient'
-import { models as modelsTable, modelUids } from '@/shared/seedSchema'
+import { getModels } from '@/stores/modelClass'
+import { GetSchemasQuery, Schema } from '@/graphql/gql/graphql'
+import { BaseDb } from '@/db/BaseDb'
+import { models as modelsTable, modelUids } from '@/seedSchema'
 import { eq } from 'drizzle-orm'
 import pluralize from 'pluralize'
-import { toSnakeCase } from '@/shared/helpers'
-import { easClient, queryClient } from '@/browser/helpers'
-import { GET_SCHEMAS } from '@/browser/item/queries'
+import { toSnakeCase } from '@/helpers'
+import { GET_SCHEMAS } from '@/Item/queries'
+import { BaseEasClient } from '@/helpers/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/BaseQueryClient'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+
 
 type GetModelSchemasReturn = {
   modelSchemas: GetSchemasQuery
   schemaStringToModelRecord: Map<string, Schema>
   modelRecords: Record<string, unknown>
 }
+
 type GetModelSchemas = () => Promise<GetModelSchemasReturn>
 
 export const getModelSchemas: GetModelSchemas = async () => {
@@ -21,7 +27,7 @@ export const getModelSchemas: GetModelSchemas = async () => {
 
   const schemaStringToModelRecord = new Map<string, Schema>()
 
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const OR: Record<string, unknown>[] = []
 
@@ -37,12 +43,7 @@ export const getModelSchemas: GetModelSchemas = async () => {
       .where(eq(modelsTable.name, modelName))
       .limit(1)
 
-    const foundModel: {
-      id: number
-      name: string
-      uid: string | null
-      tableName?: string
-    } = { ...foundModelQuery[0] }
+    const foundModel: Schema = { ...foundModelQuery[0] }
 
     if (!foundModel) {
       console.error(

package/dist/src/getPropertyData.ts

@@ -0,0 +1,50 @@
+import { PropertyData } from "@/types"
+import { BaseDb } from "@/db/BaseDb"
+import { metadata, MetadataType } from "@/seedSchema"
+import { or, eq, and, sql } from "drizzle-orm"
+import { startCase } from "lodash"
+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,27 +1,25 @@
-import { getItem } from '@/browser/db/read/getItem'
+import { getItem } from '@/db/read/getItem'
 import {
   defaultAttestationData,
   INTERNAL_DATA_TYPES,
   VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
-} from '@/shared/helpers/constants'
+} from '@/helpers/constants'
 import {
   AttestationRequest,
   SchemaEncoder,
   ZERO_BYTES32,
 } from '@ethereum-attestation-service/eas-sdk'
 
-import { getSchemaForItemProperty } from '@/browser/helpers/getSchemaForItemProperty'
-import { toSnakeCase } from '@/shared/helpers'
+import { getSchemaForItemProperty } from '@/helpers/getSchemaForItemProperty'
+import { toSnakeCase } from '@/helpers'
 import pluralize from 'pluralize'
-import { getSchemaUidForModel } from '@/browser/db/read/getSchemaUidForModel'
-import { getSchemaUidForSchemaDefinition } from '@/browser/stores/eas'
-import { ItemProperty } from '@/browser/property/ItemProperty'
-import { getCorrectId } from '@/browser/helpers'
+import { getSchemaUidForModel } from '@/db/read/getSchemaUidForModel'
+import { getSchemaUidForSchemaDefinition } from '@/stores/eas'
+import { getCorrectId } from '@/helpers'
 import { Item } from '@/browser/item/Item'
-import debug from 'debug'
-import { getSegmentedItemProperties } from '@/browser/helpers/getSegmentedItemProperties'
+import { getSegmentedItemProperties } from '@/helpers/getSegmentedItemProperties'
+import { IItemProperty } from '@/interfaces'
 
-const logger = debug('app:item:getPublishPayload')
 
 const getVersionUid = (item: Item<any>) => {
   let versionUid
@@ -36,7 +34,7 @@ const getVersionUid = (item: Item<any>) => {
   return versionUid || ZERO_BYTES32
 }
 
-const getPropertyData = async (itemProperty: ItemProperty<any>) => {
+const getPropertyData = async (itemProperty: IItemProperty<any>) => {
   const easDataType =
     INTERNAL_DATA_TYPES[itemProperty.propertyDef!.dataType].eas
 
@@ -68,7 +66,7 @@ const getPropertyData = async (itemProperty: ItemProperty<any>) => {
 }
 
 const processBasicProperties = async (
-  itemBasicProperties: ItemProperty<any>[],
+  itemBasicProperties: IItemProperty<any>[],
   itemPublishData: PublishPayload,
 ): Promise<PublishPayload> => {
   for (const basicProperty of itemBasicProperties) {
@@ -110,7 +108,7 @@ const processBasicProperties = async (
 }
 
 const processRelationProperty = async (
-  relationProperty: ItemProperty<any>,
+  relationProperty: IItemProperty<any>,
   multiPublishPayload: MultiPublishPayload,
   uploadedTransactions: UploadedTransaction[],
 ): Promise<MultiPublishPayload> => {
@@ -139,35 +137,45 @@ const processRelationProperty = async (
     relationProperty.propertyDef!.ref as string,
   )
 
-  const publishPayload: PublishPayload = {
-    localId: relatedItem.seedLocalId,
+  let publishPayload: PublishPayload = {
+    localId: relationProperty.localId,
     seedIsRevocable: true,
     versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
     seedUid: seedUid || ZERO_BYTES32,
     seedSchemaUid,
     versionUid,
     listOfAttestations: [],
-    propertiesToUpdate: [
-      {
-        publishLocalId: relationProperty.seedLocalId,
-        propertySchemaUid: relationProperty.schemaUid,
-      },
-    ],
+    propertiesToUpdate: [],
+  }
+
+  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)
+    }
   }
 
-  multiPublishPayload = await processItem(
-    relatedItem,
+  publishPayload = await processBasicProperties(
+    itemBasicProperties,
     publishPayload,
-    uploadedTransactions,
-    multiPublishPayload,
   )
 
+  multiPublishPayload.push(publishPayload)
+
   return multiPublishPayload
 }
 
 const processListProperty = async (
-  listProperty: ItemProperty<any>,
-  uploadTransactions: UploadedTransaction[],
+  listProperty: IItemProperty<any>,
   multiPublishPayload: MultiPublishPayload,
 ): Promise<MultiPublishPayload> => {
   let value = listProperty.getService().getSnapshot().context.propertyValue
@@ -222,71 +230,20 @@ const processListProperty = async (
       listOfAttestations: [],
       propertiesToUpdate: [
         {
-          publishLocalId: listProperty.seedLocalId,
+          publishLocalId: listProperty.localId,
           propertySchemaUid: listProperty.schemaUid,
         },
       ],
     }
 
-    multiPublishPayload = await processItem(
-      relatedItem,
-      publishPayload,
-      uploadTransactions,
-      multiPublishPayload,
-    )
-  }
-
-  return multiPublishPayload
-}
+    const { itemBasicProperties } = getSegmentedItemProperties(relatedItem)
 
-const processItem = async (
-  item: Item<any>,
-  itemPublishData: PublishPayload,
-  uploadedTransactions: UploadedTransaction[],
-  multiPublishPayload: MultiPublishPayload,
-) => {
-  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,
+    publishPayload = await processBasicProperties(
+      itemBasicProperties,
+      publishPayload,
     )
-    itemBasicProperties.push(relationProperty)
-  }
-
-  itemPublishData = await processBasicProperties(
-    itemBasicProperties,
-    itemPublishData,
-  )
-
-  multiPublishPayload.push(itemPublishData)
 
-  for (const listProperty of itemListProperties) {
-    multiPublishPayload = await processListProperty(
-      listProperty,
-      uploadedTransactions,
-      multiPublishPayload,
-    )
+    multiPublishPayload.push(publishPayload)
   }
 
   return multiPublishPayload
@@ -317,12 +274,12 @@ export const getPublishPayload = async (
   item: Item<any>,
   uploadedTransactions: UploadedTransaction[],
 ): Promise<MultiPublishPayload> => {
-  // if (item.modelName === 'Post') {
-  //   item.authors = [
-  //     'Sr0bIx9Fwj',
-  //     '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
-  //   ]
-  // }
+  if (item.modelName === 'Post') {
+    item.authors = [
+      'Sr0bIx9Fwj',
+      '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
+    ]
+  }
 
   let multiPublishPayload: MultiPublishPayload = []
 
@@ -332,7 +289,7 @@ export const getPublishPayload = async (
 
   // That means the Seed of the Item, plus any Seeds pointed to by Relations
 
-  const itemPublishData: PublishPayload = {
+  let itemPublishData: PublishPayload = {
     localId: item.seedLocalId,
     seedUid: item.seedUid || ZERO_BYTES32,
     seedIsRevocable: true,
@@ -343,12 +300,47 @@ export const getPublishPayload = async (
     propertiesToUpdate: [],
   }
 
-  multiPublishPayload = await processItem(
-    item,
+  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)
+    }
+  }
+
+  itemPublishData = await processBasicProperties(
+    itemBasicProperties,
     itemPublishData,
-    uploadedTransactions,
-    multiPublishPayload,
   )
 
+  multiPublishPayload.push(itemPublishData)
+
+  for (const relationProperty of itemRelationProperties) {
+    multiPublishPayload = await processRelationProperty(
+      relationProperty,
+      multiPublishPayload,
+      uploadedTransactions,
+    )
+  }
+
+  for (const listProperty of itemListProperties) {
+    multiPublishPayload = await processListProperty(
+      listProperty,
+      multiPublishPayload,
+    )
+  }
+
   return multiPublishPayload
 }

package/dist/src/getPublishUploads.ts

@@ -1,36 +1,17 @@
-import { Item, ItemProperty } from '@/browser'
-import Transaction from 'arweave/web/lib/transaction'
+import Transaction from 'arweave'
 import { CreateTransactionInterface } from 'arweave/web'
 import { getArweave } from '@/browser/helpers/arweave'
 import { fs } from '@zenfs/core'
-import { getCorrectId } from '@/browser/helpers'
-import { getSegmentedItemProperties } from '@/browser/helpers/getSegmentedItemProperties'
+import { getCorrectId } from '@/helpers'
+import { getSegmentedItemProperties } from '@/helpers/getSegmentedItemProperties'
 import debug from 'debug'
+import { IItem, IItemProperty } from '@/interfaces'
+import { getContentHash } from '@/helpers'
+import { BaseItem } from '@/Item/BaseItem'
 
 const logger = debug('app:item:getPublishUploads')
 
-export const getContentHash = async (
-  base64: string | null | undefined,
-  uint: Uint8Array | undefined,
-): Promise<string> => {
-  let data
 
-  if (base64 && !uint) {
-    const encoder = new TextEncoder()
-    data = encoder.encode(base64)
-  }
-
-  if (uint) {
-    data = uint
-  }
-
-  // Hash the data with SHA-256
-  const hashBuffer = await crypto.subtle.digest('SHA-256', data as Uint8Array)
-
-  // Convert the ArrayBuffer to a hex string
-  const hashArray = Array.from(new Uint8Array(hashBuffer))
-  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
-}
 export const prepareArweaveTransaction = async (
   data: string | Uint8Array,
   contentHash: string | undefined,
@@ -51,8 +32,8 @@ export const prepareArweaveTransaction = async (
   return tx
 }
 export type UploadProperty = {
-  itemProperty: ItemProperty<any>
-  childProperties: ItemProperty<any>[]
+  itemProperty: IItemProperty<any>
+  childProperties: IItemProperty<any>[]
 }
 type ChildUploadData = {
   propertyName: string
@@ -61,7 +42,7 @@ type ChildUploadData = {
 const processUploadProperty = async (
   uploadProperty: UploadProperty,
   uploads: PublishUpload[],
-  relatedItemProperty?: ItemProperty<any>,
+  relatedItemProperty?: IItemProperty<any>,
 ): Promise<PublishUpload[]> => {
   const itemProperty = uploadProperty.itemProperty
 
@@ -201,9 +182,9 @@ export type PublishUpload = {
   transactionToSign: Transaction
 }
 export const getPublishUploads = async (
-  item: Item<any>,
+  item: IItem<any>,
   uploads: PublishUpload[] = [],
-  relatedItemProperty?: ItemProperty<any>,
+  relatedItemProperty?: IItemProperty<any>,
 ) => {
   // if (item.modelName === 'Post') {
   //   if (!item.authors) {
@@ -235,7 +216,7 @@ export const getPublishUploads = async (
 
     const { localId: seedLocalId, uid: seedUid } = getCorrectId(propertyValue)
 
-    const relatedItem = await Item.find({
+    const relatedItem = await BaseItem.find({
       seedLocalId,
       seedUid,
     })