@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/write.ts

@@ -0,0 +1,366 @@
+import { sql } from 'drizzle-orm'
+import { generateId } from '@/shared/helpers'
+import { ModelValues } from '@/types'
+import { escapeSqliteString } from '@/shared/helpers/db'
+import { getSeedData } from '@/browser/db/read/getSeedData'
+import { getVersionData } from '@/browser/db/read/getVersionData'
+import debug from 'debug'
+import { eventEmitter } from '@/eventBus'
+import { getAppDb, runQueryForStatement } from '@/browser/db/sqlWasmClient'
+import { appState, MetadataType, seeds } from '@/shared/seedSchema'
+import { createVersion } from '@/browser/db/write/createVersion'
+
+const logger = debug('app:write')
+
+type CreateSeedProps = {
+  type: string
+  seedUid?: string
+}
+
+type CreateSeed = (props: CreateSeedProps) => Promise<string>
+
+const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
+  if (!modelName || (!seedLocalId && !seedUid)) {
+    return
+  }
+  eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`)
+}
+
+export const createSeed: CreateSeed = async ({ type, seedUid }) => {
+  const appDb = getAppDb()
+
+  const newSeedLocalId = generateId()
+
+  await appDb.insert(seeds).values({
+    localId: newSeedLocalId,
+    type,
+    uid: seedUid,
+    createdAt: Date.now(),
+  })
+
+  return newSeedLocalId
+}
+
+type CreateMetadataForExistingRecordProps = {
+  existingRecord: MetadataType
+  propertyName: string
+  propertyValue: any
+}
+
+type CreateMetadataForExistingRecord = (
+  props: CreateMetadataForExistingRecordProps,
+) => Promise<void>
+
+/**
+ * Create a new metadata record from an existing record.
+ * @param existingRecord
+ * @param propertyName
+ * @param propertyValue
+ */
+export const createNewMetadataFromExistingRecord: CreateMetadataForExistingRecord =
+  async ({ existingRecord, propertyName, propertyValue }) => {
+    const appDb = getAppDb()
+
+    const newLocalId = generateId()
+    await appDb.run(
+      sql.raw(
+        `INSERT INTO metadata (local_id, seed_local_id, seed_uid, property_name, property_value, attestation_created_at,
+                               schema_uid, model_type, version_local_id, version_uid, eas_data_type, ref_value_type,
+                               ref_schema_uid, ref_seed_type, ref_resolved_value, ref_resolved_display_value,
+                               attestation_raw)
+         VALUES ('${newLocalId}', '${existingRecord.seedLocalId}',
+                 '${existingRecord.seedUid}' '${propertyName}', '${propertyValue}',
+                 '${existingRecord.attestationCreatedAt}', '${existingRecord.schemaUid}',
+                 '${existingRecord.modelType}',
+                 '${existingRecord.versionLocalId}', '${existingRecord.versionUid}',
+                 '${existingRecord.easDataType}', '${existingRecord.refValueType}',
+                 '${existingRecord.refSchemaUid}', '${existingRecord.refSeedType}',
+                 '${existingRecord.refResolvedValue}', '${existingRecord.refResolvedDisplayValue}',
+                 '${existingRecord.attestationRaw}');
+        `,
+      ),
+    )
+  }
+
+export const updateMetadataValue = async (
+  localId: string,
+  propertyValue: any,
+) => {
+  const appDb = getAppDb()
+
+  await appDb.run(
+    sql.raw(
+      `UPDATE metadata
+       SET property_value = '${propertyValue}'
+       WHERE local_id = '${localId}';
+      `,
+    ),
+  )
+}
+
+type CreateNewItemProps = Partial<ModelValues<any>> & {
+  modelName: string
+}
+
+type CreateNewItemReturnType = {
+  seedLocalId: string
+  versionLocalId: string
+}
+
+type CreateNewItem = (
+  props: CreateNewItemProps,
+) => Promise<CreateNewItemReturnType>
+
+export const createNewItem: CreateNewItem = async ({
+  modelName,
+  ...propertyData
+}) => {
+  if (!modelName) {
+    throw new Error('A model name is required for createNewItem')
+  }
+
+  const appDb = getAppDb()
+
+  const seedType = modelName.toLowerCase()
+
+  const newSeedId = await createSeed({ type: seedType })
+
+  const newVersionId = await createVersion({ seedLocalId: newSeedId })
+
+  for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
+    await appDb.run(
+      sql.raw(
+        `INSERT INTO metadata (seed_local_id, version_local_id, property_name, property_value, model_type, created_at,
+                               attestation_created_at)
+         VALUES ('${newSeedId}', '${newVersionId}', '${propertyName}', '${propertyValue}', '${seedType}', ${Date.now()},
+                 ${Date.now()});`,
+      ),
+    )
+  }
+
+  // eventEmitter.emit(`item.requestAll`, { modelName })
+
+  return {
+    modelName,
+    seedLocalId: newSeedId,
+    versionLocalId: newVersionId,
+  }
+}
+
+type UpdateItemPropertyValueProps = {
+  propertyLocalId?: string
+  propertyName?: string
+  newValue: any
+  seedLocalId?: string
+  seedUid?: string
+  modelName?: string
+  refResolvedValue?: string
+  refResolvedDisplayValue?: string
+  refSeedType?: string
+  versionLocalId?: string
+  versionUid?: string
+  schemaUid?: string
+}
+
+type UpdateItemPropertyValue = (
+  props: UpdateItemPropertyValueProps,
+) => Promise<void>
+
+export const updateItemPropertyValue: UpdateItemPropertyValue = async ({
+  propertyLocalId,
+  propertyName,
+  newValue,
+  seedUid,
+  seedLocalId,
+  modelName,
+  refSeedType,
+  refResolvedValue,
+  refResolvedDisplayValue,
+  versionLocalId,
+  versionUid,
+  schemaUid,
+}) => {
+  if (!propertyLocalId && !seedLocalId) {
+    logger(
+      `[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`,
+    )
+    return
+  }
+
+  let safeNewValue = newValue
+
+  if (
+    typeof newValue === 'string' &&
+    !refResolvedDisplayValue &&
+    !refResolvedValue
+  ) {
+    safeNewValue = escapeSqliteString(newValue)
+  }
+
+  const mostRecentRecordStatement = `SELECT local_id,
+                                            uid,
+                                            property_name,
+                                            property_value,
+                                            model_type,
+                                            seed_uid,
+                                            seed_local_id,
+                                            version_local_id,
+                                            version_uid,
+                                            schema_uid,
+                                            eas_data_type
+                                     FROM metadata
+                                     WHERE property_name = '${propertyName}'
+                                       AND seed_local_id = '${seedLocalId}'
+                                     ORDER BY COALESCE(attestation_created_at, created_at) DESC;`
+
+  const { rows } = await runQueryForStatement(mostRecentRecordStatement)
+
+  if (rows && rows.length > 0) {
+    const mostRecentRecord = rows[0]
+    const localId = mostRecentRecord[0]
+    const uid = mostRecentRecord[1]
+    const propertyNameFromDb = mostRecentRecord[2]
+    const propertyValueFromDb = mostRecentRecord[3]
+    const modelType = mostRecentRecord[4]
+    const seedUid = mostRecentRecord[5]
+    const seedLocalIdFromDb = mostRecentRecord[6]
+    const versionLocalId = mostRecentRecord[7]
+    const versionUid = mostRecentRecord[8]
+    const schemaUid = mostRecentRecord[9]
+    const easDataType = mostRecentRecord[10]
+
+    if (propertyValueFromDb === newValue) {
+      logger(
+        `[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`,
+      )
+      return
+    }
+
+    // This means we already have a local-only record so we should just update that one
+    if (!uid) {
+      const updatePropertyStatement = `UPDATE metadata
+                                       SET property_value             = '${safeNewValue}',
+                                           ref_seed_type              = ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                           ref_resolved_value         = ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                           ref_resolved_display_value = ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                           updated_at                 = ${Date.now()}
+                                       WHERE local_id = '${localId}';`
+
+      await runQueryForStatement(updatePropertyStatement)
+
+      sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+      return
+    }
+
+    const seedDataFromDb = await getSeedData({ seedLocalId })
+    const versionDataFromDb = await getVersionData({ versionLocalId })
+
+    // Here we don't have a local-only record so we need to create a new one
+    const newLocalId = generateId()
+
+    const newPropertyStatement = `INSERT INTO metadata (local_id,
+                                                        property_name,
+                                                        property_value,
+                                                        model_type,
+                                                        seed_uid,
+                                                        seed_local_id,
+                                                        version_local_id,
+                                                        version_uid,
+                                                        schema_uid,
+                                                        eas_data_type,
+                                                        ref_seed_type,
+                                                        ref_resolved_value,
+                                                        ref_resolved_display_value,
+                                                        created_at)
+                                  VALUES ('${newLocalId}',
+                                          '${propertyNameFromDb}',
+                                          '${safeNewValue}',
+                                          '${modelType}',
+                                          ${seedDataFromDb?.uid ? `'${seedDataFromDb.uid}'` : 'NULL'},
+                                          '${seedLocalIdFromDb}',
+                                          '${versionLocalId}',
+                                          ${versionDataFromDb?.uid ? `'${versionDataFromDb.uid}'` : 'NULL'},
+                                          '${schemaUid}',
+                                          ${easDataType ? `'${easDataType}'` : 'NULL'},
+                                          ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                          ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                          ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                          ${Date.now()});`
+
+    await runQueryForStatement(newPropertyStatement)
+
+    sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+    return
+  }
+
+  // Here there are no records for this property on this seed so we should create one
+
+  const newLocalId = generateId()
+
+  if (!seedUid) {
+    const seedData = await getSeedData({ seedLocalId })
+    if (seedData) {
+      seedUid = seedData.uid
+    }
+  }
+
+  if (!versionUid) {
+    const versionData = await getVersionData({ versionLocalId })
+    if (versionData) {
+      versionUid = versionData.uid
+    }
+  }
+
+  const newPropertyStatement = `INSERT INTO metadata (local_id,
+                                                      property_name,
+                                                      property_value,
+                                                      model_type,
+                                                      seed_uid,
+                                                      seed_local_id,
+                                                      version_local_id,
+                                                      version_uid,
+                                                      schema_uid,
+                                                      ref_seed_type,
+                                                      ref_resolved_value,
+                                                      ref_resolved_display_value,
+                                                      created_at)
+                                VALUES ('${newLocalId}',
+                                        '${propertyName}',
+                                        '${safeNewValue}',
+                                        '${modelName?.toLowerCase()}',
+                                        ${seedUid ? `'${seedUid}'` : 'NULL'},
+                                        '${seedLocalId}',
+                                        '${versionLocalId}',
+                                        ${versionUid ? `'${versionUid}'` : 'NULL'},
+                                        '${schemaUid}',
+                                        ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                        ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                        ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                        ${Date.now()});`
+
+  await runQueryForStatement(newPropertyStatement)
+
+  sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+  if (!seedLocalId && propertyName && modelName && newValue) {
+    // TODO: Does this ever happen? If so, what should we do?
+  }
+}
+export const writeAppState = async (key: string, value: string) => {
+  const appDb = getAppDb()
+
+  await appDb
+    .insert(appState)
+    .values({
+      key,
+      value,
+    })
+    .onConflictDoUpdate({
+      target: appState.key,
+      set: {
+        value,
+      },
+    })
+}

package/dist/types/src/browser/db/read/getModelSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getModelSchemas.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getModelSchemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAQ/D,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,eAAe,CAAA;IAC7B,yBAAyB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACtC,CAAA;AACD,KAAK,eAAe,GAAG,MAAM,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe,EAAE,eAsE7B,CAAA"}
+{"version":3,"file":"getModelSchemas.d.ts","sourceRoot":"","sources":["../../../../../../src/browser/db/read/getModelSchemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAS/D,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,eAAe,CAAA;IAC7B,yBAAyB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACtC,CAAA;AACD,KAAK,eAAe,GAAG,MAAM,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe,EAAE,eAsE7B,CAAA"}

package/dist/types/src/browser/item/single/actors/hydrateExistingItem.d.ts

@@ -1,2 +1,4 @@
-export declare const hydrateExistingItem: any;
+import { EventObject } from 'xstate';
+import { FromCallbackInput, HydrateExistingItemEvent, ItemMachineContext } from '@/types';
+export declare const hydrateExistingItem: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<ItemMachineContext<any>, HydrateExistingItemEvent>, EventObject>;
 //# sourceMappingURL=hydrateExistingItem.d.ts.map

package/dist/types/src/browser/item/single/actors/hydrateExistingItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrateExistingItem.d.ts","sourceRoot":"","sources":["../../../../../../../src/browser/item/single/actors/hydrateExistingItem.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB,KAgI9B,CAAA"}
+{"version":3,"file":"hydrateExistingItem.d.ts","sourceRoot":"","sources":["../../../../../../../src/browser/item/single/actors/hydrateExistingItem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAElD,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,mBAAmB,qIAgI9B,CAAA"}

package/dist/types/src/browser/item/single/actors/saveDataToDb.d.ts

@@ -1,6 +1,6 @@
 import { EventObject } from 'xstate';
 export declare const saveDataToDb: import("xstate").CallbackActorLogic<EventObject, import("xstate").StateMachine<import("../../../../types").ItemMachineContext<any>, import("xstate").AnyEventObject, {
-    [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, import("../../../../types").FromCallbackInput<import("../../../../types").ItemMachineContext<any>>, EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, import("../../../../types").FromCallbackInput<import("../../../../types").ItemMachineContext<any>, import("../../../../types").HydrateExistingItemEvent>, EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, import("../../../../types").FromCallbackInput<import("../../../../types").ItemMachineContext<any>>, EventObject>> | undefined;
 }, import("xstate").Values<{
     waitForDb: {
         src: "waitForDb";
@@ -14,7 +14,7 @@ export declare const saveDataToDb: import("xstate").CallbackActorLogic<EventObje
     };
     hydrateExistingItem: {
         src: "hydrateExistingItem";
-        logic: any;
+        logic: import("xstate").CallbackActorLogic<EventObject, import("../../../../types").FromCallbackInput<import("../../../../types").ItemMachineContext<any>, import("../../../../types").HydrateExistingItemEvent>, EventObject>;
         id: string | undefined;
     };
     hydrateNewItem: {
@@ -40,7 +40,7 @@ export declare const saveDataToDb: import("xstate").CallbackActorLogic<EventObje
     };
     hydrateExistingItem: {
         src: "hydrateExistingItem";
-        logic: any;
+        logic: import("xstate").CallbackActorLogic<EventObject, import("../../../../types").FromCallbackInput<import("../../../../types").ItemMachineContext<any>, import("../../../../types").HydrateExistingItemEvent>, EventObject>;
         id: string | undefined;
     };
     hydrateNewItem: {

package/dist/types/src/browser/item/single/itemMachineSingle.d.ts

@@ -1,6 +1,6 @@
 import { ItemMachineContext } from '@/types';
 export declare const itemMachineSingle: import("xstate").StateMachine<ItemMachineContext<any>, import("xstate").AnyEventObject, {
-    [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<ItemMachineContext<any>>, import("xstate").EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<ItemMachineContext<any>>, import("xstate").EventObject>> | undefined;
 }, import("xstate").Values<{
     waitForDb: {
         src: "waitForDb";
@@ -14,7 +14,7 @@ export declare const itemMachineSingle: import("xstate").StateMachine<ItemMachin
     };
     hydrateExistingItem: {
         src: "hydrateExistingItem";
-        logic: any;
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>;
         id: string | undefined;
     };
     hydrateNewItem: {
@@ -40,7 +40,7 @@ export declare const itemMachineSingle: import("xstate").StateMachine<ItemMachin
     };
     hydrateExistingItem: {
         src: "hydrateExistingItem";
-        logic: any;
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>;
         id: string | undefined;
     };
     hydrateNewItem: {

package/dist/types/src/browser/property/ItemProperty.d.ts

@@ -2,7 +2,7 @@ import { ItemPropertyProps, PropertyMachineContext } from '@/types';
 import { Subscriber } from 'rxjs';
 import { immerable } from 'immer';
 import { Static } from '@sinclair/typebox';
-import { TProperty } from '@/browser';
+import { TProperty } from '@/browser/property';
 type ItemPropertyFindProps = {
     propertyName: string;
     propertyLocalId?: string;
@@ -28,7 +28,7 @@ export declare class ItemProperty<PropertyType> {
     static cacheKey(seedLocalIdOrUid: string, propertyName: string): string;
     getService(): import("xstate").ActorRef<import("xstate").MachineSnapshot<PropertyMachineContext, import("xstate").AnyEventObject, {
         [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<PropertyMachineContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").StateMachine<import("@/types").ItemMachineContext<any>, import("xstate").AnyEventObject, {
-            [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>>, import("xstate").EventObject>> | undefined;
+            [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>>, import("xstate").EventObject>> | undefined;
         }, import("xstate").Values<{
             waitForDb: {
                 src: "waitForDb";
@@ -42,7 +42,7 @@ export declare class ItemProperty<PropertyType> {
             };
             hydrateExistingItem: {
                 src: "hydrateExistingItem";
-                logic: any;
+                logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>;
                 id: string | undefined;
             };
             hydrateNewItem: {
@@ -68,7 +68,7 @@ export declare class ItemProperty<PropertyType> {
             };
             hydrateExistingItem: {
                 src: "hydrateExistingItem";
-                logic: any;
+                logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>;
                 id: string | undefined;
             };
             hydrateNewItem: {
@@ -106,7 +106,7 @@ export declare class ItemProperty<PropertyType> {
         resolveRemoteStorage: {
             src: "resolveRemoteStorage";
             logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").StateMachine<import("@/types").ItemMachineContext<any>, import("xstate").AnyEventObject, {
-                [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>>, import("xstate").EventObject>> | undefined;
+                [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>>, import("xstate").EventObject>> | undefined;
             }, import("xstate").Values<{
                 waitForDb: {
                     src: "waitForDb";
@@ -120,7 +120,7 @@ export declare class ItemProperty<PropertyType> {
                 };
                 hydrateExistingItem: {
                     src: "hydrateExistingItem";
-                    logic: any;
+                    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>;
                     id: string | undefined;
                 };
                 hydrateNewItem: {
@@ -146,7 +146,7 @@ export declare class ItemProperty<PropertyType> {
                 };
                 hydrateExistingItem: {
                     src: "hydrateExistingItem";
-                    logic: any;
+                    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<import("@/types").ItemMachineContext<any>, import("@/types").HydrateExistingItemEvent>, import("xstate").EventObject>;
                     id: string | undefined;
                 };
                 hydrateNewItem: {

package/dist/types/src/browser/property/ItemProperty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ItemProperty.d.ts","sourceRoot":"","sources":["../../../../../src/browser/property/ItemProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAEnE,OAAO,EAAmB,UAAU,EAAE,MAAM,MAAM,CAAA;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAQjC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAIrC,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAID,qBAAa,YAAY,CAAC,YAAY;IACpC,OAAO,CAAC,MAAM,CAAC,aAAa,CAGf;IACb,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAC/D,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,oBAAoB,CAAqB;IACjD,CAAC,SAAS,CAAC,UAAO;gBAKN,EACV,aAAa,EACb,OAAO,EACP,WAAW,EACX,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,SAAS,GACV,EAAE,iBAAiB;IA8IpB,OAAO,CAAC,uBAAuB;IAO/B,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS;WA0CzD,IAAI,CAAC,EAChB,YAAY,EACZ,WAAW,EACX,OAAO,GACR,EAAE,qBAAqB,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IA4BjE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;IAKvE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIV,IAAI,OAAO,WAEV;IAED,IAAI,GAAG,WAEN;IAED,IAAI,WAAW,uBAEd;IAED,IAAI,OAAO,uBAEV;IAED,IAAI,YAAY,WAKf;IAED,IAAI,aAAa,WAEhB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,OAAO,SAAS,CAAC,GAAG,SAAS,CAEtD;IAED,IAAI,MAAM,OAET;IAED,IAAI,KAAK,uBAER;IAED,IAAI,KAAK,IAOQ,GAAG,CAFnB;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,GAAG,EAYnB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAItC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,MAAM;CAWP"}
+{"version":3,"file":"ItemProperty.d.ts","sourceRoot":"","sources":["../../../../../src/browser/property/ItemProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAEnE,OAAO,EAAmB,UAAU,EAAE,MAAM,MAAM,CAAA;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAQjC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAI9C,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAID,qBAAa,YAAY,CAAC,YAAY;IACpC,OAAO,CAAC,MAAM,CAAC,aAAa,CAGf;IACb,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAC/D,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,oBAAoB,CAAqB;IACjD,CAAC,SAAS,CAAC,UAAO;gBAKN,EACV,aAAa,EACb,OAAO,EACP,WAAW,EACX,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,SAAS,GACV,EAAE,iBAAiB;IA8IpB,OAAO,CAAC,uBAAuB;IAO/B,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS;WA0CzD,IAAI,CAAC,EAChB,YAAY,EACZ,WAAW,EACX,OAAO,GACR,EAAE,qBAAqB,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IA4BjE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;IAKvE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIV,IAAI,OAAO,WAEV;IAED,IAAI,GAAG,WAEN;IAED,IAAI,WAAW,uBAEd;IAED,IAAI,OAAO,uBAEV;IAED,IAAI,YAAY,WAKf;IAED,IAAI,aAAa,WAEhB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,OAAO,SAAS,CAAC,GAAG,SAAS,CAEtD;IAED,IAAI,MAAM,OAET;IAED,IAAI,KAAK,uBAER;IAED,IAAI,KAAK,IAOQ,GAAG,CAFnB;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,GAAG,EAYnB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAItC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,MAAM;CAWP"}

package/dist/types/src/browser/property/actors/resolveRemoteStorage.d.ts

@@ -1,6 +1,6 @@
 import { EventObject } from 'xstate';
 export declare const resolveRemoteStorage: import("xstate").CallbackActorLogic<EventObject, import("xstate").StateMachine<import("../../../types").ItemMachineContext<any>, import("xstate").AnyEventObject, {
-    [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, import("../../../types").FromCallbackInput<import("../../../types").ItemMachineContext<any>>, EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<any> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, import("../../../types").FromCallbackInput<import("../../../types").ItemMachineContext<any>, import("../../../types").HydrateExistingItemEvent>, EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<EventObject, import("../../../types").FromCallbackInput<import("../../../types").ItemMachineContext<any>>, EventObject>> | undefined;
 }, import("xstate").Values<{
     waitForDb: {
         src: "waitForDb";
@@ -14,7 +14,7 @@ export declare const resolveRemoteStorage: import("xstate").CallbackActorLogic<E
     };
     hydrateExistingItem: {
         src: "hydrateExistingItem";
-        logic: any;
+        logic: import("xstate").CallbackActorLogic<EventObject, import("../../../types").FromCallbackInput<import("../../../types").ItemMachineContext<any>, import("../../../types").HydrateExistingItemEvent>, EventObject>;
         id: string | undefined;
     };
     hydrateNewItem: {
@@ -40,7 +40,7 @@ export declare const resolveRemoteStorage: import("xstate").CallbackActorLogic<E
     };
     hydrateExistingItem: {
         src: "hydrateExistingItem";
-        logic: any;
+        logic: import("xstate").CallbackActorLogic<EventObject, import("../../../types").FromCallbackInput<import("../../../types").ItemMachineContext<any>, import("../../../types").HydrateExistingItemEvent>, EventObject>;
         id: string | undefined;
     };
     hydrateNewItem: {

package/dist/types/src/browser/react/trash.d.ts

@@ -1,4 +1,4 @@
-import { Item } from '@/browser';
+import { Item } from '@/browser/item/Item';
 export declare const useDeleteItem: () => {
     deleteItem: (item: Item<any>) => Promise<void>;
     isDeletingItem: boolean;

package/dist/types/src/browser/react/trash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trash.d.ts","sourceRoot":"","sources":["../../../../../src/browser/react/trash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAIhC,eAAO,MAAM,aAAa;uBAIT,IAAI,CAAC,GAAG,CAAC;;CAmBzB,CAAA"}
+{"version":3,"file":"trash.d.ts","sourceRoot":"","sources":["../../../../../src/browser/react/trash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAA;AAI1C,eAAO,MAAM,aAAa;uBAIT,IAAI,CAAC,GAAG,CAAC;;CAmBzB,CAAA"}

package/dist/types/src/browser/services/db/dbMachine.d.ts

@@ -2,6 +2,11 @@ import { DbServiceContext } from '@/types';
 declare const dbMachine: import("xstate").StateMachine<Partial<DbServiceContext>, import("xstate").AnyEventObject, {
     [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, FromCallbackInput<DbServiceContext>, import("xstate").EventObject>> | undefined;
 }, import("xstate").Values<{
+    migrate: {
+        src: "migrate";
+        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>;
+        id: string | undefined;
+    };
     checkStatus: {
         src: "checkStatus";
         logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>;
@@ -17,12 +22,12 @@ declare const dbMachine: import("xstate").StateMachine<Partial<DbServiceContext>
         logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>;
         id: string | undefined;
     };
+}>, never, never, never, {}, string, Partial<DbServiceContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, import("xstate").MachineConfig<Partial<DbServiceContext>, import("xstate").AnyEventObject, import("xstate").Values<{
     migrate: {
         src: "migrate";
         logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>;
         id: string | undefined;
     };
-}>, never, never, never, {}, string, Partial<DbServiceContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, import("xstate").MachineConfig<Partial<DbServiceContext>, import("xstate").AnyEventObject, import("xstate").Values<{
     checkStatus: {
         src: "checkStatus";
         logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>;
@@ -38,11 +43,6 @@ declare const dbMachine: import("xstate").StateMachine<Partial<DbServiceContext>
         logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>;
         id: string | undefined;
     };
-    migrate: {
-        src: "migrate";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("@/types").FromCallbackInput<DbServiceContext>, import("xstate").EventObject>;
-        id: string | undefined;
-    };
 }>, never, never, never, string, Partial<DbServiceContext>, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject>>;
 export { dbMachine };
 //# sourceMappingURL=dbMachine.d.ts.map