@seedprotocol/sdk 0.1.52 → 0.1.54

package/dist/{index-wKss7188.js → index-NmD9sjcJ.js}

@@ -1,4 +1,4 @@
-export { f as GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, e as GET_PROPERTIES, G as GET_SCHEMAS, a as GET_SEEDS, b as GET_SEED_IDS, c as GET_STORAGE_TRANSACTION_ID, d as GET_VERSIONS, I as Item, g as itemMachineAll, i as itemMachineSingle } from './index-DMIKRod-.js';
+export { f as GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, e as GET_PROPERTIES, G as GET_SCHEMAS, a as GET_SEEDS, b as GET_SEED_IDS, c as GET_STORAGE_TRANSACTION_ID, d as GET_VERSIONS, I as Item, g as itemMachineAll, i as itemMachineSingle } from './index-DQKd-s2Q.js';
 import './constants-BLctWkrn.js';
 import 'path';
 import 'reflect-metadata';
@@ -27,4 +27,4 @@ import 'arweave';
 import 'react';
 import 'use-immer';
 import '@xstate/react';
-//# sourceMappingURL=index-wKss7188.js.map
+//# sourceMappingURL=index-NmD9sjcJ.js.map

package/dist/index-NmD9sjcJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-NmD9sjcJ.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/main.js

@@ -1,4 +1,4 @@
-export { h as ImageSrc, I as Item, j as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, s as client, t as getCorrectId, r as getGlobalService, m as useCreateItem, o as useDeleteItem, p as useGlobalServiceStatus, k as useItem, l as useItemProperties, n as useItemProperty, u as useItems, q as useServices, w as withSeed } from './index-DMIKRod-.js';
+export { h as ImageSrc, I as Item, j as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, s as client, t as getCorrectId, r as getGlobalService, m as useCreateItem, o as useDeleteItem, p as useGlobalServiceStatus, k as useItem, l as useItemProperties, n as useItemProperty, u as useItems, q as useServices, w as withSeed } from './index-DQKd-s2Q.js';
 import 'immer';
 import 'reflect-metadata';
 import './constants-BLctWkrn.js';

package/dist/{seed.schema.config-C0M8Rcti.js → seed.schema.config-OyHsE0Zl.js}

@@ -1,6 +1,6 @@
 import { _ as __decorate, a as __metadata } from './constants-BLctWkrn.js';
 import 'drizzle-orm';
-import { T as Text, M as Model } from './index-DMIKRod-.js';
+import { T as Text, M as Model } from './index-DQKd-s2Q.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
@@ -74,4 +74,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-C0M8Rcti.js.map
+//# sourceMappingURL=seed.schema.config-OyHsE0Zl.js.map

package/dist/{seed.schema.config-C0M8Rcti.js.map → seed.schema.config-OyHsE0Zl.js.map}

@@ -1 +1 @@
-{"version":3,"file":"seed.schema.config-C0M8Rcti.js","sources":["../../src/shared/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/browser'\n\n@Model\nclass Seed {\n  @Text() uid!: string\n  @Text() type!: string\n}\n\n@Model\nclass Version {\n  @Text() seedUid!: string\n  @Text() note!: string\n}\n\n@Model\nclass Metadata {\n  @Text() key!: string\n  @Text() value!: string\n}\n\nexport const models = {\n  Seed,\n  Version,\n  Metadata,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,IAAI,GAAV,MAAM,IAAI,CAAA;CAGT;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,IAAI,GAAA,UAAA,CAAA;IADT;AACK,CAAA,EAAA,IAAI,CAGT;AAGD,IAAM,OAAO,GAAb,MAAM,OAAO,CAAA;CAGZ;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAiB,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,SAAA,EAAA,KAAA,CAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,OAAO,GAAA,UAAA,CAAA;IADZ;AACK,CAAA,EAAA,OAAO,CAGZ;AAGD,IAAM,QAAQ,GAAd,MAAM,QAAQ,CAAA;CAGb;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,KAAA,CAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}
+{"version":3,"file":"seed.schema.config-OyHsE0Zl.js","sources":["../../src/shared/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/browser'\n\n@Model\nclass Seed {\n  @Text() uid!: string\n  @Text() type!: string\n}\n\n@Model\nclass Version {\n  @Text() seedUid!: string\n  @Text() note!: string\n}\n\n@Model\nclass Metadata {\n  @Text() key!: string\n  @Text() value!: string\n}\n\nexport const models = {\n  Seed,\n  Version,\n  Metadata,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,IAAI,GAAV,MAAM,IAAI,CAAA;CAGT;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,IAAI,GAAA,UAAA,CAAA;IADT;AACK,CAAA,EAAA,IAAI,CAGT;AAGD,IAAM,OAAO,GAAb,MAAM,OAAO,CAAA;CAGZ;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAiB,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,SAAA,EAAA,KAAA,CAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,OAAO,GAAA,UAAA,CAAA;IADZ;AACK,CAAA,EAAA,OAAO,CAGZ;AAGD,IAAM,QAAQ,GAAd,MAAM,QAAQ,CAAA;CAGb;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,KAAA,CAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}

package/dist/src/ItemProperty.ts

@@ -1,5 +1,11 @@
-import { ItemPropertyProps, PropertyMachineContext } from '@/types'
-import { ActorRefFrom, createActor, Subscription, waitFor } from 'xstate'
+import { CreatePropertyInstanceProps, PropertyMachineContext } from '@/types'
+import {
+  ActorRefFrom,
+  createActor,
+  SnapshotFrom,
+  Subscription,
+  waitFor,
+} from 'xstate'
 import { BehaviorSubject, Subscriber } from 'rxjs'
 import { propertyMachine } from './propertyMachine'
 import { immerable } from 'immer'
@@ -12,9 +18,13 @@ import { getModel } from '@/browser/stores/modelClass'
 import { getCorrectId } from '@/browser/helpers'
 import { Static } from '@sinclair/typebox'
 import { TProperty } from '@/browser/property'
+import { fs } from '@zenfs/core'
 
 const logger = debug('app:property:class')
 
+type ItemPropertyService = ActorRefFrom<typeof propertyMachine>
+type ItemPropertySnapshot = SnapshotFrom<typeof propertyMachine>
+
 type ItemPropertyFindProps = {
   propertyName: string
   propertyLocalId?: string
@@ -29,7 +39,7 @@ export class ItemProperty<PropertyType> {
     string,
     { instance: ItemProperty<any>; refCount: number }
   > = new Map()
-  private readonly _service: ActorRefFrom<typeof propertyMachine>
+  private readonly _service: ItemPropertyService
   private _subject: BehaviorSubject<any>
   private readonly _isRelation: boolean = false
   private readonly _isList: boolean = false
@@ -47,11 +57,13 @@ export class ItemProperty<PropertyType> {
     propertyValue,
     seedUid,
     seedLocalId,
+    versionLocalId,
+    versionUid,
     itemModelName,
     propertyName,
     storageTransactionId,
     schemaUid,
-  }: ItemPropertyProps) {
+  }: Partial<CreatePropertyInstanceProps>) {
     const ModelClass = getModel(itemModelName)
 
     if (!ModelClass) {
@@ -62,13 +74,13 @@ export class ItemProperty<PropertyType> {
       throw new Error(`Property name not provided`)
     }
 
-    this._lastRenderedValue = propertyValue
-
     const serviceInput: Partial<PropertyMachineContext> = {
       propertyValue,
-      seedUid,
       propertyName,
       seedLocalId,
+      seedUid,
+      versionLocalId,
+      versionUid,
       itemModelName,
       storageTransactionId,
       propertyRecordSchema: ModelClass.schema[propertyName],
@@ -130,65 +142,92 @@ export class ItemProperty<PropertyType> {
     this._service = createActor(propertyMachine, {
       input: serviceInput,
     })
-    this._subscription = this._service.subscribe((snapshot) => {
-      const { context } = snapshot
-
-      // if (this.uid && !cacheHasProperty(this.uid)) {
-      //   addPropertyToCache(this)
-      // }
-      //
-      // if (!this.uid && this.localId && !cacheHasProperty(this.localId,)) {
-      //   addPropertyToCache(this)
-      // }
-
-      if (context.seedLocalId) {
-        const cacheKey = ItemProperty.cacheKey(
-          context.seedLocalId,
-          context.propertyName,
-        )
-        if (!ItemProperty.instanceCache.has(cacheKey)) {
-          ItemProperty.instanceCache.set(cacheKey, {
-            instance: this,
-            refCount: 1,
-          })
+    this._subscription = this._service.subscribe(
+      async (snapshot: ItemPropertySnapshot) => {
+        if (!snapshot || !snapshot.context) {
+          return
         }
-        // this._updateResponseEvent = `property.${context.seedLocalId}.${this.propertyName}.save.response`
-        // eventEmitter.addListener(
-        //   this._updateResponseEvent,
-        //   this._updateResponseListener,
-        // )
-      }
 
-      const renderValue = context.renderValue || context.propertyValue
+        const { context } = snapshot
+        const { propertyRecordSchema } = context
+
+        // if (this.uid && !cacheHasProperty(this.uid)) {
+        //   addPropertyToCache(this)
+        // }
+        //
+        // if (!this.uid && this.localId && !cacheHasProperty(this.localId,)) {
+        //   addPropertyToCache(this)
+        // }
+
+        if (context.seedLocalId) {
+          const cacheKey = ItemProperty.cacheKey(
+            context.seedLocalId,
+            context.propertyName,
+          )
+          if (!ItemProperty.instanceCache.has(cacheKey)) {
+            ItemProperty.instanceCache.set(cacheKey, {
+              instance: this,
+              refCount: 1,
+            })
+          }
+          // this._updateResponseEvent = `property.${context.seedLocalId}.${this.propertyName}.save.response`
+          // eventEmitter.addListener(
+          //   this._updateResponseEvent,
+          //   this._updateResponseListener,
+          // )
+        }
 
-      let transformedPropertyName = propertyName
+        let renderValue
 
-      const skipTransform =
-        internalPropertyNames.includes(propertyName) || !!this._alias
+        if (
+          propertyRecordSchema &&
+          propertyRecordSchema.storageType &&
+          propertyRecordSchema.storageType === 'ItemStorage' &&
+          context.resolvedValue &&
+          context.localStorageDir
+        ) {
+          const filePath = `/files/${context.localStorageDir}/${context.resolvedValue}`
+          const exists = await fs.promises.exists(filePath)
+          if (exists) {
+            renderValue = await fs.promises.readFile(filePath, 'utf-8')
+          }
+        }
 
-      if (!skipTransform && transformedPropertyName.endsWith('Id')) {
-        transformedPropertyName = transformedPropertyName.slice(0, -2)
-      }
+        if (!renderValue) {
+          renderValue = context.renderValue || context.propertyValue
+        }
 
-      if (!skipTransform && transformedPropertyName.endsWith('Ids')) {
-        transformedPropertyName = transformedPropertyName.slice(0, -3)
-      }
+        let transformedPropertyName = propertyName
 
-      if (skipTransform && this._alias) {
-        transformedPropertyName = this._alias
-      }
+        const skipTransform =
+          internalPropertyNames.includes(propertyName) || !!this._alias
 
-      if (skipTransform && !this._alias) {
-      }
+        if (!skipTransform && transformedPropertyName.endsWith('Id')) {
+          transformedPropertyName = transformedPropertyName.slice(0, -2)
+        }
 
-      this._subject.next(renderValue)
-      if (context.seedLocalId) {
-        eventEmitter.emit(`item.${itemModelName}.${context.seedLocalId}.update`)
-      }
-      if (context.seedUid) {
-        eventEmitter.emit(`item.${itemModelName}.${context.seedUid}.update`)
-      }
-    })
+        if (!skipTransform && transformedPropertyName.endsWith('Ids')) {
+          transformedPropertyName = transformedPropertyName.slice(0, -3)
+        }
+
+        if (skipTransform && this._alias) {
+          transformedPropertyName = this._alias
+        }
+
+        if (skipTransform && !this._alias) {
+        }
+
+        this._subject.next(renderValue)
+        if (context.seedLocalId) {
+          eventEmitter.emit(
+            `item.${itemModelName}.${context.seedLocalId}.update`,
+          )
+        }
+        if (context.seedUid) {
+          eventEmitter.emit(`item.${itemModelName}.${context.seedUid}.update`)
+        }
+      },
+    )
 
     this._service.start()
   }
@@ -200,8 +239,11 @@ export class ItemProperty<PropertyType> {
     )
   }
 
-  static create(props: ItemPropertyProps): ItemProperty<any> | undefined {
-    const { propertyName, seedLocalId, seedUid } = props
+  static create(
+    props: Partial<CreatePropertyInstanceProps>,
+  ): ItemProperty<any> | undefined {
+    const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } =
+      props
     if (!propertyName || (!seedLocalId && !seedUid)) {
       return
     }
@@ -283,39 +325,43 @@ export class ItemProperty<PropertyType> {
     return this._service
   }
 
+  private _getSnapshot(): ItemPropertySnapshot {
+    return this._service.getSnapshot() as ItemPropertySnapshot
+  }
+
   get localId() {
-    return this._service.getSnapshot().context.localId
+    return this._getSnapshot().context.localId
   }
 
   get uid() {
-    return this._service.getSnapshot().context.uid
+    return this._getSnapshot().context.uid
   }
 
   get seedLocalId() {
-    return this._service.getSnapshot().context.seedLocalId
+    return this._getSnapshot().context.seedLocalId
   }
 
   get seedUid() {
-    return this._service.getSnapshot().context.seedUid
+    return this._getSnapshot().context.seedUid
   }
 
   get propertyName() {
     if (this._alias) {
       return this._alias
     }
-    return this._service.getSnapshot().context.propertyName
+    return this._getSnapshot().context.propertyName
   }
 
   get itemModelName() {
-    return this._service.getSnapshot().context.itemModelName
+    return this._getSnapshot().context.itemModelName
   }
 
   get propertyDef(): Static<typeof TProperty> | undefined {
-    return this._service.getSnapshot().context.propertyRecordSchema
+    return this._getSnapshot().context.propertyRecordSchema
   }
 
   get status() {
-    return this._service.getSnapshot().value
+    return this._getSnapshot().value
   }
 
   get alias() {
@@ -344,7 +390,7 @@ export class ItemProperty<PropertyType> {
   }
 
   get published(): boolean {
-    return !!this._service.getSnapshot().context.uid
+    return !!this._getSnapshot().context.uid
   }
 
   subscribe(callback: Partial<Subscriber<any>>) {

package/dist/src/allItems.ts

@@ -8,13 +8,15 @@ type SaveServiceEvent = {
 export const saveServiceHandler = async (event: SaveServiceEvent) => {
   const globalService = getGlobalService()
 
-  if (!globalService) {
+  if (!globalService || !globalService.getSnapshot().context) {
     return
   }
 
   const { modelName } = event
 
-  const service = globalService.getSnapshot().context[`${modelName}Service`]
+  const nameOfService: string = `${modelName}Service`
+
+  const service = globalService.getSnapshot().context[nameOfService]
 
   await writeAppState(
     `snapshot__${modelName}`,

package/dist/src/createMetadata.ts

@@ -0,0 +1,36 @@
+import { metadata, MetadataType } from '@/shared/seedSchema'
+import { getAppDb } from '../sqlWasmClient'
+import { generateId } from '@/shared/helpers'
+import { PropertyType } from '@/types'
+
+type CreateMetadata = (
+  metadataValues: Partial<MetadataType>,
+  propertyRecordSchema?: PropertyType | undefined,
+) => Promise<MetadataType>
+
+export const createMetadata: CreateMetadata = async (
+  metadataValues,
+  propertyRecordSchema?,
+) => {
+  const appDb = getAppDb()
+
+  metadataValues.localId = generateId()
+
+  if (
+    propertyRecordSchema &&
+    propertyRecordSchema.localStorageDir &&
+    propertyRecordSchema.storageType === 'ItemStorage'
+  ) {
+    metadataValues.refResolvedValue = `${metadataValues.localId}${propertyRecordSchema.filenameSuffix}`
+    metadataValues.refValueType = 'file'
+  }
+
+  return appDb
+    .insert(metadata)
+    .values({
+      ...metadataValues,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    })
+    .returning()
+}

package/dist/src/getItem.ts

@@ -5,17 +5,9 @@ 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'
+import { seeds } from '@/shared/seedSchema'
+import { and, eq, getTableColumns, gt, sql, SQL } from 'drizzle-orm'
+import { getVersionData } from './subqueries/versionData'
 
 const logger = debug('app:db:queries:getItem')
 
@@ -57,44 +49,31 @@ export const getItemDataFromDb: GetItemDataFromDb = async ({
     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),
-  )
+  if (seedUid) {
+    whereClauses.push(eq(seeds.uid, seedUid))
+  }
+
+  if (seedLocalId && !seedUid) {
+    whereClauses.push(eq(seeds.localId, seedLocalId))
+  }
+
+  const versionData = getVersionData()
 
   const itemDataRows = await appDb
-    .with(latestVersions)
+    .with(versionData)
     .select({
       ...rest,
       seedLocalId: seeds.localId,
       seedUid: seeds.uid,
-      versionsCount: count(versions.localId),
-      lastVersionPublishedAt: max(versions.attestationCreatedAt),
-      latestVersionUid: latestVersions.uid,
+      versionsCount: versionData.versionsCount,
+      lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+      latestVersionUid: versionData.latestVersionUid,
+      latestVersionLocalId: versionData.latestVersionLocalId,
     })
     .from(seeds)
-    .leftJoin(versions, eq(versions.seedLocalId, seeds.localId))
-    .leftJoin(
-      latestVersions,
-      eq(versions.seedLocalId, latestVersions.seedLocalId),
-    )
-    .where(and(...whereClauses))
+    .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+    .where(and(...whereClauses, gt(versionData.versionsCount, 0)))
+    .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
     .groupBy(seeds.localId)
 
   if (!itemDataRows || itemDataRows.length === 0) {
@@ -180,10 +159,5 @@ export const getItem: GetItem = async ({ modelName, seedLocalId, seedUid }) => {
     return
   }
 
-  console.log(
-    `[${modelName}.${seedLocalId}] [getItem] Creating Item`,
-    itemInitObj,
-  )
-
   return Item.create(itemInitObj)
 }

package/dist/src/getItemProperty.ts

@@ -0,0 +1,35 @@
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { metadata, MetadataType } from '@/shared/seedSchema'
+import { and, eq, getTableColumns } from 'drizzle-orm'
+
+type GetItemPropertyProps = Partial<MetadataType>
+
+type GetItemPropertyData = (
+  props: GetItemPropertyProps,
+) => Promise<Partial<MetadataType>>
+
+export const getItemPropertyData: GetItemPropertyData = async (props) => {
+  const appDb = getAppDb()
+
+  const whereClauses = []
+
+  const tableColumns = getTableColumns(metadata)
+
+  for (const [propertyName, propertyValue] of Object.entries(props)) {
+    if (Object.keys(tableColumns).includes(propertyName)) {
+      const column = tableColumns[propertyName]
+      whereClauses.push(eq(tableColumns[propertyName], propertyValue))
+    }
+  }
+
+  const queryRows = await appDb
+    .select()
+    .from(metadata)
+    .where(and(...whereClauses))
+
+  if (!queryRows || queryRows.length === 0) {
+    return
+  }
+
+  return queryRows[0]
+}

package/dist/src/getItems.ts

@@ -1,18 +1,8 @@
 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 { and, eq, isNotNull, isNull, or, SQL, sql } from 'drizzle-orm'
+import { seeds } from '@/shared/seedSchema'
 import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { getVersionData } from './subqueries/versionData'
 
 type GetItemsDataProps = {
   modelName?: string
@@ -51,22 +41,25 @@ export const getItemsData: GetItemsData = async ({
     )
   }
 
+  const versionData = getVersionData()
+
   let query = appDb
+    .with(versionData)
     .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),
+      versionsCount: versionData.versionsCount,
+      lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+      lastLocalUpdateAt: versionData.lastLocalUpdateAt,
       createdAt: seeds.createdAt,
     })
     .from(seeds)
-    .leftJoin(versions, eq(seeds.localId, versions.seedLocalId))
+    .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
     .where(and(...conditions))
-    .orderBy(desc(seeds.createdAt))
+    .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
     .groupBy(seeds.localId)
 
   const itemsData = (await query) as ItemData[]

package/dist/src/getVersionData.ts

@@ -1,58 +1,46 @@
-import { runQueryForStatement } from '../sqlWasmClient'
-
-type VersionData = {
-  localId: string
-  uid: string
-  seedLocalId: string
-  seedUid: string
-  seedType: string
-  note: string
-  attestationCreatedAt: string
-  attestationRaw: string
-  createdAt: string
-  updatedAt: string
-}
+import { getAppDb } from '../sqlWasmClient'
+import { versions, VersionsType } from '@/shared/seedSchema'
+import { and, eq } from 'drizzle-orm'
 
 type GetVersionDataProps = {
-  seedLocalId: string
+  localId?: string
+  uid?: string
+  seedLocalId?: string
 }
 
 type GetVersionData = (
   props: GetVersionDataProps,
-) => Promise<VersionData | undefined>
-
-export const getVersionData: GetVersionData = async ({ seedLocalId }) => {
-  const getVersionStatement = `SELECT local_id,
-                                      uid,
-                                      seed_local_id,
-                                      seed_uid,
-                                      seed_type,
-                                      note,
-                                      attestation_created_at,
-                                      attestation_raw,
-                                      created_at,
-                                      updated_at
-                               FROM versions
-                               WHERE local_id = '${seedLocalId}';`
-
-  const { rows } = await runQueryForStatement(getVersionStatement)
-
-  if (!rows || !rows.length) {
-    return
+) => Promise<VersionsType | undefined>
+
+export const getVersionData: GetVersionData = async ({
+  localId,
+  seedLocalId,
+  uid,
+}) => {
+  const appDb = getAppDb()
+
+  const whereClauses = []
+
+  if (seedLocalId) {
+    whereClauses.push(eq(versions.localId, seedLocalId))
+  }
+
+  if (localId) {
+    whereClauses.push(eq(versions.localId, localId))
+  }
+
+  if (uid) {
+    whereClauses.push(eq(versions.uid, uid))
   }
 
-  const seedValues = rows[0]
-
-  return {
-    localId: seedValues[0],
-    uid: seedValues[1],
-    seedLocalId: seedValues[2],
-    seedUid: seedValues[3],
-    seedType: seedValues[4],
-    note: seedValues[5],
-    attestationCreatedAt: seedValues[6],
-    attestationRaw: seedValues[7],
-    createdAt: seedValues[8],
-    updatedAt: seedValues[9],
+  const queryRows = await appDb
+    .select()
+    .from(versions)
+    .where(and(...whereClauses))
+
+  if (!queryRows || !queryRows.length) {
+    return
   }
+
+  return queryRows[0]
 }