@seedprotocol/sdk 0.2.54 → 0.3.1

package/dist/src/checkStatus.ts

@@ -0,0 +1,57 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput } from '@/types'
+import {
+  BROWSER_FS_TOP_DIR,
+  DB_CHECK_STATUS_EXISTS,
+  DB_CHECK_STATUS_UPDATE_PATHS,
+} from '@/services/internal/constants'
+import debug from 'debug'
+import { isBrowser } from '@/helpers/environment'
+
+const logger = debug('app:services:db:actors:checkStatus')
+
+export const checkStatus = fromCallback<
+  EventObject,
+  FromCallbackInput<DbServiceContext>
+>(({ sendBack, input: { context, event, } }) => {
+  const { dbName, } = context
+  let { pathToDir, } = context
+
+
+  logger('[db/actors] checkStatus context', context)
+  console.log('[db/actors] checkStatus context', context)
+  console.log('[db/actors] checkStatus event', event)
+  if (isBrowser()) {
+    pathToDir = BROWSER_FS_TOP_DIR
+  }
+  const pathToDbDir = `${pathToDir}/db`
+  const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`
+
+  sendBack({
+    type: DB_CHECK_STATUS_UPDATE_PATHS,
+    pathToDb,
+    pathToDir,
+    pathToDbDir,
+  })
+
+  const _checkStatus = async (): Promise<void> => {
+    // logger('[db/actors] _checkStatus pathToDb', pathToDb)
+    // const exists = await fs.promises.exists(pathToJournal)
+    // if (exists) {
+    //   sendBack({
+    //     type: DB_CHECK_STATUS_EXISTS,
+    //   })
+    //   return
+    // }
+    //
+    // return new Promise((resolve) => {
+    //   sendBack({ type: DB_CHECK_STATUS_DOES_NOT_EXIST })
+    //
+    // })
+  }
+
+  _checkStatus().then(() => {
+    sendBack({ type: DB_CHECK_STATUS_EXISTS })
+    return
+  })
+})

package/dist/src/clientManagerMachine.ts

@@ -0,0 +1,59 @@
+import { ClientManagerContext } from "@/types"
+import { assign, setup } from "xstate"
+import { initialize } from "./actors/initialize"
+import { setAddresses } from "./actions/setAddresses"
+
+export const clientManagerMachine = setup({
+  types: {
+    context: {} as ClientManagerContext,
+    input: {} as ClientManagerContext | undefined,
+  },
+  actions: {
+    setAddresses,
+  },
+  actors: {
+    initialize,
+  },
+}).createMachine({
+  id: 'clientManager',
+  initial: 'uninitialized',
+  context: ({ input }) => input as ClientManagerContext,
+  states: {
+    uninitialized: {
+      on: {
+        init: {
+          target: 'initializing',
+        },
+      },
+    },
+    initializing: {
+      on: {
+        initialized: {
+          target: 'idle',
+        },
+      },
+      invoke: {
+        src: 'initialize',
+        input: ({ event, context }) => ({ event, context }),
+      },
+    },
+    idle: {
+      entry: assign({
+        isInitialized: true,
+      }),
+      on: {
+        saveAppStateSuccess: {
+          actions: assign(({ event }) => {
+            const { key, value } = event
+            return {
+              isSaving: false
+            }
+          }),
+        },
+        setAddresses: {
+          actions: ['setAddresses'],
+        },
+      },
+    },
+  },
+})

package/dist/src/configureFs.ts

@@ -0,0 +1,98 @@
+import { EventObject, fromCallback } from 'xstate'
+import { areFsListenersReady, isFsInitialized } from '@/events/files'
+import { waitForEvent } from '@/events'
+import {
+  BROWSER_FS_TOP_DIR,
+  DB_WAITING_FOR_FILES_RECEIVED,
+  INTERNAL_CONFIGURING_FS_SUCCESS,
+} from '@/services/internal/constants'
+import fs from '@zenfs/core'
+import debug from 'debug'
+import { FromCallbackInput, InternalMachineContext } from '@/types'
+import { isBrowser } from '@/helpers/environment'
+
+const logger = debug('app:internal:actors:configureFs')
+
+export const configureFs = fromCallback<
+  EventObject,
+  FromCallbackInput<InternalMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { endpoints, appDbService, filesDir, } = context
+
+  logger('[internal/actors] [configureFs] Configuring FS')
+
+  const _configureFs = async (): Promise<boolean> => {
+    logger('[internal/actors] [configureFs] calling _configureFs')
+
+    logger(
+      '[internal/actors] [configureFs] areFsListenersReady:',
+      areFsListenersReady(),
+    )
+    logger(
+      '[internal/actors] [configureFs] isFsInitialized:',
+      isFsInitialized(),
+    )
+
+    if (isBrowser()) {
+      await waitForEvent({
+        req: {
+          eventLabel: 'fs.downloadAll.request',
+          data: { endpoints },
+        },
+        res: {
+          eventLabel: 'fs.downloadAll.success',
+        },
+      })
+    }
+
+
+    const journalPath = `${filesDir || BROWSER_FS_TOP_DIR}/db/meta/_journal.json`
+
+
+    let journalExists = await fs.promises.exists(journalPath)
+
+    if (!journalExists) {
+      journalExists = fs.existsSync(journalPath)
+    }
+
+    if (journalExists) {
+      appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
+      logger('[internal/actors] [configureFs] fs configured!')
+      return true
+    }
+
+    sendBack({ type: 'shouldWaitForFiles' })
+    
+
+    return false
+
+    // return new Promise<void>((resolve) => {
+    //   const interval = setInterval(() => {
+    //     journalExistsSync = fs.existsSync(journalPath)
+    //     logger(
+    //       '[internal/actors] [configureFs] journalExistsSync:',
+    //       journalExistsSync,
+    //     )
+    //     if (journalExistsSync) {
+    //       service.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
+    //       clearInterval(interval)
+    //       resolve()
+    //     }
+    //   }, 200)
+    // })
+
+  }
+
+  // Some of our dependencies use fs sync functions, which don't work with
+  // OPFS. ZenFS creates an async cache of all files so that the sync functions
+  // work, but we have to wait for it to be built. Otherwise things like
+  // drizzleMigrate will fail since they can't see the migration files yet.
+  _configureFs().then((fsConfigured) => {
+    if (fsConfigured) {
+      sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS })
+    }
+    return
+  })
+
+  return () => { }
+})

package/dist/src/connectToDb.ts

@@ -0,0 +1,41 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput } from '@/types'
+import { getSqliteWasmClient } from '@/db/sqlWasmClient'
+import { DB_CREATING_SUCCESS } from '@/services/internal/constants'
+import debug from 'debug'
+import { BaseDb } from '@/db/Db/BaseDb'
+
+const logger = debug('app:services:db:actors:connectToDb')
+
+export const connectToDb = fromCallback<
+  EventObject,
+  FromCallbackInput<DbServiceContext>
+>(({ sendBack, input: { context } }) => {
+  logger('[db/actors] connectToDb context', context)
+
+  const { dbName, pathToDir } = context
+
+  if (!pathToDir || !dbName) {
+    throw new Error('pathToDir and dbName are required')
+  }
+
+  let isConnecting = false
+  let dbId: string | undefined
+
+  const _connectToDb = async (): Promise<void> => {
+    if (isConnecting) {
+      return
+    }
+    isConnecting = true
+    const dbId = await BaseDb.connectToDb(pathToDir, dbName)
+    if (dbId) {
+      sendBack({ type: DB_CREATING_SUCCESS, dbId, })
+    }
+    isConnecting = false
+  }
+
+  _connectToDb().then(() => {
+    return
+  })
+
+})

package/dist/src/connectionManager.ts

@@ -0,0 +1,67 @@
+type SqliteDatabase = {
+  open: (filename: string) => Promise<void>
+  exec: (sql: string, params?: any[]) => any
+  close: () => void
+}
+
+class SqliteConnectionManager {
+  private sqliteModule: SqliteDatabase
+  private idleTimeout: number
+  private databases: { [key: string]: SqliteDatabase }
+  private idleTimers: { [key: string]: NodeJS.Timeout }
+
+  constructor(sqliteModule: SqliteDatabase, idleTimeout: number = 300000) {
+    // Default idle timeout: 5 minutes
+    this.sqliteModule = sqliteModule
+    this.idleTimeout = idleTimeout
+    this.databases = {}
+    this.idleTimers = {}
+  }
+
+  private resetIdleTimer(dbName: string): void {
+    if (this.idleTimers[dbName]) {
+      clearTimeout(this.idleTimers[dbName])
+    }
+
+    this.idleTimers[dbName] = setTimeout(() => {
+      this.closeConnection(dbName)
+    }, this.idleTimeout)
+  }
+
+  private async getConnection(dbName: string): Promise<SqliteDatabase> {
+    if (this.databases[dbName]) {
+      this.resetIdleTimer(dbName)
+      return this.databases[dbName]
+    }
+
+    const db = new this.sqliteModule()
+    await db.open(dbName)
+    this.databases[dbName] = db
+    this.resetIdleTimer(dbName)
+    return db
+  }
+
+  public async execute(
+    dbName: string,
+    sql: string,
+    params: any[] = [],
+  ): Promise<any> {
+    const db = await this.getConnection(dbName)
+    const result = db.exec(sql, params)
+    this.resetIdleTimer(dbName)
+    return result
+  }
+
+  public closeConnection(dbName: string): void {
+    if (this.databases[dbName]) {
+      this.databases[dbName].close()
+      delete this.databases[dbName]
+      if (this.idleTimers[dbName]) {
+        clearTimeout(this.idleTimers[dbName])
+        delete this.idleTimers[dbName]
+      }
+    }
+  }
+}
+
+export { SqliteConnectionManager }

package/dist/src/constants.ts

@@ -0,0 +1,125 @@
+const ENV = (typeof process !== 'undefined' && process.env) 
+            ? process.env 
+            : (typeof window !== 'undefined' && (window as any).env) 
+            ? (window as any).env 
+            : {};
+
+
+const MACHINE_ID_SCOPE = '@seedSdk'
+
+export enum MachineIds {
+  GLOBAL      = `${MACHINE_ID_SCOPE}/global`,
+  INTERNAL    = `${MACHINE_ID_SCOPE}/internal`,
+  DB          = `${MACHINE_ID_SCOPE}/db`,
+  EAS         = `${MACHINE_ID_SCOPE}/eas`,
+  ITEM        = `${MACHINE_ID_SCOPE}/item`,
+  ALL_ITEMS   = `${MACHINE_ID_SCOPE}/allItems`,
+  MODEL       = `${MACHINE_ID_SCOPE}/model`,
+  FILE_SYSTEM = `${MACHINE_ID_SCOPE}/fileSystem`,
+}
+
+const { INTERNAL, DB, GLOBAL, EAS, MODEL } = MachineIds
+
+export enum GlobalState {
+  UNINITIALIZED       = 'uninitialized',
+  INITIALIZING        = 'initializing',
+  INITIALIZED         = 'initialized',
+  PUBLISHING_ITEM     = 'publishingItem',
+  ADDING_MODELS_TO_DB = 'addingModelsToDb',
+}
+
+const {
+        UNINITIALIZED,
+        INITIALIZING,
+        INITIALIZED,
+        PUBLISHING_ITEM,
+        ADDING_MODELS_TO_DB,
+      } = GlobalState
+
+export enum InternalState {
+  IDLE             = 'idle',
+  INITIALIZING     = 'initializing',
+  VALIDATING_INPUT = 'validatingInput',
+  CONFIGURING_FS   = 'configuringFs',
+  LOADING_SEED_DB  = 'loadingSeedDb',
+  SAVING_CONFIG    = 'savingConfig',
+  LOADING_APP_DB   = 'loadingAppDb',
+  LOADING_SDK_DB   = 'loadingSdkDb',
+}
+
+const { VALIDATING_INPUT, CONFIGURING_FS, LOADING_SEED_DB, LOADING_APP_DB } =
+        InternalState
+
+export enum DbState {
+  CHECKING_STATUS   = 'checkingStatus',
+  WAITING_FOR_FILES = 'waitingForFiles',
+  VALIDATING        = 'validating',
+  CONNECTING_TO_DB  = 'connectingToDb',
+  // FETCHING_MIGRATIONS = 'fetchingMigrations',
+  MIGRATING         = 'migrating',
+}
+
+const {
+        CHECKING_STATUS,
+        VALIDATING,
+        CONNECTING_TO_DB,
+        WAITING_FOR_FILES,
+        MIGRATING,
+      } = DbState
+
+export enum PublishMachineStates {
+  VALIDATING_ITEM_DATA           = 'validatingItemData',
+  CREATING_PUBLISH_ATTEMPT       = 'creatingPublishAttempt',
+  UPLOADING                      = 'uploading',
+  PREPARING_PUBLISH_REQUEST_DATA = 'preparingPublishRequestData',
+  PUBLISHING                     = 'publishing',
+  IDLE                           = 'idle',
+}
+
+export const INTERNAL_VALIDATING_INPUT_SUCCESS = `${INTERNAL}.${VALIDATING_INPUT}.success`
+
+export const INTERNAL_CONFIGURING_FS_SUCCESS = `${INTERNAL}.${CONFIGURING_FS}.success`
+export const INTERNAL_CONFIGURING_FS_FAILURE = `${INTERNAL}.${CONFIGURING_FS}.failure`
+
+export const INTERNAL_LOADING_SEED_DB_SUCCESS = `${INTERNAL}.${LOADING_SEED_DB}.success`
+export const INTERNAL_LOADING_SEED_DB_FAILURE = `${INTERNAL}.${LOADING_SEED_DB}.failure`
+
+export const INTERNAL_LOADING_APP_DB_SUCCESS = `${INTERNAL}.${LOADING_APP_DB}.success`
+export const INTERNAL_LOADING_APP_DB_FAILURE = `${INTERNAL}.${LOADING_APP_DB}.failure`
+
+export const INTERNAL_SAVING_CONFIG_SUCCESS = `${INTERNAL}.savingConfig.success`
+export const INTERNAL_SAVING_CONFIG_FAILURE = `${INTERNAL}.savingConfig.failure`
+
+export const GLOBAL_GETTING_SEED_CLASS_SUCCESS             = `${GLOBAL}.${PUBLISHING_ITEM}.success`
+export const GLOBAL_INITIALIZING_SEND_CONFIG               = `${GLOBAL}.${INITIALIZING}.sendConfig`
+export const GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY    = `${GLOBAL}.${INITIALIZING}.internalServiceReady`
+export const GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES = `${GLOBAL}.${INITIALIZING}.createAllItemsServices`
+export const GLOBAL_ADDING_MODELS_TO_DB_SUCCESS            = `${GLOBAL}.${ADDING_MODELS_TO_DB}.success`
+
+export const DB_CHECK_STATUS_UPDATE_PATHS   = `${DB}.${CHECKING_STATUS}.updatePaths`
+export const DB_CHECK_STATUS_EXISTS         = `${DB}.${CHECKING_STATUS}.exists`
+export const DB_CHECK_STATUS_DOES_NOT_EXIST = `${DB}.${CHECKING_STATUS}.doesNotExist`
+export const DB_CHECK_STATUS_FAILURE        = `${DB}.${CHECKING_STATUS}.failure`
+
+export const DB_VALIDATING_SUCCESS         = `${DB}.${VALIDATING}.success`
+export const DB_VALIDATING_WAIT            = `${DB}.${VALIDATING}.wait`
+export const DB_MIGRATING_WAIT             = `${DB}.${MIGRATING}.wait`
+export const DB_MIGRATING_SUCCESS          = `${DB}.${MIGRATING}.success`
+export const DB_CREATING_SUCCESS           = `${DB}.${CONNECTING_TO_DB}.success`
+export const DB_WAITING_FOR_FILES_RECEIVED = `${DB}.${WAITING_FOR_FILES}.filesReceived`
+export const DB_ON_SNAPSHOT                = `${DB}.onSnapshot`
+export const CHILD_SNAPSHOT                = 'childSnapshot'
+
+export const INTERNAL_SERVICE_SNAPSHOT = 'internalServiceSnapshot'
+
+export const DB_NAME_APP        = 'app_db'
+export const BROWSER_FS_TOP_DIR = 'app-files'
+
+export const EAS_ENDPOINT =
+               ENV.NEXT_PUBLIC_EAS_ENDPOINT ||
+               ENV.EAS_ENDPOINT ||
+               'https://optimism-sepolia.easscan.org/graphql'
+
+export const ARWEAVE_HOST     =
+               ENV.NEXT_PUBLIC_ARWEAVE_HOST || 'arweave.net'
+export const ARWEAVE_ENDPOINT = `https://${ARWEAVE_HOST}/graphql`

package/dist/src/content-hash.ts

@@ -0,0 +1,30 @@
+const hashLargeString = async ( input: string, ): Promise<string> => {
+  // Convert the string to an ArrayBuffer
+  const encoder = new TextEncoder()
+  const data = encoder.encode(input,)
+
+  // Hash the data with SHA-256
+  const hashBuffer = await crypto.subtle.digest('SHA-256', data,)
+
+  // Convert the ArrayBuffer to a hex string
+  const hashArray = Array.from(new Uint8Array(hashBuffer,),)
+  const hashHex = hashArray.map(( b, ) => b.toString(16,).padStart(2, '0',),).join('',)
+
+  return hashHex
+}
+
+onmessage = async (event,) => {
+  postMessage('Content hash worker received message',)
+  if (!event || !event.data || !event.data.trackingId || !event.data.base64) {
+    postMessage('No event data received',)
+    return
+  }
+  const { trackingId, base64, } = event.data
+  postMessage('Beginning content hash calculation',)
+  const contentHash = await hashLargeString(base64,)
+  postMessage('Content hash calculation complete',)
+  postMessage({
+    trackingId,
+    contentHash,
+  },)
+}

package/dist/src/create.ts

@@ -0,0 +1,39 @@
+import { eventEmitter } from '@/eventBus'
+import { createItemCacheKey, getItemCache, updateItemCache } from './requestAll'
+import { BaseItem } from '@/Item/BaseItem'
+
+export const createItemRequestHandler = async (event) => {
+  const { ModelClass, itemData } = event
+
+  const itemCache = getItemCache()
+
+  const itemCacheKey = createItemCacheKey(itemData)
+
+  if (!itemCacheKey) {
+    console.warn('itemCacheKey not found for itemData', itemData)
+    return
+  }
+
+  if (itemCache.has(itemCacheKey)) {
+    return
+  }
+
+  const newItem = await BaseItem.create({
+    modelName: ModelClass.originalConstructor.name,
+    ...itemData,
+  })
+
+  updateItemCache(itemCacheKey, newItem)
+
+  return new Promise<void>((resolve) => {
+    const subscription = newItem.subscribe((context) => {
+      if (context && context.versionLocalId && context.seedLocalId) {
+        subscription.unsubscribe()
+        // allItemsService.send({ type: 'addItemToContext', item: newItem })
+        eventEmitter.emit('item.create.response', { item: newItem })
+        // eventEmitter.emit('item.requestAll', { modelName })
+        resolve()
+      }
+    })
+  })
+}

package/dist/src/createMetadata.ts

@@ -0,0 +1,77 @@
+import { metadata, MetadataType } from '@/seedSchema'
+import { BaseEasClient, BaseQueryClient, generateId } from '@/helpers'
+import { PropertyType } from '@/types'
+import { BaseDb } from '../Db/BaseDb'
+import { GET_SCHEMA_BY_NAME, } from '@/Item/queries'
+import { INTERNAL_DATA_TYPES } from '@/helpers/constants'
+import { toSnakeCase } from 'drizzle-orm/casing'
+import { Schema } from '@/graphql/gql/graphql'
+import path from 'path'
+import fs from '@zenfs/core'
+
+type CreateMetadata = (
+  metadataValues: Partial<MetadataType>,
+  propertyRecordSchema?: PropertyType | undefined,
+) => Promise<MetadataType>
+
+export const createMetadata: CreateMetadata = async (
+  metadataValues,
+  propertyRecordSchema?,
+) => {
+  const appDb = BaseDb.getAppDb()
+
+  metadataValues.localId = generateId()
+
+  if (!metadataValues.modelType && metadataValues.modelName) {
+    metadataValues.modelType = toSnakeCase(metadataValues.modelName)
+  }
+
+  const isItemStorage = propertyRecordSchema && propertyRecordSchema.storageType === 'ItemStorage'
+
+  // if (
+  //   propertyRecordSchema &&
+  //   propertyRecordSchema.localStorageDir &&
+  //   isItemStorage
+  // ) {
+  //   const filename = `${metadataValues.seedUid || metadataValues.seedLocalId}${propertyRecordSchema.filenameSuffix}`
+  //   const filePath = path.join(propertyRecordSchema.localStorageDir, filename)
+  //   await fs.promises.writeFile(filePath, metadataValues.propertyValue)
+  //   metadataValues.propertyValue = filename
+  //   metadataValues.refValueType = 'file'
+  // }
+
+  if (!isItemStorage && !metadataValues.schemaUid && propertyRecordSchema) {
+    const queryClient = BaseQueryClient.getQueryClient()
+    const easClient = BaseEasClient.getEasClient()
+
+    const easDataType = INTERNAL_DATA_TYPES[propertyRecordSchema.dataType].eas
+
+    const propertyNameSnakeCase = toSnakeCase(metadataValues.propertyName)
+  
+    const queryResult = await queryClient.fetchQuery({
+      queryKey: [`getSchemaByName${metadataValues.propertyName}`],
+      queryFn: async (): Promise<{schemas: Schema[]}> =>
+        easClient.request(GET_SCHEMA_BY_NAME, {
+          where: {
+            schema: {
+              equals: `${easDataType} ${propertyNameSnakeCase}`,
+            },
+          },
+        }),
+    })
+
+    if (queryResult && queryResult.schemas.length > 0) {
+      metadataValues.schemaUid = queryResult.schemas[0].id
+    }
+
+  }
+
+  return appDb
+    .insert(metadata)
+    .values({
+      ...metadataValues,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    })
+    .returning()
+}

package/dist/src/createNewItem.ts

@@ -0,0 +1,61 @@
+import { ModelValues } from '@/types'
+import { getModel } from '@/stores/modelClass'
+import { createSeed } from './createSeed'
+import { createVersion } from './createVersion'
+import { createMetadata } from './createMetadata'
+import { toSnakeCase } from 'drizzle-orm/casing'
+import { eventEmitter } from '@/eventBus'
+
+type CreateNewItemProps = Partial<ModelValues<any>> & {
+  modelName: string
+}
+
+type CreateNewItemReturnType = {
+  modelName: string
+  seedLocalId: string
+  versionLocalId: string
+}
+
+export const createNewItem = async ({
+  modelName,
+  ...propertyData
+}: CreateNewItemProps): Promise<CreateNewItemReturnType> => {
+  if (!modelName) {
+    throw new Error('A model name is required for createNewItem')
+  }
+
+  const seedType = toSnakeCase(modelName)
+
+  const newSeedId = await createSeed({ type: seedType })
+
+  const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: toSnakeCase(modelName) })
+
+  const propertySchemas = getModel(modelName)?.schema
+
+  for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
+    let propertyRecordSchema
+
+    if (propertySchemas && propertySchemas[propertyName]) {
+      propertyRecordSchema = propertySchemas[propertyName]
+    }
+
+    await createMetadata(
+      {
+        seedLocalId: newSeedId,
+        versionLocalId: newVersionId,
+        propertyName,
+        propertyValue,
+        modelName,
+      },
+      propertyRecordSchema,
+    )
+  }
+
+  eventEmitter.emit('item.requestAll', { modelName })
+
+  return {
+    modelName,
+    seedLocalId: newSeedId,
+    versionLocalId: newVersionId,
+  }
+} 

package/dist/src/createPublishAttempt.ts

@@ -0,0 +1,16 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, PublishMachineContext } from '@/types'
+
+export const createPublishAttempt = fromCallback<
+  EventObject,
+  FromCallbackInput<PublishMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const _createPublishAttempt = async () => {
+    // Do some stuff
+    return true
+  }
+
+  _createPublishAttempt().then(() => {
+    sendBack({ type: 'createPublishAttemptSuccess' })
+  })
+})