@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/propertyMachine.ts

@@ -0,0 +1,202 @@
+import { assign, setup } from 'xstate'
+import { PropertyMachineContext } from '@/types'
+
+import { resolveRemoteStorage } from '@/ItemProperty/service/actors/resolveRemoteStorage'
+import { waitForDb } from '@/ItemProperty/service/actors/waitForDb'
+import { initialize } from '@/ItemProperty/service/actors/initialize'
+import { resolveRelatedValue } from '@/ItemProperty/service/actors/resolveRelatedValue'
+import { hydrateFromDb } from '@/ItemProperty/service/actors/hydrateFromDb'
+import {
+  saveImageSrc,
+  saveItemStorage,
+  saveRelation,
+} from '@/ItemProperty/service/actors/saveValueToDb'
+import { analyzeInput } from '@/ItemProperty/service/actors/saveValueToDb/analyzeInput' // import { updateMachineContext } from '@/helpers'
+// import { updateMachineContext } from '@/helpers'
+
+export const propertyMachine = setup({
+  types: {
+    context: {} as PropertyMachineContext,
+    input: {} as PropertyMachineContext,
+  },
+  // actions: {
+  //   updateContext: updateMachineContext,
+  // },
+  actors: {
+    waitForDb,
+    hydrateFromDb,
+    initialize,
+    resolveRelatedValue,
+    resolveRemoteStorage,
+    analyzeInput,
+    saveImageSrc,
+    saveRelation,
+    saveItemStorage,
+  },
+}).createMachine({
+  id: 'itemProperty',
+  initial: 'waitingForDb',
+  context: ({ input }) => input as PropertyMachineContext,
+  on: {
+    // reload: '.hydratingFromDb',
+    save: {
+      actions: assign({
+        isSaving: true,
+      }),
+      target: '.saving',
+    },
+    updateContext: {
+      actions: assign(({ context, event }) => {
+        const newContext = Object.assign({}, context)
+
+        for (let i = 0; i < Object.keys(event).length; i++) {
+          const key = Object.keys(event)[i]
+          if (key === 'type') {
+            continue
+          }
+          newContext[key] = event[key]
+        }
+        return newContext
+      }),
+    },
+  },
+  states: {
+    idle: {},
+    waitingForDb: {
+      on: {
+        waitForDbSuccess: {
+          target: 'hydratingFromDb',
+          actions: assign({
+            isDbReady: true,
+          }),
+        },
+      },
+      invoke: {
+        src: 'waitForDb',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    hydratingFromDb: {
+      on: {
+        hydrateFromDbSuccess: 'initializing',
+      },
+      invoke: {
+        src: 'hydrateFromDb',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    initializing: {
+      on: {
+        initializeSuccess: 'idle',
+        isRelatedProperty: {
+          target: 'resolvingRelatedValue',
+        },
+        hasRemoteBackup: {
+          target: 'resolvingRemoteStorage',
+        },
+      },
+      invoke: {
+        src: 'initialize',
+        input: ({ context, event }) => ({ context, event }),
+      },
+    },
+    resolvingRelatedValue: {
+      on: {
+        resolvingRelatedValueSuccess: {
+          target: 'idle',
+          actions: assign({
+            refResolvedDisplayValue: ({ event }) =>
+              event.refResolvedDisplayValue,
+            refResolvedValue: ({ event }) => event.refResolvedValue,
+          }),
+        },
+        resolvingRelatedValueDone: {
+          target: 'idle',
+        },
+      },
+      invoke: {
+        src: 'resolveRelatedValue',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    resolvingRemoteStorage: {
+      on: {
+        resolveRemoteStorageSuccess: {
+          target: 'idle',
+        },
+      },
+      invoke: {
+        src: 'resolveRemoteStorage',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    saving: {
+      initial: 'analyzingInput',
+      states: {
+        analyzingInput: {
+          on: {
+            saveValueToDbSuccess: {
+              target: 'doneSaving',
+            },
+            saveImageSrc: 'savingImageSrc',
+            saveRelation: 'savingRelation',
+            saveItemStorage: 'savingItemStorage',
+          },
+          invoke: {
+            src: 'analyzeInput',
+            input: ({ context, event }) => ({ context, event }),
+          },
+        },
+        savingImageSrc: {
+          on: {
+            saveImageSrcSuccess: 'doneSaving',
+          },
+          invoke: {
+            src: 'saveImageSrc',
+            input: ({ context, event }) => ({ context, event }),
+          },
+        },
+        savingRelation: {
+          on: {
+            saveRelationSuccess: 'doneSaving',
+          },
+          invoke: {
+            src: 'saveRelation',
+            input: ({ context, event }) => ({ context, event }),
+          },
+        },
+        savingItemStorage: {
+          on: {
+            saveItemStorageSuccess: 'doneSaving',
+          },
+          invoke: {
+            src: 'saveItemStorage',
+            input: ({ context, event }) => ({ context, event }),
+          },
+        },
+        doneSaving: {
+          type: 'final',
+        },
+      },
+      onDone: {
+        target: 'idle',
+        actions: assign(({ context }) => {
+          return {
+            isSaving: false,
+          }
+        }),
+      },
+    },
+  },
+
+  // conflict: {
+  //   on: {
+  //     resolveConflict: {
+  //       target: 'saving',
+  //       actions: assign({
+  //         data: ({ context, event }) => event.output,
+  //       }),
+  //     },
+  //   },
+  // },
+})

package/dist/src/publish.ts

@@ -0,0 +1,28 @@
+import { getGlobalService } from '@/services/global'
+
+type PublishItemRequestEvent = {
+  seedLocalId: string
+}
+
+type PublishItemRequestHandler = (
+  event: PublishItemRequestEvent,
+) => Promise<void>
+
+export const publishItemRequestHandler: PublishItemRequestHandler = async ({
+  seedLocalId,
+}) => {
+  const globalService = getGlobalService()
+  globalService.subscribe((snapshot) => {
+    if (
+      !snapshot ||
+      !snapshot.context ||
+      !snapshot.context.publishItemService
+    ) {
+      return
+    }
+  })
+  globalService.send({
+    type: 'publishItemRequest',
+    seedLocalId,
+  })
+}

package/dist/src/publishMachine.ts

@@ -0,0 +1,77 @@
+import { setup } from 'xstate'
+import { validateItemData } from './actors/validateItemData'
+import { PublishMachineStates } from '@/services/internal/constants'
+import { PublishMachineContext } from '@/types'
+import { createPublishAttempt } from './actors/createPublishAttempt'
+import { updateMachineContext } from '@/helpers/updateMachineContext'
+import { preparePublishRequestData } from '@/services/publish/actors/preparePublishRequestData'
+import { upload } from '@/services/publish/actors/upload'
+
+const {
+  VALIDATING_ITEM_DATA,
+  CREATING_PUBLISH_ATTEMPT,
+  PREPARING_PUBLISH_REQUEST_DATA,
+  UPLOADING,
+  PUBLISHING,
+  IDLE,
+} = PublishMachineStates
+
+export const publishMachine = setup({
+  types: {
+    context: {} as PublishMachineContext,
+    input: {} as PublishMachineContext,
+  },
+  actors: {
+    validateItemData,
+    createPublishAttempt,
+    upload,
+    preparePublishRequestData,
+  },
+}).createMachine({
+  id: 'publish',
+  initial: VALIDATING_ITEM_DATA,
+  context: ({ input }) => input,
+  on: {
+    updateContext: updateMachineContext,
+  },
+  states: {
+    [VALIDATING_ITEM_DATA]: {
+      on: {
+        validateItemDataSuccess: [CREATING_PUBLISH_ATTEMPT],
+      },
+      invoke: {
+        src: 'validateItemData',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    [CREATING_PUBLISH_ATTEMPT]: {
+      on: {
+        createPublishAttemptSuccess: [UPLOADING],
+      },
+      invoke: {
+        src: 'createPublishAttempt',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    [UPLOADING]: {
+      on: {
+        uploadingSuccess: [PREPARING_PUBLISH_REQUEST_DATA],
+      },
+      invoke: {
+        src: 'upload',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    [PREPARING_PUBLISH_REQUEST_DATA]: {
+      on: {
+        preparePublishRequestDataSuccess: [UPLOADING],
+      },
+      invoke: {
+        src: 'preparePublishRequestData',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    [PUBLISHING]: {},
+    [IDLE]: {},
+  },
+})

package/dist/src/queries.ts

@@ -0,0 +1,13 @@
+import { graphql } from '@/graphql/gql'
+
+export const GET_SCHEMA_UIDS_FOR_MODELS = graphql(/* GraphQL */ `
+  query GetSchemaUids($where: SchemaWhereInput!) {
+    schemaUids: schemata(where: $where) {
+      id
+      schema
+      schemaNames {
+        name
+      }
+    }
+  }
+`)

package/dist/src/recoverDeletedItem.ts

@@ -0,0 +1,14 @@
+import { BaseDb } from '@/db/Db/BaseDb'
+import { seeds } from '@/seedSchema'
+import { eq, or } from 'drizzle-orm'
+
+export const recoverDeletedItem = async ({ seedLocalId, seedUid }: { seedLocalId: string, seedUid: string }) => {
+  const appDb = BaseDb.getAppDb()
+
+  await appDb
+    .update(seeds)
+    .set({
+      _markedForDeletion: 0,
+    })
+    .where(or(eq(seeds.localId, seedLocalId), eq(seeds.uid, seedUid)))
+}

package/dist/src/reload.ts

@@ -0,0 +1,33 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput } from '@/types/machines'
+import { ItemMachineContext } from '@/types/item'
+
+export const reload = fromCallback<
+  EventObject,
+  FromCallbackInput<ItemMachineContext<any>>
+>(({ sendBack, input: { context } }) => {
+  const { propertyInstances } = context
+
+  const _reload = async () => {
+    if (!propertyInstances) {
+      return
+    }
+
+    for (const propertyInstance of propertyInstances.values()) {
+      if (propertyInstance) {
+        const propertyRecordSchema = propertyInstance.propertyDef
+        if (
+          propertyRecordSchema &&
+          propertyRecordSchema.storageType &&
+          propertyRecordSchema.storageType === 'ItemStorage'
+        ) {
+          propertyInstance.getService().send({ type: 'reload' })
+        }
+      }
+    }
+  }
+
+  _reload().then(() => {
+    sendBack({ type: 'reloadSuccess' })
+  })
+})

package/dist/src/request.ts

@@ -0,0 +1,45 @@
+import { getItem } from '@/db/read/getItem'
+import { eventEmitter } from '@/eventBus'
+
+const activeItemRequests = new Set<string>()
+
+const queue = new Map<string, Record<string, unknown>>()
+
+export const itemRequestHandler = async (event) => {
+  const { seedLocalId, seedUid, modelName, eventId } = event
+
+  if (activeItemRequests.has(seedLocalId)) {
+    queue.set(seedLocalId, event)
+    return
+  }
+
+  const item = await getItem({
+    modelName,
+    seedLocalId,
+    seedUid,
+  })
+
+  if (!item) {
+    console.warn(
+      `[item/events] [itemRequestHandler] no item for seedLocalId ${seedLocalId} or versionUid ${seedUid}`,
+    )
+    if (eventId) {
+      eventEmitter.emit(`item.${modelName}.${seedLocalId}.response`, {
+        item,
+        eventId,
+      })
+    }
+    return
+  }
+
+  eventEmitter.emit(`item.${modelName}.${seedLocalId}.response`, {
+    item,
+    eventId,
+  })
+
+  queue.delete(seedLocalId)
+  if (queue.size > 0 && queue.has(seedLocalId)) {
+    const nextEvent = queue.get(seedLocalId)
+    await itemRequestHandler(nextEvent)
+  }
+}

package/dist/src/requestAll.ts

@@ -0,0 +1,157 @@
+import { eventEmitter } from '@/eventBus'
+import { getItemsData } from '@/db/read/getItems'
+import debug from 'debug'
+import { getModel } from '@/stores/modelClass'
+import { BaseItem } from '@/Item/BaseItem'
+
+const logger = debug('app:events:requestAll')
+
+const cache = new Map<string, Map<string, BaseItem<any>>>()
+
+let modelCount = 0
+
+const handleRequestAll = async (event) => {
+  const { modelName, eventId } = event
+
+  let modelItemsCache
+
+  if (cache.has(modelName)) {
+    modelItemsCache = cache.get(modelName)
+  }
+
+  if (modelItemsCache && modelName === 'Identity' && modelCount <= 1) {
+    // Send what we have while we update the cache
+    eventEmitter.emit(`item.${modelName}.requestAll.response`, {
+      items: Array.from(modelItemsCache.values()),
+      eventId,
+    })
+    modelCount++
+  }
+
+  if (!modelItemsCache) {
+    modelItemsCache = new Map()
+  }
+
+  const itemsData = await getItemsData({ modelName })
+
+  const cacheKeys = Array.from(modelItemsCache.keys())
+
+  const keysInDb = []
+
+  const returnItems = []
+
+  const ModelClass = getModel(modelName)
+
+  for (const itemData of itemsData) {
+    returnItems.push(
+      await BaseItem.create({
+        ...itemData,
+        modelName,
+      }),
+    )
+  }
+
+  if (modelName === 'Identity' && modelCount <= 1) {
+    logger(
+      `[XXXXXX] [handleRequestAll] ${ModelClass?.originalConstructor.name}:`,
+      returnItems.length,
+    )
+    eventEmitter.emit(`item.${modelName}.requestAll.response`, {
+      items: returnItems,
+      eventId,
+    })
+  }
+
+  for (const returnItem of returnItems) {
+    const itemCacheKey = `${returnItem.seedLocalId}_${returnItem.seedUid || ''}`
+    keysInDb.push(itemCacheKey)
+    const existingCacheKey = cacheKeys.find((ck) => ck.includes(itemCacheKey))
+
+    if (!existingCacheKey) {
+      modelItemsCache.set(itemCacheKey, returnItem)
+      continue
+    }
+
+    if (existingCacheKey) {
+      const existingItem = modelItemsCache.get(existingCacheKey)
+      if (!existingItem) {
+        console.error(
+          '[events/requestAll] [getItemsDataFromDb] no existingItem for cache key',
+          existingCacheKey,
+          modelItemsCache,
+        )
+        continue
+      }
+      for (const [key, value] of Object.entries(returnItem)) {
+        if (key === 'seedLocalId' || key === 'seedUid') {
+          continue
+        }
+        existingItem[key] = value
+      }
+      modelItemsCache.set(existingCacheKey, existingItem)
+    }
+  }
+
+  // Remove any stale items from the cache that were deleted from the DB
+  if (keysInDb.length !== cacheKeys.length) {
+    for (const cacheKey of cacheKeys) {
+      if (!keysInDb.includes(cacheKey)) {
+        modelItemsCache.delete(cacheKey)
+      }
+    }
+  }
+
+  cache.set(modelName, modelItemsCache)
+
+  if (modelName === 'Identity' && modelCount <= 1) {
+    logger(
+      `[XXXXXX] [getItemsDataFromDb] ${modelName} responding with`,
+      Array.from(modelItemsCache.values()),
+    )
+    eventEmitter.emit(`item.${modelName}.requestAll.response`, {
+      items: Array.from(modelItemsCache.values()),
+      eventId,
+    })
+  }
+}
+
+export const itemRequestAllHandler = async (event) => {
+  logger('[events/requestAll] Request all items', event)
+  await handleRequestAll(event)
+  // eventQueue.push(event, (err) => {
+  //   if (err) {
+  //     console.error(err)
+  //   }
+  //   if (!err) {
+  //     logger('[events/requestAll] Request all items done without error')
+  //   }
+  // })
+}
+
+// export const getItemCache = () => {
+//   return itemCache
+// }
+
+type CreateItemCacheKeyParams = {
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type CreateItemCacheKey = (
+  itemData: CreateItemCacheKeyParams,
+) => string | undefined
+
+export const createItemCacheKey: CreateItemCacheKey = (itemData) => {
+  if (!itemData || (!itemData.seedLocalId && !itemData.seedUid)) {
+    return
+  }
+  return `${itemData.seedLocalId}_${itemData.seedUid || ''}`
+}
+
+// export const updateItemCache = (itemCacheKey: string, item: Item<any>) => {
+//   itemCache.set(itemCacheKey, item)
+// }
+//
+// export const deleteItemFromCache = (itemCacheKey: string) => {
+//   itemCache.delete(itemCacheKey)
+// }