@seedprotocol/sdk 0.3.1 → 0.3.3

package/dist/seed.schema.config-BxJYabim.js

@@ -1,74 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
-import { T as Text, M as Model } from './index-BSR5hv7Q.js';
-import 'immer';
-import '@sinclair/typebox';
-import 'xstate';
-import './constants-Bhl5dZpN.js';
-import 'graphql-request';
-import '@ethereum-attestation-service/eas-sdk';
-import 'debug';
-import 'pluralize';
-import 'drizzle-orm/sqlite-core';
-import 'drizzle-orm';
-import 'eventemitter3';
-import 'nanoid';
-import 'nanoid-dictionary';
-import '@zenfs/core';
-import 'lodash-es';
-import '@statelyai/inspect';
-import 'path';
-import 'arweave';
-import 'rxjs';
-import 'drizzle-orm/casing';
-import 'react';
-import 'use-immer';
-import '@xstate/react';
-
-let Seed = class Seed {
-};
-__decorate([
-    Text(),
-    __metadata("design:type", String)
-], Seed.prototype, "uid", void 0);
-__decorate([
-    Text(),
-    __metadata("design:type", String)
-], Seed.prototype, "type", void 0);
-Seed = __decorate([
-    Model
-], Seed);
-let Version = class Version {
-};
-__decorate([
-    Text(),
-    __metadata("design:type", String)
-], Version.prototype, "seedUid", void 0);
-__decorate([
-    Text(),
-    __metadata("design:type", String)
-], Version.prototype, "note", void 0);
-Version = __decorate([
-    Model
-], Version);
-let Metadata = class Metadata {
-};
-__decorate([
-    Text(),
-    __metadata("design:type", String)
-], Metadata.prototype, "key", void 0);
-__decorate([
-    Text(),
-    __metadata("design:type", String)
-], Metadata.prototype, "value", void 0);
-Metadata = __decorate([
-    Model
-], Metadata);
-const models = {
-    Seed,
-    Version,
-    Metadata,
-};
-
-export { models };
-//# sourceMappingURL=seed.schema.config-BxJYabim.js.map

package/dist/seed.schema.config-BxJYabim.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"seed.schema.config-BxJYabim.js","sources":["../../src/db/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/schema'\n\n@Model\nclass Seed {\n  @Text() uid!: string\n  @Text() type!: string\n}\n\n@Model\nclass Version {\n  @Text() seedUid!: string\n  @Text() note!: string\n}\n\n@Model\nclass Metadata {\n  @Text() key!: string\n  @Text() value!: string\n}\n\nexport const models = {\n  Seed,\n  Version,\n  Metadata,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,IAAI,GAAV,MAAM,IAAI,CAAA;CAGT;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,KAAA,EAAA,MAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,MAAA,CAAA;AAFjB,IAAI,GAAA,UAAA,CAAA;IADT;AACK,CAAA,EAAA,IAAI,CAGT;AAGD,IAAM,OAAO,GAAb,MAAM,OAAO,CAAA;CAGZ;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAiB,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,SAAA,EAAA,MAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,MAAA,CAAA;AAFjB,OAAO,GAAA,UAAA,CAAA;IADZ;AACK,CAAA,EAAA,OAAO,CAGZ;AAGD,IAAM,QAAQ,GAAd,MAAM,QAAQ,CAAA;CAGb;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,KAAA,EAAA,MAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,MAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}

package/dist/src/AppStateSchema.ts

@@ -1,10 +0,0 @@
-import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core'
-
-export const appState = sqliteTable('appState', {
-  key: text('key').unique(),
-  value: text('value'),
-  createdAt: int('created_at'),
-  updatedAt: int('updated_at'),
-})
-
-export type appStateType = appState.$inferSelect

package/dist/src/ArweaveClient.ts

@@ -1,13 +0,0 @@
-import { BaseArweaveClient } from '@/helpers/ArweaveClient/BaseArweaveClient';
-import { ARWEAVE_ENDPOINT } from '@/services/internal/constants';
-import { GraphQLClient } from 'graphql-request';
-
-class ArweaveClient extends BaseArweaveClient {
-  static getArweaveClient(): GraphQLClient {
-    return new GraphQLClient(ARWEAVE_ENDPOINT);
-  }
-}
-
-BaseArweaveClient.setPlatformClass(ArweaveClient);
-
-export { ArweaveClient }; 

package/dist/src/Attestation.ts

@@ -1,21 +0,0 @@
-import { graphql, } from '../gql'
-
-export const ATTESTATION_FIELDS = graphql(/* GraphQL */ `
-  fragment attestationFields on Attestation {
-    id
-    decodedDataJson
-    attester
-    schema {
-      schemaNames {
-        name
-      }
-    }
-    refUID
-    revoked
-    schemaId
-    txid
-    timeCreated
-    time
-    isOffchain
-  }
-`,)

package/dist/src/BaseArweaveClient.ts

@@ -1,13 +0,0 @@
-import { GraphQLClient } from 'graphql-request'
-
-export abstract class BaseArweaveClient {
-  static PlatformClass: typeof BaseArweaveClient
-
-  static setPlatformClass(platformClass: typeof BaseArweaveClient) {
-    this.PlatformClass = platformClass
-  }
-
-  static getArweaveClient(): GraphQLClient {
-    return this.PlatformClass.getArweaveClient()
-  }
-}

package/dist/src/BaseClientManager.ts

@@ -1,35 +0,0 @@
-import { initEasClient } from "@/helpers/EasClient"
-import { initArweaveClient } from "@/helpers/ArweaveClient"
-import { initQueryClient } from "@/helpers/QueryClient"
-import { initFileManager } from "@/helpers/FileManager"
-import { initDb } from "@/db/Db"
-import { initItem } from "@/Item"
-import { initItemProperty } from "@/ItemProperty"
-import { SeedConstructorOptions } from "@/types"
-
-
-export abstract class BaseClientManager {
-  static isInitialized = false
-  constructor() {
-  }
-
-  static async init(options: SeedConstructorOptions): Promise<void> {
-    if (this.isInitialized) {
-      return
-    }
-
-    const { config, addresses } = options
-
-    await initItem()
-    await initItemProperty()
-    await initEasClient()
-    await initArweaveClient()
-    await initQueryClient()
-    await initFileManager()
-    await initDb()
-
-    this.isInitialized = true
-
-
-  }
-}

package/dist/src/BaseDb.ts

@@ -1,35 +0,0 @@
-import { IDb } from '@/interfaces/IDb'
-import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core'
-
-export abstract class BaseDb implements IDb {
-
-  constructor() {
-  }
-
-  static PlatformClass: typeof BaseDb
-
-  static setPlatformClass(platformClass: typeof BaseDb) {
-    this.PlatformClass = platformClass
-  }
-
-  static getAppDb(): BaseSQLiteDatabase {
-    return this.PlatformClass.getAppDb()
-  }
-
-  static isAppDbReady(): boolean {
-    return this.PlatformClass.isAppDbReady()
-  }
-
-  static prepareDb(filesDir: string): Promise<BaseSQLiteDatabase> {
-    return this.PlatformClass.prepareDb(filesDir)
-  }
-
-  static connectToDb(pathToDir: string, dbName: string): Promise<unknown> {
-    return this.PlatformClass.connectToDb(pathToDir, dbName)
-  }
-
-  static async migrate(pathToDbDir: string, dbName: string, dbId: string): Promise<void> {
-    return this.PlatformClass.migrate(pathToDbDir, dbName, dbId)
-  }
-
-}

package/dist/src/BaseEasClient.ts

@@ -1,14 +0,0 @@
-import { GraphQLClient } from 'graphql-request'
-import { EAS_ENDPOINT }  from '@/services/internal/constants'
-
-export abstract class BaseEasClient {
-  static PlatformClass: typeof BaseEasClient
-
-  static setPlatformClass(platformClass: typeof BaseEasClient) {
-    this.PlatformClass = platformClass
-  }
-
-  static getEasClient(): GraphQLClient {
-    return new GraphQLClient(EAS_ENDPOINT)
-  }
-} 

package/dist/src/BaseFileManager.ts

@@ -1,60 +0,0 @@
-export abstract class BaseFileManager {
-  private static fileSystemInitialized = false
-  private static initializing = false
-
-  static PlatformClass: typeof BaseFileManager
-
-  static setPlatformClass( platformClass: typeof BaseFileManager ) {
-    this.PlatformClass = platformClass
-  }
-
-  static async initializeFileSystem(): Promise<void> {
-    if (this.initializing || this.fileSystemInitialized) {
-      return Promise.resolve()
-    }
-    this.initializing = true
-    await this.PlatformClass.initializeFileSystem()
-    this.fileSystemInitialized = true
-    this.initializing = false
-  }
-
-  static getContentUrlFromPath( path: string ): Promise<string | undefined> {
-    return this.PlatformClass.getContentUrlFromPath(path)
-  }
-
-  static downloadAllFiles( {
-                             transactionIds,
-                             arweaveHost,
-                             excludedTransactions,
-                           }: DownloadAllFilesParams ): Promise<void> {
-    return this.PlatformClass.downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions })
-  }
-
-  static resizeImage( { filePath, width, height }: ResizeImageParams ): Promise<void> {
-    return this.PlatformClass.resizeImage({ filePath, width, height })
-  }
-
-  static resizeAllImages( { width, height }: ResizeAllImagesParams ): Promise<void> {
-    return this.PlatformClass.resizeAllImages({ width, height })
-  }
-
-  static pathExists(filePath: string): Promise<boolean> {
-    return this.PlatformClass.pathExists(filePath)
-  }
-
-  static createDirIfNotExists(filePath: string): Promise<void> {
-    return this.PlatformClass.createDirIfNotExists(filePath)
-  }
-
-  static async waitForFile(filePath: string): Promise<boolean> {
-    return this.PlatformClass.waitForFile(filePath)
-  }
-
-  static async saveFile(filePath: string, content: string | Blob | ArrayBuffer): Promise<void> {
-    return this.PlatformClass.saveFile(filePath, content)
-  }
-
-  static async readFile(filePath: string): Promise<File> {
-    return this.PlatformClass.readFile(filePath)
-  }
-}

package/dist/src/BaseItem.ts

@@ -1,413 +0,0 @@
-import { IItem, IItemProperty } from '@/interfaces'
-import { itemMachineSingle } from '@/Item/service/itemMachineSingle'
-import { internalPropertyNames } from '@/helpers/constants'
-import { VersionsType } from '@/seedSchema/VersionSchema'
-import { getModel } from '@/stores/modelClass'
-
-import {
-  CreatePropertyInstanceProps,
-  ItemData,
-  ItemFindProps,
-  ModelSchema,
-  ModelValues,
-  NewItemProps,
-  PropertyData
-} from '@/types'
-
-import { immerable } from 'immer'
-import { BehaviorSubject } from 'rxjs'
-import { ActorRefFrom, Subscription, createActor } from 'xstate'
-import { eventEmitter } from '@/eventBus'
-import pluralize from 'pluralize'
-import { orderBy, startCase } from 'lodash-es'
-import { waitForEvent } from '@/events'
-import { getItemData } from '@/db/read/getItemData'
-import { getItemsData } from '@/db/read/getItems'
-import { BaseItemProperty } from '@/ItemProperty/BaseItemProperty'
-import { getItemProperties } from '@/db/read/getItemProperties'
-import { getPublishUploads } from '@/db/read/getPublishUploads'
-import { getPublishPayload } from '@/db/read/getPublishPayload'
-import { createNewItem } from '@/db/write/createNewItem'
-
-
-export abstract class BaseItem<T extends ModelValues<ModelSchema>> implements IItem<T> {
-
-  protected static instanceCache: Map<string, { instance: BaseItem<any>; refCount: number }> = new Map();
-  protected _subscription: Subscription | undefined;
-  protected readonly _storageTransactionId: string | undefined;
-  [immerable] = true;
-  protected _propertiesSubject: BehaviorSubject<Record<string, IItemProperty<any>>> = new BehaviorSubject({});
-  protected readonly _service: ActorRefFrom<typeof itemMachineSingle>;
-
-  constructor(initialValues: NewItemProps<T>) {
-
-    const {
-      modelName,
-      seedUid,
-      schemaUid,
-      seedLocalId,
-      latestVersionLocalId,
-      latestVersionUid,
-    } = initialValues
-
-    const ModelClass = getModel(modelName)
-
-    if (
-      ModelClass &&
-      Object.keys(ModelClass?.schema).includes('storageTransactionId') &&
-      initialValues.storageTransactionId
-    ) {
-      this._storageTransactionId = initialValues.storageTransactionId
-    }
-
-    this._service = createActor(itemMachineSingle, {
-      input: {
-        seedLocalId,
-        seedUid,
-        schemaUid,
-        ModelClass,
-        latestVersionLocalId,
-        latestVersionUid,
-        storageTransactionId: this._storageTransactionId,
-      },
-    })
-
-    this._subscription = this._service.subscribe((snapshot) => {
-      const { context } = snapshot
-
-      if (
-        !context ||
-        !context.propertyInstances ||
-        context.propertyInstances.size === 0
-      ) {
-        return
-      }
-
-      const propertiesObj: Record<string, IItemProperty<any>> = {}
-
-      for (const [key, propertyInstance] of context.propertyInstances) {
-        if (typeof key !== 'string' || internalPropertyNames.includes(key)) {
-          propertiesObj[key.toString()] = propertyInstance
-          continue
-        }
-
-        let transformedKey: string = key as string
-
-        if (propertyInstance.alias) {
-          transformedKey = propertyInstance.alias
-        }
-
-        if (!propertyInstance.alias && key.endsWith('Ids')) {
-          transformedKey = key.slice(0, -3) // Remove 'Ids'
-          transformedKey = pluralize(transformedKey)
-        }
-
-        if (!propertyInstance.alias && key.endsWith('Id')) {
-          transformedKey = key.slice(0, -2) // Remove 'Id'
-        }
-
-        propertiesObj[transformedKey] = propertyInstance
-      }
-
-      this._propertiesSubject.next(propertiesObj)
-      // eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`)
-    })
-
-    this._service.start()
-
-    const definedKeys: string[] = ['ModelClass']
-
-    const itemPropertyBase: Partial<CreatePropertyInstanceProps> = {
-      seedLocalId,
-      seedUid,
-      versionLocalId: latestVersionLocalId,
-      versionUid: latestVersionUid,
-      modelName: modelName,
-    }
-
-    if (ModelClass && ModelClass.schema) {
-      const schema = ModelClass.schema
-
-      for (const [propertyName, propertyRecordSchema] of Object.entries(
-        schema,
-      )) {
-        if (!propertyRecordSchema) {
-          throw new Error(`Property ${propertyName} has no definition`)
-        }
-
-        this._createPropertyInstance({
-          ...itemPropertyBase,
-          propertyName,
-          propertyValue: initialValues[propertyName as keyof T],
-        })
-
-        definedKeys.push(propertyName)
-
-        if (
-          propertyRecordSchema.dataType === 'Relation' &&
-          !propertyName.endsWith('Id')
-        ) {
-          definedKeys.push(`${propertyName}Id`)
-        }
-
-        if (
-          propertyRecordSchema.dataType === 'List' &&
-          !propertyName.endsWith('Ids')
-        ) {
-          const singularPropertyName = pluralize.singular(propertyName)
-          const propertyNameForSchema = `${singularPropertyName}${propertyRecordSchema.ref}Ids`
-          definedKeys.push(propertyNameForSchema)
-        }
-      }
-    }
-
-    ; (Object.keys(initialValues) as Array<string & keyof Partial<T>>).forEach(
-      (key) => {
-        // If we already defined it, that means it was in the schema
-        if (definedKeys.includes(key)) {
-          return
-        }
-
-        this._createPropertyInstance({
-          ...itemPropertyBase,
-          propertyName: key,
-          propertyValue: initialValues[key],
-        })
-      },
-    )
-  }
-
-  static PlatformClass: typeof BaseItem
-
-  static setPlatformClass(platformClass: typeof BaseItem) {
-    this.PlatformClass = platformClass
-  }
-
-  static async create<T extends ModelValues<ModelSchema>>(
-    props: Partial<ItemData>,
-  ): Promise<BaseItem<any>> {
-    if (!props.modelName && props.type) {
-      props.modelName = startCase(props.type)
-    }
-    if (props.seedUid || props.seedLocalId) {
-      const seedId = (props.seedUid || props.seedLocalId) as string
-      if (this.instanceCache.has(seedId)) {
-        const { instance, refCount } = this.instanceCache.get(seedId)!
-        this.instanceCache.set(seedId, {
-          instance,
-          refCount: refCount + 1,
-        })
-        for (const [propertyName, propertyValue] of Object.entries(props)) {
-          const propertyInstances = instance.getService().getSnapshot()
-            .context.propertyInstances
-          if (!propertyInstances || !propertyInstances.has(propertyName)) {
-            continue
-          }
-          const propertyInstance = propertyInstances.get(propertyName)
-          if (!propertyInstance) {
-            continue
-          }
-          propertyInstance.getService().send({
-            type: 'updateContext',
-            propertyValue,
-          })
-        }
-        return instance
-      }
-      if (!this.instanceCache.has(seedId)) {
-        const newInstance = new this(props)
-        this.instanceCache.set(seedId, {
-          instance: newInstance,
-          refCount: 1,
-        })
-        return newInstance
-      }
-    }
-    if (!props.modelName) {
-      throw new Error('Model name is required to create an item')
-    }
-    const { seedLocalId, versionLocalId, } = await createNewItem({
-      modelName: props.modelName,
-      ...props,
-    })
-    props.seedLocalId = seedLocalId
-    props.latestVersionLocalId = versionLocalId
-    const newInstance = new this(props)
-    this.instanceCache.set(newInstance.seedUid || newInstance.seedLocalId, {
-      instance: newInstance,
-      refCount: 1,
-    })
-    return newInstance
-  }
-
-  static async find({
-    modelName,
-    seedLocalId,
-    seedUid,
-  }: ItemFindProps): Promise<IItem<any> | undefined> {
-    if (!seedLocalId && !seedUid) {
-      return
-    }
-    const itemData = await getItemData({
-      modelName,
-      seedLocalId,
-      seedUid,
-    })
-
-    if (!itemData) {
-      console.error('No item data found', { modelName, seedLocalId, seedUid })
-      return
-    }
-
-    return BaseItem.create({
-      ...itemData,
-      modelName,
-    })
-  }
-
-  static async all(
-    modelName?: string,
-    deleted?: boolean,
-  ): Promise<BaseItem<any>[]> {
-    const itemsData = await getItemsData({ modelName, deleted })
-    const itemInstances: BaseItem<any>[] = []
-    for (const itemData of itemsData) {
-      itemInstances.push(
-        await BaseItem.create({
-          ...itemData,
-          modelName,
-        }),
-      )
-    }
-
-    return orderBy(itemInstances, ['createdAt'], ['desc'])
-  }
-
-  protected _createPropertyInstance(props: Partial<CreatePropertyInstanceProps>) {
-    if (this._storageTransactionId) {
-      props.storageTransactionId = this._storageTransactionId
-    }
-
-    const propertyInstance = BaseItemProperty.create(props)
-
-    if (!propertyInstance || !props.propertyName) {
-      return
-    }
-
-    this._service.send({
-      type: 'addPropertyInstance',
-      propertyName: props.propertyName,
-      propertyInstance,
-    })
-
-    Object.defineProperty(this, props.propertyName, {
-      get: () => propertyInstance.value,
-      set: (value) => (propertyInstance.value = value),
-      enumerable: true,
-    })
-  }
-
-
-  static async publish(item: IItem<any>): Promise<void> {
-    await waitForEvent({
-      req: {
-        eventLabel: `item.${item.seedLocalId}.publish.request`,
-        data: {
-          seedLocalId: item.seedLocalId,
-        },
-      },
-      res: {
-        eventLabel: `item.${item.seedLocalId}.publish.success`,
-      },
-    })
-  }
-
-  subscribe = (callback: (itemProps: any) => void): Subscription => {
-    return this._service.subscribe((snapshot) => {
-      callback(snapshot.context)
-    })
-  }
-
-  getService = (): ActorRefFrom<typeof itemMachineSingle> => {
-    return this._service
-  }
-
-  getEditedProperties = async (): Promise<PropertyData[]> => {
-    return await getItemProperties({
-      seedLocalId: this.seedLocalId,
-      edited: true,
-    })
-  }
-
-  publish = async (): Promise<void> => {
-    await waitForEvent({
-      req: {
-        eventLabel: `item.publish.request`,
-        data: {
-          seedLocalId: this.seedLocalId,
-        },
-      },
-      res: {
-        eventLabel: `item.${this.seedLocalId}.publish.success`,
-      },
-    })
-  }
-
-  getPublishUploads = async () => {
-    return await getPublishUploads(this)
-  }
-
-  getPublishPayload = async (uploadedTransactions: any[]) => {
-    return await getPublishPayload(this, uploadedTransactions)
-  }
-
-  get serviceContext() {
-    const snapshot = this._service.getSnapshot()
-    return (snapshot as any).context || {}
-  }
-
-  get seedLocalId(): string {
-    return this.serviceContext.seedLocalId as string
-  }
-
-  get seedUid(): string | undefined {
-    return this.serviceContext.seedUid
-  }
-
-  get schemaUid(): string {
-    return this.serviceContext.schemaUid as string
-  }
-
-  get latestVersionUid(): VersionsType {
-    return this.serviceContext.latestVersionUid as VersionsType
-  }
-
-  get latestVersionLocalId(): string {
-    return this.serviceContext.latestVersionLocalId as string
-  }
-
-  get modelName(): string {
-    return this.serviceContext.modelName as string
-  }
-
-  get properties(): Record<string, IItemProperty<any>> {
-    return this._propertiesSubject.value
-  }
-
-  get attestationCreatedAt(): number {
-    return this.serviceContext.attestationCreatedAt as number
-  }
-
-  get versionsCount(): number {
-    return this.serviceContext.versionsCount as number
-  }
-
-  get lastVersionPublishedAt(): number {
-    return this.serviceContext.lastVersionPublishedAt as number
-  }
-
-  unload(): void {
-    this._subscription?.unsubscribe()
-    this._service.stop()
-  }
-}