@seedprotocol/sdk 0.1.128 → 0.2.0

package/dist/src/ItemProperty.ts

@@ -1,456 +1,16 @@
-import { CreatePropertyInstanceProps, PropertyMachineContext } from '@/types'
-import {
-  ActorRefFrom,
-  createActor,
-  SnapshotFrom,
-  Subscription,
-  waitFor,
-} from 'xstate'
-import { BehaviorSubject, Subscriber } from 'rxjs'
-import { propertyMachine } from './propertyMachine'
-import { immerable } from 'immer'
-import pluralize from 'pluralize'
-import { eventEmitter } from '@/eventBus'
-import { getPropertyData } from '@/browser/db/read'
-import { internalPropertyNames } from '@/shared/helpers/constants'
-import debug from 'debug'
-import { getModel } from '@/browser/stores/modelClass'
-import { getCorrectId } from '@/browser/helpers'
-import { Static } from '@sinclair/typebox'
-import { TProperty } from '@/browser/property'
-import { fs } from '@zenfs/core'
+import { CreatePropertyInstanceProps, PropertyType } from '@/types'
+import { IItemProperty } from '@/interfaces/IItemProperty'
+import { BaseItemProperty } from '@/ItemProperty/BaseItemProperty'
 
-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
-}
-
-const namesThatEndWithId: string[] = []
-
-export class ItemProperty<PropertyType> {
-  private static instanceCache: Map<
-    string,
-    { instance: ItemProperty<any>; refCount: number }
-  > = new Map()
-  private readonly _service: ItemPropertyService
-  private _subject: BehaviorSubject<any>
-  private readonly _isRelation: boolean = false
-  private readonly _isList: boolean = false
-  private readonly _alias: string | undefined
-  private _subscription: Subscription
-  private _dataType: string | undefined
-  private _schemaUid: string | undefined
-  private _updateResponseEvent: string | undefined;
-  [immerable] = true
-
-  // private constructor(localIdOrUid) {
-  // }
-
-  constructor({
-    propertyValue,
-    seedUid,
-    seedLocalId,
-    versionLocalId,
-    versionUid,
-    modelName,
-    propertyName,
-    storageTransactionId,
-    schemaUid,
-  }: Partial<CreatePropertyInstanceProps>) {
-    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
-
-      if (
-        propertyName.endsWith('Id') &&
-        !namesThatEndWithId.includes(propertyName)
-      ) {
-        propertyNameWithoutId = propertyName.slice(0, -2)
-      }
-
-      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 = ItemProperty.cacheKey(
-            context.seedLocalId,
-            context.propertyName,
-          )
-          if (!ItemProperty.instanceCache.has(cacheKey)) {
-            ItemProperty.instanceCache.set(cacheKey, {
-              instance: this,
-              refCount: 1,
-            })
-          }
-          // this._updateResponseEvent = `property.${context.seedLocalId}.${this.propertyName}.save.response`
-          // eventEmitter.addListener(
-          //   this._updateResponseEvent,
-          //   this._updateResponseListener,
-          // )
-        }
-
-        if (
-          context.seedUid ===
-            '0x66922b8f40057eb04f94983d59a608e32bceb95b47134dd5b550688940c64f1d' &&
-          propertyName === 'featureImage'
-        ) {
-          console.log('context', context)
-        }
-
-        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)
-        if (context.seedLocalId) {
-          eventEmitter.emit(`item.${modelName}.${context.seedLocalId}.update`)
-        }
-        if (context.seedUid) {
-          eventEmitter.emit(`item.${modelName}.${context.seedUid}.update`)
-        }
-      },
-    )
-
-    this._service.start()
-  }
-
-  private _updateResponseListener(event) {
-    logger(
-      `[ItemProperty] [_updateResponseListener] [${this.modelName}.${this.seedLocalId}] ${this.propertyName} event`,
-      event,
-    )
-  }
-
-  static create(
-    props: Partial<CreatePropertyInstanceProps>,
-  ): ItemProperty<any> | undefined {
-    const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } =
-      props
-    if (!propertyName || (!seedLocalId && !seedUid)) {
-      return
-    }
-    const cacheKey = ItemProperty.cacheKey(
-      (seedUid || seedLocalId) as string,
-      propertyName,
-    )
-    if (seedLocalId && propertyName) {
-      if (ItemProperty.instanceCache.has(cacheKey)) {
-        const { instance, refCount } = ItemProperty.instanceCache.get(cacheKey)!
-        ItemProperty.instanceCache.set(cacheKey, {
-          instance,
-          refCount: refCount + 1,
-        })
-        return instance
-      }
-      if (!ItemProperty.instanceCache.has(cacheKey)) {
-        const newInstance = new ItemProperty(props)
-        ItemProperty.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 ItemProperty(props)
-        this.instanceCache.set(cacheKey, { instance: newInstance, refCount: 1 })
-        return newInstance
-      }
-    }
-    return new ItemProperty(props)
-  }
+export class ItemProperty extends BaseItemProperty<PropertyType> implements IItemProperty<PropertyType> {
 
-  static async find({
-    propertyName,
-    seedLocalId,
-    seedUid,
-  }: ItemPropertyFindProps): Promise<ItemProperty<any> | undefined> {
-    if ((!seedLocalId && !seedUid) || !propertyName) {
-      return
-    }
-    const cacheKeyId = seedUid || seedLocalId
-    const cacheKey = ItemProperty.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 ItemProperty.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
+  constructor(initialValues: Partial<CreatePropertyInstanceProps>) {
+    super(initialValues)
   }
 
-  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()
-    logger(
-      `[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`,
-      this._updateResponseEvent,
-    )
-    eventEmitter.removeListener(
-      this._updateResponseEvent,
-      this._updateResponseListener,
-    )
-  }
 }
+
+BaseItemProperty.setPlatformClass(ItemProperty)

package/dist/src/QueryClientWeb.ts

@@ -0,0 +1,20 @@
+import { BaseQueryClient } from '@/helpers/BaseQueryClient'
+import { IQueryClient } from '@/interfaces/IQueryClient'
+import { QueryClient } from '@tanstack/react-query'
+
+class QueryClientWeb extends BaseQueryClient {
+  static getQueryClient(): IQueryClient {
+    return new QueryClient({
+      defaultOptions: {
+        queries: {
+          networkMode: 'offlineFirst',
+          gcTime: 1000 * 60 * 60 * 24, // 24 hours
+        },
+      },
+    })
+  }
+}
+
+BaseQueryClient.setPlatformClass(QueryClientWeb)
+
+export { QueryClientWeb }

package/dist/src/SeedProtocolSdk.d.ts

@@ -0,0 +1,34 @@
+export interface SeedProtocolSdk {
+  // Exported classes
+  Item: typeof import('@/browser/item/Item').Item;
+  ItemProperty: typeof import('@/browser/property/ItemProperty').ItemProperty;
+
+  // Exported hooks
+  useItems: typeof import('@/browser').useItems;
+  useItem: typeof import('@/browser').useItem;
+  useItemProperties: typeof import('@/browser').useItemProperties;
+  useCreateItem: typeof import('@/browser').useCreateItem;
+  useItemProperty: typeof import('@/browser').useItemProperty;
+  useDeleteItem: typeof import('@/browser').useDeleteItem;
+  useGlobalServiceStatus: typeof import('@/browser').useGlobalServiceStatus;
+  useServices: typeof import('@/browser').useServices;
+
+  // Exported functions
+  getGlobalService: typeof import('@/browser').getGlobalService;
+  getCorrectId: typeof import('@/helpers').getCorrectId;
+
+  // Exported constants
+  eventEmitter: typeof import('@/eventBus').eventEmitter;
+
+  // Exported types
+  Model: typeof import('@/browser/schema').Model;
+  Property: typeof import('@/browser/schema').Property;
+  ImageSrc: typeof import('@/browser/schema').ImageSrc;
+  List: typeof import('@/browser/schema').List;
+  Text: typeof import('@/browser/schema').Text;
+  Json: typeof import('@/browser/schema').Json;
+  Relation: typeof import('@/browser/schema').Relation;
+
+  // Node-specific exports
+  withSeed?: typeof import('@/node').withSeed;
+} 

package/dist/src/addModelsToDb.ts

@@ -1,14 +1,16 @@
 import { EventObject, fromCallback } from 'xstate'
-import { models as modelsTable, modelUids } from '@/shared/seedSchema'
+import { models as modelsTable, modelUids } from '@/seedSchema'
 import { eq } from 'drizzle-orm'
-import { toSnakeCase } from '@/shared/helpers'
-import { easClient, queryClient } from '@/browser/helpers'
-import { getAppDb } from '@/browser/db/sqlWasmClient'
-import { GLOBAL_ADDING_MODELS_TO_DB_SUCCESS } from '@/browser/services/internal/constants'
+import { toSnakeCase, BaseEasClient, BaseQueryClient } from '@/helpers'
+import { BaseDb } from '@/db/BaseDb'
+import { GLOBAL_ADDING_MODELS_TO_DB_SUCCESS } from '@/services/internal/constants'
 import { eventEmitter } from '@/eventBus'
 import { FromCallbackInput, GlobalMachineContext } from '@/types'
 import debug from 'debug'
-import { GET_SCHEMAS } from '@/browser/item/queries'
+import { GET_SCHEMAS } from '@/Item/queries'
+
+const easClient = BaseEasClient.getEasClient()
+const queryClient = BaseQueryClient.getQueryClient()
 
 const logger = debug('app:services:global:actors:addModelsToDb')
 
@@ -19,7 +21,7 @@ export const addModelsToDb = fromCallback<
   const { models } = context
 
   const _addModelsToDb = async () => {
-    const appDb = getAppDb()
+    const appDb = BaseDb.getAppDb()
 
     if (!models) {
       return
@@ -146,5 +148,5 @@ export const addModelsToDb = fromCallback<
     return
   })
 
-  return () => {}
+  return () => { }
 })

package/dist/src/allItems.ts

@@ -1,6 +1,6 @@
-import { getGlobalService } from '@/browser/services/global'
+import { getGlobalService } from '@/services/global'
 
-import { saveAppState } from '@/browser/db/write/saveAppState'
+import { saveAppState } from '@/db/write/saveAppState'
 
 type SaveServiceEvent = {
   modelName: string

package/dist/src/analyzeInput.ts

@@ -5,10 +5,10 @@ import {
   PropertyMachineContext,
   SaveValueToDbEvent,
 } from '@/types/property'
-import { updateItemPropertyValue } from '@/browser/db/write/updateItemPropertyValue'
+import { updateItemPropertyValue } from '@/db/write/updateItemPropertyValue'
 
-import { getSchemaForItemProperty } from '@/browser/helpers/getSchemaForItemProperty'
-import { INTERNAL_DATA_TYPES } from '@/shared/helpers/constants'
+import { getSchemaForItemProperty } from '@/helpers/getSchemaForItemProperty'
+import { INTERNAL_DATA_TYPES } from '@/helpers/constants'
 import { TypedData } from '@ethereum-attestation-service/eas-sdk/dist/offchain/typed-data-handler'
 
 export const analyzeInput = fromCallback<

package/dist/src/browser.seed.db.config.ts

@@ -24,7 +24,7 @@ if (process.env.IS_SEED_DEV) {
 }
 
 export default defineConfig({
-  schema: `${sdkRoot}/browser/db/seedSchema/*Schema.ts`,
+  schema: `${sdkRoot}/db/seedSchema/*Schema.ts`,
   dialect: 'sqlite',
   out: `${dotSeedDir}/seed/db`,
   dbCredentials: {

package/dist/src/checkStatus.ts

@@ -4,7 +4,7 @@ import {
   BROWSER_FS_TOP_DIR,
   DB_CHECK_STATUS_EXISTS,
   DB_CHECK_STATUS_UPDATE_PATHS,
-} from '@/browser/services/internal/constants'
+} from '@/services/internal/constants'
 import debug from 'debug'
 
 const logger = debug('app:services:db:actors:checkStatus')

package/dist/src/client.ts

@@ -1,16 +1,16 @@
-import { areFsListenersReady, setupFsListeners } from '@/browser/events/files'
-import { setupAllItemsEventHandlers } from '@/browser/events'
-import { setupServicesEventHandlers } from '@/browser/services/events'
+import { areFsListenersReady, setupFsListeners } from '@/events/files'
+import { setupAllItemsEventHandlers } from '@/events'
+import { setupServicesEventHandlers } from '@/services/events'
 import { eventEmitter } from '@/eventBus'
-import { globalService } from '@/browser/services'
+import { globalService } from '@/services'
 import { ModelClassType, SeedConstructorOptions } from '@/types'
 import {
   getModel,
   getModelNames,
   getModels,
   setModel,
-} from '@/browser/stores/modelClass'
-import { setupServiceHandlers } from '@/browser/events/services'
+} from '@/stores/modelClass'
+import { setupServiceHandlers } from '@/events/services'
 import { setArweaveDomain } from '@/browser/helpers/arweave'
 
 const client = {

package/dist/src/configureFs.ts

@@ -1,11 +1,11 @@
 import { EventObject, fromCallback } from 'xstate'
-import { areFsListenersReady, isFsInitialized } from '@/browser/events/files'
-import { waitForEvent } from '@/browser/events'
+import { areFsListenersReady, isFsInitialized } from '@/events/files'
+import { waitForEvent } from '@/events'
 import {
   BROWSER_FS_TOP_DIR,
   DB_WAITING_FOR_FILES_RECEIVED,
   INTERNAL_CONFIGURING_FS_SUCCESS,
-} from '@/browser/services/internal/constants'
+} from '@/services/internal/constants'
 import { fs } from '@zenfs/core'
 import debug from 'debug'
 import { FromCallbackInput, InternalMachineContext } from '@/types'
@@ -77,5 +77,5 @@ export const configureFs = fromCallback<
     return
   })
 
-  return () => {}
+  return () => { }
 })