@seedprotocol/sdk 0.3.1 → 0.3.3

package/dist/src/propertyMachine.ts

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

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

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

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

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

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

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

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