@livestore/cli 0.4.0 → 0.5.0-dev.0

package/src/mcp-content/schemas/todo.ts

@@ -34,8 +34,8 @@ export const tables = {
   // Client-only state for UI (not synced)
   uiState: State.SQLite.clientDocument({
     name: 'uiState',
-    schema: Schema.Struct({ 
-      newTodoText: Schema.String, 
+    schema: Schema.Struct({
+      newTodoText: Schema.String,
       filter: Schema.Literal('all', 'active', 'completed'),
       selectedTags: Schema.Array(Schema.String)
     }),
@@ -48,8 +48,8 @@ export const events = {
   // Todo events
   todoCreated: Events.synced({
     name: 'v1.TodoCreated',
-    schema: Schema.Struct({ 
-      id: Schema.String, 
+    schema: Schema.Struct({
+      id: Schema.String,
       title: Schema.String,
       createdAt: Schema.Date,
       position: Schema.Number
@@ -60,7 +60,7 @@ export const events = {
     schema: Schema.Struct({ id: Schema.String }),
   }),
   todoUncompleted: Events.synced({
-    name: 'v1.TodoUncompleted', 
+    name: 'v1.TodoUncompleted',
     schema: Schema.Struct({ id: Schema.String }),
   }),
   todoTitleChanged: Events.synced({
@@ -76,16 +76,16 @@ export const events = {
     schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
   }),
   todosCleared: Events.synced({
-    name: 'v1.TodosCleared', 
+    name: 'v1.TodosCleared',
     schema: Schema.Struct({ deletedAt: Schema.Date }),
   }),
-  
+
   // Tag events
   tagCreated: Events.synced({
     name: 'v1.TagCreated',
-    schema: Schema.Struct({ 
-      id: Schema.String, 
-      name: Schema.String, 
+    schema: Schema.Struct({
+      id: Schema.String,
+      name: Schema.String,
       color: Schema.NullOr(Schema.String),
       createdAt: Schema.Date
     }),
@@ -94,7 +94,7 @@ export const events = {
     name: 'v1.TagDeleted',
     schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
   }),
-  
+
   // Todo-Tag relationship events
   todoTagged: Events.synced({
     name: 'v1.TodoTagged',
@@ -104,7 +104,7 @@ export const events = {
     name: 'v1.TodoUntagged',
     schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String }),
   }),
-  
+
   // UI state events (local only)
   uiStateSet: tables.uiState.set,
 }
@@ -112,39 +112,39 @@ export const events = {
 // Materializers - Map events to state changes with conflict-free semantics
 const materializers = State.SQLite.materializers(events, {
   // Todo materializers
-  'v1.TodoCreated': ({ id, title, createdAt, position }) => 
+  'v1.TodoCreated': ({ id, title, createdAt, position }) =>
     tables.todos.insert({ id, title, completed: false, createdAt, position }),
-    
-  'v1.TodoCompleted': ({ id }) => 
+
+  'v1.TodoCompleted': ({ id }) =>
     tables.todos.update({ completed: true }).where({ id }),
-    
-  'v1.TodoUncompleted': ({ id }) => 
+
+  'v1.TodoUncompleted': ({ id }) =>
     tables.todos.update({ completed: false }).where({ id }),
-    
-  'v1.TodoTitleChanged': ({ id, title }) => 
+
+  'v1.TodoTitleChanged': ({ id, title }) =>
     tables.todos.update({ title }).where({ id }),
-    
-  'v1.TodoReordered': ({ id, position }) => 
+
+  'v1.TodoReordered': ({ id, position }) =>
     tables.todos.update({ position }).where({ id }),
-    
-  'v1.TodoDeleted': ({ id, deletedAt }) => 
+
+  'v1.TodoDeleted': ({ id, deletedAt }) =>
     tables.todos.update({ deletedAt }).where({ id }),
-    
-  'v1.TodosCleared': ({ deletedAt }) => 
+
+  'v1.TodosCleared': ({ deletedAt }) =>
     tables.todos.update({ deletedAt }).where({ completed: true, deletedAt: null }),
-    
-  // Tag materializers  
-  'v1.TagCreated': ({ id, name, color, createdAt }) => 
+
+  // Tag materializers
+  'v1.TagCreated': ({ id, name, color, createdAt }) =>
     tables.tags.insert({ id, name, color, createdAt }),
-    
-  'v1.TagDeleted': ({ id, deletedAt }) => 
+
+  'v1.TagDeleted': ({ id, deletedAt }) =>
     tables.tags.update({ deletedAt }).where({ id }),
-    
+
   // Todo-Tag relationship materializers
-  'v1.TodoTagged': ({ todoId, tagId, createdAt }) => 
+  'v1.TodoTagged': ({ todoId, tagId, createdAt }) =>
     tables.todoTags.insert({ todoId, tagId, createdAt }),
-    
-  'v1.TodoUntagged': ({ todoId, tagId }) => 
+
+  'v1.TodoUntagged': ({ todoId, tagId }) =>
     tables.todoTags.delete().where({ todoId, tagId }),
 })
 
@@ -153,7 +153,7 @@ const state = State.SQLite.makeState({ tables, materializers })
 export const schema = makeSchema({ events, state })
 
 // Example usage:
-// 
+//
 // import { queryDb, dispatchEvent } from '@livestore/livestore'
 // import { schema, events, tables } from './schema.js'
 //

package/src/mcp-runtime/runtime.ts

@@ -55,7 +55,7 @@ export const init = ({
         storeId,
         adapter,
         disableDevtools: true,
-        syncPayload,
+        ...(syncPayload !== undefined ? { syncPayload } : {}),
         syncPayloadSchema,
       }),
     )
@@ -73,7 +73,7 @@ export const init = ({
     return store
   }).pipe(Effect.provide(ModuleLoaderLayer), Effect.withSpan('mcp-runtime:init'))
 
-export const getStore = Effect.sync(() => Option.fromNullable(store))
+export const getStore = Effect.sync(() => Option.fromNullishOr(store))
 
 export const status = Effect.gen(function* () {
   const opt = yield* getStore
@@ -111,26 +111,26 @@ export const query = Effect.fn('mcp-runtime:query')(function* ({
 }) {
   const opt = yield* getStore
   if (opt._tag === 'None') {
-    return yield* Effect.dieMessage('LiveStore not connected. Call livestore_instance_connect first.')
+    return yield* Effect.die(new Error('LiveStore not connected. Call livestore_instance_connect first.'))
   }
   const s = opt.value
 
   const rows = s.query<Array<Record<string, unknown>>>({ query: sql, bindValues: (bindValues as any) ?? [] })
-  const jsonRows = rows.map((r) => Object.fromEntries(Object.entries(r).map(([k, v]) => [k, v as Schema.JsonValue])))
+  const jsonRows = rows.map((r) => Object.fromEntries(Object.entries(r).map(([k, v]) => [k, v as Schema.Json])))
   return { rows: jsonRows, rowCount: jsonRows.length }
 })
 
 export const commit = Effect.fn('mcp-runtime:commit')(function* ({
   events,
 }: {
-  events: ReadonlyArray<{ name: string; args: Schema.JsonValue }>
+  events: ReadonlyArray<{ name: string; args: Schema.Json }>
 }) {
   const opt = yield* getStore
   if (opt._tag === 'None') {
-    return yield* Effect.dieMessage('LiveStore not connected. Call livestore_instance_connect first.')
+    return yield* Effect.die(new Error('LiveStore not connected. Call livestore_instance_connect first.'))
   }
   const s = opt.value
-  const InputEventSchema = LiveStoreEvent.Input.makeSchema(s.schema) as Schema.Schema<any>
+  const InputEventSchema = LiveStoreEvent.Input.makeSchema(s.schema) as Schema.Codec<any>
   const decoded = events.map((e) => Schema.decodeSync(InputEventSchema)(e))
   s.commit(...decoded)
   return { committed: decoded.length }

package/src/module-loader.ts

@@ -14,8 +14,8 @@ import { Effect, FileSystem, Schema } from '@livestore/utils/effect'
 export interface ModuleConfig {
   schema: LiveStoreSchema
   syncBackendConstructor: SyncBackend.SyncBackendConstructor
-  syncPayloadSchema: Schema.Schema<any>
-  syncPayload: unknown
+  syncPayloadSchema: Schema.Codec<Schema.Json, Schema.Json>
+  syncPayload: Schema.Json | undefined
 }
 
 /**
@@ -52,7 +52,7 @@ export const loadModuleConfig = ({
         }),
     })
 
-    const schema = (mod)?.schema
+    const schema = mod?.schema
     if (isLiveStoreSchema(schema) === false) {
       return yield* UnknownError.make({
         cause: `Module at ${abs} must export a valid LiveStore 'schema'`,
@@ -60,7 +60,7 @@ export const loadModuleConfig = ({
       })
     }
 
-    const syncBackendConstructor = (mod)?.syncBackend
+    const syncBackendConstructor = mod?.syncBackend
     if (typeof syncBackendConstructor !== 'function') {
       return yield* UnknownError.make({
         cause: `Module at ${abs} must export a 'syncBackend' constructor`,
@@ -68,21 +68,21 @@ export const loadModuleConfig = ({
       })
     }
 
-    const syncPayloadSchemaExport = (mod)?.syncPayloadSchema
+    const syncPayloadSchemaExport = mod?.syncPayloadSchema
     const syncPayloadSchema =
       syncPayloadSchemaExport === undefined
-        ? Schema.JsonValue
+        ? Schema.Json
         : Schema.isSchema(syncPayloadSchemaExport) === true
-          ? (syncPayloadSchemaExport as Schema.Schema<any>)
+          ? (syncPayloadSchemaExport as Schema.Codec<Schema.Json, Schema.Json>)
           : shouldNeverHappen(
               `Exported 'syncPayloadSchema' from ${abs} must be an Effect Schema (received ${typeof syncPayloadSchemaExport}).`,
             )
 
-    const syncPayloadExport = (mod)?.syncPayload
+    const syncPayloadExport = mod?.syncPayload
     const syncPayload = yield* (
       syncPayloadExport === undefined
-        ? Effect.succeed<unknown>(undefined)
-        : Schema.decodeUnknown(syncPayloadSchema)(syncPayloadExport)
+        ? Effect.succeed<Schema.Json | undefined>(undefined)
+        : Schema.decodeUnknownEffect(syncPayloadSchema)(syncPayloadExport)
     ).pipe(UnknownError.mapToUnknownError)
 
     return {

package/src/sync-operations.ts

@@ -7,7 +7,6 @@ import { UnknownError } from '@livestore/common'
 import { LiveStoreEvent } from '@livestore/common/schema'
 import {
   Cause,
-  Chunk,
   Effect,
   type FileSystem,
   type HttpClient,
@@ -43,18 +42,21 @@ export const ExportFileSchema = Schema.Struct({
 
 export type ExportFile = typeof ExportFileSchema.Type
 
-export class ConnectionError extends Schema.TaggedError<ConnectionError>('~@livestore/cli/ConnectionError')('ConnectionError', {
-  cause: Schema.Defect,
-  note: Schema.String,
-}) {}
+export class ConnectionError extends Schema.TaggedError<ConnectionError>('~@livestore/cli/ConnectionError')(
+  'ConnectionError',
+  {
+    cause: Schema.Defect(),
+    note: Schema.String,
+  },
+) {}
 
 export class ExportError extends Schema.TaggedError<ExportError>('~@livestore/cli/ExportError')('ExportError', {
-  cause: Schema.Defect,
+  cause: Schema.Defect(),
   note: Schema.String,
 }) {}
 
 export class ImportError extends Schema.TaggedError<ImportError>('~@livestore/cli/ImportError')('ImportError', {
-  cause: Schema.Defect,
+  cause: Schema.Defect(),
   note: Schema.String,
 }) {}
 
@@ -85,7 +87,7 @@ export const makeSyncBackend = ({
       storeId,
       clientId,
       /** syncPayload is validated against syncPayloadSchema by loadModuleConfig */
-      payload: syncPayload as Schema.JsonValue | undefined,
+      payload: syncPayload as Schema.Json | undefined,
     }).pipe(Effect.provide(KeyValueStore.layerMemory), UnknownError.mapToUnknownError)
 
     /** Connect to the sync backend */
@@ -102,8 +104,8 @@ export const makeSyncBackend = ({
     /** Verify connectivity with a ping (with timeout) */
     yield* syncBackend.ping.pipe(
       Effect.timeout(CONNECTION_TIMEOUT_MS),
-      Effect.catchAll((cause) => {
-        if (Cause.isTimeoutException(cause) === true) {
+      Effect.catch((cause) => {
+        if (Cause.isTimeoutError(cause) === true) {
           return Effect.fail(
             new ConnectionError({
               cause,
@@ -126,7 +128,7 @@ export const makeSyncBackend = ({
 const releaseSyncBackend = (syncBackend: SyncBackend.SyncBackend): Effect.Effect<void> => {
   const maybeDisconnect = (syncBackend as { disconnect?: Effect.Effect<void> }).disconnect
   const releaseEffect = maybeDisconnect ?? SubscriptionRef.set(syncBackend.isConnected, false)
-  return releaseEffect.pipe(Effect.orElse(() => Effect.void))
+  return releaseEffect.pipe(Effect.catch(() => Effect.void))
 }
 
 export interface ExportResult {
@@ -173,9 +175,7 @@ export const pullEventsFromSyncBackend = ({
           ),
         )
 
-        const events = Chunk.toReadonlyArray(batchesChunk)
-          .flatMap((item) => item.batch)
-          .map((item) => item.eventEncoded)
+        const events = batchesChunk.flatMap((item) => item.batch).map((item) => item.eventEncoded)
 
         const exportedAt = new Date().toISOString()
         const exportData: ExportFile = {
@@ -224,7 +224,7 @@ export const validateExportData = ({
   targetStoreId: string
 }): Effect.Effect<ImportValidationResult, ImportError> =>
   Effect.gen(function* () {
-    const exportData = yield* Schema.decodeUnknown(ExportFileSchema)(data).pipe(
+    const exportData = yield* Schema.decodeUnknownEffect(ExportFileSchema)(data).pipe(
       Effect.mapError(
         (cause) =>
           new ImportError({
@@ -272,7 +272,7 @@ export const pushEventsToSyncBackend = ({
     makeSyncBackend({ configPath, storeId, clientId }),
     (syncBackend) =>
       Effect.gen(function* () {
-        const exportData = yield* Schema.decodeUnknown(ExportFileSchema)(data).pipe(
+        const exportData = yield* Schema.decodeUnknownEffect(ExportFileSchema)(data).pipe(
           Effect.mapError(
             (cause) =>
               new ImportError({