@seedprotocol/sdk 0.3.1 → 0.3.3

package/dist/src/getPublishUploads.ts

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

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

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

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

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

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

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

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

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

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