@seedprotocol/sdk 0.1.46 → 0.1.48

package/dist/src/fetchDbData.ts

@@ -0,0 +1,16 @@
+import { EventObject, fromCallback } from 'xstate'
+import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+
+export const fetchDbData = fromCallback<EventObject, typeof itemMachineAll>(
+  ({ sendBack, input: { context } }) => {
+    const { modelNamePlural, times } = context
+
+    const _fetchDbData = async (): Promise<void> => {}
+
+    _fetchDbData().then(() => {
+      sendBack({ type: 'fetchDbDataSuccess' })
+    })
+
+    return () => {}
+  },
+)

package/dist/src/fetchRelatedItems.ts

@@ -0,0 +1,179 @@
+import { EventObject, fromCallback } from 'xstate'
+import {
+  GET_ALL_PROPERTIES_FOR_ALL_VERSIONS,
+  GET_SEED_IDS,
+  GET_VERSIONS,
+} from '@/browser/item/queries'
+import {
+  models as modelsTable,
+  modelUids,
+  PropertyType,
+} from '@/shared/seedSchema'
+import { Attestation } from '@/browser/gql/graphql'
+import {
+  AllItemsMachineContext,
+  FromCallbackInput,
+  ModelClassType,
+} from '@/types'
+import { getAddressesFromDb } from '@/shared/helpers/db'
+import { eq } from 'drizzle-orm'
+import { easClient, queryClient } from '@/browser/helpers'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+export const fetchRelatedItems = fromCallback<
+  EventObject,
+  FromCallbackInput<AllItemsMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { ModelClass, modelName } = context
+
+  const appDb = getAppDb()
+
+  const relatedProperties = new Map<string, PropertyType>()
+  const relatedVersionsBySeedUid = new Map<string, Attestation[]>()
+  const schemaUidsByModelName = new Map<string, string>()
+  const mostRecentVersionsBySeedUid = new Map<string, Attestation>()
+  const mostRecentPropertiesBySeedUid = new Map<string, Attestation[]>()
+  const seedUidsByMostRecentVersionUid = new Map<string, string>()
+
+  const _fetchRelatedItems = async () => {
+    // Get related properties
+    for (const [propertyName, propertyDef] of Object.entries(
+      (ModelClass as ModelClassType).schema,
+    )) {
+      if (propertyDef && propertyDef.ref && propertyDef.refModelId) {
+        relatedProperties.set(propertyName, propertyDef)
+      }
+    }
+
+    const addresses = await getAddressesFromDb(appDb)
+
+    // Get the models they point to from sdkConfigDb
+    for (const [propertyName, propertyDef] of relatedProperties.entries()) {
+      const relatedModelQuery = await appDb
+        .select({
+          id: modelsTable.id,
+          name: modelsTable.name,
+          uid: modelUids.uid,
+        })
+        .from(modelsTable)
+        .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
+        .where(eq(modelsTable.id, propertyDef.refModelId))
+        .limit(1)
+
+      if (relatedModelQuery && relatedModelQuery.length > 0) {
+        const relatedModel = relatedModelQuery[0]
+        const relatedModelUid = relatedModel.uid
+        // Exclude the current model's schemaUid since we already have its versions
+        if (relatedModelUid && relatedModelUid !== ModelClass.schemaUid) {
+          schemaUidsByModelName.set(relatedModel.name, relatedModelUid)
+        }
+      }
+    }
+
+    const queryKey = [`getRelatedSeedIds${modelName}`]
+
+    const { itemSeedIds: relatedSeedIdAttestations } =
+      await queryClient.fetchQuery({
+        queryKey,
+        queryFn: async () =>
+          easClient.request(GET_SEED_IDS, {
+            where: {
+              schema: {
+                is: {
+                  id: {
+                    in: Array.from(schemaUidsByModelName.values()),
+                  },
+                },
+              },
+              attester: {
+                in: addresses,
+              },
+            },
+          }),
+      })
+
+    const relatedSeedIds = relatedSeedIdAttestations.map((seed) => seed.id)
+
+    const { itemVersions: relatedVersions } = await queryClient.fetchQuery({
+      queryKey: [`getRelatedVersions${modelName}`],
+      queryFn: async () =>
+        easClient.request(GET_VERSIONS, {
+          where: {
+            refUID: {
+              in: relatedSeedIds,
+            },
+            attester: {
+              in: addresses,
+            },
+          },
+        }),
+    })
+
+    // Index versions by seedUid
+    for (const version of relatedVersions) {
+      const existingVersionsForSeedUid =
+        relatedVersionsBySeedUid.get(version.refUID) || []
+      existingVersionsForSeedUid.push(version)
+      relatedVersionsBySeedUid.set(version.refUID, existingVersionsForSeedUid)
+    }
+
+    // Sort the indexed versions by timeCreated and index the most recent
+    for (const [
+      seedUid,
+      versionsForSeed,
+    ] of relatedVersionsBySeedUid.entries()) {
+      const versionsForSeedSorted = versionsForSeed.sort(
+        (a: Attestation, b: Attestation) => {
+          return a.timeCreated - b.timeCreated
+        },
+      )
+      relatedVersionsBySeedUid.set(seedUid, versionsForSeedSorted)
+      mostRecentVersionsBySeedUid.set(seedUid, versionsForSeedSorted[0])
+      seedUidsByMostRecentVersionUid.set(versionsForSeedSorted[0].id, seedUid)
+    }
+
+    // Extract the ids of the most recent versions
+    const mostRecentVersionIds = Array.from(
+      mostRecentVersionsBySeedUid.values(),
+    ).map((version) => version.id)
+
+    const { allProperties } = await queryClient.fetchQuery({
+      queryKey: [`getAllProperties${modelName}`],
+      queryFn: async () =>
+        easClient.request(GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, {
+          where: {
+            refUID: {
+              in: mostRecentVersionIds,
+            },
+            attester: {
+              in: addresses,
+            },
+          },
+        }),
+    })
+
+    for (const propertyAttestation of allProperties) {
+      const seedUidForProperty = seedUidsByMostRecentVersionUid.get(
+        propertyAttestation.refUID,
+      )
+      const existingPropertiesForSeedUid =
+        mostRecentPropertiesBySeedUid.get(seedUidForProperty!) || []
+      existingPropertiesForSeedUid.push(propertyAttestation)
+      mostRecentPropertiesBySeedUid.set(
+        seedUidForProperty!,
+        existingPropertiesForSeedUid,
+      )
+    }
+  }
+
+  _fetchRelatedItems().then(() => {
+    sendBack({
+      type: 'fetchRelatedItemsSuccess',
+      mostRecentPropertiesBySeedUid,
+      relatedVersionsBySeedUid,
+      relatedProperties,
+      schemaUidsByModelName,
+    })
+    return
+  })
+})

package/dist/src/fetchSeeds.ts

@@ -0,0 +1,44 @@
+import { EventObject, fromCallback } from 'xstate'
+import { GET_SEEDS } from '@/browser/item/queries'
+import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { Attestation } from '@/browser/gql/graphql'
+import { easClient, queryClient } from '@/browser/helpers'
+import debug from 'debug'
+
+const logger = debug('app:allItemsActors:fetchSeeds')
+
+export const fetchSeeds = fromCallback<EventObject, typeof itemMachineAll>(
+  ({ sendBack, input: { context } }) => {
+    const { queryVariables, modelName } = context
+
+    if (!queryVariables) {
+      throw new Error('No queryVariables found')
+    }
+
+    let itemSeeds: Attestation[] | undefined
+
+    const _fetchSeeds = async () => {
+      const queryKey = [`getSeeds${modelName}`]
+
+      const cachedResults = queryClient.getQueryData(queryKey)
+
+      logger(
+        `[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`,
+        cachedResults,
+      )
+
+      const results = await queryClient.fetchQuery({
+        queryKey,
+        queryFn: async () => easClient.request(GET_SEEDS, queryVariables),
+      })
+
+      itemSeeds = results.itemSeeds
+    }
+
+    _fetchSeeds().then(() => {
+      sendBack({ type: 'fetchSeedsSuccess', itemSeeds })
+    })
+
+    return () => {}
+  },
+)

package/dist/src/fetchVersions.ts

@@ -0,0 +1,41 @@
+import { EventObject, fromCallback } from 'xstate'
+import { GET_VERSIONS } from '@/browser/item/queries'
+import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { Attestation } from '@/browser/gql/graphql'
+import { easClient, queryClient } from '@/browser/helpers'
+
+export const fetchVersions = fromCallback<EventObject, typeof itemMachineAll>(
+  ({ sendBack, input: { context } }) => {
+    const { itemSeeds, modelName } = context
+
+    if (!itemSeeds) {
+      throw new Error('No queryVariables found')
+    }
+
+    let itemVersions: Attestation[] | undefined
+
+    const _fetchVersions = async () => {
+      const seedIds = itemSeeds.map((seed) => seed.id)
+
+      const results = await queryClient.fetchQuery({
+        queryKey: [`getVersions${modelName}`],
+        queryFn: async () =>
+          easClient.request(GET_VERSIONS, {
+            where: {
+              refUID: {
+                in: seedIds,
+              },
+            },
+          }),
+      })
+
+      itemVersions = results.itemVersions
+    }
+
+    _fetchVersions().then(() => {
+      sendBack({ type: 'fetchVersionsSuccess', itemVersions })
+    })
+
+    return () => {}
+  },
+)

package/dist/src/files.ts

@@ -0,0 +1,16 @@
+export const listFilesInOPFSRoot = async () => {
+  // Get the root directory handle
+  const rootDirHandle = await navigator.storage.getDirectory()
+
+  // Initialize an array to hold the file names
+  let fileNames = []
+
+  // Create an async iterator to loop through directory entries
+  for await (const entry of rootDirHandle.values()) {
+    if (entry.kind === 'file') {
+      fileNames.push(entry.name)
+    }
+  }
+
+  return fileNames
+}

package/dist/src/fragment-masking.ts

@@ -0,0 +1,87 @@
+/* eslint-disable */
+import { ResultOf, DocumentTypeDecoration, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { FragmentDefinitionNode } from 'graphql';
+import { Incremental } from './graphql';
+
+
+export type FragmentType<TDocumentType extends DocumentTypeDecoration<any, any>> = TDocumentType extends DocumentTypeDecoration<
+  infer TType,
+  any
+>
+  ? [TType] extends [{ ' $fragmentName'?: infer TKey }]
+    ? TKey extends string
+      ? { ' $fragmentRefs'?: { [key in TKey]: TType } }
+      : never
+    : never
+  : never;
+
+// return non-nullable if `fragmentType` is non-nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>>
+): TType;
+// return nullable if `fragmentType` is undefined
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | undefined
+): TType | undefined;
+// return nullable if `fragmentType` is nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null
+): TType | null;
+// return nullable if `fragmentType` is nullable or undefined
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null | undefined
+): TType | null | undefined;
+// return array of non-nullable if `fragmentType` is array of non-nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>>
+): Array<TType>;
+// return array of nullable if `fragmentType` is array of nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined
+): Array<TType> | null | undefined;
+// return readonly array of non-nullable if `fragmentType` is array of non-nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>>
+): ReadonlyArray<TType>;
+// return readonly array of nullable if `fragmentType` is array of nullable
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined
+): ReadonlyArray<TType> | null | undefined;
+export function useFragment<TType>(
+  _documentNode: DocumentTypeDecoration<TType, any>,
+  fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | Array<FragmentType<DocumentTypeDecoration<TType, any>>> | ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined
+): TType | Array<TType> | ReadonlyArray<TType> | null | undefined {
+  return fragmentType as any;
+}
+
+
+export function makeFragmentData<
+  F extends DocumentTypeDecoration<any, any>,
+  FT extends ResultOf<F>
+>(data: FT, _fragment: F): FragmentType<F> {
+  return data as FragmentType<F>;
+}
+export function isFragmentReady<TQuery, TFrag>(
+  queryNode: DocumentTypeDecoration<TQuery, any>,
+  fragmentNode: TypedDocumentNode<TFrag>,
+  data: FragmentType<TypedDocumentNode<Incremental<TFrag>, any>> | null | undefined
+): data is FragmentType<typeof fragmentNode> {
+  const deferredFields = (queryNode as { __meta__?: { deferredFields: Record<string, (keyof TFrag)[]> } }).__meta__
+    ?.deferredFields;
+
+  if (!deferredFields) return true;
+
+  const fragDef = fragmentNode.definitions[0] as FragmentDefinitionNode | undefined;
+  const fragName = fragDef?.name?.value;
+
+  const fields = (fragName && deferredFields[fragName]) || [];
+  return fields.length > 0 && fields.every(field => data && field in data);
+}

package/dist/src/fsProxy.ts

@@ -0,0 +1,36 @@
+// File: fsProxy.js
+let actualFs = {} // Empty placeholder for the real implementation
+
+let resolveFsReady
+const fsReady = new Promise((resolve) => {
+  resolveFsReady = resolve
+})
+
+// Create a proxy object that intercepts all accesses to `fs`
+const fsProxy = new Proxy(actualFs, {
+  get(target, prop) {
+    if (prop.endsWith('Sync')) {
+      return (...args) => {
+        actualFs[prop](...args)
+      }
+    }
+
+    return async (...args) => {
+      await fsReady
+      if (typeof actualFs[prop] === 'function') {
+        return actualFs[prop](...args)
+      } else {
+        return actualFs[prop]
+      }
+    }
+  },
+})
+
+const setFsImplementation = (configuredFs) => {
+  Object.assign(actualFs, configuredFs)
+  resolveFsReady() // Resolve the promise to signal fs is ready
+}
+
+export { setFsImplementation }
+
+export default fsProxy

package/dist/src/getItem.ts

@@ -0,0 +1,189 @@
+import { Item } from '@/browser/item'
+
+import { getItemProperties } from '@/browser/db/read/getItemProperties'
+import { getSeedData } from '@/browser/db/read/getSeedData'
+import debug from 'debug'
+import { ItemData } from '@/types'
+import { getAppDb } from '../sqlWasmClient'
+import { seeds, versions } from '@/shared/seedSchema'
+import {
+  and,
+  count,
+  eq,
+  getTableColumns,
+  isNull,
+  max,
+  or,
+  SQL,
+} from 'drizzle-orm'
+
+const logger = debug('app:db:queries:getItem')
+
+type GetItemDataFromDbParams = {
+  modelName?: string
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type GetItemDataFromDb = (
+  params: GetItemDataFromDbParams,
+) => Promise<ItemData | undefined>
+
+export const getItemDataFromDb: GetItemDataFromDb = async ({
+  modelName,
+  seedLocalId,
+  seedUid,
+}) => {
+  if (!seedLocalId && !seedUid) {
+    throw new Error('[db/queries] [getItem] no seedLocalId or seedUid')
+  }
+
+  if (seedUid && !seedLocalId) {
+    const seedData = await getSeedData({ seedUid })
+    if (!seedData) {
+      logger('[db/queries] [getItem] no seedData seedUid', seedUid)
+      return
+    }
+    seedLocalId = seedData.localId
+  }
+
+  const appDb = getAppDb()
+
+  const { localId, uid, ...rest } = getTableColumns(seeds)
+
+  const whereClauses: SQL[] = []
+
+  if (modelName) {
+    whereClauses.push(eq(seeds.type, modelName.toLowerCase()))
+  }
+
+  const uidWhereClause: SQL = seedUid
+    ? eq(seeds.uid, seedUid)
+    : isNull(seeds.uid)
+  const localWhereClause: SQL = seedLocalId
+    ? eq(seeds.localId, seedLocalId)
+    : isNull(seeds.localId)
+
+  whereClauses.push(or(localWhereClause, uidWhereClause) as SQL)
+
+  const latestVersions = appDb.$with('latestVersions').as(
+    appDb
+      .select({
+        localId: versions.localId,
+        uid: versions.uid,
+        seedLocalId: versions.seedLocalId,
+        seedUid: versions.seedUid,
+      })
+      .from(versions)
+      .groupBy(versions.seedLocalId),
+  )
+
+  const itemDataRows = await appDb
+    .with(latestVersions)
+    .select({
+      ...rest,
+      seedLocalId: seeds.localId,
+      seedUid: seeds.uid,
+      versionsCount: count(versions.localId),
+      lastVersionPublishedAt: max(versions.attestationCreatedAt),
+      latestVersionUid: latestVersions.uid,
+    })
+    .from(seeds)
+    .leftJoin(versions, eq(versions.seedLocalId, seeds.localId))
+    .leftJoin(
+      latestVersions,
+      eq(versions.seedLocalId, latestVersions.seedLocalId),
+    )
+    .where(and(...whereClauses))
+    .groupBy(seeds.localId)
+
+  if (!itemDataRows || itemDataRows.length === 0) {
+    logger('[db/queries] [getItemDataFromDb] no itemDataRows')
+    return
+  }
+
+  let itemData = itemDataRows[0]
+
+  const propertiesData = await getItemProperties({ seedLocalId, seedUid })
+
+  // const initObj: ItemData = {
+  //   seedLocalId,
+  //   seedUid,
+  //   modelName,
+  // }
+
+  if (!propertiesData || propertiesData.length === 0) {
+    return itemData
+  }
+
+  const firstPropertyData = propertiesData[0]
+
+  for (const propertyData of propertiesData) {
+    const propertyName = propertyData.propertyName
+
+    const propertyValue = propertyData.propertyValue
+
+    // TODO: Find a better place for the property data below
+    // Since initObj is used to initialize an Item, the following values
+    // just overwrite each other for each property since they are Property
+    // specific.
+
+    // const refSeedType = propertyDbValues[11]
+    // if (refSeedType) {
+    //   initObj.refSeedType = refSeedType
+    // }
+    // const refValueType = propertyDbValues[12]
+    // if (refValueType) {
+    //   initObj.refValueType = refValueType
+    // }
+    //
+    // if (
+    //   refSeedType &&
+    //   refValueType === 'list' &&
+    //   propertyName.endsWith('Ids')
+    // ) {
+    //   logger('[db/queries] [getItemDataFromDb] propertyName', propertyName)
+    // }
+
+    itemData[propertyName] = propertyValue
+  }
+
+  return itemData
+}
+
+type GetItemParams = {
+  modelName?: string
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type GetItem = (params: GetItemParams) => Promise<Item<any> | undefined>
+
+export const getItem: GetItem = async ({ modelName, seedLocalId, seedUid }) => {
+  const itemInitObj = await getItemDataFromDb({
+    modelName,
+    seedLocalId,
+    seedUid,
+  })
+
+  if (!itemInitObj) {
+    console.error(
+      `[db/queries] [getItem] no itemInitObj modelName: ${modelName} seedLocalId: ${seedLocalId} seedUid: ${seedUid}`,
+    )
+    return
+  }
+
+  if (!itemInitObj.seedLocalId) {
+    console.error(
+      `[db/queries] [getItem] no itemInitObj.seedLocalId modelName: ${modelName} seedLocalId: ${seedLocalId} seedUid: ${seedUid}`,
+    )
+    return
+  }
+
+  console.log(
+    `[${modelName}.${seedLocalId}] [getItem] Creating Item`,
+    itemInitObj,
+  )
+
+  return Item.create(itemInitObj)
+}