@seedprotocol/sdk 0.2.51 → 0.2.53

package/dist/src/internalMachine.ts

@@ -1,238 +0,0 @@
-import { assign, setup } from 'xstate'
-import { createBrowserInspector } from '@statelyai/inspect'
-import {
-  DB_NAME_APP,
-  INTERNAL_CONFIGURING_FS_SUCCESS,
-  INTERNAL_LOADING_APP_DB_SUCCESS,
-  INTERNAL_SAVING_CONFIG_SUCCESS,
-  INTERNAL_VALIDATING_INPUT_SUCCESS,
-  InternalState,
-  MachineIds,
-} from './constants'
-import { dbMachine } from '@/services/db/dbMachine'
-import debug from 'debug'
-import { validateInput } from '@/services/internal/actors/validateInput'
-import { prepareDb } from '@/services/internal/actors/prepareDb'
-import { configureFs } from '@/services/internal/actors/configureFs'
-import { saveConfig } from '@/services/internal/actors/saveConfig'
-import { loadAppDb } from '@/services/internal/actors/loadAppDb'
-import { InternalMachineContext } from '@/types'
-import { waitForFiles } from './actors/waitForFiles'
-
-const logger = debug('app:services:internal:machine')
-
-const { inspect } = createBrowserInspector({
-  autoStart: false,
-})
-
-const {
-  IDLE,
-  VALIDATING_INPUT,
-  SAVING_CONFIG,
-  CONFIGURING_FS,
-  LOADING_APP_DB,
-} = InternalState
-
-// Create the state machine
-export const internalMachine = setup({
-  types: {
-    context: {} as Partial<InternalMachineContext>,
-    input: {} as Partial<InternalMachineContext> | undefined,
-  },
-  actors: {
-    prepareDb,
-    validateInput,
-    waitForFiles,
-    configureFs,
-    loadAppDb,
-    saveConfig,
-  },
-}).createMachine({
-  id: MachineIds.INTERNAL,
-  initial: IDLE,
-  context: ({ input }) => {
-    return {
-      ...input,
-      error: undefined,
-      hasFiles: false,
-    }
-  },
-  states: {
-    [IDLE]: {
-      on: {
-        reValidate: VALIDATING_INPUT,
-        init: {
-          target: VALIDATING_INPUT,
-          actions: [
-            assign({
-              appDbService: ({ spawn }) =>
-                spawn(dbMachine, {
-                  input: {
-                    dbName: DB_NAME_APP,
-                  },
-                }),
-            }),
-          ],
-        },
-      },
-      meta: {
-        displayText: 'Waiting for something to happen ...',
-        percentComplete: 0,
-      },
-    },
-    [VALIDATING_INPUT]: {
-      on: {
-        [INTERNAL_VALIDATING_INPUT_SUCCESS]: {
-          target: 'preparingDb',
-          actions: assign({
-            endpoints: ({ event }) => event.endpoints,
-            addresses: ({ event }) => event.addresses,
-            filesDir: ({ event }) => event.filesDir,
-            arweaveDomain: ({ event }) => event.arweaveDomain,
-          }),
-        },
-      },
-      invoke: {
-        src: 'validateInput',
-        input: ({ context, event }) => ({ context, event }),
-      },
-      meta: {
-        displayText: 'Validating input',
-        percentComplete: 20,
-      },
-      tags: ['loading'],
-    },
-    preparingDb: {
-      on: {
-        prepareDbSuccess: {
-          target: CONFIGURING_FS,
-        },
-      },
-      invoke: {
-        src: 'prepareDb',
-        input: ({ context, event }) => ({ context, event }),
-      },
-    },
-    waitingForFiles: {
-      on: {
-        filesReceived: {
-          target: LOADING_APP_DB,
-        },
-      },
-      invoke: {
-        src: 'waitForFiles',
-        input: ({ context, event }) => ({ context, event }),
-      },
-    },
-    [CONFIGURING_FS]: {
-      on: {
-        [INTERNAL_CONFIGURING_FS_SUCCESS]: {
-          target: LOADING_APP_DB,
-          actions: assign({ hasFiles: true }),
-        },
-        shouldWaitForFiles: {
-          target: 'waitingForFiles',
-        },
-      },
-      invoke: {
-        src: 'configureFs',
-        input: ({ context, event }) => ({ context, event }),
-      },
-      meta: {
-        displayText: 'Downloading app files',
-        percentComplete: 30,
-      },
-      tags: ['loading'],
-    },
-    [LOADING_APP_DB]: {
-      on: {
-        [INTERNAL_LOADING_APP_DB_SUCCESS]: {
-          target: SAVING_CONFIG,
-          actions: () => {
-            logger('[sdk] [internal/index] App DB loaded!')
-          },
-        },
-      },
-      invoke: {
-        src: 'loadAppDb',
-        input: ({ context, event }) => ({ context, event }),
-      },
-    },
-    // Save developer's config to DB
-    [SAVING_CONFIG]: {
-      on: {
-        [INTERNAL_SAVING_CONFIG_SUCCESS]: 'ready',
-      },
-      invoke: {
-        src: 'saveConfig',
-        input: ({ context, event }) => ({ context, event }),
-      },
-      meta: {
-        displayText: 'Saving configuration',
-        percentComplete: 80,
-      },
-      tags: ['loading'],
-    },
-    ready: {
-      entry: () => {
-        logger('[sdk] [internal/index] Ready!')
-      },
-      meta: {
-        displayText: "Crossing the t's ...",
-        percentComplete: 90,
-      },
-    },
-    error: {
-      on: {
-        retry: {
-          target: CONFIGURING_FS,
-          actions: assign({ error: undefined }),
-        },
-      },
-      entry: () => {
-        logger('[sdk] [internal/index] Error!')
-      },
-      meta: {
-        displayText: 'Whoops! Something went wrong.',
-        percentComplete: null,
-      },
-      tags: ['error'],
-    },
-  },
-})
-
-// const internalService = createActor(internalMachine, {
-//   input: {},
-//   inspect: (inspEvent) => {
-//     if (inspEvent.type === '@xstate.snapshot') {
-//       if (
-//         inspEvent.event &&
-//         inspEvent.event.snapshot &&
-//         inspEvent.event.snapshot.value
-//       ) {
-//         logger(
-//           `[internalService] ${inspEvent.event.snapshot.value}`,
-//           inspEvent,
-//         )
-//         return
-//       }
-//
-//       if (inspEvent.snapshot && inspEvent.snapshot.value) {
-//         logger(`[internalService] ${inspEvent.snapshot.value}`, inspEvent)
-//         return
-//       }
-//
-//       // logger(`[internalService] Uncaught event`, inspEvent)
-//     }
-//   },
-// })
-
-// internalService.subscribe((snapshot) => {
-//   globalService.send({ type: INTERNAL_SERVICE_SNAPSHOT, snapshot })
-// })
-//
-// internalService.on(CHILD_SNAPSHOT, (emitted) => {
-//   globalService.send({ ...emitted })
-// })
-
-// internalService.start()

package/dist/src/itemMachineAll.ts

@@ -1,157 +0,0 @@
-import { assign, setup } from 'xstate'
-import { MachineIds } from '@/services/internal/constants'
-import { AllItemsMachineContext } from '@/types'
-import { eventEmitter } from '@/eventBus'
-import { initialize } from '../allItems/actors/initialize'
-import { fetchDbData } from '../allItems/actors/fetchDbData'
-import { fetchSeeds } from '../allItems/actors/fetchSeeds'
-import { fetchVersions } from '../allItems/actors/fetchVersions'
-import { fetchRelatedItems } from '../allItems/actors/fetchRelatedItems'
-import { processItems } from '../allItems/actors/processItems'
-
-
-export const itemMachineAll = setup({
-  types: {
-    context: {} as Partial<AllItemsMachineContext>,
-    input: {} as Partial<AllItemsMachineContext> | undefined,
-  },
-  actors: {
-    initialize,
-    fetchDbData,
-    fetchSeeds,
-    fetchVersions,
-    fetchRelatedItems,
-    processItems,
-  },
-}).createMachine({
-  id: MachineIds.ALL_ITEMS,
-  initial: 'uninitialized',
-  context: ({ input }) => input as AllItemsMachineContext,
-  on: {
-    updateTimes: {
-      actions: assign({
-        times: ({ event }) => event.times,
-      }),
-    },
-  },
-  states: {
-    idle: {
-      entry: ({ self, context }) => {
-        eventEmitter.emit('service.saveState.request', {
-          state: self.getPersistedSnapshot(),
-          serviceId: `${MachineIds.ALL_ITEMS}_${context.modelName}`,
-        })
-      },
-    },
-    uninitialized: {
-      on: {
-        modelsFound: {
-          target: 'initializing',
-          actions: assign({
-            modelAddedToDb: true,
-          }),
-        },
-      },
-    },
-    initializing: {
-      on: {
-        initializeSuccess: {
-          target: 'fetchingSeeds',
-          actions: assign({
-            modelName: ({ event }) => event.modelName,
-            modelNameLowercase: ({ event }) => event.modelNameLowercase,
-            modelNamePlural: ({ event }) => event.modelNamePlural,
-            queryVariables: ({ event }) => event.queryVariables,
-          }),
-        },
-        modelsNotFound: 'idle',
-      },
-      invoke: {
-        src: 'initialize',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    fetchingSeeds: {
-      on: {
-        fetchSeedsSuccess: {
-          target: 'fetchingVersions',
-          actions: assign({
-            itemSeeds: ({ event }) => event.itemSeeds,
-          }),
-        },
-      },
-      invoke: {
-        src: 'fetchSeeds',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    fetchingVersions: {
-      on: {
-        fetchVersionsSuccess: {
-          target: 'fetchingRelatedItems',
-          actions: assign({
-            itemVersions: ({ event }) => event.itemVersions,
-          }),
-        },
-      },
-      invoke: {
-        src: 'fetchVersions',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    fetchingRelatedItems: {
-      on: {
-        fetchRelatedItemsSuccess: {
-          target: 'processingItems',
-          actions: assign({
-            relatedProperties: ({ event }) => event.relatedProperties,
-            relatedVersionsBySeedUid: ({ event }) =>
-              event.relatedVersionsBySeedUid,
-            relatedVersionsBySchemaUid: ({ event }) =>
-              event.relatedVersionsBySchemaUid,
-            schemaUidsByModelName: ({ event }) => event.schemaUidsByModelName,
-            mostRecentPropertiesBySeedUid: ({ event }) =>
-              event.mostRecentPropertiesBySeedUid,
-          }),
-        },
-      },
-      invoke: {
-        src: 'fetchRelatedItems',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    processingItems: {
-      on: {
-        processItemsSuccess: 'idle',
-        itemCreated: {
-          actions: assign({
-            items: ({ context, event }) => {
-              if (context && context.items) {
-                const foundItem = context.items.find((item) => {
-                  if (!item.versionLocalId) {
-                    return false
-                  }
-                  return (
-                    item.versionLocalId === event.item.versionLocalId ||
-                    item.versionUid === event.item.versionUid
-                  )
-                })
-                if (foundItem) {
-                  return context.items
-                }
-                return [...context.items, event.item]
-              }
-              if (context && !context.items) {
-                return [event.item]
-              }
-            },
-          }),
-        },
-      },
-      invoke: {
-        src: 'processItems',
-        input: ({ context, self }) => ({ context, self }),
-      },
-    },
-  },
-})

package/dist/src/itemMachineSingle.ts

@@ -1,158 +0,0 @@
-import { assign, setup } from 'xstate'
-import { MachineIds } from '@/services/internal/constants'
-import { ItemMachineContext } from '@/types'
-import { waitForDb } from './actors/waitForDb'
-import { initialize } from './actors/initialize'
-import { hydrateExistingItem } from './actors/hydrateExistingItem'
-import { hydrateNewItem } from './actors/hydrateNewItem'
-import { fetchDataFromEas } from './actors/fetchDataFromEas'
-import { reload } from './actors/reload'
-import { IItemProperty } from '@/interfaces'
-
-export const itemMachineSingle = setup({
-  types: {
-    context: {} as ItemMachineContext<any>,
-    input: {},
-  },
-  actors: {
-    waitForDb,
-    initialize,
-    hydrateExistingItem,
-    hydrateNewItem,
-    fetchDataFromEas,
-    reload,
-  },
-}).createMachine({
-  id: MachineIds.ITEM,
-  initial: 'waitingForDb',
-  context: ({ input }) => input as ItemMachineContext<any>,
-  on: {
-    updatedPropertiesBySchemaUid: {
-      actions: assign({
-        propertiesBySchemaUid: ({ event }) => event.propertiesBySchemaUid,
-      }),
-    },
-    updatePropertiesMetadata: {
-      actions: assign({
-        propertiesMetadata: ({ event }) => event.propertiesMetadata,
-      }),
-    },
-    updateProperties: {
-      actions: assign({
-        propertiesUpdatedAt: Date.now(),
-      }),
-    },
-    updateValue: {
-      actions: assign(({ event, context }) => {
-        let { propertyInstances } = context
-        if (!propertyInstances) {
-          propertyInstances = new Map<string, IItemProperty<any>>()
-        }
-        const { propertyName, propertyValue } = event
-
-        if (!propertyInstances.has(propertyName)) {
-          return {
-            [propertyName]: propertyValue,
-          }
-        }
-        const propertyInstance = propertyInstances.get(
-          propertyName,
-        ) as IItemProperty<any>
-
-        propertyInstance.value = propertyValue
-        propertyInstances.set(propertyName, propertyInstance)
-        // TODO: use immer here
-        return {
-          propertyInstances,
-        }
-      }),
-    },
-    addPropertyInstance: {
-      actions: assign(({ context, event }) => {
-        const propertyInstances =
-          context.propertyInstances || new Map<string, IItemProperty<any>>()
-        propertyInstances.set(event.propertyName, event.propertyInstance)
-        return {
-          propertyInstances,
-        }
-      }),
-    },
-    reload: '.reloading',
-  },
-  states: {
-    idle: {},
-    waitingForDb: {
-      on: {
-        waitForDbSuccess: 'initializing',
-      },
-      invoke: {
-        src: 'waitForDb',
-      },
-    },
-    initializing: {
-      on: {
-        hasExistingItem: {
-          target: 'idle',
-          actions: assign({
-            modelTableName: ({ event }) => event.modelTableName,
-            modelNamePlural: ({ event }) => event.modelNamePlural,
-            modelName: ({ event }) => event.modelName,
-            existingItem: ({ event }) => event.existingItem,
-          }),
-        },
-        isNewItem: {
-          target: 'idle',
-          actions: assign({
-            modelTableName: ({ event }) => event.modelTableName,
-            modelNamePlural: ({ event }) => event.modelNamePlural,
-            modelName: ({ event }) => event.modelName,
-          }),
-        },
-      },
-      invoke: {
-        src: 'initialize',
-        input: ({ context, event }) => ({ context, event }),
-      },
-    },
-    hydratingExistingItem: {
-      on: {
-        hydrateExistingItemSuccess: 'idle',
-        hydrateExistingItemFailure: 'destroying',
-      },
-      invoke: {
-        src: 'hydrateExistingItem',
-        input: ({ event, context }) => ({ event, context }),
-      },
-    },
-    hydratingNewItem: {
-      on: {
-        hydrateNewItemSuccess: 'idle',
-      },
-      invoke: {
-        src: 'hydrateNewItem',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    fetchingRemoteData: {
-      on: {
-        fetchRemoteDataSuccess: 'idle',
-      },
-      invoke: {
-        src: 'fetchRemoteData',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    reloading: {
-      on: {
-        reloadSuccess: 'idle',
-      },
-      invoke: {
-        src: 'reload',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    destroying: {
-      type: 'final',
-    },
-  },
-})

package/dist/src/loadAppDb.ts

@@ -1,47 +0,0 @@
-import { EventObject, fromCallback, Subscription } from 'xstate'
-import {
-  DB_NAME_APP,
-  DB_ON_SNAPSHOT,
-  INTERNAL_LOADING_APP_DB_SUCCESS,
-} from '@/services/internal/constants'
-import debug from 'debug'
-import { FromCallbackInput, InternalMachineContext } from '@/types'
-
-const logger = debug('app:services:internal:actors:loadAppDb')
-
-export const loadAppDb = fromCallback<
-  EventObject,
-  FromCallbackInput<InternalMachineContext>
->(({ sendBack, input: { context } }) => {
-  const { appDbService } = context
-
-  let subscription: Subscription | undefined
-
-  const _loadAppDb = async (): Promise<void> => {
-    return new Promise((resolve) => {
-      if (appDbService.getSnapshot().value === 'ready') {
-        return resolve()
-      }
-      subscription = appDbService.subscribe({
-        next: (snapshot) => {
-          if (snapshot.value === 'ready') {
-            return resolve()
-          }
-
-          sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot })
-        },
-      })
-    })
-  }
-
-  _loadAppDb().then(() => {
-    sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS })
-    logger('[sdk] [internal/actors] Successfully loaded app DB')
-  })
-
-  return () => {
-    if (subscription) {
-      subscription.unsubscribe()
-    }
-  }
-})

package/dist/src/machines.ts

@@ -1,60 +0,0 @@
-import { Endpoints, Environment, ModelClassType } from './index'
-import { ActorRefFrom } from 'xstate'
-import { PublishRequestData } from './seedProtocol'
-
-export type DbServiceContext = {
-  dbName: string
-  dbId?: string
-  dirName: string
-  drizzleDb?: any
-  pathToDb?: string
-  pathToDir?: string
-  pathToDbDir?: string
-  hasFiles?: boolean
-  error?: string
-}
-
-export type InternalMachineContext = {
-  error?: string
-  endpoints: Endpoints
-  addresses: string[]
-  filesDir?: string
-  arweaveDomain?: string
-  environment: string
-  hasFiles: boolean
-  seedDbService: any
-  appDbService: any
-  sdkDbService: any
-}
-
-export type GlobalMachineContext = {
-  isInitialized?: boolean
-  addedModelRecordsToDb?: boolean
-  environment?: Environment
-  endpoints?: Endpoints
-  addresses?: string[]
-  models?: { [key: string]: ModelClassType }
-  internalService?: ActorRefFrom<any>
-  publishItemService?: ActorRefFrom<any>
-  arweaveDomain?: string
-  filesDir?: string
-}
-
-export type PublishMachineContext = PublishRequestData & {
-  status: string
-}
-
-export type GetSchemaForModelEvent = {
-  type: 'getSchemaForModel'
-  modelName: string
-}
-
-export type HydrateExistingItemEvent = {
-  type: 'hydrateExistingItem'
-  existingItem: any
-}
-
-export type FromCallbackInput<T, P = undefined> = {
-  context: T
-  event?: P
-}

package/dist/src/metadataLatest.ts

@@ -1,34 +0,0 @@
-import { and, eq, getTableColumns, or, SQL, sql } from 'drizzle-orm'
-import { BaseDb } from '@/db/Db/BaseDb'
-import { metadata } from '@/seedSchema'
-
-export const getMetadataLatest = ({seedLocalId, seedUid}: {seedLocalId?: string, seedUid?: string}) => {
-  const appDb = BaseDb.getAppDb()
-
-  const whereClauses: SQL[] = []
-
-  if (seedLocalId) {
-    whereClauses.push(eq(metadata.seedLocalId, seedLocalId))
-  }
-
-  if (seedUid) {
-    whereClauses.push(eq(metadata.seedUid, seedUid))
-  }
-
-  const metadataColumns = getTableColumns(metadata)
-
-  return appDb.$with('metadataLatest').as(
-    appDb
-      .select({
-        ...metadataColumns,
-        rowNum: sql.raw(`
-           ROW_NUMBER() OVER (
-               PARTITION BY property_name 
-               ORDER BY COALESCE(created_at, attestation_created_at) DESC
-           )
-          `).as('rowNum')
-      })
-      .from(metadata)
-      .where(and(...whereClauses))
-  )
-}