@seedprotocol/sdk 0.2.54 → 0.3.1

package/dist/src/filesDownload.ts

@@ -0,0 +1,326 @@
+
+export default `(
+  ${
+    function () {
+
+const identifyString = (str: string) => {
+  try {
+    JSON.parse(str)
+    return 'json'
+  } catch (e) {
+    // Not JSON
+  }
+
+  if (!str) {
+    return
+  }
+
+  if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
+    return 'html'
+  }
+
+  // Simple markdown checks (very naive)
+  if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
+    return 'markdown'
+  }
+
+  if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
+    return 'base64'
+  }
+
+  // Default to plain text if unsure
+  return 'text'
+}
+
+const getMimeType = (base64: string) => {
+  if (!base64) {
+    return null
+  }
+  const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/)
+
+  if (result && result.length > 1) {
+    return result[1]
+  } else {
+    return null // MIME type could not be determined
+  }
+}
+
+const getDataTypeFromString = (
+  data: string,
+): 'imageBase64' | 'base64' | 'url' | null => {
+  const nonImageBase64Regex =
+    /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/
+
+  if (nonImageBase64Regex.test(data)) {
+    return 'base64'
+  }
+
+  // Regular expression for base64 (simple version, checking for base64 format)
+  const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/
+
+  if (imageBase64Regex.test(data)) {
+    return 'imageBase64'
+  }
+
+  // Regular expression for URL (simple version, checking for common URL format)
+  const urlRegex =
+    /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/
+
+  if (urlRegex.test(data)) {
+    return 'url'
+  }
+
+  return null
+}
+
+const isBinary = (arrayBuffer: ArrayBuffer): boolean => {
+  const view = new Uint8Array(arrayBuffer);
+
+  let nonTextCount = 0;
+  const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
+
+  for (let i = 0; i < view.length; i++) {
+      const byte = view[i];
+
+      // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
+      if (
+          (byte >= 32 && byte <= 126) || // Printable ASCII
+          byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
+      ) {
+          continue;
+      }
+
+      nonTextCount++;
+      if (nonTextCount / view.length > threshold) {
+          return true; // More than threshold are non-text bytes
+      }
+  }
+
+  return false; // Fewer than threshold are non-text bytes
+}
+
+const saveBufferToOPFS = async (filePath: string, buffer: Uint8Array): Promise<void> => {
+  // Access the OPFS root directory
+  const rootHandle = await navigator.storage.getDirectory();
+
+  // Split the filePath into directory segments and file name
+  const segments = filePath.split('/').filter(Boolean);
+  const fileName = segments.pop(); // Extract the file name
+  if (!fileName) {
+      throw new Error('Invalid file path: No file name provided.');
+  }
+
+  // Traverse or create directories as needed
+  let currentDirHandle = rootHandle;
+  for (const segment of segments) {
+      currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
+  }
+
+  // Create or open the file in OPFS
+  const fileHandleAsync = await currentDirHandle.getFileHandle(fileName, { create: true });
+  const fileHandle = await fileHandleAsync.createSyncAccessHandle();
+  // Write the buffer to the file
+  fileHandle.write(buffer);
+  fileHandle.flush();
+  fileHandle.close();
+}
+
+const downloadFiles = async ({
+  transactionIds,
+  arweaveHost,
+}: {
+  transactionIds: string[],
+  arweaveHost: string,
+}) => {
+
+  let arrayBuffer: ArrayBuffer | undefined
+
+  for (const transactionId of transactionIds) {
+    try {
+      const response = await fetch(`https://${arweaveHost}/raw/${transactionId}`);
+
+      arrayBuffer = await response.arrayBuffer();
+    } catch(error) {
+      console.log(`[filesDownload] transaction ${transactionId} data not found`, error)
+      globalThis.postMessage({
+        message: 'excludeTransaction',
+        transactionId,
+      })
+      continue
+    }
+
+    let dataString
+    const isBinaryData = isBinary(arrayBuffer)
+
+    if (!isBinaryData) {
+      const decoder = new TextDecoder('utf-8')
+      const text = decoder.decode(arrayBuffer)
+      dataString = text
+    }
+
+    if (!dataString && !arrayBuffer) {
+      console.log(
+        `[filesDownload] transaction ${transactionId} data not found`,
+      )
+    }
+
+    if (dataString && dataString.startsWith('===FILE_SEPARATOR===')) {
+      const dataStringParts = dataString
+        .split('===FILE_SEPARATOR===')
+        .slice(1)
+
+      if (dataStringParts.length % 2 !== 0) {
+        throw new Error('Input array must have an even number of elements.')
+      }
+
+      for (let i = 0; i < dataStringParts.length; i += 2) {
+        const contentType = dataStringParts[i]
+        const content = dataStringParts[i + 1]
+        const encoder = new TextEncoder()
+        if (contentType === 'html') {
+          const fileName = `${transactionId}.html`
+          const buffer = encoder.encode(content)
+          saveBufferToOPFS(`/files/html/${fileName}`, buffer)
+        }
+        if (contentType === 'json') {
+          const fileName = `${transactionId}.json`
+          const buffer = encoder.encode(content)
+          saveBufferToOPFS(`/files/json/${fileName}`, buffer)
+        }
+      }
+
+      continue
+    }
+
+    if (!dataString && arrayBuffer) {
+      saveBufferToOPFS(
+        `/files/images/${transactionId}`,
+        new Uint8Array(arrayBuffer),
+      )
+      continue
+    }
+
+    if (!dataString) {
+      continue
+    }
+
+    let contentType = identifyString(dataString)
+
+    if (
+      contentType !== 'json' &&
+      contentType !== 'base64' &&
+      contentType !== 'html'
+    ) {
+      const possibleImageType = getDataTypeFromString(dataString)
+      if (!possibleImageType) {
+        console.log(
+          `[filesDownload] transaction ${transactionId} data not in expected format: ${possibleImageType}`,
+        )
+        continue
+      }
+
+      contentType = possibleImageType
+    }
+
+    if (contentType === 'url') {
+      const url = dataString as string
+
+      let buffer: ArrayBuffer | undefined
+
+      try {
+        const response = await fetch(url)
+  
+        buffer = await response.arrayBuffer()
+
+      } catch(error) {
+        console.log(`[filesDownload] transaction ${transactionId} value was url: ${dataString} but failed to fetch`, error)
+        globalThis.postMessage({
+          message: 'excludeTransaction',
+          transactionId,
+        })
+        continue
+      }
+
+      const bufferUint8Array = new Uint8Array(buffer)
+
+      // Extract the file extension from the URL
+      const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i)
+      if (!extensionMatch) {
+        throw new Error(
+          'Unable to determine the file extension from the URL.',
+        )
+      }
+      const fileExtension = extensionMatch[0] // e.g., ".jpg"
+
+      // Set the file name (you can customize this)
+      // const fileNameFromUrl = `${transactionId}${fileExtension}`
+
+      await saveBufferToOPFS(
+        `/files/images/${transactionId}`,
+        bufferUint8Array,
+      )
+
+      continue
+    }
+
+    const mimeType = getMimeType(dataString as string)
+    let fileExtension = mimeType
+
+    if (fileExtension && fileExtension?.startsWith('image')) {
+      fileExtension = fileExtension.replace('image/', '')
+    }
+
+    let fileName = transactionId
+
+    if (contentType === 'base64') {
+      if (fileExtension) {
+        fileName += `.${fileExtension}`
+      }
+
+      // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
+      const base64Data = dataString.split(',').pop() || ''
+
+      // Decode the Base64 string to binary
+      const binaryString = atob(base64Data)
+      const length = binaryString.length
+      const binaryData = new Uint8Array(length)
+
+      for (let i = 0; i < length; i++) {
+        binaryData[i] = binaryString.charCodeAt(i)
+      }
+
+      await saveBufferToOPFS(`/files/images/${fileName}`, binaryData)
+
+    }
+
+    if (contentType === 'html') {
+      fileName += '.html'
+      const encoder = new TextEncoder()
+      const buffer = encoder.encode(dataString)
+      await saveBufferToOPFS(`/files/html/${fileName}`, buffer)
+    }
+
+    if (contentType === 'json') {
+      fileName += '.json'
+      const encoder = new TextEncoder()
+      const buffer = encoder.encode(dataString)
+      await saveBufferToOPFS(`/files/json/${fileName}`, buffer)
+    }
+  }
+}
+
+onmessage = async (e) => {
+  console.log({
+    message: 'filesDownload onmessage',
+    data: e.data,
+  })
+  await downloadFiles(e.data);
+  globalThis.postMessage({
+    message: 'filesDownload onmessage done',
+    done: true,
+  })
+  
+}
+}.toString()
+}
+)()`

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/getExistingItem.ts

@@ -0,0 +1,60 @@
+import { BaseDb } from '@/db/Db/BaseDb'
+import { seeds } from '@/seedSchema'
+import { and, eq, isNotNull, not, or } from 'drizzle-orm'
+
+type GetExistingItemProps = {
+  seedLocalId: string
+  seedUid: string
+}
+
+type GetExistingItemReturn = {
+  seedLocalId: string
+  seedUid: string
+  createdAt: string
+}
+
+export const getExistingItem = async ({
+  seedLocalId,
+  seedUid,
+}: GetExistingItemProps): Promise<GetExistingItemReturn | undefined> => {
+  const appDb = BaseDb.getAppDb()
+
+  const rows = await appDb
+    .select({
+      seedLocalId: seeds.localId,
+      seedUid: seeds.uid,
+      createdAt: seeds.createdAt,
+    })
+    .from(seeds)
+    .where(
+      or(
+        and(
+          isNotNull(seeds.uid),
+          not(eq(seeds.uid, '')),
+          not(eq(seeds.uid, 'undefined')),
+          not(eq(seeds.uid, 'null')),
+          not(eq(seeds.uid, 'false')),
+          not(eq(seeds.uid, '0')),
+          eq(seeds.uid, seedUid)
+        ),
+        and(
+          isNotNull(seeds.localId),
+          not(eq(seeds.localId, '')),
+          not(eq(seeds.localId, 'undefined')),
+          not(eq(seeds.localId, 'null')),
+          not(eq(seeds.localId, 'false')),
+          not(eq(seeds.localId, '0')),
+          eq(seeds.localId, seedLocalId)
+        )
+      )
+    )
+
+  if (!rows || rows.length === 0) {
+    return undefined
+  }
+
+  const matchingRow = rows.find(row => row.seedUid === seedUid) ||
+    rows.find(row => row.seedLocalId === seedLocalId)
+
+  return matchingRow
+} 

package/dist/src/getItem.ts

@@ -0,0 +1,32 @@
+import { getItemData } from './getItemData'
+import { GetItem } from '@/types'
+import { BaseItem } from '@/Item/BaseItem'
+import { startCase } from 'lodash-es'
+
+export const getItem: GetItem = async ({ modelName, seedLocalId, seedUid }) => {
+  const itemInitObj = await getItemData({
+    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
+  }
+
+  if (!itemInitObj.modelName && itemInitObj.type) {
+    itemInitObj.modelName = startCase(itemInitObj.type)
+  }
+
+  return BaseItem.create(itemInitObj)
+}

package/dist/src/getItemData.ts

@@ -0,0 +1,99 @@
+import { GetItemData, ItemData } from "@/types"
+import debug from "debug"
+import { BaseDb } from "../Db/BaseDb"
+import { and, eq, getTableColumns, gt, SQL, sql } from "drizzle-orm"
+import { getItemProperties } from "./getItemProperties"
+import { getVersionData } from "./subqueries/versionData"
+import { seeds } from "@/seedSchema"
+import { getSeedData } from "./getSeedData"
+
+const logger = debug('app:db:read:getItemData')
+
+export const getItemData: GetItemData = 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 = BaseDb.getAppDb()
+
+  const { localId, uid, ...rest } = getTableColumns(seeds)
+
+  const whereClauses: SQL[] = []
+
+  if (modelName) {
+    whereClauses.push(eq(seeds.type, modelName.toLowerCase()))
+  }
+
+  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(versionData)
+    .select({
+      ...rest,
+      seedLocalId: seeds.localId,
+      seedUid: seeds.uid,
+      versionsCount: versionData.versionsCount,
+      lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+      latestVersionUid: versionData.latestVersionUid,
+      latestVersionLocalId: versionData.latestVersionLocalId,
+    })
+    .from(seeds)
+    .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) as ItemData[]
+
+  if (!itemDataRows || itemDataRows.length === 0) {
+    logger('[db/queries] [getItemDataFromDb] no itemDataRows')
+    return
+  }
+
+  let itemData = itemDataRows[0] as ItemData & { [key: string]: any }
+
+  const propertiesData = await getItemProperties({
+    seedLocalId,
+    seedUid: itemData.seedUid || undefined,
+  })
+
+  if (!propertiesData || propertiesData.length === 0) {
+    return itemData
+  }
+
+  for (const propertyData of propertiesData) {
+    const propertyName = propertyData.propertyName
+
+    let propertyValue = propertyData.propertyValue
+
+    if (propertyName.endsWith('Id') || propertyName.endsWith('Ids')) {
+      if (propertyData.refSeedType) {
+        const propertyNameVariant = propertyName.replace(/Ids?$/, '')
+        itemData[propertyNameVariant] = propertyValue
+      }
+    }
+
+    itemData[propertyName] = propertyValue
+  }
+
+  if (itemData) return itemData
+}

package/dist/src/getItemProperties.ts

@@ -0,0 +1,56 @@
+import { GetItemProperties, PropertyData } from '@/types'
+import { metadata, seeds, versions } from '@/seedSchema'
+import { and, eq, getTableColumns, isNotNull, isNull, sql, SQL } from 'drizzle-orm'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { getMetadataLatest } from './subqueries/metadataLatest'
+
+
+export const getItemProperties: GetItemProperties = async ({
+  seedLocalId,
+  seedUid,
+  edited,
+}) => {
+  const appDb = BaseDb.getAppDb()
+
+  const whereClauses: SQL[] = [isNotNull(metadata.propertyName)]
+
+  if (seedUid) {
+    whereClauses.push(eq(seeds.uid, seedUid))
+  }
+
+  if (seedLocalId) {
+    whereClauses.push(eq(seeds.localId, seedLocalId))
+  }
+
+  whereClauses.push(isNotNull(metadata.propertyName))
+
+  if (typeof edited !== 'undefined') {
+    if (edited) {
+      whereClauses.push(isNull(metadata.uid))
+    }
+    if (!edited) {
+      whereClauses.push(isNotNull(metadata.uid))
+    }
+  }
+
+  // const metadataColumns = getTableColumns(metadata)
+
+  const metadataLatest = getMetadataLatest({seedLocalId, seedUid})
+
+  const propertiesData = await appDb
+    .with(metadataLatest)
+    .select()
+    .from(metadataLatest)
+    .where(eq(metadataLatest.rowNum, 1))
+
+  return propertiesData.map(data => ({
+    ...data,
+    localId: data.localId || '',
+    uid: data.uid || '',
+    propertyName: data.propertyName || '',
+    propertyValue: data.propertyValue || '',
+    schemaUid: data.schemaUid || '',
+    modelType: data.modelType || '',
+    seedLocalId: data.seedLocalId || '',
+  })) as PropertyData[]
+}

package/dist/src/getItemProperty.ts

@@ -0,0 +1,34 @@
+import { BaseDb } from '@/db/Db/BaseDb'
+import { metadata, MetadataType } from '@/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 = BaseDb.getAppDb()
+
+  const whereClauses = []
+
+  const tableColumns = getTableColumns(metadata)
+
+  for (const [propertyName, propertyValue] of Object.entries(props)) {
+    if (Object.keys(tableColumns).includes(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]
+}