@seedprotocol/sdk 0.1.47 → 0.1.49

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

package/dist/src/dbMachine.ts

@@ -0,0 +1,181 @@
+import { assign, emit, setup } from 'xstate'
+import {
+  DB_CHECK_STATUS_EXISTS,
+  DB_CHECK_STATUS_UPDATE_PATHS,
+  DB_CREATING_SUCCESS,
+  DB_MIGRATING_SUCCESS,
+  DB_MIGRATING_WAIT,
+  DB_VALIDATING_SUCCESS,
+  DB_VALIDATING_WAIT,
+  DB_WAITING_FOR_FILES_RECEIVED,
+  DbState,
+  MachineIds,
+} from '../internal/constants'
+import debug from 'debug'
+import { DbServiceContext } from '@/types'
+import { checkStatus } from '@/browser/services/db/actors/checkStatus'
+import { connectToDb } from '@/browser/services/db/actors/connectToDb'
+import { validate } from '@/browser/services/db/actors/validate'
+import { migrate } from '@/browser/services/db/actors/migrate'
+
+const logger = debug('app:services:db:machine')
+
+const {
+  CHECKING_STATUS,
+  VALIDATING,
+  WAITING_FOR_FILES,
+  CONNECTING_TO_DB,
+  MIGRATING,
+} = DbState
+
+const dbMachine = setup({
+  types: {
+    context: {} as Partial<DbServiceContext>,
+    input: {} as Partial<DbServiceContext> | undefined,
+  },
+  actors: {
+    checkStatus,
+    validate,
+    connectToDb,
+    migrate,
+  },
+}).createMachine({
+  id: MachineIds.DB,
+  initial: CHECKING_STATUS,
+  context: ({ input }) => input as DbServiceContext,
+  on: {
+    [DB_WAITING_FOR_FILES_RECEIVED]: {
+      actions: assign({
+        hasFiles: ({ event }) => {
+          logger('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event)
+          return true
+        },
+      }),
+    },
+    updateHasFiles: {
+      target: `.${CHECKING_STATUS}`,
+      actions: assign({
+        hasFiles: ({ context, event }) => {
+          logger('[db/machine] updateHasFiles event:', event)
+          logger('[db/machine] updateHasFiles context:', context)
+          return event.hasFiles
+        },
+      }),
+    },
+  },
+  // always: {
+  //   target: `.${CHECKING_STATUS}`,
+  //   guard: ({ context, event }) => context.hasFiles && event.type === 'updateHasFiles',
+  // },
+  states: {
+    idle: {
+      on: {
+        start: CHECKING_STATUS,
+      },
+      meta: {
+        displayText: 'DB starting ...',
+        percentComplete: 0,
+      },
+    },
+    [CHECKING_STATUS]: {
+      on: {
+        [DB_CHECK_STATUS_UPDATE_PATHS]: {
+          actions: assign({
+            pathToDb: ({ event }) => event.pathToDb,
+            pathToDir: ({ event }) => event.pathToDir,
+            pathToDbDir: ({ event }) => event.pathToDbDir,
+          }),
+        },
+        [DB_CHECK_STATUS_EXISTS]: CONNECTING_TO_DB,
+      },
+      invoke: {
+        src: 'checkStatus',
+        input: ({ context, event }) => ({ context, event }),
+      },
+      meta: {
+        displayText: 'Checking DB status',
+        percentComplete: 60,
+      },
+    },
+    [CONNECTING_TO_DB]: {
+      on: {
+        [DB_CREATING_SUCCESS]: {
+          target: VALIDATING,
+          actions: assign({
+            dbId: ({ event }) => event.dbId,
+          }),
+        },
+      },
+      invoke: {
+        src: 'connectToDb',
+        input: ({ context }) => ({ context }),
+      },
+      meta: {
+        displayText: 'Connecting to local DB',
+        percentComplete: 70,
+      },
+    },
+    [VALIDATING]: {
+      on: {
+        [DB_VALIDATING_SUCCESS]: {
+          target: MIGRATING,
+          // guard: ({ context }) => context.hasFiles,
+        },
+        [DB_VALIDATING_WAIT]: {
+          target: WAITING_FOR_FILES,
+          // guard: ({ context }) => !context.hasFiles,
+        },
+      },
+      invoke: {
+        src: 'validate',
+        input: ({ context }) => ({ context }),
+      },
+      meta: {
+        displayText: 'Validating DB',
+        percentComplete: 80,
+      },
+    },
+    // Here we're waiting for migration and schema files to be downloaded
+    [WAITING_FOR_FILES]: {
+      on: {
+        [DB_WAITING_FOR_FILES_RECEIVED]: {
+          target: MIGRATING,
+          actions: assign({
+            hasFiles: true,
+          }),
+        },
+        [DB_MIGRATING_SUCCESS]: 'ready',
+      },
+      entry: ({ context }) => {
+        if (context.hasFiles) {
+          emit({ type: DB_WAITING_FOR_FILES_RECEIVED })
+        }
+      },
+    },
+    [MIGRATING]: {
+      on: {
+        [DB_MIGRATING_WAIT]: WAITING_FOR_FILES,
+        [DB_MIGRATING_SUCCESS]: {
+          target: 'ready',
+        },
+      },
+      invoke: {
+        src: 'migrate',
+        input: ({ context }) => ({ context }),
+      },
+      meta: {
+        displayText: 'Migrating DB',
+        percentComplete: 90,
+      },
+    },
+    ready: {
+      target: 'idle',
+      meta: {
+        displayText: 'Wrapping up the db ...',
+        percentComplete: 100,
+      },
+    },
+  },
+})
+
+export { dbMachine }

package/dist/src/deleteItem.ts

@@ -0,0 +1,19 @@
+import { getAppDb } from '../sqlWasmClient'
+import { seeds } from '@/shared/seedSchema'
+import { eq, or } from 'drizzle-orm'
+
+type DeleteItemProps = {
+  seedLocalId?: string
+  seedUid?: string
+}
+type DeleteItem = (props: DeleteItemProps) => Promise<void>
+export const deleteItem: DeleteItem = async ({ seedLocalId, seedUid }) => {
+  const appDb = getAppDb()
+
+  await appDb
+    .update(seeds)
+    .set({
+      _markedForDeletion: 1,
+    })
+    .where(or(eq(seeds.localId, seedLocalId), eq(seeds.uid, seedUid)))
+}