@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/processItems.ts

@@ -0,0 +1,71 @@
+import { EventObject, fromCallback } from 'xstate'
+import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { Attestation } from '@/browser/gql/graphql'
+import { eventEmitter } from '@/eventBus'
+
+export const processItems = fromCallback<EventObject, typeof itemMachineAll>(
+  ({ sendBack, input: { context } }) => {
+    const {
+      itemVersions,
+      itemSeeds,
+      ModelClass,
+      schemaUidsByModelName,
+      mostRecentPropertiesBySeedUid,
+      times,
+      // relatedProperties,
+      // relatedVersionsBySchemaUid,
+      // relatedVersionsBySeedUid,
+    } = context
+
+    if (!itemVersions || !itemSeeds) {
+      throw new Error('No itemVersions or itemSeeds found')
+    }
+
+    const _processItems = async () => {
+      // For each itemSeed, find all the Versions
+      for (const itemSeed of itemSeeds.slice(8, 16)) {
+        const versionsForSeed = itemVersions.filter(
+          (version) => version.refUID === itemSeed.id,
+        )
+
+        if (versionsForSeed.length === 0) {
+          continue
+        }
+
+        // Find the most recent Version for each Seed
+        const recentVersionsMap: { [seedId: string]: Attestation } = {}
+        versionsForSeed.forEach((version: Attestation) => {
+          const existingVersion = recentVersionsMap[version.refUID]
+          if (
+            !existingVersion ||
+            new Date(version.timeCreated * 1000) >
+              new Date(existingVersion.timeCreated * 1000)
+          ) {
+            recentVersionsMap[version.refUID] = version
+          }
+        })
+      }
+    }
+
+    _processItems().then(() => {
+      sendBack({ type: 'processItemsSuccess' })
+      const modelName = ModelClass.originalConstructor.name
+      eventEmitter.emit('item.requestAll', {
+        modelName,
+      })
+      eventEmitter.emit('service.save', {
+        modelName,
+      })
+      sendBack({
+        type: 'updateTimes',
+        times: {
+          ...times,
+          processItems: {
+            start: null,
+            end: Date.now(),
+          },
+        },
+      })
+    })
+  },
+)

package/dist/src/property.ts

@@ -0,0 +1,161 @@
+import { useImmer } from 'use-immer'
+import { Item } from '@/browser/item'
+import { useCallback, useEffect, useState } from 'react'
+import { useSelector } from '@xstate/react'
+import debug from 'debug'
+import { eventEmitter } from '@/eventBus'
+import { ItemProperty } from '@/browser/property'
+import { useGlobalServiceStatus } from '@/browser/react/services'
+
+const logger = debug('app:react:property')
+
+type UseItemPropertyProps = {
+  propertyName: string
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type UseItemPropertyReturn = {
+  property: ItemProperty<any> | undefined
+  isInitialized: boolean
+  isReadingFromDb: boolean
+  value: any
+  status: string
+}
+
+type UseItemProperty = (props: UseItemPropertyProps) => UseItemPropertyReturn
+
+export const useItemProperty: UseItemProperty = ({
+  propertyName,
+  seedLocalId,
+  seedUid,
+}) => {
+  const [property, setProperty] = useState<ItemProperty<any> | undefined>()
+  const [isReadingFromDb, setIsReadingFromDb] = useState(false)
+  const [isInitialized, setIsInitialized] = useState(false)
+
+  // const isDbReady = useMemo(() => useIsDbReady(), [])
+
+  const { internalStatus } = useGlobalServiceStatus()
+
+  const value = useSelector(property?.getService(), (snapshot) => {
+    if (!snapshot || !snapshot.context) {
+      return
+    }
+    return snapshot.context.renderValue || snapshot.context.propertyValue
+  })
+
+  const status = useSelector(
+    property?.getService(),
+    (snapshot) => snapshot?.value as string,
+  )
+
+  // useEffect(() => {
+  //   if (property && property.value !== value) {
+  //     readFromDb()
+  //   }
+  // }, [property, value])
+
+  const readFromDb = useCallback(async () => {
+    if (
+      internalStatus !== 'ready' ||
+      isReadingFromDb ||
+      (!seedLocalId && !seedUid)
+    ) {
+      return
+    }
+    setIsReadingFromDb(true)
+    const foundProperty = await ItemProperty.find({
+      propertyName,
+      seedLocalId,
+      seedUid,
+    })
+    setIsReadingFromDb(false)
+    if (!foundProperty) {
+      logger(
+        `[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`,
+      )
+      return
+    }
+    if (foundProperty.status === 'waitingForDb') {
+      foundProperty.getService().send({ type: 'waitForDbSuccess' })
+    }
+    setProperty(foundProperty)
+    setIsInitialized(true)
+  }, [internalStatus, isReadingFromDb])
+
+  // let count = 0
+  //
+  // const refresh = useCallback(() => {
+  //   count++
+  //   console.log('[useItemPropertyTest] [refresh] property', property)
+  // }, [property])
+
+  useEffect(() => {
+    if (internalStatus === 'ready') {
+      readFromDb()
+    }
+  }, [internalStatus])
+
+  // useEffect(() => {
+  //   eventEmitter.addListener(
+  //     `property.${seedUid || seedLocalId}.${propertyName}.update`,
+  //     (event) => {
+  //       refresh()
+  //     },
+  //   )
+  //
+  //   return () => {
+  //     eventEmitter.removeListener(
+  //       `property.${seedUid || seedLocalId}.${propertyName}.update`,
+  //     )
+  //   }
+  // }, [])
+
+  return {
+    property,
+    isInitialized,
+    isReadingFromDb,
+    value,
+    status,
+  }
+}
+export const useItemProperties = (item?: Item<any>) => {
+  const [propertyObj, setPropertyObj] = useImmer({})
+  const [isListening, setIsListening] = useState(false)
+
+  const updatePropertyObj = useCallback(
+    (event) => {
+      if (!item) {
+        console.error('[XXXXXX] [updatePropertyObj] no item when expected')
+        return
+      }
+      const { propertyName, propertyValue } = event
+      if (!propertyName) {
+        return
+      }
+      setPropertyObj((draft) => {
+        draft[propertyName] = propertyValue
+      })
+    },
+    [item],
+  )
+
+  useEffect(() => {
+    if (!item) {
+      return
+    }
+
+    const eventKey = `item.${item.seedLocalId}.property.update`
+
+    eventEmitter.addListener(eventKey, updatePropertyObj)
+
+    return () => {
+      eventEmitter.removeListener(eventKey, updatePropertyObj)
+    }
+  }, [item])
+
+  return {
+    properties: propertyObj,
+  }
+}

package/dist/src/propertyMachine.ts

@@ -0,0 +1,154 @@
+import { assign, setup } from 'xstate'
+import { PropertyMachineContext } from '@/types'
+
+import { resolveRemoteStorage } from '@/browser/property/actors/resolveRemoteStorage'
+import { waitForDb } from '@/browser/property/actors/waitForDb'
+import { initialize } from '@/browser/property/actors/initialize'
+import { resolveRelatedValue } from '@/browser/property/actors/resolveRelatedValue'
+import { hydrateFromDb } from '@/browser/property/actors/hydrateFromDb'
+import { saveValueToDb } from '@/browser/property/actors/saveValueToDb'
+import { updateMachineContext } from '@/browser/helpers'
+
+export const propertyMachine = setup({
+  types: {
+    context: {} as PropertyMachineContext,
+  },
+  actors: {
+    waitForDb,
+    hydrateFromDb,
+    initialize,
+    resolveRelatedValue,
+    resolveRemoteStorage,
+    saveValueToDb,
+  },
+}).createMachine({
+  id: 'itemProperty',
+  initial: 'waitingForDb',
+  context: ({ input }) => input as PropertyMachineContext,
+  on: {
+    updatePropertyValue: {
+      target: '.resolvingRelatedValue',
+      guard: ({ context }) => !context.isDbReady,
+      actions: assign(({ event }) => {
+        return {
+          propertyValue: event.propertyValue,
+        }
+      }),
+    },
+    updateRenderValue: {
+      actions: assign(({ event, context }) => {
+        return {
+          renderValue: event.renderValue,
+        }
+      }),
+    },
+    save: {
+      actions: assign({
+        isSaving: true,
+      }),
+      target: '.saving',
+    },
+    updateContext: updateMachineContext,
+  },
+  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({
+            resolvedDisplayValue: ({ event }) => event.resolvedDisplayValue,
+            resolvedValue: ({ event }) => event.resolvedValue,
+          }),
+        },
+        resolvingRelatedValueDone: {
+          target: 'idle',
+        },
+      },
+      invoke: {
+        src: 'resolveRelatedValue',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    resolvingRemoteStorage: {
+      on: {
+        resolveRemoteStorageSuccess: {
+          target: 'idle',
+        },
+      },
+      invoke: {
+        src: 'resolveRemoteStorage',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    saving: {
+      on: {
+        saveValueToDbSuccess: {
+          target: 'idle',
+          actions: assign({
+            isSaving: false,
+          }),
+        },
+        saveValueToDbFailure: {
+          target: 'idle',
+          actions: assign({
+            isSaving: false,
+          }),
+        },
+      },
+      invoke: {
+        src: 'saveValueToDb',
+        input: ({ context, event }) => ({ context, event }),
+      },
+    },
+  },
+
+  // conflict: {
+  //   on: {
+  //     resolveConflict: {
+  //       target: 'saving',
+  //       actions: assign({
+  //         data: ({ context, event }) => event.output,
+  //       }),
+  //     },
+  //   },
+  // },
+})

package/dist/src/publish.ts

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

package/dist/src/publishMachine.ts

@@ -0,0 +1,77 @@
+import { setup } from 'xstate'
+import { validateItemData } from './actors/validateItemData'
+import { PublishMachineStates } from '@/browser/services/internal/constants'
+import { PublishMachineContext } from '@/types'
+import { createPublishAttempt } from './actors/createPublishAttempt'
+import { updateMachineContext } from '@/browser/helpers'
+import { preparePublishRequestData } from '@/browser/services/publish/actors/preparePublishRequestData'
+import { upload } from '@/browser/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 '@/browser/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/read.ts

@@ -0,0 +1,174 @@
+import { PropertyData } from '@/types'
+import { startCase } from 'lodash-es'
+import { metadata, MetadataType } from '@/shared/seedSchema'
+import { and, eq, max, sql } from 'drizzle-orm'
+import { getAppDb, runQueryForStatement } from '@/browser/db/sqlWasmClient'
+
+export const getPropertyData = async (
+  propertyName: string,
+  seedLocalId?: string,
+  seedUid?: string,
+): Promise<PropertyData | undefined> => {
+  const appDb = getAppDb()
+
+  const queryBase = appDb.select().from(metadata)
+
+  if (seedLocalId) {
+    queryBase.where(
+      and(
+        eq(metadata.propertyName, propertyName),
+        eq(metadata.seedLocalId, seedLocalId),
+      ),
+    )
+  }
+
+  if (seedUid) {
+    queryBase.where(
+      and(
+        eq(metadata.propertyName, propertyName),
+        eq(metadata.seedUid, seedUid),
+      ),
+    )
+  }
+
+  const rows = (await queryBase.orderBy(
+    sql.raw(`COALESCE(attestation_created_at, created_at) DESC`),
+  )) as MetadataType[]
+
+  if (!rows || rows.length === 0) {
+    return
+  }
+
+  const row = rows[0]
+
+  return {
+    ...row,
+    itemModelName: startCase(row.modelType),
+  }
+}
+
+const seedUidToStorageTransactionId = new Map<string, string>()
+
+type GetStorageTransactionIdResults = {
+  storageTransactionId: string
+}[]
+
+export const getStorageTransactionIdForSeedUid = async (
+  seedUid: string,
+): Promise<string | undefined> => {
+  if (seedUidToStorageTransactionId.has(seedUid)) {
+    return seedUidToStorageTransactionId.get(seedUid)
+  }
+
+  const appDb = getAppDb()
+
+  const results = (await appDb
+    .select({
+      storageTransactionId: metadata.propertyValue,
+    })
+    .from(metadata)
+    .where(
+      and(
+        eq(metadata.seedUid, seedUid),
+        eq(metadata.propertyName, 'storageTransactionId'),
+      ),
+    )) as GetStorageTransactionIdResults
+
+  if (!results || results.length === 0) {
+    return
+  }
+
+  seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId)
+  return results[0].storageTransactionId
+}
+
+export const getRelationValueData = async (
+  propertyValue: any,
+): Promise<MetadataType | undefined> => {
+  const appDb = getAppDb()
+
+  const rows = (await appDb
+    .select({
+      propertyValue: metadata.propertyValue,
+      attestationCreatedAt: max(metadata.attestationCreatedAt),
+      refResolvedDisplayValue: metadata.refResolvedDisplayValue,
+      refResolvedValue: metadata.refResolvedValue,
+      refSeedType: metadata.refSeedType,
+      easDataType: metadata.easDataType,
+    })
+    .from(metadata)
+    .where(eq(metadata.propertyValue, propertyValue))) as MetadataType[]
+
+  if (!rows || rows.length === 0) {
+    return
+  }
+
+  return rows[0]
+}
+
+type GetExistingItemProps = {
+  seedLocalId: string
+  seedUid: string
+}
+
+type GetExistingItemReturn = {
+  seedLocalId: string
+  seedUid: string
+  createdAt: string
+}
+
+type GetExistingItem = (
+  props: GetExistingItemProps,
+) => Promise<GetExistingItemReturn | undefined>
+
+export const getExistingItem: GetExistingItem = async ({
+  seedLocalId,
+  seedUid,
+}) => {
+  const existingItemStatement = `SELECT local_id, uid, created_at
+                                 FROM seeds
+                                 WHERE (uid IS NOT NULL
+                                     AND uid != ''
+                                     AND uid != 'undefined'
+                                     AND uid != 'null'
+                                     AND uid != 'false'
+                                     AND uid != '0'
+                                     AND uid != 0
+                                     AND uid = '${seedUid}'
+                                     )
+                                    OR (
+                                     local_id IS NOT NULL
+                                         AND local_id != ''
+                                         AND local_id != 'undefined'
+                                         AND local_id != 'null'
+                                         AND local_id != 'false'
+                                         AND local_id != '0'
+                                         AND local_id != 0
+                                         AND local_id = '${seedLocalId}'
+                                     );
+  `
+
+  const { rows } = await runQueryForStatement(existingItemStatement)
+
+  let existingItem
+
+  if (rows && rows.length > 0) {
+    // We know the zero index is versionLocalId because we specifically asked for it first
+    // in the SELECT statement above. Same with the rest of the indexes.
+    let matchingRow = rows.find((row) => row[1] === seedUid)
+
+    if (!matchingRow) {
+      matchingRow = rows.find((row) => row[0] === seedLocalId)
+    }
+
+    if (matchingRow) {
+      existingItem = {
+        seedLocalId: matchingRow[0],
+        seedUid: matchingRow[1],
+        createdAt: matchingRow[2],
+      }
+    }
+  }
+
+  return existingItem
+}

package/dist/src/recoverDeletedItem.ts

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