@seedprotocol/sdk 0.2.9 → 0.2.11

package/dist/src/initialize.ts

@@ -1,127 +1,278 @@
-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/EasClient/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
+import { toSnakeCase } from '@/helpers'
 import {
-  GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
-  GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY,
-  GLOBAL_INITIALIZING_SEND_CONFIG,
-} from '@/services/internal/constants'
-import debug from 'debug'
-import { FromCallbackInput, GlobalMachineContext } from '@/types'
+  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/Db/BaseDb'
-import { appState } from '@/seedSchema'
-import { like } from 'drizzle-orm'
-import { fetchSchemaUids } from '@/stores/eas'
 
-const logger = debug('app:services:global:actors:initialize')
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
+
+
+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 queryClient = BaseQueryClient.getQueryClient()
+    const easClient = BaseEasClient.getEasClient()
+
+    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 = BaseDb.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/syncDbWithEas.ts

@@ -666,6 +666,9 @@ const syncDbWithEasHandler: DebouncedFunc<any> = throttle(
       itemSeeds,
     })
 
+    const queryClient = BaseQueryClient.getQueryClient()
+    const easClient = BaseEasClient.getEasClient()
+
     const { itemVersions } = await queryClient.fetchQuery({
       queryKey: [`getVersionsForAllModels`],
       queryFn: async () =>

package/dist/src/waitForDb.ts

@@ -1,22 +1,23 @@
 import { EventObject, fromCallback } from 'xstate'
-import { itemMachineSingle } from '@/Item/service/itemMachineSingle'
+import { FromCallbackInput, PropertyMachineContext } from '@/types'
 import { BaseDb } from '@/db/Db/BaseDb'
 
-export const waitForDb = fromCallback<EventObject, typeof itemMachineSingle>(
-  ({ sendBack }) => {
-    const _waitForDb = new Promise<void>((resolve) => {
-      const interval = setInterval(() => {
-        const appDb = BaseDb.getAppDb()
+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)
-    })
+      if (appDb) {
+        clearInterval(interval)
+        resolve()
+      }
+    }, 100)
+  })
 
-    _waitForDb.then(() => {
-      sendBack({ type: 'waitForDbSuccess' })
-    })
-  },
-)
+  _waitForDb.then(() => {
+    sendBack({ type: 'waitForDbSuccess' })
+  })
+})

package/dist/types/src/events/item/syncDbWithEas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncDbWithEas.d.ts","sourceRoot":"","sources":["../../../../../src/events/item/syncDbWithEas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,aAAa,EAAuB,MAAM,WAAW,CAAA;AAymBzE,QAAA,MAAM,oBAAoB,EAAE,aAAa,CAAC,GAAG,CA+F5C,CAAA;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA"}
+{"version":3,"file":"syncDbWithEas.d.ts","sourceRoot":"","sources":["../../../../../src/events/item/syncDbWithEas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,aAAa,EAAuB,MAAM,WAAW,CAAA;AAymBzE,QAAA,MAAM,oBAAoB,EAAE,aAAa,CAAC,GAAG,CAkG5C,CAAA;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seedprotocol/sdk",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "The SDK for Seed Protocol",
   "type": "module",
   "engines": {