@livestore/livestore 0.0.41 → 0.0.42-dev.0

package/src/schema/index.ts

@@ -1,100 +0,0 @@
-import type { ReadonlyArray } from '@livestore/utils/effect'
-import type { SqliteDsl } from 'effect-db-schema'
-
-import { isReadonlyArray } from '../utils/util.js'
-import {
-  type MutationDef,
-  type MutationDefMap,
-  type MutationDefRecord,
-  type RawSqlMutation,
-  rawSqlMutation,
-} from './mutations.js'
-import { systemTables } from './system-tables.js'
-import type { TableDef } from './table-def.js'
-
-export * from './system-tables.js'
-export * as DbSchema from './table-def.js'
-export * as ParseUtils from './parse-utils.js'
-export * from './mutations.js'
-
-export type LiveStoreSchema<
-  TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema,
-  TMutationsDefRecord extends MutationDefRecord = MutationDefRecord,
-> = {
-  /** Only used on type-level */
-  readonly _DbSchemaType: TDbSchema
-  /** Only used on type-level */
-  readonly _MutationDefMapType: TMutationsDefRecord
-
-  readonly tables: Map<string, TableDef>
-  readonly mutations: MutationDefMap
-}
-
-export type InputSchema = {
-  readonly tables: Record<string, TableDef> | ReadonlyArray<TableDef>
-  readonly mutations?: ReadonlyArray<MutationDef.Any> | Record<string, MutationDef.Any>
-}
-
-export const makeSchema = <TInputSchema extends InputSchema>(
-  /** Note when using the object-notation for tables/mutations, the object keys are ignored and not used as table/mutation names */
-  schema: TInputSchema,
-): LiveStoreSchema<
-  DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
-  MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>
-> => {
-  const inputTables: ReadonlyArray<TableDef> = Array.isArray(schema.tables)
-    ? schema.tables
-    : // TODO validate that table names are unique in this case
-      Object.values(schema.tables)
-
-  const tables = new Map<string, TableDef>()
-
-  for (const tableDef of inputTables) {
-    // TODO validate tables (e.g. index names are unique)
-    tables.set(tableDef.sqliteDef.ast.name, tableDef)
-  }
-
-  for (const tableDef of systemTables) {
-    tables.set(tableDef.sqliteDef.name, tableDef)
-  }
-
-  const mutations: MutationDefMap = new Map()
-
-  if (isReadonlyArray(schema.mutations)) {
-    for (const mutation of schema.mutations) {
-      mutations.set(mutation.name, mutation)
-    }
-  } else {
-    for (const [name, mutation] of Object.entries(schema.mutations ?? {})) {
-      mutations.set(name, mutation)
-    }
-  }
-
-  mutations.set('livestore.RawSql', rawSqlMutation)
-
-  return {
-    _DbSchemaType: Symbol('livestore.DbSchemaType') as any,
-    _MutationDefMapType: Symbol('livestore.MutationDefMapType') as any,
-    tables,
-    mutations,
-  } satisfies LiveStoreSchema
-}
-
-/**
- * In case of ...
- * - array: we use the table name of each array item (= table definition) as the object key
- * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
- */
-export type DbSchemaFromInputSchemaTables<TTables extends InputSchema['tables']> =
-  TTables extends ReadonlyArray<TableDef>
-    ? { [K in TTables[number] as K['sqliteDef']['name']]: K['sqliteDef'] }
-    : TTables extends Record<string, TableDef>
-      ? { [K in keyof TTables as TTables[K]['sqliteDef']['name']]: TTables[K]['sqliteDef'] }
-      : never
-
-export type MutationDefRecordFromInputSchemaMutations<TMutations extends InputSchema['mutations']> =
-  TMutations extends ReadonlyArray<MutationDef.Any>
-    ? { [K in TMutations[number] as K['name']]: K } & { 'livestore.RawSql': RawSqlMutation }
-    : TMutations extends { [name: string]: MutationDef.Any }
-      ? { [K in keyof TMutations as TMutations[K]['name']]: TMutations[K] } & { 'livestore.RawSql': RawSqlMutation }
-      : never

package/src/schema/mutations.ts

@@ -1,128 +0,0 @@
-import type { BindValues } from '@livestore/sql-queries'
-import { cuid } from '@livestore/utils/cuid'
-import { Schema } from '@livestore/utils/effect'
-
-import type { LiveStoreSchema } from './index.js'
-
-export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
-export type MutationDefRecord = {
-  'livestore.RawSql': RawSqlMutation
-  [name: string]: MutationDef.Any
-}
-
-export type InternalMutationSchema<TRecord extends MutationDefRecord = MutationDefRecord> = {
-  _DefRecord: TRecord
-
-  map: Map<keyof TRecord, TRecord[keyof TRecord]>
-  schemaHashMap: Map<keyof TRecord, number>
-}
-
-export type MutationDef<TName extends string, TFrom, TTo> = {
-  name: TName
-  schema: Schema.Schema<TTo, TFrom>
-  sql:
-    | string
-    | ((args: TTo) =>
-        | string
-        | {
-            sql: string
-            /** Note args need to be manually encoded to `BindValues` when returning this argument */
-            bindValues: BindValues
-            writeTables?: ReadonlySet<string>
-          })
-
-  /** Helper function to construct mutation event */
-  (args: TTo): { mutation: TName; args: TTo; id: string }
-}
-
-export namespace MutationDef {
-  export type Any = MutationDef<string, any, any>
-}
-
-// TODO possibly also allow for mutation event subsumption behaviour
-export const defineMutation = <TName extends string, TFrom, TTo>(
-  name: TName,
-  schema: Schema.Schema<TTo, TFrom>,
-  sql: string | ((args: TTo) => string | { sql: string; bindValues: BindValues; writeTables?: ReadonlySet<string> }),
-): MutationDef<TName, TFrom, TTo> => {
-  const makeEvent = (args: TTo) => ({ mutation: name, args, id: cuid() })
-
-  Object.defineProperty(makeEvent, 'name', { value: name })
-  Object.defineProperty(makeEvent, 'schema', { value: schema })
-  Object.defineProperty(makeEvent, 'sql', { value: sql })
-
-  return makeEvent as MutationDef<TName, TFrom, TTo>
-}
-
-export const makeMutationDefRecord = <TInputRecord extends Record<string, MutationDef.Any>>(
-  inputRecord: TInputRecord,
-): {
-  [K in TInputRecord[keyof TInputRecord]['name']]: Extract<TInputRecord[keyof TInputRecord], { name: K }>
-} => {
-  const result: any = {}
-
-  for (const [name, def] of Object.entries(inputRecord)) {
-    result[name] = def
-  }
-
-  result['livestore.RawSql'] = rawSqlMutation
-
-  return result
-}
-
-export const rawSqlMutation = defineMutation(
-  'livestore.RawSql',
-  Schema.struct({
-    sql: Schema.string,
-    bindValues: Schema.optional(Schema.record(Schema.string, Schema.any)),
-    writeTables: Schema.optional(Schema.readonlySet(Schema.string)),
-  }),
-  ({ sql, bindValues, writeTables }) => ({ sql, bindValues: bindValues ?? {}, writeTables }),
-)
-
-export type RawSqlMutation = typeof rawSqlMutation
-export type RawSqlMutationEvent = ReturnType<typeof rawSqlMutation>
-
-export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
-  mutation: TMutationsDef['name']
-  args: Schema.Schema.To<TMutationsDef['schema']>
-  id: string
-}
-
-export namespace MutationEvent {
-  export type Any = MutationEvent<MutationDef.Any>
-
-  export type ForSchema<TSchema extends LiveStoreSchema> = {
-    [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
-  }[keyof TSchema['_MutationDefMapType']]
-}
-
-export type MutationEventSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.To<TMutationsDefRecord[K]['schema']>
-      id: string
-    }
-  }[keyof TMutationsDefRecord],
-  {
-    [K in keyof TMutationsDefRecord]: {
-      mutation: K
-      args: Schema.Schema.From<TMutationsDefRecord[K]['schema']>
-      id: string
-    }
-  }[keyof TMutationsDefRecord]
->
-
-export const makeMutationEventSchema = <TMutationsDefRecord extends MutationDefRecord>(
-  mutationDefRecord: TMutationsDefRecord,
-): MutationEventSchema<TMutationsDefRecord> =>
-  Schema.union(
-    ...Object.values(mutationDefRecord).map((def) =>
-      Schema.struct({
-        mutation: Schema.literal(def.name),
-        args: def.schema,
-        id: Schema.string,
-      }),
-    ),
-  ) as any

package/src/schema/parse-utils.ts

@@ -1,42 +0,0 @@
-import { shouldNeverHappen } from '@livestore/utils'
-import type { ReadonlyArray } from '@livestore/utils/effect'
-import { pipe, ReadonlyRecord, Schema, TreeFormatter } from '@livestore/utils/effect'
-import { SqliteDsl } from 'effect-db-schema' // eslint-disable-line
-
-import { type FromColumns, type FromTable, getDefaultValuesDecoded, type TableDef } from './table-def.js'
-
-export const many = <TTableDef extends TableDef>(
-  table: TTableDef,
-): ((rawRows: ReadonlyArray<any>) => ReadonlyArray<FromTable.RowDecoded<TTableDef>>) => {
-  return Schema.decodeSync(Schema.array(table.schema)) as TODO
-}
-
-export const first =
-  <TTableDef extends TableDef>(
-    table: TTableDef,
-    fallback?: FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>,
-  ) =>
-  (rawRows: ReadonlyArray<any>) => {
-    const rows = Schema.decodeSync(Schema.array(table.schema))(rawRows)
-
-    if (rows.length === 0) {
-      const schemaDefaultValues = getDefaultValuesDecoded(table)
-
-      const defaultValuesResult = pipe(
-        table.sqliteDef.columns,
-        ReadonlyRecord.map((_column, columnName) => (fallback as any)?.[columnName] ?? schemaDefaultValues[columnName]),
-        Schema.validateEither(table.schema),
-      )
-
-      if (defaultValuesResult._tag === 'Right') {
-        return defaultValuesResult.right
-      } else {
-        console.error('decode error', TreeFormatter.formatError(defaultValuesResult.left))
-        return shouldNeverHappen(
-          `Expected query (for table ${table.sqliteDef.name}) to return at least one result but found none. Also can't fallback to default values as some were not provided.`,
-        )
-      }
-    }
-
-    return rows[0]!
-  }

package/src/schema/system-tables.ts

@@ -1,21 +0,0 @@
-import { type SqliteAst as __SqliteAst, SqliteDsl } from 'effect-db-schema'
-
-import type { FromTable } from './table-def.js'
-import { table } from './table-def.js'
-
-export const SCHEMA_META_TABLE = '__livestore_schema'
-
-const schemaMetaTable = table(
-  SCHEMA_META_TABLE,
-  {
-    tableName: SqliteDsl.text({ primaryKey: true }),
-    schemaHash: SqliteDsl.integer({ nullable: false }),
-    /** ISO date format */
-    updatedAt: SqliteDsl.text({ nullable: false }),
-  },
-  { disableAutomaticIdColumn: true },
-)
-
-export type SchemaMetaRow = FromTable.RowDecoded<typeof schemaMetaTable>
-
-export const systemTables = [schemaMetaTable]

package/src/schema/table-def.ts

@@ -1,270 +0,0 @@
-import { shouldNeverHappen } from '@livestore/utils'
-import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
-import type { Nullable, PrettifyFlat } from 'effect-db-schema'
-import { SqliteAst, SqliteDsl } from 'effect-db-schema'
-
-export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
-
-export { type SqliteDsl } from 'effect-db-schema'
-
-import { dynamicallyRegisteredTables } from '../global-state.js'
-
-export type StateType = 'singleton' | 'dynamic'
-
-export type DefaultSqliteTableDef = SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
-export type DefaultSqliteTableDefConstrained = SqliteDsl.TableDefinition<string, SqliteDsl.ConstraintColumns>
-
-// export type TableDefConstraint<
-//   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
-//   TIsSingleColumn extends boolean = boolean,
-//   TOptions extends TableOptions = TableOptions,
-// > = TableDefBase<TSqliteDef, TIsSingleColumn, TOptions> & { schema: Schema.Schema<any> }
-
-// /**
-//  * NOTE in the past we used to have a single `TableDef` but there are some TS issues when indroducing
-//  * `schema: SqliteDsl.StructSchemaForColumns<TSqliteDef>` so we split it into two types
-//  * and only use `TableDefConstraint` in some places
-//  */
-// export type TableDefBase<
-//   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
-//   TIsSingleColumn extends boolean = boolean,
-//   TOptions extends TableOptions = TableOptions,
-// > = {
-//   sqliteDef: TSqliteDef
-//   // schema: SqliteDsl.StructSchemaForColumns<TSqliteDef>
-//   // schema: any;
-//   isSingleColumn: TIsSingleColumn
-//   options: TOptions
-// }
-
-export type TableDef<
-  TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
-  TIsSingleColumn extends boolean = boolean,
-  TOptions extends TableOptions = TableOptions,
-  // NOTE we're not using `SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>`
-  // as we don't want the alias type for users to show up
-  TSchema = Schema.Schema<
-    SqliteDsl.AnyIfConstained<
-      TSqliteDef['columns'],
-      { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.To<TSqliteDef['columns'][K]['schema']> }
-    >,
-    SqliteDsl.AnyIfConstained<
-      TSqliteDef['columns'],
-      { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.From<TSqliteDef['columns'][K]['schema']> }
-    >
-  >,
-> = {
-  sqliteDef: TSqliteDef
-  isSingleColumn: TIsSingleColumn
-  options: TOptions
-  schema: TSchema
-}
-
-export type TableOptionsInput = Partial<TableOptions & { indexes: SqliteDsl.Index[] }>
-
-export type TableOptions = {
-  /**
-   * Setting this to true will have the following consequences:
-   * - An `id` column will be added with `primaryKey: true` and `"singleton"` as default value and only allowed value
-   * - LiveStore will automatically create the singleton row when the table is created
-   * - LiveStore will fail if there is already a column defined with `primaryKey: true`
-   *
-   * @default false
-   */
-  isSingleton: boolean
-  // TODO
-  dynamicRegistration: boolean
-  disableAutomaticIdColumn: boolean
-}
-
-export const table = <
-  TName extends string,
-  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
-  const TOptionsInput extends TableOptionsInput = TableOptionsInput,
->(
-  name: TName,
-  columnOrColumns: TColumns,
-  // type?: TStateType,
-  options?: TOptionsInput,
-): TableDef<
-  SqliteDsl.TableDefinition<
-    TName,
-    PrettifyFlat<
-      WithId<TColumns extends SqliteDsl.Columns ? TColumns : { value: TColumns }, WithDefaults<TOptionsInput>>
-    >
-  >,
-  TColumns extends SqliteDsl.ColumnDefinition<any, any> ? true : false,
-  WithDefaults<TOptionsInput>
-> => {
-  const tablePath = name
-
-  const options_: TableOptions = {
-    isSingleton: options?.isSingleton ?? false,
-    dynamicRegistration: options?.dynamicRegistration ?? false,
-    disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
-  }
-
-  const columns = (
-    SqliteDsl.isColumnDefinition(columnOrColumns) ? { value: columnOrColumns } : columnOrColumns
-  ) as SqliteDsl.Columns
-
-  if (options_.disableAutomaticIdColumn === true) {
-    if (columns.id === undefined && options_.isSingleton === true) {
-      shouldNeverHappen(
-        `Cannot create table ${name} with "isSingleton: true" because there is no column with name "id" and "disableAutomaticIdColumn: true" is set`,
-      )
-    }
-  } else if (columns.id === undefined && ReadonlyRecord.some(columns, (_) => _.primaryKey === true) === false) {
-    if (options_.isSingleton) {
-      columns.id = SqliteDsl.text({ schema: Schema.literal('singleton'), primaryKey: true, default: 'singleton' })
-    } else {
-      columns.id = SqliteDsl.text({ primaryKey: true })
-    }
-  }
-
-  const sqliteDef = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
-
-  if (options_.isSingleton) {
-    for (const column of sqliteDef.ast.columns) {
-      if (column.nullable === false && column.default._tag === 'None') {
-        shouldNeverHappen(
-          `When creating a singleton table, each column must be either nullable or have a default value. Column '${column.name}' is neither.`,
-        )
-      }
-    }
-  }
-
-  const isSingleColumn = SqliteDsl.isColumnDefinition(columnOrColumns) === true
-
-  const schema = SqliteDsl.structSchemaForTable(sqliteDef)
-  const tableDef = { sqliteDef, isSingleColumn, options: options_, schema } satisfies TableDef
-
-  if (dynamicallyRegisteredTables.has(tablePath)) {
-    if (SqliteAst.hash(dynamicallyRegisteredTables.get(tablePath)!.sqliteDef.ast) !== SqliteAst.hash(sqliteDef.ast)) {
-      console.error('previous tableDef', dynamicallyRegisteredTables.get(tablePath), 'new tableDef', sqliteDef.ast)
-      shouldNeverHappen(`Table with name "${name}" was already previously defined with a different definition`)
-    }
-  } else {
-    dynamicallyRegisteredTables.set(tablePath, tableDef)
-  }
-
-  return tableDef as any
-}
-
-export const tableIsSingleton = <TTableDef extends TableDef>(
-  tableDef: TTableDef,
-): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
-
-export const getDefaultValuesEncoded = <TTableDef extends TableDef>(
-  tableDef: TTableDef,
-  fallbackValues?: Record<string, any>,
-) =>
-  pipe(
-    tableDef.sqliteDef.columns,
-    ReadonlyRecord.filter((col, key) => {
-      if (fallbackValues?.[key] !== undefined) return true
-      if (key === 'id') return false
-      return col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false
-    }),
-    ReadonlyRecord.map((column, columnName) =>
-      fallbackValues?.[columnName] === undefined
-        ? column!.default._tag === 'None'
-          ? column!.nullable === true
-            ? null
-            : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
-          : Schema.encodeSync(column!.schema)(column!.default.value)
-        : fallbackValues[columnName],
-    ),
-  )
-
-export const getDefaultValuesDecoded = <TTableDef extends TableDef>(tableDef: TTableDef) =>
-  pipe(
-    tableDef.sqliteDef.columns,
-    ReadonlyRecord.filter((_, key) => key !== 'id'),
-    ReadonlyRecord.filter(
-      (col) => col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false,
-    ),
-    ReadonlyRecord.map((column, columnName) =>
-      column!.default._tag === 'None'
-        ? column!.nullable === true
-          ? null
-          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
-        : Schema.validateSync(column!.schema)(column!.default.value),
-    ),
-  )
-
-type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> = TColumns &
-  (TOptions['disableAutomaticIdColumn'] extends true
-    ? {}
-    : TOptions['isSingleton'] extends true
-      ? {
-          id: SqliteDsl.ColumnDefinition<'singleton', 'singleton'>
-        }
-      : {
-          id: SqliteDsl.ColumnDefinition<string, string>
-        })
-
-type WithDefaults<TOptionsInput extends TableOptionsInput> = {
-  isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
-  dynamicRegistration: TOptionsInput['dynamicRegistration'] extends true ? true : false
-  disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
-}
-
-export namespace FromTable {
-  // TODO this sometimes doesn't preserve the order of columns
-  export type RowDecoded<TTableDef extends TableDef> = PrettifyFlat<
-    Nullable<Pick<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>> &
-      Omit<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>
-  >
-
-  export type NullableColumnNames<TTableDef extends TableDef> = FromColumns.NullableColumnNames<
-    TTableDef['sqliteDef']['columns']
-  >
-
-  export type Columns<TTableDef extends TableDef> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['columnType']
-  }
-
-  export type RowEncodeNonNullable<TTableDef extends TableDef> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.From<TTableDef['sqliteDef']['columns'][K]['schema']>
-  }
-
-  export type RowEncoded<TTableDef extends TableDef> = PrettifyFlat<
-    Nullable<Pick<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>> &
-      Omit<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>
-  >
-
-  export type RowDecodedAll<TTableDef extends TableDef> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.To<TTableDef['sqliteDef']['columns'][K]['schema']>
-  }
-}
-
-export namespace FromColumns {
-  // TODO this sometimes doesn't preserve the order of columns
-  export type RowDecoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
-    Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> &
-      Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>
-  >
-
-  export type RowDecodedAll<TColumns extends SqliteDsl.Columns> = {
-    [K in keyof TColumns]: Schema.Schema.To<TColumns[K]['schema']>
-  }
-
-  export type RowEncoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
-    Nullable<Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>> &
-      Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
-  >
-
-  export type RowEncodeNonNullable<TColumns extends SqliteDsl.Columns> = {
-    [K in keyof TColumns]: Schema.Schema.From<TColumns[K]['schema']>
-  }
-
-  export type NullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
-    [K in keyof TColumns as TColumns[K]['default'] extends true ? K : never]: {}
-  }
-
-  export type RequiredInsertColumnNames<TColumns extends SqliteDsl.Columns> =
-    SqliteDsl.FromColumns.RequiredInsertColumnNames<TColumns>
-
-  export type InsertRowDecoded<TColumns extends SqliteDsl.Columns> = SqliteDsl.FromColumns.InsertRowDecoded<TColumns>
-}

package/src/storage/in-memory/index.ts

@@ -1,28 +0,0 @@
-import type * as otel from '@opentelemetry/api'
-
-import type { MutationEvent } from '../../index.js'
-import type { PreparedBindValues } from '../../utils/util.js'
-import type { Storage, StorageOtelProps } from '../index.js'
-
-export type StorageOptionsWebInMemory = {
-  type: 'web-in-memory'
-}
-
-/** NOTE: This storage is currently only used for testing */
-export class InMemoryStorage implements Storage {
-  constructor(readonly otelTracer: otel.Tracer) {}
-
-  static load = async (_options?: StorageOptionsWebInMemory) => {
-    return ({ otelTracer }: StorageOtelProps) => new InMemoryStorage(otelTracer)
-  }
-
-  execute = (_query: string, _bindValues?: PreparedBindValues): void => {}
-
-  mutate = (_mutationEventEncoded: MutationEvent.Any, _parentSpan?: otel.Span | undefined) => {}
-
-  getPersistedData = async (): Promise<Uint8Array> => new Uint8Array()
-
-  getMutationLogData = async (): Promise<Uint8Array> => new Uint8Array()
-
-  dangerouslyReset = async () => {}
-}

package/src/storage/index.ts

@@ -1,36 +0,0 @@
-// A storage represents a raw SQLite database.
-// Examples include:
-// - A native SQLite process running in a Tauri Rust process
-// - A SQL.js WASM version of SQLite running in a web worker
-//
-// We can send commands to execute various kinds of queries,
-// and respond to various events from the database.
-
-import type * as otel from '@opentelemetry/api'
-
-import type { MutationEvent } from '../index.js'
-import type { PreparedBindValues } from '../utils/util.js'
-
-export type StorageInit = (otelProps: StorageOtelProps) => Promise<Storage> | Storage
-
-export interface Storage {
-  // TODO consider transferables for `bindValues` (e.g. Uint8Array values)
-  execute(query: string, bindValues?: PreparedBindValues, parentSpan?: otel.Span): void
-
-  // TODO consider transferables for `bindValues` (e.g. Uint8Array values)
-  mutate(mutationEventEncoded: MutationEvent.Any, parentSpan?: otel.Span): void
-
-  /** Return a snapshot of persisted data from the storage */
-  getPersistedData(parentSpan?: otel.Span): Promise<Uint8Array>
-
-  getMutationLogData(parentSpan?: otel.Span): Promise<Uint8Array>
-
-  dangerouslyReset(): Promise<void>
-}
-
-export type StorageType = 'tauri' | 'web' | 'web-in-memory'
-
-export type StorageOtelProps = {
-  otelTracer: otel.Tracer
-  parentSpan: otel.Span
-}