@seedprotocol/sdk 0.2.54 → 0.3.1

package/dist/src/FileManager.ts

@@ -0,0 +1,59 @@
+import * as fsAsync        from 'fs/promises'
+import { BaseFileManager } from '@/helpers/FileManager/BaseFileManager'
+
+class FileManager extends BaseFileManager {
+
+  static async getContentUrlFromPath( path: string ): Promise<string | undefined> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async initializeFileSystem(): Promise<void> {
+    return // No need to initialize file system in node
+  }
+
+  static async downloadAllFiles(): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async resizeImage(): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async resizeAllImages(): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async pathExists(filePath: string): Promise<boolean> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async createDirIfNotExists(filePath: string): Promise<void> {
+    return new Promise(( resolve, reject ) => {
+      reject(new Error('Not implemented'))
+    })
+  }
+
+  static async readFileAsBuffer( filePath: string ): Promise<Buffer> {
+    return await fsAsync.readFile(filePath)
+  }
+
+  static async readFile(filePath: string): Promise<File> {
+    return new File([await fsAsync.readFile(filePath)], filePath)
+  }
+
+}
+
+BaseFileManager.setPlatformClass(FileManager)
+
+export { FileManager }
+

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,26 @@
+import { ActorRefFrom, Subscription } from 'xstate'
+import { ModelSchema, ModelValues, PropertyData } from '@/types'
+import { VersionsType } from '@/seedSchema/VersionSchema'
+import { IItemProperty } from './IItemProperty'
+
+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 latestVersionLocalId: string
+  readonly modelName: string
+  readonly properties: Record<string, IItemProperty<any>>
+  readonly attestationCreatedAt: number
+  readonly versionsCount: number
+  readonly lastVersionPublishedAt: number
+} 

package/dist/src/IItemProperty.ts

@@ -0,0 +1,28 @@
+import { ActorRefFrom, Subscription } from 'xstate';
+import { BehaviorSubject } from 'rxjs';
+import { Static } from '@sinclair/typebox';
+import { TProperty } from '@/schema';
+import { CreatePropertyInstanceProps } from '@/types';
+
+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,11 @@
+
+type FetchQueryOptions = {
+  queryKey: any
+  queryFn: () => Promise<any>
+  networkMode?: 'offlineFirst' | 'onlineOnly'
+}
+
+export interface IQueryClient {
+  fetchQuery: (options: FetchQueryOptions) => Promise<any>
+  getQueryData: (queryKey: any) => any
+}

package/dist/src/ImageResizer.ts

@@ -0,0 +1,81 @@
+import fs from '@zenfs/core';
+import imageResize from './imageResize'
+import { FileManager } from '@/browser/helpers/FileManager';
+
+
+
+export class ImageResizer {
+  private cores: number
+  private workersArchive: Map<string, Worker> = new Map()
+  private workerBlobUrl: string
+
+  constructor() {
+    this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+
+    this.workerBlobUrl = globalThis.URL.createObjectURL(
+      new Blob([imageResize], { type: 'application/javascript' })
+    )
+  }
+
+    public async resize({filePath, width, height}: ResizeImageParams) {
+      
+    if (this.workersArchive.has(filePath)) {
+      const savedWorker = this.workersArchive.get(filePath)
+      savedWorker?.terminate()
+      console.log('[ImageResizer.resize] Terminated worker for filePath due to incoming request', filePath)
+      this.workersArchive.delete(filePath)
+    }
+
+    const worker = new Worker(this.workerBlobUrl);
+
+    this.workersArchive.set(filePath, worker)
+
+    return new Promise((resolve, reject) => {
+      worker.onmessage = (e) => {
+        console.log('[ImageResizer.resize] main thread onmessage', e.data);
+        if (e.data.done) {
+          const savedWorker = this.workersArchive.get(filePath)
+          savedWorker?.terminate()
+          console.log('[ImageResizer.resize] Terminated worker for filePath due to done', filePath)
+          this.workersArchive.delete(filePath)
+          resolve(e.data)
+        }
+
+        if (e.data.error) {
+          reject(e.data.error)
+        }
+      }
+  
+      worker.postMessage({
+        filePath,
+        width,
+        height,
+      });
+    })
+  }
+
+  public async resizeAll({width, height}: ResizeAllImagesParams) {
+
+    const imageDir = '/files/images'
+    let imageFilesStats = await fs.promises.readdir(imageDir, {
+      withFileTypes: true
+    })
+
+    imageFilesStats = imageFilesStats.filter(file => file.isFile())
+
+    const imageFiles = imageFilesStats.map(file => file.path)
+
+    const widthDir = `${imageDir}/${width}`
+
+    await FileManager.createDirIfNotExists(widthDir)
+
+    for (const imageFile of imageFiles) {
+      const resizedImageExists = await fs.promises.exists(`${widthDir}/${imageFile}`)
+      if (!resizedImageExists) {
+        await this.resize({filePath: `${imageDir}/${imageFile}`, width, height})
+      }
+    }
+
+  
+  }
+}

package/dist/src/Item.ts

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

package/dist/src/ItemProperty.ts

@@ -0,0 +1,9 @@
+import { IItemProperty } from '@/interfaces'
+import { BaseItemProperty } from '@/ItemProperty/BaseItemProperty'
+import { CreatePropertyInstanceProps, ModelSchema, ModelValues, } from '@/types'
+
+export class ItemProperty<PropertyType> extends BaseItemProperty<PropertyType> implements IItemProperty<PropertyType> {
+  constructor(initialValues: Partial<CreatePropertyInstanceProps>) {
+    super(initialValues)
+  }
+}

package/dist/src/MetadataSchema.ts

@@ -0,0 +1,28 @@
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+export const metadata = sqliteTable('metadata', {
+  localId: text('local_id').unique(),
+  uid: text('uid'),
+  propertyName: text('property_name'),
+  propertyValue: text('property_value'),
+  schemaUid: text('schema_uid'),
+  modelType: text('model_type'),
+  seedLocalId: text('seed_local_id'),
+  seedUid: text('seed_uid'),
+  versionLocalId: text('version_local_id'),
+  versionUid: text('version_uid'),
+  easDataType: text('eas_data_type'),
+  refValueType: text('ref_value_type'),
+  refModelUid: text('ref_schema_uid'),
+  refSeedType: text('ref_seed_type'),
+  refResolvedValue: text('ref_resolved_value'),
+  refResolvedDisplayValue: text('ref_resolved_display_value'),
+  localStorageDir: text('local_storage_dir'),
+  attestationRaw: text('attestation_raw'),
+  attestationCreatedAt: int('attestation_created_at'),
+  contentHash: text('content_hash'),
+  createdAt: int('created_at'),
+  updatedAt: int('updated_at'),
+})
+
+export type MetadataType = metadata.$inferSelect

package/dist/src/ModelSchema.ts

@@ -0,0 +1,46 @@
+import { int, sqliteTable, text, unique } from 'drizzle-orm/sqlite-core'
+import { relations } from 'drizzle-orm'
+
+export const models = sqliteTable('models', {
+  id: int('id').primaryKey({ autoIncrement: true }),
+  name: text('name').notNull(),
+})
+
+export const modelsRelations = relations(models, ({ many }) => ({
+  properties: many(properties),
+}))
+
+export type NewModelRecord = typeof models.$inferInsert
+export type ModelRecordType = typeof models.$inferSelect
+
+export const properties = sqliteTable(
+  'properties',
+  {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(),
+    dataType: text('data_type').notNull(),
+    readEndpoint: text('read_endpoint'),
+    updateEndpoint: text('update_endpoint'),
+    modelId: int('model_id')
+      .notNull()
+      .references(() => models.id),
+    refModelId: int('ref_model_id').references(() => models.id),
+    refValueType: text('ref_value_type'),
+  },
+  (table) => {
+    return {
+      uniqueNameModelId: unique('unique_name_model_id').on(
+        table.name,
+        table.modelId,
+      ),
+    }
+  },
+)
+
+export const propertiesRelations = relations(properties, ({ one }) => ({
+  model: one(models),
+  refModel: one(models),
+}))
+
+export type NewPropertyRecord = typeof properties.$inferInsert
+export type PropertyType = typeof properties.$inferSelect

package/dist/src/ModelUidSchema.ts

@@ -0,0 +1,16 @@
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { relations } from 'drizzle-orm'
+import { models } from './ModelSchema'
+
+export const modelUids = sqliteTable('model_uids', {
+  id: int('id').primaryKey({ autoIncrement: true }),
+  uid: text('uid').notNull(),
+  modelId: int('model_id')
+    .notNull()
+    .unique()
+    .references(() => models.id),
+})
+
+export const modelRelations = relations(modelUids, ({ many, one }) => ({
+  model: one(models),
+}))

package/dist/src/PropertyUidSchema.ts

@@ -0,0 +1,16 @@
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { relations } from 'drizzle-orm'
+import { models, properties } from './ModelSchema'
+
+export const propertyUids = sqliteTable('property_uids', {
+  id: int('id').primaryKey({ autoIncrement: true }),
+  uid: text('uid').notNull(),
+  propertyId: int('property_id')
+    .notNull()
+    .unique()
+    .references(() => models.id),
+})
+
+export const propertyUidRelations = relations(propertyUids, ({ one }) => ({
+  property: one(properties),
+}))

package/dist/src/QueryClient.ts

@@ -0,0 +1,26 @@
+import { BaseQueryClient } from "@/helpers/QueryClient/BaseQueryClient"
+import { IQueryClient }    from '@/interfaces/IQueryClient'
+
+
+
+class QueryClient extends BaseQueryClient {
+  static getQueryClient = (): IQueryClient=> {
+    return {
+      fetchQuery: async <T>({
+        queryKey,
+        queryFn,
+       }): Promise<T> => {
+        return await queryFn()
+      },
+      getQueryData: () => {
+        return new Promise((resolve, reject) => {
+          reject(new Error('Not implemented'))
+        })
+      },
+    }
+  }
+}
+
+BaseQueryClient.setPlatformClass(QueryClient)
+
+export { QueryClient }

package/dist/src/Schema.ts

@@ -0,0 +1,17 @@
+import { graphql, } from '../gql'
+
+export const SCHEMA_FIELDS = graphql(/* GraphQL */ `
+  fragment schemaFields on Schema {
+    id
+    resolver
+    revocable
+    schema
+    index
+    schemaNames {
+      name
+    }
+    time
+    txid
+    creator
+  }
+`,)

package/dist/src/SeedProtocolSdk.d.ts

@@ -0,0 +1,19 @@
+export interface SeedProtocolSdk {
+
+  getCorrectId: typeof import('@/helpers').getCorrectId;
+
+  // Exported constants
+  eventEmitter: typeof import('@/eventBus').eventEmitter;
+
+  // Exported types
+  Model: typeof import('@/schema').Model;
+  Property: typeof import('@/schema').Property;
+  ImageSrc: typeof import('@/schema').ImageSrc;
+  List: typeof import('@/schema').List;
+  Text: typeof import('@/schema').Text;
+  Json: typeof import('@/schema').Json;
+  Relation: typeof import('@/schema').Relation;
+
+  // Node-specific exports
+  withSeed?: typeof import('@/node').withSeed;
+} 

package/dist/src/SeedSchema.ts

@@ -0,0 +1,29 @@
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+export const seeds = sqliteTable(
+  'seeds',
+  {
+    localId: text('local_id').unique(),
+    uid: text('uid'),
+    schemaUid: text('schema_uid'),
+    type: text('type'),
+    attestationRaw: text('attestation_raw'),
+    attestationCreatedAt: int('attestation_created_at'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+    _markedForDeletion: int('_marked_for_deletion'),
+  },
+  // {
+  //   triggers: [
+  //     sql<string>`CREATE TRIGGER IF NOT EXISTS seeds_created_at_trigger
+  //         BEFORE INSERT
+  //         ON seeds
+  //         FOR EACH ROW
+  //     BEGIN
+  //         SELECT strftime('%s', 'now') * 1000 INTO NEW.created_at;
+  //     END;`,
+  //   ],
+  // },
+)
+
+export type SeedType = seeds.$inferSelect

package/dist/src/VersionSchema.ts

@@ -0,0 +1,16 @@
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+export const versions = sqliteTable('versions', {
+  localId: text('local_id').unique(),
+  uid: text('uid'),
+  seedLocalId: text('seed_local_id'),
+  seedUid: text('seed_uid'),
+  seedType: text('seed_type'),
+  note: text('note'),
+  createdAt: int('created_at'),
+  updatedAt: int('updated_at'),
+  attestationCreatedAt: int('attestation_created_at'),
+  attestationRaw: text('attestation_raw'),
+})
+
+export type VersionsType = versions.$inferSelect