@seedprotocol/sdk 0.1.46 → 0.1.48

package/dist/src/itemMachineAll.ts

@@ -0,0 +1,158 @@
+import { assign, setup } from 'xstate'
+import { MachineIds } from '@/browser/services/internal/constants'
+import { AllItemsMachineContext } from '@/types'
+import { eventEmitter } from '@/eventBus'
+import { initialize } from '@/browser/item/all/actors/initialize'
+import { fetchDbData } from '@/browser/item/all/actors/fetchDbData'
+import { fetchSeeds } from '@/browser/item/all/actors/fetchSeeds'
+import { fetchVersions } from '@/browser/item/all/actors/fetchVersions'
+import { fetchRelatedItems } from '@/browser/item/all/actors/fetchRelatedItems'
+import { processItems } from '@/browser/item/all/actors/processItems'
+
+const excludedVersionUidValues = ['', 'undefined', 'null', '0', 0]
+
+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,175 @@
+import { assign, setup } from 'xstate'
+import { MachineIds } from '@/browser/services/internal/constants'
+import { ItemMachineContext } from '@/types'
+import { ItemProperty } from '../../property'
+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'
+
+export const itemMachineSingle = setup({
+  types: {
+    context: {} as ItemMachineContext<any>,
+    input: {},
+  },
+  actors: {
+    waitForDb,
+    initialize,
+    hydrateExistingItem,
+    hydrateNewItem,
+    fetchDataFromEas,
+  },
+}).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, ItemProperty<any>>()
+        }
+        const { propertyName, propertyValue } = event
+
+        if (!propertyInstances.has(propertyName)) {
+          return {
+            [propertyName]: propertyValue,
+          }
+        }
+        const propertyInstance = propertyInstances.get(
+          propertyName,
+        ) as ItemProperty<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, typeof ItemProperty>()
+        propertyInstances.set(event.propertyName, event.propertyInstance)
+        return {
+          propertyInstances,
+        }
+      }),
+    },
+    // addPropertyAttestation: {
+    //   actions: assign(({ context, event }) => {
+    //     console.log('[singleItemMachine] [addPropertyAttestation] event', event)
+    //     const propertyInstances =
+    //       context.propertyInstances || new Map<string, typeof ItemProperty>()
+    //     propertyInstances.set(event.propertyName, event.propertyInstances)
+    //     return {
+    //       propertyInstances,
+    //     }
+    //   }),
+    // },
+  },
+  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 }),
+      },
+    },
+    // fetchingDataFromEas: {
+    //   on: {
+    //     fetchDataFromEasSuccess: 'savingDataToDb',
+    //   },
+    //   invoke: {
+    //     src: 'fetchDataFromEas',
+    //     input: ({ context }) => ({ context }),
+    //   },
+    // },
+    // savingDataToDb: {
+    //   on: {
+    //     saveDataToDbSuccess: 'idle',
+    //   },
+    //   invoke: {
+    //     src: 'saveDataToDb',
+    //     input: ({ context }) => ({ context }),
+    //   },
+    // },
+    destroying: {
+      type: 'final',
+    },
+  },
+})

package/dist/src/loadAppDb.ts

@@ -0,0 +1,47 @@
+import { EventObject, fromCallback, Subscription } from 'xstate'
+import {
+  DB_NAME_APP,
+  DB_ON_SNAPSHOT,
+  INTERNAL_LOADING_APP_DB_SUCCESS,
+} from '@/browser/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/logger.ts

@@ -0,0 +1,33 @@
+import { dayjs } from '@/shared/helpers/index'
+
+type Log = (message: string, data?: unknown) => void
+
+type LoggerType = (tag: string) => {
+  log: Log
+}
+
+const tagsToLog = [
+  // 'InternalMachine',
+  'internal/actors',
+  'db/actors',
+]
+
+const Logger: LoggerType = (tag: string) => {
+  const _tag = tag || 'Logger'
+
+  const log: Log = (message, data = undefined): void => {
+    if (process.env.IS_SEED_DEV && tagsToLog.includes(_tag)) {
+      const timestamp = dayjs().format('YYYY-MM-DD HH:mm:ss')
+      console.log(
+        `[${timestamp}] [${_tag}] ${dayjs().format('YYYY-MM-DD HH:mm:ss')} ${message}`,
+        data || '',
+      )
+    }
+  }
+
+  return {
+    log,
+  }
+}
+
+export default Logger

package/dist/src/machine.ts

@@ -0,0 +1,55 @@
+import { ActorRefFrom, assign, setup } from 'xstate'
+import { downloadMachine } from '@/browser/schema/file/download'
+import { uploadMachine } from '@/browser/schema/file/upload'
+import { MachineIds } from '@/browser/services/internal/constants'
+
+type FileSystemMachineContext = {
+  addresses?: string[]
+  downloads: ActorRefFrom<typeof downloadMachine>[]
+  uploads: ActorRefFrom<typeof uploadMachine>[]
+  files?: any[]
+  filesMetadata?: any[]
+}
+
+export const fileSystemMachine = setup({
+  types: {
+    context: {} as FileSystemMachineContext,
+  },
+  actors: {},
+}).createMachine({
+  id: MachineIds.FILE_SYSTEM,
+  initial: 'idle',
+  context: ({ input }) =>
+    ({
+      ...input,
+      fetchRequests: [],
+      downloads: [],
+      uploads: [],
+      files: [],
+    }) as FileSystemMachineContext,
+  on: {
+    updateFilesMetadata: {
+      actions: assign({
+        filesMetadata: ({ event }) => event.filesMetadata,
+      }),
+    },
+  },
+  states: {
+    idle: {
+      on: {
+        download: {
+          target: 'createDownload',
+        },
+        upload: {
+          target: 'createUpload',
+        },
+        fetch: {
+          target: 'createFetchFiles',
+          actions: assign({
+            addresses: ({ event }) => event.addresses,
+          }),
+        },
+      },
+    },
+  },
+})

package/dist/src/machines.ts

@@ -0,0 +1,58 @@
+import { Endpoints, Environment, ModelClassType } from './index'
+import { ActorRefFrom } from 'xstate'
+import { fileSystemMachine } from '@/browser/schema/file/machine'
+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[]
+  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>
+  fileSystemService?: ActorRefFrom<typeof fileSystemMachine>
+  publishItemService?: ActorRefFrom<any>
+}
+
+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
+}