@livestore/livestore 0.0.38 → 0.0.39-dev.2

package/src/schema/table-def.ts

@@ -1,5 +1,5 @@
 import { shouldNeverHappen } from '@livestore/utils'
-import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
+import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 import type { Nullable, PrettifyFlat } from 'effect-db-schema'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
@@ -12,15 +12,52 @@ import { dynamicallyRegisteredTables } from '../global-state.js'
 export type StateType = 'singleton' | 'dynamic'
 
 export type DefaultSqliteTableDef = SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
+export type DefaultSqliteTableDefConstrained = SqliteDsl.TableDefinition<string, SqliteDsl.ConstraintColumns>
+
+// export type TableDefConstraint<
+//   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
+//   TIsSingleColumn extends boolean = boolean,
+//   TOptions extends TableOptions = TableOptions,
+// > = TableDefBase<TSqliteDef, TIsSingleColumn, TOptions> & { schema: Schema.Schema<any, any> }
+
+// /**
+//  * NOTE in the past we used to have a single `TableDef` but there are some TS issues when indroducing
+//  * `schema: SqliteDsl.StructSchemaForColumns<TSqliteDef>` so we split it into two types
+//  * and only use `TableDefConstraint` in some places
+//  */
+// export type TableDefBase<
+//   TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
+//   TIsSingleColumn extends boolean = boolean,
+//   TOptions extends TableOptions = TableOptions,
+// > = {
+//   sqliteDef: TSqliteDef
+//   // schema: SqliteDsl.StructSchemaForColumns<TSqliteDef>
+//   // schema: any;
+//   isSingleColumn: TIsSingleColumn
+//   options: TOptions
+// }
 
 export type TableDef<
-  TTableDef extends DefaultSqliteTableDef = DefaultSqliteTableDef,
+  TSqliteDef extends DefaultSqliteTableDef = DefaultSqliteTableDefConstrained,
   TIsSingleColumn extends boolean = boolean,
   TOptions extends TableOptions = TableOptions,
+  // NOTE we're not using `SqliteDsl.StructSchemaForColumns<TSqliteDef['columns']>`
+  // as we don't want the alias type for users to show up
+  TSchema = Schema.Schema<
+    SqliteDsl.AnyIfConstained<
+      TSqliteDef['columns'],
+      { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.From<TSqliteDef['columns'][K]['schema']> }
+    >,
+    SqliteDsl.AnyIfConstained<
+      TSqliteDef['columns'],
+      { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.To<TSqliteDef['columns'][K]['schema']> }
+    >
+  >,
 > = {
-  schema: TTableDef
+  sqliteDef: TSqliteDef
   isSingleColumn: TIsSingleColumn
   options: TOptions
+  schema: TSchema
 }
 
 export type TableOptionsInput = Partial<TableOptions & { indexes: SqliteDsl.Index[] }>
@@ -85,10 +122,10 @@ export const table = <
     }
   }
 
-  const schema = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
+  const sqliteDef = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
 
   if (options_.isSingleton) {
-    for (const column of schema.ast.columns) {
+    for (const column of sqliteDef.ast.columns) {
       if (column.nullable === false && column.default._tag === 'None') {
         shouldNeverHappen(
           `When creating a singleton table, each column must be either nullable or have a default value. Column '${column.name}' is neither.`,
@@ -99,11 +136,12 @@ export const table = <
 
   const isSingleColumn = SqliteDsl.isColumnDefinition(columnOrColumns) === true
 
-  const tableDef = { schema, isSingleColumn, options: options_ }
+  const schema = SqliteDsl.structSchemaForTable(sqliteDef)
+  const tableDef = { sqliteDef, isSingleColumn, options: options_, schema } satisfies TableDef
 
   if (dynamicallyRegisteredTables.has(tablePath)) {
-    if (SqliteAst.hash(dynamicallyRegisteredTables.get(tablePath)!.schema.ast) !== SqliteAst.hash(schema.ast)) {
-      console.error('previous tableDef', dynamicallyRegisteredTables.get(tablePath), 'new tableDef', schema.ast)
+    if (SqliteAst.hash(dynamicallyRegisteredTables.get(tablePath)!.sqliteDef.ast) !== SqliteAst.hash(sqliteDef.ast)) {
+      console.error('previous tableDef', dynamicallyRegisteredTables.get(tablePath), 'new tableDef', sqliteDef.ast)
       shouldNeverHappen(`Table with name "${name}" was already previously defined with a different definition`)
     }
   } else {
@@ -113,6 +151,36 @@ export const table = <
   return tableDef as any
 }
 
+export const tableIsSingleton = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+): tableDef is TTableDef & { options: { isSingleton: true } } => tableDef.options.isSingleton === true
+
+export const getDefaultValuesEncoded = <TTableDef extends TableDef>(tableDef: TTableDef) =>
+  pipe(
+    tableDef.sqliteDef.columns,
+    ReadonlyRecord.filter((_, key) => key !== 'id'),
+    ReadonlyRecord.map((column, columnName) =>
+      column!.default._tag === 'None'
+        ? column!.nullable === true
+          ? null
+          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+        : Schema.encodeSync(column!.schema)(column!.default.value),
+    ),
+  )
+
+export const getDefaultValuesDecoded = <TTableDef extends TableDef>(tableDef: TTableDef) =>
+  pipe(
+    tableDef.sqliteDef.columns,
+    ReadonlyRecord.filter((_, key) => key !== 'id'),
+    ReadonlyRecord.map((column, columnName) =>
+      column!.default._tag === 'None'
+        ? column!.nullable === true
+          ? null
+          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
+        : Schema.validateSync(column!.schema)(column!.default.value),
+    ),
+  )
+
 type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> = TColumns &
   (TOptions['disableAutomaticIdColumn'] extends true
     ? {}
@@ -138,15 +206,15 @@ export namespace FromTable {
   >
 
   export type NullableColumnNames<TTableDef extends TableDef> = FromColumns.NullableColumnNames<
-    TTableDef['schema']['columns']
+    TTableDef['sqliteDef']['columns']
   >
 
   export type Columns<TTableDef extends TableDef> = {
-    [K in keyof TTableDef['schema']['columns']]: TTableDef['schema']['columns'][K]['columnType']
+    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['columnType']
   }
 
   export type RowEncodeNonNullable<TTableDef extends TableDef> = {
-    [K in keyof TTableDef['schema']['columns']]: Schema.Schema.From<TTableDef['schema']['columns'][K]['schema']>
+    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.From<TTableDef['sqliteDef']['columns'][K]['schema']>
   }
 
   export type RowEncoded<TTableDef extends TableDef> = PrettifyFlat<
@@ -155,7 +223,7 @@ export namespace FromTable {
   >
 
   export type RowDecodedAll<TTableDef extends TableDef> = {
-    [K in keyof TTableDef['schema']['columns']]: Schema.Schema.To<TTableDef['schema']['columns'][K]['schema']>
+    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.To<TTableDef['sqliteDef']['columns'][K]['schema']>
   }
 }
 

package/src/store.ts

@@ -11,35 +11,19 @@ import { InMemoryDatabase } from './inMemoryDatabase.js'
 import { migrateDb } from './migrations.js'
 import type { StackInfo } from './react/utils/stack-info.js'
 import type { DebugRefreshReasonBase, ReactiveGraph, Ref } from './reactive.js'
-import type { DbContext, DbGraph, ILiveStoreQuery } from './reactiveQueries/base-class.js'
-import type { LiveStoreGraphQLQuery } from './reactiveQueries/graphql.js'
-import type { LiveStoreJSQuery } from './reactiveQueries/js.js'
-import type { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
+import type { DbContext, DbGraph, LiveQuery } from './reactiveQueries/base-class.js'
 import type { ActionDefinition, GetActionArgs, LiveStoreSchema, SQLWriteStatement } from './schema/index.js'
 import type { Storage, StorageInit } from './storage/index.js'
 import { getDurationMsFromSpan } from './utils/otel.js'
 import type { ParamsObject } from './utils/util.js'
 import { isPromise, prepareBindValues, sql } from './utils/util.js'
 
-export type LiveStoreQuery<TResult extends Record<string, any> = any> =
-  | LiveStoreSQLQuery<TResult>
-  | LiveStoreJSQuery<TResult>
-  | LiveStoreGraphQLQuery<TResult, any, any>
-
 export type BaseGraphQLContext = {
   queriedTables: Set<string>
   /** Needed by Pothos Otel plugin for resolver tracing to work */
   otelContext?: otel.Context
 }
 
-export type QueryResult<TQuery> = TQuery extends LiveStoreSQLQuery<infer R>
-  ? ReadonlyArray<Readonly<R>>
-  : TQuery extends LiveStoreJSQuery<infer S>
-    ? Readonly<S>
-    : TQuery extends LiveStoreGraphQLQuery<infer Result, any, any>
-      ? Readonly<Result>
-      : never
-
 export type GraphQLOptions<TContext> = {
   schema: GraphQLSchema
   makeContext: (db: InMemoryDatabase, tracer: otel.Tracer) => TContext
@@ -120,7 +104,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLConte
   tableRefs: { [key: string]: Ref<null, DbContext, RefreshReason> }
 
   /** RC-based set to see which queries are currently subscribed to */
-  activeQueries: ReferenceCountedSet<LiveStoreQuery>
+  activeQueries: ReferenceCountedSet<LiveQuery<any>>
   storage?: Storage
 
   private constructor({
@@ -160,7 +144,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLConte
     const allTableNames = new Set([
       ...this.schema.tables.keys(),
       // TODO activate dynamic tables
-      ...Array.from(dynamicallyRegisteredTables.values()).map((_) => _.schema.name),
+      ...Array.from(dynamicallyRegisteredTables.values()).map((_) => _.sqliteDef.name),
     ])
     const existingTableRefs = new Map(
       Array.from(this.graph.atoms.values())
@@ -168,13 +152,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLConte
         .map((_) => [_.label!.slice('tableRef:'.length), _] as const),
     )
     for (const tableName of allTableNames) {
-      this.tableRefs[tableName] =
-        existingTableRefs.get(tableName) ??
-        this.graph.makeRef(null, {
-          equal: () => false,
-          label: `tableRef:${tableName}`,
-          meta: { liveStoreRefType: 'table' },
-        })
+      this.tableRefs[tableName] = existingTableRefs.get(tableName) ?? this.makeTableRef(tableName)
     }
 
     if (graphQLOptions) {
@@ -202,7 +180,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLConte
    * Returns a function to cancel the subscription.
    */
   subscribe = <TResult>(
-    query: ILiveStoreQuery<TResult>,
+    query: LiveQuery<TResult, any>,
     onNewValue: (value: TResult) => void,
     onUnsubsubscribe?: () => void,
     options?: { label?: string; otelContext?: otel.Context; skipInitialRun?: boolean } | undefined,
@@ -217,7 +195,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLConte
         const label = `subscribe:${options?.label}`
         const effect = this.graph.makeEffect((get) => onNewValue(get(query.results$)), { label })
 
-        this.activeQueries.add(query as LiveStoreQuery)
+        this.activeQueries.add(query as LiveQuery<TResult>)
 
         // Running effect right away to get initial value (unless `skipInitialRun` is set)
         if (options?.skipInitialRun !== true) {
@@ -227,7 +205,7 @@ export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLConte
         const unsubscribe = () => {
           try {
             this.graph.destroyNode(effect)
-            this.activeQueries.remove(query as LiveStoreQuery)
+            this.activeQueries.remove(query as LiveQuery<TResult>)
             onUnsubsubscribe?.()
           } finally {
             span.end()
@@ -538,6 +516,13 @@ export class Store<TGraphQLContext extends BaseGraphQLContext = BaseGraphQLConte
   select = (query: string, params: ParamsObject = {}) => {
     return this.inMemoryDB.select(query, { bindValues: prepareBindValues(params, query) })
   }
+
+  makeTableRef = (tableName: string) =>
+    this.graph.makeRef(null, {
+      equal: () => false,
+      label: `tableRef:${tableName}`,
+      meta: { liveStoreRefType: 'table' },
+    })
 }
 
 /** Create a new LiveStore Store */

package/src/update-path.ts

@@ -0,0 +1,102 @@
+import { notYetImplemented, shouldNeverHappen } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
+
+import type { FromTable, TableDef } from './schema/table-def.js'
+
+/**
+ * A description of a path to update a value either ...
+ * - as a whole row
+ * - or a single column value
+ * - or a sub value in a JSON column
+ */
+export type UpdatePathDesc<TTableDef extends TableDef = TableDef> =
+  | UpdatePathDescNone
+  | UpdatePathDescRow<TTableDef>
+  | UpdatePathDescColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
+  | UpdatePathDescCol<TTableDef, keyof TTableDef['sqliteDef']['columns']>
+
+export type UpdatePathDescNone = {
+  _tag: 'None'
+}
+
+export type UpdatePathDescRow<TTableDef extends TableDef> = {
+  _tag: 'Row'
+  table: TTableDef
+  id: string
+}
+
+export type UpdatePathDescCol<TTableDef extends TableDef, TColName extends keyof TTableDef['sqliteDef']['columns']> = {
+  _tag: 'Col'
+  table: TTableDef
+  id: string
+  column: TColName
+}
+
+export type UpdatePathDescColJsonValue<TTableDef extends TableDef, TColName extends GetJsonColumn<TTableDef>> = {
+  _tag: 'ColJsonValue'
+  table: TTableDef
+  id: string
+  column: TColName
+  /**
+   * example: `$.tabs[3].items[2]` (`$` referring to the column value)
+   */
+  jsonPath: string
+}
+
+type GetJsonColumn<TTableDef extends TableDef> = keyof {
+  [ColName in keyof TTableDef['sqliteDef']['columns'] as TTableDef['sqliteDef']['columns'][ColName]['columnType'] extends 'text'
+    ? ColName
+    : never]: {}
+}
+
+// type GetObjValues<TObj extends {}> = TObj[keyof TObj]
+
+export type UpdateValueForPath<TPath extends UpdatePathDesc> = TPath extends { _tag: 'Row' }
+  ? Partial<FromTable.RowDecodedAll<TPath['table']>>
+  : TPath extends { _tag: 'Col' }
+    ? Schema.Schema.To<TPath['table']['sqliteDef']['columns'][TPath['column']]['schema']>
+    : TPath extends { _tag: 'ColJsonValue' }
+      ? { TODO: true }
+      : never
+
+export const storeEventForUpdatePath = <TPath extends UpdatePathDesc>(
+  updatePath: TPath,
+  value: UpdateValueForPath<TPath>,
+): StoreEvent => {
+  if (updatePath._tag === 'ColJsonValue' || updatePath._tag === 'None') {
+    return notYetImplemented('TODO')
+  }
+
+  const sqliteTableDef = updatePath.table.sqliteDef
+  const id = updatePath.id
+
+  const { columnNames, bindValues } = (() => {
+    if (updatePath._tag === 'Row') {
+      const columnNames = Object.keys(value)
+
+      const partialStructSchema = updatePath.table.schema.pipe(Schema.pick(...columnNames))
+
+      // const columnNames = Object.keys(value)
+      const bindValues = Schema.encodeSync(partialStructSchema)(value)
+      return { columnNames, bindValues }
+    } else if (updatePath._tag === 'Col') {
+      const columnName = updatePath.column
+      const columnSchema =
+        sqliteTableDef.columns[columnName]?.schema ?? shouldNeverHappen(`Column ${columnName} not found`)
+      const bindValues = { [columnName]: Schema.encodeSync(columnSchema)(value) }
+      return { columnNames: [columnName], bindValues }
+    } else {
+      return shouldNeverHappen()
+    }
+  })()
+
+  const updateClause = columnNames.map((columnName) => `${columnName} = $${columnName}`).join(', ')
+
+  const whereClause = `where id = '${id}'`
+  const sql = `UPDATE ${sqliteTableDef.name} SET ${updateClause} ${whereClause}`
+  const writeTables = new Set<string>([updatePath.table.sqliteDef.name])
+
+  return { eventType: 'livestore.RawSql', args: { sql, bindValues, writeTables } }
+}
+
+type StoreEvent = { eventType: string; args: any }

package/src/utils/util.ts

@@ -2,6 +2,8 @@
 
 import type { Brand } from '@livestore/utils/effect'
 
+export type GetValForKey<T, K> = K extends keyof T ? T[K] : never
+
 export type ParamsObject = Record<string, SqlValue>
 export type SqlValue = string | number | Uint8Array | null