@seedprotocol/sdk 0.1.128 → 0.2.0

package/dist/src/item.ts

@@ -1,374 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
-import { createNewItem } from '@/browser/db/write'
-import { Item } from '@/browser/item'
-import { eventEmitter } from '@/eventBus'
-import { useImmer } from 'use-immer'
-import { orderBy } from 'lodash-es'
-import { getAreItemEventHandlersReady } from '@/browser/events'
-import debug from 'debug'
-import { useGlobalServiceStatus } from '@/browser/react/services'
-import { ModelValues } from '@/types'
-import { Subscription } from 'xstate'
-import { useSelector } from '@xstate/react'
-
-const logger = debug('app:react:item')
-
-type UseItemProps = {
-  modelName: string
-  seedLocalId?: string
-  seedUid?: string
-}
-
-type UseItemReturn<T extends ModelValues<T>> = {
-  item: Item<T> | undefined
-  itemData: ItemData<T>
-  itemStatus: string | Record<string, unknown> | undefined
-}
-
-type UseItem<T> = (props: UseItemProps) => UseItemReturn<T>
-
-type ItemData<T> = Record<string, Partial<T>>
-
-export const useItem: UseItem<any> = ({ modelName, seedLocalId, seedUid }) => {
-  // const [itemSubscription, setItemSubscription] = useState<
-  //   Subscription | undefined
-  // >()
-  //
-  // const queryClient = useQueryClient()
-  //
-  // const { data: item } = useQuery({
-  //   queryKey: ['item', modelName, seedLocalId, seedUid],
-  //   queryFn: async () =>
-  //     Item.find({
-  //       modelName,
-  //       seedLocalId,
-  //       seedUid,
-  //     }),
-  //   networkMode: 'offlineFirst',
-  // })
-  //
-  // const updateItem = async (newItem: Item<any>) => {
-  //   queryClient.setQueryData(['item', modelName, seedLocalId, seedUid], newItem)
-  // }
-  //
-  // useEffect(() => {
-  //   if (item && item.subscribe && !itemSubscription) {
-  //     const subscription = item.subscribe(async (_) => {
-  //       const newItem = await Item.find({ modelName, seedLocalId, seedUid })
-  //       if (!newItem) {
-  //         logger(
-  //           '[useItem] [itemSubscription] no item found',
-  //           modelName,
-  //           seedLocalId,
-  //         )
-  //         return
-  //       }
-  //       updateItem(newItem)
-  //     })
-  //     setItemSubscription(subscription)
-  //   }
-  //
-  //   return () => {
-  //     itemSubscription?.unsubscribe()
-  //   }
-  // }, [item, itemSubscription])
-  //
-  // return {
-  //   item,
-  //   itemData: {},
-  //   itemStatus: undefined,
-  // }
-
-  const [itemData, setItemData] = useImmer<ItemData<any>>({})
-  const [item, setItem] = useState<Item<any> | undefined>()
-  const [itemSubscription, setItemSubscription] = useState<
-    Subscription | undefined
-  >()
-
-  const { status, internalStatus } = useGlobalServiceStatus()
-
-  const isReadingDb = useRef(false)
-
-  const itemStatus = useSelector(
-    item?.getService(),
-    (snapshot) => snapshot?.value,
-  )
-
-  const updateItem = useCallback(
-    (newItem: Item<any>) => {
-      setItemData((draft) => {
-        Object.keys(newItem.properties).forEach((propertyName) => {
-          const value = newItem[propertyName]
-          draft[propertyName] = value
-        })
-      })
-    },
-    [setItemData],
-  )
-
-  const readFromDb = useCallback(async () => {
-    if (
-      isReadingDb.current ||
-      internalStatus !== 'ready' ||
-      (!seedUid && !seedLocalId)
-    ) {
-      return
-    }
-    isReadingDb.current = true
-    const foundItem = await Item.find({
-      modelName,
-      seedLocalId,
-      seedUid,
-    })
-    if (!foundItem) {
-      logger('[useItem] [getItemFromDb] no item found', modelName, seedLocalId)
-      isReadingDb.current = false
-      return
-    }
-    setItem(() => foundItem)
-    updateItem(foundItem)
-    isReadingDb.current = false
-  }, [internalStatus])
-
-  const listenerRef = useRef(readFromDb)
-
-  useEffect(() => {
-    listenerRef.current = readFromDb
-  }, [readFromDb])
-
-  useEffect(() => {
-    if (internalStatus === 'ready') {
-      listenerRef.current()
-    }
-  }, [internalStatus, status])
-
-  useEffect(() => {
-    if (item && !itemSubscription) {
-      const subscription = item.subscribe(async (_) => {
-        const newItem = await Item.find({ modelName, seedLocalId, seedUid })
-        if (!newItem) {
-          logger(
-            '[useItem] [itemSubscription] no item found',
-            modelName,
-            seedLocalId,
-          )
-          return
-        }
-        updateItem(newItem)
-        setItem(() => newItem)
-      })
-      setItemSubscription(subscription)
-    }
-
-    return () => {
-      itemSubscription?.unsubscribe()
-    }
-  }, [item, itemSubscription])
-
-  useEffect(() => {
-    const seedId = seedUid || seedLocalId
-
-    eventEmitter.addListener(`item.${modelName}.${seedId}.update`, () => {
-      listenerRef.current()
-    })
-
-    return () => {
-      eventEmitter.removeListener(`item.${modelName}.${seedId}.update`)
-    }
-  }, [])
-
-  return {
-    item,
-    itemData,
-    itemStatus,
-  }
-}
-type UseItemsReturn = {
-  items: Item<any>[]
-  isReadingDb: boolean
-}
-type UseItemsProps = {
-  modelName?: string
-  deleted?: boolean
-}
-type UseItems = (props: UseItemsProps) => UseItemsReturn
-export const useItems: UseItems = ({ modelName, deleted }) => {
-  const [items, setItems] = useImmer<Item<any>[]>([])
-
-  const { status, internalStatus } = useGlobalServiceStatus()
-
-  const modelNameRef = useRef<string | undefined>(modelName)
-
-  const isReadingDb = useRef(false)
-
-  const readFromDb = useCallback(async () => {
-    if (isReadingDb.current || internalStatus !== 'ready') {
-      return
-    }
-    isReadingDb.current = true
-    const allItems = await Item.all(modelNameRef.current, deleted)
-    setItems(() => [])
-    setItems(() => allItems)
-    isReadingDb.current = false
-  }, [internalStatus])
-
-  const listenerRef = useRef(readFromDb)
-
-  useEffect(() => {
-    listenerRef.current = readFromDb
-  }, [readFromDb])
-
-  useEffect(() => {
-    if (internalStatus === 'ready') {
-      listenerRef.current()
-    }
-  }, [internalStatus, status])
-
-  useEffect(() => {
-    eventEmitter.addListener('item.requestAll', (event) => {
-      if (
-        !event ||
-        !event.modelName ||
-        event.modelName !== modelNameRef.current
-      ) {
-        return
-      }
-      listenerRef.current()
-    })
-
-    return () => {
-      eventEmitter.removeListener('item.requestAll', readFromDb)
-    }
-  }, [])
-
-  return {
-    items: orderBy(
-      items,
-      [
-        (item) =>
-          item.lastVersionPublishedAt ||
-          item.attestationCreatedAt ||
-          item.createdAt,
-      ],
-      ['desc'],
-    ),
-    isReadingDb,
-  }
-}
-export const useItemIsReady = () => {
-  const [itemListenersReady, setItemListenersReady] = useState(false)
-
-  const itemEventListenersHandler = useCallback((_) => {
-    setItemListenersReady(true)
-  }, [])
-
-  useEffect(() => {
-    const areReady = getAreItemEventHandlersReady()
-
-    if (areReady) {
-      itemEventListenersHandler(true)
-    }
-
-    eventEmitter.addListener(
-      'item.events.setupAllItemsEventHandlers',
-      itemEventListenersHandler,
-    )
-
-    return () => {
-      eventEmitter.removeListener('item.events.setupAllItemsEventHandlers')
-    }
-  }, [])
-
-  return {
-    isReady: itemListenersReady,
-  }
-}
-export const useCreateItem = <T>(modelName: string) => {
-  const [isCreatingItem, setIsCreatingItem] = useState(false)
-
-  const { isReady } = useItemIsReady()
-
-  const createItem = useCallback(
-    async (itemData) => {
-      if (!isReady) {
-        console.error(
-          `[useCreateItem] [createItem] called before listeners are ready`,
-          itemData,
-        )
-        return
-      }
-      if (isCreatingItem) {
-        // TODO: should we setup a queue for this?
-        console.error(
-          `[useCreateItem] [createItem] already creating item`,
-          itemData,
-        )
-        return
-      }
-
-      setIsCreatingItem(true)
-
-      const { seedLocalId } = await createNewItem({ modelName, ...itemData })
-
-      const newItem = await Item.find({ modelName, seedLocalId })
-
-      eventEmitter.emit('item.requestAll', { modelName })
-
-      setIsCreatingItem(false)
-    },
-    [isCreatingItem, isReady],
-  )
-
-  return {
-    createItem,
-    isCreatingItem,
-  }
-}
-
-type PublishItemResult = Error | undefined | void
-
-type UsePublishItemReturn = {
-  publishItem: (
-    item: Item<any> | undefined,
-    callback: (result: PublishItemResult) => any,
-  ) => void
-  isPublishing: boolean
-}
-
-type PublishItemProps =
-  | [Item<any> | undefined]
-  | [Item<any> | undefined, (result: PublishItemResult) => any | undefined]
-
-type PublishItem = (...props: PublishItemProps) => Promise<any>
-
-export const usePublishItem = (): UsePublishItemReturn => {
-  const [isPublishing, setIsPublishing] = useState(false)
-
-  const isLocked = useRef(false)
-
-  const publishItem: PublishItem = useCallback(async (item, callback?) => {
-    if (!item || isLocked.current) {
-      return
-    }
-    isLocked.current = true
-    setIsPublishing(true)
-    try {
-      // await item.publish()
-      const payload = await item.getPublishPayload()
-      if (callback) {
-        callback()
-      }
-    } catch (e) {
-      if (callback) {
-        callback(e as Error)
-      }
-    }
-    setIsPublishing(false)
-    isLocked.current = false
-  }, [])
-
-  return {
-    publishItem,
-    isPublishing,
-  }
-}

package/dist/src/read.ts

@@ -1,174 +0,0 @@
-import { PropertyData } from '@/types'
-import { startCase } from 'lodash-es'
-import { metadata, MetadataType } from '@/shared/seedSchema'
-import { and, eq, max, or, 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 whereClauses: any[] = [
-    or(
-      eq(metadata.propertyName, propertyName),
-      eq(metadata.propertyName, propertyName + 'Id'),
-      eq(metadata.propertyName, propertyName + 'Ids'),
-    ),
-  ]
-
-  if (seedLocalId) {
-    whereClauses.push(eq(metadata.seedLocalId, seedLocalId))
-  }
-
-  if (seedUid) {
-    whereClauses.push(eq(metadata.seedUid, seedUid))
-  }
-
-  const rows = (await appDb
-    .select()
-    .from(metadata)
-    .where(and(...whereClauses))
-    .orderBy(
-      sql.raw(`COALESCE(attestation_created_at, created_at) DESC`),
-    )) as MetadataType[]
-
-  if (!rows || rows.length === 0) {
-    return
-  }
-
-  const row = rows[0]
-
-  return {
-    ...row,
-    modelName: 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/write.ts

@@ -1,115 +0,0 @@
-import { generateId } from '@/shared/helpers'
-import { ModelValues } from '@/types'
-import debug from 'debug'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
-import { MetadataType, seeds } from '@/shared/seedSchema'
-import { createVersion } from '@/browser/db/write/createVersion'
-import { createMetadata } from '@/browser/db/write/createMetadata'
-import { getModel } from '@/browser/stores/modelClass'
-import { getSchemaUidForModel } from '@/browser/db/read/getSchemaUidForModel'
-
-const logger = debug('app:write')
-
-type CreateSeedProps = {
-  type: string
-  seedUid?: string
-}
-
-type CreateSeed = (props: CreateSeedProps) => Promise<string>
-
-export const createSeed: CreateSeed = async ({ type, seedUid }) => {
-  const schemaUid = await getSchemaUidForModel(type)
-
-  if (!schemaUid) {
-    throw new Error(`No schema found for model type: ${type}`)
-  }
-
-  const appDb = getAppDb()
-
-  const newSeedLocalId = generateId()
-
-  await appDb.insert(seeds).values({
-    localId: newSeedLocalId,
-    type,
-    uid: seedUid,
-    createdAt: Date.now(),
-    schemaUid,
-  })
-
-  return newSeedLocalId
-}
-
-type CreateMetadataForExistingRecordProps = {
-  existingRecord: MetadataType
-  propertyName: string
-  propertyValue: any
-}
-
-type CreateMetadataForExistingRecord = (
-  props: CreateMetadataForExistingRecordProps,
-) => Promise<void>
-
-type CreateNewItemProps = Partial<ModelValues<any>> & {
-  modelName: string
-}
-
-type CreateNewItemReturnType = {
-  seedLocalId: string
-  versionLocalId: string
-}
-
-type CreateNewItem = (
-  props: CreateNewItemProps,
-) => Promise<CreateNewItemReturnType>
-
-export const createNewItem: CreateNewItem = async ({
-  modelName,
-  ...propertyData
-}) => {
-  if (!modelName) {
-    throw new Error('A model name is required for createNewItem')
-  }
-
-  const seedType = modelName.toLowerCase()
-
-  const newSeedId = await createSeed({ type: seedType })
-
-  const newVersionId = await createVersion({ seedLocalId: newSeedId })
-
-  const propertySchemas = getModel(modelName)?.schema
-
-  for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
-    let propertyRecordSchema
-
-    if (propertySchemas && propertySchemas[propertyName]) {
-      propertyRecordSchema = propertySchemas[propertyName]
-    }
-
-    await createMetadata(
-      {
-        seedLocalId: newSeedId,
-        versionLocalId: newVersionId,
-        propertyName,
-        propertyValue,
-        modelName,
-      },
-      propertyRecordSchema,
-    )
-    // await appDb.run(
-    //   sql.raw(
-    //     `INSERT INTO metadata (seed_local_id, version_local_id, property_name, property_value, model_type, created_at,
-    //                            attestation_created_at)
-    //      VALUES ('${newSeedId}', '${newVersionId}', '${propertyName}', '${propertyValue}', '${seedType}', ${Date.now()},
-    //              ${Date.now()});`,
-    //   ),
-    // )
-  }
-
-  // eventEmitter.emit(`item.requestAll`, { modelName })
-
-  return {
-    modelName,
-    seedLocalId: newSeedId,
-    versionLocalId: newVersionId,
-  }
-}

package/dist/types/src/browser/db/read/getItem.d.ts

@@ -1,18 +0,0 @@
-import { Item } from '@/browser/item';
-import { ItemData } from '@/types';
-type GetItemDataFromDbParams = {
-    modelName?: string;
-    seedLocalId?: string;
-    seedUid?: string;
-};
-type GetItemDataFromDb = (params: GetItemDataFromDbParams) => Promise<ItemData | undefined>;
-export declare const getItemDataFromDb: GetItemDataFromDb;
-type GetItemParams = {
-    modelName?: string;
-    seedLocalId?: string;
-    seedUid?: string;
-};
-type GetItem = (params: GetItemParams) => Promise<Item<any> | undefined>;
-export declare const getItem: GetItem;
-export {};
-//# sourceMappingURL=getItem.d.ts.map

package/dist/types/src/browser/db/read/getItem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getItem.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getItem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAKrC,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAQlC,KAAK,uBAAuB,GAAG;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,KAAK,iBAAiB,GAAG,CACvB,MAAM,EAAE,uBAAuB,KAC5B,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAA;AAElC,eAAO,MAAM,iBAAiB,EAAE,iBAuF/B,CAAA;AAED,KAAK,aAAa,GAAG;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,CAAA;AAExE,eAAO,MAAM,OAAO,EAAE,OAsBrB,CAAA"}

package/dist/types/src/browser/db/read/getItemProperties.d.ts

@@ -1,10 +0,0 @@
-import { PropertyData } from '@/types';
-type GetPropertiesForSeedProps = {
-    seedLocalId?: string;
-    seedUid?: string;
-    edited?: boolean;
-};
-type GetItemProperties = (props: GetPropertiesForSeedProps) => Promise<PropertyData[]>;
-export declare const getItemProperties: GetItemProperties;
-export {};
-//# sourceMappingURL=getItemProperties.d.ts.map

package/dist/types/src/browser/db/read/getItemProperties.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getItemProperties.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getItemProperties.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAKtC,KAAK,yBAAyB,GAAG;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,KAAK,iBAAiB,GAAG,CACvB,KAAK,EAAE,yBAAyB,KAC7B,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;AAE5B,eAAO,MAAM,iBAAiB,EAAE,iBAkD/B,CAAA"}

package/dist/types/src/browser/db/read/getItemProperty.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getItemProperty.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getItemProperty.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAG5D,KAAK,oBAAoB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;AAEjD,KAAK,mBAAmB,GAAG,CACzB,KAAK,EAAE,oBAAoB,KACxB,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA;AAEnC,eAAO,MAAM,mBAAmB,EAAE,mBAuBjC,CAAA"}

package/dist/types/src/browser/db/read/getItems.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getItems.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getItems.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAMlC,KAAK,iBAAiB,GAAG;IACvB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,KAAK,YAAY,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAA;AAErE,eAAO,MAAM,YAAY,EAAE,YAwD1B,CAAA"}