@seedprotocol/sdk 0.1.129 → 0.2.1

package/dist/main.js

@@ -1,4 +1,4 @@
-export { j as ImageSrc, I as Item, k as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, t as client, x as eventEmitter, v as getCorrectId, s as getGlobalService, n as useCreateItem, p as useDeleteItem, q as useGlobalServiceStatus, l as useItem, m as useItemProperties, o as useItemProperty, u as useItems, r as useServices, w as withSeed } from './index-CjvApuBp.js';
+export { a as ImageSrc, I as Item, b as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, l as client, n as eventEmitter, m as getCorrectId, k as getGlobalService, e as useCreateItem, g as useDeleteItem, h as useGlobalServiceStatus, c as useItem, d as useItemProperties, f as useItemProperty, u as useItems, j as useServices, w as withSeed } from './index-DaK2dz5P.js';
 import 'immer';
 import 'reflect-metadata';
 import 'tslib';
@@ -6,31 +6,28 @@ import 'xstate';
 import 'arweave';
 import 'drizzle-orm';
 import '@sinclair/typebox';
+import 'rxjs';
 import '@zenfs/core';
 import 'dayjs';
 import 'nanoid';
 import 'nanoid-dictionary';
 import 'debug';
 import 'drizzle-orm/sqlite-core';
-import 'react';
-import '@tanstack/react-query';
-import 'graphql-request';
-import '@tanstack/query-sync-storage-persister';
-import '@tanstack/react-query-persist-client';
 import 'path';
-import 'use-immer';
-import '@xstate/react';
+import 'react';
+import 'pluralize';
 import 'eventemitter3';
 import 'lodash-es';
-import 'pluralize';
+import './constants-B6s6tGup.js';
+import '@ethereum-attestation-service/eas-sdk';
+import 'thirdweb';
 import '@statelyai/inspect';
-import 'rxjs';
 import 'drizzle-orm/sqlite-proxy';
 import 'drizzle-orm/sqlite-proxy/migrator';
 import 'drizzle-orm/migrator';
 import 'node:fs';
 import '@zenfs/dom';
-import './constants-B6s6tGup.js';
-import '@ethereum-attestation-service/eas-sdk';
-import 'thirdweb';
+import 'use-immer';
+import '@xstate/react';
+import 'lodash';
 //# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -1 +1 @@
-{"version":3,"file":"main.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/{seed.schema.config-oOqgroqV.js → seed.schema.config-DIMmvqJf.js}

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from 'tslib';
 import 'drizzle-orm';
-import { T as Text, M as Model } from './index-CjvApuBp.js';
+import { T as Text, M as Model } from './index-DaK2dz5P.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
@@ -8,31 +8,28 @@ import 'arweave';
 import '@zenfs/core';
 import '@zenfs/dom';
 import '@sinclair/typebox';
+import 'rxjs';
+import 'immer';
 import 'dayjs';
 import 'nanoid';
 import 'nanoid-dictionary';
 import 'debug';
 import 'drizzle-orm/sqlite-core';
-import '@tanstack/react-query';
-import 'graphql-request';
-import '@tanstack/query-sync-storage-persister';
-import '@tanstack/react-query-persist-client';
 import 'path';
-import 'use-immer';
-import '@xstate/react';
+import 'pluralize';
 import 'eventemitter3';
 import 'lodash-es';
-import 'immer';
-import 'pluralize';
+import './constants-B6s6tGup.js';
+import '@ethereum-attestation-service/eas-sdk';
+import 'thirdweb';
 import '@statelyai/inspect';
-import 'rxjs';
 import 'drizzle-orm/sqlite-proxy';
 import 'drizzle-orm/sqlite-proxy/migrator';
 import 'drizzle-orm/migrator';
 import 'node:fs';
-import './constants-B6s6tGup.js';
-import '@ethereum-attestation-service/eas-sdk';
-import 'thirdweb';
+import 'use-immer';
+import '@xstate/react';
+import 'lodash';
 
 let Seed = class Seed {
 };
@@ -80,4 +77,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-oOqgroqV.js.map
+//# sourceMappingURL=seed.schema.config-DIMmvqJf.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seed.schema.config-DIMmvqJf.js","sources":["../../src/shared/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/browser'\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,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,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,KAAA,CAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,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,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,KAAA,CAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}

package/dist/shared/configs/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/ArweaveClientWeb.ts

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

package/dist/src/BaseArweaveClient.ts

@@ -0,0 +1,13 @@
+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/BaseDb.ts

@@ -0,0 +1,31 @@
+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(): Promise<unknown> {
+    return this.PlatformClass.prepareDb()
+  }
+
+  static connectToDb(pathToDir: string, dbName: string): Promise<unknown> {
+    return this.PlatformClass.connectToDb(pathToDir, dbName)
+  }
+
+}

package/dist/src/BaseEasClient.ts

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

package/dist/src/BaseFileManager.ts

@@ -0,0 +1,11 @@
+export abstract class BaseFileManager {
+  static PlatformClass: typeof BaseFileManager
+
+  static setPlatformClass(platformClass: typeof BaseFileManager) {
+    this.PlatformClass = platformClass
+  }
+
+  static getContentUrlFromPath(path: string): Promise<string | undefined> {
+    return this.PlatformClass.getContentUrlFromPath(path)
+  }
+}

package/dist/src/BaseItem.ts

@@ -0,0 +1,397 @@
+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'
+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'
+
+
+export abstract class BaseItem<T extends ModelValues<ModelSchema>>
+
+  implements IItem<T> {
+  protected static instanceCache: Map<string, { instance: IItem<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<IItem<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 } = await createNewItem({
+      modelName: props.modelName,
+    })
+    props.seedLocalId = seedLocalId
+    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<IItem<any>[]> {
+    const itemsData = await getItemsData({ modelName, deleted })
+    const itemInstances: IItem<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 modelName(): string {
+    return this.serviceContext.modelName as string
+  }
+
+  get properties(): Record<string, IItemProperty<any>> {
+    return this._propertiesSubject.value
+  }
+
+  unload(): void {
+    this._subscription?.unsubscribe()
+    this._service.stop()
+  }
+}