@livestore/common 0.4.0-dev.14 → 0.4.0-dev.15

package/src/leader-thread/make-leader-thread-layer.ts

@@ -1,5 +1,5 @@
 import { omitUndefineds, shouldNeverHappen } from '@livestore/utils'
-import type { HttpClient, Schema, Scope } from '@livestore/utils/effect'
+import type { HttpClient, Scope } from '@livestore/utils/effect'
 import {
   Deferred,
   Effect,
@@ -7,6 +7,7 @@ import {
   Layer,
   PlatformError,
   Queue,
+  Schema,
   Stream,
   Subscribable,
   SubscriptionRef,
@@ -44,7 +45,8 @@ import { LeaderThreadCtx } from './types.ts'
 
 export interface MakeLeaderThreadLayerParams {
   storeId: string
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadSchema: Schema.Schema<any> | undefined
+  syncPayloadEncoded: Schema.JsonValue | undefined
   clientId: string
   schema: LiveStoreSchema
   makeSqliteDb: MakeSqliteDb
@@ -70,7 +72,8 @@ export const makeLeaderThreadLayer = ({
   schema,
   storeId,
   clientId,
-  syncPayload,
+  syncPayloadSchema = Schema.JsonValue,
+  syncPayloadEncoded,
   makeSqliteDb,
   syncOptions,
   dbState,
@@ -81,6 +84,9 @@ export const makeLeaderThreadLayer = ({
   testing,
 }: MakeLeaderThreadLayerParams): Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient> =>
   Effect.gen(function* () {
+    const syncPayloadDecoded =
+      syncPayloadEncoded === undefined ? undefined : yield* Schema.decodeUnknown(syncPayloadSchema)(syncPayloadEncoded)
+
     const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
 
     const dbEventlogMissing = !hasEventlogTables(dbEventlog)
@@ -93,7 +99,7 @@ export const makeLeaderThreadLayer = ({
     const syncBackend =
       syncOptions?.backend === undefined
         ? undefined
-        : yield* syncOptions.backend({ storeId, clientId, payload: syncPayload }).pipe(
+        : yield* syncOptions.backend({ storeId, clientId, payload: syncPayloadDecoded }).pipe(
             Effect.provide(
               Layer.succeed(
                 KeyValueStore.KeyValueStore,

package/src/schema/state/sqlite/column-spec.test.ts

@@ -56,9 +56,9 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(`"'order' integer not null  , 'group' text   "`)
-    expect(result).toContain("'order'")
-    expect(result).toContain("'group'")
+    expect(result).toMatchInlineSnapshot(`""order" integer   not null , "group" text    "`)
+    expect(result).toContain('"order"')
+    expect(result).toContain('"group"')
   })
 
   it('should handle basic columns with primary keys', () => {
@@ -69,8 +69,7 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(`"'id' text not null  , 'name' text   , PRIMARY KEY ('id')"`)
-    expect(result).toContain("PRIMARY KEY ('id')")
+    expect(result).toMatchInlineSnapshot(`""id" text primary key   , "name" text    "`)
   })
 
   it('should handle multi-column primary keys', () => {
@@ -85,9 +84,9 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'tenant_id' text not null  , 'user_id' text not null  , PRIMARY KEY ('tenant_id', 'user_id')"`,
+      `""tenant_id" text   not null , "user_id" text   not null , PRIMARY KEY ("tenant_id", "user_id")"`,
     )
-    expect(result).toContain("PRIMARY KEY ('tenant_id', 'user_id')")
+    expect(result).toContain('PRIMARY KEY ("tenant_id", "user_id")')
   })
 
   it('should handle auto-increment columns', () => {
@@ -101,9 +100,9 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(`"'id' integer not null autoincrement , 'title' text   , PRIMARY KEY ('id')"`)
+    expect(result).toMatchInlineSnapshot(`""id" integer primary key autoincrement  , "title" text    "`)
     expect(result).toContain('autoincrement')
-    expect(result).toContain("PRIMARY KEY ('id')")
+    expect(result).not.toContain("PRIMARY KEY ('id')")
   })
 
   it('should handle columns with default values', () => {
@@ -121,7 +120,7 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null  , 'name' text not null  , 'price' real   default 0, 'active' integer   default true, 'description' text   default 'No description', PRIMARY KEY ('id')"`,
+      `""id" integer primary key   , "name" text   not null , "price" real    default 0, "active" integer    default true, "description" text    default 'No description'"`,
     )
     expect(result).toContain('default 0')
     expect(result).toContain('default true')
@@ -141,7 +140,7 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null  , 'created_at' text   default CURRENT_TIMESTAMP, 'random_value' real   default RANDOM(), PRIMARY KEY ('id')"`,
+      `""id" integer primary key   , "created_at" text    default CURRENT_TIMESTAMP, "random_value" real    default RANDOM()"`,
     )
     expect(result).toContain('default CURRENT_TIMESTAMP')
     expect(result).toContain('default RANDOM()')
@@ -158,9 +157,7 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null  , 'optional_text' text   default null, PRIMARY KEY ('id')"`,
-    )
+    expect(result).toMatchInlineSnapshot(`""id" integer primary key   , "optional_text" text    default null"`)
     expect(result).toContain('default null')
   })
 
@@ -190,7 +187,7 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null autoincrement , 'name' text not null  default 'Unnamed', 'created_at' text not null  default CURRENT_TIMESTAMP, 'status' text   default 'pending', PRIMARY KEY ('id')"`,
+      `""id" integer primary key autoincrement  , "name" text   not null default 'Unnamed', "created_at" text   not null default CURRENT_TIMESTAMP, "status" text    default 'pending'"`,
     )
   })
 
@@ -213,7 +210,7 @@ describe('makeColumnSpec', () => {
     const result = makeColumnSpec(table)
     // The makeColumnSpec function only generates column specifications, not indexes
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null autoincrement , 'email' text not null  , 'username' text not null  , 'created_at' text   default CURRENT_TIMESTAMP, PRIMARY KEY ('id')"`,
+      `""id" integer primary key autoincrement  , "email" text   not null , "username" text   not null , "created_at" text    default CURRENT_TIMESTAMP"`,
     )
     // Verify the table has the indexes (even though they're not in the column spec)
     expect(table.indexes).toHaveLength(3)

package/src/schema/state/sqlite/column-spec.ts

@@ -10,21 +10,40 @@ import { type SqliteAst, SqliteDsl } from './db-schema/mod.ts'
  * ```
  */
 export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
-  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => `'${_.name}'`)
-  const columnDefStrs = tableAst.columns.map(toSqliteColumnSpec)
-
-  if (primaryKeys.length > 0) {
-    columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
+  const pkColumns = tableAst.columns.filter((_) => _.primaryKey)
+  const hasSinglePk = pkColumns.length === 1
+  const pkColumn = hasSinglePk ? pkColumns[0] : undefined
+
+  // Build column definitions, handling the special SQLite rule that AUTOINCREMENT
+  // is only valid on a single column declared as INTEGER PRIMARY KEY (column-level).
+  const columnDefStrs = tableAst.columns.map((column) =>
+    toSqliteColumnSpec(column, {
+      inlinePrimaryKey: hasSinglePk && column === pkColumn && column.primaryKey === true,
+    }),
+  )
+
+  // For composite primary keys, add a table-level PRIMARY KEY clause.
+  if (pkColumns.length > 1) {
+    const quotedPkCols = pkColumns.map((_) => `"${_.name}"`)
+    columnDefStrs.push(`PRIMARY KEY (${quotedPkCols.join(', ')})`)
   }
 
   return columnDefStrs.join(', ')
 }
 
 /** NOTE primary keys are applied on a table level not on a column level to account for multi-column primary keys */
-const toSqliteColumnSpec = (column: SqliteAst.Column) => {
+const toSqliteColumnSpec = (column: SqliteAst.Column, opts: { inlinePrimaryKey: boolean }) => {
   const columnTypeStr = column.type._tag
-  const nullableStr = column.nullable === false ? 'not null' : ''
-  const autoIncrementStr = column.autoIncrement ? 'autoincrement' : ''
+  // When PRIMARY KEY is declared inline, NOT NULL is implied and should not be emitted,
+  // and AUTOINCREMENT must immediately follow PRIMARY KEY within the same constraint.
+  const nullableStr = opts.inlinePrimaryKey ? '' : column.nullable === false ? 'not null' : ''
+
+  // Only include AUTOINCREMENT when it's valid: single-column INTEGER PRIMARY KEY
+  const includeAutoIncrement = opts.inlinePrimaryKey && column.type._tag === 'integer' && column.autoIncrement === true
+
+  const pkStr = opts.inlinePrimaryKey ? 'primary key' : ''
+  const autoIncrementStr = includeAutoIncrement ? 'autoincrement' : ''
+
   const defaultValueStr = (() => {
     if (column.default._tag === 'None') return ''
 
@@ -38,5 +57,6 @@ const toSqliteColumnSpec = (column: SqliteAst.Column) => {
     return `default ${encodedDefaultValue}`
   })()
 
-  return `'${column.name}' ${columnTypeStr} ${nullableStr} ${autoIncrementStr} ${defaultValueStr}`
+  // Ensure order: PRIMARY KEY [AUTOINCREMENT] [NOT NULL] ...
+  return `"${column.name}" ${columnTypeStr} ${pkStr} ${autoIncrementStr} ${nullableStr} ${defaultValueStr}`
 }

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'/)
+  })
+})

package/src/schema-management/migrations.ts

@@ -168,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) {
@@ -201,5 +201,7 @@ 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(', ')})`
+  return sql`create ${uniqueStr} index if not exists "${index.name}" on "${tableName}" (${index.columns
+    .map((col) => `"${col}"`)
+    .join(', ')})`
 }

package/src/sync/sync-backend.ts

@@ -19,15 +19,15 @@ export * from './sync-backend-kv.ts'
 /**
  * Those arguments can be used to implement multi-tenancy etc and are passed in from the store.
  */
-export type MakeBackendArgs = {
+export type MakeBackendArgs<TPayload = Schema.JsonValue> = {
   storeId: string
   clientId: string
-  payload: Schema.JsonValue | undefined
+  payload: TPayload | undefined
 }
 
 // TODO rename to `SyncProviderClientConstructor`
-export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue> = (
-  args: MakeBackendArgs,
+export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue, TPayload = Schema.JsonValue> = (
+  args: MakeBackendArgs<TPayload>,
 ) => Effect.Effect<
   SyncBackend<TSyncMetadata>,
   UnexpectedError,

package/src/sync/sync.ts

@@ -1,11 +1,12 @@
 export * from './errors.ts'
 export * as SyncBackend from './sync-backend.ts'
 
+import type { Schema } from '@livestore/utils/effect'
 import type { InitialSyncOptions } from '../leader-thread/types.ts'
 import type { SyncBackendConstructor } from './sync-backend.ts'
 
-export type SyncOptions = {
-  backend?: SyncBackendConstructor<any>
+export type SyncOptions<TPayload = Schema.JsonValue> = {
+  backend?: SyncBackendConstructor<any, TPayload>
   /** @default { _tag: 'Skip' } */
   initialSyncOptions?: InitialSyncOptions
   /**

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.4.0-dev.14' as const
+export const liveStoreVersion = '0.4.0-dev.15' as const
 
 /**
  * CRITICAL: Increment this version whenever you modify client-side EVENTLOG table schemas.