@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/migrate.ts

@@ -0,0 +1,57 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput, SqliteWasmResult } from '@/types'
+import {
+  BROWSER_FS_TOP_DIR,
+  DB_MIGRATING_SUCCESS,
+} from '@/services/internal/constants'
+import debug from 'debug'
+import { BaseDb } from '@/db/Db/BaseDb'
+import fs from '@zenfs/core'
+import { FileManager } from '@/browser/helpers/FileManager'
+import { isBrowser } from '@/helpers/environment'
+
+const logger = debug('app:services:db:actors:migrate')
+
+
+
+export const migrate = fromCallback<
+  EventObject,
+  FromCallbackInput<DbServiceContext>
+>(({ sendBack, input: { context } }) => {
+  const { pathToDbDir, dbId, dbName } = context
+
+  logger('[db/actors] migrate context', context)
+
+  let journalExists = false
+
+
+  const _checkForFiles = async (): Promise<void> => {
+    const journalPath = `/${pathToDbDir}/meta/_journal.json`
+
+    journalExists = await fs.promises.exists(journalPath)
+
+    if (!journalExists && isBrowser()) {
+      await FileManager.waitForFile(journalPath, 500, 60000)
+    }
+  }
+
+  const _migrate = async (): Promise<void> => {
+    await BaseDb.migrate(pathToDbDir, dbName, dbId)
+  }
+
+  _checkForFiles()
+    .then(() => {
+      if (!isBrowser()) {
+        return _migrate()
+      }
+      if (journalExists) {
+        return _migrate()
+      }
+    })
+    .then(() => {
+      console.log('sending db migrating success')
+      sendBack({ type: DB_MIGRATING_SUCCESS, dbName })
+    })
+
+  return () => { }
+})

package/dist/src/model.ts

@@ -0,0 +1,72 @@
+import { PropertyStates, PropertyValue } from './property'
+import { Actor, AnyActorLogic } from 'xstate'
+import { Static } from '@sinclair/typebox'
+import { IModelClass, TModelSchema } from '@/schema'
+import { BaseItem } from '@/Item/BaseItem'
+
+export type ModelDefinitions = {
+  [modelName: string]: ModelClassType
+}
+
+export type ModelStatus = (propName: string) => keyof PropertyStates
+
+export type ExcludedKeys = 'states' | 'status'
+
+type ExcludeKeys<T, K> = {
+  [P in keyof T as Exclude<P, K>]: T[P]
+}
+
+export type ModelClassType = {
+  originalConstructor: () => void
+  schema: ModelSchema
+  schemaUid?: string
+  create: (values: ModelValues<any>) => Promise<BaseItem<any>>
+}
+
+export type ModelValues<T extends Record<string, any>> = BaseItem<any> & {
+  schema: ModelSchema
+  ModelClass?: ModelClassType
+  [key: string & keyof T]: PropertyValue
+}
+
+export type StatesMap<T> = Map<string, Actor<T extends AnyActorLogic ? T : never>>
+
+// export type ModelSchema = {
+//   [key: string]: TObject
+// }
+
+export type ModelSchema = Partial<Static<typeof TModelSchema>>
+
+export type ModelConstructor = <
+  T extends { new(...args: any[]): IModelClass },
+>(
+  constructor: T,
+) => T & IModelClass
+
+// export type ModelConstructor = Static<TModelConstructor>
+
+export interface ModelProperty {
+  propertyLocalId?: string
+  name: string
+  dataType:
+  | 'string'
+  | 'bytes32'
+  | 'uint8'
+  | 'uint256'
+  | 'bool'
+  | 'address'
+  | 'bytes'
+  | 'int8'
+  | 'int256'
+  | 'int'
+  | 'bytes32[]'
+  modelSchemaUids: string[]
+  modelLocalId?: string
+  schemaName?: string
+  schemaUid: string
+  schemaDefinition: string
+  relatedModelSchemaUid?: string
+  relatedModelLocalId?: string
+  createdAt?: number
+  updatedAt?: number
+}

package/dist/src/modelClass.ts

@@ -0,0 +1,19 @@
+import { ModelClassType } from '@/types'
+
+const modelStore = new Map<string, ModelClassType>()
+
+export const getModels = (): Record<string, ModelClassType> => {
+  return Object.fromEntries(modelStore)
+}
+
+export const getModel = (modelName: string): ModelClassType | undefined => {
+  return modelStore.get(modelName)
+}
+
+export const getModelNames = (): string[] => {
+  return Array.from(modelStore.keys())
+}
+
+export const setModel = (modelName: string, model: ModelClassType) => {
+  modelStore.set(modelName, model)
+}

package/dist/src/node.app.db.config.ts

@@ -0,0 +1,41 @@
+import { defineConfig } from 'drizzle-kit'
+import dotenv from 'dotenv'
+import process from 'node:process'
+import path from 'path'
+import { DrizzleConfig } from 'drizzle-orm'
+
+dotenv.config()
+
+let sdkRoot = './node_modules/@seedprotocol/sdk'
+
+if (process.env.IS_SEED_DEV) {
+  sdkRoot = './src'
+}
+
+let dotSeedDir = path.join(process.cwd(), '.seed')
+
+if (process.env.IS_SEED_DEV) {
+  dotSeedDir = path.join(
+    process.cwd(),
+    '__tests__',
+    '__mocks__',
+    'node',
+    'project',
+    '.seed',
+  )
+}
+
+let schemaDir = `${sdkRoot}/dist/seedSchema/*.ts`
+
+if (process.env.IS_SEED_DEV) {
+  schemaDir = `${sdkRoot}/seedSchema/*.ts`
+}
+
+export default defineConfig({
+  schema: schemaDir,
+  dialect: 'sqlite',
+  out: `${dotSeedDir}/db`,
+  dbCredentials: {
+    url: `${dotSeedDir}/db/app_db.sqlite3`,
+  },
+}) as DrizzleConfig

package/dist/src/prepareDb.ts

@@ -0,0 +1,29 @@
+import { BaseDb } from '@/db/Db/BaseDb'
+import { InternalMachineContext } from '@/types'
+import { FromCallbackInput } from '@/types'
+import { EventObject, fromCallback } from 'xstate'
+
+
+export const prepareDb = fromCallback<
+  EventObject,
+  FromCallbackInput<InternalMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { filesDir } = context
+
+  if (!filesDir) {
+    throw new Error('filesDir is required')
+  }
+
+  const _prepareDb = async (): Promise<void> => {
+    const appDb = await BaseDb.prepareDb(filesDir)
+    if (appDb) {
+      sendBack({ type: 'prepareDbSuccess'})
+    }
+
+  }
+
+  _prepareDb().then(() => {
+    return
+  })
+
+})

package/dist/src/preparePublishRequestData.ts

@@ -0,0 +1,81 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PublishMachineContext } from '@/types'
+import { models as modelsTable, modelUids } from '@/seedSchema'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { eq } from 'drizzle-orm'
+import { getModelSchemas } from '@/db/read/getModelSchemas'
+import { BaseItem } from '@/Item/BaseItem'
+
+export const preparePublishRequestData = fromCallback<
+  EventObject,
+  FromCallbackInput<PublishMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { localId } = context
+
+  const _preparePublishRequestData = async () => {
+    const item = await BaseItem.find({ seedLocalId: localId })
+
+    if (!item) {
+      return false
+    }
+
+    const appDb = BaseDb.getAppDb()
+
+    const modelsRows = await appDb
+      .select({
+        modelName: modelsTable.name,
+        schemaUid: modelUids.uid,
+      })
+      .from(modelsTable)
+      .leftJoin(modelUids, eq(modelUids.modelId, modelsTable.id))
+      .where(eq(modelsTable.name, 'Version'))
+
+    if (!modelsRows || modelsRows.length === 0) {
+      sendBack({ type: 'preparePublishRequestDataError' })
+      return false
+    }
+
+    const versionSchemaUid = modelsRows[0].schemaUid
+
+    const editedProperties = await item.getEditedProperties()
+
+    const { modelSchemas, schemaStringToModelRecord } = await getModelSchemas({
+      sdkConfigDb: appDb,
+    })
+
+    // const dataEncoder = new SchemaEncoder(modelProperty.schemaDefinition,)
+    // const encodedData = dataEncoder.encodeData(data,)
+    //
+    // itemData.listOfAttestations.push({
+    //   schema : modelProperty.schemaUid,
+    //   data   : [
+    //     {
+    //       ...defaultAttestationData,
+    //       data : encodedData,
+    //     },
+    //   ],
+    // },)
+
+    const publishRequestData = {
+      seedIsRevocable: false,
+      seedSchemaUid: item.schemaUid,
+      seedUid: item.seedUid,
+      versionSchemaUid,
+      versionUid: item.latestVersionUid,
+      listOfAttestations: [],
+    }
+
+    sendBack({
+      type: 'updateContext',
+      ...publishRequestData,
+    })
+
+    return true
+  }
+
+  _preparePublishRequestData().then((success) => {
+    if (success) {
+      sendBack({ type: 'preparePublishRequestDataSuccess' })
+    }
+  })
+})

package/dist/src/processItems.ts

@@ -0,0 +1,74 @@
+import { EventObject, fromCallback } from 'xstate'
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
+import { Attestation } from '@/graphql/gql/graphql'
+import { eventEmitter } from '@/eventBus'
+
+export const processItems = fromCallback<
+  EventObject,
+  FromCallbackInput<AllItemsMachineContext>
+>(
+  ({ sendBack, input: { context } }) => {
+    const {
+      itemVersions,
+      itemSeeds,
+      ModelClass,
+      schemaUidsByModelName,
+      mostRecentPropertiesBySeedUid,
+      times,
+      // relatedProperties,
+      // relatedVersionsBySchemaUid,
+      // relatedVersionsBySeedUid,
+    } = context
+
+    if (!itemVersions || !itemSeeds) {
+      throw new Error('No itemVersions or itemSeeds found')
+    }
+
+    const _processItems = async () => {
+      // For each itemSeed, find all the Versions
+      for (const itemSeed of itemSeeds.slice(8, 16)) {
+        const versionsForSeed = itemVersions.filter(
+          (version) => version.refUID === itemSeed.id,
+        )
+
+        if (versionsForSeed.length === 0) {
+          continue
+        }
+
+        // Find the most recent Version for each Seed
+        const recentVersionsMap: { [seedId: string]: Attestation } = {}
+        versionsForSeed.forEach((version: Attestation) => {
+          const existingVersion = recentVersionsMap[version.refUID]
+          if (
+            !existingVersion ||
+            new Date(version.timeCreated * 1000) >
+            new Date(existingVersion.timeCreated * 1000)
+          ) {
+            recentVersionsMap[version.refUID] = version
+          }
+        })
+      }
+    }
+
+    _processItems().then(() => {
+      sendBack({ type: 'processItemsSuccess' })
+      const modelName = ModelClass.originalConstructor.name
+      eventEmitter.emit('item.requestAll', {
+        modelName,
+      })
+      eventEmitter.emit('service.save', {
+        modelName,
+      })
+      sendBack({
+        type: 'updateTimes',
+        times: {
+          ...times,
+          processItems: {
+            start: null,
+            end: Date.now(),
+          },
+        },
+      })
+    })
+  },
+)

package/dist/src/property.ts

@@ -0,0 +1,156 @@
+import { useImmer } from 'use-immer'
+import { Item } from '@/browser/Item'
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { useSelector } from '@xstate/react'
+import debug from 'debug'
+import { eventEmitter } from '@/eventBus'
+import { ItemProperty } from '@/browser/ItemProperty/ItemProperty'
+import { useGlobalServiceStatus } from '@/browser/react/services'
+import { IItemProperty } from '@/interfaces'
+
+const logger = debug('app:react:property')
+
+type UseItemPropertyProps = {
+  propertyName: string
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type UseItemPropertyReturn = {
+  property: IItemProperty<any> | undefined
+  isInitialized: boolean
+  value: any
+  status: string
+}
+
+type UseItemProperty = (props: UseItemPropertyProps | undefined) => UseItemPropertyReturn
+
+export const useItemProperty: UseItemProperty = (props = {
+  propertyName: '',
+  seedLocalId: '',
+  seedUid: '',
+}) => {
+
+  const { propertyName, seedLocalId, seedUid } = props
+
+  const [property, setProperty] = useState<IItemProperty<any> | undefined>()
+  const [isInitialized, setIsInitialized] = useState(false)
+
+  const { internalStatus } = useGlobalServiceStatus()
+
+  const isReadingDb = useRef(false)
+
+  const value = useSelector(property?.getService(), (snapshot) => {
+    if (!snapshot || !snapshot.context) {
+      return
+    }
+    return snapshot.context.renderValue || snapshot.context.propertyValue
+  })
+
+  const status = useSelector(
+    property?.getService(),
+    (snapshot) => snapshot?.value as string,
+  )
+
+  const readFromDb = useCallback(async () => {
+    if (
+      internalStatus !== 'ready' ||
+      isReadingDb.current ||
+      (!seedLocalId && !seedUid)
+    ) {
+      return
+    }
+    isReadingDb.current = true
+    const foundProperty = await ItemProperty.find({
+      propertyName,
+      seedLocalId,
+      seedUid,
+    })
+    if (!foundProperty) {
+      logger(
+        `[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`,
+      )
+      isReadingDb.current = false
+      return
+    }
+    if (foundProperty.status === 'waitingForDb') {
+      foundProperty.getService().send({ type: 'waitForDbSuccess' })
+    }
+    setProperty(foundProperty)
+    setIsInitialized(true)
+    isReadingDb.current = false
+  }, [internalStatus, props])
+
+  const listenerRef = useRef(readFromDb)
+
+  useEffect(() => {
+    listenerRef.current = readFromDb
+  }, [readFromDb, props])
+
+  useEffect(() => {
+    if (internalStatus === 'ready') {
+      readFromDb()
+    }
+  }, [internalStatus])
+
+  useEffect(() => {
+    eventEmitter.addListener(
+      `property.${seedUid || seedLocalId}.${propertyName}.update`,
+      () => {
+        listenerRef.current()
+      },
+    )
+
+    return () => {
+      eventEmitter.removeListener(
+        `property.${seedUid || seedLocalId}.${propertyName}.update`,
+      )
+    }
+  }, [])
+
+  return {
+    property,
+    isInitialized,
+    value,
+    status,
+  }
+}
+export const useItemProperties = (item?: Item<any>) => {
+  const [propertyObj, setPropertyObj] = useImmer({})
+  const [isListening, setIsListening] = useState(false)
+
+  const updatePropertyObj = useCallback(
+    (event) => {
+      if (!item) {
+        console.error('[XXXXXX] [updatePropertyObj] no item when expected')
+        return
+      }
+      const { propertyName, propertyValue } = event
+      if (!propertyName) {
+        return
+      }
+      setPropertyObj((draft) => {
+        draft[propertyName] = propertyValue
+      })
+    },
+    [item],
+  )
+
+  useEffect(() => {
+    if (!item) {
+      return
+    }
+
+    const eventKey = `item.${item.seedLocalId}.property.update`
+
+    eventEmitter.addListener(eventKey, updatePropertyObj)
+
+    return () => {
+      eventEmitter.removeListener(eventKey, updatePropertyObj)
+    }
+  }, [item])
+
+  return {
+    properties: propertyObj,
+  }
+}