@seedprotocol/sdk 0.1.46 → 0.1.48

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/upload.ts

@@ -0,0 +1,86 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PublishMachineContext } from '@/types'
+import { Item } from '@/browser'
+import debug from 'debug'
+import { getCorrectId } from '@/browser/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 Item.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,42 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput } from '@/types/machines'
+import { fs } from '@zenfs/core'
+import {
+  DB_VALIDATING_SUCCESS,
+  DB_VALIDATING_WAIT,
+} from '@/browser/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(() => {
+    sendBack({ type: DB_VALIDATING_SUCCESS, pathToDb, pathToDir })
+    return
+  })
+})

package/dist/src/validateInput.ts

@@ -0,0 +1,33 @@
+import { EventObject, fromCallback } from 'xstate'
+import { INTERNAL_VALIDATING_INPUT_SUCCESS } from '@/browser/services/internal/constants'
+import { internalMachine } from '@/browser/services/internal/internalMachine'
+
+export const validateInput = fromCallback<EventObject, typeof internalMachine>(
+  ({ sendBack, input: { event } }) => {
+    const { endpoints, addresses } = event
+
+    if (typeof window === 'undefined') {
+      throw new Error('validateInput called from non-browser context')
+    }
+
+    if (!endpoints || !endpoints.filePaths || !endpoints.files) {
+      throw new Error('validateInput called with invalid endpoints')
+    }
+
+    if (!addresses || !addresses.length) {
+      throw new Error('validateInput called with invalid addresses')
+    }
+
+    const _validateInput = async (): Promise<void> => {
+      sendBack({
+        type: INTERNAL_VALIDATING_INPUT_SUCCESS,
+        endpoints,
+        addresses,
+      })
+    }
+
+    _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/waitForDb.ts

@@ -0,0 +1,23 @@
+import { EventObject, fromCallback } from 'xstate'
+import { itemMachineSingle } from '@/browser/item/single/itemMachineSingle'
+
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+export const waitForDb = fromCallback<EventObject, typeof itemMachineSingle>(
+  ({ sendBack }) => {
+    const _waitForDb = new Promise<void>((resolve) => {
+      const interval = setInterval(() => {
+        const appDb = getAppDb()
+
+        if (appDb) {
+          clearInterval(interval)
+          resolve()
+        }
+      }, 100)
+    })
+
+    _waitForDb.then(() => {
+      sendBack({ type: 'waitForDbSuccess' })
+    })
+  },
+)