@seedprotocol/sdk 0.1.47 → 0.1.48

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

package/dist/src/getModelSchemas.ts

@@ -0,0 +1,88 @@
+import { getModels } from '@/browser/stores/modelClass'
+import { GetSchemasQuery, Schema } from '@/browser/gql/graphql'
+import { getAppDb } from '../sqlWasmClient'
+import { models as modelsTable, modelUids } from '@/shared/seedSchema'
+import { eq } from 'drizzle-orm'
+import pluralize from 'pluralize'
+import { toSnakeCase } from '@/shared/helpers'
+import { easClient, queryClient } from '@/browser/helpers'
+import { GET_SCHEMAS } from '@/browser/item/queries'
+
+type GetModelSchemasReturn = {
+  modelSchemas: GetSchemasQuery
+  schemaStringToModelRecord: Map<string, Schema>
+  modelRecords: Record<string, unknown>
+}
+type GetModelSchemas = () => Promise<GetModelSchemasReturn>
+
+export const getModelSchemas: GetModelSchemas = async () => {
+  const models = getModels()
+  const modelRecords = [] as Record<string, unknown>[]
+
+  const schemaStringToModelRecord = new Map<string, Schema>()
+
+  const appDb = getAppDb()
+
+  const OR: Record<string, unknown>[] = []
+
+  for (const [modelName, _] of Object.entries(models)) {
+    const foundModelQuery = await appDb
+      .select({
+        id: modelsTable.id,
+        name: modelsTable.name,
+        uid: modelUids.uid,
+      })
+      .from(modelsTable)
+      .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
+      .where(eq(modelsTable.name, modelName))
+      .limit(1)
+
+    const foundModel: {
+      id: number
+      name: string
+      uid: string | null
+      tableName?: string
+    } = { ...foundModelQuery[0] }
+
+    if (!foundModel) {
+      console.error(
+        `[item/events] [syncDbWithEas] model ${modelName} not found in SDK DB`,
+      )
+      return
+    }
+
+    foundModel.tableName = pluralize(foundModel.name).toLowerCase()
+
+    modelRecords!.push(foundModel)
+
+    if (modelName === 'Seed' || modelName === 'Version') {
+      continue
+    }
+
+    const schemaString = `bytes32 ${toSnakeCase(modelName)}`
+
+    OR.push({
+      schema: {
+        equals: `bytes32 ${toSnakeCase(modelName)}`,
+      },
+    })
+
+    schemaStringToModelRecord.set(schemaString, foundModel)
+  }
+
+  const modelSchemas = await queryClient.fetchQuery({
+    queryKey: [`getSchemasAllModels`],
+    queryFn: async () =>
+      easClient.request(GET_SCHEMAS, {
+        where: {
+          OR,
+        },
+      }),
+  })
+
+  return {
+    modelSchemas,
+    schemaStringToModelRecord,
+    modelRecords,
+  }
+}

package/dist/src/getSchemaForModel.ts

@@ -0,0 +1,42 @@
+import { EventObject, fromCallback } from 'xstate'
+import {
+  FromCallbackInput,
+  GetSchemaForModelEvent,
+  GlobalMachineContext,
+} from '@/types'
+import debug from 'debug'
+
+const logger = debug('app:services:global:actors:getSchemaForModel')
+
+export const getSchemaForModel = fromCallback<
+  EventObject,
+  FromCallbackInput<GlobalMachineContext, GetSchemaForModelEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const { modelName } = event
+
+  if (!modelName) {
+    console.warn('No modelName found')
+    return
+  }
+
+  const { models } = context
+
+  if (!models) {
+    console.warn('No models found')
+    return
+  }
+
+  const model = Object.entries(models).find(
+    ([modelNameFromConfig]) => modelNameFromConfig === modelName,
+  )
+
+  if (!model) {
+    throw new Error(`Model ${modelName} not found`)
+  }
+
+  logger('[service/actor] [getSchemaForModel] model:', model)
+
+  sendBack({ type: 'schemaForModel', schema: model.schema })
+
+  return () => {}
+})

package/dist/src/getSeedData.ts

@@ -0,0 +1,34 @@
+import { getAppDb } from '../sqlWasmClient'
+import { seeds, SeedType } from '@/shared/seedSchema'
+import { eq } from 'drizzle-orm'
+
+type GetSeedDataProps = {
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type GetSeedData = (props: GetSeedDataProps) => Promise<SeedType | undefined>
+
+export const getSeedData: GetSeedData = async ({ seedLocalId, seedUid }) => {
+  const appDb = getAppDb()
+
+  let query
+
+  const queryBase = appDb.select().from(seeds)
+
+  if (seedLocalId) {
+    query = queryBase.where(eq(seeds.localId, seedLocalId))
+  }
+
+  if (seedUid) {
+    query = queryBase.where(eq(seeds.uid, seedUid))
+  }
+
+  const rows = await query
+
+  if (!rows || !rows.length) {
+    return
+  }
+
+  return rows[0]
+}

package/dist/src/getVersionData.ts

@@ -0,0 +1,58 @@
+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
+}
+
+type GetVersionDataProps = {
+  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
+  }
+
+  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],
+  }
+}

package/dist/src/getVersionsForVersionUids.ts

@@ -0,0 +1,39 @@
+import { runQueryForStatement } from '../sqlWasmClient'
+
+type VersionData = {
+  localId: string
+  uid: string
+  seedUid: string
+  seedLocalId: string
+}
+type GetVersionsForVersionUids = (
+  versionUids: string[],
+) => Promise<VersionData[]>
+export const getVersionsForVersionUids: GetVersionsForVersionUids = async (
+  versionUids: string[],
+) => {
+  const queryStatement = `
+      SELECT local_id, uid, seed_uid, seed_local_id
+      FROM versions
+      WHERE uid IN ('${versionUids.join("','")}');
+  `
+
+  const { rows } = await runQueryForStatement(queryStatement)
+
+  if (!rows || rows.length === 0) {
+    return []
+  }
+
+  const versionsData: VersionData[] = []
+
+  for (const row of rows) {
+    versionsData.push({
+      localId: row[0],
+      uid: row[1],
+      seedUid: row[2],
+      seedLocalId: row[3],
+    })
+  }
+
+  return versionsData
+}