@seedprotocol/sdk 0.3.1 → 0.3.3

package/dist/src/checkStatus.ts

@@ -1,57 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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' })
-  })
-})