@seedprotocol/sdk 0.3.1 → 0.3.2

package/dist/src/migrate.ts

@@ -1,57 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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,
-  }
-}