@seedprotocol/sdk 0.1.128 → 0.2.0

package/dist/src/connectToDb.ts

@@ -1,8 +1,9 @@
 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 { getSqliteWasmClient } from '@/db/sqlWasmClient'
+import { DB_CREATING_SUCCESS } from '@/services/internal/constants'
 import debug from 'debug'
+import { BaseDb } from '@/db/BaseDb'
 
 const logger = debug('app:services:db:actors:connectToDb')
 
@@ -14,61 +15,27 @@ export const connectToDb = fromCallback<
 
   const { dbName, pathToDir } = context
 
+  if (!pathToDir || !dbName) {
+    throw new Error('pathToDir and dbName are required')
+  }
+
   let isConnecting = false
   let dbId: string | undefined
 
-  const _create = async (): Promise<void> => {
+  const _connectToDb = 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
+    const dbId = await BaseDb.connectToDb(pathToDir, dbName)
     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)
+      sendBack({ type: DB_CREATING_SUCCESS, dbId, })
     }
+    isConnecting = false
   }
+
+  _connectToDb().then(() => {
+    return
+  })
+
 })

package/dist/src/createMetadata.ts

@@ -1,7 +1,7 @@
-import { metadata, MetadataType } from '@/shared/seedSchema'
-import { getAppDb } from '../sqlWasmClient'
-import { generateId } from '@/shared/helpers'
+import { metadata, MetadataType } from '@/seedSchema'
+import { generateId } from '@/helpers'
 import { PropertyType } from '@/types'
+import { BaseDb } from '../BaseDb'
 
 type CreateMetadata = (
   metadataValues: Partial<MetadataType>,
@@ -12,7 +12,7 @@ export const createMetadata: CreateMetadata = async (
   metadataValues,
   propertyRecordSchema?,
 ) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   metadataValues.localId = generateId()
 

package/dist/src/createNewItem.ts

@@ -0,0 +1,57 @@
+import { ModelValues } from '@/types'
+import { getModel } from '@/stores/modelClass'
+import { createSeed } from './createSeed'
+import { createVersion } from './createVersion'
+import { createMetadata } from './createMetadata'
+
+type CreateNewItemProps = Partial<ModelValues<any>> & {
+  modelName: string
+}
+
+type CreateNewItemReturnType = {
+  modelName: string
+  seedLocalId: string
+  versionLocalId: string
+}
+
+export const createNewItem = async ({
+  modelName,
+  ...propertyData
+}: CreateNewItemProps): Promise<CreateNewItemReturnType> => {
+  if (!modelName) {
+    throw new Error('A model name is required for createNewItem')
+  }
+
+  const seedType = modelName.toLowerCase()
+
+  const newSeedId = await createSeed({ type: seedType })
+
+  const newVersionId = await createVersion({ seedLocalId: newSeedId })
+
+  const propertySchemas = getModel(modelName)?.schema
+
+  for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
+    let propertyRecordSchema
+
+    if (propertySchemas && propertySchemas[propertyName]) {
+      propertyRecordSchema = propertySchemas[propertyName]
+    }
+
+    await createMetadata(
+      {
+        seedLocalId: newSeedId,
+        versionLocalId: newVersionId,
+        propertyName,
+        propertyValue,
+        modelName,
+      },
+      propertyRecordSchema,
+    )
+  }
+
+  return {
+    modelName,
+    seedLocalId: newSeedId,
+    versionLocalId: newVersionId,
+  }
+} 

package/dist/src/createSeed.ts

@@ -0,0 +1,31 @@
+import { generateId } from '@/helpers'
+import { seeds } from '@/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
+import { getSchemaUidForModel } from '@/db/read/getSchemaUidForModel'
+
+type CreateSeedProps = {
+  type: string
+  seedUid?: string
+}
+
+export const createSeed = async ({ type, seedUid }: CreateSeedProps): Promise<string> => {
+  const schemaUid = await getSchemaUidForModel(type)
+
+  if (!schemaUid) {
+    throw new Error(`No schema found for model type: ${type}`)
+  }
+
+  const appDb = BaseDb.getAppDb()
+
+  const newSeedLocalId = generateId()
+
+  await appDb.insert(seeds).values({
+    localId: newSeedLocalId,
+    type,
+    uid: seedUid,
+    createdAt: Date.now(),
+    schemaUid,
+  })
+
+  return newSeedLocalId
+} 

package/dist/src/createSeeds.ts

@@ -1,12 +1,12 @@
-import { seeds, SeedType } from '@/shared/seedSchema'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { seeds, SeedType } from '@/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
 
 type CreateSeeds = (newSeeds: Partial<SeedType>[]) => Promise<string[]>
 
 export const createSeeds: CreateSeeds = async (
   newSeeds: Partial<SeedType>[],
 ) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const results = await appDb
     .insert(seeds)

package/dist/src/createVersion.ts

@@ -1,6 +1,6 @@
-import { getAppDb } from '../sqlWasmClient'
-import { generateId } from '@/shared/helpers'
-import { versions } from '@/shared/seedSchema'
+import { generateId } from '@/helpers'
+import { versions } from '@/seedSchema'
+import { BaseDb } from '../BaseDb'
 
 type CreateVersionProps = {
   seedLocalId?: string
@@ -16,7 +16,7 @@ export const createVersion: CreateVersion = async ({
   seedType,
   uid,
 }) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const newVersionLocalId = generateId()
 

package/dist/src/dbMachine.ts

@@ -13,10 +13,10 @@ import {
 } 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'
+import { checkStatus } from '@/services/db/actors/checkStatus'
+import { connectToDb } from '@/services/db/actors/connectToDb'
+import { validate } from '@/services/db/actors/validate'
+import { migrate } from '@/services/db/actors/migrate'
 
 const logger = debug('app:services:db:machine')
 

package/dist/src/deleteItem.ts

@@ -1,5 +1,5 @@
-import { getAppDb } from '../sqlWasmClient'
-import { seeds } from '@/shared/seedSchema'
+import { BaseDb } from '@/db/BaseDb'
+import { seeds } from '@/seedSchema'
 import { eq, or } from 'drizzle-orm'
 
 type DeleteItemProps = {
@@ -8,7 +8,7 @@ type DeleteItemProps = {
 }
 type DeleteItem = (props: DeleteItemProps) => Promise<void>
 export const deleteItem: DeleteItem = async ({ seedLocalId, seedUid }) => {
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   await appDb
     .update(seeds)

package/dist/src/download.ts

@@ -1,26 +1,30 @@
-import { syncDbFiles } from '@/browser/services/internal/helpers'
+import { syncDbFiles } from '@/services/internal/helpers'
 import { eventEmitter } from '@/eventBus'
 import { fs } from '@zenfs/core'
-import { ARWEAVE_HOST } from '@/browser/services/internal/constants'
-import { appState } from 'src/shared/seedSchema'
+import { ARWEAVE_HOST } from '@/services/internal/constants'
+import { appState } from '@/seedSchema'
 import { eq } from 'drizzle-orm'
 import { getArweave } from '@/browser/schema/file'
-import { getAddressesFromDb } from '@/shared/helpers/db'
+import { getAddressesFromDb } from '@/helpers/db'
 import {
   getDataTypeFromString,
   getMimeType,
   identifyString,
-} from '@/shared/helpers'
-import { arweaveClient, easClient, queryClient } from '@/browser/helpers'
+} from '@/helpers'
 import { GET_FILES_METADATA } from '@/browser/schema/file/queries'
 import debug from 'debug'
-import { getAppDb, isAppDbReady } from '@/browser/db/sqlWasmClient'
-import { getGlobalService } from '@/browser/services'
+import { getGlobalService } from '@/services'
 import { waitFor } from 'xstate'
-import { getMetadata } from '@/browser/db/read/getMetadata'
-import { saveMetadata } from '@/browser/db/write/saveMetadata'
+import { getMetadata } from '@/db/read/getMetadata'
+import { saveMetadata } from '@/db/write/saveMetadata'
 import { GET_TRANSACTION_TAGS } from '@/browser/arweave/queries'
-import { saveAppState } from '@/browser/db/write/saveAppState'
+import { saveAppState } from '@/db/write/saveAppState'
+import { BaseDb } from '@/db/BaseDb'
+import { BaseEasClient, BaseQueryClient, BaseArweaveClient } from '@/helpers'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+const arweaveClient = BaseArweaveClient.getArweaveClient()
 
 const logger = debug('app:files:download')
 
@@ -37,11 +41,11 @@ export const downloadAllFilesRequestHandler = async ({
 export const downloadAllFilesBinaryRequestHandler = async () => {
   let addresses: string[] | undefined
 
-  if (isAppDbReady()) {
+  if (BaseDb.isAppDbReady()) {
     addresses = await getAddressesFromDb()
   }
 
-  if (!isAppDbReady()) {
+  if (!BaseDb.isAppDbReady()) {
     const globalService = getGlobalService()
     const internalService = globalService.getSnapshot().context.internalService
     if (internalService) {
@@ -90,7 +94,7 @@ export const downloadAllFilesBinaryRequestHandler = async () => {
     await fs.promises.mkdir('/files/images', { recursive: true })
   }
 
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   if (!appDb) {
     console.warn('[fetchAll/actors] [fetchAllBinaryData] seedDb not available')

package/dist/src/drizzle.ts

@@ -5,7 +5,7 @@ import { camelCase, snakeCase } from 'lodash-es'
 import * as nunjucks from 'nunjucks'
 import { ILoader } from 'nunjucks'
 import { ModelClassType } from '@/types'
-import { SCHEMA_NJK } from '@/shared/helpers/constants'
+import { SCHEMA_NJK } from '@/helpers/constants'
 import {
   appGeneratedSchemaDir,
   dotSeedDir,

package/dist/src/eas.ts

@@ -1,5 +1,5 @@
-import { toSnakeCase } from '@/shared/helpers'
-import { getSchemaForItemProperty } from '@/browser/helpers/getSchemaForItemProperty'
+import { toSnakeCase } from '@/helpers'
+import { getSchemaForItemProperty } from '@/helpers/getSchemaForItemProperty'
 
 const schemaUidForSchemaDefinition = new Map<string, string>()
 

package/dist/src/fetchDataFromEas.ts

@@ -1,10 +1,14 @@
 import { EventObject, fromCallback } from 'xstate'
-import { GET_PROPERTIES } from '@/browser/item/queries'
-import { itemMachineSingle } from '@/browser/item/single/itemMachineSingle'
-import { PropertyType } from '@/shared/seedSchema'
-import { easClient, queryClient } from '@/browser/helpers'
-import { Attestation } from '@/browser/gql/graphql'
+import { GET_PROPERTIES } from '@/Item/queries'
+import { itemMachineSingle } from '@/Item/service/itemMachineSingle'
+import { PropertyType } from '@/seedSchema'
+import { Attestation } from '@/graphql/gql/graphql'
 import { ModelClassType } from '@/types'
+import { BaseEasClient, BaseQueryClient } from '@/helpers'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+
 
 export const fetchDataFromEas = fromCallback<
   EventObject,

package/dist/src/fetchRelatedItems.ts

@@ -3,22 +3,26 @@ import {
   GET_ALL_PROPERTIES_FOR_ALL_VERSIONS,
   GET_SEED_IDS,
   GET_VERSIONS,
-} from '@/browser/item/queries'
+} from '@/Item/queries'
 import {
   models as modelsTable,
   modelUids,
   PropertyType,
-} from '@/shared/seedSchema'
-import { Attestation } from '@/browser/gql/graphql'
+} from '@/seedSchema'
+import { Attestation } from '@/graphql/gql/graphql'
 import {
   AllItemsMachineContext,
   FromCallbackInput,
   ModelClassType,
 } from '@/types'
-import { getAddressesFromDb } from '@/shared/helpers/db'
+import { getAddressesFromDb } from '@/helpers/db'
 import { eq } from 'drizzle-orm'
-import { easClient, queryClient } from '@/browser/helpers'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { BaseDb } from '@/db/BaseDb'
+import { BaseEasClient } from '@/helpers/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/BaseQueryClient'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
 
 export const fetchRelatedItems = fromCallback<
   EventObject,
@@ -26,7 +30,7 @@ export const fetchRelatedItems = fromCallback<
 >(({ sendBack, input: { context } }) => {
   const { ModelClass, modelName } = context
 
-  const appDb = getAppDb()
+  const appDb = BaseDb.getAppDb()
 
   const relatedProperties = new Map<string, PropertyType>()
   const relatedVersionsBySeedUid = new Map<string, Attestation[]>()

package/dist/src/fetchSeeds.ts

@@ -1,10 +1,14 @@
 import { EventObject, fromCallback } from 'xstate'
-import { GET_SEEDS } from '@/browser/item/queries'
+import { GET_SEEDS } from '@/Item/queries'
 import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
-import { Attestation } from '@/browser/gql/graphql'
-import { easClient, queryClient } from '@/browser/helpers'
+import { Attestation } from '@/graphql/gql/graphql'
+import { BaseEasClient } from '@/helpers/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/BaseQueryClient'
 import debug from 'debug'
 
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+
 const logger = debug('app:allItemsActors:fetchSeeds')
 
 export const fetchSeeds = fromCallback<EventObject, typeof itemMachineAll>(
@@ -39,6 +43,6 @@ export const fetchSeeds = fromCallback<EventObject, typeof itemMachineAll>(
       sendBack({ type: 'fetchSeedsSuccess', itemSeeds })
     })
 
-    return () => {}
+    return () => { }
   },
 )

package/dist/src/fetchVersions.ts

@@ -1,8 +1,13 @@
 import { EventObject, fromCallback } from 'xstate'
-import { GET_VERSIONS } from '@/browser/item/queries'
+import { GET_VERSIONS } from '@/Item/queries'
 import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
-import { Attestation } from '@/browser/gql/graphql'
-import { easClient, queryClient } from '@/browser/helpers'
+import { Attestation } from '@/graphql/gql/graphql'
+import { BaseEasClient } from '@/helpers/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/BaseQueryClient'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
+
 
 export const fetchVersions = fromCallback<EventObject, typeof itemMachineAll>(
   ({ sendBack, input: { context } }) => {
@@ -36,6 +41,6 @@ export const fetchVersions = fromCallback<EventObject, typeof itemMachineAll>(
       sendBack({ type: 'fetchVersionsSuccess', itemVersions })
     })
 
-    return () => {}
+    return () => { }
   },
 )

package/dist/src/getExistingItem.ts

@@ -0,0 +1,60 @@
+import { BaseDb } from '@/db/BaseDb'
+import { seeds } from '@/seedSchema'
+import { and, eq, isNotNull, not, or } from 'drizzle-orm'
+
+type GetExistingItemProps = {
+  seedLocalId: string
+  seedUid: string
+}
+
+type GetExistingItemReturn = {
+  seedLocalId: string
+  seedUid: string
+  createdAt: string
+}
+
+export const getExistingItem = async ({
+  seedLocalId,
+  seedUid,
+}: GetExistingItemProps): Promise<GetExistingItemReturn | undefined> => {
+  const appDb = BaseDb.getAppDb()
+
+  const rows = await appDb
+    .select({
+      seedLocalId: seeds.localId,
+      seedUid: seeds.uid,
+      createdAt: seeds.createdAt,
+    })
+    .from(seeds)
+    .where(
+      or(
+        and(
+          isNotNull(seeds.uid),
+          not(eq(seeds.uid, '')),
+          not(eq(seeds.uid, 'undefined')),
+          not(eq(seeds.uid, 'null')),
+          not(eq(seeds.uid, 'false')),
+          not(eq(seeds.uid, '0')),
+          eq(seeds.uid, seedUid)
+        ),
+        and(
+          isNotNull(seeds.localId),
+          not(eq(seeds.localId, '')),
+          not(eq(seeds.localId, 'undefined')),
+          not(eq(seeds.localId, 'null')),
+          not(eq(seeds.localId, 'false')),
+          not(eq(seeds.localId, '0')),
+          eq(seeds.localId, seedLocalId)
+        )
+      )
+    )
+
+  if (!rows || rows.length === 0) {
+    return undefined
+  }
+
+  const matchingRow = rows.find(row => row.seedUid === seedUid) ||
+    rows.find(row => row.seedLocalId === seedLocalId)
+
+  return matchingRow
+} 

package/dist/src/getItem.ts

@@ -1,125 +1,10 @@
 import { Item } from '@/browser/item'
+import { getItemData } from './getItemData'
+import { GetItem } from '@/types'
 
-import { getItemProperties } from '@/browser/db/read/getItemProperties'
-import { getSeedData } from '@/browser/db/read/getSeedData'
-import debug from 'debug'
-import { ItemData } from '@/types'
-import { getAppDb } from '../sqlWasmClient'
-import { seeds } from '@/shared/seedSchema'
-import { and, eq, getTableColumns, gt, sql, SQL } from 'drizzle-orm'
-import { getVersionData } from './subqueries/versionData'
-
-const logger = debug('app:db:queries:getItem')
-
-type GetItemDataFromDbParams = {
-  modelName?: string
-  seedLocalId?: string
-  seedUid?: string
-}
-
-type GetItemDataFromDb = (
-  params: GetItemDataFromDbParams,
-) => Promise<ItemData | undefined>
-
-export const getItemDataFromDb: GetItemDataFromDb = async ({
-  modelName,
-  seedLocalId,
-  seedUid,
-}) => {
-  if (!seedLocalId && !seedUid) {
-    throw new Error('[db/queries] [getItem] no seedLocalId or seedUid')
-  }
-
-  if (seedUid && !seedLocalId) {
-    const seedData = await getSeedData({ seedUid })
-    if (!seedData) {
-      logger('[db/queries] [getItem] no seedData seedUid', seedUid)
-      return
-    }
-    seedLocalId = seedData.localId
-  }
-
-  const appDb = getAppDb()
-
-  const { localId, uid, ...rest } = getTableColumns(seeds)
-
-  const whereClauses: SQL[] = []
-
-  if (modelName) {
-    whereClauses.push(eq(seeds.type, modelName.toLowerCase()))
-  }
-
-  if (seedUid) {
-    whereClauses.push(eq(seeds.uid, seedUid))
-  }
-
-  if (seedLocalId && !seedUid) {
-    whereClauses.push(eq(seeds.localId, seedLocalId))
-  }
-
-  const versionData = getVersionData()
-
-  const itemDataRows = await appDb
-    .with(versionData)
-    .select({
-      ...rest,
-      seedLocalId: seeds.localId,
-      seedUid: seeds.uid,
-      versionsCount: versionData.versionsCount,
-      lastVersionPublishedAt: versionData.lastVersionPublishedAt,
-      latestVersionUid: versionData.latestVersionUid,
-      latestVersionLocalId: versionData.latestVersionLocalId,
-    })
-    .from(seeds)
-    .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
-    .where(and(...whereClauses, gt(versionData.versionsCount, 0)))
-    .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
-    .groupBy(seeds.localId)
-
-  if (!itemDataRows || itemDataRows.length === 0) {
-    logger('[db/queries] [getItemDataFromDb] no itemDataRows')
-    return
-  }
-
-  let itemData = itemDataRows[0]
-
-  const propertiesData = await getItemProperties({
-    seedLocalId,
-    seedUid: itemData.seedUid || undefined,
-  })
-
-  if (!propertiesData || propertiesData.length === 0) {
-    return itemData
-  }
-
-  for (const propertyData of propertiesData) {
-    const propertyName = propertyData.propertyName
-
-    let propertyValue = propertyData.propertyValue
-
-    if (propertyName.endsWith('Id') || propertyName.endsWith('Ids')) {
-      if (propertyData.refSeedType) {
-        const propertyNameVariant = propertyName.replace(/Ids?$/, '')
-        itemData[propertyNameVariant] = propertyValue
-      }
-    }
-
-    itemData[propertyName] = propertyValue
-  }
-
-  if (itemData) return itemData
-}
-
-type GetItemParams = {
-  modelName?: string
-  seedLocalId?: string
-  seedUid?: string
-}
-
-type GetItem = (params: GetItemParams) => Promise<Item<any> | undefined>
 
 export const getItem: GetItem = async ({ modelName, seedLocalId, seedUid }) => {
-  const itemInitObj = await getItemDataFromDb({
+  const itemInitObj = await getItemData({
     modelName,
     seedLocalId,
     seedUid,