@livestore/common 0.4.0-dev.2 → 0.4.0-dev.20

package/src/schema/state/sqlite/query-builder/impl.ts

@@ -35,7 +35,6 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         select: { columns },
       }) as any
     },
-    // biome-ignore lint/complexity/useArrowFunction: prefer function over arrow function for this case
     where: function () {
       if (ast._tag === 'InsertQuery') return invalidQueryBuilder('Cannot use where with insert')
       if (ast._tag === 'RowQuery') return invalidQueryBuilder('Cannot use where with row')
@@ -219,21 +218,27 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
     update: (values) => {
       const filteredValues = Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined))
 
+      // Preserve where clauses if coming from a SelectQuery
+      const whereClause = ast._tag === 'SelectQuery' ? ast.where : []
+
       return makeQueryBuilder(tableDef, {
         _tag: 'UpdateQuery',
         tableDef,
         values: filteredValues,
-        where: [],
+        where: whereClause,
         returning: undefined,
         resultSchema: Schema.Void,
       }) as any
     },
 
     delete: () => {
+      // Preserve where clauses if coming from a SelectQuery
+      const whereClause = ast._tag === 'SelectQuery' ? ast.where : []
+
       return makeQueryBuilder(tableDef, {
         _tag: 'DeleteQuery',
         tableDef,
-        where: [],
+        where: whereClause,
         returning: undefined,
         resultSchema: Schema.Void,
       }) as any

package/src/schema/state/sqlite/schema-helpers.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+
+import * as State from '../mod.ts'
+import { getDefaultValuesDecoded, getDefaultValuesEncoded } from './schema-helpers.ts'
+
+describe('schema-helpers', () => {
+  it('resolves thunk defaults when decoding values', () => {
+    let counter = 0
+    const table = State.SQLite.table({
+      name: 'sessions',
+      columns: {
+        id: State.SQLite.text({ primaryKey: true }),
+        token: State.SQLite.text({ default: () => `token-${++counter}` }),
+      },
+    })
+
+    expect(counter).toBe(0)
+
+    const firstDefaults = getDefaultValuesDecoded(table)
+    const secondDefaults = getDefaultValuesDecoded(table)
+
+    expect(firstDefaults.token).toBe('token-1')
+    expect(secondDefaults.token).toBe('token-2')
+  })
+
+  it('resolves thunk defaults when encoding values', () => {
+    let counter = 0
+    const table = State.SQLite.table({
+      name: 'sessions_encoded',
+      columns: {
+        id: State.SQLite.text({ primaryKey: true }),
+        token: State.SQLite.text({ default: () => `encoded-${++counter}` }),
+      },
+    })
+
+    expect(counter).toBe(0)
+
+    const firstDefaults = getDefaultValuesEncoded(table)
+    const secondDefaults = getDefaultValuesEncoded(table)
+
+    expect(firstDefaults.token).toBe('encoded-1')
+    expect(secondDefaults.token).toBe('encoded-2')
+  })
+})

package/src/schema/state/sqlite/schema-helpers.ts

@@ -2,9 +2,9 @@ import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 
 import { SqliteDsl } from './db-schema/mod.ts'
-import type { TableDef, TableDefBase } from './table-def.ts'
+import type { TableDefBase } from './table-def.ts'
 
-export const getDefaultValuesEncoded = <TTableDef extends TableDef>(
+export const getDefaultValuesEncoded = <TTableDef extends TableDefBase>(
   tableDef: TTableDef,
   fallbackValues?: Record<string, any>,
 ) =>
@@ -15,15 +15,19 @@ export const getDefaultValuesEncoded = <TTableDef extends TableDef>(
       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],
-    ),
+    ReadonlyRecord.map((column, columnName) => {
+      if (fallbackValues?.[columnName] !== undefined) return fallbackValues[columnName]
+      if (column!.default._tag === 'None') {
+        return column!.nullable === true
+          ? null
+          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+      }
+
+      const defaultValue = column!.default.value
+      const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
+
+      return Schema.encodeSync(column!.schema)(resolvedDefault)
+    }),
   )
 
 export const getDefaultValuesDecoded = <TTableDef extends TableDefBase>(
@@ -37,13 +41,17 @@ export const getDefaultValuesDecoded = <TTableDef extends TableDefBase>(
       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.validateSync(column!.schema)(column!.default.value)
-        : fallbackValues[columnName],
-    ),
+    ReadonlyRecord.map((column, columnName) => {
+      if (fallbackValues?.[columnName] !== undefined) return fallbackValues[columnName]
+      if (column!.default._tag === 'None') {
+        return column!.nullable === true
+          ? null
+          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+      }
+
+      const defaultValue = column!.default.value
+      const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
+
+      return Schema.validateSync(column!.schema)(resolvedDefault)
+    }),
   )

package/src/schema/state/sqlite/system-tables/eventlog-tables.ts

@@ -0,0 +1,64 @@
+import { Schema } from '@livestore/utils/effect'
+
+import * as EventSequenceNumber from '../../../EventSequenceNumber/mod.ts'
+import { SqliteDsl } from '../db-schema/mod.ts'
+import { table } from '../table-def.ts'
+
+/**
+ * EVENTLOG DATABASE SYSTEM TABLES
+ *
+ * ⚠️  CRITICAL: NEVER modify eventlog schemas without bumping `liveStoreStorageFormatVersion`!
+ * Eventlog is the source of truth - schema changes cause permanent data loss.
+ *
+ * TODO: Implement proper eventlog versioning system to prevent accidental data loss
+ */
+
+export const EVENTLOG_META_TABLE = 'eventlog'
+
+/**
+ * Main client-side event log storing all events (global and local/rebased).
+ */
+export const eventlogMetaTable = table({
+  name: EVENTLOG_META_TABLE,
+  columns: {
+    // TODO Adjust modeling so a global event never needs a client id component
+    seqNumGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.Global.Schema }),
+    seqNumClient: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.Client.Schema }),
+    seqNumRebaseGeneration: SqliteDsl.integer({ primaryKey: true }),
+    parentSeqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.Global.Schema }),
+    parentSeqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.Client.Schema }),
+    parentSeqNumRebaseGeneration: SqliteDsl.integer({}),
+    /** Event definition name */
+    name: SqliteDsl.text({}),
+    argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
+    clientId: SqliteDsl.text({}),
+    sessionId: SqliteDsl.text({}),
+    schemaHash: SqliteDsl.integer({}),
+    syncMetadataJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Option(Schema.JsonValue)) }),
+  },
+  indexes: [
+    { columns: ['seqNumGlobal'], name: 'idx_eventlog_seqNumGlobal' },
+    { columns: ['seqNumGlobal', 'seqNumClient', 'seqNumRebaseGeneration'], name: 'idx_eventlog_seqNum' },
+  ],
+})
+
+export type EventlogMetaRow = typeof eventlogMetaTable.Type
+
+export const SYNC_STATUS_TABLE = '__livestore_sync_status'
+
+/**
+ * Tracks sync status including the remote head position and backend identity.
+ */
+// TODO support sync backend identity (to detect if sync backend changes)
+export const syncStatusTable = table({
+  name: SYNC_STATUS_TABLE,
+  columns: {
+    head: SqliteDsl.integer({ primaryKey: true }),
+    // Null means the sync backend is not yet connected and we haven't yet seen a backend ID
+    backendId: SqliteDsl.text({ nullable: true }),
+  },
+})
+
+export type SyncStatusRow = typeof syncStatusTable.Type
+
+export const eventlogSystemTables = [eventlogMetaTable, syncStatusTable] as const

package/src/schema/state/sqlite/system-tables/mod.ts

@@ -0,0 +1,2 @@
+export * from './eventlog-tables.ts'
+export * from './state-tables.ts'

package/src/schema/state/sqlite/system-tables/state-tables.ts

@@ -0,0 +1,69 @@
+import * as EventSequenceNumber from '../../../EventSequenceNumber/mod.ts'
+import { SqliteDsl } from '../db-schema/mod.ts'
+import { table } from '../table-def.ts'
+
+/**
+ * STATE DATABASE SYSTEM TABLES
+ *
+ * ⚠️  SAFE TO CHANGE: State tables are automatically rebuilt from eventlog when schema changes.
+ * No need to bump `liveStoreStorageFormatVersion` (uses hash-based migration via SqliteAst.hash()).
+ */
+
+export const SCHEMA_META_TABLE = '__livestore_schema'
+
+/**
+ * Tracks schema hashes for user-defined tables to detect schema changes.
+ */
+export const schemaMetaTable = table({
+  name: SCHEMA_META_TABLE,
+  columns: {
+    tableName: SqliteDsl.text({ primaryKey: true }),
+    schemaHash: SqliteDsl.integer({ nullable: false }),
+    /** ISO date format */
+    updatedAt: SqliteDsl.text({ nullable: false }),
+  },
+})
+
+export type SchemaMetaRow = typeof schemaMetaTable.Type
+
+export const SCHEMA_EVENT_DEFS_META_TABLE = '__livestore_schema_event_defs'
+
+/**
+ * Tracks schema hashes for event definitions to detect event schema changes.
+ */
+export const schemaEventDefsMetaTable = table({
+  name: SCHEMA_EVENT_DEFS_META_TABLE,
+  columns: {
+    eventName: SqliteDsl.text({ primaryKey: true }),
+    schemaHash: SqliteDsl.integer({ nullable: false }),
+    /** ISO date format */
+    updatedAt: SqliteDsl.text({ nullable: false }),
+  },
+})
+
+export type SchemaEventDefsMetaRow = typeof schemaEventDefsMetaTable.Type
+
+/**
+ * Table which stores SQLite changeset blobs which is used for rolling back
+ * read-model state during rebasing.
+ */
+export const SESSION_CHANGESET_META_TABLE = '__livestore_session_changeset'
+
+export const sessionChangesetMetaTable = table({
+  name: SESSION_CHANGESET_META_TABLE,
+  columns: {
+    // TODO bring back primary key
+    seqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.Global.Schema }),
+    seqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.Client.Schema }),
+    seqNumRebaseGeneration: SqliteDsl.integer({}),
+    changeset: SqliteDsl.blob({ nullable: true }),
+    debug: SqliteDsl.json({ nullable: true }),
+  },
+  indexes: [{ columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_session_changeset_id' }],
+})
+
+export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
+
+export const stateSystemTables = [schemaMetaTable, schemaEventDefsMetaTable, sessionChangesetMetaTable] as const
+
+export const isStateSystemTable = (tableName: string) => stateSystemTables.some((_) => _.sqliteDef.name === tableName)

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

@@ -178,6 +178,59 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.age.columnType).toBe('integer')
   })
 
+  it('should support schemas that transform flat columns into nested types', () => {
+    const Flat = Schema.Struct({
+      id: Schema.String.pipe(State.SQLite.withPrimaryKey),
+      contactFirstName: Schema.String,
+      contactLastName: Schema.String,
+      contactEmail: Schema.String.pipe(State.SQLite.withUnique),
+    })
+
+    const Nested = Schema.transform(
+      Flat,
+      Schema.Struct({
+        id: Schema.String,
+        contact: Schema.Struct({
+          firstName: Schema.String,
+          lastName: Schema.String,
+          email: Schema.String,
+        }),
+      }),
+      {
+        decode: ({ id, contactFirstName, contactLastName, contactEmail }) => ({
+          id,
+          contact: {
+            firstName: contactFirstName,
+            lastName: contactLastName,
+            email: contactEmail,
+          },
+        }),
+        encode: ({ id, contact }) => ({
+          id,
+          contactFirstName: contact.firstName,
+          contactLastName: contact.lastName,
+          contactEmail: contact.email,
+        }),
+      },
+    )
+
+    const contactsTable = State.SQLite.table({
+      name: 'contacts',
+      schema: Nested,
+    })
+
+    const columns = contactsTable.sqliteDef.columns
+
+    expect(Object.keys(columns)).toEqual(['id', 'contactFirstName', 'contactLastName', 'contactEmail'])
+    expect(columns.id.primaryKey).toBe(true)
+    expect(columns.contactEmail.columnType).toBe('text')
+    expect(contactsTable.sqliteDef.indexes).toContainEqual({
+      name: 'idx_contacts_contactEmail_unique',
+      columns: ['contactEmail'],
+      isUnique: true,
+    })
+  })
+
   it('should extract table name from Schema.Class identifier', () => {
     class TodoItem extends Schema.Class<TodoItem>('TodoItem')({
       id: Schema.String,
@@ -247,4 +300,52 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.metadata.columnType).toBe('text')
     expect(userTable.sqliteDef.columns.metadata.nullable).toBe(true)
   })
+
+  it('supports discriminated unions with parsed JSON payloads', () => {
+    const CircleDataSchema = Schema.Struct({
+      radius: Schema.Number,
+    })
+    const CircleSchema = Schema.Struct({
+      kind: Schema.Literal('circle'),
+      data: Schema.parseJson(CircleDataSchema),
+    })
+
+    const SquareDataSchema = Schema.Struct({
+      sideLength: Schema.Number,
+    })
+    const SquareSchema = Schema.Struct({
+      kind: Schema.Literal('square'),
+      data: Schema.parseJson(SquareDataSchema),
+    })
+
+    const ShapeSchema = Schema.Union(CircleSchema, SquareSchema)
+
+    const shapes = State.SQLite.table({
+      name: 'shapes',
+      schema: ShapeSchema,
+    })
+
+    expect(shapes.sqliteDef.columns.kind.columnType).toBe('text')
+
+    const kindSchema = shapes.sqliteDef.columns.kind.schema.toString()
+    expect(kindSchema).toContain('"circle" | "square"')
+
+    expect(() =>
+      shapes
+        .insert({
+          kind: 'square',
+          data: { sideLength: 10 },
+        })
+        .asSql(),
+    ).not.toThrow()
+
+    expect(() =>
+      shapes
+        .insert({
+          kind: 'circle',
+          data: { radius: 5 },
+        })
+        .asSql(),
+    ).not.toThrow()
+  })
 })

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

@@ -1,5 +1,5 @@
 import { type Nullable, shouldNeverHappen } from '@livestore/utils'
-import { Option, type Schema, SchemaAST, type Types } from '@livestore/utils/effect'
+import { Option, Schema, SchemaAST, type Types } from '@livestore/utils/effect'
 
 import { getColumnDefForSchema, schemaFieldsToColumns } from './column-def.ts'
 import { SqliteDsl } from './db-schema/mod.ts'
@@ -221,7 +221,7 @@ export function table<
     ) as SqliteDsl.Columns
     additionalIndexes = []
   } else if ('schema' in args) {
-    const result = schemaFieldsToColumns(SchemaAST.getPropertySignatures(args.schema.ast))
+    const result = schemaFieldsToColumns(Schema.getResolvedPropertySignatures(args.schema))
     columns = result.columns
 
     // We'll set tableName first, then use it for index names
@@ -381,12 +381,13 @@ export declare namespace SchemaToColumns {
   export type ColumnDefForType<TEncoded, TType> = SqliteDsl.ColumnDefinition<TEncoded, TType>
 
   // Create columns type from schema Type and Encoded
-  export type FromTypes<TType, TEncoded> = TType extends Record<string, any>
-    ? TEncoded extends Record<string, any>
-      ? {
-          [K in keyof TType & keyof TEncoded]: ColumnDefForType<TEncoded[K], TType[K]>
-        }
-      : SqliteDsl.Columns
+  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
 }
 

package/src/schema/unknown-events.ts

@@ -0,0 +1,131 @@
+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, never>
+
+  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* Effect.fail(error)
+      }
+      case 'warn': {
+        yield* Effect.logWarning('@livestore/common:schema:unknown-event', context)
+        return
+      }
+      case 'ignore': {
+        return
+      }
+      case 'callback': {
+        const callback = config.onUnknownEvent
+
+        yield* Effect.tryAll<void>(() => callback(context, error)).pipe(
+          Effect.catchAll((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,86 @@
+import { Effect, Option, Schema } from '@livestore/utils/effect'
+import { describe, expect, it } from 'vitest'
+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.Number,
+        }),
+        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.Number,
+        }),
+      ],
+      [],
+    )
+
+    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'/)
+  })
+})