@seedprotocol/sdk 0.3.1 → 0.3.3

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

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

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

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

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-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' })
-  })
-})