@seedprotocol/sdk 0.3.1 → 0.3.2

package/dist/src/filesDownload.ts

@@ -1,326 +0,0 @@
-
-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

@@ -1,87 +0,0 @@
-/* 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

@@ -1,60 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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]
-}