@seedprotocol/sdk 0.2.51 → 0.2.53

package/dist/src/connectToDb.ts

@@ -1,41 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { DbServiceContext, FromCallbackInput } from '@/types'
-import { getSqliteWasmClient } from '@/db/sqlWasmClient'
-import { DB_CREATING_SUCCESS } from '@/services/internal/constants'
-import debug from 'debug'
-import { BaseDb } from '@/db/Db/BaseDb'
-
-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
-
-  if (!pathToDir || !dbName) {
-    throw new Error('pathToDir and dbName are required')
-  }
-
-  let isConnecting = false
-  let dbId: string | undefined
-
-  const _connectToDb = async (): Promise<void> => {
-    if (isConnecting) {
-      return
-    }
-    isConnecting = true
-    const dbId = await BaseDb.connectToDb(pathToDir, dbName)
-    if (dbId) {
-      sendBack({ type: DB_CREATING_SUCCESS, dbId, })
-    }
-    isConnecting = false
-  }
-
-  _connectToDb().then(() => {
-    return
-  })
-
-})

package/dist/src/connectionManager.ts

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

@@ -1,125 +0,0 @@
-const ENV = (typeof process !== 'undefined' && process.env) 
-            ? process.env 
-            : (typeof window !== 'undefined' && (window as any).env) 
-            ? (window as any).env 
-            : {};
-
-
-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 =
-               ENV.NEXT_PUBLIC_EAS_ENDPOINT ||
-               ENV.EAS_ENDPOINT ||
-               'https://optimism-sepolia.easscan.org/graphql'
-
-export const ARWEAVE_HOST     =
-               ENV.NEXT_PUBLIC_ARWEAVE_HOST || 'arweave.net'
-export const ARWEAVE_ENDPOINT = `https://${ARWEAVE_HOST}/graphql`

package/dist/src/content-hash.ts

@@ -1,30 +0,0 @@
-const hashLargeString = async ( input: string, ): Promise<string> => {
-  // Convert the string to an ArrayBuffer
-  const encoder = new TextEncoder()
-  const data = encoder.encode(input,)
-
-  // Hash the data with SHA-256
-  const hashBuffer = await crypto.subtle.digest('SHA-256', data,)
-
-  // Convert the ArrayBuffer to a hex string
-  const hashArray = Array.from(new Uint8Array(hashBuffer,),)
-  const hashHex = hashArray.map(( b, ) => b.toString(16,).padStart(2, '0',),).join('',)
-
-  return hashHex
-}
-
-onmessage = async (event,) => {
-  postMessage('Content hash worker received message',)
-  if (!event || !event.data || !event.data.trackingId || !event.data.base64) {
-    postMessage('No event data received',)
-    return
-  }
-  const { trackingId, base64, } = event.data
-  postMessage('Beginning content hash calculation',)
-  const contentHash = await hashLargeString(base64,)
-  postMessage('Content hash calculation complete',)
-  postMessage({
-    trackingId,
-    contentHash,
-  },)
-}

package/dist/src/create.ts

@@ -1,39 +0,0 @@
-import { eventEmitter } from '@/eventBus'
-import { createItemCacheKey, getItemCache, updateItemCache } from './requestAll'
-import { BaseItem } from '@/Item/BaseItem'
-
-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 = await BaseItem.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/createMetadata.ts

@@ -1,77 +0,0 @@
-import { metadata, MetadataType } from '@/seedSchema'
-import { BaseEasClient, BaseQueryClient, generateId } from '@/helpers'
-import { PropertyType } from '@/types'
-import { BaseDb } from '../Db/BaseDb'
-import { GET_SCHEMA_BY_NAME, } from '@/Item/queries'
-import { INTERNAL_DATA_TYPES } from '@/helpers/constants'
-import { toSnakeCase } from 'drizzle-orm/casing'
-import { Schema } from '@/graphql/gql/graphql'
-import path from 'path'
-import fs from '@zenfs/core'
-
-type CreateMetadata = (
-  metadataValues: Partial<MetadataType>,
-  propertyRecordSchema?: PropertyType | undefined,
-) => Promise<MetadataType>
-
-export const createMetadata: CreateMetadata = async (
-  metadataValues,
-  propertyRecordSchema?,
-) => {
-  const appDb = BaseDb.getAppDb()
-
-  metadataValues.localId = generateId()
-
-  if (!metadataValues.modelType && metadataValues.modelName) {
-    metadataValues.modelType = toSnakeCase(metadataValues.modelName)
-  }
-
-  const isItemStorage = propertyRecordSchema && propertyRecordSchema.storageType === 'ItemStorage'
-
-  // if (
-  //   propertyRecordSchema &&
-  //   propertyRecordSchema.localStorageDir &&
-  //   isItemStorage
-  // ) {
-  //   const filename = `${metadataValues.seedUid || metadataValues.seedLocalId}${propertyRecordSchema.filenameSuffix}`
-  //   const filePath = path.join(propertyRecordSchema.localStorageDir, filename)
-  //   await fs.promises.writeFile(filePath, metadataValues.propertyValue)
-  //   metadataValues.propertyValue = filename
-  //   metadataValues.refValueType = 'file'
-  // }
-
-  if (!isItemStorage && !metadataValues.schemaUid && propertyRecordSchema) {
-    const queryClient = BaseQueryClient.getQueryClient()
-    const easClient = BaseEasClient.getEasClient()
-
-    const easDataType = INTERNAL_DATA_TYPES[propertyRecordSchema.dataType].eas
-
-    const propertyNameSnakeCase = toSnakeCase(metadataValues.propertyName)
-  
-    const queryResult = await queryClient.fetchQuery({
-      queryKey: [`getSchemaByName${metadataValues.propertyName}`],
-      queryFn: async (): Promise<{schemas: Schema[]}> =>
-        easClient.request(GET_SCHEMA_BY_NAME, {
-          where: {
-            schema: {
-              equals: `${easDataType} ${propertyNameSnakeCase}`,
-            },
-          },
-        }),
-    })
-
-    if (queryResult && queryResult.schemas.length > 0) {
-      metadataValues.schemaUid = queryResult.schemas[0].id
-    }
-
-  }
-
-  return appDb
-    .insert(metadata)
-    .values({
-      ...metadataValues,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    })
-    .returning()
-}

package/dist/src/createNewItem.ts

@@ -1,61 +0,0 @@
-import { ModelValues } from '@/types'
-import { getModel } from '@/stores/modelClass'
-import { createSeed } from './createSeed'
-import { createVersion } from './createVersion'
-import { createMetadata } from './createMetadata'
-import { toSnakeCase } from 'drizzle-orm/casing'
-import { eventEmitter } from '@/eventBus'
-
-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 = toSnakeCase(modelName)
-
-  const newSeedId = await createSeed({ type: seedType })
-
-  const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: toSnakeCase(modelName) })
-
-  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,
-    )
-  }
-
-  eventEmitter.emit('item.requestAll', { modelName })
-
-  return {
-    modelName,
-    seedLocalId: newSeedId,
-    versionLocalId: newVersionId,
-  }
-} 

package/dist/src/createPublishAttempt.ts

@@ -1,16 +0,0 @@
-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/createSeed.ts

@@ -1,31 +0,0 @@
-import { generateId } from '@/helpers'
-import { seeds } from '@/seedSchema'
-import { BaseDb } from '@/db/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,24 +0,0 @@
-import { seeds, SeedType } from '@/seedSchema'
-import { BaseDb } from '@/db/Db/BaseDb'
-
-type CreateSeeds = (newSeeds: Partial<SeedType>[]) => Promise<string[]>
-
-export const createSeeds: CreateSeeds = async (
-  newSeeds: Partial<SeedType>[],
-) => {
-  const appDb = BaseDb.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

@@ -1,33 +0,0 @@
-import { generateId } from '@/helpers'
-import { versions } from '@/seedSchema'
-import { BaseDb } from '../Db/BaseDb'
-
-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 = BaseDb.getAppDb()
-
-  const newVersionLocalId = generateId()
-
-  await appDb.insert(versions).values({
-    localId: newVersionLocalId,
-    createdAt: Date.now(),
-    seedLocalId,
-    seedUid: seedUid ?? 'NULL',
-    seedType,
-    uid: uid || 'NULL',
-  })
-
-  return newVersionLocalId
-}