@seedprotocol/sdk 0.2.54 → 0.3.1

package/dist/src/getPublishUploads.ts

@@ -0,0 +1,207 @@
+import Transaction from 'arweave'
+import { CreateTransactionInterface } from 'arweave/web'
+import { getArweave } from '@/helpers/ArweaveClient'
+import fs from '@zenfs/core'
+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 prepareArweaveTransaction = async (
+  data: string | Uint8Array,
+  contentHash: string | undefined,
+): Promise<Transaction> => {
+  const transactionData: Partial<CreateTransactionInterface> = {
+    data,
+    tags: [],
+  }
+
+  const tx = await getArweave()!.createTransaction(transactionData)
+
+  if (contentHash) {
+    logger('contentHash', contentHash)
+    logger('adding content hash tag to tx.id:', tx.id)
+    tx.addTag('Content-SHA-256', contentHash)
+  }
+
+  return tx
+}
+export type UploadProperty = {
+  itemProperty: IItemProperty<any>
+  childProperties: IItemProperty<any>[]
+}
+type ChildUploadData = {
+  propertyName: string
+  localStoragePath: string
+}
+const processUploadProperty = async (
+  uploadProperty: UploadProperty,
+  uploads: PublishUpload[],
+  relatedItemProperty?: IItemProperty<any>,
+): Promise<PublishUpload[]> => {
+  const itemProperty = uploadProperty.itemProperty
+
+  const childUploads: ChildUploadData[] = []
+
+  for (const childProperty of uploadProperty.childProperties) {
+    const filePath = childProperty.localStoragePath
+
+    if (!filePath || filePath.endsWith('undefined')) {
+      continue
+    }
+
+    const exists = await fs.promises.exists(filePath)
+    if (!exists) {
+      continue
+    }
+
+    childUploads.push({
+      propertyName: childProperty.propertyName,
+      localStoragePath: filePath,
+    })
+  }
+
+  let fileContents
+  let transaction: Transaction
+
+  if (!childUploads || childUploads.length === 0) {
+    if (relatedItemProperty && relatedItemProperty.localStoragePath) {
+      const filePath = relatedItemProperty.localStoragePath
+
+      if (!filePath || filePath.endsWith('undefined')) {
+        return uploads
+      }
+
+      const exists = await fs.promises.exists(filePath)
+      if (!exists) {
+        return uploads
+
+      }
+
+      try {
+        fileContents = await fs.promises.readFile(filePath)
+      } catch (e) {
+        fileContents = fs.readFileSync(filePath)
+      }
+    }
+    if (!fileContents) {
+      return uploads
+    }
+  }
+
+  if (childUploads.length > 0) {
+    const separator = '===FILE_SEPARATOR==='
+    // let compositeFileContents = `${itemProperty.propertyName}${separator}${mainFileContents}`
+    let compositeFileContents = ''
+
+    for (const childUpload of childUploads) {
+      let childUploadContents
+
+      try {
+        childUploadContents = await fs.promises.readFile(
+          childUpload.localStoragePath,
+        )
+      } catch (e) {
+        childUploadContents = fs.readFileSync(childUpload.localStoragePath)
+      }
+
+      compositeFileContents += `${separator}${childUpload.propertyName}${separator}${childUploadContents}`
+    }
+
+    fileContents = Buffer.from(compositeFileContents)
+  }
+
+  if (!fileContents) {
+    throw new Error(`No file contents found for ${itemProperty.propertyName}`)
+  }
+
+  const uint8Array = new Uint8Array(
+    fileContents.buffer,
+    fileContents.byteOffset,
+    fileContents.byteLength,
+  )
+
+  const contentHash = await getContentHash(null, uint8Array)
+
+  transaction = await prepareArweaveTransaction(fileContents, contentHash)
+
+  let itemPropertyLocalId = relatedItemProperty
+    ? relatedItemProperty.localId
+    : itemProperty.localId
+  let itemPropertyName = relatedItemProperty
+    ? relatedItemProperty.propertyName
+    : itemProperty.propertyName
+
+  uploads.push({
+    itemPropertyName,
+    itemPropertyLocalId,
+    seedLocalId: itemProperty.seedLocalId!,
+    versionLocalId: itemProperty.versionLocalId!,
+    transactionToSign: transaction,
+  })
+
+  return uploads
+}
+export type PublishUpload = {
+  itemPropertyName: string
+  itemPropertyLocalId: string
+  seedLocalId: string
+  versionLocalId: string
+  transactionToSign: Transaction
+}
+export const getPublishUploads = async (
+  item: IItem<any>,
+  uploads: PublishUpload[] = [],
+  relatedItemProperty?: IItemProperty<any>,
+) => {
+  // if (item.modelName === 'Post') {
+  //   if (!item.authors) {
+  //     item.authors = [
+  //       'Sr0bIx9Fwj',
+  //       '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
+  //     ]
+  //   }
+  // }
+
+  const { itemUploadProperties, itemRelationProperties } =
+    getSegmentedItemProperties(item)
+
+  for (const uploadProperty of itemUploadProperties) {
+    uploads = await processUploadProperty(
+      uploadProperty,
+      uploads,
+      relatedItemProperty,
+    )
+  }
+
+  for (const relationProperty of itemRelationProperties) {
+    const propertyValue = relationProperty.getService().getSnapshot()
+      .context.propertyValue
+
+    if (!propertyValue || relationProperty.uid) {
+      continue
+    }
+
+    const { localId: seedLocalId, uid: seedUid } = getCorrectId(propertyValue)
+
+    const relatedItem = await BaseItem.find({
+      seedLocalId,
+      seedUid,
+    })
+
+    if (!relatedItem) {
+      throw new Error(
+        `No relatedItem found for ${relationProperty.propertyName}`,
+      )
+    }
+
+    uploads = await getPublishUploads(relatedItem, uploads, relationProperty)
+  }
+
+  return uploads
+}

package/dist/src/getRelationValueData.ts

@@ -0,0 +1,27 @@
+import { metadata, MetadataType } from '@/seedSchema'
+import { eq, max } from 'drizzle-orm'
+import { BaseDb } from '@/db/Db/BaseDb'
+
+export const getRelationValueData = async (
+  propertyValue: any,
+): Promise<MetadataType | undefined> => {
+  const appDb = BaseDb.getAppDb()
+
+  const rows = (await appDb
+    .select({
+      propertyValue: metadata.propertyValue,
+      attestationCreatedAt: max(metadata.attestationCreatedAt),
+      refResolvedDisplayValue: metadata.refResolvedDisplayValue,
+      refResolvedValue: metadata.refResolvedValue,
+      refSeedType: metadata.refSeedType,
+      easDataType: metadata.easDataType,
+    })
+    .from(metadata)
+    .where(eq(metadata.propertyValue, propertyValue))) as MetadataType[]
+
+  if (!rows || rows.length === 0) {
+    return
+  }
+
+  return rows[0]
+} 

package/dist/src/getSchemaForItemProperty.ts

@@ -0,0 +1,68 @@
+import { Schema, SchemaWhereInput } from '@/graphql/gql/graphql'
+import { toSnakeCase, BaseEasClient, BaseQueryClient } from '@/helpers'
+import { GET_SCHEMAS } from '@/Item/queries'
+import { TypedData } from '@ethereum-attestation-service/eas-sdk/dist/offchain/typed-data-handler'
+
+
+type GetSchemaForPropertyProps = {
+  schemaUid?: string
+  propertyName: string
+  easDataType?: TypedData['type']
+}
+type GetSchemaForProperty = (
+  props: GetSchemaForPropertyProps,
+) => Promise<Schema | void>
+export const getSchemaForItemProperty: GetSchemaForProperty = async ({
+  schemaUid,
+  propertyName,
+  easDataType,
+}): Promise<Schema | void> => {
+  const propertyNameSnakeCase = toSnakeCase(propertyName)
+  const isMissingSchemaUid =
+    !schemaUid || schemaUid === 'null' || schemaUid === 'undefined'
+
+  const queryClient = BaseQueryClient.getQueryClient()
+  const easClient = BaseEasClient.getEasClient()
+
+  let queryParams: { where: SchemaWhereInput } = {
+    where: {
+      id: {
+        equals: schemaUid,
+      },
+    },
+  }
+
+  if (easDataType) {
+    queryParams = {
+      where: {
+        schema: {
+          equals: `${easDataType} ${propertyNameSnakeCase}`,
+        },
+      },
+    }
+  }
+
+  if (!easDataType && isMissingSchemaUid) {
+    queryParams = {
+      where: {
+        schemaNames: {
+          some: {
+            name: {
+              equals: propertyNameSnakeCase,
+            },
+          },
+        },
+      },
+    }
+  }
+
+  const foundPropertySchema = await queryClient.fetchQuery({
+    queryKey: [`getPropertySchema${propertyName}`],
+    queryFn: async () => easClient.request(GET_SCHEMAS, queryParams),
+    networkMode: 'offlineFirst',
+  })
+
+  if (foundPropertySchema && foundPropertySchema.schemas.length > 0) {
+    return foundPropertySchema.schemas[0] as Schema
+  }
+}

package/dist/src/getSchemaForModel.ts

@@ -0,0 +1,42 @@
+import { EventObject, fromCallback } from 'xstate'
+import {
+  FromCallbackInput,
+  GetSchemaForModelEvent,
+  GlobalMachineContext,
+} from '@/types'
+import debug from 'debug'
+
+const logger = debug('app:services:global:actors:getSchemaForModel')
+
+export const getSchemaForModel = fromCallback<
+  EventObject,
+  FromCallbackInput<GlobalMachineContext, GetSchemaForModelEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const { modelName } = event
+
+  if (!modelName) {
+    console.warn('No modelName found')
+    return
+  }
+
+  const { models } = context
+
+  if (!models) {
+    console.warn('No models found')
+    return
+  }
+
+  const model = Object.entries(models).find(
+    ([modelNameFromConfig]) => modelNameFromConfig === modelName,
+  )
+
+  if (!model) {
+    throw new Error(`Model ${modelName} not found`)
+  }
+
+  logger('[service/actor] [getSchemaForModel] model:', model)
+
+  sendBack({ type: 'schemaForModel', schema: model.schema })
+
+  return () => {}
+})

package/dist/src/getSchemaUidForModel.ts

@@ -0,0 +1,32 @@
+import { GET_SCHEMAS } from '@/Item/queries'
+import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
+
+
+export const getSchemaUidForModel = async (
+  modelName: string,
+): Promise<string> => {
+  const queryClient = BaseQueryClient.getQueryClient()
+  const easClient = BaseEasClient.getEasClient()
+
+  const modeType = modelName.toLowerCase()
+
+  const modelSchemaQuery = await queryClient.fetchQuery({
+    queryKey: [`getPropertySchema${modelName}`],
+    queryFn: async () =>
+      easClient.request(GET_SCHEMAS, {
+        where: {
+          schemaNames: {
+            some: {
+              name: {
+                equals: modeType,
+              },
+            },
+          },
+        },
+      }),
+  })
+
+  const foundSchema = modelSchemaQuery.schemas[0]
+  return foundSchema.id
+}

package/dist/src/getSeedData.ts

@@ -0,0 +1,34 @@
+import { BaseDb } from '@/db/Db/BaseDb'
+import { seeds, SeedType } from '@/seedSchema'
+import { eq } from 'drizzle-orm'
+
+type GetSeedDataProps = {
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type GetSeedData = (props: GetSeedDataProps) => Promise<SeedType | undefined>
+
+export const getSeedData: GetSeedData = async ({ seedLocalId, seedUid }) => {
+  const appDb = BaseDb.getAppDb()
+
+  let query
+
+  const queryBase = appDb.select().from(seeds)
+
+  if (seedLocalId) {
+    query = queryBase.where(eq(seeds.localId, seedLocalId))
+  }
+
+  if (seedUid) {
+    query = queryBase.where(eq(seeds.uid, seedUid))
+  }
+
+  const rows = await query
+
+  if (!rows || !rows.length) {
+    return
+  }
+
+  return rows[0]
+}

package/dist/src/getSegmentedItemProperties.ts

@@ -0,0 +1,65 @@
+import { UploadProperty } from '@/db/read/getPublishUploads'
+import { IItem } from '@/interfaces'
+
+export const getSegmentedItemProperties = (item: IItem<any>) => {
+  const itemBasicProperties = []
+  const itemRelationProperties = []
+  const itemListProperties = []
+  const itemUploadProperties: UploadProperty[] = []
+  const itemStorageProperties = []
+  let itemStorageTransactionProperty: UploadProperty | undefined
+
+  for (const itemProperty of Object.values(item.properties)) {
+    if (!itemProperty.propertyDef) {
+      continue
+    }
+
+    const isItemStorage =
+      itemProperty.propertyDef.storageType &&
+      itemProperty.propertyDef.storageType === 'ItemStorage'
+
+    const isImageSrc =
+      itemProperty.propertyDef.dataType === 'Relation' &&
+      itemProperty.propertyDef.refValueType === 'ImageSrc'
+
+    const isStorageTransaction =
+      itemProperty.propertyName === 'storageTransactionId'
+
+    if (itemProperty.propertyDef.dataType === 'Relation') {
+      itemRelationProperties.push(itemProperty)
+      continue
+    }
+
+    if (itemProperty.propertyDef.dataType === 'List') {
+      itemListProperties.push(itemProperty)
+      continue
+    }
+
+    if (isItemStorage) {
+      itemStorageProperties.push(itemProperty)
+      continue
+    }
+
+    if (isStorageTransaction) {
+      itemStorageTransactionProperty = { itemProperty, childProperties: [] }
+      continue
+    }
+
+    itemBasicProperties.push(itemProperty)
+  }
+
+  if (itemStorageTransactionProperty && itemStorageProperties.length > 0) {
+    itemStorageTransactionProperty.childProperties = itemStorageProperties
+  }
+
+  if (itemStorageTransactionProperty) {
+    itemUploadProperties.push(itemStorageTransactionProperty)
+  }
+
+  return {
+    itemBasicProperties,
+    itemRelationProperties,
+    itemListProperties,
+    itemUploadProperties,
+  }
+}

package/dist/src/getStorageTransactionIdForSeedUid.ts

@@ -0,0 +1,38 @@
+import { metadata } from '@/seedSchema'
+import { and, eq } from 'drizzle-orm'
+import { BaseDb } from '@/db/Db/BaseDb'
+
+const seedUidToStorageTransactionId = new Map<string, string>()
+
+type GetStorageTransactionIdResults = {
+  storageTransactionId: string
+}[]
+
+export const getStorageTransactionIdForSeedUid = async (
+  seedUid: string,
+): Promise<string | undefined> => {
+  if (seedUidToStorageTransactionId.has(seedUid)) {
+    return seedUidToStorageTransactionId.get(seedUid)
+  }
+
+  const appDb = BaseDb.getAppDb()
+
+  const results = (await appDb
+    .select({
+      storageTransactionId: metadata.propertyValue,
+    })
+    .from(metadata)
+    .where(
+      and(
+        eq(metadata.seedUid, seedUid),
+        eq(metadata.propertyName, 'storageTransactionId'),
+      ),
+    )) as GetStorageTransactionIdResults
+
+  if (!results || results.length === 0) {
+    return
+  }
+
+  seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId)
+  return results[0].storageTransactionId
+} 

package/dist/src/getVersionData.ts

@@ -0,0 +1,46 @@
+import { versions, VersionsType } from '@/seedSchema'
+import { and, eq } from 'drizzle-orm'
+import { BaseDb } from '../Db/BaseDb'
+
+type GetVersionDataProps = {
+  localId?: string | null
+  uid?: string
+  seedLocalId?: string
+}
+
+type GetVersionData = (
+  props: GetVersionDataProps,
+) => Promise<VersionsType | undefined>
+
+export const getVersionData: GetVersionData = async ({
+  localId,
+  seedLocalId,
+  uid,
+}) => {
+  const appDb = BaseDb.getAppDb()
+
+  const whereClauses = []
+
+  if (seedLocalId) {
+    whereClauses.push(eq(versions.localId, seedLocalId))
+  }
+
+  if (localId) {
+    whereClauses.push(eq(versions.localId, localId))
+  }
+
+  if (uid) {
+    whereClauses.push(eq(versions.uid, uid))
+  }
+
+  const queryRows = await appDb
+    .select()
+    .from(versions)
+    .where(and(...whereClauses))
+
+  if (!queryRows || !queryRows.length) {
+    return
+  }
+
+  return queryRows[0]
+}

package/dist/src/getVersionsForVersionUids.ts

@@ -0,0 +1,39 @@
+import { runQueryForStatement } from '../sqlWasmClient'
+
+type VersionData = {
+  localId: string
+  uid: string
+  seedUid: string
+  seedLocalId: string
+}
+type GetVersionsForVersionUids = (
+  versionUids: string[],
+) => Promise<VersionData[]>
+export const getVersionsForVersionUids: GetVersionsForVersionUids = async (
+  versionUids: string[],
+) => {
+  const queryStatement = `
+      SELECT local_id, uid, seed_uid, seed_local_id
+      FROM versions
+      WHERE uid IN ('${versionUids.join("','")}');
+  `
+
+  const { rows } = await runQueryForStatement(queryStatement)
+
+  if (!rows || rows.length === 0) {
+    return []
+  }
+
+  const versionsData: VersionData[] = []
+
+  for (const row of rows) {
+    versionsData.push({
+      localId: row[0],
+      uid: row[1],
+      seedUid: row[2],
+      seedLocalId: row[3],
+    })
+  }
+
+  return versionsData
+}