@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/internalMachine.ts

@@ -0,0 +1,241 @@
+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: ({context, spawn }) => {
+                return spawn(dbMachine, {
+                  input: {
+                    dbName: DB_NAME_APP,
+                    pathToDir: context?.filesDir,
+                  },
+                })
+              },
+            }),
+          ],
+        },
+      },
+      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: () => {
+        console.log('[sdk] [internal/index] Ready!')
+        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

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

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

@@ -0,0 +1,44 @@
+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> => {
+    if (appDbService.getSnapshot().value === 'ready') {
+      return
+    }
+    return new Promise((resolve) => {
+      subscription = appDbService.subscribe((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 })
+  })
+
+  return () => {
+    if (subscription) {
+      subscription.unsubscribe()
+    }
+  }
+})

package/dist/src/machines.ts

@@ -0,0 +1,66 @@
+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
+}
+
+export type ClientManagerContext = {
+  isInitialized: boolean
+  addressesSet: boolean
+  isSaving: boolean
+}

package/dist/src/metadataLatest.ts

@@ -0,0 +1,34 @@
+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))
+  )
+}