@seedprotocol/sdk 0.1.46 → 0.1.48

package/dist/{index-ChGsdGPJ.js → index-wKss7188.js}

@@ -1,4 +1,4 @@
-export { f as GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, e as GET_PROPERTIES, G as GET_SCHEMAS, a as GET_SEEDS, b as GET_SEED_IDS, c as GET_STORAGE_TRANSACTION_ID, d as GET_VERSIONS, I as Item, g as itemMachineAll, i as itemMachineSingle } from './index-BEzB8REh.js';
+export { f as GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, e as GET_PROPERTIES, G as GET_SCHEMAS, a as GET_SEEDS, b as GET_SEED_IDS, c as GET_STORAGE_TRANSACTION_ID, d as GET_VERSIONS, I as Item, g as itemMachineAll, i as itemMachineSingle } from './index-DMIKRod-.js';
 import './constants-BLctWkrn.js';
 import 'path';
 import 'reflect-metadata';
@@ -13,18 +13,18 @@ import 'debug';
 import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
 import 'eventemitter3';
-import 'react';
-import 'rxjs';
-import 'immer';
-import 'pluralize';
 import '@tanstack/react-query';
 import 'graphql-request';
 import '@tanstack/query-sync-storage-persister';
 import '@tanstack/react-query-persist-client';
-import 'use-immer';
-import '@xstate/react';
+import 'rxjs';
+import 'immer';
+import 'pluralize';
 import '@statelyai/inspect';
-import 'arweave';
-import '@zenfs/dom';
 import 'drizzle-orm/sqlite-proxy';
-//# sourceMappingURL=index-ChGsdGPJ.js.map
+import '@zenfs/dom';
+import 'arweave';
+import 'react';
+import 'use-immer';
+import '@xstate/react';
+//# sourceMappingURL=index-wKss7188.js.map

package/dist/index-wKss7188.js.map

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

package/dist/main.js

@@ -1,4 +1,4 @@
-export { h as ImageSrc, I as Item, j as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, s as client, t as getCorrectId, r as getGlobalService, m as useCreateItem, o as useDeleteItem, p as useGlobalServiceStatus, k as useItem, l as useItemProperties, n as useItemProperty, u as useItems, q as useServices, w as withSeed } from './index-BEzB8REh.js';
+export { h as ImageSrc, I as Item, j as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, s as client, t as getCorrectId, r as getGlobalService, m as useCreateItem, o as useDeleteItem, p as useGlobalServiceStatus, k as useItem, l as useItemProperties, n as useItemProperty, u as useItems, q as useServices, w as withSeed } from './index-DMIKRod-.js';
 import 'immer';
 import 'reflect-metadata';
 import './constants-BLctWkrn.js';
@@ -15,16 +15,16 @@ import 'debug';
 import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
 import 'eventemitter3';
-import 'react';
-import 'rxjs';
-import 'pluralize';
 import '@tanstack/react-query';
 import 'graphql-request';
 import '@tanstack/query-sync-storage-persister';
 import '@tanstack/react-query-persist-client';
-import 'use-immer';
-import '@xstate/react';
+import 'rxjs';
+import 'pluralize';
 import '@statelyai/inspect';
-import '@zenfs/dom';
 import 'drizzle-orm/sqlite-proxy';
+import '@zenfs/dom';
+import 'react';
+import 'use-immer';
+import '@xstate/react';
 //# sourceMappingURL=main.js.map

package/dist/{seed.schema.config-jKpK-lR6.js → seed.schema.config-C0M8Rcti.js}

@@ -1,6 +1,6 @@
 import { _ as __decorate, a as __metadata } from './constants-BLctWkrn.js';
 import 'drizzle-orm';
-import { T as Text, M as Model } from './index-BEzB8REh.js';
+import { T as Text, M as Model } from './index-DMIKRod-.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
@@ -16,17 +16,17 @@ import 'debug';
 import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
 import 'eventemitter3';
-import 'rxjs';
-import 'immer';
-import 'pluralize';
 import '@tanstack/react-query';
 import 'graphql-request';
 import '@tanstack/query-sync-storage-persister';
 import '@tanstack/react-query-persist-client';
-import 'use-immer';
-import '@xstate/react';
+import 'rxjs';
+import 'immer';
+import 'pluralize';
 import '@statelyai/inspect';
 import 'drizzle-orm/sqlite-proxy';
+import 'use-immer';
+import '@xstate/react';
 
 let Seed = class Seed {
 };
@@ -74,4 +74,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-jKpK-lR6.js.map
+//# sourceMappingURL=seed.schema.config-C0M8Rcti.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seed.schema.config-C0M8Rcti.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/src/AppStateSchema.ts

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

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

@@ -0,0 +1,15 @@
+import { blob, int, sqliteTable, text, check, } from 'drizzle-orm/sqlite-core'
+import { sql }                          from 'drizzle-orm'
+
+export const config = sqliteTable('config', {
+  id: int('id').primaryKey({ autoIncrement: true }),
+  key: text('key').notNull(),
+  text: text('text'),
+  json: text('json', {mode: 'json'}),
+  blob: blob('blob', {mode: 'buffer'}),
+}, () => {
+  return {
+    // Add a custom check constraint
+    atLeastOneNotNull: check('hasValue', sql`key IS NOT NULL OR text IS NOT NULL OR json IS NOT NULL OR blob IS NOT NULL`),
+  }
+})

package/dist/src/ItemProperty.ts

@@ -0,0 +1,383 @@
+import { ItemPropertyProps, PropertyMachineContext } from '@/types'
+import { ActorRefFrom, createActor, 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'
+
+const logger = debug('app:property:class')
+
+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: ActorRefFrom<typeof propertyMachine>
+  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,
+    itemModelName,
+    propertyName,
+    storageTransactionId,
+    schemaUid,
+  }: ItemPropertyProps) {
+    const ModelClass = getModel(itemModelName)
+
+    if (!ModelClass) {
+      throw new Error(`Model ${itemModelName} not found`)
+    }
+
+    if (!propertyName) {
+      throw new Error(`Property name not provided`)
+    }
+
+    this._lastRenderedValue = propertyValue
+
+    const serviceInput: Partial<PropertyMachineContext> = {
+      propertyValue,
+      seedUid,
+      propertyName,
+      seedLocalId,
+      itemModelName,
+      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((snapshot) => {
+      const { context } = snapshot
+
+      // if (this.uid && !cacheHasProperty(this.uid)) {
+      //   addPropertyToCache(this)
+      // }
+      //
+      // if (!this.uid && this.localId && !cacheHasProperty(this.localId,)) {
+      //   addPropertyToCache(this)
+      // }
+
+      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,
+        // )
+      }
+
+      const 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) {
+      }
+
+      this._subject.next(renderValue)
+      if (context.seedLocalId) {
+        eventEmitter.emit(`item.${itemModelName}.${context.seedLocalId}.update`)
+      }
+      if (context.seedUid) {
+        eventEmitter.emit(`item.${itemModelName}.${context.seedUid}.update`)
+      }
+    })
+
+    this._service.start()
+  }
+
+  private _updateResponseListener(event) {
+    logger(
+      `[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`,
+      event,
+    )
+  }
+
+  static create(props: ItemPropertyProps): ItemProperty<any> | undefined {
+    const { propertyName, seedLocalId, seedUid } = 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)
+  }
+
+  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,
+      })
+      if (instance.status === 'idle') {
+        instance.getService().send({ type: 'refresh' })
+      }
+      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
+  }
+
+  get localId() {
+    return this._service.getSnapshot().context.localId
+  }
+
+  get uid() {
+    return this._service.getSnapshot().context.uid
+  }
+
+  get seedLocalId() {
+    return this._service.getSnapshot().context.seedLocalId
+  }
+
+  get seedUid() {
+    return this._service.getSnapshot().context.seedUid
+  }
+
+  get propertyName() {
+    if (this._alias) {
+      return this._alias
+    }
+    return this._service.getSnapshot().context.propertyName
+  }
+
+  get itemModelName() {
+    return this._service.getSnapshot().context.itemModelName
+  }
+
+  get propertyDef(): Static<typeof TProperty> | undefined {
+    return this._service.getSnapshot().context.propertyRecordSchema
+  }
+
+  get status() {
+    return this._service.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._service.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,
+    )
+  }
+}

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/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
+  }
+`,)