@livestore/livestore 0.0.55-dev.3 → 0.0.55

package/src/reactiveQueries/sql.ts

@@ -1,26 +1,24 @@
 import { type Bindable, prepareBindValues, type QueryInfo, type QueryInfoNone } from '@livestore/common'
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Schema, SchemaEquivalence, TreeFormatter } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import { globalReactivityGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
+import { NOT_REFRESHED_YET } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { GetAtomResult, LiveQuery, QueryContext, ReactivityGraph } from './base-class.js'
 import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
 
-export type MapRows<TResult, TRaw = any> =
-  | ((rows: ReadonlyArray<TRaw>) => TResult)
-  | Schema.Schema<TResult, ReadonlyArray<TRaw>, unknown>
-
 /**
  * NOTE `querySQL` is only supposed to read data. Don't use it to insert/update/delete data but use mutations instead.
  */
-export const querySQL = <TResult, TRaw = any>(
+export const querySQL = <TResultSchema, TResult = TResultSchema>(
   query: string | ((get: GetAtomResult) => string),
-  options?: {
-    map?: MapRows<TResult, TRaw>
+  options: {
+    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
+    map?: (rows: TResultSchema) => TResult
     /**
      * Can be provided explicitly to slightly speed up initial query performance
      *
@@ -32,21 +30,23 @@ export const querySQL = <TResult, TRaw = any>(
     reactivityGraph?: ReactivityGraph
   },
 ): LiveQuery<TResult, QueryInfoNone> =>
-  new LiveStoreSQLQuery<TResult, QueryInfoNone>({
+  new LiveStoreSQLQuery<TResultSchema, TResult, QueryInfoNone>({
     label: options?.label,
     genQueryString: query,
     queriedTables: options?.queriedTables,
     bindValues: options?.bindValues,
     reactivityGraph: options?.reactivityGraph,
     map: options?.map,
+    schema: options.schema,
     queryInfo: { _tag: 'None' },
   })
 
 /* An object encapsulating a reactive SQL query */
-export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfoNone> extends LiveStoreQueryBase<
-  TResult,
-  TQueryInfo
-> {
+export class LiveStoreSQLQuery<
+  TResultSchema,
+  TResult = TResultSchema,
+  TQueryInfo extends QueryInfo = QueryInfoNone,
+> extends LiveStoreQueryBase<TResult, TQueryInfo> {
   _tag: 'sql' = 'sql'
 
   /** A reactive thunk representing the query text */
@@ -62,7 +62,8 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
   /** Currently only used by `rowQuery` for lazy table migrations and eager default row insertion */
   private execBeforeFirstRun
 
-  private mapRows
+  private mapResult: (rows: TResultSchema) => TResult
+  private schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
 
   queryInfo: TQueryInfo
 
@@ -70,8 +71,9 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     genQueryString,
     queriedTables,
     bindValues,
-    label: label_,
+    label = genQueryString.toString(),
     reactivityGraph,
+    schema,
     map,
     execBeforeFirstRun,
     queryInfo,
@@ -81,51 +83,20 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
     queriedTables?: Set<string>
     bindValues?: Bindable
     reactivityGraph?: ReactivityGraph
-    map?: MapRows<TResult>
+    schema: Schema.Schema<TResultSchema, ReadonlyArray<any>>
+    map?: (rows: TResultSchema) => TResult
     execBeforeFirstRun?: (ctx: QueryContext) => void
     queryInfo?: TQueryInfo
   }) {
     super()
 
-    const label = label_ ?? genQueryString.toString()
     this.label = `sql(${label})`
     this.reactivityGraph = reactivityGraph ?? globalReactivityGraph
     this.execBeforeFirstRun = execBeforeFirstRun
     this.queryInfo = queryInfo ?? ({ _tag: 'None' } as TQueryInfo)
-    this.mapRows =
-      map === undefined
-        ? (rows: any) => rows as TResult
-        : Schema.isSchema(map)
-          ? (rows: any, opts: { sqlString: string }) => {
-              const parseResult = Schema.decodeEither(map as Schema.Schema<TResult, ReadonlyArray<any>>)(rows)
-              if (parseResult._tag === 'Left') {
-                const parseErrorStr = TreeFormatter.formatErrorSync(parseResult.left)
-                const expectedSchemaStr = String(map.ast)
-                const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
-
-                console.error(
-                  `\
-Error parsing SQL query result.
-
-Query: ${opts.sqlString}\
-${bindValuesStr}
-
-Expected schema: ${expectedSchemaStr}
 
-Error: ${parseErrorStr}
-
-Result:`,
-                  rows,
-                )
-                // console.error(`Error parsing SQL query result: ${TreeFormatter.formatErrorSync(parseResult.left)}`)
-                return shouldNeverHappen(`Error parsing SQL query result: ${parseResult.left}`)
-              } else {
-                return parseResult.right as TResult
-              }
-            }
-          : typeof map === 'function'
-            ? map
-            : shouldNeverHappen(`Invalid map function ${map}`)
+    this.schema = schema
+    this.mapResult = map === undefined ? (rows: any) => rows as TResult : map
 
     let queryString$OrQueryString: string | Thunk<string, QueryContext, RefreshReason>
     if (typeof genQueryString === 'function') {
@@ -137,7 +108,11 @@ Result:`,
           setDebugInfo({ _tag: 'js', label: `${label}:queryString`, query: queryString, durationMs })
           return queryString
         },
-        { label: `${label}:queryString`, meta: { liveStoreThunkType: 'sqlQueryString' } },
+        {
+          label: `${label}:queryString`,
+          meta: { liveStoreThunkType: 'sqlQueryString' },
+          equal: (a, b) => a === b,
+        },
       )
 
       this.queryString$ = queryString$OrQueryString
@@ -149,6 +124,15 @@ Result:`,
 
     const queriedTablesRef = { current: queriedTables }
 
+    const schemaEqual = SchemaEquivalence.make(schema)
+    // TODO also support derived equality for `map` (probably will depend on having an easy way to transform a schema without an `encode` step)
+    // This would mean dropping the `map` option
+    const equal =
+      map === undefined
+        ? (a: TResult, b: TResult) =>
+            a === NOT_REFRESHED_YET || b === NOT_REFRESHED_YET ? false : schemaEqual(a as any, b as any)
+        : undefined
+
     const results$ = this.reactivityGraph.makeThunk<TResult>(
       (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) =>
         otelTracer.startActiveSpan(
@@ -189,7 +173,31 @@ Result:`,
 
             span.setAttribute('sql.rowsCount', rawResults.length)
 
-            const result = this.mapRows(rawResults, { sqlString })
+            const parsedResult = Schema.decodeEither(this.schema)(rawResults)
+
+            if (parsedResult._tag === 'Left') {
+              const parseErrorStr = TreeFormatter.formatErrorSync(parsedResult.left)
+              const expectedSchemaStr = String(this.schema.ast)
+              const bindValuesStr = bindValues === undefined ? '' : `\nBind values: ${JSON.stringify(bindValues)}`
+
+              console.error(
+                `\
+Error parsing SQL query result.
+
+Query: ${sqlString}\
+${bindValuesStr}
+
+Expected schema: ${expectedSchemaStr}
+
+Error: ${parseErrorStr}
+
+Result:`,
+                rawResults,
+              )
+              return shouldNeverHappen(`Error parsing SQL query result: ${parsedResult.left}`)
+            }
+
+            const result = this.mapResult(parsedResult.right)
 
             span.end()
 
@@ -202,45 +210,12 @@ Result:`,
             return result
           },
         ),
-      { label: queryLabel },
+      { label: queryLabel, equal },
     )
 
     this.results$ = results$
   }
 
-  /**
-   * Returns a new reactive query that contains the result of
-   * running an arbitrary JS computation on the results of this SQL query.
-   */
-  // pipe = <U>(fn: (result: Result, get: GetAtomResult) => U): LiveStoreJSQuery<U> =>
-  //   new LiveStoreJSQuery({
-  //     fn: (get) => {
-  //       const results = get(this.results$!)
-  //       return fn(results, get)
-  //     },
-  //     label: `${this.label}:js`,
-  //     onDestroy: () => this.destroy(),
-  //     reactivityGraph: this.reactivityGraph,
-  //     queryInfo: undefined,
-  //   })
-
-  /** Returns a reactive query  */
-  // getFirstRow = (args?: { defaultValue?: Result }) =>
-  //   new LiveStoreJSQuery({
-  //     fn: (get) => {
-  //       const results = get(this.results$!)
-  //       if (results.length === 0 && args?.defaultValue === undefined) {
-  //         // const queryLabel = this._tag === 'sql' ? this.queryString$!.computeResult(otelContext) : this.label
-  //         const queryLabel = this.label
-  //         return shouldNeverHappen(`Expected query ${queryLabel} to return at least one result`)
-  //       }
-  //       return results[0] ?? args!.defaultValue!
-  //     },
-  //     label: `${this.label}:first`,
-  //     onDestroy: () => this.destroy(),
-  //     reactivityGraph: this.reactivityGraph,
-  //   })
-
   destroy = () => {
     if (this.queryString$ !== undefined) {
       this.reactivityGraph.destroyNode(this.queryString$)

package/src/row-query.ts

@@ -3,7 +3,7 @@ import { sql } from '@livestore/common'
 import { DbSchema } from '@livestore/common/schema'
 import type { GetValForKey } from '@livestore/utils'
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema, TreeFormatter } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import type { SqliteDsl } from 'effect-db-schema'
 
@@ -12,14 +12,16 @@ import { computed } from './reactiveQueries/js.js'
 import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
 import type { Store } from './store.js'
 
-export type RowQueryOptions = {
+export type RowQueryOptions<TTableDef extends DbSchema.TableDef, TResult = RowResult<TTableDef>> = {
   otelContext?: otel.Context
   skipInsertDefaultRow?: boolean
   reactivityGraph?: ReactivityGraph
+  map?: (result: RowResult<TTableDef>) => TResult
+  label?: string
 }
 
 export type RowQueryOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
-  defaultValues: Partial<RowResult<TTableDef>>
+  defaultValues?: Partial<RowResult<TTableDef>>
 }
 
 export type MakeRowQuery = {
@@ -29,9 +31,10 @@ export type MakeRowQuery = {
       boolean,
       DbSchema.TableOptions & { isSingleton: true }
     >,
+    TResult = RowResult<TTableDef>,
   >(
     table: TTableDef,
-    options?: RowQueryOptions,
+    options?: RowQueryOptions<TTableDef, TResult>,
   ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
   <
     TTableDef extends DbSchema.TableDef<
@@ -39,19 +42,20 @@ export type MakeRowQuery = {
       boolean,
       DbSchema.TableOptions & { isSingleton: false }
     >,
+    TResult = RowResult<TTableDef>,
   >(
     table: TTableDef,
     // TODO adjust so it works with arbitrary primary keys or unique constraints
     id: string,
-    options?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
-  ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
+    options?: RowQueryOptions<TTableDef, TResult> & RowQueryOptionsDefaulValues<TTableDef>,
+  ): LiveQuery<TResult, QueryInfoRow<TTableDef>>
 }
 
 // TODO also allow other where clauses and multiple rows
 export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
   table: TTableDef,
-  idOrOptions?: string | RowQueryOptions,
-  options_?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
+  idOrOptions?: string | RowQueryOptions<TTableDef, any>,
+  options_?: RowQueryOptions<TTableDef, any> & RowQueryOptionsDefaulValues<TTableDef>,
 ) => {
   const id = typeof idOrOptions === 'string' ? idOrOptions : undefined
   const options = typeof idOrOptions === 'string' ? options_ : idOrOptions
@@ -70,8 +74,10 @@ export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
   const whereClause = id === undefined ? '' : `where id = '${id}'`
   const queryStr = sql`select * from ${tableName} ${whereClause} limit 1`
 
+  const rowSchema = table.isSingleColumn === true ? table.schema.pipe(Schema.pluck('value' as any)) : table.schema
+
   return new LiveStoreSQLQuery({
-    label: `rowQuery:query:${tableSchema.name}${id === undefined ? '' : `:${id}`}`,
+    label: options?.label ?? `rowQuery:query:${tableSchema.name}${id === undefined ? '' : `:${id}`}`,
     genQueryString: queryStr,
     queriedTables: new Set([tableName]),
     reactivityGraph: options?.reactivityGraph,
@@ -83,18 +89,8 @@ export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
       id,
       skipInsertDefaultRow: options?.skipInsertDefaultRow,
     }),
-    map: (results): RowResult<TTableDef> => {
-      if (results.length === 0) return shouldNeverHappen(`No results for query ${queryStr}`)
-
-      const parseResult = Schema.decodeEither(table.schema)(results[0]!)
-
-      if (parseResult._tag === 'Left') {
-        console.error('decode error', TreeFormatter.formatErrorSync(parseResult.left), 'results', results)
-        return shouldNeverHappen(`Error decoding query result for ${queryStr}`)
-      }
-
-      return table.isSingleColumn === true ? parseResult.right.value : parseResult.right
-    },
+    schema: rowSchema.pipe(Schema.Array, Schema.headOrElse()),
+    map: options?.map,
     queryInfo: { _tag: 'Row', table, id: id ?? 'singleton' },
   })
 }