@livestore/livestore 0.0.12 → 0.0.13

package/dist/util.js

@@ -0,0 +1,53 @@
+/// <reference lib="es2022" />
+/**
+ * This is a tag function for tagged literals.
+ * it lets us get syntax highlighting on SQL queries in VSCode, but
+ * doesn't do anything at runtime.
+ * Code copied from: https://esdiscuss.org/topic/string-identity-template-tag
+ */
+export const sql = (template, ...args) => {
+    let str = '';
+    for (const [i, arg] of args.entries()) {
+        str += template[i] + String(arg);
+    }
+    return str + template.at(-1);
+};
+/** Prepare bind values to send to SQLite
+/*  Add $ to the beginning of keys; which we use as our interpolation syntax
+/*  We also strip out any params that aren't used in the statement,
+/*  because rusqlite doesn't allow unused named params
+/*  TODO: Search for unused params via proper parsing, not string search
+**/
+export const prepareBindValues = (values, statement) => {
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (statement.includes(key)) {
+            result[`$${key}`] = value;
+        }
+    }
+    return result;
+};
+/**
+ * Use this to make assertion at end of if-else chain that all members of a
+ * union have been accounted for.
+ */
+/* eslint-disable-next-line prefer-arrow/prefer-arrow-functions */
+export function casesHandled(x) {
+    throw new Error(`A case was not handled for value: ${objectToString(x)}`);
+}
+export const objectToString = (error) => {
+    const stack = typeof process !== 'undefined' && process.env.CL_DEBUG ? error.stack : undefined;
+    const str = error.toString();
+    const stackStr = stack ? `\n${stack}` : '';
+    if (str !== '[object Object]')
+        return str + stackStr;
+    try {
+        return JSON.stringify({ ...error, stack }, null, 2);
+    }
+    catch (e) {
+        console.log(error);
+        return 'Error while printing error: ' + e;
+    }
+};
+export const isPromise = (value) => typeof value?.then === 'function';
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAO9B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,QAA8B,EAAE,GAAG,IAAe,EAAU,EAAE;IAChF,IAAI,GAAG,GAAG,EAAE,CAAA;IACZ,KAAK,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE;QACrC,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;KACjC;IACD,OAAO,GAAG,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;AAC9B,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,MAAoB,EAAE,SAAiB,EAAgB,EAAE;IACzF,MAAM,MAAM,GAAiB,EAAE,CAAA;IAC/B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACjD,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YAC3B,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,KAAK,CAAA;SAC1B;KACF;IAED,OAAO,MAAM,CAAA;AACf,CAAC,CAAA;AAED;;;GAGG;AACH,kEAAkE;AAClE,MAAM,UAAU,YAAY,CAAC,CAAQ;IACnC,MAAM,IAAI,KAAK,CAAC,qCAAqC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAC3E,CAAC;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAU,EAAU,EAAE;IACnD,MAAM,KAAK,GAAG,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAA;IAC9F,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAA;IAC5B,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAC1C,IAAI,GAAG,KAAK,iBAAiB;QAAE,OAAO,GAAG,GAAG,QAAQ,CAAA;IAEpD,IAAI;QACF,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA;KACpD;IAAC,OAAO,CAAM,EAAE;QACf,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAElB,OAAO,8BAA8B,GAAG,CAAC,CAAA;KAC1C;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAU,EAA6B,EAAE,CAAC,OAAO,KAAK,EAAE,IAAI,KAAK,UAAU,CAAA"}

package/package.json

@@ -1,15 +1,36 @@
 {
   "name": "@livestore/livestore",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
   "exports": {
-    ".": "./dist/index.js",
-    "./react": "./dist/react/index.js",
-    "./effect": "./dist/effect/index.js",
-    "./util": "./dist/util.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./storage/web-worker": {
+      "types": "./dist/storage/web-worker/index.d.ts",
+      "default": "./dist/storage/web-worker/index.js"
+    },
+    "./storage/in-memory": {
+      "types": "./dist/storage/in-memory/index.d.ts",
+      "default": "./dist/storage/in-memory/index.js"
+    },
+    "./storage/tauri": {
+      "types": "./dist/storage/tauri/index.d.ts",
+      "default": "./dist/storage/tauri/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "default": "./dist/react/index.js"
+    },
+    "./effect": {
+      "types": "./dist/effect/index.d.ts",
+      "default": "./dist/effect/index.js"
+    },
+    "./util": {
+      "types": "./dist/util.d.ts",
+      "default": "./dist/util.js"
+    }
   },
   "types": "./dist/index.d.ts",
   "typesVersions": {
@@ -34,11 +55,26 @@
     "@livestore/utils": "workspace:*",
     "@opentelemetry/api": "^1.6.0",
     "comlink": "^4.4.1",
+    "effect-db-schema": "workspace:*",
     "graphql": "^16.8.1",
     "lodash-es": "^4.17.21",
     "sqlite-esm": "3.42.0-build6",
     "uuid": "^9.0.1"
   },
+  "devDependencies": {
+    "@tauri-apps/api": "^1.5.0",
+    "@testing-library/react": "^14.0.0",
+    "@types/lodash-es": "^4.17.9",
+    "@types/react": "^18.2.28",
+    "@types/react-dom": "^18.2.13",
+    "@types/uuid": "^9.0.5",
+    "jsdom": "^22.1.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "typescript": "5.2.2",
+    "vite": "4.4.11",
+    "vitest": "^0.34.6"
+  },
   "peerDependencies": {
     "@tauri-apps/api": "^1.4.0",
     "react": "^18",
@@ -49,16 +85,7 @@
       "optional": true
     }
   },
-  "devDependencies": {
-    "@tauri-apps/api": "^1.4.0",
-    "@testing-library/react": "^14.0.0",
-    "@types/lodash-es": "^4.17.9",
-    "@types/uuid": "^9.0.4",
-    "jsdom": "^22.1.0",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "typescript": "5.2.2",
-    "vite": "4.4.9",
-    "vitest": "^0.34.6"
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/__tests__/react/fixture.tsx

@@ -4,6 +4,7 @@ import React from 'react'
 import * as LiveStore from '../../index.js'
 import { sql } from '../../index.js'
 import * as LiveStoreReact from '../../react/index.js'
+import { InMemoryStorage } from '../../storage/in-memory/index.js'
 
 export type Todo = {
   id: string
@@ -25,24 +26,19 @@ export const globalQueryDefs = {
   appState,
 }
 
-export const schema = LiveStore.defineSchema({
+export const schema = LiveStore.makeSchema({
   tables: {
-    todos: {
-      columns: {
-        id: { type: 'text', primaryKey: true },
-        text: { type: 'text', default: '', nullable: false },
-        completed: { type: 'boolean', default: false, nullable: false },
-      },
-    },
-    app: {
-      columns: {
-        id: { type: 'text', primaryKey: true },
-        newTodoText: { type: 'text', default: '', nullable: true },
-        filter: { type: 'text', default: 'all', nullable: false },
-      },
-    },
+    todos: LiveStore.DbSchema.table('todos', {
+      id: LiveStore.DbSchema.text({ primaryKey: true }),
+      text: LiveStore.DbSchema.text({ default: '', nullable: false }),
+      completed: LiveStore.DbSchema.boolean({ default: false, nullable: false }),
+    }),
+    app: LiveStore.DbSchema.table('app', {
+      id: LiveStore.DbSchema.text({ primaryKey: true }),
+      newTodoText: LiveStore.DbSchema.text({ default: '', nullable: true }),
+      filter: LiveStore.DbSchema.text({ default: 'all', nullable: false }),
+    }),
   },
-  materializedViews: {},
   actions: {
     // TODO: fix these actions to make them have write annotatinos
     addTodo: {
@@ -63,23 +59,18 @@ export const schema = LiveStore.defineSchema({
 })
 
 export const makeTodoMvc = async () => {
-  type UserInfoComponentState = { username: string }
-
-  const AppSchema = LiveStore.defineComponentStateSchema<UserInfoComponentState>({
-    componentType: 'UserInfo',
-    columns: {
-      username: { type: 'text', default: '' },
-    },
+  const AppSchema = LiveStore.defineComponentStateSchema('UserInfo', {
+    username: LiveStore.DbSchema.text({ default: '' }),
   })
 
   const store = await LiveStore.createStore({
     schema,
-    backendOptions: { type: 'web-in-memory' },
-    boot: async (backend) => {
-      backend.execute(sql`INSERT INTO app (newTodoText, filter) VALUES ('', 'all');`)
+    loadStorage: () => InMemoryStorage.load(),
+    boot: async (storage) => {
+      storage.execute(sql`INSERT INTO app (newTodoText, filter) VALUES ('', 'all');`)
       // NOTE we can't insert into components__UserInfo yet because the table doesn't exist yet
-      // backend.execute(sql`INSERT INTO components__UserInfo (id, username) VALUES ('u1', 'username_u1');`)
-      // backend.execute(sql`INSERT INTO components__UserInfo (id, username) VALUES ('u2', 'username_u2');`)
+      // storage.execute(sql`INSERT INTO components__UserInfo (id, username) VALUES ('u1', 'username_u1');`)
+      // storage.execute(sql`INSERT INTO components__UserInfo (id, username) VALUES ('u2', 'username_u2');`)
     },
   })
 

package/src/effect/LiveStore.ts

@@ -4,9 +4,9 @@ import * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 import { mapValues } from 'lodash-es'
 
-import type { Backend, BackendOptions } from '../backends/index.js'
 import type { InMemoryDatabase } from '../inMemoryDatabase.js'
 import type { Schema } from '../schema.js'
+import type { StorageInit } from '../storage/index.js'
 import type { BaseGraphQLContext, GraphQLOptions, LiveStoreQuery, Store } from '../store.js'
 import { createStore } from '../store.js'
 
@@ -22,11 +22,11 @@ export type GlobalQueryDefs = { [key: string]: QueryDefinition }
 export type LiveStoreCreateStoreOptions<GraphQLContext extends BaseGraphQLContext> = {
   schema: Schema
   globalQueryDefs: GlobalQueryDefs
-  backendOptions: BackendOptions
+  loadStorage: () => StorageInit | Promise<StorageInit>
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelTracer?: otel.Tracer
   otelRootSpanContext?: otel.Context
-  boot?: (backend: Backend, parentSpan: otel.Span) => Promise<void>
+  boot?: (db: InMemoryDatabase, parentSpan: otel.Span) => unknown | Promise<unknown>
 }
 
 export const LiveStoreContext = Context.Tag<LiveStoreContext>('@livestore/livestore/LiveStoreContext')
@@ -41,12 +41,12 @@ export const DeferredStoreContext = Context.Tag<DeferredStoreContext>(
 export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
   schema: Schema
   globalQueryDefs?: Effect.Effect<never, never, GlobalQueryDefs>
-  backendOptions: Effect.Effect<never, never, BackendOptions>
+  loadStorage: () => StorageInit | Promise<StorageInit>
   graphQLOptions?: {
     schema: Effect.Effect<otel.Tracer, never, GraphQLSchema>
     makeContext: (db: InMemoryDatabase) => GraphQLContext
   }
-  boot?: (backend: Backend) => Effect.Effect<never, never, void>
+  boot?: (db: InMemoryDatabase) => Effect.Effect<never, never, void>
 }
 
 export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>(
@@ -62,7 +62,7 @@ export const LiveStoreContextDeferred = Layer.effect(DeferredStoreContext, Defer
 export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>({
   globalQueryDefs,
   schema,
-  backendOptions: backendOptions_,
+  loadStorage,
   graphQLOptions: graphQLOptions_,
   boot: boot_,
 }: LiveStoreContextProps<GraphQLContext>): Effect.Effect<
@@ -84,10 +84,8 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
           : Effect.succeed(undefined),
       )
 
-      const backendOptions = yield* $(backendOptions_)
-
       const boot = boot_
-        ? (db: Backend) =>
+        ? (db: InMemoryDatabase) =>
             boot_(db).pipe(Effect.withSpan('boot'), Effect.tapCauseLogPretty, Runtime.runPromise(runtime))
         : undefined
 
@@ -95,7 +93,7 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
         Effect.tryPromise(() =>
           createStore({
             schema,
-            backendOptions,
+            loadStorage,
             graphQLOptions,
             otelTracer,
             otelRootSpanContext,
@@ -116,9 +114,6 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
         }),
       )
 
-      // NOTE give main thread a chance to render
-      yield* $(Effect.yieldNow())
-
       return { store, globalQueries }
     }),
     Effect.tap((storeCtx) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.succeed(def, storeCtx))),

package/src/events.ts

@@ -5,4 +5,4 @@ export type LiveStoreEvent = {
   args?: any
 }
 
-export const EVENTS_TABLE_NAME = '__events'
+export const EVENTS_TABLE_NAME = '__livestore_events'

package/src/inMemoryDatabase.ts

@@ -1,18 +1,14 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
 import { shouldNeverHappen } from '@livestore/utils'
-import { identity } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type * as SqliteWasm from 'sqlite-esm'
-import initSqlJs from 'sqlite-esm'
 
 import BoundMap, { BoundArray } from './bounded-collections.js'
-import type { LiveStoreEvent } from './events.js'
 // import { EVENTS_TABLE_NAME } from './events.js'
 import { sql } from './index.js'
 import { getDurationMsFromSpan, getStartTimeHighResFromSpan } from './otel.js'
 import QueryCache from './QueryCache.js'
-import type { ActionDefinition } from './schema.js'
 import type { Bindable, ParamsObject } from './util.js'
 import { prepareBindValues } from './util.js'
 
@@ -66,18 +62,13 @@ export class InMemoryDatabase {
     public SQL: SqliteWasm.Sqlite3Static,
   ) {}
 
-  static async load(
+  static load(
     data: Uint8Array | undefined,
     otelTracer: otel.Tracer,
     otelRootSpanContext: otel.Context,
-  ): Promise<InMemoryDatabase> {
-    const sqlite3 = await initSqlJs({
-      // Required to load the wasm binary asynchronously. Of course, you can host it wherever you want
-      // You can omit locateFile completely when running in node
-      // locateFile: () => `/sql-wasm.wasm`,
-      print: (message) => console.log(`[sql-client] ${message}`),
-      printErr: (message) => console.error(`[sql-client] ${message}`),
-    })
+    sqlite3: SqliteWasm.Sqlite3Static,
+  ): InMemoryDatabase {
+    // TODO move WASM init higher up in the init process (to do some other work while it's loading)
 
     const db = new sqlite3.oo1.DB({ filename: ':memory:', flags: 'c' }) as DatabaseWithCAPI
     db.capi = sqlite3.capi
@@ -97,7 +88,11 @@ export class InMemoryDatabase {
       )
     }
 
-    return new InMemoryDatabase(db, otelTracer, otelRootSpanContext, sqlite3)
+    const inMemoryDatabase = new InMemoryDatabase(db, otelTracer, otelRootSpanContext, sqlite3)
+
+    configureSQLite(inMemoryDatabase)
+
+    return inMemoryDatabase
   }
 
   txn<TRes>(callback: () => TRes): TRes {
@@ -141,49 +136,75 @@ export class InMemoryDatabase {
     return tablesUsed as string[]
   }
 
-  /**
-   * NOTE `execute` is untraced since it's usually called from `applyEvent` which is traced
-   */
   execute(
     query: string,
     bindValues?: ParamsObject,
     writeTables?: string[],
-    options?: { hasNoEffects?: boolean },
-  ): void {
-    try {
-      let stmt = this.cachedStmts.get(query)
-      if (stmt === undefined) {
-        stmt = this.db.prepare(query)
-        this.cachedStmts.set(query, stmt)
-      }
+    options?: { hasNoEffects?: boolean; otelContext: otel.Context },
+  ): { durationMs: number } {
+    return this.otelTracer.startActiveSpan(
+      'livestore.in-memory-db:execute',
+      // TODO truncate query string
+      { attributes: { 'sql.query': query } },
+      options?.otelContext ?? this.otelRootSpanContext,
+      (span) => {
+        try {
+          let stmt = this.cachedStmts.get(query)
+          if (stmt === undefined) {
+            stmt = this.db.prepare(query)
+            this.cachedStmts.set(query, stmt)
+          }
 
-      if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
-        stmt.bind(prepareBindValues(bindValues, query))
-      }
+          // TODO check whether we can remove the extra `prepareBindValues` call here (e.g. enforce proper type in API)
+          if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
+            stmt.bind(prepareBindValues(bindValues, query))
+          }
 
-      try {
-        stmt.step()
-      } finally {
-        stmt.reset() // Reset is needed for next execution
-      }
-    } catch (error) {
-      shouldNeverHappen(
-        `Error executing query: ${error} \n ${JSON.stringify({
-          query,
-          bindValues,
-        })}`,
-      )
-    }
+          if (import.meta.env.DEV) {
+            this.debugInfo.events.push([query, bindValues])
+          }
 
-    if (options?.hasNoEffects !== true && !this.resultCache.ignoreQuery(query)) {
-      // TODO use write tables instead
-      // check what queries actually end up here.
-      this.resultCache.invalidate(writeTables ?? this.getTablesUsed(query))
-    }
+          try {
+            stmt.step()
+          } finally {
+            stmt.reset() // Reset is needed for next execution
+          }
+        } catch (error) {
+          shouldNeverHappen(
+            `Error executing query: ${error} \n ${JSON.stringify({
+              query,
+              bindValues,
+            })}`,
+          )
+        }
 
-    if (options?.hasNoEffects === true) {
-      return
-    }
+        if (options?.hasNoEffects !== true && !this.resultCache.ignoreQuery(query)) {
+          // TODO use write tables instead
+          // check what queries actually end up here.
+          this.resultCache.invalidate(writeTables ?? this.getTablesUsed(query))
+        }
+
+        span.end()
+
+        const durationMs = getDurationMsFromSpan(span)
+
+        this.debugInfo.queryFrameDuration += durationMs
+        this.debugInfo.queryFrameCount++
+
+        if (durationMs > 5 && import.meta.env.DEV) {
+          this.debugInfo.slowQueries.push([
+            query,
+            bindValues,
+            durationMs,
+            undefined,
+            [],
+            getStartTimeHighResFromSpan(span),
+          ])
+        }
+
+        return { durationMs }
+      },
+    )
   }
 
   select<T = any>(
@@ -218,19 +239,27 @@ export class InMemoryDatabase {
             stmt = this.db.prepare(query)
             this.cachedStmts.set(query, stmt)
           }
-          if (bindValues) {
-            stmt.bind(bindValues ?? {})
+          if (bindValues !== undefined && Object.keys(bindValues).length > 0) {
+            stmt.bind(bindValues)
           }
 
           const result: T[] = []
+
           try {
-            const columns = stmt.getColumnNames()
+            // NOTE `getColumnNames` only works for `SELECT` statements, ignoring other statements for now
+            let columns = undefined
+            try {
+              columns = stmt.getColumnNames()
+            } catch (_e) {}
+
             while (stmt.step()) {
-              const obj: { [key: string]: any } = {}
-              for (const [i, c] of columns.entries()) {
-                obj[c] = stmt.get(i)
+              if (columns !== undefined) {
+                const obj: { [key: string]: any } = {}
+                for (const [i, c] of columns.entries()) {
+                  obj[c] = stmt.get(i)
+                }
+                result.push(obj as unknown as T)
               }
-              result.push(obj as unknown as T)
             }
           } finally {
             // we're caching statements in this iteration. do not free.
@@ -275,67 +304,6 @@ export class InMemoryDatabase {
     )
   }
 
-  // TODO move `applyEvent` logic to Store and only call `execute` here
-  applyEvent(
-    event: LiveStoreEvent,
-    eventDefinition: ActionDefinition,
-    otelContext: otel.Context,
-  ): { durationMs: number } {
-    return this.otelTracer.startActiveSpan('livestore.in-memory-db:applyEvent', {}, otelContext, (span) => {
-      // TODO: in the future, we'll do more CRDT-style stuff here to decide whether to run effects of the event
-
-      // NOTE: These two updates should happen transactionally;
-      // we don't create a transaction here because that's handled in the caller.
-      // The reason for this is that sometimes we want to apply multiple events in a larger transaction.
-
-      // Insert into the events table
-      // this.execute(sql`insert into ${EVENTS_TABLE_NAME} (id, type, args) values ($id, $type, $args)`, {
-      //   id: event.id,
-      //   type: event.type,
-      //   args: JSON.stringify(event.args ?? {}),
-      // })
-
-      const statement =
-        typeof eventDefinition.statement === 'function'
-          ? eventDefinition.statement(event.args)
-          : eventDefinition.statement
-
-      const prepareBindValues = eventDefinition.prepareBindValues ?? identity
-
-      const bindValues =
-        typeof eventDefinition.statement === 'function' && statement.argsAlreadyBound
-          ? {}
-          : prepareBindValues(event.args)
-
-      if (import.meta.env.DEV) {
-        this.debugInfo.events.push([statement.sql, bindValues])
-      }
-
-      // Run the effects of the event
-      this.execute(statement.sql, bindValues, statement.writeTables)
-
-      span.end()
-
-      const durationMs = getDurationMsFromSpan(span)
-
-      this.debugInfo.queryFrameDuration += durationMs
-      this.debugInfo.queryFrameCount++
-
-      if (durationMs > 5 && import.meta.env.DEV) {
-        this.debugInfo.slowQueries.push([
-          statement.sql,
-          bindValues,
-          durationMs,
-          undefined,
-          [],
-          getStartTimeHighResFromSpan(span),
-        ])
-      }
-
-      return { durationMs }
-    })
-  }
-
   export() {
     // Clear statement cache because exporting frees statements
     for (const key of this.cachedStmts.keys()) {
@@ -345,3 +313,18 @@ export class InMemoryDatabase {
     return this.db.capi.sqlite3_js_db_export(this.db.pointer)
   }
 }
+
+/** Set up SQLite performance; hasn't been super carefully optimized yet. */
+const configureSQLite = (db: InMemoryDatabase) => {
+  db.execute(
+    // TODO: revisit these tuning parameters for max performance
+    sql`
+      PRAGMA page_size=32768;
+      PRAGMA cache_size=10000;
+      PRAGMA journal_mode='MEMORY'; -- we don't flush to disk before committing a write
+      PRAGMA synchronous='OFF';
+      PRAGMA temp_store='MEMORY';
+      PRAGMA foreign_keys='ON'; -- we want foreign key constraints to be enforced
+    `,
+  )
+}

package/src/index.ts

@@ -6,18 +6,14 @@ export type { QueryDefinition, LiveStoreCreateStoreOptions, LiveStoreContext } f
 export {
   defineComponentStateSchema,
   EVENT_CURSOR_TABLE,
-  defineSchema,
   defineAction,
   defineActions,
   defineTables,
   defineMaterializedViews,
+  makeSchema,
 } from './schema.js'
 export { InMemoryDatabase, type DebugInfo, emptyDebugInfo } from './inMemoryDatabase.js'
-export { createBackend, IndexType } from './backends/index.js'
-export type { BackendOptions, Backend, BackendType } from './backends/index.js'
-export { isBackendType } from './backends/index.js'
-export type { SelectResponse } from './backends/index.js'
-export { WebWorkerBackend } from './backends/web.js'
+export type { Storage, StorageType, StorageInit } from './storage/index.js'
 export type {
   GetAtom,
   AtomDebugInfo,
@@ -32,16 +28,14 @@ export type { LiveStoreGraphQLQuery } from './reactiveQueries/graphql.js'
 
 export { labelForKey } from './componentKey.js'
 export type { ComponentKey } from './componentKey.js'
-export type {
-  Schema,
-  TableDefinition,
-  GetActionArgs,
-  GetApplyEventArgs,
-  ColumnDefinition,
-  Index,
-  ActionDefinition,
-  ActionDefinitions,
-} from './schema.js'
+export type { Schema, GetActionArgs, GetApplyEventArgs, Index, ActionDefinition, ActionDefinitions } from './schema.js'
+
+export { SqliteAst, SqliteDsl } from 'effect-db-schema'
+
+import type { SqliteAst } from 'effect-db-schema'
+export type TableDefinition = SqliteAst.Table
+
+export { SqliteDsl as DbSchema } from 'effect-db-schema'
 
 export { sql, type Bindable } from './util.js'
 export { isEqual } from 'lodash-es'