@seedprotocol/sdk 0.1.129 → 0.2.1

package/dist/src/BaseItemProperty.ts

@@ -0,0 +1,415 @@
+import { ActorRefFrom, createActor, SnapshotFrom, Subscription, waitFor } from 'xstate'
+import { BehaviorSubject, Subscriber } from 'rxjs'
+import { Static } from '@sinclair/typebox'
+import { ItemProperty, TProperty } from '@/browser/property'
+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'
+
+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: IItemProperty<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 = ItemProperty.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)
+        if (context.seedLocalId) {
+          eventEmitter.emit(`item.${modelName}.${context.seedLocalId}.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>,
+  ): IItemProperty<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 ItemProperty(props)
+        this.instanceCache.set(cacheKey, { instance: newInstance, refCount: 1 })
+        return newInstance
+      }
+    }
+    return new ItemProperty(props)
+  }
+
+  static async find({
+    propertyName,
+    seedLocalId,
+    seedUid,
+  }: ItemPropertyFindProps): Promise<IItemProperty<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
+  }
+
+  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/Db.ts

@@ -0,0 +1,8 @@
+import { BaseDb } from "@/db/BaseDb";
+import { IDb } from "@/interfaces";
+
+export class Db extends BaseDb implements IDb {
+  constructor() {
+    super()
+  }
+}

package/dist/src/EasClientWeb.ts

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

package/dist/src/FileManagerWeb.ts

@@ -0,0 +1,18 @@
+import { BaseFileManager } from "@/helpers/BaseFileManager";
+import fs from "@zenfs/core";
+import { basename } from "path-browserify";
+
+export class FileManagerWeb extends BaseFileManager {
+
+  static async getContentUrlFromPath(path: string): Promise<string | undefined> {
+    const imageFileExists = await fs.promises.exists(path)
+    if (!imageFileExists) {
+      return
+    }
+    const fileContents = await fs.promises.readFile(path)
+    const fileHandler = new File([fileContents], basename(path))
+    return URL.createObjectURL(fileHandler)
+  }
+}
+
+BaseFileManager.setPlatformClass(FileManagerWeb)

package/dist/src/IDb.ts

@@ -0,0 +1,7 @@
+import { ItemData, ModelSchema, ModelValues, PropertyData } from '@/types'
+import { VersionsType } from '@/seedSchema/VersionSchema'
+import { IItem } from '@/interfaces'
+
+export interface IDb {
+
+} 

package/dist/src/IEasClient.ts

@@ -0,0 +1,2 @@
+export interface IEasClient {
+}

package/dist/src/IItem.ts

@@ -0,0 +1,21 @@
+import { ActorRefFrom, Subscription } from 'xstate'
+import { ItemProperty } from '@/browser/property/ItemProperty'
+import { CreatePropertyInstanceProps, ModelSchema, ModelValues, PropertyData } from '@/types'
+import { VersionsType } from '@/seedSchema/VersionSchema'
+
+export interface IItem<T extends ModelValues<ModelSchema>> {
+  subscribe(callback: (itemProps: any) => void): Subscription
+  getService(): ActorRefFrom<any>
+  getEditedProperties(): Promise<PropertyData[]>
+  publish(): Promise<void>
+  getPublishUploads(): Promise<any>
+  getPublishPayload(uploadedTransactions: any[]): Promise<any>
+  unload(): void
+
+  readonly seedLocalId: string
+  readonly seedUid?: string
+  readonly schemaUid: string
+  readonly latestVersionUid: VersionsType
+  readonly modelName: string
+  readonly properties: Record<string, ItemProperty<any>>
+} 

package/dist/src/IItemProperty.ts

@@ -0,0 +1,27 @@
+import { ActorRefFrom, Subscription } from 'xstate';
+import { PropertyMachineContext } from '@/types';
+import { BehaviorSubject } from 'rxjs';
+import { Static } from '@sinclair/typebox';
+import { TProperty } from '@/browser/property';
+
+export interface IItemProperty<PropertyType> {
+  readonly localId: string;
+  readonly uid: string;
+  readonly seedLocalId: string;
+  readonly seedUid: string;
+  readonly schemaUid: string;
+  readonly propertyName: string;
+  readonly modelName: string;
+  readonly propertyDef: Static<typeof TProperty> | undefined;
+  readonly localStoragePath: string | void;
+  readonly versionLocalId: string | undefined;
+  readonly status: any;
+  readonly alias: string | undefined;
+  value: any;
+  readonly published: boolean;
+
+  subscribe(callback: Partial<BehaviorSubject<any>>): Subscription;
+  save(): Promise<void>;
+  unload(): void;
+  getService(): ActorRefFrom<any>;
+} 

package/dist/src/IQueryClient.ts

@@ -0,0 +1,4 @@
+export interface IQueryClient {
+  fetchQuery: (options: any) => Promise<any>
+  getQueryData: (queryKey: any) => any
+}

package/dist/src/Item.ts

@@ -0,0 +1,12 @@
+import { IItem } from '@/interfaces';
+import { BaseItem } from '@/Item/BaseItem';
+import { ModelSchema, ModelValues } from '@/types';
+
+export class Item<T extends ModelValues<ModelSchema>> extends BaseItem<T> implements IItem<T> {
+  constructor(initialValues: any) {
+    super(initialValues);
+  }
+
+}
+
+BaseItem.setPlatformClass(Item)