@seedprotocol/sdk 0.1.129 → 0.2.1

package/dist/src/initialize.ts

@@ -1,127 +1,277 @@
-import { EventObject, fromCallback, Subscription } from 'xstate'
-import { isNode, isReactNative } from '@/shared'
+import { EventObject, fromCallback } from 'xstate'
+import { GET_SCHEMAS } from '@/Item/queries'
+import pluralize from 'pluralize'
+import { BaseEasClient } from '@/helpers/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/BaseQueryClient'
+import { toSnakeCase } from '@/helpers'
 import {
-  GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
-  GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY,
-  GLOBAL_INITIALIZING_SEND_CONFIG,
-} from '@/browser/services/internal/constants'
-import debug from 'debug'
-import { FromCallbackInput, GlobalMachineContext } from '@/types'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
-import { appState } from '@/shared/seedSchema'
-import { like } from 'drizzle-orm'
-import { fetchSchemaUids } from '@/browser/stores/eas'
-
-const logger = debug('app:services:global:actors:initialize')
+  models as modelsTable,
+  modelUids,
+  properties,
+  propertyUids,
+} from '@/seedSchema'
+import { eq } from 'drizzle-orm'
+import { SchemaWhereInput } from '@/graphql/gql/graphql'
+import { INTERNAL_DATA_TYPES } from '@/helpers/constants'
+import { getAddressesFromDb } from '@/helpers/db'
+import { eventEmitter } from '@/eventBus'
+import { BaseDb } from '@/db/BaseDb'
+
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+
+type Times = {
+  initialize?: {
+    start: number | null
+    end: number | null
+  }
+  fetchDbData?: {
+    start: number | null
+    end: number | null
+  }
+  fetchSeeds?: {
+    start: number | null
+    end: number | null
+  }
+  fetchVersions?: {
+    start: number | null
+    end: number | null
+  }
+  fetchRelatedItems?: {
+    start: number | null
+    end: number | null
+  }
+  processItems?: {
+    start: number | null
+    end: number | null
+  }
+}
+
+type InternalDataType = keyof typeof INTERNAL_DATA_TYPES;
 
 export const initialize = fromCallback<
   EventObject,
-  FromCallbackInput<GlobalMachineContext, EventObject>
->(({ sendBack, input: { event, context } }) => {
-  const { internalService, models, endpoints, arweaveDomain } = context
+  FromCallbackInput<AllItemsMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { modelName, modelAddedToDb, ModelClass, times } = context
 
-  const { addresses } = event
+  const newTimes: Times = {
+    initialize: {
+      start: Date.now(),
+      end: null,
+    },
+  }
 
-  let environment = 'browser'
+  let modelNameLowercase: string | undefined
+  let modelNamePlural: string | undefined
+  let queryVariables: Record<string, unknown> | undefined
+  let appDb
 
-  if (isNode()) {
-    environment = 'node'
-  }
+  const _initialize = async () => {
+    appDb = BaseDb.getAppDb()
 
-  if (isReactNative()) {
-    environment = 'react-native'
-  }
+    // const rows = await getItemsDataFromDb(modelName)
+    //
+    // if (rows && rows.length > 0) {
+    //   for (const itemData of rows) {
+    //     const {
+    //       versionLocalId,
+    //       versionUid,
+    //       createdAt,
+    //       seedLocalId,
+    //       seedUid,
+    //       attestationCreatedAt,
+    //     } = itemData
+    //
+    //     eventEmitter.emit('item.create.request', {
+    //       itemData: {
+    //         versionLocalId,
+    //         versionUid,
+    //         createdAt,
+    //         seedLocalId,
+    //         seedUid,
+    //         attestationCreatedAt,
+    //       },
+    //       ModelClass,
+    //     })
+    //   }
+    // }
 
-  let internalSubscription: Subscription | undefined
-  let easSubscription: Subscription | undefined
+    modelNameLowercase = modelName.toLowerCase()
+    modelNamePlural = pluralize(modelNameLowercase!)
 
-  if (environment === 'browser' && models) {
-    const _initFileSystem = async (): Promise<void> => {
-      return
-      // return new Promise((resolve) => {
-      // })
+    const modelSchemas = await queryClient.fetchQuery({
+      queryKey: [`getSchemas${modelName}`],
+      queryFn: async () =>
+        easClient.request(GET_SCHEMAS, {
+          where: {
+            schema: {
+              equals: `bytes32 ${toSnakeCase(modelName)}`,
+            },
+          },
+        }),
+    })
+
+    if (
+      !modelSchemas ||
+      !modelSchemas.schemas ||
+      modelSchemas.schemas.length === 0
+    ) {
+      throw new Error(`No schema found for ${modelName}`)
     }
 
-    const _initInternal = async (): Promise<void> => {
-      return new Promise((resolve) => {
-        internalSubscription = internalService.subscribe((snapshot) => {
-          logger('[sdk] [internal] snapshot', snapshot)
-          if (snapshot.value === 'ready') {
-            resolve()
-          }
-        })
-        internalService.send({
-          type: 'init',
-          endpoints,
-          addresses,
-          arweaveDomain,
-        })
+    const modelSchema = modelSchemas.schemas[0]
+
+    if (!modelSchema.id) {
+      throw new Error(
+        `No schema ID found for schema ${JSON.stringify(modelSchema)}`,
+      )
+    }
+
+    const foundModels = await appDb
+      .select({
+        id: modelsTable.id,
+        name: modelsTable.name,
+        uid: modelUids.uid,
       })
+      .from(modelsTable)
+      .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
+      .where(eq(modelsTable.name, modelName))
+      .limit(1)
+
+    const foundModel = foundModels[0]
+
+    if (!foundModel) {
+      sendBack({ type: 'modelNotFound', modelName })
+      return
     }
 
-    const _initAllItemsServices = async (): Promise<void> => {
-      const appDb = getAppDb()
+    await appDb
+      .insert(modelUids)
+      .values({
+        modelId: foundModel.id,
+        uid: modelSchema.id,
+      })
+      .onConflictDoNothing()
 
-      const rows = await appDb
-        .select()
-        .from(appState)
-        .where(like(appState.key, 'snapshot__%'))
+    const foundPropertiesDb = await appDb
+      .select({
+        id: properties.id,
+        name: properties.name,
+        dataType: properties.dataType,
+        uid: propertyUids.uid,
+      })
+      .from(properties)
+      .fullJoin(propertyUids, eq(properties.id, propertyUids.propertyId))
+      .where(eq(properties.modelId, foundModel.id))
 
-      const payloadObj = {
-        create: {},
-        restore: {},
+    if (foundPropertiesDb && foundPropertiesDb.length > 0) {
+      const queryVariables: { where: SchemaWhereInput } = {
+        where: {
+          OR: [],
+        },
       }
 
-      const modelNamesRestored: string[] = []
+      for (const foundPropertyDb of foundPropertiesDb) {
+        if (foundPropertyDb.name && foundPropertyDb.dataType) {
+          const easDatatype = INTERNAL_DATA_TYPES[foundPropertyDb.dataType as InternalDataType].eas
 
-      if (rows && rows.length > 0) {
-        for (const row of rows) {
-          const modelName = row.key.replace('snapshot__', '')
-          payloadObj.restore[modelName] = JSON.parse(row.value)
-          modelNamesRestored.push(modelName)
+          let easPropertyName = toSnakeCase(foundPropertyDb.name)
+
+          if (foundPropertyDb.dataType === 'Relation') {
+            easPropertyName += '_id'
+          }
+
+          queryVariables.where.OR!.push({
+            schema: {
+              equals: `${easDatatype} ${easPropertyName}`,
+            },
+          })
         }
       }
-      for (const [modelName, ModelClass] of Object.entries(models)) {
-        if (!modelNamesRestored.includes(modelName)) {
-          payloadObj.create[modelName] = ModelClass
+
+      const foundPropertySchemas = await queryClient.fetchQuery({
+        queryKey: [`getPropertySchemas${modelName}`],
+        queryFn: async () => easClient.request(GET_SCHEMAS, queryVariables),
+      })
+
+      const tempExclusions = ['html', 'json']
+
+      for (const foundProperty of foundPropertiesDb) {
+        if (tempExclusions.includes(foundProperty.name)) {
+          continue
+        }
+        const easDatatype = INTERNAL_DATA_TYPES[foundProperty.dataType as InternalDataType].eas
+
+        let easPropertyName = toSnakeCase(foundProperty.name)
+
+        if (foundProperty.dataType === 'Relation') {
+          easPropertyName += '_id'
+        }
+
+        const regex = new RegExp(`${easDatatype} ${easPropertyName}`)
+        const propertySchema = foundPropertySchemas.schemas.find((s) =>
+          regex.test(s.schema),
+        )
+
+        if (!propertySchema) {
+          // TODO: We should create the schema here?
+          continue
         }
+        await appDb
+          .insert(propertyUids)
+          .values({
+            propertyId: foundProperty.id,
+            uid: propertySchema.id,
+          })
+          .onConflictDoNothing()
       }
-      sendBack({
-        type: GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
-        ...payloadObj,
-      })
     }
 
-    const _initEas = async (): Promise<void> => {
-      await fetchSchemaUids()
+    const addresses = await getAddressesFromDb()
+
+    queryVariables = {
+      where: {
+        attester: {
+          in: addresses,
+        },
+        schemaId: {
+          equals: modelSchema.id,
+        },
+        decodedDataJson: {
+          contains: modelSchema.id,
+        },
+      },
     }
+  }
 
-    _initFileSystem().then(() => {
-      logger('[global/actors] File system initialized')
+  const initializeHandler = () => {
+    _initialize().then(() => {
+      sendBack({
+        type: 'initializeSuccess',
+        modelName,
+        modelNameLowercase,
+        modelNamePlural,
+        queryVariables,
+      })
+      newTimes!.initialize!.end = Date.now()
+      sendBack({ type: 'updateTimes', times: newTimes })
     })
+  }
 
-    _initInternal()
-      .then(() => {
-        return _initAllItemsServices()
-      })
-      .then(() => {
-        return _initEas()
-      })
-      .then(() => {
-        logger('[global/actors] Internal initialized')
-        sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY })
-        internalSubscription?.unsubscribe()
-      })
+  if (modelAddedToDb) {
+    initializeHandler()
+  }
 
-    // _initEas().then(() => {
-    //   logger('EAS initialized')
-    // })
+  const dbReadyHandler = (event) => {
+    initializeHandler()
   }
 
-  sendBack({ type: GLOBAL_INITIALIZING_SEND_CONFIG, environment })
+  eventEmitter.addListener('allDbsLoaded', dbReadyHandler)
 
   return () => {
-    internalSubscription?.unsubscribe()
-    easSubscription?.unsubscribe()
+    eventEmitter.removeListener('allDbsLoaded', dbReadyHandler)
   }
 })

package/dist/src/internalMachine.ts

@@ -9,13 +9,13 @@ import {
   InternalState,
   MachineIds,
 } from './constants'
-import { dbMachine } from '@/browser/services/db/dbMachine'
+import { dbMachine } from '@/services/db/dbMachine'
 import debug from 'debug'
-import { validateInput } from '@/browser/services/internal/actors/validateInput'
-import { prepareDb } from '@/browser/services/internal/actors/prepareDb'
-import { configureFs } from '@/browser/services/internal/actors/configureFs'
-import { saveConfig } from '@/browser/services/internal/actors/saveConfig'
-import { loadAppDb } from '@/browser/services/internal/actors/loadAppDb'
+import { validateInput } from '@/services/internal/actors/validateInput'
+import { prepareDb } from '@/services/internal/actors/prepareDb'
+import { configureFs } from '@/services/internal/actors/configureFs'
+import { saveConfig } from '@/services/internal/actors/saveConfig'
+import { loadAppDb } from '@/services/internal/actors/loadAppDb'
 import { InternalMachineContext } from '@/types'
 
 const logger = debug('app:services:internal:machine')

package/dist/src/itemMachineAll.ts

@@ -1,5 +1,5 @@
 import { assign, setup } from 'xstate'
-import { MachineIds } from '@/browser/services/internal/constants'
+import { MachineIds } from '@/services/internal/constants'
 import { AllItemsMachineContext } from '@/types'
 import { eventEmitter } from '@/eventBus'
 import { initialize } from '@/browser/item/all/actors/initialize'

package/dist/src/itemMachineSingle.ts

@@ -1,5 +1,5 @@
 import { assign, setup } from 'xstate'
-import { MachineIds } from '@/browser/services/internal/constants'
+import { MachineIds } from '@/services/internal/constants'
 import { ItemMachineContext } from '@/types'
 import { ItemProperty } from '../../property'
 import { waitForDb } from './actors/waitForDb'
@@ -7,7 +7,7 @@ import { initialize } from './actors/initialize'
 import { hydrateExistingItem } from './actors/hydrateExistingItem'
 import { hydrateNewItem } from './actors/hydrateNewItem'
 import { fetchDataFromEas } from './actors/fetchDataFromEas'
-import { reload } from '@/browser/item/single/actors/reload'
+import { reload } from './actors/reload'
 
 export const itemMachineSingle = setup({
   types: {

package/dist/src/loadAppDb.ts

@@ -3,7 +3,7 @@ import {
   DB_NAME_APP,
   DB_ON_SNAPSHOT,
   INTERNAL_LOADING_APP_DB_SUCCESS,
-} from '@/browser/services/internal/constants'
+} from '@/services/internal/constants'
 import debug from 'debug'
 import { FromCallbackInput, InternalMachineContext } from '@/types'
 

package/dist/src/logger.ts

@@ -1,4 +1,4 @@
-import { dayjs } from '@/shared/helpers/index'
+import { dayjs } from '@/helpers/index'
 
 type Log = (message: string, data?: unknown) => void
 

package/dist/src/machine.ts

@@ -1,7 +1,7 @@
 import { ActorRefFrom, assign, setup } from 'xstate'
 import { downloadMachine } from '@/browser/schema/file/download'
 import { uploadMachine } from '@/browser/schema/file/upload'
-import { MachineIds } from '@/browser/services/internal/constants'
+import { MachineIds } from '@/services/internal/constants'
 
 type FileSystemMachineContext = {
   addresses?: string[]

package/dist/src/migrate.ts

@@ -3,7 +3,7 @@ import { DbServiceContext, FromCallbackInput, SqliteWasmResult } from '@/types'
 import {
   BROWSER_FS_TOP_DIR,
   DB_MIGRATING_SUCCESS,
-} from '@/browser/services/internal/constants'
+} from '@/services/internal/constants'
 import { getSqliteWasmClient, setAppDb } from '@/browser/db/sqlWasmClient'
 import { drizzle } from 'drizzle-orm/sqlite-proxy'
 import { sql } from 'drizzle-orm'
@@ -12,7 +12,7 @@ import debug from 'debug'
 import { migrate as drizzleMigrate } from 'drizzle-orm/sqlite-proxy/migrator'
 import { readMigrationFiles } from 'drizzle-orm/migrator'
 import * as fsNode from 'node:fs'
-import { waitForFile } from '@/shared/helpers/files'
+import { waitForFile } from '@/helpers/files'
 
 const logger = debug('app:services:db:actors:migrate')
 
@@ -311,5 +311,5 @@ export const migrate = fromCallback<
       sendBack({ type: DB_MIGRATING_SUCCESS, dbName })
     })
 
-  return () => {}
+  return () => { }
 })

package/dist/src/prepareDb.ts

@@ -1,34 +1,23 @@
+import { BaseDb } from '@/db/BaseDb'
 import { EventObject, fromCallback } from 'xstate'
-import { SqliteConnectionManager } from '@/browser/services/db'
-import { getSqliteWasmClient, setManager } from '@/browser/db/sqlWasmClient'
+
 
 export const prepareDb = fromCallback<EventObject>(({ sendBack }) => {
-  let sqliteWasmClient
+
   const _prepareDb = async (): Promise<void> => {
     if (typeof window === 'undefined') {
       return
     }
-    sqliteWasmClient = await getSqliteWasmClient()
-  }
 
-  const interval = setInterval(() => {
-    // TODO: Add a timeout
-    // TODO: Add a cancel token to the promise so we can prevent more loops starting while we're checking the successful outcome
-    if (sqliteWasmClient) {
-      clearInterval(interval)
-      const manager = new SqliteConnectionManager(sqliteWasmClient)
-      setManager(manager)
+    const manager = await BaseDb.prepareDb()
+    if (manager) {
       sendBack({ type: 'prepareDbSuccess', manager })
-      return
     }
-    _prepareDb().then(() => {
-      return
-    })
-  }, 200)
 
-  return () => {
-    if (interval) {
-      clearInterval(interval)
-    }
   }
+
+  _prepareDb().then(() => {
+    return
+  })
+
 })

package/dist/src/preparePublishRequestData.ts

@@ -1,10 +1,10 @@
 import { EventObject, fromCallback } from 'xstate'
 import { FromCallbackInput, PublishMachineContext } from '@/types'
 import { Item } from '@/browser/item'
-import { models as modelsTable, modelUids } from '@/shared/seedSchema'
-import { getAppDb } from '@/browser'
+import { models as modelsTable, modelUids } from '@/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
 import { eq } from 'drizzle-orm'
-import { getModelSchemas } from '@/browser/db/read/getModelSchemas'
+import { getModelSchemas } from '@/db/read/getModelSchemas'
 
 export const preparePublishRequestData = fromCallback<
   EventObject,
@@ -19,7 +19,7 @@ export const preparePublishRequestData = fromCallback<
       return false
     }
 
-    const appDb = getAppDb()
+    const appDb = BaseDb.getAppDb()
 
     const modelsRows = await appDb
       .select({

package/dist/src/processItems.ts

@@ -1,6 +1,6 @@
 import { EventObject, fromCallback } from 'xstate'
 import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
-import { Attestation } from '@/browser/gql/graphql'
+import { Attestation } from '@/graphql/gql/graphql'
 import { eventEmitter } from '@/eventBus'
 
 export const processItems = fromCallback<EventObject, typeof itemMachineAll>(
@@ -39,7 +39,7 @@ export const processItems = fromCallback<EventObject, typeof itemMachineAll>(
           if (
             !existingVersion ||
             new Date(version.timeCreated * 1000) >
-              new Date(existingVersion.timeCreated * 1000)
+            new Date(existingVersion.timeCreated * 1000)
           ) {
             recentVersionsMap[version.refUID] = version
           }

package/dist/src/property.ts

@@ -4,8 +4,9 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 import { useSelector } from '@xstate/react'
 import debug from 'debug'
 import { eventEmitter } from '@/eventBus'
-import { ItemProperty } from '@/browser/property'
+import { ItemProperty } from '@/browser/item/ItemProperty'
 import { useGlobalServiceStatus } from '@/browser/react/services'
+import { IItemProperty } from '@/interfaces'
 
 const logger = debug('app:react:property')
 
@@ -16,7 +17,7 @@ type UseItemPropertyProps = {
 }
 
 type UseItemPropertyReturn = {
-  property: ItemProperty<any> | undefined
+  property: IItemProperty<any> | undefined
   isInitialized: boolean
   value: any
   status: string
@@ -29,7 +30,7 @@ export const useItemProperty: UseItemProperty = ({
   seedLocalId,
   seedUid,
 }) => {
-  const [property, setProperty] = useState<ItemProperty<any> | undefined>()
+  const [property, setProperty] = useState<IItemProperty<any> | undefined>()
   const [isInitialized, setIsInitialized] = useState(false)
 
   const { internalStatus } = useGlobalServiceStatus()

package/dist/src/propertyMachine.ts

@@ -1,18 +1,18 @@
 import { assign, setup } from 'xstate'
 import { PropertyMachineContext } from '@/types'
 
-import { resolveRemoteStorage } from '@/browser/property/actors/resolveRemoteStorage'
-import { waitForDb } from '@/browser/property/actors/waitForDb'
-import { initialize } from '@/browser/property/actors/initialize'
-import { resolveRelatedValue } from '@/browser/property/actors/resolveRelatedValue'
-import { hydrateFromDb } from '@/browser/property/actors/hydrateFromDb'
+import { resolveRemoteStorage } from '@/ItemProperty/service/actors/resolveRemoteStorage'
+import { waitForDb } from '@/ItemProperty/service/actors/waitForDb'
+import { initialize } from '@/ItemProperty/service/actors/initialize'
+import { resolveRelatedValue } from '@/ItemProperty/service/actors/resolveRelatedValue'
+import { hydrateFromDb } from '@/ItemProperty/service/actors/hydrateFromDb'
 import {
   saveImageSrc,
   saveItemStorage,
   saveRelation,
-} from '@/browser/property/actors/saveValueToDb'
-import { analyzeInput } from '@/browser/property/actors/saveValueToDb/analyzeInput' // import { updateMachineContext } from '@/browser/helpers'
-// import { updateMachineContext } from '@/browser/helpers'
+} from '@/ItemProperty/service/actors/saveValueToDb'
+import { analyzeInput } from '@/ItemProperty/service/actors/saveValueToDb/analyzeInput' // import { updateMachineContext } from '@/helpers'
+// import { updateMachineContext } from '@/helpers'
 
 export const propertyMachine = setup({
   types: {

package/dist/src/publish.ts

@@ -1,4 +1,4 @@
-import { getGlobalService } from '@/browser/services/global'
+import { getGlobalService } from '@/services/global'
 
 type PublishItemRequestEvent = {
   seedLocalId: string

package/dist/src/publishMachine.ts

@@ -1,11 +1,11 @@
 import { setup } from 'xstate'
 import { validateItemData } from './actors/validateItemData'
-import { PublishMachineStates } from '@/browser/services/internal/constants'
+import { PublishMachineStates } from '@/services/internal/constants'
 import { PublishMachineContext } from '@/types'
 import { createPublishAttempt } from './actors/createPublishAttempt'
-import { updateMachineContext } from '@/browser/helpers/updateMachineContext'
-import { preparePublishRequestData } from '@/browser/services/publish/actors/preparePublishRequestData'
-import { upload } from '@/browser/services/publish/actors/upload'
+import { updateMachineContext } from '@/helpers/updateMachineContext'
+import { preparePublishRequestData } from '@/services/publish/actors/preparePublishRequestData'
+import { upload } from '@/services/publish/actors/upload'
 
 const {
   VALIDATING_ITEM_DATA,