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

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/sql-queries/sql-queries.ts

@@ -247,7 +247,15 @@ export const createTable = ({
     .map(([columnName, _]) => columnName)
   const columnDefStrs = Object.entries(table.columns).map(([columnName, columnDef]) => {
     const nullModifier = columnDef.nullable === true ? '' : 'NOT NULL'
-    const defaultModifier = columnDef.default._tag === 'None' ? '' : `DEFAULT ${columnDef.default.value}`
+    const defaultModifier = (() => {
+      if (columnDef.default._tag === 'None') return ''
+      const defaultValue = columnDef.default.value
+      if (typeof defaultValue === 'function') return ''
+      if (defaultValue && typeof defaultValue === 'object' && 'sql' in defaultValue) {
+        return `DEFAULT ${defaultValue.sql}`
+      }
+      return `DEFAULT ${defaultValue}`
+    })()
     return sql`${columnName} ${columnDef.columnType} ${nullModifier} ${defaultModifier}`
   })
 

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.16' as const
 
 /**
  * CRITICAL: Increment this version whenever you modify client-side EVENTLOG table schemas.