@livestore/livestore 0.0.24 → 0.0.27

package/src/reactiveQueries/graphql.ts

@@ -3,11 +3,12 @@ import { assertNever, shouldNeverHappen } from '@livestore/utils'
 import * as otel from '@opentelemetry/api'
 import * as graphql from 'graphql'
 
-import { getDurationMsFromSpan } from '../otel.js'
+import { dbGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
 import type { BaseGraphQLContext, RefreshReason, Store } from '../store.js'
-import { type GetAtomResult, LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
-import { type DbContext, dbGraph } from './graph.js'
+import { getDurationMsFromSpan } from '../utils/otel.js'
+import type { DbContext, GetAtomResult } from './base-class.js'
+import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 import { LiveStoreJSQuery } from './js.js'
 
 export const queryGraphQL = <TResult extends Record<string, any>, TVariableValues extends Record<string, any>>(

package/src/reactiveQueries/js.ts

@@ -1,11 +1,10 @@
 import * as otel from '@opentelemetry/api'
 
-import { getDurationMsFromSpan } from '../otel.js'
+import { dbGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
-import { type GetAtomResult, LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
-import type { DbContext } from './graph.js'
-import { dbGraph } from './graph.js'
+import { getDurationMsFromSpan } from '../utils/otel.js'
+import { type DbContext, type GetAtomResult, LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
 export const queryJS = <TResult>(fn: (get: GetAtomResult) => TResult, options: { label: string }) =>
   new LiveStoreJSQuery<TResult>({ fn, label: options.label })
@@ -18,7 +17,12 @@ export class LiveStoreJSQuery<TResult> extends LiveStoreQueryBase<TResult> {
 
   label: string
 
-  /** Currently only used for "nested destruction" of piped queries */
+  /**
+   * Currently only used for "nested destruction" of piped queries
+   *
+   * i.e. when doing something like `const q = querySQL(...).pipe(...)`
+   * we need to also destory the SQL query when the JS query `q` is destroyed
+   */
   private onDestroy: (() => void) | undefined
 
   constructor({

package/src/reactiveQueries/sql.ts

@@ -1,14 +1,14 @@
 import { shouldNeverHappen } from '@livestore/utils'
 import * as otel from '@opentelemetry/api'
 
-import { getDurationMsFromSpan } from '../otel.js'
+import { dbGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
-import type { Bindable } from '../util.js'
-import { prepareBindValues } from '../util.js'
-import { type GetAtomResult, LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
-import type { DbContext } from './graph.js'
-import { dbGraph } from './graph.js'
+import { getDurationMsFromSpan } from '../utils/otel.js'
+import type { Bindable } from '../utils/util.js'
+import { prepareBindValues } from '../utils/util.js'
+import type { DbContext, GetAtomResult } from './base-class.js'
+import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 import { LiveStoreJSQuery } from './js.js'
 
 export const querySQL = <Row>(
@@ -19,7 +19,7 @@ export const querySQL = <Row>(
      *
      * NOTE In the future we want to do this automatically at build time
      */
-    queriedTables?: ReadonlyArray<string>
+    queriedTables?: Set<string>
     bindValues?: Bindable
     label?: string
   },
@@ -51,7 +51,7 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
   }: {
     label?: string
     genQueryString: string | ((get: GetAtomResult) => string)
-    queriedTables?: ReadonlyArray<string>
+    queriedTables?: Set<string>
     bindValues?: Bindable
   }) {
     super()
@@ -150,7 +150,7 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
         if (results.length === 0 && args?.defaultValue === undefined) {
           // const queryLabel = this._tag === 'sql' ? this.queryString$!.computeResult(otelContext) : this.label
           const queryLabel = this.label
-          throw new Error(`Expected query ${queryLabel} to return at least one result`)
+          return shouldNeverHappen(`Expected query ${queryLabel} to return at least one result`)
         }
         return results[0] ?? args!.defaultValue!
       },

package/src/row-query.ts

@@ -0,0 +1,142 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import { pipe, ReadonlyRecord, Schema, TreeFormatter } from '@livestore/utils/effect'
+import type * as otel from '@opentelemetry/api'
+import { SqliteAst, SqliteDsl } from 'effect-db-schema'
+
+import type { InMemoryDatabase } from './inMemoryDatabase.js'
+import { migrateTable } from './migrations.js'
+import type { LiveStoreJSQuery } from './reactiveQueries/js.js'
+import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
+import { SCHEMA_META_TABLE } from './schema/index.js'
+import type { TableDef } from './schema/table-def.js'
+import type { Store } from './store.js'
+import { prepareBindValues, sql } from './utils/util.js'
+
+export type RowQueryArgs<TTableDef extends TableDef> = TTableDef['options']['isSingleton'] extends true
+  ? {
+      table: TTableDef
+      store: Store
+      otelContext?: otel.Context
+    }
+  : {
+      table: TTableDef
+      store: Store
+      otelContext?: otel.Context
+      id: string
+    }
+
+// TODO also allow other where clauses and multiple rows
+export const rowQuery = <TTableDef extends TableDef>(
+  args: RowQueryArgs<TTableDef>,
+): LiveStoreJSQuery<RowResult<TTableDef>> => {
+  const { table, store } = args
+  const otelContext = args.otelContext ?? store.otel.queriesSpanContext
+  const id: string | undefined = (args as any).id
+
+  // Validate query args
+  if (table.options.isSingleton === true && id !== undefined) {
+    shouldNeverHappen(`Cannot query state table ${table.schema.name} with id "${id}" as it is a singleton`)
+  } else if (table.options.isSingleton !== true && id === undefined) {
+    shouldNeverHappen(`Cannot query state table ${table.schema.name} without id`)
+  }
+
+  const stateSchema = table.schema
+  const componentTableName = stateSchema.name
+
+  type TComponentState = SqliteDsl.FromColumns.RowDecoded<TTableDef['schema']['columns']>
+
+  // TODO find a better solution for this
+  if (store.tableRefs[componentTableName] === undefined) {
+    const schemaHash = SqliteAst.hash(stateSchema.ast)
+    const res = store.inMemoryDB.select<{ schemaHash: number }>(
+      sql`SELECT schemaHash FROM ${SCHEMA_META_TABLE} WHERE tableName = '${componentTableName}'`,
+    )
+    if (res.length === 0 || res[0]!.schemaHash !== schemaHash) {
+      migrateTable({
+        db: store._proxyDb,
+        tableAst: stateSchema.ast,
+        otelContext,
+        schemaHash,
+      })
+    }
+
+    store.tableRefs[componentTableName] = store.graph.makeRef(null, {
+      equal: () => false,
+      label: componentTableName,
+      meta: { liveStoreRefType: 'table' },
+    })
+  }
+
+  // TODO find a way to only do this if necessary
+  insertRowWithDefaultValuesOrIgnore({
+    db: store._proxyDb,
+    id: id ?? 'singleton',
+    stateSchema,
+    otelContext,
+  })
+
+  const whereClause = id === undefined ? '' : `where id = '${id}'`
+  const queryStr = sql`select * from ${componentTableName} ${whereClause} limit 1`
+
+  return new LiveStoreSQLQuery({
+    label: `localState:query:${stateSchema.name}${id === undefined ? '' : `:${id}`}`,
+    genQueryString: queryStr,
+    queriedTables: new Set([componentTableName]),
+  }).pipe<TComponentState>((results) => {
+    if (results.length === 0) return shouldNeverHappen(`No results for query ${queryStr}`)
+
+    const componentStateEffectSchema = SqliteDsl.structSchemaForTable(stateSchema)
+    const parseResult = Schema.parseEither(componentStateEffectSchema)(results[0]!)
+
+    if (parseResult._tag === 'Left') {
+      console.error('decode error', TreeFormatter.formatErrors(parseResult.left.errors), 'results', results)
+      return shouldNeverHappen(`Error decoding query result for ${queryStr}`)
+    }
+
+    return table.isSingleColumn === true ? parseResult.right.value : parseResult.right
+  }) as unknown as LiveStoreJSQuery<RowResult<TTableDef>>
+}
+
+type GetValForKey<T, K> = K extends keyof T ? T[K] : never
+
+export type RowResult<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
+  ? GetValForKey<SqliteDsl.FromColumns.RowDecoded<TTableDef['schema']['columns']>, 'value'>
+  : SqliteDsl.FromColumns.RowDecoded<TTableDef['schema']['columns']>
+
+export type RowResultEncoded<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
+  ? GetValForKey<SqliteDsl.FromColumns.RowEncoded<TTableDef['schema']['columns']>, 'value'>
+  : SqliteDsl.FromColumns.RowEncoded<TTableDef['schema']['columns']>
+
+const insertRowWithDefaultValuesOrIgnore = ({
+  db,
+  id,
+  stateSchema,
+  otelContext,
+}: {
+  db: InMemoryDatabase
+  id: string
+  stateSchema: SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
+  otelContext: otel.Context
+}) => {
+  const columnNames = Object.keys(stateSchema.columns)
+  const columnValues = columnNames.map((name) => `$${name}`).join(', ')
+
+  const tableName = stateSchema.name
+  const insertQuery = sql`insert into ${tableName} (${columnNames.join(
+    ', ',
+  )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = '${id}')`
+
+  const defaultValues = pipe(
+    stateSchema.columns,
+    ReadonlyRecord.filter((_, key) => key !== 'id'),
+    ReadonlyRecord.map((column, columnName) =>
+      column.default === undefined
+        ? column.nullable === true
+          ? null
+          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+        : Schema.encodeSync(column.type.codec)(column.default ?? null),
+    ),
+  )
+
+  void db.execute(insertQuery, prepareBindValues({ ...defaultValues, id }, insertQuery), [tableName], { otelContext })
+}

package/src/schema/action.ts

@@ -0,0 +1,41 @@
+export type SQLWriteStatement = {
+  sql: string
+
+  /** Tables written by the statement */
+  writeTables: ReadonlyArray<string>
+  // TODO refactor this
+  argsAlreadyBound?: boolean
+}
+
+export type ActionDefinition<TArgs = any> = {
+  statement: SQLWriteStatement | ((args: TArgs) => SQLWriteStatement)
+  prepareBindValues?: (args: TArgs) => any
+}
+
+export type ActionDefinitions<TArgsMap extends Record<string, any>> = {
+  [key in keyof TArgsMap]: ActionDefinition<TArgsMap[key]>
+}
+
+export const defineActions = <A extends ActionDefinitions<any>>(actions: A) => actions
+export const defineAction = <TArgs extends Record<string, any>>(
+  action: ActionDefinition<TArgs>,
+): ActionDefinition<TArgs> => action
+
+export type GetApplyEventArgs<TActionDefinitionsMap> = RecordValues<{
+  [eventType in keyof TActionDefinitionsMap]: {
+    eventType: eventType
+    args: GetActionArgs<TActionDefinitionsMap[eventType]>
+  }
+}>
+
+type RecordValues<T> = T extends Record<string, infer V> ? V : never
+
+export type GetActionArgs<A> = A extends ActionDefinition<infer TArgs> ? TArgs : never
+
+// TODO get rid of this
+declare global {
+  // NOTE Can be extended
+  interface LiveStoreActionDefinitionsTypes {
+    [key: string]: ActionDefinition
+  }
+}

package/src/schema/index.ts

@@ -0,0 +1,63 @@
+import type { SqliteDsl } from 'effect-db-schema'
+
+import type { ActionDefinitions } from './action.js'
+import { systemTables } from './system-tables.js'
+import type { TableDef } from './table-def.js'
+
+export * from './action.js'
+export * from './system-tables.js'
+export * as DbSchema from './table-def.js'
+
+// export { SqliteDsl as DbSchema } from 'effect-db-schema'
+
+export type LiveStoreSchema<TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema> = {
+  /** Only used on type-level */
+  readonly _DbSchemaType: TDbSchema
+
+  readonly tables: Map<string, TableDef>
+  readonly actions: ActionDefinitions<any>
+}
+
+export type InputSchema = {
+  tables: Record<string, TableDef> | ReadonlyArray<TableDef>
+  actions: ActionDefinitions<any>
+}
+
+export const makeSchema = <TInputSchema extends InputSchema>(
+  /** Note when using the object-notation for tables, the object keys are ignored and not used as table names */
+  schema: TInputSchema,
+): LiveStoreSchema<DbSchemaFromInputSchemaTables<TInputSchema['tables']>> => {
+  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.schema.ast.name, tableDef)
+  }
+
+  for (const tableDef of systemTables) {
+    tables.set(tableDef.schema.name, tableDef)
+  }
+
+  return {
+    _DbSchemaType: Symbol('livestore.DbSchemaType') as any,
+    tables,
+    actions: schema.actions,
+  } 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['schema']['name']]: K['schema'] }
+    : TTables extends Record<string, TableDef>
+      ? { [K in keyof TTables as TTables[K]['schema']['name']]: TTables[K]['schema'] }
+      : never

package/src/schema/system-tables.ts

@@ -0,0 +1,21 @@
+import { 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

@@ -0,0 +1,199 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
+import type { Nullable, PrettifyFlat } from 'effect-db-schema'
+import { SqliteAst, SqliteDsl } from 'effect-db-schema'
+
+export const {
+  blob,
+  blobWithSchema,
+  boolean,
+  column,
+  datetime,
+  integer,
+  isColumnDefinition,
+  json,
+  real,
+  text,
+  textWithSchema,
+} = SqliteDsl
+
+export { SqliteDsl as __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 TableDef<
+  TTableDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
+  TIsSingleColumn extends boolean = boolean,
+  TOptions extends TableOptions = TableOptions,
+> = {
+  schema: TTableDef
+  isSingleColumn: TIsSingleColumn
+  options: TOptions
+}
+
+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) {
+      if (options_.isSingleton) {
+        columns.id = SqliteDsl.textWithSchema(Schema.literal('singleton'), { primaryKey: true, default: 'singleton' })
+      } else {
+        columns.id = SqliteDsl.text({ primaryKey: true })
+      }
+    }
+  }
+
+  const schema = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
+
+  if (options_.isSingleton) {
+    for (const column of schema.ast.columns) {
+      if (column.nullable === false && column.default === undefined) {
+        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 tableDef = { schema, isSingleColumn, options: options_ }
+
+  if (dynamicallyRegisteredTables.has(tablePath)) {
+    if (SqliteAst.hash(dynamicallyRegisteredTables.get(tablePath)!.schema.ast) !== SqliteAst.hash(schema.ast)) {
+      console.error('previous tableDef', dynamicallyRegisteredTables.get(tablePath), 'new tableDef', schema.ast)
+      shouldNeverHappen(`Table with name "${name}" was already previously defined with a different definition`)
+    }
+  } else {
+    dynamicallyRegisteredTables.set(tablePath, tableDef)
+  }
+
+  return tableDef as any
+}
+
+type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> = TColumns &
+  (TOptions['disableAutomaticIdColumn'] extends true
+    ? {}
+    : TOptions['isSingleton'] extends true
+      ? {
+          id: SqliteDsl.ColumnDefinition<SqliteDsl.FieldType.FieldTypeText<'singleton', 'singleton'>, false>
+        }
+      : {
+          id: SqliteDsl.ColumnDefinition<SqliteDsl.FieldType.FieldTypeText<string, string>, false>
+        })
+
+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['schema']['columns']
+  >
+
+  export type Columns<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['schema']['columns']]: TTableDef['schema']['columns'][K]['type']['columnType']
+  }
+
+  export type RowEncodeNonNullable<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['schema']['columns']]: Schema.Schema.From<TTableDef['schema']['columns'][K]['type']['codec']>
+  }
+
+  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['schema']['columns']]: Schema.Schema.To<TTableDef['schema']['columns'][K]['type']['codec']>
+  }
+}
+
+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]['type']['codec']>
+  }
+
+  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]['type']['codec']>
+  }
+
+  export type NullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
+    [K in keyof TColumns as TColumns[K] extends SqliteDsl.ColumnDefinition<any, true> ? K : never]: {}
+  }
+}

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

@@ -1,6 +1,6 @@
 import type * as otel from '@opentelemetry/api'
 
-import type { PreparedBindValues } from '../../util.js'
+import type { PreparedBindValues } from '../../utils/util.js'
 import type { Storage, StorageOtelProps } from '../index.js'
 
 export type StorageOptionsWebInMemory = {

package/src/storage/index.ts

@@ -8,11 +8,12 @@
 
 import type * as otel from '@opentelemetry/api'
 
-import type { PreparedBindValues } from '../util.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
 
   /** Return a snapshot of persisted data from the storage */

package/src/storage/tauri/index.ts

@@ -2,8 +2,8 @@ import { getTraceParentHeader } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 import { invoke } from '@tauri-apps/api'
 
-import type { PreparedBindValues } from '../../util.js'
-import { prepareBindValues } from '../../util.js'
+import type { PreparedBindValues } from '../../utils/util.js'
+import { prepareBindValues } from '../../utils/util.js'
 import type { Storage, StorageOtelProps } from '../index.js'
 
 export type StorageOptionsTauri = {

package/src/storage/web-worker/index.ts

@@ -2,7 +2,7 @@ import { casesHandled } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 import * as Comlink from 'comlink'
 
-import type { PreparedBindValues } from '../../util.js'
+import type { PreparedBindValues } from '../../utils/util.js'
 import type { Storage, StorageOtelProps } from '../index.js'
 import { IDB } from '../utils/idb.js'
 import type { WrappedWorker } from './worker.js'

package/src/storage/web-worker/worker.ts

@@ -8,8 +8,8 @@ import type * as SqliteWasm from 'sqlite-esm'
 import sqlite3InitModule from 'sqlite-esm'
 
 // import { v4 as uuid } from 'uuid'
-import type { Bindable } from '../../util.js'
-import { casesHandled, sql } from '../../util.js'
+import type { Bindable } from '../../utils/util.js'
+import { casesHandled, sql } from '../../utils/util.js'
 import { IDB } from '../utils/idb.js'
 import type { StorageOptionsWeb } from './index.js'