@seedprotocol/sdk 0.1.47 → 0.1.48

package/dist/src/save.ts

@@ -0,0 +1,183 @@
+import { Attestation } from '@/browser/gql/graphql'
+import { sql } from 'drizzle-orm'
+import { generateId } from '@/shared/helpers'
+import { escapeSqliteString } from '@/shared/helpers/db'
+import { camelCase } from 'lodash-es'
+
+import { getVersionsForVersionUids } from '@/browser/db/read/getVersionsForVersionUids'
+import debug from 'debug'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+const logger = debug('app:property:save')
+
+const relationValuesToExclude = [
+  '0x0000000000000000000000000000000000000000000000000000000000000020',
+]
+
+const seedUidToLocalId = new Map<string, string>()
+const seedUidToModelType = new Map<string, string>()
+
+const versionUidToLocalId = new Map<string, string>()
+const versionUidToSeedUid = new Map<string, string>()
+
+const propertyUidToLocalId = new Map<string, string>()
+
+export const savePropertiesToDb = async (properties: Attestation[]) => {
+  const appDb = getAppDb()
+
+  const propertyUids = properties.map((property) => property.id)
+  const versionUids = properties.map((property) => property.refUID)
+
+  const existingRecordsQuery = await appDb.run(
+    sql.raw(
+      `SELECT uid, local_id
+       FROM metadata
+       WHERE uid IN ('${propertyUids.join("','")}');`,
+    ),
+  )
+
+  const existingRecordsUids = new Set<string>()
+
+  if (
+    existingRecordsQuery &&
+    existingRecordsQuery.rows &&
+    existingRecordsQuery.rows.length > 0
+  ) {
+    for (const row of existingRecordsQuery.rows) {
+      existingRecordsUids.add(row[0])
+      propertyUidToLocalId.set(row[0], row[1])
+    }
+  }
+
+  const newProperties = properties.filter(
+    (property) => !existingRecordsUids.has(property.id),
+  )
+
+  if (newProperties.length === 0) {
+    return { propertyUids }
+  }
+
+  let insertPropertiesQuery = `INSERT INTO metadata (local_id, uid, schema_uid, property_name, property_value,
+                                                     eas_data_type, version_uid, version_local_id, seed_uid,
+                                                     seed_local_id, model_type, created_at, attestation_created_at,
+                                                     attestation_raw)
+  VALUES `
+
+  for (let i = 0; i < newProperties.length; i++) {
+    const property = newProperties[i]
+    const propertyLocalId = generateId()
+    const metadata = JSON.parse(property.decodedDataJson)[0].value
+
+    let propertyNameSnake = metadata.name
+
+    if (!propertyNameSnake) {
+      propertyNameSnake = metadata.name
+    }
+
+    if (!propertyNameSnake) {
+      logger(
+        '[item/events] [syncDbWithEas] no propertyName found for property: ',
+        property,
+      )
+      return
+    }
+
+    let isRelation = false
+    let refValueType = 'single'
+    let refResolvedValue
+    let refResolvedDisplayValue
+
+    if (
+      (propertyNameSnake.endsWith('_id') ||
+        propertyNameSnake.endsWith('_ids')) &&
+      propertyNameSnake !== 'storage_transaction_id' &&
+      propertyNameSnake !== 'storage_provider_transaction_id'
+    ) {
+      isRelation = true
+      let isList = false
+
+      if (Array.isArray(metadata.value)) {
+        isList = true
+        refValueType = 'list'
+
+        // const relatedValuesQuery = await appDb.run(
+        //   sql.raw(
+        //     `SELECT s.uid, MAX(v.attestation_created_at) as last_published_at
+        //      FROM seeds s
+        //               JOIN versions v ON s.local_id = v.seed_local_id
+        //               JOIN metadata m ON v.local_id = m.version_local_id
+        //      WHERE s.uid IN ('${metadata.value.join("','")}')
+        //        AND m.property_name = 'storage_transation_id';`,
+        //   ),
+        // )
+        //
+        // if (
+        //   relatedValuesQuery &&
+        //   relatedValuesQuery.rows &&
+        //   relatedValuesQuery.rows.length > 0
+        // ) {
+        //   for (const row of relatedValuesQuery.rows) {
+        //     // relatedSeedUids.add(row[0])
+        //   }
+        // }
+      }
+
+      if (!isList) {
+        if (relationValuesToExclude.includes(metadata.value)) {
+          continue
+        }
+      }
+    }
+
+    const versionsData = await getVersionsForVersionUids(versionUids)
+
+    for (const version of versionsData) {
+      const { seedUid, seedLocalId, uid, localId } = version
+      versionUidToLocalId.set(uid, localId)
+      versionUidToSeedUid.set(uid, seedUid)
+      seedUidToLocalId.set(seedUid, seedLocalId)
+    }
+
+    let propertyValue = metadata.value
+
+    if (typeof propertyValue !== 'string') {
+      propertyValue = JSON.stringify(propertyValue)
+    }
+
+    const propertyName = camelCase(propertyNameSnake)
+    propertyValue = escapeSqliteString(propertyValue)
+    const easDataType = metadata.type
+    const versionUid = property.refUID
+    const versionLocalId = versionUidToLocalId.get(versionUid)
+    const attestationCreatedAt = property.timeCreated * 1000
+    const attestationRaw = escapeSqliteString(JSON.stringify(property))
+    const seedUid = versionUidToSeedUid.get(versionUid)
+    const seedLocalId = seedUidToLocalId.get(seedUid!)
+    const modelType = seedUidToModelType.get(seedUid!)
+
+    const valuesString = `('${propertyLocalId}', '${property.id}', '${property.schemaId}', '${propertyName}', '${propertyValue}', '${easDataType}', '${versionUid}', '${versionLocalId}', '${seedUid}', '${seedLocalId}', '${modelType}',
+                 ${Date.now()}, ${attestationCreatedAt}, '${attestationRaw}')`
+
+    if (i < newProperties.length - 1) {
+      insertPropertiesQuery += valuesString + ', '
+    }
+
+    if (i === newProperties.length - 1) {
+      insertPropertiesQuery += valuesString + ';'
+    }
+
+    propertyUidToLocalId.set(property.id, propertyLocalId)
+  }
+
+  if (insertPropertiesQuery.endsWith('VALUES ')) {
+    return { propertyUids }
+  }
+
+  if (insertPropertiesQuery.endsWith(', ')) {
+    insertPropertiesQuery = insertPropertiesQuery.slice(0, -2) + ';'
+  }
+
+  await appDb.run(sql.raw(insertPropertiesQuery))
+
+  return { propertyUids }
+}

package/dist/src/saveConfig.ts

@@ -0,0 +1,79 @@
+import { EventObject, fromCallback } from 'xstate'
+import { INTERNAL_SAVING_CONFIG_SUCCESS } from '@/browser/services/internal/constants'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { sql } from 'drizzle-orm'
+import debug from 'debug'
+import { FromCallbackInput, InternalMachineContext } from '@/types'
+import { appState } from '@/shared/seedSchema'
+
+const logger = debug('app:services:internal:actors:saveConfig')
+
+export const saveConfig = fromCallback<
+  EventObject,
+  FromCallbackInput<InternalMachineContext>
+>(({ sendBack, input: { context } }) => {
+  if (typeof window === 'undefined') {
+    console.error('seedInitBrowser called from non-browser context')
+    sendBack({
+      type: 'error',
+      error: 'Browser method called from non-browser context',
+    })
+  }
+
+  const { endpoints, addresses } = context
+
+  if (!endpoints) {
+    throw new Error('saveConfig called with invalid endpoints')
+  }
+
+  const _saveConfig = async (): Promise<void> => {
+    // logger('[sdk] [internal/actors] starting _saveConfig')
+    const appDb = getAppDb()
+    if (!appDb) {
+      throw new Error('App DB not found')
+    }
+    const endpointsValueString = JSON.stringify(endpoints)
+    const addressesValueString = JSON.stringify(addresses)
+    // TODO: Figure out how to define on conflict with multiple rows added
+    try {
+      // logger('[sdk] [internal/actors] Saving endpoints to db')
+      await appDb
+        .insert(appState)
+        .values({
+          key: 'endpoints',
+          value: endpointsValueString,
+        })
+        .onConflictDoUpdate({
+          target: appState.key,
+          set: {
+            value: endpointsValueString,
+          },
+          setWhere: sql`key = 'endpoints'`,
+        })
+      // logger('[sdk] [internal/actors] Saving addresses to db')
+      await appDb
+        .insert(appState)
+        .values({
+          key: 'addresses',
+          value: addressesValueString,
+        })
+        .onConflictDoUpdate({
+          target: appState.key,
+          set: {
+            value: addressesValueString,
+          },
+          setWhere: sql`key = 'addresses'`,
+        })
+      logger('[sdk] [internal/actors] Should be done saving')
+    } catch (error) {
+      console.error('Error saving config:', error)
+    }
+  }
+
+  _saveConfig().then(() => {
+    logger('[sdk] [internal/actors] Successfully saved config')
+    return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS })
+  })
+
+  return () => {}
+})

package/dist/src/saveDataToDb.ts

@@ -0,0 +1,145 @@
+import { EventObject, fromCallback } from 'xstate'
+import { itemMachineSingle } from '@/browser/item/single/itemMachineSingle'
+import { sql } from 'drizzle-orm'
+import { escapeSqliteString } from '@/shared/helpers/db'
+import { generateId } from '@/shared/helpers'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+const relatedSnakeCaseToCamelCase = (snakeCase: string): string => {
+  let camelCasePropertyName = snakeCase
+
+  camelCasePropertyName = camelCasePropertyName.replace(/_(id|ids)$/, '')
+
+  return camelCasePropertyName
+    .toLowerCase()
+    .replace(/[-_][a-z]/g, (group) => group.slice(-1).toUpperCase())
+}
+
+export const saveDataToDb = fromCallback<EventObject, typeof itemMachineSingle>(
+  ({ sendBack, input: { context } }) => {
+    const {
+      modelName,
+      modelTableName,
+      versionUid,
+      versionLocalId,
+      seedLocalId,
+      propertiesBySchemaUid,
+    } = context
+
+    const _saveDataToDb = async (): Promise<void> => {
+      const appDb = getAppDb()
+
+      // Write fetched data from EAS to the database
+      await appDb.run(
+        sql.raw(
+          `INSERT INTO ${modelTableName} (version_local_id, seed_local_id, version_uid, created_at)
+           VALUES ('${versionLocalId}', '${seedLocalId}', '${versionUid}', ${new Date().getTime()});`,
+        ),
+      )
+
+      const existingItemQuery = await appDb.run(
+        sql.raw(
+          `SELECT id, version_local_id, version_uid, seed_local_id, created_at
+           FROM ${modelTableName}
+           WHERE version_local_id = '${versionLocalId}';`,
+        ),
+      )
+
+      let itemDbId
+
+      if (
+        existingItemQuery &&
+        existingItemQuery.rows &&
+        existingItemQuery.rows.length > 0
+      ) {
+        itemDbId = existingItemQuery.rows[0][0]
+      }
+
+      if (typeof itemDbId === 'undefined') {
+        console.error(
+          '[singleItemActors] [saveDataToDb] itemDbId not found in rows: ',
+          existingItemQuery.rows,
+        )
+        return
+      }
+
+      for (const [schemaUid, properties] of Object.entries(
+        propertiesBySchemaUid,
+      )) {
+        for (const property of properties) {
+          const json = JSON.parse(property.decodedDataJson)
+          const attestationValue = json[0].value
+          let propertyValue = attestationValue.value
+
+          if (typeof propertyValue === 'string') {
+            propertyValue = escapeSqliteString(propertyValue)
+          }
+
+          const camelCasePropertyName = relatedSnakeCaseToCamelCase(
+            attestationValue.name,
+          )
+
+          let attestationCreatedAt = property.timeCreated * 1000
+
+          await appDb.run(
+            sql.raw(
+              `INSERT INTO metadata (uid,
+                                     local_id,
+                                     property_name,
+                                     property_value,
+                                     model_type,
+                                     schema_uid,
+                                     version_uid,
+                                     eas_data_type,
+                                     created_at,
+                                     attestation_created_at)
+               VALUES ('${property.id}', '${generateId()}', '${attestationValue.name}', '${propertyValue}',
+                       '${modelTableName}', '${schemaUid}',
+                       '${versionUid}',
+                       '${attestationValue.type}',
+                       ${new Date().getTime()}, ${attestationCreatedAt}, ${itemDbId})
+               ON CONFLICT DO NOTHING;`,
+            ),
+          )
+
+          // sendBack({
+          //   type: 'updateValue',
+          //   propertyName: camelCasePropertyName,
+          //   propertyValue,
+          //   source: 'eas',
+          // })
+        }
+      }
+      // const propertiesQuery = (await appDb.run(
+      //   sql.raw(
+      //     `SELECT property_name, property_value, schema_uid
+      //      FROM metadata
+      //      WHERE version_uid = '${versionUid}'
+      //      ORDER BY created_at DESC;`,
+      //   ),
+      // )) as { rows: Array<[string, string]> }
+
+      // propertiesQuery.rows?.forEach((row) => {
+      //   const propertyName = relatedSnakeCaseToCamelCase(row[0] as string)
+      //   let propertyValue = row[1] as string
+      //   const schemaUid = row[2] as string
+      //   if (isJSONString(propertyValue)) {
+      //     propertyValue = JSON.parse(propertyValue)
+      //   }
+      //   sendBack({
+      //     type: 'updateValue',
+      //     propertyName,
+      //     propertyValue,
+      //     schemaUid,
+      //     source: 'db',
+      //   })
+      // })
+
+      return
+    }
+
+    _saveDataToDb().then(() => {
+      sendBack({ type: 'saveDataToDbSuccess' })
+    })
+  },
+)

package/dist/src/saveMetadata.ts

@@ -0,0 +1,18 @@
+import { metadata, MetadataType } from '@/shared/seedSchema'
+import { getAppDb } from '../sqlWasmClient'
+import { eq } from 'drizzle-orm'
+
+export const saveMetadata = async (
+  metadataRecord: Partial<MetadataType>,
+  metadataValues: Partial<MetadataType>,
+) => {
+  const appDb = getAppDb()
+
+  await appDb
+    .update(metadata)
+    .set({
+      ...metadataValues,
+      updatedAt: Date.now(),
+    })
+    .where(eq(metadata.localId, metadataRecord.localId))
+}

package/dist/src/saveValueToDb.ts

@@ -0,0 +1,94 @@
+import { EventObject, fromCallback } from 'xstate'
+import { propertyMachine } from '@/browser/property/propertyMachine'
+import { createSeed, updateItemPropertyValue } from '@/browser/db/write'
+import { fs } from '@zenfs/core'
+import { getContentUrlFromPath } from '@/browser/helpers'
+import { createVersion } from '@/browser/db/write/createVersion'
+
+export const saveValueToDb = fromCallback<EventObject, typeof propertyMachine>(
+  ({ sendBack, input: { context, event } }) => {
+    const {
+      localId,
+      propertyName: propertyNameRaw,
+      seedLocalId,
+      propertyValue: existingValue,
+      propertyRecordSchema,
+      itemModelName,
+      schemaUid,
+    } = context
+
+    let { newValue } = event
+
+    if (existingValue === newValue) {
+      sendBack({ type: 'saveValueToDbSuccess' })
+      return
+    }
+
+    const _saveValueToDb = async () => {
+      let refResolvedValue
+      let refResolvedDisplayValue
+      let refSeedType
+      let propertyName = propertyNameRaw
+      let versionLocalId
+
+      if (
+        propertyRecordSchema &&
+        propertyRecordSchema.dataType === 'Relation'
+      ) {
+        refResolvedValue = newValue
+
+        if (!propertyName.endsWith('Id')) {
+          propertyName = `${propertyName}Id`
+        }
+
+        let fileType
+
+        const dirs = await fs.promises.readdir('/files')
+
+        for (const dir of dirs) {
+          const files = await fs.promises.readdir(`/files/${dir}`)
+          if (files.includes(newValue)) {
+            fileType = dir
+            break
+          }
+        }
+
+        if (fileType === 'images') {
+          const filePath = `/files/images/${newValue}`
+          refResolvedDisplayValue = await getContentUrlFromPath(filePath)
+          refSeedType = 'image'
+          newValue = await createSeed({
+            type: refSeedType,
+          })
+          versionLocalId = await createVersion({
+            seedLocalId: newValue,
+            seedType: refSeedType,
+          })
+        }
+      }
+
+      await updateItemPropertyValue({
+        propertyLocalId: localId,
+        propertyName,
+        newValue,
+        seedLocalId,
+        refSeedType,
+        refResolvedValue,
+        refResolvedDisplayValue,
+        versionLocalId,
+        modelName: itemModelName,
+        schemaUid,
+      })
+
+      sendBack({
+        type: 'updateContext',
+        propertyValue: newValue,
+        renderValue: refResolvedDisplayValue,
+      })
+    }
+
+    _saveValueToDb().then(() => {
+      sendBack({ type: 'saveValueToDbSuccess' })
+    })
+  },
+)

package/dist/src/seed.schema.config.ts

@@ -0,0 +1,25 @@
+import { Model, Text } from '@/browser'
+
+@Model
+class Seed {
+  @Text() uid!: string
+  @Text() type!: string
+}
+
+@Model
+class Version {
+  @Text() seedUid!: string
+  @Text() note!: string
+}
+
+@Model
+class Metadata {
+  @Text() key!: string
+  @Text() value!: string
+}
+
+export const models = {
+  Seed,
+  Version,
+  Metadata,
+}

package/dist/src/seed.ts

@@ -0,0 +1,37 @@
+import { isBrowser, isNode, isReactNative } from '@/shared/environment'
+import { Endpoints, SeedConstructorOptions } from '@/types/types'
+import { Subject } from 'rxjs'
+
+type Environment = 'node' | 'browser' | 'react-native'
+
+abstract class SeedBase {
+  private readonly _env: Environment = 'browser'
+  protected _subject: Subject<void> = new Subject<void>()
+
+  constructor(props: { endpoints: Endpoints }) {
+    console.log('Seed constructor called')
+    if (isNode()) {
+      this._env = 'node'
+    }
+    if (isBrowser()) {
+      this._env = 'browser'
+    }
+    if (isReactNative()) {
+      this._env = 'react-native'
+    }
+  }
+
+  async initialize() {}
+
+  subscribe(callback: (event: any) => void) {
+    return this._subject.subscribe(callback)
+  }
+}
+
+class SeedSync extends SeedBase {
+  constructor(props: SeedConstructorOptions) {
+    super(props)
+  }
+}
+
+export { SeedBase, SeedSync }

package/dist/src/seedProtocol.ts

@@ -0,0 +1,17 @@
+import { Attestation } from '@/browser/gql/graphql'
+
+export type PropertyToUpdateWithSeed = {
+  publishLocalId: string
+  propertySchemaUid: string
+}
+
+export type PublishRequestData = {
+  localId: string
+  seedIsRevocable: boolean
+  seedSchemaUid: string
+  seedUid?: string
+  versionSchemaUid: string
+  versionUid?: string
+  propertiesToUpdate: PropertyToUpdateWithSeed[]
+  listOfAttestations: Attestation[]
+}