@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/BaseItemProperty.ts

@@ -0,0 +1,416 @@
+import { ActorRefFrom, createActor, SnapshotFrom, Subscription, waitFor } from 'xstate'
+import { BehaviorSubject, Subscriber } from 'rxjs'
+import { Static } from '@sinclair/typebox'
+import { IItemProperty } from '@/interfaces/IItemProperty'
+import { immerable } from 'immer'
+import { CreatePropertyInstanceProps, PropertyMachineContext } from '@/types'
+import { getModel } from '@/stores/modelClass'
+import { propertyMachine } from './service/propertyMachine'
+import { internalPropertyNames } from '@/helpers/constants'
+import debug from 'debug'
+import pluralize from 'pluralize'
+import { eventEmitter } from '@/eventBus'
+import fs from '@zenfs/core'
+import { getPropertyData } from '@/db/read/getPropertyData'
+import { getCorrectId } from '@/helpers'
+import { TProperty } from '@/schema'
+
+const logger = debug('app:property:class')
+
+type ItemPropertyService = ActorRefFrom<typeof propertyMachine>
+type ItemPropertySnapshot = SnapshotFrom<typeof propertyMachine>
+
+type ItemPropertyFindProps = {
+  propertyName: string
+  propertyLocalId?: string
+  seedLocalId?: string
+  seedUid?: string
+}
+
+export abstract class BaseItemProperty<PropertyType> implements IItemProperty<PropertyType> {
+  protected static instanceCache: Map<
+    string,
+    { instance: BaseItemProperty<any>; refCount: number }
+  > = new Map()
+  protected readonly _service: ItemPropertyService
+  protected _subject: BehaviorSubject<any>
+  protected readonly _isRelation: boolean = false
+  protected readonly _isList: boolean = false
+  protected readonly _alias: string | undefined
+  protected _subscription: Subscription
+  protected _dataType: string | undefined
+  protected _schemaUid: string | undefined
+  [immerable] = true
+
+  constructor(initialValues: Partial<CreatePropertyInstanceProps>) {
+    const { modelName, propertyName, propertyValue, seedLocalId, seedUid, versionLocalId, versionUid, storageTransactionId, schemaUid } = initialValues
+
+    if (!modelName) {
+      throw new Error('Model name is required')
+    }
+
+    const ModelClass = getModel(modelName)
+
+    if (!ModelClass) {
+      throw new Error(`Model ${modelName} not found`)
+    }
+
+    if (!propertyName) {
+      throw new Error(`Property name not provided`)
+    }
+
+    const serviceInput: Partial<PropertyMachineContext> = {
+      propertyValue,
+      propertyName,
+      seedLocalId,
+      seedUid,
+      versionLocalId,
+      versionUid,
+      modelName: modelName,
+      storageTransactionId,
+      propertyRecordSchema: ModelClass.schema[propertyName],
+      schemaUid,
+    }
+
+
+
+    if (!internalPropertyNames.includes(propertyName)) {
+      let propertyNameWithoutId
+
+      const propertyRecordSchema =
+        ModelClass.schema[propertyNameWithoutId || propertyName]
+      if (propertyRecordSchema) {
+        this._dataType = propertyRecordSchema.dataType
+
+        serviceInput.propertyRecordSchema = propertyRecordSchema
+
+        if (propertyRecordSchema.dataType === 'Relation') {
+          this._isRelation = true
+        }
+
+        if (
+          propertyRecordSchema.dataType === 'List' &&
+          propertyRecordSchema.ref
+        ) {
+          this._isList = true
+          this._isRelation = true
+
+          if (propertyValue) {
+            try {
+              serviceInput.propertyValue = JSON.parse(propertyValue)
+            } catch (e) {
+              logger('List property value is not JSON', e)
+            }
+          }
+
+          const propertyNameSingular = pluralize(propertyName!, 1)
+
+          this._alias = propertyName
+
+          serviceInput.propertyName = `${propertyNameSingular}${propertyRecordSchema.ref}Ids`
+        }
+
+        if (!this._alias && propertyNameWithoutId) {
+          this._alias = propertyNameWithoutId
+        }
+      }
+    }
+
+    serviceInput.isRelation = this._isRelation
+
+    this._subject = new BehaviorSubject(propertyValue)
+    this._service = createActor(propertyMachine, {
+      input: serviceInput,
+    })
+
+    this._subscription = this._service.subscribe(
+      async (snapshot: ItemPropertySnapshot) => {
+        if (!snapshot || !snapshot.context) {
+          return
+        }
+
+        const { context } = snapshot
+        const { propertyRecordSchema } = context
+
+        if (context.seedLocalId) {
+          const cacheKey = BaseItemProperty.cacheKey(
+            context.seedLocalId,
+            context.propertyName,
+          )
+          if (!BaseItemProperty.instanceCache.has(cacheKey)) {
+            BaseItemProperty.instanceCache.set(cacheKey, {
+              instance: this,
+              refCount: 1,
+            })
+          }
+        }
+
+        let renderValue
+
+        if (
+          propertyRecordSchema &&
+          propertyRecordSchema.storageType &&
+          propertyRecordSchema.storageType === 'ItemStorage' &&
+          context.refResolvedValue &&
+          context.localStorageDir
+        ) {
+          const filePath = `/files/${context.localStorageDir}/${context.refResolvedValue}`
+          try {
+            const exists = await fs.promises.exists(filePath)
+            if (exists) {
+              renderValue = await fs.promises.readFile(filePath, 'utf-8')
+            }
+            if (!exists) {
+              renderValue = 'No file found'
+            }
+          } catch (e) {
+            logger(
+              `[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`,
+              e,
+            )
+            renderValue = 'No file found'
+          }
+        }
+
+        if (!renderValue) {
+          renderValue = context.renderValue || context.propertyValue
+        }
+
+        let transformedPropertyName = propertyName
+
+        const skipTransform =
+          internalPropertyNames.includes(propertyName) || !!this._alias
+
+        if (!skipTransform && transformedPropertyName.endsWith('Id')) {
+          transformedPropertyName = transformedPropertyName.slice(0, -2)
+        }
+
+        if (!skipTransform && transformedPropertyName.endsWith('Ids')) {
+          transformedPropertyName = transformedPropertyName.slice(0, -3)
+        }
+
+        if (skipTransform && this._alias) {
+          transformedPropertyName = this._alias
+        }
+
+        if (skipTransform && !this._alias) {
+        }
+
+        if (this._subject.value === renderValue) {
+          return
+        }
+
+        this._subject.next(renderValue)
+        // TODO: Maybe have this only update the property?
+        // if (context.seedLocalId || context.seedUid) {
+        //   eventEmitter.emit(`property.${context.seedUid || context.seedLocalId}.${propertyName}.update`)
+        // }
+        // if (context.seedUid) {
+        //   eventEmitter.emit(`item.${modelName}.${context.seedUid}.update`)
+        // }
+      },
+    )
+
+    this._service.start()
+  }
+
+  static PlatformClass: typeof BaseItemProperty
+
+  static setPlatformClass(platformClass: typeof BaseItemProperty) {
+    this.PlatformClass = platformClass
+  }
+
+  static create(
+    props: Partial<CreatePropertyInstanceProps>,
+  ): BaseItemProperty<any> | undefined {
+    const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } =
+      props
+    if (!propertyName || (!seedLocalId && !seedUid)) {
+      return
+    }
+    const cacheKey = this.cacheKey(
+      (seedUid || seedLocalId) as string,
+      propertyName,
+    )
+    if (seedLocalId && propertyName) {
+      if (this.instanceCache.has(cacheKey)) {
+        const { instance, refCount } = this.instanceCache.get(cacheKey)!
+        this.instanceCache.set(cacheKey, {
+          instance,
+          refCount: refCount + 1,
+        })
+        return instance
+      }
+      if (!this.instanceCache.has(cacheKey)) {
+        const newInstance = new this(props)
+        this.instanceCache.set(cacheKey, {
+          instance: newInstance,
+          refCount: 1,
+        })
+        return newInstance
+      }
+    }
+    if (seedUid && propertyName) {
+      if (this.instanceCache.has(cacheKey)) {
+        const { instance, refCount } = this.instanceCache.get(cacheKey)!
+        this.instanceCache.set(cacheKey, { instance, refCount: refCount + 1 })
+        return instance
+      }
+      if (!this.instanceCache.has(cacheKey)) {
+        const newInstance = new this(props)
+        this.instanceCache.set(cacheKey, { instance: newInstance, refCount: 1 })
+        return newInstance
+      }
+    }
+    return new this(props)
+  }
+
+  static async find({
+    propertyName,
+    seedLocalId,
+    seedUid,
+  }: ItemPropertyFindProps): Promise<IItemProperty<any> | undefined> {
+    if ((!seedLocalId && !seedUid) || !propertyName) {
+      return
+    }
+    const cacheKeyId = seedUid || seedLocalId
+    const cacheKey = BaseItemProperty.cacheKey(cacheKeyId!, propertyName)
+    if (this.instanceCache.has(cacheKey)) {
+      const { instance, refCount } = this.instanceCache.get(cacheKey)!
+      this.instanceCache.set(cacheKey, {
+        instance,
+        refCount: refCount + 1,
+      })
+      return instance
+    }
+    const propertyData = await getPropertyData({
+      propertyName,
+      seedLocalId,
+      seedUid,
+    })
+    if (!propertyData) {
+      return
+    }
+    return BaseItemProperty.create(propertyData)
+  }
+
+  static cacheKey(seedLocalIdOrUid: string, propertyName: string): string {
+    const { uid, localId } = getCorrectId(seedLocalIdOrUid)
+    return `Item_${uid || localId}_${propertyName}`
+  }
+
+  getService() {
+    return this._service
+  }
+
+  private _getSnapshot(): ItemPropertySnapshot {
+    return this._service.getSnapshot() as ItemPropertySnapshot
+  }
+
+  get localId() {
+    return this._getSnapshot().context.localId
+  }
+
+  get uid() {
+    return this._getSnapshot().context.uid
+  }
+
+  get seedLocalId() {
+    return this._getSnapshot().context.seedLocalId
+  }
+
+  get seedUid() {
+    return this._getSnapshot().context.seedUid
+  }
+
+  get schemaUid() {
+    return this._getSnapshot().context.schemaUid
+  }
+
+  get propertyName() {
+    if (this._alias) {
+      return this._alias
+    }
+    return this._getSnapshot().context.propertyName
+  }
+
+  get modelName() {
+    return this._getSnapshot().context.modelName
+  }
+
+  get propertyDef(): Static<typeof TProperty> | undefined {
+    return this._getSnapshot().context.propertyRecordSchema
+  }
+
+  get localStoragePath(): string | void {
+    if (this.propertyDef && this.propertyDef.localStorageDir) {
+      return `/files${this.propertyDef.localStorageDir}/${this._getSnapshot().context.refResolvedValue}`
+    }
+    if (this._getSnapshot().context.localStorageDir) {
+      return `/files${this._getSnapshot().context.localStorageDir}/${this._getSnapshot().context.refResolvedValue}`
+    }
+  }
+
+  get versionLocalId(): string | undefined {
+    return this._getSnapshot().context.versionLocalId
+  }
+
+  get status() {
+    return this._getSnapshot().value
+  }
+
+  get alias() {
+    return this._alias
+  }
+
+  get value() {
+    // logger(
+    //   `[XXXXXXXXXX] [value] [get] subjectValue: ${this._subject.value} serviceValue: ${this._service.getSnapshot().context.renderValue}`,
+    // )
+    return this._subject.value
+  }
+
+  set value(value: any) {
+    if (this._subject.value === value) {
+      return
+    }
+    const context = this._service.getSnapshot().context
+    if (!context.propertyRecordSchema) {
+      this._subject.next(value)
+    }
+    this._service.send({
+      type: 'save',
+      newValue: value,
+    })
+  }
+
+  get published(): boolean {
+    return !!this._getSnapshot().context.uid
+  }
+
+  subscribe(callback: Partial<Subscriber<any>>) {
+    return this._subject.subscribe(callback)
+  }
+
+  async save(): Promise<void> {
+    await waitFor(
+      this._service,
+      (snapshot) => !snapshot.context.isSaving && snapshot.value === 'idle',
+      {
+        timeout: 10_000,
+      },
+    )
+    // return new Promise((resolve) => {
+    //   const saveSub = this._service.subscribe((snapshot) => {
+    //     if (!snapshot.context.isSaving) {
+    //       saveSub.unsubscribe()
+    //       resolve()
+    //     }
+    //   })
+    // })
+  }
+
+  unload() {
+    this._service.stop()
+  }
+} 

package/dist/src/BaseQueryClient.ts

@@ -0,0 +1,13 @@
+import { IQueryClient } from "@/interfaces/IQueryClient"
+
+export abstract class BaseQueryClient {
+  static PlatformClass: typeof BaseQueryClient
+
+  static setPlatformClass(platformClass: typeof BaseQueryClient) {
+    this.PlatformClass = platformClass
+  }
+
+  static getQueryClient(): IQueryClient {
+    return this.PlatformClass.getQueryClient()
+  }
+} 

package/dist/src/ClientManager.ts

@@ -0,0 +1,63 @@
+import debug                      from 'debug'
+import { createActor, waitFor }   from 'xstate'
+import { clientManagerMachine }   from '@/client/clientManagerMachine'
+import { SeedConstructorOptions } from '@/types/index'
+import { BaseDb }                 from '@/db/Db/BaseDb'
+import { appState }               from '@/seedSchema'
+import { eq }                     from 'drizzle-orm'
+import { CLIENT_NOT_INITIALIZED } from '@/helpers/constants'
+
+const logger               = debug('app:client')
+
+export const clientManager = createActor(clientManagerMachine, {
+  input: {
+    isInitialized: false,
+  }
+})
+
+const subscription         = clientManager.subscribe(( snapshot ) => {
+  logger('ClientManager snapshot.value:', snapshot.value)
+  logger('ClientManager snapshot.context.isInitialized:', snapshot.context.isInitialized)
+})
+
+clientManager.start()
+
+const ensureInitialized = () => {
+  if (!clientManager.getSnapshot().context.isInitialized) {
+    throw new Error(CLIENT_NOT_INITIALIZED);
+  }
+}
+
+export const ClientManager = {
+  isInitialized: () => clientManager.getSnapshot().context.isInitialized,
+  getService: () => {
+    ensureInitialized();
+    return clientManager;
+  },
+  init: async (options: SeedConstructorOptions) => {
+    clientManager.send({ type: 'init', options });
+    await waitFor(clientManager, (snapshot) => snapshot.context.isInitialized);
+  },
+  setAddresses: async (addresses: string[]) => {
+    ensureInitialized();
+    logger('setAddresses', addresses);
+    clientManager.send({ type: 'setAddresses', addresses });
+    await waitFor(clientManager, (snapshot) => !snapshot.context.isSaving);
+    logger('setAddresses success', addresses);
+  },
+  getAddresses: async () => {
+    ensureInitialized();
+    const db = await BaseDb.getAppDb();
+    const results = await db.select().from(appState).where(eq(appState.key, 'addresses'));
+    return JSON.parse(results[0]?.value);
+  },
+  stop: () => {
+    ensureInitialized();
+    clientManager.stop();
+  },
+  unload: () => {
+    ensureInitialized();
+    clientManager.stop();
+    subscription.unsubscribe();
+  },
+}

package/dist/src/ConfigSchema.ts

@@ -0,0 +1,15 @@
+import { blob, int, sqliteTable, text, check, } from 'drizzle-orm/sqlite-core'
+import { sql }                          from 'drizzle-orm'
+
+export const config = sqliteTable('config', {
+  id: int('id').primaryKey({ autoIncrement: true }),
+  key: text('key').notNull(),
+  text: text('text'),
+  json: text('json', {mode: 'json'}),
+  blob: blob('blob', {mode: 'buffer'}),
+}, () => {
+  return {
+    // Add a custom check constraint
+    atLeastOneNotNull: check('hasValue', sql`key IS NOT NULL OR text IS NOT NULL OR json IS NOT NULL OR blob IS NOT NULL`),
+  }
+})

package/dist/src/Db.ts

@@ -0,0 +1,82 @@
+import { BaseDb }         from "@/db/Db/BaseDb";
+import { IDb }            from "@/interfaces";
+import nodeAppDbConfig                    from "./node.app.db.config";
+import { BetterSQLite3Database, drizzle } from "drizzle-orm/better-sqlite3";
+import { defineConfig, }                  from "drizzle-kit";
+import path               from "path";
+import { DrizzleConfig, } from "drizzle-orm";
+import { isBrowser }      from '@/helpers/environment'
+import {migrate}          from 'drizzle-orm/better-sqlite3/migrator'
+import fs from 'fs'
+import debug from 'debug'
+import { appState } from '@/seedSchema'
+
+const logger = debug('app:node:db:Db')
+
+const getConfig = (dotSeedDir: string) => {
+
+  let schemaDir = `${dotSeedDir}/schema/*Schema.ts`
+  if (!isBrowser()) {
+    schemaDir = path.join(process.cwd(), 'schema')
+  }
+
+  const nodeDbConfig = defineConfig({
+    schema: schemaDir,
+    dialect: 'sqlite',
+    out: `${dotSeedDir}/db`,
+    dbCredentials: {
+      url: `${dotSeedDir}/db/app_db.sqlite3`,
+    }
+  }) as DrizzleConfig & { dbCredentials: { url: string } }
+
+  return nodeDbConfig
+}
+
+class Db extends BaseDb implements IDb {
+  static db: BetterSQLite3Database
+  constructor() {
+    super()
+  }
+
+  static getAppDb() {
+    return this.db
+  }
+
+  static isAppDbReady() {
+    return true
+  }
+
+  static async prepareDb(filesDir: string) {
+    const nodeDbConfig = getConfig(filesDir)
+
+    this.db = drizzle({
+      ...nodeDbConfig,
+      logger: true,
+    })
+
+    if (!this.db) {
+      throw new Error('Db not found')
+    }
+
+    return this.db
+  }
+
+  static async connectToDb(pathToDir: string, dbName: string) {
+
+    return {
+      id: this.db.constructor.name
+    }
+  }
+
+  static async migrate(pathToDbDir: string, dbName: string, dbId: string) {
+    migrate(this.db, { migrationsFolder: pathToDbDir })
+    const queryResult = await this.db.select().from(appState)
+    logger('queryResult', queryResult)
+
+    return this.db
+  }
+}
+
+BaseDb.setPlatformClass(Db)
+
+export { Db }

package/dist/src/EasClient.ts

@@ -0,0 +1,13 @@
+import { BaseEasClient } from "@/helpers/EasClient/BaseEasClient"
+import { EAS_ENDPOINT } from "@/services/internal/constants"
+import { GraphQLClient } from "graphql-request"
+
+class EasClient extends BaseEasClient {
+  static getEasClient() {
+    return new GraphQLClient(EAS_ENDPOINT)
+  }
+}
+
+BaseEasClient.setPlatformClass(EasClient)
+
+export { EasClient }

package/dist/src/FileDownloader.ts

@@ -0,0 +1,63 @@
+import { saveAppState } from '@/db/write/saveAppState.js';
+import filesDownload from './filesDownload.js'
+
+
+
+export class FileDownloader {
+  private cores: number
+  private workersArchive: Worker[] = []
+  private workerBlobUrl: string
+
+  constructor() {
+    this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+
+    this.workerBlobUrl = globalThis.URL.createObjectURL(
+      new Blob([filesDownload], { type: 'application/javascript' })
+    )
+  }
+
+  public downloadAll = async ({transactionIds, arweaveHost, excludedTransactions}: DownloadAllFilesParams): Promise<void> => {
+
+    if (this.workersArchive.length > 0) {
+      for (let i = 0; i < this.workersArchive.length; i++) {
+        this.workersArchive[i].terminate()
+        delete this.workersArchive[i]
+      }
+      this.workersArchive = []
+    }
+
+    const worker = new Worker(this.workerBlobUrl);
+
+    this.workersArchive.push(worker)
+
+    const localExcludedTransactions = new Set(excludedTransactions)
+
+    return new Promise((resolve, reject) => {
+      worker.onmessage = (e) => {
+        console.log('filesDownload main thread onmessage', e.data);
+
+        if (e.data.message === 'excludeTransaction') {
+          localExcludedTransactions.add(e.data.transactionId)
+        }
+
+        if (e.data.done) {
+          saveAppState('excludedTransactions', JSON.stringify(Array.from(localExcludedTransactions)))
+          .then(() => {
+            resolve(e.data)
+          })
+          .catch((error) => {
+            reject(error)
+          })
+        }
+        if (e.data.error) {
+          reject(e.data.error)
+        }
+      }
+  
+      worker.postMessage({
+        transactionIds,
+        arweaveHost,
+      });
+    })
+  }
+}