@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/client.ts

@@ -0,0 +1,85 @@
+import { areFsListenersReady, setupFsListeners } from '@/browser/events/files'
+import { setupAllItemsEventHandlers } from '@/browser/events'
+import { setupServicesEventHandlers } from '@/browser/services/events'
+import { eventEmitter } from '@/eventBus'
+import { globalService } from '@/browser/services'
+import { ModelClassType, SeedConstructorOptions } from '@/types'
+import {
+  getModel,
+  getModelNames,
+  getModels,
+  setModel,
+} from '@/browser/stores/modelClass'
+import { setupServiceHandlers } from '@/browser/events/services'
+
+const client = {
+  init: ({ config, addresses }: SeedConstructorOptions) => {
+    const { endpoints, models } = config
+
+    for (const [key, value] of Object.entries(models)) {
+      setModel(key, value)
+    }
+    setupFsListeners()
+    setupAllItemsEventHandlers()
+    setupServicesEventHandlers()
+    setupServiceHandlers()
+    if (areFsListenersReady()) {
+      eventEmitter.emit('fs.init')
+    }
+    if (!areFsListenersReady()) {
+      console.error('fs listeners not ready during init')
+    }
+    globalService.send({ type: 'init', endpoints, models, addresses })
+    import('@/shared/configs/seed.schema.config').then(({ models }) => {
+      for (const [key, value] of Object.entries(models)) {
+        setModel(key, value)
+      }
+    })
+  },
+  subscribe: (callback: any) => {
+    callback({
+      type: '@xstate.snapshot',
+      actorRef: globalService,
+      snapshot: globalService.getSnapshot(),
+    })
+    eventEmitter.addListener('globalService', callback)
+
+    return {
+      unsubscribe: () => {
+        eventEmitter.removeListener('globalService', callback)
+      },
+    }
+  },
+  on: (outerEvent: string, callback: any) => {
+    eventEmitter.addListener(outerEvent, callback)
+
+    return {
+      unsubscribe: () => {
+        eventEmitter.removeListener(outerEvent, callback)
+      },
+    }
+  },
+  getSeedClass: async () => {
+    return new Promise((resolve) => {
+      const subscription = globalService.subscribe((snapshot) => {
+        if (snapshot.status === 'done') {
+          resolve(snapshot.output)
+        }
+      })
+
+      globalService.send({ type: 'getSeed' })
+      subscription.unsubscribe()
+    })
+  },
+  getModel: (modelName: string) => {
+    return getModel(modelName)
+  },
+  getModels: (): Record<string, ModelClassType> => {
+    return getModels()
+  },
+  getModelNames: (): string[] => {
+    return getModelNames()
+  },
+}
+
+export { client }

package/dist/src/configureFs.ts

@@ -0,0 +1,81 @@
+import { EventObject, fromCallback } from 'xstate'
+import { areFsListenersReady, isFsInitialized } from '@/browser/events/files'
+import { waitForEvent } from '@/browser/events'
+import {
+  BROWSER_FS_TOP_DIR,
+  DB_WAITING_FOR_FILES_RECEIVED,
+  INTERNAL_CONFIGURING_FS_SUCCESS,
+} from '@/browser/services/internal/constants'
+import { fs } from '@zenfs/core'
+import debug from 'debug'
+import { FromCallbackInput, InternalMachineContext } from '@/types'
+
+const logger = debug('app:internal:actors:configureFs')
+
+export const configureFs = fromCallback<
+  EventObject,
+  FromCallbackInput<InternalMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { endpoints, appDbService } = context
+
+  logger('[internal/actors] [configureFs] Configuring FS')
+
+  const _configureFs = async (): Promise<void> => {
+    logger('[internal/actors] [configureFs] calling _configureFs')
+
+    logger(
+      '[internal/actors] [configureFs] areFsListenersReady:',
+      areFsListenersReady(),
+    )
+    logger(
+      '[internal/actors] [configureFs] isFsInitialized:',
+      isFsInitialized(),
+    )
+
+    await waitForEvent({
+      req: {
+        eventLabel: 'fs.downloadAll.request',
+        data: { endpoints },
+      },
+      res: {
+        eventLabel: 'fs.downloadAll.success',
+      },
+    })
+
+    const journalPath = `${BROWSER_FS_TOP_DIR}/db/meta/_journal.json`
+
+    const journalExists = await fs.promises.exists(journalPath)
+
+    if (journalExists) {
+      appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
+    }
+
+    // return new Promise<void>((resolve) => {
+    //   const interval = setInterval(() => {
+    //     journalExistsSync = fs.existsSync(journalPath)
+    //     logger(
+    //       '[internal/actors] [configureFs] journalExistsSync:',
+    //       journalExistsSync,
+    //     )
+    //     if (journalExistsSync) {
+    //       service.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
+    //       clearInterval(interval)
+    //       resolve()
+    //     }
+    //   }, 200)
+    // })
+
+    logger('[internal/actors] [configureFs] fs configured!')
+  }
+
+  // Some of our dependencies use fs sync functions, which don't work with
+  // OPFS. ZenFS creates an async cache of all files so that the sync functions
+  // work, but we have to wait for it to be built. Otherwise things like
+  // drizzleMigrate will fail since they can't see the migration files yet.
+  _configureFs().then(() => {
+    sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS })
+    return
+  })
+
+  return () => {}
+})

package/dist/src/connectToDb.ts

@@ -0,0 +1,74 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput } from '@/types'
+import { getSqliteWasmClient } from '@/browser/db/sqlWasmClient'
+import { DB_CREATING_SUCCESS } from '@/browser/services/internal/constants'
+import debug from 'debug'
+
+const logger = debug('app:services:db:actors:connectToDb')
+
+export const connectToDb = fromCallback<
+  EventObject,
+  FromCallbackInput<DbServiceContext>
+>(({ sendBack, input: { context } }) => {
+  logger('[db/actors] connectToDb context', context)
+
+  const { dbName, pathToDir } = context
+
+  let isConnecting = false
+  let dbId: string | undefined
+
+  const _create = async (): Promise<void> => {
+    if (isConnecting) {
+      return
+    }
+    isConnecting = true
+    let response
+
+    const sqliteWasmClient = await getSqliteWasmClient()
+
+    //@ts-ignore
+    response = await sqliteWasmClient('config-get', {})
+    logger(response)
+    logger('Running SQLite3 version', response.result.version.libVersion)
+
+    //@ts-ignore
+    response = await sqliteWasmClient('open', {
+      filename: `file:${pathToDir}/db/${dbName}.sqlite3?vfs=opfs`,
+    })
+
+    logger(response)
+    dbId = response.dbId
+    // logger(`dbId: ${dbId}`)
+    logger(
+      'OPFS is available, created persisted database at',
+      response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'),
+    )
+  }
+
+  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 (dbId) {
+      // logger(
+      //   '[db/actors] opening sqliteWasm connection with dbId:',
+      //   dbId,
+      // )
+      clearInterval(interval)
+      sendBack({ type: DB_CREATING_SUCCESS, dbId })
+      return
+    }
+    _create()
+      .then(() => {
+        return
+      })
+      .catch((e) => {
+        isConnecting = false
+      })
+  }, 500)
+
+  return () => {
+    if (interval) {
+      clearInterval(interval)
+    }
+  }
+})

package/dist/src/connectionManager.ts

@@ -0,0 +1,67 @@
+type SqliteDatabase = {
+  open: (filename: string) => Promise<void>
+  exec: (sql: string, params?: any[]) => any
+  close: () => void
+}
+
+class SqliteConnectionManager {
+  private sqliteModule: SqliteDatabase
+  private idleTimeout: number
+  private databases: { [key: string]: SqliteDatabase }
+  private idleTimers: { [key: string]: NodeJS.Timeout }
+
+  constructor(sqliteModule: SqliteDatabase, idleTimeout: number = 300000) {
+    // Default idle timeout: 5 minutes
+    this.sqliteModule = sqliteModule
+    this.idleTimeout = idleTimeout
+    this.databases = {}
+    this.idleTimers = {}
+  }
+
+  private resetIdleTimer(dbName: string): void {
+    if (this.idleTimers[dbName]) {
+      clearTimeout(this.idleTimers[dbName])
+    }
+
+    this.idleTimers[dbName] = setTimeout(() => {
+      this.closeConnection(dbName)
+    }, this.idleTimeout)
+  }
+
+  private async getConnection(dbName: string): Promise<SqliteDatabase> {
+    if (this.databases[dbName]) {
+      this.resetIdleTimer(dbName)
+      return this.databases[dbName]
+    }
+
+    const db = new this.sqliteModule()
+    await db.open(dbName)
+    this.databases[dbName] = db
+    this.resetIdleTimer(dbName)
+    return db
+  }
+
+  public async execute(
+    dbName: string,
+    sql: string,
+    params: any[] = [],
+  ): Promise<any> {
+    const db = await this.getConnection(dbName)
+    const result = db.exec(sql, params)
+    this.resetIdleTimer(dbName)
+    return result
+  }
+
+  public closeConnection(dbName: string): void {
+    if (this.databases[dbName]) {
+      this.databases[dbName].close()
+      delete this.databases[dbName]
+      if (this.idleTimers[dbName]) {
+        clearTimeout(this.idleTimers[dbName])
+        delete this.idleTimers[dbName]
+      }
+    }
+  }
+}
+
+export { SqliteConnectionManager }

package/dist/src/constants.ts

@@ -0,0 +1,118 @@
+const MACHINE_ID_SCOPE = '@seedSdk'
+
+export enum MachineIds {
+  GLOBAL = `${MACHINE_ID_SCOPE}/global`,
+  INTERNAL = `${MACHINE_ID_SCOPE}/internal`,
+  DB = `${MACHINE_ID_SCOPE}/db`,
+  EAS = `${MACHINE_ID_SCOPE}/eas`,
+  ITEM = `${MACHINE_ID_SCOPE}/item`,
+  ALL_ITEMS = `${MACHINE_ID_SCOPE}/allItems`,
+  MODEL = `${MACHINE_ID_SCOPE}/model`,
+  FILE_SYSTEM = `${MACHINE_ID_SCOPE}/fileSystem`,
+}
+
+const { INTERNAL, DB, GLOBAL, EAS, MODEL } = MachineIds
+
+export enum GlobalState {
+  UNINITIALIZED = 'uninitialized',
+  INITIALIZING = 'initializing',
+  INITIALIZED = 'initialized',
+  PUBLISHING_ITEM = 'publishingItem',
+  ADDING_MODELS_TO_DB = 'addingModelsToDb',
+}
+
+const {
+  UNINITIALIZED,
+  INITIALIZING,
+  INITIALIZED,
+  PUBLISHING_ITEM,
+  ADDING_MODELS_TO_DB,
+} = GlobalState
+
+export enum InternalState {
+  IDLE = 'idle',
+  INITIALIZING = 'initializing',
+  VALIDATING_INPUT = 'validatingInput',
+  CONFIGURING_FS = 'configuringFs',
+  LOADING_SEED_DB = 'loadingSeedDb',
+  SAVING_CONFIG = 'savingConfig',
+  LOADING_APP_DB = 'loadingAppDb',
+  LOADING_SDK_DB = 'loadingSdkDb',
+}
+
+const { VALIDATING_INPUT, CONFIGURING_FS, LOADING_SEED_DB, LOADING_APP_DB } =
+  InternalState
+
+export enum DbState {
+  CHECKING_STATUS = 'checkingStatus',
+  WAITING_FOR_FILES = 'waitingForFiles',
+  VALIDATING = 'validating',
+  CONNECTING_TO_DB = 'connectingToDb',
+  // FETCHING_MIGRATIONS = 'fetchingMigrations',
+  MIGRATING = 'migrating',
+}
+
+const {
+  CHECKING_STATUS,
+  VALIDATING,
+  CONNECTING_TO_DB,
+  WAITING_FOR_FILES,
+  MIGRATING,
+} = DbState
+
+export enum PublishMachineStates {
+  VALIDATING_ITEM_DATA = 'validatingItemData',
+  CREATING_PUBLISH_ATTEMPT = 'creatingPublishAttempt',
+  UPLOADING = 'uploading',
+  PREPARING_PUBLISH_REQUEST_DATA = 'preparingPublishRequestData',
+  PUBLISHING = 'publishing',
+  IDLE = 'idle',
+}
+
+export const INTERNAL_VALIDATING_INPUT_SUCCESS = `${INTERNAL}.${VALIDATING_INPUT}.success`
+
+export const INTERNAL_CONFIGURING_FS_SUCCESS = `${INTERNAL}.${CONFIGURING_FS}.success`
+export const INTERNAL_CONFIGURING_FS_FAILURE = `${INTERNAL}.${CONFIGURING_FS}.failure`
+
+export const INTERNAL_LOADING_SEED_DB_SUCCESS = `${INTERNAL}.${LOADING_SEED_DB}.success`
+export const INTERNAL_LOADING_SEED_DB_FAILURE = `${INTERNAL}.${LOADING_SEED_DB}.failure`
+
+export const INTERNAL_LOADING_APP_DB_SUCCESS = `${INTERNAL}.${LOADING_APP_DB}.success`
+export const INTERNAL_LOADING_APP_DB_FAILURE = `${INTERNAL}.${LOADING_APP_DB}.failure`
+
+export const INTERNAL_SAVING_CONFIG_SUCCESS = `${INTERNAL}.savingConfig.success`
+export const INTERNAL_SAVING_CONFIG_FAILURE = `${INTERNAL}.savingConfig.failure`
+
+export const GLOBAL_GETTING_SEED_CLASS_SUCCESS = `${GLOBAL}.${PUBLISHING_ITEM}.success`
+export const GLOBAL_INITIALIZING_SEND_CONFIG = `${GLOBAL}.${INITIALIZING}.sendConfig`
+export const GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY = `${GLOBAL}.${INITIALIZING}.internalServiceReady`
+export const GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES = `${GLOBAL}.${INITIALIZING}.createAllItemsServices`
+export const GLOBAL_ADDING_MODELS_TO_DB_SUCCESS = `${GLOBAL}.${ADDING_MODELS_TO_DB}.success`
+
+export const DB_CHECK_STATUS_UPDATE_PATHS = `${DB}.${CHECKING_STATUS}.updatePaths`
+export const DB_CHECK_STATUS_EXISTS = `${DB}.${CHECKING_STATUS}.exists`
+export const DB_CHECK_STATUS_DOES_NOT_EXIST = `${DB}.${CHECKING_STATUS}.doesNotExist`
+export const DB_CHECK_STATUS_FAILURE = `${DB}.${CHECKING_STATUS}.failure`
+
+export const DB_VALIDATING_SUCCESS = `${DB}.${VALIDATING}.success`
+export const DB_VALIDATING_WAIT = `${DB}.${VALIDATING}.wait`
+export const DB_MIGRATING_WAIT = `${DB}.${MIGRATING}.wait`
+export const DB_MIGRATING_SUCCESS = `${DB}.${MIGRATING}.success`
+export const DB_CREATING_SUCCESS = `${DB}.${CONNECTING_TO_DB}.success`
+export const DB_WAITING_FOR_FILES_RECEIVED = `${DB}.${WAITING_FOR_FILES}.filesReceived`
+export const DB_ON_SNAPSHOT = `${DB}.onSnapshot`
+export const CHILD_SNAPSHOT = 'childSnapshot'
+
+export const INTERNAL_SERVICE_SNAPSHOT = 'internalServiceSnapshot'
+
+export const DB_NAME_APP = 'app_db'
+export const BROWSER_FS_TOP_DIR = 'app-files'
+
+export const EAS_ENDPOINT =
+  process.env.NEXT_PUBLIC_EAS_ENDPOINT ||
+  process.env.EAS_ENDPOINT ||
+  'https://optimism-sepolia.easscan.org/graphql'
+
+export const ARWEAVE_HOST =
+  process.env.NEXT_PUBLIC_ARWEAVE_HOST || 'permagate.io'
+export const ARWEAVE_ENDPOINT = `https://${ARWEAVE_HOST}/graphql`

package/dist/src/create.ts

@@ -0,0 +1,39 @@
+import { Item } from 'src/browser/item'
+import { eventEmitter } from '@/eventBus'
+import { createItemCacheKey, getItemCache, updateItemCache } from './requestAll'
+
+export const createItemRequestHandler = async (event) => {
+  const { ModelClass, itemData } = event
+
+  const itemCache = getItemCache()
+
+  const itemCacheKey = createItemCacheKey(itemData)
+
+  if (!itemCacheKey) {
+    console.warn('itemCacheKey not found for itemData', itemData)
+    return
+  }
+
+  if (itemCache.has(itemCacheKey)) {
+    return
+  }
+
+  const newItem = Item.create({
+    modelName: ModelClass.originalConstructor.name,
+    ...itemData,
+  })
+
+  updateItemCache(itemCacheKey, newItem)
+
+  return new Promise<void>((resolve) => {
+    const subscription = newItem.subscribe((context) => {
+      if (context && context.versionLocalId && context.seedLocalId) {
+        subscription.unsubscribe()
+        // allItemsService.send({ type: 'addItemToContext', item: newItem })
+        eventEmitter.emit('item.create.response', { item: newItem })
+        // eventEmitter.emit('item.requestAll', { modelName })
+        resolve()
+      }
+    })
+  })
+}

package/dist/src/createItem.ts

@@ -0,0 +1,15 @@
+import { EventObject, fromCallback } from 'xstate'
+import { createItemMachine } from '../createItemMachine'
+
+export const createItem = fromCallback<EventObject, typeof createItemMachine>(
+  ({ sendBack, input: { context, event } }) => {
+    const { item } = context
+
+    if (!item) {
+      console.warn('No item found')
+      return
+    }
+
+    sendBack({ type: 'itemCreated', item })
+  },
+)

package/dist/src/createItemMachine.ts

@@ -0,0 +1,37 @@
+import { setup } from 'xstate'
+
+const createItemMachine = setup({
+  types: {
+    context: {},
+    input: {},
+  },
+}).createMachine({
+  id: 'createItem',
+  initial: 'creating',
+  context: ({ input }) => input as any,
+  states: {
+    idle: {
+      on: {
+        create: 'creating',
+      },
+    },
+    creating: {
+      invoke: {
+        src: 'createItem',
+        onDone: {
+          target: 'created',
+          actions: 'onSuccess',
+        },
+        onError: {
+          target: 'idle',
+          actions: 'onError',
+        },
+      },
+    },
+    created: {
+      type: 'final',
+    },
+  },
+})
+
+export { createItemMachine }

package/dist/src/createPublishAttempt.ts

@@ -0,0 +1,16 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PublishMachineContext } from '@/types'
+
+export const createPublishAttempt = fromCallback<
+  EventObject,
+  FromCallbackInput<PublishMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const _createPublishAttempt = async () => {
+    // Do some stuff
+    return true
+  }
+
+  _createPublishAttempt().then(() => {
+    sendBack({ type: 'createPublishAttemptSuccess' })
+  })
+})

package/dist/src/createSeeds.ts

@@ -0,0 +1,24 @@
+import { seeds, SeedType } from '@/shared/seedSchema'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+type CreateSeeds = (newSeeds: Partial<SeedType>[]) => Promise<string[]>
+
+export const createSeeds: CreateSeeds = async (
+  newSeeds: Partial<SeedType>[],
+) => {
+  const appDb = getAppDb()
+
+  const results = await appDb
+    .insert(seeds)
+    .values(newSeeds)
+    .returning({ uid: seeds.uid })
+
+  const newUids = results.reduce((acc, result) => {
+    if (result.uid) {
+      acc.push(result.uid)
+    }
+    return acc
+  }, [] as string[])
+
+  return newUids
+}

package/dist/src/createVersion.ts

@@ -0,0 +1,33 @@
+import { getAppDb } from '../sqlWasmClient'
+import { generateId } from '@/shared/helpers'
+import { versions } from '@/shared/seedSchema'
+
+type CreateVersionProps = {
+  seedLocalId?: string
+  seedUid?: string
+  seedType?: string
+  uid?: string
+}
+type CreateVersion = (props: CreateVersionProps) => Promise<string>
+
+export const createVersion: CreateVersion = async ({
+  seedLocalId,
+  seedUid,
+  seedType,
+  uid,
+}) => {
+  const appDb = getAppDb()
+
+  const newVersionLocalId = generateId()
+
+  await appDb.insert(versions).values({
+    localId: newVersionLocalId,
+    createdAt: Date.now(),
+    seedLocalId,
+    seedUid: seedUid ?? 'NULL',
+    seedType,
+    uid: uid || 'NULL',
+  })
+
+  return newVersionLocalId
+}