@seedprotocol/sdk 0.1.47 → 0.1.49

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)
+}

package/dist/src/getItemProperties.ts

@@ -0,0 +1,162 @@
+import { PropertyData } from '@/types'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { metadata, seeds, versions } from '@/shared/seedSchema'
+import {
+  and,
+  eq,
+  getTableColumns,
+  isNotNull,
+  isNull,
+  or,
+  SQL,
+} from 'drizzle-orm'
+
+type GetPropertiesForSeedProps = {
+  seedLocalId?: string
+  seedUid?: string
+  edited?: boolean
+}
+
+type GetItemProperties = (
+  props: GetPropertiesForSeedProps,
+) => Promise<PropertyData[]>
+
+export const getItemProperties: GetItemProperties = async ({
+  seedLocalId,
+  seedUid,
+  edited,
+}) => {
+  const appDb = getAppDb()
+
+  const whereClauses: SQL[] = [isNotNull(metadata.propertyName)]
+
+  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)
+  whereClauses.push(isNotNull(metadata.propertyName))
+  whereClauses.push(isNotNull(metadata.easDataType))
+
+  if (typeof edited !== 'undefined') {
+    if (edited) {
+      whereClauses.push(isNull(metadata.uid))
+    }
+    if (!edited) {
+      whereClauses.push(isNotNull(metadata.uid))
+    }
+  }
+
+  // if (!seedLocalId || !seedUid) {
+  //   const seedRows = await appDb
+  //     .select({
+  //       localId: seeds.localId,
+  //       uid: seeds.uid,
+  //     })
+  //     .from(seeds)
+  //     .where(or(localWhereClause, uidWhereClause))
+  //
+  //   if (seedRows && seedRows.length > 0) {
+  //     seedUid = seedRows[0].uid as string
+  //     seedLocalId = seedRows[0].localId as string
+  //   }
+  // }
+
+  const metadataColumns = getTableColumns(metadata)
+
+  const propertiesData = await appDb
+    .select({
+      ...metadataColumns,
+    })
+    .from(seeds)
+    .leftJoin(metadata, eq(metadata.seedLocalId, seeds.localId))
+    .leftJoin(versions, eq(versions.localId, seeds.localId))
+    .where(and(...whereClauses))
+    .groupBy(metadata.propertyName)
+
+  return propertiesData
+}
+
+// const localIdWhere = seedLocalId
+//   ? `s.local_id = '${seedLocalId}'`
+//   : 's.local_id IS NULL'
+// const uidWhere = seedUid ? `s.uid = '${seedUid}'` : 's.uid IS NULL'
+//
+// const queryStatement = `WITH LatestMetadata as (SELECT m.property_name,
+//                                                        m.property_value,
+//                                                        m.version_local_id,
+//                                                        MAX(m.attestation_created_at),
+//                                                        m.uid,
+//                                                        m.seed_local_id,
+//                                                        seed_uid
+//                                                 FROM metadata m
+//                                                          JOIN seeds s ON s.local_id = m.seed_local_id
+//                                                 GROUP BY m.property_name),
+//
+//                              LatestVersion as (SELECT v.local_id,
+//                                                       MAX(v.attestation_created_at) as attestation_created_at,
+//                                                       v.uid,
+//                                                       v.seed_local_id,
+//                                                       v.seed_uid
+//                                                FROM versions v
+//                                                         JOIN seeds s ON s.local_id = v.seed_local_id
+//                                                GROUP BY s.local_id)
+//
+//
+//                         SELECT s.local_id,
+//                                s.uid,
+//                                s.schema_uid,
+//                                m.property_name,
+//                                m.property_value,
+//                                COUNT(v.local_id) as versions_count,
+//                                m.model_type,
+//                                lv.attestation_created_at,
+//                                m.local_id,
+//                                m.uid,
+//                                MAX(m.attestation_created_at),
+//                                m.ref_seed_type,
+//                                m.ref_value_type,
+//                                m.seed_local_id,
+//                                m.seed_uid,
+//                                m.created_at,
+//                                m.updated_at,
+//                                m.version_uid
+//                         FROM seeds s
+//                                  JOIN LatestMetadata lm ON s.local_id = m.seed_local_id
+//                                  JOIN LatestVersion lv ON lv.seed_local_id = m.seed_local_id
+//                                  JOIN metadata m ON m.property_name = lm.property_name OR lm.property_value = s.uid
+//                                  JOIN versions v ON s.local_id = v.seed_local_id
+//                         WHERE ${localIdWhere}
+//                            OR ${uidWhere}
+//                         GROUP BY m.property_name;
+// `
+//
+// const { rows } = await runQueryForStatement(queryStatement)
+//
+// const propertiesDataOld: PropertyData[] = []
+//
+// for (const row of rows) {
+//   propertiesDataOld.push({
+//     localId: row[0],
+//     uid: row[1],
+//     schemaUid: row[2],
+//     propertyName: row[3],
+//     propertyValue: row[4],
+//     versionsCount: row[5],
+//     itemModelName: row[6],
+//     attestationCreatedAt: row[7],
+//     metadataLocalId: row[8],
+//     metadataUid: row[9],
+//     metadataAttestationCreatedAt: row[10],
+//     refSeedType: row[11],
+//     refValueType: row[12],
+//     seedLocalId: row[13],
+//     seedUid: row[14],
+//     createdAt: row[15],
+//     updatedAt: row[16],
+//     versionUid: row[17],
+//   })
+// }

package/dist/src/getItems.ts

@@ -0,0 +1,75 @@
+import { ItemData } from '@/types'
+import {
+  and,
+  count,
+  desc,
+  eq,
+  isNotNull,
+  isNull,
+  max,
+  or,
+  SQL,
+  sql,
+} from 'drizzle-orm'
+import { seeds, versions } from '@/shared/seedSchema'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+type GetItemsDataProps = {
+  modelName?: string
+  deleted?: boolean
+}
+
+type GetItemsData = (props: GetItemsDataProps) => Promise<ItemData[]>
+
+export const getItemsData: GetItemsData = async ({
+  modelName,
+  deleted,
+}): Promise<ItemData[]> => {
+  const appDb = getAppDb()
+
+  const conditions: SQL[] = []
+
+  if (modelName) {
+    conditions.push(eq(seeds.type, modelName.toLowerCase()))
+  }
+
+  if (deleted) {
+    conditions.push(
+      or(
+        isNotNull(seeds._markedForDeletion),
+        eq(seeds._markedForDeletion, 1),
+      ) as SQL,
+    )
+  }
+
+  if (!deleted) {
+    conditions.push(
+      or(
+        isNull(seeds._markedForDeletion),
+        eq(seeds._markedForDeletion, 0),
+      ) as SQL,
+    )
+  }
+
+  let query = appDb
+    .select({
+      seedLocalId: seeds.localId,
+      seedUid: seeds.uid,
+      schemaUid: seeds.schemaUid,
+      modelName: sql<string>`${modelName}`,
+      attestationCreatedAt: seeds.attestationCreatedAt,
+      versionsCount: count(versions.localId),
+      lastVersionPublishedAt: max(versions.attestationCreatedAt),
+      lastLocalUpdateAt: max(versions.createdAt),
+      createdAt: seeds.createdAt,
+    })
+    .from(seeds)
+    .leftJoin(versions, eq(seeds.localId, versions.seedLocalId))
+    .where(and(...conditions))
+    .orderBy(desc(seeds.createdAt))
+    .groupBy(seeds.localId)
+
+  const itemsData = (await query) as ItemData[]
+
+  return itemsData
+}

package/dist/src/getMetadata.ts

@@ -0,0 +1,40 @@
+import { getAppDb } from '@/browser/db'
+import { and, eq, SQL } from 'drizzle-orm'
+import { metadata, MetadataType } from '@/shared/seedSchema'
+
+type GetMetadataProps =
+  | {
+      storageTransactionId?: string
+    }
+  | undefined
+
+type GetMetadata = (
+  props: GetMetadataProps,
+) => Promise<MetadataType | undefined>
+
+export const getMetadata: GetMetadata = async (props) => {
+  const appDb = getAppDb()
+
+  let storageTransactionId: string | undefined
+  if (props) {
+    storageTransactionId = props.storageTransactionId
+  }
+
+  const whereClauses: SQL[] = []
+
+  if (storageTransactionId) {
+    whereClauses.push(eq(metadata.propertyName, 'storageTransactionId'))
+    whereClauses.push(eq(metadata.propertyValue, storageTransactionId))
+  }
+
+  const metadataRows = await appDb
+    .select()
+    .from(metadata)
+    .where(and(...whereClauses))
+
+  if (!metadataRows || metadataRows.length === 0) {
+    return
+  }
+
+  return metadataRows[0]
+}