@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/logger.ts

@@ -0,0 +1,33 @@
+import { dayjs } from '@/shared/helpers/index'
+
+type Log = (message: string, data?: unknown) => void
+
+type LoggerType = (tag: string) => {
+  log: Log
+}
+
+const tagsToLog = [
+  // 'InternalMachine',
+  'internal/actors',
+  'db/actors',
+]
+
+const Logger: LoggerType = (tag: string) => {
+  const _tag = tag || 'Logger'
+
+  const log: Log = (message, data = undefined): void => {
+    if (process.env.IS_SEED_DEV && tagsToLog.includes(_tag)) {
+      const timestamp = dayjs().format('YYYY-MM-DD HH:mm:ss')
+      console.log(
+        `[${timestamp}] [${_tag}] ${dayjs().format('YYYY-MM-DD HH:mm:ss')} ${message}`,
+        data || '',
+      )
+    }
+  }
+
+  return {
+    log,
+  }
+}
+
+export default Logger

package/dist/src/machine.ts

@@ -0,0 +1,55 @@
+import { ActorRefFrom, assign, setup } from 'xstate'
+import { downloadMachine } from '@/browser/schema/file/download'
+import { uploadMachine } from '@/browser/schema/file/upload'
+import { MachineIds } from '@/browser/services/internal/constants'
+
+type FileSystemMachineContext = {
+  addresses?: string[]
+  downloads: ActorRefFrom<typeof downloadMachine>[]
+  uploads: ActorRefFrom<typeof uploadMachine>[]
+  files?: any[]
+  filesMetadata?: any[]
+}
+
+export const fileSystemMachine = setup({
+  types: {
+    context: {} as FileSystemMachineContext,
+  },
+  actors: {},
+}).createMachine({
+  id: MachineIds.FILE_SYSTEM,
+  initial: 'idle',
+  context: ({ input }) =>
+    ({
+      ...input,
+      fetchRequests: [],
+      downloads: [],
+      uploads: [],
+      files: [],
+    }) as FileSystemMachineContext,
+  on: {
+    updateFilesMetadata: {
+      actions: assign({
+        filesMetadata: ({ event }) => event.filesMetadata,
+      }),
+    },
+  },
+  states: {
+    idle: {
+      on: {
+        download: {
+          target: 'createDownload',
+        },
+        upload: {
+          target: 'createUpload',
+        },
+        fetch: {
+          target: 'createFetchFiles',
+          actions: assign({
+            addresses: ({ event }) => event.addresses,
+          }),
+        },
+      },
+    },
+  },
+})

package/dist/src/machines.ts

@@ -0,0 +1,58 @@
+import { Endpoints, Environment, ModelClassType } from './index'
+import { ActorRefFrom } from 'xstate'
+import { fileSystemMachine } from '@/browser/schema/file/machine'
+import { PublishRequestData } from './seedProtocol'
+
+export type DbServiceContext = {
+  dbName: string
+  dbId?: string
+  dirName: string
+  drizzleDb?: any
+  pathToDb?: string
+  pathToDir?: string
+  pathToDbDir?: string
+  hasFiles?: boolean
+  error?: string
+}
+
+export type InternalMachineContext = {
+  error?: string
+  endpoints: Endpoints
+  addresses: string[]
+  environment: string
+  hasFiles: boolean
+  seedDbService: any
+  appDbService: any
+  sdkDbService: any
+}
+
+export type GlobalMachineContext = {
+  isInitialized?: boolean
+  addedModelRecordsToDb?: boolean
+  environment?: Environment
+  endpoints?: Endpoints
+  addresses?: string[]
+  models?: { [key: string]: ModelClassType }
+  internalService?: ActorRefFrom<any>
+  fileSystemService?: ActorRefFrom<typeof fileSystemMachine>
+  publishItemService?: ActorRefFrom<any>
+}
+
+export type PublishMachineContext = PublishRequestData & {
+  status: string
+}
+
+export type GetSchemaForModelEvent = {
+  type: 'getSchemaForModel'
+  modelName: string
+}
+
+export type HydrateExistingItemEvent = {
+  type: 'hydrateExistingItem'
+  existingItem: any
+}
+
+export type FromCallbackInput<T, P = undefined> = {
+  context: T
+  event?: P
+}

package/dist/src/migrate.ts

@@ -0,0 +1,288 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput, SqliteWasmResult } from '@/types'
+import {
+  BROWSER_FS_TOP_DIR,
+  DB_MIGRATING_SUCCESS,
+} from '@/browser/services/internal/constants'
+import { getSqliteWasmClient, setAppDb } from '@/browser/db/sqlWasmClient'
+import { drizzle } from 'drizzle-orm/sqlite-proxy'
+import { sql } from 'drizzle-orm'
+import { fs } from '@zenfs/core'
+import debug from 'debug'
+
+const logger = debug('app:services:db:actors:migrate')
+
+export const dbExec = async (dbId, params, sql, dbName, retries = 2) => {
+  const rowsToReturnRaw: SqliteWasmResult[] = []
+  const rowsValues: string[][] = []
+
+  const sqliteWasmClient = await getSqliteWasmClient()
+
+  // For a single exec command, the callback potentially gets called several times -- once for each row.
+  // So we need to collect all rows into a final array to return (execResult).
+  const rowsToReturn = await new Promise((resolve, reject) => {
+    sqliteWasmClient('exec', {
+      dbId,
+      sql,
+      bind: params,
+      callback: (result) => {
+        // Checks if this is the final callback of the query
+        if (!result || !result.row || !result.rowNumber) {
+          const returnResult = []
+          // Before returning the array, we process it to match the expected output format
+          // const rowsToReturnProcessed = rowsToReturnRaw.reduce((acc, curr) => {
+          //   if (
+          //     Array.isArray(curr.row) &&
+          //     curr.row?.length > 0 &&
+          //     curr.columnNames.length > 0
+          //   ) {
+          //     const returnObj: ReturnObj = {
+          //       database: dbName,
+          //     }
+          //
+          //     const values = []
+          //
+          //     curr.columnNames.forEach((colName, index: number) => {
+          //       if (curr.row && curr.row[index]) {
+          //         returnObj[colName] = curr.row[index]
+          //         values.push(curr.row[index])
+          //       }
+          //     })
+          //     // rowsValueStrings.push(`(${values.join(', ')})`)
+          //     acc.push(returnObj)
+          //   }
+          //   return acc
+          // }, [] as string[])
+          for (const currRow of rowsToReturnRaw) {
+            // const values: string[] = []
+            // currRow.columnNames.forEach((colName, index: number) => {
+            //   if (currRow.row) {
+            //     values.push(currRow.row[index])
+            //   }
+            // })
+            // logger(`[db/actors] [dbExec] currRow`, currRow)
+            returnResult.push(currRow.row)
+          }
+          resolve(returnResult)
+        } else {
+          // If not the final response, add this row to the return array
+          rowsToReturnRaw.push(result)
+        }
+      },
+    }).catch(async (error) => {
+      reject(error)
+    })
+  })
+
+  // logger(`[db/actors] [dbExec] rowsToReturn`, rowsToReturn)
+  // logger(`[db/actors] [dbExec] rowsValues`, rowsValues)
+
+  return rowsToReturn || []
+}
+export const migrate = fromCallback<
+  EventObject,
+  FromCallbackInput<DbServiceContext>
+>(({ sendBack, input: { context } }) => {
+  const { pathToDbDir, dbId, dbName } = context
+
+  logger('[db/actors] migrate context', context)
+
+  const schemaGlobString = `${BROWSER_FS_TOP_DIR}/schema/*`
+
+  let journalExists = false
+
+  // const _initFs = async (): Promise<void> => {
+  //   const handle = await navigator.storage.getDirectory()
+  //   // await configure({ backend: WebAccess, handle })
+  //   await configureSingle({
+  //     backend: WebAccess,
+  //     handle,
+  //   })
+  // }
+  //
+  // _initFs()
+
+  const _checkForFiles = async (): Promise<void> => {
+    const { fs } = await import('@zenfs/core')
+
+    journalExists = await fs.promises.exists(
+      `/${pathToDbDir}/meta/_journal.json`,
+    )
+
+    if (!journalExists) {
+      window.location.reload()
+      // setTimeout(() => {
+      //   _checkForFiles().then(() => {
+      //     return
+      //   })
+      // }, 500)
+    }
+  }
+
+  const _migrate = async (): Promise<void> => {
+    const drizzleDb = drizzle(
+      async (sql, params, method) => {
+        try {
+          // logger(
+          //   `executing sql on ${dbName} with id: ${dbId} and method: ${method}`,
+          //   sql,
+          // )
+
+          const finalResult = await dbExec(dbId, params, sql, dbName)
+
+          // logger(`finalResult with method: ${method}`, finalResult)
+          // Drizzle always waits for {rows: string[][]} or {rows: string[]} for the return value.
+
+          // When the method is get,  you should return a value as {rows: string[]}.
+          // Otherwise, you should return {rows: string[][]}.
+
+          return { rows: finalResult }
+        } catch (e: any) {
+          console.error('Error from sqlite proxy server: ', JSON.stringify(e))
+          return { rows: [] }
+        }
+      },
+      {
+        schema: schemaGlobString,
+        // logger: true,
+      },
+    )
+
+    const { migrate: drizzleMigrate } = await import(
+      'drizzle-orm/sqlite-proxy/migrator'
+    )
+    const { readMigrationFiles } = await import('drizzle-orm/migrator')
+
+    try {
+      const migrations = readMigrationFiles({
+        migrationsFolder: pathToDbDir,
+      })
+
+      if (migrations.length > 0) {
+        const incomingMigrationHashes = migrations.map(
+          (migration) => migration.hash,
+        )
+
+        let existingMigrationHashes
+        let rows = []
+
+        try {
+          const query = await drizzleDb.run(
+            sql.raw(
+              `SELECT hash, created_at
+               FROM main.__drizzle_migrations;`,
+            ),
+          )
+
+          rows = query.rows
+        } catch (e) {
+          rows = []
+        }
+
+        if (rows && rows.length > 0) {
+          existingMigrationHashes = rows.map((row) => row[0])
+        }
+
+        if (existingMigrationHashes) {
+          let shouldRebuildDb = false
+          for (const existingHash of existingMigrationHashes) {
+            if (!incomingMigrationHashes.includes(existingHash)) {
+              shouldRebuildDb = true
+              break
+            }
+          }
+          if (shouldRebuildDb) {
+            await fs.promises.unlink(`${pathToDbDir}/${dbName}.sqlite3`)
+          }
+        }
+      }
+
+      await drizzleMigrate(
+        drizzleDb,
+        async (queriesToRun) => {
+          // logger('queriesToRun', queriesToRun)
+          for (const query of queriesToRun) {
+            // logger('query', query)
+            await drizzleDb.run(sql.raw(query))
+          }
+        },
+        {
+          migrationsFolder: pathToDbDir,
+        },
+      )
+    } catch (error) {
+      console.error('Error migrating database: ', error)
+      window.location.reload()
+    }
+
+    setAppDb(drizzleDb)
+    // const createTempTableQuery = await appDb.run(
+    //   sql.raw(
+    //     `CREATE TEMP TABLE IF NOT EXISTS temp_last_inserted_id (id INTEGER, table TEXT);`,
+    //   ),
+    // )
+    //
+    // logger(
+    //   '[db/actors] [migrate] createTempTableQuery',
+    //   createTempTableQuery,
+    // )
+
+    // const triggersQuery = await appDb.run(
+    //   sql.raw(
+    //     `SELECT name
+    //      FROM main.sqlite_master
+    //      WHERE type = 'trigger';`,
+    //   ),
+    // )
+    //
+    // logger('[db/actors] [migrate] triggersQuery', triggersQuery)
+    //
+    // const triggers = triggersQuery.rows.map((row) => row[0])
+    //
+    // const tablesQuery = await appDb.run(
+    //   sql.raw(
+    //     `SELECT name
+    //      FROM main.sqlite_master
+    //      WHERE type = 'table';`,
+    //   ),
+    // )
+    //
+    // logger('[db/actors] [migrate] tablesQuery', tablesQuery)
+    //
+    // const tableNames = tablesQuery.rows.map((row) => row[0])
+    // logger('[db/actors] [migrate] tableNames', tableNames)
+    // for (const tableName of tableNames) {
+    //   const triggerName = `after_insert_${tableName}`
+    //   if (triggers.includes(triggerName)) {
+    //     continue
+    //   }
+    //           const createTriggerQuery = await appDb.run(
+    //             sql.raw(
+    //               `CREATE TRIGGER after_insert_${tableName}
+    // AFTER INSERT ON ${tableName}
+    // BEGIN
+    //     DELETE FROM temp_last_inserted_id;
+    //     INSERT INTO temp_last_inserted_id (id) VALUES (new.id);
+    // END;`,
+    //             ),
+    //           )
+    //
+    //           logger(
+    //             '[db/actors] [migrate] createTriggerQuery',
+    //             createTriggerQuery,
+    //           )
+    //         }
+  }
+
+  _checkForFiles()
+    .then(() => {
+      if (journalExists) {
+        return _migrate()
+      }
+    })
+    .then(() => {
+      sendBack({ type: DB_MIGRATING_SUCCESS, dbName })
+    })
+
+  return () => {}
+})

package/dist/src/model.ts

@@ -0,0 +1,71 @@
+import { PropertyStates, PropertyValue } from './property'
+import { Actor } from 'xstate'
+import { Static } from '@sinclair/typebox'
+import { IModelClass, Item, TModelSchema } from '@/browser/schema'
+
+export type ModelDefinitions = {
+  [modelName: string]: ModelClassType
+}
+
+export type ModelStatus = (propName: string) => keyof PropertyStates
+
+export type ExcludedKeys = 'states' | 'status'
+
+type ExcludeKeys<T, K> = {
+  [P in keyof T as Exclude<P, K>]: T[P]
+}
+
+export type ModelClassType = {
+  originalConstructor: () => void
+  schema: ModelSchema
+  schemaUid?: string
+  create: <T>(values: ModelValues<T>) => Promise<Item<T>>
+}
+
+export type ModelValues<T> = Item<T> & {
+  schema: ModelSchema
+  ModelClass?: ModelClassType
+  [key: string & keyof T]: PropertyValue
+}
+
+export type StatesMap<T> = Map<string, Actor<T>>
+
+// export type ModelSchema = {
+//   [key: string]: TObject
+// }
+
+export type ModelSchema = Partial<Static<typeof TModelSchema>>
+
+export type ModelConstructor = <
+  T extends { new (...args: any[]): IModelClass },
+>(
+  constructor: T,
+) => T & IModelClass
+
+// export type ModelConstructor = Static<TModelConstructor>
+
+export interface ModelProperty {
+  propertyLocalId?: string
+  name: string
+  dataType:
+    | 'string'
+    | 'bytes32'
+    | 'uint8'
+    | 'uint256'
+    | 'bool'
+    | 'address'
+    | 'bytes'
+    | 'int8'
+    | 'int256'
+    | 'int'
+    | 'bytes32[]'
+  modelSchemaUids: string[]
+  modelLocalId?: string
+  schemaName?: string
+  schemaUid: string
+  schemaDefinition: string
+  relatedModelSchemaUid?: string
+  relatedModelLocalId?: string
+  createdAt?: number
+  updatedAt?: number
+}

package/dist/src/modelClass.ts

@@ -0,0 +1,19 @@
+import { ModelClassType } from '@/types'
+
+const modelStore = new Map<string, ModelClassType>()
+
+export const getModels = (): Record<string, ModelClassType> => {
+  return Object.fromEntries(modelStore)
+}
+
+export const getModel = (modelName: string): ModelClassType | undefined => {
+  return modelStore.get(modelName)
+}
+
+export const getModelNames = (): string[] => {
+  return Array.from(modelStore.keys())
+}
+
+export const setModel = (modelName: string, model: ModelClassType) => {
+  modelStore.set(modelName, model)
+}

package/dist/src/node.app.db.config.ts

@@ -0,0 +1,40 @@
+import { defineConfig } from 'drizzle-kit'
+import dotenv from 'dotenv'
+import process from 'node:process'
+import path from 'path'
+import { DrizzleConfig } from 'drizzle-orm'
+
+dotenv.config()
+
+let sdkRoot = './node_modules/@seedprotocol/sdk'
+
+if (process.env.IS_SEED_DEV) {
+  sdkRoot = './src'
+}
+
+let dotSeedDir = path.join(process.cwd(), '.seed')
+
+if (process.env.IS_SEED_DEV) {
+  dotSeedDir = path.join(
+    process.cwd(),
+    '__tests__',
+    '__mocks__',
+    'project',
+    '.seed',
+  )
+}
+
+let schemaDir = `${sdkRoot}/dist/shared/seedSchema/*.ts`
+
+if (process.env.IS_SEED_DEV) {
+  schemaDir = `${sdkRoot}/shared/seedSchema/*.ts`
+}
+
+export default defineConfig({
+  schema: schemaDir,
+  dialect: 'sqlite',
+  out: `${dotSeedDir}/db`,
+  dbCredentials: {
+    url: `${dotSeedDir}/db/app_db.sqlite3`,
+  },
+}) as DrizzleConfig

package/dist/src/prepareDb.ts

@@ -0,0 +1,34 @@
+import { EventObject, fromCallback } from 'xstate'
+import { SqliteConnectionManager } from '@/browser/services/db'
+import { getSqliteWasmClient, setManager } from '@/browser/db/sqlWasmClient'
+
+export const prepareDb = fromCallback<EventObject>(({ sendBack }) => {
+  let sqliteWasmClient
+  const _prepareDb = async (): Promise<void> => {
+    if (typeof window === 'undefined') {
+      return
+    }
+    sqliteWasmClient = await getSqliteWasmClient()
+  }
+
+  const interval = setInterval(() => {
+    // TODO: Add a timeout
+    // TODO: Add a cancel token to the promise so we can prevent more loops starting while we're checking the successful outcome
+    if (sqliteWasmClient) {
+      clearInterval(interval)
+      const manager = new SqliteConnectionManager(sqliteWasmClient)
+      setManager(manager)
+      sendBack({ type: 'prepareDbSuccess', manager })
+      return
+    }
+    _prepareDb().then(() => {
+      return
+    })
+  }, 200)
+
+  return () => {
+    if (interval) {
+      clearInterval(interval)
+    }
+  }
+})

package/dist/src/preparePublishRequestData.ts

@@ -0,0 +1,81 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PublishMachineContext } from '@/types'
+import { Item } from '@/browser/item'
+import { models as modelsTable, modelUids } from '@/shared/seedSchema'
+import { getAppDb } from '@/browser'
+import { eq } from 'drizzle-orm'
+import { getModelSchemas } from '@/browser/db/read/getModelSchemas'
+
+export const preparePublishRequestData = fromCallback<
+  EventObject,
+  FromCallbackInput<PublishMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { localId } = context
+
+  const _preparePublishRequestData = async () => {
+    const item = await Item.find({ seedLocalId: localId })
+
+    if (!item) {
+      return false
+    }
+
+    const appDb = getAppDb()
+
+    const modelsRows = await appDb
+      .select({
+        modelName: modelsTable.name,
+        schemaUid: modelUids.uid,
+      })
+      .from(modelsTable)
+      .leftJoin(modelUids, eq(modelUids.modelId, modelsTable.id))
+      .where(eq(modelsTable.name, 'Version'))
+
+    if (!modelsRows || modelsRows.length === 0) {
+      sendBack({ type: 'preparePublishRequestDataError' })
+      return false
+    }
+
+    const versionSchemaUid = modelsRows[0].schemaUid
+
+    const editedProperties = await item.getEditedProperties()
+
+    const { modelSchemas, schemaStringToModelRecord } = await getModelSchemas({
+      sdkConfigDb: appDb,
+    })
+
+    // const dataEncoder = new SchemaEncoder(modelProperty.schemaDefinition,)
+    // const encodedData = dataEncoder.encodeData(data,)
+    //
+    // itemData.listOfAttestations.push({
+    //   schema : modelProperty.schemaUid,
+    //   data   : [
+    //     {
+    //       ...defaultAttestationData,
+    //       data : encodedData,
+    //     },
+    //   ],
+    // },)
+
+    const publishRequestData = {
+      seedIsRevocable: false,
+      seedSchemaUid: item.schemaUid,
+      seedUid: item.seedUid,
+      versionSchemaUid,
+      versionUid: item.latestVersionUid,
+      listOfAttestations: [],
+    }
+
+    sendBack({
+      type: 'updateContext',
+      ...publishRequestData,
+    })
+
+    return true
+  }
+
+  _preparePublishRequestData().then((success) => {
+    if (success) {
+      sendBack({ type: 'preparePublishRequestDataSuccess' })
+    }
+  })
+})