@seedprotocol/sdk 0.3.1 → 0.3.3

package/dist/src/BaseItemProperty.ts

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

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

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

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

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

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

@@ -1,63 +0,0 @@
-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,
-      });
-    })
-  }
-}