@seedprotocol/sdk 0.1.46 → 0.1.48

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
+}

package/dist/src/db.ts

@@ -0,0 +1,247 @@
+import {
+  appState,
+  models as modelsTable,
+  NewModelRecord,
+  NewPropertyRecord,
+  properties,
+} from 'src/shared/seedSchema'
+import { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy'
+import { DbQueryResult, ModelDefinitions, ResultObject } from '@/types'
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3'
+import { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core'
+import { and, eq, isNull, SQL } from 'drizzle-orm'
+
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+export const escapeSqliteString = (value: string): string => {
+  if (typeof value !== 'string') {
+    throw new Error(
+      `Value must be a string, instead got: ${JSON.stringify(value)}`,
+    )
+  }
+  return value.replace(/'/g, "''")
+}
+export const getObjectForRow = (row: any): ResultObject => {
+  const obj: ResultObject = {}
+
+  row.columnNames.forEach((colName, index) => {
+    const value = row.row[index]
+    if (typeof value !== 'string') {
+      obj[colName] = row.row[index]
+      return
+    }
+
+    // Try to parse the value as JSON
+    try {
+      obj[colName] = JSON.parse(value)
+    } catch (e) {
+      // If it fails, just set the value as a string
+      obj[colName] = value
+    }
+  })
+
+  return obj
+}
+export const getSqlResultObject = (
+  queryResult: DbQueryResult,
+): ResultObject | ResultObject[] | undefined => {
+  if (!queryResult || !queryResult.rows || queryResult.rows.length === 0) {
+    return
+  }
+
+  let obj: ResultObject | ResultObject[] | undefined
+
+  if (queryResult.rows.length === 1) {
+    obj = getObjectForRow(queryResult.rows[0])
+  }
+
+  if (queryResult.rows.length > 1) {
+    obj = queryResult.rows.reduce((acc, row) => {
+      const rowObj = getObjectForRow(row)
+
+      acc.push(rowObj)
+      return acc
+    }, [] as ResultObject[])
+  }
+
+  return obj
+}
+export const createOrUpdate = async <T>(
+  db: BetterSQLite3Database | SqliteRemoteDatabase,
+  table: SQLiteTableWithColumns<any>,
+  values: Partial<Record<keyof T, T[keyof T]>>,
+) => {
+  const startTime = Date.now()
+
+  const valueFilters: SQL[] = []
+
+  const propertiesToExcludeFromDb = ['ref']
+
+  const safeValues = Object.keys(values).reduce(
+    (acc, key) => {
+      if (!propertiesToExcludeFromDb.includes(key)) {
+        acc[key] = values[key as string & keyof T]
+      }
+      return acc
+    },
+    {} as Record<string, unknown>,
+  )
+
+  for (const [key, value] of Object.entries(safeValues)) {
+    let finalValue = value
+    if (key === 'TObject') {
+      continue
+    }
+    if (typeof value === 'object') {
+      finalValue = JSON.stringify(value)
+    }
+    const column = table[key]
+    if (!column) {
+      throw new Error(`Column not found for ${key}`)
+    }
+    if (typeof finalValue === 'undefined') {
+      finalValue = null
+    }
+    if (finalValue === null) {
+      valueFilters.push(isNull(table[key]))
+      continue
+    }
+    valueFilters.push(eq(table[key], finalValue))
+  }
+
+  const doneWithFilters = Date.now()
+
+  // console.log('valueFilters:', valueFilters)
+
+  // for ( const filter of valueFilters ) {
+  //   console.log('filter:', Object.keys(filter))
+  // }
+
+  // Build a query to find the record based on properties
+  const existingRecords = await db
+    .select()
+    .from(table)
+    .where(and(...valueFilters))
+
+  const doneWithExistingRecords = Date.now()
+
+  if (existingRecords.length > 1) {
+    throw new Error('Multiple records found')
+  }
+
+  if (existingRecords.length > 0) {
+    // If record exists, update it
+    await db
+      .update(table)
+      .set(safeValues)
+      .where(and(...valueFilters))
+    console.log('updatedRecord:', {
+      ...existingRecords[0],
+      ...safeValues,
+    })
+
+    const doneWithUpdate = Date.now()
+
+    console.log(
+      '[helpers/db] [createOrUpdate] filters duration:',
+      doneWithFilters - startTime,
+    )
+    console.log(
+      '[helpers/db] [createOrUpdate] existingRecords duration:',
+      doneWithExistingRecords - doneWithFilters,
+    )
+    console.log(
+      '[helpers/db] [createOrUpdate] update duration:',
+      doneWithUpdate - doneWithExistingRecords,
+    )
+
+    return existingRecords[0] as T
+  } else {
+    // If no record exists, create a new one
+    const newRecord = await db.insert(table).values(safeValues).returning()
+    console.log('newRecord:', newRecord)
+    return newRecord[0] as T
+  }
+}
+export const addModelsToInternalDb = async (
+  db: BetterSQLite3Database<any> | SqliteRemoteDatabase<any>,
+  models: ModelDefinitions,
+) => {
+  for (const [modelName, modelClass] of Object.entries(models)) {
+    console.log(
+      '[helpers/db] [addModelsToInternalDb] starting modelName:',
+      modelName,
+    )
+    const modelRecord = await createOrUpdate<NewModelRecord>(db, modelsTable, {
+      name: modelName,
+    })
+
+    for (let [propertyName, propertyValues] of Object.entries(
+      modelClass.schema,
+    )) {
+      if (!propertyValues) {
+        throw new Error(`Property values not found for ${propertyName}`)
+      }
+      propertyValues.name = propertyName
+      propertyValues.modelId = modelRecord.id!
+      for (let [key, value] of Object.entries(propertyValues)) {
+        if (key === 'ref') {
+          const refModel = await createOrUpdate<NewModelRecord>(
+            db,
+            modelsTable,
+            {
+              name: value,
+            },
+          )
+          // delete propertyValues.ref
+          propertyValues.refModelId = refModel.id
+        }
+      }
+
+      const propertyRecord = await createOrUpdate<NewPropertyRecord>(
+        db,
+        properties,
+        propertyValues,
+      )
+
+      console.log('propertyRecord:', propertyRecord)
+    }
+
+    console.log(
+      '[helpers/db] [addModelsToInternalDb] done modelName:',
+      modelName,
+    )
+  }
+}
+export const getAddressesFromDb = async (): Promise<string[]> => {
+  const appDb = getAppDb()
+
+  if (!appDb) {
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        const addresses = await getAddressesFromDb()
+        resolve(addresses)
+      }, 500)
+    })
+  }
+
+  const appStatesRecords = await appDb!
+    .select()
+    .from(appState)
+    .where(eq(appState.key, 'addresses'))
+    .limit(1)
+
+  if (!appStatesRecords || appStatesRecords.length === 0) {
+    throw new Error('No appStatesRecords for addresses found')
+  }
+
+  const addressRecord = appStatesRecords[0]
+
+  const addressArrayString = addressRecord.value
+
+  if (!addressArrayString) {
+    throw new Error('No addresses found')
+  }
+
+  return JSON.parse(addressArrayString)
+}