@livestore/common 0.3.0-dev.8 → 0.3.0

package/src/schema-management/common.ts

@@ -1,4 +1,4 @@
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { SqliteDb } from '../adapter-types.js'
 import type { ParamsObject } from '../util.js'
 import { prepareBindValues } from '../util.js'
 
@@ -6,7 +6,7 @@ import { prepareBindValues } from '../util.js'
 // will require proper scope-aware cleanup etc (for testing and apps with multiple LiveStore instances)
 // const cachedStmts = new Map<string, PreparedStatement>()
 
-export const dbExecute = (db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
+export const dbExecute = (db: SqliteDb, queryStr: string, bindValues?: ParamsObject) => {
   // let stmt = cachedStmts.get(queryStr)
   // if (!stmt) {
   const stmt = db.prepare(queryStr)
@@ -20,7 +20,7 @@ export const dbExecute = (db: SynchronousDatabase, queryStr: string, bindValues?
   stmt.finalize()
 }
 
-export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
+export const dbSelect = <T>(db: SqliteDb, queryStr: string, bindValues?: ParamsObject) => {
   // let stmt = cachedStmts.get(queryStr)
   // if (!stmt) {
   const stmt = db.prepare(queryStr)
@@ -33,12 +33,12 @@ export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValue
 }
 
 export interface SchemaManager {
-  getMutationDefInfos: () => ReadonlyArray<MutationDefInfo>
+  getEventDefInfos: () => ReadonlyArray<EventDefInfo>
 
-  setMutationDefInfo: (mutationDefInfo: MutationDefInfo) => void
+  setEventDefInfo: (eventDefInfo: EventDefInfo) => void
 }
 
-export type MutationDefInfo = {
-  mutationName: string
+export type EventDefInfo = {
+  eventName: string
   schemaHash: number
 }

package/src/schema-management/migrations.ts

@@ -1,42 +1,41 @@
-import { SqliteAst, SqliteDsl } from '@livestore/db-schema'
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 
-import type { SynchronousDatabase } from '../adapter-types.js'
+import type { MigrationsReport, MigrationsReportEntry, SqliteDb, UnexpectedError } from '../adapter-types.js'
 import type { LiveStoreSchema } from '../schema/mod.js'
-import type { SchemaMetaRow, SchemaMutationsMetaRow } from '../schema/system-tables.js'
+import { SqliteAst, SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
+import type { SchemaEventDefsMetaRow, SchemaMetaRow } from '../schema/state/sqlite/system-tables.js'
 import {
+  isStateSystemTable,
+  SCHEMA_EVENT_DEFS_META_TABLE,
   SCHEMA_META_TABLE,
-  SCHEMA_MUTATIONS_META_TABLE,
-  schemaMetaTable,
-  schemaMutationsMetaTable,
-  systemTables,
-} from '../schema/system-tables.js'
+  schemaEventDefsMetaTable,
+  stateSystemTables,
+} from '../schema/state/sqlite/system-tables.js'
 import { sql } from '../util.js'
 import type { SchemaManager } from './common.js'
 import { dbExecute, dbSelect } from './common.js'
-import { validateSchema } from './validate-mutation-defs.js'
+import { validateSchema } from './validate-schema.js'
 
 const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
 
-export const makeSchemaManager = (db: SynchronousDatabase): Effect.Effect<SchemaManager> =>
+export const makeSchemaManager = (db: SqliteDb): Effect.Effect<SchemaManager> =>
   Effect.gen(function* () {
     yield* migrateTable({
       db,
-      tableAst: schemaMutationsMetaTable.sqliteDef.ast,
+      tableAst: schemaEventDefsMetaTable.sqliteDef.ast,
       behaviour: 'create-if-not-exists',
     })
 
     return {
-      getMutationDefInfos: () =>
-        dbSelect<SchemaMutationsMetaRow>(db, sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`),
+      getEventDefInfos: () => dbSelect<SchemaEventDefsMetaRow>(db, sql`SELECT * FROM ${SCHEMA_EVENT_DEFS_META_TABLE}`),
 
-      setMutationDefInfo: (info) => {
+      setEventDefInfo: (info) => {
         dbExecute(
           db,
-          sql`INSERT OR REPLACE INTO ${SCHEMA_MUTATIONS_META_TABLE} (mutationName, schemaHash, updatedAt) VALUES ($mutationName, $schemaHash, $updatedAt)`,
+          sql`INSERT OR REPLACE INTO ${SCHEMA_EVENT_DEFS_META_TABLE} (eventName, schemaHash, updatedAt) VALUES ($eventName, $schemaHash, $updatedAt)`,
           {
-            mutationName: info.mutationName,
+            eventName: info.eventName,
             schemaHash: info.schemaHash,
             updatedAt: new Date().toISOString(),
           },
@@ -51,16 +50,18 @@ export const migrateDb = ({
   schema,
   onProgress,
 }: {
-  db: SynchronousDatabase
+  db: SqliteDb
   schema: LiveStoreSchema
   onProgress?: (opts: { done: number; total: number }) => Effect.Effect<void>
-}) =>
+}): Effect.Effect<MigrationsReport, UnexpectedError> =>
   Effect.gen(function* () {
-    yield* migrateTable({
-      db,
-      tableAst: schemaMetaTable.sqliteDef.ast,
-      behaviour: 'create-if-not-exists',
-    })
+    for (const tableDef of stateSystemTables) {
+      yield* migrateTable({
+        db,
+        tableAst: tableDef.sqliteDef.ast,
+        behaviour: 'create-if-not-exists',
+      })
+    }
 
     // TODO enforce that migrating tables isn't allowed once the store is running
 
@@ -73,14 +74,15 @@ export const migrateDb = ({
       schemaMetaRows.map(({ tableName, schemaHash }) => [tableName, schemaHash]),
     )
 
-    const tableDefs = new Set([
+    const tableDefs = [
       // NOTE it's important the `SCHEMA_META_TABLE` comes first since we're writing to it below
-      ...systemTables,
-      ...Array.from(schema.tables.values()).filter((_) => _.sqliteDef.name !== SCHEMA_META_TABLE),
-    ])
+      ...stateSystemTables,
+      ...Array.from(schema.state.sqlite.tables.values()).filter((_) => !isStateSystemTable(_.sqliteDef.name)),
+    ]
 
     const tablesToMigrate = new Set<{ tableAst: SqliteAst.Table; schemaHash: number }>()
 
+    const migrationsReportEntries: MigrationsReportEntry[] = []
     for (const tableDef of tableDefs) {
       const tableAst = tableDef.sqliteDef.ast
       const tableName = tableAst.name
@@ -90,9 +92,10 @@ export const migrateDb = ({
       if (schemaHash !== dbSchemaHash) {
         tablesToMigrate.add({ tableAst, schemaHash })
 
-        console.log(
-          `Schema hash mismatch for table '${tableName}' (DB: ${dbSchemaHash}, expected: ${schemaHash}), migrating table...`,
-        )
+        migrationsReportEntries.push({
+          tableName,
+          hashes: { expected: schemaHash, actual: dbSchemaHash },
+        })
       }
     }
 
@@ -107,6 +110,8 @@ export const migrateDb = ({
         yield* onProgress({ done: processedTables, total: tablesCount })
       }
     }
+
+    return { migrations: migrationsReportEntries }
   })
 
 export const migrateTable = ({
@@ -116,7 +121,7 @@ export const migrateTable = ({
   behaviour,
   skipMetaTable = false,
 }: {
-  db: SynchronousDatabase
+  db: SqliteDb
   tableAst: SqliteAst.Table
   schemaHash?: number
   behaviour: 'drop-and-recreate' | 'create-if-not-exists'
@@ -182,6 +187,7 @@ const toSqliteColumnSpec = (column: SqliteAst.Column) => {
   const defaultValueStr = (() => {
     if (column.default._tag === 'None') return ''
 
+    if (column.default.value === null) return 'default null'
     if (SqliteDsl.isSqlDefaultValue(column.default.value)) return `default ${column.default.value.sql}`
 
     const encodeValue = EffectSchema.encodeSync(column.schema)

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

@@ -0,0 +1,61 @@
+import { Effect, Schema } from '@livestore/utils/effect'
+
+import { UnexpectedError } from '../adapter-types.js'
+import type { EventDef } from '../schema/EventDef.js'
+import type { LiveStoreSchema } from '../schema/mod.js'
+import type { EventDefInfo, SchemaManager } from './common.js'
+
+export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaManager) =>
+  Effect.gen(function* () {
+    // Validate mutation definitions
+    const registeredEventDefInfos = schemaManager.getEventDefInfos()
+
+    const missingEventDefs = registeredEventDefInfos.filter(
+      (registeredEventDefInfo) => !schema.eventsDefsMap.has(registeredEventDefInfo.eventName),
+    )
+
+    if (missingEventDefs.length > 0) {
+      yield* new UnexpectedError({
+        cause: `Missing mutation definitions: ${missingEventDefs.map((info) => info.eventName).join(', ')}`,
+      })
+    }
+
+    for (const [, eventDef] of schema.eventsDefsMap) {
+      const registeredEventDefInfo = registeredEventDefInfos.find((info) => info.eventName === eventDef.name)
+
+      validateEventDef(eventDef, schemaManager, registeredEventDefInfo)
+    }
+
+    // Validate table schemas
+  })
+
+export const validateEventDef = (
+  eventDef: EventDef.AnyWithoutFn,
+  schemaManager: SchemaManager,
+  registeredEventDefInfo: EventDefInfo | undefined,
+) => {
+  const schemaHash = Schema.hash(eventDef.schema)
+
+  if (registeredEventDefInfo === undefined) {
+    schemaManager.setEventDefInfo({
+      schemaHash,
+      eventName: eventDef.name,
+    })
+
+    return
+  }
+
+  if (schemaHash === registeredEventDefInfo.schemaHash) return
+
+  // TODO bring back some form of schema compatibility check (see https://github.com/livestorejs/livestore/issues/69)
+  // const newSchemaIsCompatibleWithOldSchema = Schema.isSubType(jsonSchemaDefFromMgmtStore, eventDef.schema)
+
+  // if (!newSchemaIsCompatibleWithOldSchema) {
+  //   shouldNeverHappen(`Schema for mutation ${eventDef.name} has changed in an incompatible way`)
+  // }
+
+  schemaManager.setEventDefInfo({
+    schemaHash,
+    eventName: eventDef.name,
+  })
+}

package/src/sql-queries/sql-queries.ts

@@ -1,7 +1,7 @@
-import type { SqliteDsl } from '@livestore/db-schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyArray, Schema, TreeFormatter } from '@livestore/utils/effect'
 
+import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
 import { sql } from '../util.js'
 import { objectEntries } from './misc.js'
 import * as ClientTypes from './types.js'

package/src/sql-queries/sql-query-builder.ts

@@ -1,5 +1,4 @@
-import type { SqliteDsl } from '@livestore/db-schema'
-
+import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
 import type { BindValues } from './sql-queries.js'
 import * as SqlQueries from './sql-queries.js'
 import type * as ClientTypes from './types.js'

package/src/sql-queries/types.ts

@@ -1,6 +1,8 @@
-import type { Prettify, SqliteDsl } from '@livestore/db-schema'
+import type { Prettify } from '@livestore/utils'
 import type { Schema } from '@livestore/utils/effect'
 
+import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
+
 export type DecodedValuesForTableAll<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = {
   [K in keyof GetColumns<TSchema, TTableName>]: Schema.Schema.Type<GetColumn<TSchema, TTableName, K>['schema']>
 }