@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/ts-to-proto.ts

@@ -0,0 +1,101 @@
+import { Decorator, Project } from 'ts-morph'
+import { Field, Type } from 'protobufjs'
+import fs from 'fs'
+
+type TsToProtoOptions = {
+  tsFilePath: string
+  tsConfigPath: string
+  outputFilePath: string
+}
+
+type TsToProto = (options: TsToProtoOptions) => void
+
+export const tsToProto: TsToProto = ({
+  tsFilePath,
+  tsConfigPath,
+  outputFilePath,
+}) => {
+  // Initialize the TypeScript project
+  const project = new Project({
+    tsConfigFilePath: tsConfigPath,
+  })
+
+  // Add the source file
+  const sourceFile = project.addSourceFileAtPath(tsFilePath)
+
+  // Helper function to extract decorator arguments
+  const getDecoratorArgument = (decorator: Decorator): string => {
+    const callExpression = decorator.getCallExpression()
+    if (callExpression) {
+      const args = callExpression.getArguments()
+      if (args.length > 0) {
+        return args[0].getText().replace(/['"]/g, '')
+      }
+    }
+    return ''
+  }
+
+  // Process each class
+  const classes = sourceFile.getClasses()
+  const protoClasses: { [key: string]: Type } = {}
+
+  classes.forEach((cls) => {
+    const className = cls.getName()
+    if (!className) {
+      throw new Error('Class name not found')
+    }
+    const type = new Type(className)
+
+    // Process each property
+    cls.getProperties().forEach((prop, index) => {
+      const propName = prop.getName()
+      const decorators = prop.getDecorators()
+
+      decorators.forEach((decorator) => {
+        const decoratorName = decorator.getName()
+        switch (decoratorName) {
+          case 'Text':
+            type.add(new Field(propName, type.fieldsArray.length + 1, 'string'))
+            break
+          case 'ImageSrc':
+            type.add(new Field(propName, type.fieldsArray.length + 1, 'string'))
+            break
+          case 'Relation':
+            const relatedType = getDecoratorArgument(decorator)
+            type.add(
+              new Field(propName, type.fieldsArray.length + 1, relatedType),
+            )
+            break
+          case 'List':
+            const listType = getDecoratorArgument(decorator)
+            type.add(
+              new Field(
+                propName,
+                type.fieldsArray.length + 1,
+                listType,
+                'repeated',
+              ),
+            )
+            break
+          default:
+            break
+        }
+      })
+    })
+
+    protoClasses[className] = type
+  })
+
+  // Generate .proto content
+  let protoContent = 'syntax = "proto3";\n\n'
+  Object.values(protoClasses).forEach((type) => {
+    protoContent += `message ${type.name} {\n`
+    for (const field of type.fieldsArray) {
+      protoContent += `  ${field.repeated ? 'repeated' : ''} ${field.type} ${field.name} = ${field.id};\n`
+    }
+    protoContent += '}\n'
+  })
+
+  // Write to .proto file
+  fs.writeFileSync(outputFilePath, protoContent)
+}

package/dist/src/types.ts

@@ -0,0 +1,12 @@
+type SqliteWasmResult = {
+  type: string | null
+  row: string[] | null
+  rowNumber: number | null
+  columnNames: string[]
+}
+type SqliteWasmCallback = (result: SqliteWasmResult) => void
+
+type ReturnObj = {
+  database: string
+  [key: string]: string | number | null | undefined | string[]
+}

package/dist/src/updateItemPropertyValue.ts

@@ -0,0 +1,243 @@
+import { escapeSqliteString } from '@/helpers/db'
+import { metadata, MetadataType } from '@/seedSchema'
+import { and, eq, sql } from 'drizzle-orm'
+import { getSeedData } from '@/db/read/getSeedData'
+import { getVersionData } from '@/db/read/getVersionData'
+import { generateId } from '@/helpers'
+import debug from 'debug'
+import { eventEmitter } from '@/eventBus'
+import { BaseDb } from '@/db/Db/BaseDb'
+const logger = debug('app:write:updateItemPropertyValue')
+
+const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }: { modelName: string, seedLocalId: string, seedUid: string }) => {
+  if (!modelName || (!seedLocalId && !seedUid)) {
+    return
+  }
+  // eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`)
+}
+
+type UpdateItemPropertyValueResult = {
+  localId: string
+  schemaUid: string
+}
+
+type UpdateItemPropertyValue = (props: Partial<MetadataType>) => Promise<UpdateItemPropertyValueResult | undefined>
+
+export const updateItemPropertyValue: UpdateItemPropertyValue = async ({
+  localId,
+  propertyName,
+  newValue,
+  seedUid,
+  seedLocalId,
+  modelName,
+  refSeedType,
+  refResolvedValue,
+  refResolvedDisplayValue,
+  versionLocalId,
+  versionUid,
+  schemaUid,
+  localStorageDir,
+}) => {
+  if (!localId && !seedLocalId) {
+    logger(
+      `[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`,
+    )
+    return
+  }
+
+  let safeNewValue = newValue
+
+  if (
+    typeof newValue === 'string' &&
+    !refResolvedDisplayValue &&
+    !refResolvedValue
+  ) {
+    safeNewValue = escapeSqliteString(newValue)
+  }
+
+  const appDb = BaseDb.getAppDb()
+
+  const rows = await appDb
+    .select()
+    .from(metadata)
+    .where(
+      and(
+        eq(metadata.propertyName, propertyName!),
+        eq(metadata.seedLocalId, seedLocalId!),
+      ),
+    )
+    .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+
+  // const mostRecentRecordStatement = `SELECT local_id,
+  //                                           uid,
+  //                                           property_name,
+  //                                           property_value,
+  //                                           model_type,
+  //                                           seed_uid,
+  //                                           seed_local_id,
+  //                                           version_local_id,
+  //                                           version_uid,
+  //                                           schema_uid,
+  //                                           eas_data_type
+  //                                    FROM metadata
+  //                                    WHERE property_name = '${propertyName}'
+  //                                      AND seed_local_id = '${seedLocalId}'
+  //                                    ORDER BY COALESCE(attestation_created_at, created_at) DESC;`
+  //
+  // const { rows } = await runQueryForStatement(mostRecentRecordStatement)
+
+  if (rows && rows.length > 0) {
+    const {
+      localId,
+      uid,
+      propertyName: propertyNameFromDb,
+      propertyValue: propertyValueFromDb,
+      modelType,
+      seedUid,
+      seedLocalId: seedLocalIdFromDb,
+      versionLocalId,
+      versionUid,
+      schemaUid,
+      easDataType,
+      localStorageDir: localStorageDirFromDb,
+      refSeedType: refSeedTypeFromDb,
+      refResolvedValue: refResolvedValueFromDb,
+      refResolvedDisplayValue: refResolvedDisplayValueFromDb,
+    } = rows[0]
+
+    if (
+      propertyValueFromDb === newValue &&
+      modelType === modelName?.toLowerCase() &&
+      refSeedTypeFromDb === refSeedType &&
+      refResolvedValueFromDb === refResolvedValue
+    ) {
+      logger(
+        `[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`,
+      )
+      return
+    }
+
+    // This means we already have a local-only record so we should just update that one
+    if (!uid) {
+      const updatePropertyStatement = `UPDATE metadata
+                                       SET property_value             = '${safeNewValue}',
+                                           ref_seed_type              = ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                           ref_resolved_value         = ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                           ref_resolved_display_value = ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                           updated_at                 = ${Date.now()}
+                                       WHERE local_id = '${localId}';`
+
+      await appDb.run(sql.raw(updatePropertyStatement))
+
+      sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+      return
+    }
+
+    const seedDataFromDb = await getSeedData({ seedLocalId })
+    const versionDataFromDb = await getVersionData({ localId: versionLocalId })
+
+    // Here we don't have a local-only record so we need to create a new one
+    const newLocalId = generateId()
+
+    const newPropertyStatement = `INSERT INTO metadata (local_id,
+                                                        property_name,
+                                                        property_value,
+                                                        model_type,
+                                                        seed_uid,
+                                                        seed_local_id,
+                                                        version_local_id,
+                                                        version_uid,
+                                                        schema_uid,
+                                                        eas_data_type,
+                                                        ref_seed_type,
+                                                        ref_resolved_value,
+                                                        ref_resolved_display_value,
+                                                        local_storage_dir,
+                                                        created_at)
+                                  VALUES ('${newLocalId}',
+                                          '${propertyNameFromDb}',
+                                          '${safeNewValue}',
+                                          '${modelType || modelName?.toLowerCase()}',
+                                          ${seedDataFromDb?.uid ? `'${seedDataFromDb.uid}'` : 'NULL'},
+                                          '${seedLocalIdFromDb}',
+                                          '${versionLocalId}',
+                                          ${versionDataFromDb?.uid ? `'${versionDataFromDb.uid}'` : 'NULL'},
+                                          '${schemaUid}',
+                                          ${easDataType ? `'${easDataType}'` : 'NULL'},
+                                          ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                          ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                          ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                          ${localStorageDir ? `'${localStorageDir}'` : 'NULL'},
+                                          ${Date.now()});`
+
+    await appDb.run(sql.raw(newPropertyStatement))
+
+    sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+    return {
+      localId: newLocalId,
+      schemaUid,
+    }
+  }
+
+  // Here there are no records for this property on this seed so we should create one
+
+  const newLocalId = generateId()
+
+  if (!seedUid) {
+    const seedData = await getSeedData({ seedLocalId })
+    if (seedData) {
+      seedUid = seedData.uid
+    }
+  }
+
+  if (!versionUid) {
+    const versionData = await getVersionData({ localId: versionLocalId })
+    if (versionData) {
+      versionUid = versionData.uid
+    }
+  }
+
+  const newPropertyStatement = `INSERT INTO metadata (local_id,
+                                                      property_name,
+                                                      property_value,
+                                                      model_type,
+                                                      seed_uid,
+                                                      seed_local_id,
+                                                      version_local_id,
+                                                      version_uid,
+                                                      schema_uid,
+                                                      ref_seed_type,
+                                                      ref_resolved_value,
+                                                      ref_resolved_display_value,
+                                                      local_storage_dir,
+                                                      created_at)
+                                VALUES ('${newLocalId}',
+                                        '${propertyName}',
+                                        '${safeNewValue}',
+                                        '${modelName?.toLowerCase()}',
+                                        ${seedUid ? `'${seedUid}'` : 'NULL'},
+                                        '${seedLocalId}',
+                                        '${versionLocalId}',
+                                        ${versionUid ? `'${versionUid}'` : 'NULL'},
+                                        '${schemaUid}',
+                                        ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                        ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                        ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                        ${localStorageDir ? `'${localStorageDir}'` : 'NULL'},
+                                        ${Date.now()});`
+
+  await appDb.run(sql.raw(newPropertyStatement))
+
+  sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+  return {
+    localId: newLocalId,
+    schemaUid,
+  }
+
+  if (!seedLocalId && propertyName && modelName && newValue) {
+    // TODO: Does this ever happen? If so, what should we do?
+  }
+}

package/dist/src/updateMachineContext.ts

@@ -0,0 +1,21 @@
+import { ActionFunction, assign } from 'xstate'
+
+type UpdateMachineContext = {
+  actions: ActionFunction<any, any, any, any, any, any, any, any, any>[] | any
+}
+export const updateMachineContext: UpdateMachineContext = {
+  actions: assign(({ context, event }) => {
+    const newContext = Object.assign({}, context)
+
+    for (let i = 0; i < Object.keys(event).length; i++) {
+      const key = Object.keys(event)[i]
+      if (key === 'type') {
+        continue
+      }
+      newContext[key] = event[key]
+    }
+    return {
+      ...newContext,
+    }
+  }),
+}

package/dist/src/updateMetadata.ts

@@ -0,0 +1,59 @@
+import { metadata, MetadataType } from '@/seedSchema'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { eq } from 'drizzle-orm'
+import { PropertyType } from '@/types'
+import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
+import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
+import { INTERNAL_DATA_TYPES } from '@/helpers/constants'
+import { toSnakeCase } from 'drizzle-orm/casing'
+import { Schema } from '@/graphql/gql/graphql'
+import { GET_SCHEMA_BY_NAME } from '@/Item/queries'
+
+type UpdateMetadata = (
+  metadataValues: Partial<MetadataType>,
+  propertyRecordSchema?: PropertyType | undefined,
+) => Promise<MetadataType>
+
+export const updateMetadata: UpdateMetadata = async (metadataValues, propertyRecordSchema) => {
+  const appDb = BaseDb.getAppDb()
+
+  const { localId, ...rest } = metadataValues
+
+  if (!localId) {
+    throw new Error('No localId provided to updateMetadata')
+  }
+  
+  const isItemStorage = propertyRecordSchema && propertyRecordSchema.storageType === 'ItemStorage'
+
+  if (
+    !isItemStorage && 
+    propertyRecordSchema &&
+    (!metadataValues.schemaUid || metadataValues.schemaUid === 'undefined' )
+  ) {
+    const queryClient = BaseQueryClient.getQueryClient()
+    const easClient = BaseEasClient.getEasClient()
+
+    const easDataType = INTERNAL_DATA_TYPES[propertyRecordSchema.dataType].eas
+
+    const propertyNameSnakeCase = toSnakeCase(metadataValues.propertyName)
+  
+    const queryResult = await queryClient.fetchQuery({
+      queryKey: [`getSchemaByName${metadataValues.propertyName}`],
+      queryFn: async (): Promise<{schemas: Schema[]}> =>
+        easClient.request(GET_SCHEMA_BY_NAME, {
+          where: {
+            schema: {
+              equals: `${easDataType} ${propertyNameSnakeCase}`,
+            },
+          },
+        }),
+    })
+
+    if (queryResult && queryResult.schemas.length > 0) {
+      metadataValues.schemaUid = queryResult.schemas[0].id
+    }
+
+  }
+
+  await appDb.update(metadata).set(rest).where(eq(metadata.localId, localId))
+}

package/dist/src/upload.ts

@@ -0,0 +1,86 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PublishMachineContext } from '@/types'
+import { BaseItem } from '@/Item/BaseItem'
+import debug from 'debug'
+import { getCorrectId } from '@/helpers'
+
+const logger = debug('app:services:publish:actors:upload')
+
+type UploadItem = {
+  sourceFilePath: string
+  fileSize: number
+  filename: string
+  seedLocalId?: string
+  metadataLocalId?: string
+}
+
+export const upload = fromCallback<
+  EventObject,
+  FromCallbackInput<PublishMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { localId } = context
+
+  const _upload = async () => {
+    const item = await BaseItem.find({ seedLocalId: localId })
+
+    if (!item) {
+      logger('no item with localId', localId)
+      return false
+    }
+
+    const editedProperties = await item.getEditedProperties()
+
+    for (const propertyData of editedProperties) {
+      if (propertyData.refSeedType === 'image') {
+        // Check sha256 of local file against sha256 of remote files
+        // If different, add this file to uploadItems
+      }
+    }
+
+    const uploadItems = []
+
+    for (const editedPropertyData of editedProperties) {
+      const propertyName = editedPropertyData.propertyName
+      const editedProperty = item.properties[propertyName]
+
+      if (!editedProperty || !editedProperty.propertyDef) {
+        continue
+      }
+
+      if (
+        editedProperty.propertyDef.refValueType &&
+        editedProperty.propertyDef.refValueType === 'ImageSrc'
+      ) {
+        const context = editedProperty.getService().getSnapshot().context
+        const imageSeedId = context.propertyValue
+        const { localId, uid } = getCorrectId(imageSeedId)
+      }
+
+      if (
+        editedProperty.propertyDef.storageType === 'ItemStorage' &&
+        editedProperty.propertyDef.localStorageDir
+      ) {
+      }
+    }
+
+    if (uploadItems.length === 0) {
+      return true
+    }
+
+    // const turbo = TurboFactory.unauthenticated()
+
+    // turbo.uploadSignedDataItem()
+    //
+    // const { id, owner, dataCaches, fastFinalityIndexes } = await turbo.uploadFile(() => {
+    //   fileStreamFactory => () => fs.createReadStream(filePath),
+    //   fileSizeFactory => () => fileSize,
+    // });
+    return false
+  }
+
+  _upload().then((isValid) => {
+    if (isValid) {
+      sendBack({ type: 'uploadSuccess' })
+    }
+  })
+})

package/dist/src/validate.ts

@@ -0,0 +1,45 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput } from '@/types/machines'
+import fs from '@zenfs/core'
+import {
+  DB_VALIDATING_SUCCESS,
+  DB_VALIDATING_WAIT,
+} from '@/services/internal/constants'
+
+export const validate = fromCallback<
+  EventObject,
+  FromCallbackInput<DbServiceContext>
+>(({ sendBack, input: { context } }) => {
+  const { pathToDir, pathToDb } = context
+
+  const pathsToCheck = [
+    pathToDir,
+    `${pathToDir}/db`,
+    `${pathToDir}/db/meta`,
+    `${pathToDir}/db/meta/_journal.json`,
+  ]
+
+  const _validate = async (): Promise<boolean> => {
+    // If any of the necessary files don't exist, we wipe them all and recreate
+    let exists = false
+
+    for (const path of pathsToCheck) {
+      exists = await fs.promises.exists(path)
+      if (!exists) {
+        sendBack({
+          type: DB_VALIDATING_WAIT,
+        })
+        return false
+      }
+    }
+    return exists
+  }
+
+  _validate().then((allFilesExist) => {
+    if (allFilesExist) {
+      sendBack({ type: DB_VALIDATING_SUCCESS, pathToDb, pathToDir })
+      return
+    }
+    sendBack({ type: DB_VALIDATING_WAIT })
+  })
+})

package/dist/src/validateInput.ts

@@ -0,0 +1,43 @@
+import { EventObject, fromCallback } from 'xstate'
+import { INTERNAL_VALIDATING_INPUT_SUCCESS, ARWEAVE_HOST } from '@/services/internal/constants'
+import { FromCallbackInput, InternalMachineContext } from '@/types'
+import { isBrowser, isNode } from '@/helpers/environment'
+
+export const validateInput = fromCallback<
+  EventObject,
+  FromCallbackInput<InternalMachineContext>
+>(
+  ({ sendBack, input: { context } }) => {
+
+    const { endpoints, addresses, arweaveDomain } = context
+    let { filesDir } = context
+
+    if (!endpoints || !endpoints.filePaths || !endpoints.files) {
+      throw new Error('validateInput called with invalid endpoints')
+    }
+
+    if (!filesDir) {
+      if (isBrowser()) {
+        filesDir = '/'
+      }
+
+      if (!isBrowser()) {
+        throw new Error('validateInput called with invalid filesDir')
+      }
+    }
+
+    const _validateInput = async (): Promise<void> => {
+      sendBack({
+        type: INTERNAL_VALIDATING_INPUT_SUCCESS,
+        endpoints,
+        addresses,
+        filesDir,
+        arweaveDomain: arweaveDomain || ARWEAVE_HOST,
+      })
+    }
+
+    _validateInput().then(() => {
+      return
+    })
+  },
+)

package/dist/src/validateItemData.ts

@@ -0,0 +1,20 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PublishMachineContext } from '@/types'
+
+export const validateItemData = fromCallback<
+  EventObject,
+  FromCallbackInput<PublishMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const _validateItemData = async () => {
+    if (context && context.localId) {
+      return true
+    }
+    return false
+  }
+
+  _validateItemData().then((isValid) => {
+    if (isValid) {
+      sendBack({ type: 'validateItemDataSuccess' })
+    }
+  })
+})

package/dist/src/versionData.ts

@@ -0,0 +1,24 @@
+import { versions } from '@/seedSchema'
+import { count, max } from 'drizzle-orm'
+import { BaseDb } from '@/db/Db/BaseDb'
+
+export const getVersionData = () => {
+  const appDb = BaseDb.getAppDb()
+
+  return appDb.$with('versionData').as(
+    appDb
+      .select({
+        seedLocalId: versions.seedLocalId,
+        seedUid: versions.seedUid,
+        latestVersionUid: versions.uid,
+        latestVersionLocalId: versions.localId,
+        versionsCount: count(versions.localId).as('versionsCount'),
+        lastVersionPublishedAt: max(versions.attestationCreatedAt).as(
+          'lastVersionPublishedAt',
+        ),
+        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
+      })
+      .from(versions)
+      .groupBy(versions.seedLocalId),
+  )
+}

package/dist/src/waitForDb.ts

@@ -0,0 +1,25 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PropertyMachineContext } from '@/types'
+import { BaseDb } from '@/db/Db/BaseDb'
+import debug from 'debug'
+
+const logger = debug('app:ItemProperty:service:actors:waitForDb')
+
+export const waitForDb = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext>
+>(({ sendBack }) => {
+  const _waitForDb = new Promise<void>((resolve) => {
+    const interval = setInterval(() => {
+      const appDb = BaseDb.getAppDb()
+      if (appDb) {
+        clearInterval(interval)
+        resolve()
+      }
+    }, 100)
+  })
+
+  _waitForDb.then(() => {
+    sendBack({ type: 'waitForDbSuccess' })
+  })
+})