@seedprotocol/sdk 0.1.128 → 0.2.0

package/dist/src/getRelationValueData.ts

@@ -0,0 +1,27 @@
+import { metadata, MetadataType } from '@/seedSchema'
+import { eq, max } from 'drizzle-orm'
+import { BaseDb } from '@/db/BaseDb'
+
+export const getRelationValueData = async (
+  propertyValue: any,
+): Promise<MetadataType | undefined> => {
+  const appDb = BaseDb.getAppDb()
+
+  const rows = (await appDb
+    .select({
+      propertyValue: metadata.propertyValue,
+      attestationCreatedAt: max(metadata.attestationCreatedAt),
+      refResolvedDisplayValue: metadata.refResolvedDisplayValue,
+      refResolvedValue: metadata.refResolvedValue,
+      refSeedType: metadata.refSeedType,
+      easDataType: metadata.easDataType,
+    })
+    .from(metadata)
+    .where(eq(metadata.propertyValue, propertyValue))) as MetadataType[]
+
+  if (!rows || rows.length === 0) {
+    return
+  }
+
+  return rows[0]
+} 

package/dist/src/getSchemaForItemProperty.ts

@@ -1,9 +1,11 @@
-import { Schema, SchemaWhereInput } from '@/browser/gql/graphql'
-import { toSnakeCase } from '@/shared/helpers'
-import { GET_SCHEMAS } from '@/browser'
-import { easClient, queryClient } from '@/browser/helpers'
+import { Schema, SchemaWhereInput } from '@/graphql/gql/graphql'
+import { toSnakeCase, BaseEasClient, BaseQueryClient } from '@/helpers'
+import { GET_SCHEMAS } from '@/Item/queries'
 import { TypedData } from '@ethereum-attestation-service/eas-sdk/dist/offchain/typed-data-handler'
 
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+
 type GetSchemaForPropertyProps = {
   schemaUid?: string
   propertyName: string

package/dist/src/getSchemaUidForModel.ts

@@ -1,5 +1,10 @@
-import { easClient, queryClient } from '@/browser/helpers'
-import { GET_SCHEMAS } from '@/browser'
+import { GET_SCHEMAS } from '@/Item/queries'
+import { BaseEasClient } from '@/helpers/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/BaseQueryClient'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+
 
 export const getSchemaUidForModel = async (
   modelName: string,

package/dist/src/getSeedData.ts

@@ -1,5 +1,5 @@
-import { getAppDb } from '../sqlWasmClient'
-import { seeds, SeedType } from '@/shared/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
+import { seeds, SeedType } from '@/seedSchema'
 import { eq } from 'drizzle-orm'
 
 type GetSeedDataProps = {
@@ -10,7 +10,7 @@ type GetSeedDataProps = {
 type GetSeedData = (props: GetSeedDataProps) => Promise<SeedType | undefined>
 
 export const getSeedData: GetSeedData = async ({ seedLocalId, seedUid }) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   let query
 

package/dist/src/getSegmentedItemProperties.ts

@@ -1,7 +1,7 @@
-import { Item } from '@/browser'
-import { UploadProperty } from '@/browser/db/read/getPublishUploads'
+import { UploadProperty } from '@/db/read/getPublishUploads'
+import { IItem } from '@/interfaces'
 
-export const getSegmentedItemProperties = (item: Item<any>) => {
+export const getSegmentedItemProperties = (item: IItem<any>) => {
   const itemBasicProperties = []
   const itemRelationProperties = []
   const itemListProperties = []

package/dist/src/getStorageTransactionIdForSeedUid.ts

@@ -0,0 +1,38 @@
+import { metadata } from '@/seedSchema'
+import { and, eq } from 'drizzle-orm'
+import { BaseDb } from '@/db/BaseDb'
+
+const seedUidToStorageTransactionId = new Map<string, string>()
+
+type GetStorageTransactionIdResults = {
+  storageTransactionId: string
+}[]
+
+export const getStorageTransactionIdForSeedUid = async (
+  seedUid: string,
+): Promise<string | undefined> => {
+  if (seedUidToStorageTransactionId.has(seedUid)) {
+    return seedUidToStorageTransactionId.get(seedUid)
+  }
+
+  const appDb = BaseDb.getAppDb()
+
+  const results = (await appDb
+    .select({
+      storageTransactionId: metadata.propertyValue,
+    })
+    .from(metadata)
+    .where(
+      and(
+        eq(metadata.seedUid, seedUid),
+        eq(metadata.propertyName, 'storageTransactionId'),
+      ),
+    )) as GetStorageTransactionIdResults
+
+  if (!results || results.length === 0) {
+    return
+  }
+
+  seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId)
+  return results[0].storageTransactionId
+} 

package/dist/src/getVersionData.ts

@@ -1,6 +1,6 @@
-import { getAppDb } from '../sqlWasmClient'
-import { versions, VersionsType } from '@/shared/seedSchema'
+import { versions, VersionsType } from '@/seedSchema'
 import { and, eq } from 'drizzle-orm'
+import { BaseDb } from '../BaseDb'
 
 type GetVersionDataProps = {
   localId?: string | null
@@ -17,7 +17,7 @@ export const getVersionData: GetVersionData = async ({
   seedLocalId,
   uid,
 }) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const whereClauses = []
 

package/dist/src/globalMachine.ts

@@ -7,16 +7,16 @@ import {
   GLOBAL_INITIALIZING_SEND_CONFIG,
   GlobalState,
   MachineIds,
-} from '@/browser/services/internal/constants'
+} from '@/services/internal/constants'
 import { GlobalMachineContext, ModelClassType } from '@/types'
 import { eventEmitter } from '@/eventBus'
-import { initialize } from '@/browser/services/global/actors/initialize'
-import { getSchemaForModel } from '@/browser/services/global/actors/getSchemaForModel'
-import { addModelsToDb } from '@/browser/services/global/actors/addModelsToDb'
-import { internalMachine } from '@/browser/services/internal/internalMachine'
+import { initialize } from '@/services/global/actors/initialize'
+import { getSchemaForModel } from '@/services/global/actors/getSchemaForModel'
+import { addModelsToDb } from '@/services/global/actors/addModelsToDb'
+import { internalMachine } from '@/services/internal/internalMachine'
 import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
-import { publishMachine } from '@/browser/services/publish/publishMachine'
-import { savePublishService } from '@/browser/services/global/actors/savePublishService'
+import { publishMachine } from '@/services/publish/publishMachine'
+import { savePublishService } from '@/services/global/actors/savePublishService'
 
 const {
   UNINITIALIZED,

package/dist/src/helpers.ts

@@ -1,7 +1,7 @@
 import { fs } from '@zenfs/core'
 import path from 'path'
 import { Endpoints } from '@/types'
-import { BROWSER_FS_TOP_DIR } from '@/browser/services/internal/constants'
+import { BROWSER_FS_TOP_DIR } from '@/services/internal/constants'
 import debug from 'debug'
 
 const logger = debug('app:services:internal:helpers')
@@ -142,8 +142,11 @@ export const confirmFilesExist = async (filePaths: string[]) => {
   }
 }
 
+const filesToExclude = ['.DS_Store']
+
 export const syncDbFiles = async ({ filePaths, files }: Endpoints) => {
-  const fileList = await fetchDirectory(filePaths)
+  let fileList = await fetchDirectory(filePaths)
+  fileList = fileList.filter((file: string) => !filesToExclude.includes(file))
   await fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList)
   await confirmFilesExist(fileList)
   logger('[syncDbFiles] Files synced!')

package/dist/src/hydrateExistingItem.ts

@@ -1,5 +1,5 @@
 import { EventObject, fromCallback } from 'xstate'
-import { waitForEvent } from '@/browser/events'
+import { waitForEvent } from '@/events'
 import {
   FromCallbackInput,
   HydrateExistingItemEvent,

package/dist/src/hydrateFromDb.ts

@@ -2,9 +2,9 @@ import { EventObject, fromCallback } from 'xstate'
 import { and, eq, or, sql } from 'drizzle-orm'
 import debug from 'debug'
 import { fs } from '@zenfs/core'
-import { metadata } from 'src/shared/seedSchema'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
-import { updateMetadata } from '@/browser/db/write/updateMetadata'
+import { metadata } from '@/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
+import { updateMetadata } from '@/db/write/updateMetadata'
 import { FromCallbackInput } from '@/types/machines'
 import { PropertyMachineContext } from '@/types/property'
 import path from 'path'
@@ -45,7 +45,7 @@ export const hydrateFromDb = fromCallback<
   }
 
   const _hydrateFromDb = async () => {
-    const appDb = getAppDb()
+    const appDb = BaseDb.getAppDb()
 
     const isRelation =
       propertyRecordSchema &&
@@ -152,14 +152,6 @@ export const hydrateFromDb = fromCallback<
       )
     }
 
-    if (
-      seedUidFromDb ===
-        '0x66922b8f40057eb04f94983d59a608e32bceb95b47134dd5b550688940c64f1d' &&
-      propertyName === 'featureImage'
-    ) {
-      console.log('Property featureImage', firstRow)
-    }
-
     if (
       propertyRecordSchema &&
       propertyRecordSchema.refValueType === 'ImageSrc'
@@ -217,7 +209,6 @@ export const hydrateFromDb = fromCallback<
           if (storageTransactionQuery && storageTransactionQuery.length > 0) {
             const row = storageTransactionQuery[0]
             refResolvedValue = row.propertyValue
-            console.log('storageTransactionId', refResolvedValue)
             await updateMetadata({
               localId,
               refResolvedValue,

package/dist/src/hydrateNewItem.ts

@@ -1,7 +1,7 @@
 import { EventObject, fromCallback } from 'xstate'
-import { createSeed } from '@/browser/db/write'
+import { createSeed } from '@/db/write/createSeed'
 import { FromCallbackInput, ItemMachineContext } from '@/types'
-import { createVersion } from '@/browser/db/write/createVersion'
+import { createVersion } from '@/db/write/createVersion'
 
 export const hydrateNewItem = fromCallback<
   EventObject,

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
-export * from './wasm.d.ts'
+export type * from './wasm.d.ts'
 
 declare module '@seedprotocol/sdk' {
-  export * from '@/types'
+  export type * from '@/types'
 }

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'