@livestore/common 0.3.0-dev.8 → 0.3.0

package/src/query-builder/impl.ts

@@ -1,285 +0,0 @@
-import { Option, Predicate, Schema } from '@livestore/utils/effect'
-
-import type { QueryInfo } from '../query-info.js'
-import type { DbSchema } from '../schema/mod.js'
-import type { QueryBuilder, QueryBuilderAst } from './api.js'
-import { QueryBuilderAstSymbol, TypeId } from './api.js'
-
-export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBase>(
-  tableDef: TTableDef,
-  ast: QueryBuilderAst = emptyAst(tableDef),
-): QueryBuilder<TResult, TTableDef, never, QueryInfo.None> => {
-  const api = {
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-    select() {
-      assertQueryBuilderAst(ast)
-
-      // eslint-disable-next-line prefer-rest-params
-      const params = [...arguments]
-
-      if (params.length === 2 && typeof params[0] === 'string' && typeof params[1] === 'object') {
-        const [col, options] = params as any as [string, { pluck: boolean }]
-        return makeQueryBuilder(tableDef, {
-          ...ast,
-          resultSchemaSingle: options.pluck ? ast.resultSchemaSingle.pipe(Schema.pluck(col)) : ast.resultSchemaSingle,
-          select: { columns: [col] },
-        })
-      }
-
-      const columns = params as unknown as ReadonlyArray<string>
-
-      return makeQueryBuilder(tableDef, {
-        ...ast,
-        resultSchemaSingle:
-          columns.length === 0 ? ast.resultSchemaSingle : ast.resultSchemaSingle.pipe(Schema.pick(...columns)),
-        select: { columns },
-      }) as any
-    },
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-    where() {
-      if (isRowQuery(ast)) return invalidQueryBuilder()
-
-      if (arguments.length === 1) {
-        // eslint-disable-next-line prefer-rest-params
-        const params = arguments[0]
-        const newOps = Object.entries(params)
-          .filter(([, value]) => value !== undefined)
-          .map<QueryBuilderAst.Where>(([col, value]) =>
-            Predicate.hasProperty(value, 'op') && Predicate.hasProperty(value, 'value')
-              ? ({ col, op: value.op, value: value.value } as any)
-              : { col, op: '=', value },
-          )
-
-        return makeQueryBuilder(tableDef, {
-          ...ast,
-          where: [...ast.where, ...newOps],
-        }) as any
-      }
-
-      // eslint-disable-next-line prefer-rest-params
-      const [col, opOrValue, valueOrUndefined] = arguments
-      const op = valueOrUndefined === undefined ? '=' : opOrValue
-      const value = valueOrUndefined === undefined ? opOrValue : valueOrUndefined
-      return makeQueryBuilder(tableDef, {
-        ...ast,
-        where: [...ast.where, { col, op, value }],
-      })
-    },
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-    orderBy() {
-      assertQueryBuilderAst(ast)
-
-      if (arguments.length === 0 || arguments.length > 2) return invalidQueryBuilder()
-
-      if (arguments.length === 1) {
-        // eslint-disable-next-line prefer-rest-params
-        const params = arguments[0] as QueryBuilder.OrderByParams<TTableDef>
-        return makeQueryBuilder(tableDef, {
-          ...ast,
-          orderBy: [...ast.orderBy, ...params],
-        })
-      }
-
-      // eslint-disable-next-line prefer-rest-params
-      const [col, direction] = arguments as any as [keyof TTableDef['sqliteDef']['columns'] & string, 'asc' | 'desc']
-
-      return makeQueryBuilder(tableDef, {
-        ...ast,
-        orderBy: [...ast.orderBy, { col, direction }],
-      }) as any
-    },
-    limit: (limit) => {
-      assertQueryBuilderAst(ast)
-
-      return makeQueryBuilder(tableDef, { ...ast, limit: Option.some(limit) })
-    },
-    offset: (offset) => {
-      assertQueryBuilderAst(ast)
-
-      return makeQueryBuilder(tableDef, { ...ast, offset: Option.some(offset) })
-    },
-    count: () => {
-      if (isRowQuery(ast)) return invalidQueryBuilder()
-
-      return makeQueryBuilder(tableDef, {
-        ...ast,
-        resultSchema: Schema.Struct({ count: Schema.Number }).pipe(
-          Schema.pluck('count'),
-          Schema.Array,
-          Schema.headOrElse(),
-        ),
-        _tag: 'CountQuery',
-      })
-    },
-    first: (options) => {
-      assertQueryBuilderAst(ast)
-
-      if (ast.limit._tag === 'Some') return invalidQueryBuilder(`.first() can't be called after .limit()`)
-
-      return makeQueryBuilder(tableDef, {
-        ...ast,
-        limit: Option.some(1),
-        // TODO improve
-        pickFirst: options?.fallback ? { fallback: options.fallback } : { fallback: () => undefined },
-      })
-    },
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-    row() {
-      // eslint-disable-next-line prefer-rest-params
-      const params = [...arguments]
-
-      let id: string
-
-      if (tableDef.options.isSingleton) {
-        id = tableDef.sqliteDef.columns.id!.default.pipe(Option.getOrThrow)
-      } else {
-        id = params[0] as string
-        if (id === undefined) {
-          invalidQueryBuilder(`Id missing for row query on non-singleton table ${tableDef.sqliteDef.name}`)
-        }
-      }
-
-      // TODO validate all required columns are present and values are matching the schema
-      const insertValues: Record<string, unknown> = params[1]?.insertValues ?? {}
-
-      return makeQueryBuilder(tableDef, {
-        _tag: 'RowQuery',
-        id,
-        tableDef,
-        insertValues,
-      }) as any
-    },
-  } satisfies QueryBuilder.ApiFull<TResult, TTableDef, never, QueryInfo.None>
-
-  return {
-    [TypeId]: TypeId,
-    [QueryBuilderAstSymbol]: ast,
-    asSql: () => astToSql(ast),
-    toString: () => {
-      try {
-        return astToSql(ast).query
-      } catch (cause) {
-        console.debug(`QueryBuilder.toString(): Error converting query builder to string`, cause, ast)
-        return `Error converting query builder to string`
-      }
-    },
-    ...api,
-  } satisfies QueryBuilder<TResult, TTableDef>
-}
-
-const emptyAst = (tableDef: DbSchema.TableDefBase) =>
-  ({
-    _tag: 'SelectQuery',
-    columns: [],
-    pickFirst: false,
-    select: { columns: [] },
-    orderBy: [],
-    offset: Option.none(),
-    limit: Option.none(),
-    tableDef,
-    where: [],
-    resultSchemaSingle: tableDef.schema,
-  }) satisfies QueryBuilderAst
-
-const astToSql = (ast: QueryBuilderAst) => {
-  if (isRowQuery(ast)) {
-    // TODO
-    return { query: `SELECT * FROM '${ast.tableDef.sqliteDef.name}' WHERE id = ?`, bindValues: [ast.id as TODO] }
-  }
-
-  const bindValues: unknown[] = []
-
-  // TODO bind values
-  const whereStmt =
-    ast.where.length > 0
-      ? `WHERE ${ast.where
-          .map(({ col, op, value }) => {
-            if (value === null) {
-              if (op !== '=' && op !== '!=') {
-                throw new Error(`Unsupported operator for NULL value: ${op}`)
-              }
-              const opStmt = op === '=' ? 'IS' : 'IS NOT'
-              return `${col} ${opStmt} NULL`
-            } else {
-              const colDef = ast.tableDef.sqliteDef.columns[col]
-              if (colDef === undefined) {
-                throw new Error(`Column ${col} not found`)
-              }
-              const isArray = op === 'IN' || op === 'NOT IN'
-              const colSchema = isArray ? Schema.Array(colDef.schema) : colDef.schema
-              const encodedValue = Schema.encodeSync(colSchema)(value)
-
-              if (isArray) {
-                bindValues.push(...encodedValue)
-                const placeholders = Array.from({ length: encodedValue.length }, () => '?').join(', ')
-                return `${col} ${op} (${placeholders})`
-              } else {
-                bindValues.push(encodedValue)
-                return `${col} ${op} ?`
-              }
-            }
-          })
-          .join(' AND ')}`
-      : ''
-
-  if (ast._tag === 'CountQuery') {
-    const selectFromStmt = `SELECT COUNT(*) as count FROM '${ast.tableDef.sqliteDef.name}'`
-    const query = [selectFromStmt, whereStmt].filter((_) => _.length > 0).join(' ')
-    return { query, bindValues }
-  }
-  const columnsStmt = ast.select.columns.length === 0 ? '*' : ast.select.columns.join(', ')
-  const selectStmt = `SELECT ${columnsStmt}`
-  const fromStmt = `FROM '${ast.tableDef.sqliteDef.name}'`
-
-  const orderByStmt =
-    ast.orderBy.length > 0
-      ? `ORDER BY ${ast.orderBy.map(({ col, direction }) => `${col} ${direction}`).join(', ')}`
-      : ''
-
-  const limitStmt = ast.limit._tag === 'Some' ? `LIMIT ?` : ''
-  if (ast.limit._tag === 'Some') bindValues.push(ast.limit.value)
-
-  const offsetStmt = ast.offset._tag === 'Some' ? `OFFSET ?` : ''
-  if (ast.offset._tag === 'Some') bindValues.push(ast.offset.value)
-
-  const query = [selectStmt, fromStmt, whereStmt, orderByStmt, offsetStmt, limitStmt]
-    .map((_) => _.trim())
-    .filter((_) => _.length > 0)
-    .join(' ')
-
-  // TODO bind values
-  return { query, bindValues }
-}
-
-// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-function assertQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.SelectQuery {
-  if (ast._tag !== 'SelectQuery') {
-    throw new Error('Expected SelectQuery but got ' + ast._tag)
-  }
-}
-
-const isRowQuery = (ast: QueryBuilderAst): ast is QueryBuilderAst.RowQuery => ast._tag === 'RowQuery'
-
-export const invalidQueryBuilder = (msg?: string) => {
-  throw new Error('Invalid query builder' + (msg ? `: ${msg}` : ''))
-}
-
-export const getResultSchema = (qb: QueryBuilder<any, any, any>) => {
-  const queryAst = qb[QueryBuilderAstSymbol]
-  if (queryAst._tag === 'SelectQuery') {
-    const arraySchema = Schema.Array(queryAst.resultSchemaSingle)
-    if (queryAst.pickFirst !== false) {
-      return arraySchema.pipe(Schema.headOrElse(queryAst.pickFirst.fallback))
-    }
-
-    return arraySchema
-  } else if (queryAst._tag === 'CountQuery') {
-    return Schema.Struct({ count: Schema.Number }).pipe(Schema.pluck('count'), Schema.Array, Schema.headOrElse())
-  } else {
-    if (queryAst.tableDef.options.isSingleColumn) {
-      return queryAst.tableDef.schema.pipe(Schema.pluck('value'), Schema.Array, Schema.headOrElse())
-    } else {
-      return queryAst.tableDef.schema.pipe(Schema.Array, Schema.headOrElse())
-    }
-  }
-}

package/src/query-info.ts

@@ -1,78 +0,0 @@
-import type { SessionIdSymbol } from './adapter-types.js'
-import type { DbSchema } from './schema/mod.js'
-
-/**
- * Semantic information about a query with supported cases being:
- * - a whole row
- * - a single column value
- * - a sub value in a JSON column
- *
- * This information is currently only used for derived mutations.
- */
-export type QueryInfo = QueryInfo.None | QueryInfo.Row | QueryInfo.Col | QueryInfo.ColJsonValue
-// export type QueryInfo<TTableDef extends DbSchema.TableDefBase = DbSchema.TableDefBase> =
-// | QueryInfo.None
-// | QueryInfo.Row<TTableDef>
-// | QueryInfo.ColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
-// | QueryInfo.Col<TTableDef, keyof TTableDef['sqliteDef']['columns']>
-
-export namespace QueryInfo {
-  export type None = {
-    _tag: 'None'
-  }
-
-  export type Row = {
-    _tag: 'Row'
-    table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol
-  }
-
-  export type Col = {
-    _tag: 'Col'
-    table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol
-    column: string
-  }
-
-  export type ColJsonValue = {
-    _tag: 'ColJsonValue'
-    table: DbSchema.TableDefBase
-    id: string | SessionIdSymbol
-    column: string
-    /**
-     * example: `$.tabs[3].items[2]` (`$` referring to the column value)
-     */
-    jsonPath: string
-  }
-
-  // NOTE maybe we want to bring back type-params back like below
-  // export type Row<TTableDef extends DbSchema.TableDefBase> = {
-  //   _tag: 'Row'
-  //   table: TTableDef
-  //   id: string | SessionIdSymbol
-  // }
-
-  // export type Col<TTableDef extends DbSchema.TableDefBase, TColName extends keyof TTableDef['sqliteDef']['columns']> = {
-  //   _tag: 'Col'
-  //   table: TTableDef
-  //   id: string | SessionIdSymbol
-  //   column: TColName
-  // }
-
-  // export type ColJsonValue<TTableDef extends DbSchema.TableDefBase, TColName extends GetJsonColumn<TTableDef>> = {
-  //   _tag: 'ColJsonValue'
-  //   table: TTableDef
-  //   id: string | SessionIdSymbol
-  //   column: TColName
-  //   /**
-  //    * example: `$.tabs[3].items[2]` (`$` referring to the column value)
-  //    */
-  //   jsonPath: string
-  // }
-}
-
-// type GetJsonColumn<TTableDef extends DbSchema.TableDefBase> = keyof {
-//   [ColName in keyof TTableDef['sqliteDef']['columns'] as TTableDef['sqliteDef']['columns'][ColName]['columnType'] extends 'text'
-//     ? ColName
-//     : never]: {}
-// }

package/src/rehydrate-from-mutationlog.ts

@@ -1,119 +0,0 @@
-import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
-import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
-
-import { type MigrationOptionsFromMutationLog, type SynchronousDatabase, UnexpectedError } from './adapter-types.js'
-import { makeApplyMutation } from './leader-thread/apply-mutation.js'
-import type { LiveStoreSchema, MutationDef, MutationEvent, MutationLogMetaRow } from './schema/mod.js'
-import { EventId, MUTATION_LOG_META_TABLE } from './schema/mod.js'
-import type { PreparedBindValues } from './util.js'
-import { sql } from './util.js'
-
-export const rehydrateFromMutationLog = ({
-  logDb,
-  // TODO re-use this db when bringing back the boot in-memory db implementation
-  // db,
-  schema,
-  migrationOptions,
-  onProgress,
-}: {
-  logDb: SynchronousDatabase
-  db: SynchronousDatabase
-  schema: LiveStoreSchema
-  migrationOptions: MigrationOptionsFromMutationLog
-  onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
-}) =>
-  Effect.gen(function* () {
-    const mutationsCount = logDb.select<{ count: number }>(
-      `SELECT COUNT(*) AS count FROM ${MUTATION_LOG_META_TABLE}`,
-    )[0]!.count
-
-    const hashMutation = memoizeByRef((mutation: MutationDef.Any) => Schema.hash(mutation.schema))
-
-    const applyMutation = yield* makeApplyMutation
-
-    const processMutation = (row: MutationLogMetaRow) =>
-      Effect.gen(function* () {
-        const mutationDef = schema.mutations.get(row.mutation) ?? shouldNeverHappen(`Unknown mutation ${row.mutation}`)
-
-        if (migrationOptions.excludeMutations?.has(row.mutation) === true) return
-
-        if (hashMutation(mutationDef) !== row.schemaHash) {
-          yield* Effect.logWarning(
-            `Schema hash mismatch for mutation ${row.mutation}. Trying to apply mutation anyway.`,
-          )
-        }
-
-        const args = JSON.parse(row.argsJson)
-
-        // Checking whether the schema has changed in an incompatible way
-        yield* Schema.decodeUnknown(mutationDef.schema)(args).pipe(
-          Effect.mapError((cause) =>
-            UnexpectedError.make({
-              cause,
-              note: `\
-There was an error during rehydrating from the mutation log while decoding
-the persisted mutation event args for mutation "${row.mutation}".
-This likely means the schema has changed in an incompatible way.
-`,
-            }),
-          ),
-        )
-
-        const mutationEventEncoded = {
-          id: { global: row.idGlobal, local: row.idLocal },
-          parentId: { global: row.parentIdGlobal, local: row.parentIdLocal },
-          mutation: row.mutation,
-          args,
-        } satisfies MutationEvent.AnyEncoded
-
-        yield* applyMutation(mutationEventEncoded, { skipMutationLog: true })
-      }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
-
-    const CHUNK_SIZE = 100
-
-    const stmt = logDb.prepare(sql`\
-SELECT * FROM ${MUTATION_LOG_META_TABLE} 
-WHERE idGlobal > $idGlobal OR (idGlobal = $idGlobal AND idLocal > $idLocal)
-ORDER BY idGlobal ASC, idLocal ASC
-LIMIT ${CHUNK_SIZE}
-`)
-
-    let processedMutations = 0
-
-    yield* Stream.unfoldChunk<Chunk.Chunk<MutationLogMetaRow> | { _tag: 'Initial ' }, MutationLogMetaRow>(
-      { _tag: 'Initial ' },
-      (item) => {
-        // End stream if no more rows
-        if (Chunk.isChunk(item) && item.length === 0) return Option.none()
-
-        const lastId = Chunk.isChunk(item)
-          ? Chunk.last(item).pipe(
-              Option.map((_) => ({ global: _.idGlobal, local: _.idLocal })),
-              Option.getOrElse(() => EventId.ROOT),
-            )
-          : EventId.ROOT
-        const nextItem = Chunk.fromIterable(
-          stmt.select<MutationLogMetaRow>({
-            $idGlobal: lastId?.global,
-            $idLocal: lastId?.local,
-          } as any as PreparedBindValues),
-        )
-        const prevItem = Chunk.isChunk(item) ? item : Chunk.empty()
-        return Option.some([prevItem, nextItem])
-      },
-    ).pipe(
-      Stream.bufferChunks({ capacity: 2 }),
-      Stream.tap((row) =>
-        Effect.gen(function* () {
-          yield* processMutation(row)
-
-          processedMutations++
-          yield* onProgress({ done: processedMutations, total: mutationsCount })
-        }),
-      ),
-      Stream.runDrain,
-    )
-  }).pipe(
-    Effect.withPerformanceMeasure('@livestore/common:rehydrateFromMutationLog'),
-    Effect.withSpan('@livestore/common:rehydrateFromMutationLog'),
-  )

package/src/schema/EventId.test.ts

@@ -1,12 +0,0 @@
-import { Vitest } from '@livestore/utils/node-vitest'
-import { expect } from 'vitest'
-
-import { EventId } from './mod.js'
-
-Vitest.describe('EventId', () => {
-  Vitest.test('nextPair', () => {
-    const e_0_0 = EventId.make({ global: 0, local: 0 })
-    expect(EventId.nextPair(e_0_0, false).id).toStrictEqual({ global: 1, local: 0 })
-    expect(EventId.nextPair(e_0_0, true).id).toStrictEqual({ global: 0, local: 1 })
-  })
-})

package/src/schema/EventId.ts

@@ -1,60 +0,0 @@
-import { Brand, Schema } from '@livestore/utils/effect'
-
-export type LocalEventId = Brand.Branded<number, 'LocalEventId'>
-export const localEventId = Brand.nominal<LocalEventId>()
-export const LocalEventId = Schema.fromBrand(localEventId)(Schema.Int)
-
-export type GlobalEventId = Brand.Branded<number, 'GlobalEventId'>
-export const globalEventId = Brand.nominal<GlobalEventId>()
-export const GlobalEventId = Schema.fromBrand(globalEventId)(Schema.Int)
-
-export const localDefault = 0 as any as LocalEventId
-
-/**
- * LiveStore event id value consisting of a globally unique event sequence number
- * and a local sequence number.
- *
- * The local sequence number is only used for localOnly mutations and starts from 0 for each global sequence number.
- */
-export type EventId = { global: GlobalEventId; local: LocalEventId }
-
-export const EventId = Schema.Struct({
-  global: GlobalEventId,
-  local: LocalEventId,
-}).annotations({ title: 'LiveStore.EventId' })
-
-/**
- * Compare two event ids i.e. checks if the first event id is less than the second.
- */
-export const compare = (a: EventId, b: EventId) => {
-  if (a.global !== b.global) {
-    return a.global - b.global
-  }
-  return a.local - b.local
-}
-
-export const isEqual = (a: EventId, b: EventId) => a.global === b.global && a.local === b.local
-
-export type EventIdPair = { id: EventId; parentId: EventId }
-
-export const ROOT = { global: -1 as any as GlobalEventId, local: localDefault } satisfies EventId
-
-export const isGreaterThan = (a: EventId, b: EventId) => {
-  return a.global > b.global || (a.global === b.global && a.local > b.local)
-}
-
-export const make = (id: EventId | typeof EventId.Encoded): EventId => {
-  return Schema.is(EventId)(id) ? id : Schema.decodeSync(EventId)(id)
-}
-
-export const nextPair = (id: EventId, isLocal: boolean): EventIdPair => {
-  if (isLocal) {
-    return { id: { global: id.global, local: (id.local + 1) as any as LocalEventId }, parentId: id }
-  }
-
-  return {
-    id: { global: (id.global + 1) as any as GlobalEventId, local: localDefault },
-    // NOTE we always point to `local: 0` for non-localOnly mutations
-    parentId: { global: id.global, local: localDefault },
-  }
-}