@livestore/common 0.4.0-dev.9 → 0.5.0-dev.0

package/src/schema/state/sqlite/table-def.ts

@@ -1,5 +1,6 @@
 import { type Nullable, shouldNeverHappen } from '@livestore/utils'
-import { Option, Schema, SchemaAST, type Types } from '@livestore/utils/effect'
+import type { Schema } from '@livestore/utils/effect'
+import { SchemaAST, type Types } from '@livestore/utils/effect'
 
 import { getColumnDefForSchema, schemaFieldsToColumns } from './column-def.ts'
 import { SqliteDsl } from './db-schema/mod.ts'
@@ -38,29 +39,17 @@ export type TableDef<
   // https://github.com/livestorejs/livestore/issues/382
   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
   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, so we're redefining it here
-  // TODO adjust this to `TSchema = Schema.TypeLiteral<` but requires some advance type-level work
-  TSchema = Schema.Schema<
-    SqliteDsl.AnyIfConstained<
-      TSqliteDef['columns'],
-      { readonly [K in keyof TSqliteDef['columns']]: TSqliteDef['columns'][K]['schema']['Type'] }
-    >,
-    SqliteDsl.AnyIfConstained<
-      TSqliteDef['columns'],
-      { readonly [K in keyof TSqliteDef['columns']]: TSqliteDef['columns'][K]['schema']['Encoded'] }
-    >
-  >,
+  TSchema extends Schema.Top = Schema.Struct<SqliteDsl.StructFieldsForColumns<TSqliteDef['columns']>>,
 > = {
   sqliteDef: TSqliteDef
   options: TOptions
   // Derived from `sqliteDef`, so only exposed for convenience
   rowSchema: TSchema
   insertSchema: SqliteDsl.InsertStructSchemaForColumns<TSqliteDef['columns']>
-  // query: QueryBuilder<ReadonlyArray<Schema.Schema.Type<TSchema>>, TableDefBase<TSqliteDef & {}, TOptions>>
-  readonly Type: Schema.Schema.Type<TSchema>
-  readonly Encoded: Schema.Schema.Encoded<TSchema>
-} & QueryBuilder<ReadonlyArray<Schema.Schema.Type<TSchema>>, TableDefBase<TSqliteDef & {}, TOptions>>
+  // query: QueryBuilder<ReadonlyArray<TSchema['Type']>>, TableDefBase<TSqliteDef & {}, TOptions>>
+  readonly Type: TSchema['Type']
+  readonly Encoded: TSchema['Encoded']
+} & QueryBuilder<ReadonlyArray<TSchema['Type']>, TableDefBase<TSqliteDef & {}, TOptions>>
 
 export type TableOptionsInput = Partial<{
   indexes: SqliteDsl.Index[]
@@ -114,7 +103,7 @@ export type TableOptions = {
  * })
  *
  * // Option 2: With name from schema annotation (title or identifier)
- * const AnnotatedUserSchema = UserSchema.annotations({ title: 'users' })
+ * const AnnotatedUserSchema = UserSchema.annotate({ title: 'users' })
  * const usersTable2 = State.SQLite.table({
  *   schema: AnnotatedUserSchema,
  * })
@@ -127,7 +116,7 @@ export type TableOptions = {
  *   title: Schema.String,
  *   authorId: Schema.String,
  *   createdAt: Schema.Date,
- * }).annotations({ identifier: 'posts' })
+ * }).annotate({ identifier: 'posts' })
  *
  * const postsTable = State.SQLite.table({
  *   schema: PostSchema,
@@ -161,30 +150,21 @@ export function table<
 // Overload 2: With schema and explicit name
 export function table<
   TName extends string,
-  TSchema extends Schema.Schema.AnyNoContext,
+  TSchema extends Schema.Top,
   const TOptionsInput extends TableOptionsInput = TableOptionsInput,
 >(
   args: {
     name: TName
     schema: TSchema
   } & Partial<TOptionsInput>,
-): TableDef<
-  SqliteTableDefForSchemaInput<TName, Schema.Schema.Type<TSchema>, Schema.Schema.Encoded<TSchema>, TSchema>,
-  TableOptions
->
+): TableDef<SqliteTableDefForSchemaInput<TName, TSchema['Type'], TSchema['Encoded'], TSchema>>
 
 // Overload 3: With schema and no name (uses schema annotations)
-export function table<
-  TSchema extends Schema.Schema.AnyNoContext,
-  const TOptionsInput extends TableOptionsInput = TableOptionsInput,
->(
+export function table<TSchema extends Schema.Top, const TOptionsInput extends TableOptionsInput = TableOptionsInput>(
   args: {
     schema: TSchema
   } & Partial<TOptionsInput>,
-): TableDef<
-  SqliteTableDefForSchemaInput<string, Schema.Schema.Type<TSchema>, Schema.Schema.Encoded<TSchema>, TSchema>,
-  TableOptions
->
+): TableDef<SqliteTableDefForSchemaInput<string, TSchema['Type'], TSchema['Encoded'], TSchema>>
 
 // Implementation
 export function table<
@@ -199,10 +179,10 @@ export function table<
       }
     | {
         name: TName
-        schema: Schema.Schema.AnyNoContext
+        schema: Schema.Top
       }
     | {
-        schema: Schema.Schema.AnyNoContext
+        schema: Schema.Top
       }
   ) &
     Partial<TOptionsInput>,
@@ -216,12 +196,10 @@ export function table<
   if ('columns' in args) {
     tableName = args.name
     const columnOrColumns = args.columns
-    columns = (
-      SqliteDsl.isColumnDefinition(columnOrColumns) ? { value: columnOrColumns } : columnOrColumns
-    ) as SqliteDsl.Columns
+    columns = SqliteDsl.isColumnDefinition(columnOrColumns) === true ? { value: columnOrColumns } : columnOrColumns
     additionalIndexes = []
   } else if ('schema' in args) {
-    const result = schemaFieldsToColumns(Schema.getResolvedPropertySignatures(args.schema))
+    const result = args.schema.pipe(getSqlitePropertySignatures, schemaFieldsToColumns)
     columns = result.columns
 
     // We'll set tableName first, then use it for index names
@@ -232,14 +210,12 @@ export function table<
       tempTableName = args.name
     } else {
       // Use title or identifier, with preference for title
-      tempTableName = SchemaAST.getTitleAnnotation(args.schema.ast).pipe(
-        Option.orElse(() => SchemaAST.getIdentifierAnnotation(args.schema.ast)),
-        Option.getOrElse(() =>
-          shouldNeverHappen(
-            'When using schema without explicit name, the schema must have a title or identifier annotation',
-          ),
-        ),
-      )
+      tempTableName =
+        SchemaAST.resolveTitle(args.schema.ast) ??
+        SchemaAST.resolveIdentifier(args.schema.ast) ??
+        shouldNeverHappen(
+          'When using schema without explicit name, the schema must have a title or identifier annotation',
+        )
     }
 
     tableName = tempTableName
@@ -289,6 +265,74 @@ export function table<
   return tableDef as any
 }
 
+const getSqlitePropertySignatures = (schema: Schema.Top): ReadonlyArray<SchemaAST.PropertySignature> => {
+  const encodedPropertySignatures = getPropertySignatures(SchemaAST.toEncoded(schema.ast))
+  const typePropertySignatures = getPropertySignatures(SchemaAST.toType(schema.ast))
+
+  return encodedPropertySignatures.map((encodedPropertySignature) => {
+    const typePropertySignature = typePropertySignatures.find(
+      (propertySignature) => propertySignature.name === encodedPropertySignature.name,
+    )
+
+    if (typePropertySignature === undefined || hasLiveStoreSqliteAnnotation(encodedPropertySignature.type) === true) {
+      return encodedPropertySignature
+    }
+
+    return new SchemaAST.PropertySignature(encodedPropertySignature.name, typePropertySignature.type)
+  })
+}
+
+const getPropertySignatures = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.PropertySignature> => {
+  if (SchemaAST.isObjects(ast) === true) return ast.propertySignatures
+
+  if (SchemaAST.isUnion(ast) === true) {
+    const members = ast.types.map(getPropertySignatures)
+    const [head, ...tail] = members
+    if (head === undefined) return []
+
+    return head.flatMap((propertySignature) => {
+      const matchingPropertySignatures: Array<SchemaAST.PropertySignature> = []
+      for (const propertySignatures of tail) {
+        const matchingPropertySignature = propertySignatures.find(
+          (memberPropertySignature) => memberPropertySignature.name === propertySignature.name,
+        )
+        if (matchingPropertySignature === undefined) {
+          return []
+        }
+        matchingPropertySignatures.push(matchingPropertySignature)
+      }
+
+      const propertySignatures = [propertySignature, ...matchingPropertySignatures]
+      /**
+       * `SchemaAST.optionalKey` became internal in Effect rc.109, so the optional-key marker is
+       * applied by constructing the union with an optional `Context`. Equivalent here because the
+       * union is freshly built and therefore carries no encoding chain to propagate the marker to.
+       */
+      const hasOptionalMember =
+        propertySignatures.some((memberPropertySignature) => SchemaAST.isOptional(memberPropertySignature.type)) ===
+        true
+      const keyContext = hasOptionalMember === true ? new SchemaAST.Context(true, false) : undefined
+      const union = new SchemaAST.Union(
+        propertySignatures.map((memberPropertySignature) => memberPropertySignature.type),
+        ast.mode,
+        undefined,
+        undefined,
+        undefined,
+        keyContext,
+      )
+
+      return [new SchemaAST.PropertySignature(propertySignature.name, union)]
+    })
+  }
+
+  return []
+}
+
+const hasLiveStoreSqliteAnnotation = (ast: SchemaAST.AST): boolean => {
+  const annotationKeys = [...Object.keys(ast.annotations ?? {}), ...Object.keys(ast.context?.annotations ?? {})]
+  return annotationKeys.some((key) => key.startsWith('livestore/state/sqlite/annotations/'))
+}
+
 export namespace FromTable {
   // TODO this sometimes doesn't preserve the order of columns
   export type RowDecoded<TTableDef extends TableDefBase> = Types.Simplify<
@@ -305,9 +349,7 @@ export namespace FromTable {
   }
 
   export type RowEncodeNonNullable<TTableDef extends TableDefBase> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.Encoded<
-      TTableDef['sqliteDef']['columns'][K]['schema']
-    >
+    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['schema']['Encoded']
   }
 
   export type RowEncoded<TTableDef extends TableDefBase> = Types.Simplify<
@@ -316,7 +358,7 @@ export namespace FromTable {
   >
 
   export type RowDecodedAll<TTableDef extends TableDefBase> = {
-    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.Type<TTableDef['sqliteDef']['columns'][K]['schema']>
+    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['schema']['Type']
   }
 }
 
@@ -328,7 +370,7 @@ export namespace FromColumns {
   >
 
   export type RowDecodedAll<TColumns extends SqliteDsl.Columns> = {
-    [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>
+    [K in keyof TColumns]: TColumns[K]['schema']['Type']
   }
 
   export type RowEncoded<TColumns extends SqliteDsl.Columns> = Types.Simplify<
@@ -337,7 +379,7 @@ export namespace FromColumns {
   >
 
   export type RowEncodeNonNullable<TColumns extends SqliteDsl.Columns> = {
-    [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
+    [K in keyof TColumns]: TColumns[K]['schema']['Encoded']
   }
 
   export type NullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
@@ -377,18 +419,21 @@ export type ToColumns<TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefin
       : never
 
 export declare namespace SchemaToColumns {
+  /** Checks if `null` or `undefined` is assignable to `T`, matching the runtime nullable detection. */
+  type IsNullable<T> = null extends T ? true : undefined extends T ? true : false
+
   // Type helper to create column definition with proper schema
-  export type ColumnDefForType<TEncoded, TType> = SqliteDsl.ColumnDefinition<TEncoded, TType>
-
-  // Create columns type from schema Type and Encoded
-  export type FromTypes<TType, TEncoded> = TEncoded extends Record<string, any>
-    ? {
-        [K in keyof TEncoded]-?: ColumnDefForType<
-          TEncoded[K],
-          TType extends Record<string, any> ? (K extends keyof TType ? TType[K] : TEncoded[K]) : TEncoded[K]
-        >
-      }
-    : SqliteDsl.Columns
+  export type ColumnDefForType<TEncoded, TType> = SqliteDsl.ColumnDefinition<TEncoded, TType, IsNullable<TEncoded>>
+
+  export type FromTypes<TType, TEncoded> =
+    TEncoded extends Record<string, any>
+      ? {
+          [K in keyof TEncoded]-?: ColumnDefForType<
+            TEncoded[K],
+            TType extends Record<string, any> ? (K extends keyof TType ? TType[K] : TEncoded[K]) : TEncoded[K]
+          >
+        }
+      : SqliteDsl.Columns
 }
 
 export declare namespace TableDefInput {

package/src/schema/unknown-events.ts

@@ -0,0 +1,132 @@
+import { Effect } from '@livestore/utils/effect'
+
+import { UnknownEventError } from '../errors.ts'
+import type { EventDef, Materializer } from './EventDef/mod.ts'
+import type * as LiveStoreEvent from './LiveStoreEvent/mod.ts'
+import type { LiveStoreSchema } from './schema.ts'
+
+export type UnknownEventContext = {
+  readonly event: Pick<LiveStoreEvent.Client.Encoded, 'name' | 'args' | 'seqNum' | 'clientId' | 'sessionId'>
+  readonly reason: 'event-definition-missing' | 'materializer-missing'
+  readonly operation: string
+}
+
+export namespace UnknownEvents {
+  export type HandlingStrategy = 'warn' | 'fail' | 'ignore' | 'callback'
+
+  export type Callback = (
+    context: UnknownEventContext,
+    error: UnknownEventError,
+  ) => Effect.SyncOrPromiseOrEffect<void, unknown>
+
+  export type HandlingConfig =
+    | { readonly strategy: 'warn' }
+    | { readonly strategy: 'ignore' }
+    | { readonly strategy: 'fail' }
+    | { readonly strategy: 'callback'; readonly onUnknownEvent: Callback }
+
+  export type Reason = UnknownEventContext['reason']
+
+  export type ResolveContext = Omit<UnknownEventContext, 'reason'>
+
+  export type Resolved =
+    | {
+        readonly _tag: 'known'
+        readonly eventDef: EventDef.AnyWithoutFn
+        readonly materializer: Materializer
+      }
+    | {
+        readonly _tag: 'unknown'
+        readonly reason: Reason
+      }
+}
+
+const DEFAULT_UNKNOWN_EVENT_HANDLING: UnknownEvents.HandlingConfig = { strategy: 'warn' }
+
+export const normalizeUnknownEventHandling = (
+  input: UnknownEvents.HandlingConfig | undefined,
+): UnknownEvents.HandlingConfig => input ?? DEFAULT_UNKNOWN_EVENT_HANDLING
+
+const handleUnknownEvent = ({
+  schema,
+  context,
+}: {
+  schema: LiveStoreSchema
+  context: UnknownEventContext
+}): Effect.Effect<void, UnknownEventError> =>
+  Effect.gen(function* () {
+    const config = schema.unknownEventHandling
+    const error = new UnknownEventError(context)
+
+    switch (config.strategy) {
+      case 'fail': {
+        return yield* error
+      }
+      case 'warn': {
+        yield* Effect.logWarning('@livestore/common:schema:unknown-event', context)
+        return
+      }
+      case 'ignore': {
+        return
+      }
+      case 'callback': {
+        const callback = config.onUnknownEvent
+
+        // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- user callback errors are immediately handled and logged below
+        yield* Effect.trySyncOrPromiseOrEffect(() => callback(context, error)).pipe(
+          Effect.catch((cause) =>
+            Effect.logWarning('@livestore/common:schema:unknown-event:callback-error', {
+              event: context.event,
+              reason: context.reason,
+              operation: context.operation,
+              cause,
+            }),
+          ),
+        )
+        return
+      }
+    }
+  })
+
+/**
+ * Resolves the runtime event definition + materializer for a given event name.
+ *
+ * Behaviour is intentionally split across the result and error channels:
+ * - For `'fail'` handling, we surface an `UnknownEventError` via the failure channel so
+ *   callers can convert it into the appropriate domain error (for example `MaterializeError`).
+ * - For all other strategies (`warn`, `ignore`, `callback`) we succeed with an
+ *   `{ _tag: 'unknown' }` value, signalling that the caller should skip the event while
+ *   continuing normal processing.
+ */
+export const resolveEventDef = (
+  schema: LiveStoreSchema,
+  context: UnknownEvents.ResolveContext,
+): Effect.Effect<UnknownEvents.Resolved, UnknownEventError> =>
+  Effect.gen(function* () {
+    const eventName = context.event.name
+    const eventDef = schema.eventsDefsMap.get(eventName)
+    if (eventDef === undefined) {
+      yield* handleUnknownEvent({
+        schema,
+        context: {
+          event: context.event,
+          reason: 'event-definition-missing',
+          operation: context.operation,
+        },
+      })
+      return { _tag: 'unknown', reason: 'event-definition-missing' }
+    }
+    const materializer = schema.state.materializers.get(eventName)
+    if (materializer === undefined) {
+      yield* handleUnknownEvent({
+        schema,
+        context: {
+          event: context.event,
+          reason: 'materializer-missing',
+          operation: context.operation,
+        },
+      })
+      return { _tag: 'unknown', reason: 'materializer-missing' }
+    }
+    return { _tag: 'known', eventDef, materializer }
+  })

package/src/schema-management/__tests__/migrations-autoincrement-quoting.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest'
+
+import { Effect, Option, Schema } from '@livestore/utils/effect'
+
+import { SqliteAst } from '../../schema/state/sqlite/db-schema/mod.ts'
+import type { PreparedStatement, SqliteDb } from '../../sqlite-types.ts'
+import type { PreparedBindValues } from '../../util.ts'
+import { migrateTable } from '../migrations.ts'
+
+const makeStubDb = () => {
+  const executed: string[] = []
+
+  const db: SqliteDb = {
+    _tag: 'SqliteDb',
+    metadata: { dbPointer: 0, persistenceInfo: { fileName: ':memory:' } } as any,
+    debug: { head: 0 as any },
+    prepare: (queryStr: string): PreparedStatement => ({
+      sql: queryStr,
+      execute: (_bind: PreparedBindValues | undefined) => {
+        executed.push(queryStr)
+      },
+      select: <T>(_bind: PreparedBindValues | undefined) => [] as unknown as ReadonlyArray<T>,
+      finalize: () => {},
+    }),
+    execute: () => {},
+    select: () => [],
+    export: () => new Uint8Array(),
+    import: () => {},
+    close: () => {},
+    destroy: () => {},
+    session: () => ({ changeset: () => undefined, finish: () => {} }),
+    makeChangeset: () => ({ invert: () => ({ invert: () => ({}) as any, apply: () => {} }) as any, apply: () => {} }),
+  }
+
+  return { db, executed }
+}
+
+describe('migrateTable - quoting and autoincrement', () => {
+  it('creates valid CREATE TABLE with inline INTEGER PRIMARY KEY AUTOINCREMENT and double-quoted identifiers', () => {
+    const { db, executed } = makeStubDb()
+
+    const table = SqliteAst.table(
+      'todos',
+      [
+        SqliteAst.column({
+          name: 'id',
+          type: { _tag: 'integer' },
+          nullable: false,
+          primaryKey: true,
+          autoIncrement: true,
+          default: Option.none(),
+          schema: Schema.Finite,
+        }),
+        SqliteAst.column({
+          name: 'text',
+          type: { _tag: 'text' },
+          nullable: false,
+          primaryKey: false,
+          autoIncrement: false,
+          default: Option.some(''),
+          schema: Schema.String,
+        }),
+        SqliteAst.column({
+          name: 'completed',
+          type: { _tag: 'integer' },
+          nullable: false,
+          primaryKey: false,
+          autoIncrement: false,
+          default: Option.some(0),
+          schema: Schema.Finite,
+        }),
+      ],
+      [],
+    )
+
+    migrateTable({ db, tableAst: table, behaviour: 'create-if-not-exists', skipMetaTable: true }).pipe(Effect.runSync)
+
+    const createStmt = executed.find((s) => /create table if not exists/i.test(s))
+    expect(createStmt).toBeDefined()
+
+    // Identifiers must be double-quoted, not single-quoted
+    expect(createStmt!).toContain('create table if not exists "todos"')
+    expect(createStmt!).toContain('"id" integer primary key autoincrement')
+    expect(createStmt!).toContain(" default ''")
+    expect(createStmt!).not.toContain("PRIMARY KEY ('id')")
+    expect(createStmt!).not.toMatch(/'todos'|'id'|'text'/)
+  })
+})

package/src/schema-management/common.ts

@@ -13,7 +13,7 @@ export const dbExecute = (db: SqliteDb, queryStr: string, bindValues?: ParamsObj
   // cachedStmts.set(queryStr, stmt)
   // }
 
-  const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
+  const preparedBindValues = bindValues !== undefined ? prepareBindValues(bindValues, queryStr) : undefined
 
   try {
     stmt.execute(preparedBindValues)
@@ -34,7 +34,7 @@ export const dbSelect = <T>(db: SqliteDb, queryStr: string, bindValues?: ParamsO
   // cachedStmts.set(queryStr, stmt)
   // }
 
-  const res = stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
+  const res = stmt.select<T>(bindValues !== undefined ? prepareBindValues(bindValues, queryStr) : undefined)
   stmt.finalize()
   return res
 }

package/src/schema-management/migrations.ts

@@ -1,20 +1,51 @@
+/**
+ * AUTOMATIC HASH-BASED SCHEMA MIGRATIONS
+ *
+ * This module implements automatic schema versioning using hash-based change detection.
+ *
+ * ⚠️  CRITICAL DISTINCTION:
+ * - STATE TABLES (safe to modify): Changes trigger rematerialization from eventlog
+ * - EVENTLOG TABLES (NEVER modify): Changes cause data loss - need manual versioning!
+ *
+ * How it works:
+ * 1. Each table's schema is hashed using SqliteAst.hash()
+ * 2. Hashes are stored in SCHEMA_META_TABLE after successful migrations
+ * 3. On app start, current schema hashes are compared with stored hashes
+ * 4. Mismatches trigger migrations:
+ *    - State tables: Recreated and repopulated from eventlog (safe, no data loss)
+ *    - Eventlog tables: Uses 'create-if-not-exists' (UNSAFE - causes data loss!)
+ *
+ * State Table Changes (SAFE):
+ * - User-defined tables are rebuilt from eventlog
+ * - System tables (schemaMetaTable, etc.) are recreated
+ * - Data preserved through rematerializeFromEventlog()
+ *
+ * Eventlog Table Changes (UNSAFE):
+ * - eventlogMetaTable, syncStatusTable changes cause "soft reset"
+ * - Old table becomes inaccessible (but remains in DB)
+ * - No automatic migration - effectively data loss
+ * - TODO: Implement proper EVENTLOG_PERSISTENCE_FORMAT_VERSION system
+ *
+ * See system-tables/state-tables.ts and system-tables/eventlog-tables.ts for detailed documentation on each table type.
+ */
+
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect } from '@livestore/utils/effect'
 
 import type { SqliteDb } from '../adapter-types.ts'
 import type { MigrationsReport, MigrationsReportEntry } from '../defs.ts'
-import type { UnexpectedError } from '../errors.ts'
+import type { UnknownError } from '../errors.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import { makeColumnSpec } from '../schema/state/sqlite/column-spec.ts'
 import { SqliteAst } from '../schema/state/sqlite/db-schema/mod.ts'
-import type { SchemaEventDefsMetaRow, SchemaMetaRow } from '../schema/state/sqlite/system-tables.ts'
+import type { SchemaEventDefsMetaRow, SchemaMetaRow } from '../schema/state/sqlite/system-tables/state-tables.ts'
 import {
   isStateSystemTable,
   SCHEMA_EVENT_DEFS_META_TABLE,
   SCHEMA_META_TABLE,
   schemaEventDefsMetaTable,
   stateSystemTables,
-} from '../schema/state/sqlite/system-tables.ts'
+} from '../schema/state/sqlite/system-tables/state-tables.ts'
 import { sql } from '../util.ts'
 import type { SchemaManager } from './common.ts'
 import { dbExecute, dbSelect } from './common.ts'
@@ -56,7 +87,7 @@ export const migrateDb = ({
   db: SqliteDb
   schema: LiveStoreSchema
   onProgress?: (opts: { done: number; total: number }) => Effect.Effect<void>
-}): Effect.Effect<MigrationsReport, UnexpectedError> =>
+}): Effect.Effect<MigrationsReport, UnknownError> =>
   Effect.gen(function* () {
     for (const tableDef of stateSystemTables) {
       yield* migrateTable({
@@ -137,10 +168,10 @@ export const migrateTable = ({
 
     if (behaviour === 'drop-and-recreate') {
       // TODO need to possibly handle cascading deletes due to foreign keys
-      dbExecute(db, sql`drop table if exists '${tableName}'`)
-      dbExecute(db, sql`create table if not exists '${tableName}' (${columnSpec}) strict`)
+      dbExecute(db, sql`drop table if exists "${tableName}"`)
+      dbExecute(db, sql`create table if not exists "${tableName}" (${columnSpec}) strict`)
     } else if (behaviour === 'create-if-not-exists') {
-      dbExecute(db, sql`create table if not exists '${tableName}' (${columnSpec}) strict`)
+      dbExecute(db, sql`create table if not exists "${tableName}" (${columnSpec}) strict`)
     }
 
     for (const index of tableAst.indexes) {
@@ -169,6 +200,8 @@ export const migrateTable = ({
   )
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
-  const uniqueStr = index.unique ? 'UNIQUE' : ''
-  return sql`create ${uniqueStr} index if not exists '${index.name}' on '${tableName}' (${index.columns.map((col) => `'${col}'`).join(', ')})`
+  const uniqueStr = index.unique === true ? 'UNIQUE' : ''
+  return sql`create ${uniqueStr} index if not exists "${index.name}" on "${tableName}" (${index.columns
+    .map((col) => `"${col}"`)
+    .join(', ')})`
 }

package/src/schema-management/validate-schema.ts

@@ -1,7 +1,7 @@
 import { Effect, Schema } from '@livestore/utils/effect'
 
-import { UnexpectedError } from '../adapter-types.ts'
-import type { EventDef } from '../schema/EventDef.ts'
+import { UnknownError } from '../adapter-types.ts'
+import type { EventDef } from '../schema/EventDef/mod.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import type { EventDefInfo, SchemaManager } from './common.ts'
 
@@ -15,7 +15,7 @@ export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaMan
     )
 
     if (missingEventDefs.length > 0) {
-      return yield* new UnexpectedError({
+      return yield* new UnknownError({
         cause: `Missing mutation definitions: ${missingEventDefs.map((info) => info.eventName).join(', ')}`,
       })
     }