@seedprotocol/sdk 0.2.0 → 0.2.2

package/dist/main.js

@@ -1,6 +1,6 @@
-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';
+export { l as BaseArweaveClient, m as BaseEasClient, n as BaseFileManager, o as BaseQueryClient, 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, q as client, p as eventEmitter, k as getCorrectId, j as getGlobalService, e as useCreateItem, g as useDeleteItem, h as useGlobalServiceStatus, c as useItem, d as useItemProperties, f as useItemProperty, u as useItems, i as useServices, w as withSeed } from './index-DIlkGqpY.js';
 import 'tslib';
 import 'xstate';
 import 'arweave';
@@ -18,9 +18,8 @@ import 'react';
 import 'pluralize';
 import 'eventemitter3';
 import 'lodash-es';
-import './constants-B6s6tGup.js';
+import './constants-yM3e1D1k.js';
 import '@ethereum-attestation-service/eas-sdk';
-import 'thirdweb';
 import '@statelyai/inspect';
 import 'drizzle-orm/sqlite-proxy';
 import 'drizzle-orm/sqlite-proxy/migrator';

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-DIMmvqJf.js → seed.schema.config-Du8pUTQu.js}

@@ -1,15 +1,14 @@
 import { __decorate, __metadata } from 'tslib';
 import 'drizzle-orm';
-import { T as Text, M as Model } from './index-DaK2dz5P.js';
+import { T as Text, M as Model } from './index-DIlkGqpY.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
 import 'arweave';
-import '@zenfs/core';
-import '@zenfs/dom';
+import 'immer';
 import '@sinclair/typebox';
 import 'rxjs';
-import 'immer';
+import '@zenfs/core';
 import 'dayjs';
 import 'nanoid';
 import 'nanoid-dictionary';
@@ -19,14 +18,14 @@ import 'path';
 import 'pluralize';
 import 'eventemitter3';
 import 'lodash-es';
-import './constants-B6s6tGup.js';
+import './constants-yM3e1D1k.js';
 import '@ethereum-attestation-service/eas-sdk';
-import 'thirdweb';
 import '@statelyai/inspect';
 import 'drizzle-orm/sqlite-proxy';
 import 'drizzle-orm/sqlite-proxy/migrator';
 import 'drizzle-orm/migrator';
 import 'node:fs';
+import '@zenfs/dom';
 import 'use-immer';
 import '@xstate/react';
 import 'lodash';
@@ -77,4 +76,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-DIMmvqJf.js.map
+//# sourceMappingURL=seed.schema.config-Du8pUTQu.js.map

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

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

@@ -1,7 +1,7 @@
 import { ActorRefFrom, createActor, SnapshotFrom, Subscription, waitFor } from 'xstate'
 import { BehaviorSubject, Subscriber } from 'rxjs'
 import { Static } from '@sinclair/typebox'
-import { ItemProperty, TProperty } from '@/browser/property'
+import { ItemProperty, TProperty } from '@/browser/ItemProperty'
 import { IItemProperty } from '@/interfaces/IItemProperty'
 import { immerable } from 'immer'
 import { CreatePropertyInstanceProps, PropertyMachineContext } from '@/types'

package/dist/src/IItemProperty.ts

@@ -2,7 +2,7 @@ import { ActorRefFrom, Subscription } from 'xstate';
 import { PropertyMachineContext } from '@/types';
 import { BehaviorSubject } from 'rxjs';
 import { Static } from '@sinclair/typebox';
-import { TProperty } from '@/browser/property';
+import { TProperty } from '@/browser/ItemProperty';
 
 export interface IItemProperty<PropertyType> {
   readonly localId: string;

package/dist/src/ItemProperty.ts

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

package/dist/src/SeedProtocolSdk.d.ts

@@ -1,6 +1,6 @@
 export interface SeedProtocolSdk {
   // Exported classes
-  Item: typeof import('@/browser/item/Item').Item;
+  Item: typeof import('@/browser/Item/Item').Item;
   ItemProperty: typeof import('@/browser/property/ItemProperty').ItemProperty;
 
   // Exported hooks

package/dist/src/client.ts

@@ -12,9 +12,15 @@ import {
 } from '@/stores/modelClass'
 import { setupServiceHandlers } from '@/events/services'
 import { setArweaveDomain } from '@/browser/helpers/arweave'
+import { initItem } from './Item'
+import { initItemProperty } from './ItemProperty'
 
 const client = {
-  init: ({ config, addresses }: SeedConstructorOptions) => {
+  init: async ({ config, addresses }: Promise<SeedConstructorOptions>) => {
+
+    await initItem()
+    await initItemProperty()
+
     const { endpoints, models, arweaveDomain } = config
 
     if (arweaveDomain) {
@@ -41,11 +47,11 @@ const client = {
       addresses,
       arweaveDomain,
     })
-    import('@/shared/configs/seed.schema.config').then(({ models }) => {
-      for (const [key, value] of Object.entries(models)) {
-        setModel(key, value)
-      }
-    })
+
+    const { models: internalModels } = await import('@/shared/configs/seed.schema.config')
+    for (const [key, value] of Object.entries(internalModels)) {
+      setModel(key, value)
+    }
   },
   subscribe: (callback: any) => {
     callback({

package/dist/src/create.ts

@@ -1,4 +1,4 @@
-import { Item } from 'src/browser/item'
+import { Item } from '@/browser/Item'
 import { eventEmitter } from '@/eventBus'
 import { createItemCacheKey, getItemCache, updateItemCache } from './requestAll'
 

package/dist/src/fetchDbData.ts

@@ -1,16 +1,19 @@
 import { EventObject, fromCallback } from 'xstate'
-import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
 
-export const fetchDbData = fromCallback<EventObject, typeof itemMachineAll>(
+export const fetchDbData = fromCallback<
+  EventObject,
+  FromCallbackInput<EventObject, AllItemsMachineContext>
+>(
   ({ sendBack, input: { context } }) => {
     const { modelNamePlural, times } = context
 
-    const _fetchDbData = async (): Promise<void> => {}
+    const _fetchDbData = async (): Promise<void> => { }
 
     _fetchDbData().then(() => {
       sendBack({ type: 'fetchDbDataSuccess' })
     })
 
-    return () => {}
+    return () => { }
   },
 )

package/dist/src/fetchSeeds.ts

@@ -1,6 +1,6 @@
 import { EventObject, fromCallback } from 'xstate'
 import { GET_SEEDS } from '@/Item/queries'
-import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
 import { Attestation } from '@/graphql/gql/graphql'
 import { BaseEasClient } from '@/helpers/BaseEasClient'
 import { BaseQueryClient } from '@/helpers/BaseQueryClient'
@@ -11,7 +11,10 @@ const queryClient = BaseQueryClient.getQueryClient()
 
 const logger = debug('app:allItemsActors:fetchSeeds')
 
-export const fetchSeeds = fromCallback<EventObject, typeof itemMachineAll>(
+export const fetchSeeds = fromCallback<
+  EventObject,
+  FromCallbackInput<EventObject, AllItemsMachineContext>
+>(
   ({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context
 

package/dist/src/fetchVersions.ts

@@ -1,6 +1,6 @@
 import { EventObject, fromCallback } from 'xstate'
 import { GET_VERSIONS } from '@/Item/queries'
-import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
 import { Attestation } from '@/graphql/gql/graphql'
 import { BaseEasClient } from '@/helpers/BaseEasClient'
 import { BaseQueryClient } from '@/helpers/BaseQueryClient'
@@ -9,7 +9,10 @@ const easClient = BaseEasClient.getEasClient()
 const queryClient = BaseQueryClient.getQueryClient()
 
 
-export const fetchVersions = fromCallback<EventObject, typeof itemMachineAll>(
+export const fetchVersions = fromCallback<
+  EventObject,
+  FromCallbackInput<EventObject, AllItemsMachineContext>
+>(
   ({ sendBack, input: { context } }) => {
     const { itemSeeds, modelName } = context
 

package/dist/src/getItem.ts

@@ -1,4 +1,4 @@
-import { Item } from '@/browser/item'
+import { Item } from '@/browser/Item'
 import { getItemData } from './getItemData'
 import { GetItem } from '@/types'
 

package/dist/src/getPublishPayload.ts

@@ -16,7 +16,7 @@ import pluralize from 'pluralize'
 import { getSchemaUidForModel } from '@/db/read/getSchemaUidForModel'
 import { getSchemaUidForSchemaDefinition } from '@/stores/eas'
 import { getCorrectId } from '@/helpers'
-import { Item } from '@/browser/item/Item'
+import { Item } from '@/browser/Item/Item'
 import { getSegmentedItemProperties } from '@/helpers/getSegmentedItemProperties'
 import { IItemProperty } from '@/interfaces'
 

package/dist/src/globalMachine.ts

@@ -14,7 +14,7 @@ import { initialize } from '@/services/global/actors/initialize'
 import { getSchemaForModel } from '@/services/global/actors/getSchemaForModel'
 import { addModelsToDb } from '@/services/global/actors/addModelsToDb'
 import { internalMachine } from '@/services/internal/internalMachine'
-import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+import { itemMachineAll } from '../allItems/itemMachineAll'
 import { publishMachine } from '@/services/publish/publishMachine'
 import { savePublishService } from '@/services/global/actors/savePublishService'
 

package/dist/src/hydrateFromDb.ts

@@ -274,7 +274,7 @@ export const hydrateFromDb = fromCallback<
       propertyRecordSchema.storageType &&
       propertyRecordSchema.storageType === 'ItemStorage'
     ) {
-      const { Item } = await import(`@/browser/item`)
+      const { Item } = await import(`@/browser/Item`)
       const item = await Item.find({
         seedLocalId,
         modelName,

package/dist/src/index.ts

@@ -1,21 +1,4 @@
-import { setup } from 'xstate'
-import {
-  uploadBinaryData,
-  uploadMetadata,
-} from '@/browser/schema/file/upload/actors'
-
-export const uploadMachine = setup({
-  actors: {
-    uploadBinaryData,
-    uploadMetadata,
-  },
-}).createMachine({
-  id: 'upload',
-  initial: 'idle',
-  context: {
-    file: '',
-  },
-  states: {
-    idle: {},
-  },
-})
+export * from './analyzeInput'
+export * from './saveImageSrc'
+export * from './saveRelation'
+export * from './saveItemStorage'

package/dist/src/initialize.ts

@@ -1,277 +1,127 @@
-import { EventObject, fromCallback } from 'xstate'
-import { GET_SCHEMAS } from '@/Item/queries'
-import pluralize from 'pluralize'
-import { BaseEasClient } from '@/helpers/BaseEasClient'
-import { BaseQueryClient } from '@/helpers/BaseQueryClient'
-import { toSnakeCase } from '@/helpers'
+import { EventObject, fromCallback, Subscription } from 'xstate'
+import { isNode, isReactNative } from '@/shared'
 import {
-  models as modelsTable,
-  modelUids,
-  properties,
-  propertyUids,
-} from '@/seedSchema'
-import { eq } from 'drizzle-orm'
-import { SchemaWhereInput } from '@/graphql/gql/graphql'
-import { INTERNAL_DATA_TYPES } from '@/helpers/constants'
-import { getAddressesFromDb } from '@/helpers/db'
-import { eventEmitter } from '@/eventBus'
+  GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
+  GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY,
+  GLOBAL_INITIALIZING_SEND_CONFIG,
+} from '@/services/internal/constants'
+import debug from 'debug'
+import { FromCallbackInput, GlobalMachineContext } from '@/types'
 import { BaseDb } from '@/db/BaseDb'
+import { appState } from '@/seedSchema'
+import { like } from 'drizzle-orm'
+import { fetchSchemaUids } from '@/stores/eas'
 
-import { AllItemsMachineContext, FromCallbackInput } from '@/types'
-
-const easClient = BaseEasClient.getEasClient()
-const queryClient = BaseQueryClient.getQueryClient()
-
-type Times = {
-  initialize?: {
-    start: number | null
-    end: number | null
-  }
-  fetchDbData?: {
-    start: number | null
-    end: number | null
-  }
-  fetchSeeds?: {
-    start: number | null
-    end: number | null
-  }
-  fetchVersions?: {
-    start: number | null
-    end: number | null
-  }
-  fetchRelatedItems?: {
-    start: number | null
-    end: number | null
-  }
-  processItems?: {
-    start: number | null
-    end: number | null
-  }
-}
-
-type InternalDataType = keyof typeof INTERNAL_DATA_TYPES;
+const logger = debug('app:services:global:actors:initialize')
 
 export const initialize = fromCallback<
   EventObject,
-  FromCallbackInput<AllItemsMachineContext>
->(({ sendBack, input: { context } }) => {
-  const { modelName, modelAddedToDb, ModelClass, times } = context
-
-  const newTimes: Times = {
-    initialize: {
-      start: Date.now(),
-      end: null,
-    },
-  }
-
-  let modelNameLowercase: string | undefined
-  let modelNamePlural: string | undefined
-  let queryVariables: Record<string, unknown> | undefined
-  let appDb
+  FromCallbackInput<GlobalMachineContext, EventObject>
+>(({ sendBack, input: { event, context } }) => {
+  const { internalService, models, endpoints, arweaveDomain } = context
 
-  const _initialize = async () => {
-    appDb = BaseDb.getAppDb()
+  const { addresses } = event
 
-    // const rows = await getItemsDataFromDb(modelName)
-    //
-    // if (rows && rows.length > 0) {
-    //   for (const itemData of rows) {
-    //     const {
-    //       versionLocalId,
-    //       versionUid,
-    //       createdAt,
-    //       seedLocalId,
-    //       seedUid,
-    //       attestationCreatedAt,
-    //     } = itemData
-    //
-    //     eventEmitter.emit('item.create.request', {
-    //       itemData: {
-    //         versionLocalId,
-    //         versionUid,
-    //         createdAt,
-    //         seedLocalId,
-    //         seedUid,
-    //         attestationCreatedAt,
-    //       },
-    //       ModelClass,
-    //     })
-    //   }
-    // }
+  let environment = 'browser'
 
-    modelNameLowercase = modelName.toLowerCase()
-    modelNamePlural = pluralize(modelNameLowercase!)
-
-    const modelSchemas = await queryClient.fetchQuery({
-      queryKey: [`getSchemas${modelName}`],
-      queryFn: async () =>
-        easClient.request(GET_SCHEMAS, {
-          where: {
-            schema: {
-              equals: `bytes32 ${toSnakeCase(modelName)}`,
-            },
-          },
-        }),
-    })
+  if (isNode()) {
+    environment = 'node'
+  }
 
-    if (
-      !modelSchemas ||
-      !modelSchemas.schemas ||
-      modelSchemas.schemas.length === 0
-    ) {
-      throw new Error(`No schema found for ${modelName}`)
-    }
+  if (isReactNative()) {
+    environment = 'react-native'
+  }
 
-    const modelSchema = modelSchemas.schemas[0]
+  let internalSubscription: Subscription | undefined
+  let easSubscription: Subscription | undefined
 
-    if (!modelSchema.id) {
-      throw new Error(
-        `No schema ID found for schema ${JSON.stringify(modelSchema)}`,
-      )
+  if (environment === 'browser' && models) {
+    const _initFileSystem = async (): Promise<void> => {
+      return
+      // return new Promise((resolve) => {
+      // })
     }
 
-    const foundModels = await appDb
-      .select({
-        id: modelsTable.id,
-        name: modelsTable.name,
-        uid: modelUids.uid,
+    const _initInternal = async (): Promise<void> => {
+      return new Promise((resolve) => {
+        internalSubscription = internalService.subscribe((snapshot) => {
+          logger('[sdk] [internal] snapshot', snapshot)
+          if (snapshot.value === 'ready') {
+            resolve()
+          }
+        })
+        internalService.send({
+          type: 'init',
+          endpoints,
+          addresses,
+          arweaveDomain,
+        })
       })
-      .from(modelsTable)
-      .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
-      .where(eq(modelsTable.name, modelName))
-      .limit(1)
-
-    const foundModel = foundModels[0]
-
-    if (!foundModel) {
-      sendBack({ type: 'modelNotFound', modelName })
-      return
     }
 
-    await appDb
-      .insert(modelUids)
-      .values({
-        modelId: foundModel.id,
-        uid: modelSchema.id,
-      })
-      .onConflictDoNothing()
+    const _initAllItemsServices = async (): Promise<void> => {
+      const appDb = BaseDb.getAppDb()
 
-    const foundPropertiesDb = await appDb
-      .select({
-        id: properties.id,
-        name: properties.name,
-        dataType: properties.dataType,
-        uid: propertyUids.uid,
-      })
-      .from(properties)
-      .fullJoin(propertyUids, eq(properties.id, propertyUids.propertyId))
-      .where(eq(properties.modelId, foundModel.id))
+      const rows = await appDb
+        .select()
+        .from(appState)
+        .where(like(appState.key, 'snapshot__%'))
 
-    if (foundPropertiesDb && foundPropertiesDb.length > 0) {
-      const queryVariables: { where: SchemaWhereInput } = {
-        where: {
-          OR: [],
-        },
+      const payloadObj = {
+        create: {},
+        restore: {},
       }
 
-      for (const foundPropertyDb of foundPropertiesDb) {
-        if (foundPropertyDb.name && foundPropertyDb.dataType) {
-          const easDatatype = INTERNAL_DATA_TYPES[foundPropertyDb.dataType as InternalDataType].eas
+      const modelNamesRestored: string[] = []
 
-          let easPropertyName = toSnakeCase(foundPropertyDb.name)
-
-          if (foundPropertyDb.dataType === 'Relation') {
-            easPropertyName += '_id'
-          }
-
-          queryVariables.where.OR!.push({
-            schema: {
-              equals: `${easDatatype} ${easPropertyName}`,
-            },
-          })
+      if (rows && rows.length > 0) {
+        for (const row of rows) {
+          const modelName = row.key.replace('snapshot__', '')
+          payloadObj.restore[modelName] = JSON.parse(row.value)
+          modelNamesRestored.push(modelName)
         }
       }
-
-      const foundPropertySchemas = await queryClient.fetchQuery({
-        queryKey: [`getPropertySchemas${modelName}`],
-        queryFn: async () => easClient.request(GET_SCHEMAS, queryVariables),
-      })
-
-      const tempExclusions = ['html', 'json']
-
-      for (const foundProperty of foundPropertiesDb) {
-        if (tempExclusions.includes(foundProperty.name)) {
-          continue
-        }
-        const easDatatype = INTERNAL_DATA_TYPES[foundProperty.dataType as InternalDataType].eas
-
-        let easPropertyName = toSnakeCase(foundProperty.name)
-
-        if (foundProperty.dataType === 'Relation') {
-          easPropertyName += '_id'
-        }
-
-        const regex = new RegExp(`${easDatatype} ${easPropertyName}`)
-        const propertySchema = foundPropertySchemas.schemas.find((s) =>
-          regex.test(s.schema),
-        )
-
-        if (!propertySchema) {
-          // TODO: We should create the schema here?
-          continue
+      for (const [modelName, ModelClass] of Object.entries(models)) {
+        if (!modelNamesRestored.includes(modelName)) {
+          payloadObj.create[modelName] = ModelClass
         }
-        await appDb
-          .insert(propertyUids)
-          .values({
-            propertyId: foundProperty.id,
-            uid: propertySchema.id,
-          })
-          .onConflictDoNothing()
       }
+      sendBack({
+        type: GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
+        ...payloadObj,
+      })
     }
 
-    const addresses = await getAddressesFromDb()
-
-    queryVariables = {
-      where: {
-        attester: {
-          in: addresses,
-        },
-        schemaId: {
-          equals: modelSchema.id,
-        },
-        decodedDataJson: {
-          contains: modelSchema.id,
-        },
-      },
+    const _initEas = async (): Promise<void> => {
+      await fetchSchemaUids()
     }
-  }
 
-  const initializeHandler = () => {
-    _initialize().then(() => {
-      sendBack({
-        type: 'initializeSuccess',
-        modelName,
-        modelNameLowercase,
-        modelNamePlural,
-        queryVariables,
-      })
-      newTimes!.initialize!.end = Date.now()
-      sendBack({ type: 'updateTimes', times: newTimes })
+    _initFileSystem().then(() => {
+      logger('[global/actors] File system initialized')
     })
-  }
 
-  if (modelAddedToDb) {
-    initializeHandler()
-  }
+    _initInternal()
+      .then(() => {
+        return _initAllItemsServices()
+      })
+      .then(() => {
+        return _initEas()
+      })
+      .then(() => {
+        logger('[global/actors] Internal initialized')
+        sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY })
+        internalSubscription?.unsubscribe()
+      })
 
-  const dbReadyHandler = (event) => {
-    initializeHandler()
+    // _initEas().then(() => {
+    //   logger('EAS initialized')
+    // })
   }
 
-  eventEmitter.addListener('allDbsLoaded', dbReadyHandler)
+  sendBack({ type: GLOBAL_INITIALIZING_SEND_CONFIG, environment })
 
   return () => {
-    eventEmitter.removeListener('allDbsLoaded', dbReadyHandler)
+    internalSubscription?.unsubscribe()
+    easSubscription?.unsubscribe()
   }
 })