@livestore/common 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

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

@@ -0,0 +1,359 @@
+import type { SqliteDsl } from '@livestore/db-schema'
+import { shouldNeverHappen } from '@livestore/utils'
+import { pipe, ReadonlyArray, Schema, TreeFormatter } from '@livestore/utils/effect'
+
+import { sql } from '../util.js'
+import { objectEntries } from './misc.js'
+import * as ClientTypes from './types.js'
+
+export type BindValues = {
+  readonly [columnName: string]: any
+}
+
+export const findManyRows = <TColumns extends SqliteDsl.Columns>({
+  columns,
+  tableName,
+  where,
+  limit,
+}: {
+  tableName: string
+  columns: TColumns
+  where: ClientTypes.WhereValuesForColumns<TColumns>
+  limit?: number
+}): [string, BindValues] => {
+  const whereSql = buildWhereSql({ where })
+  const whereModifier = whereSql === '' ? '' : `WHERE ${whereSql}`
+  const limitModifier = limit ? `LIMIT ${limit}` : ''
+
+  const whereBindValues = makeBindValues({ columns, values: where, variablePrefix: 'where_', skipNil: true })
+
+  return [sql`SELECT * FROM ${tableName} ${whereModifier} ${limitModifier}`, whereBindValues]
+}
+
+export const countRows = <TColumns extends SqliteDsl.Columns>({
+  columns,
+  tableName,
+  where,
+}: {
+  tableName: string
+  columns: TColumns
+  where: ClientTypes.WhereValuesForColumns<TColumns>
+}): [string, BindValues] => {
+  const whereSql = buildWhereSql({ where })
+  const whereModifier = whereSql === '' ? '' : `WHERE ${whereSql}`
+
+  const whereBindValues = makeBindValues({ columns, values: where, variablePrefix: 'where_', skipNil: true })
+
+  return [sql`SELECT count(1) FROM ${tableName} ${whereModifier}`, whereBindValues]
+}
+
+export const insertRow = <TColumns extends SqliteDsl.Columns>({
+  tableName,
+  columns,
+  values,
+  options = { orReplace: false },
+}: {
+  tableName: string
+  columns: TColumns
+  values: ClientTypes.DecodedValuesForColumns<TColumns>
+  options?: { orReplace: boolean }
+}): [string, BindValues] => {
+  const stmt = insertRowPrepared({ tableName, columns, options })
+
+  return [stmt, makeBindValues({ columns, values })]
+}
+
+export const insertRowPrepared = <TColumns extends SqliteDsl.Columns>({
+  tableName,
+  columns,
+  options = { orReplace: false },
+}: {
+  tableName: string
+  columns: TColumns
+  options?: { orReplace: boolean }
+}): string => {
+  const keysStr = Object.keys(columns).join(', ')
+  const valuesStr = Object.keys(columns)
+    .map((key) => `$${key}`)
+    .join(', ')
+
+  return sql`INSERT ${options.orReplace ? 'OR REPLACE ' : ''}INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`
+}
+
+export const insertRows = <TColumns extends SqliteDsl.Columns>({
+  columns,
+  tableName,
+  valuesArray,
+}: {
+  tableName: string
+  columns: TColumns
+  valuesArray: ClientTypes.DecodedValuesForColumns<TColumns>[]
+}): [string, BindValues] => {
+  const keysStr = Object.keys(valuesArray[0]!).join(', ')
+
+  // NOTE consider batching for large arrays (https://sqlite.org/forum/info/f832398c19d30a4a)
+  const valuesStrs = valuesArray
+    .map((values, itemIndex) =>
+      Object.keys(values)
+        .map((_) => `$item_${itemIndex}_${_}`)
+        .join(', '),
+    )
+    .map((_) => `(${_})`)
+    .join(', ')
+
+  const bindValues = valuesArray.reduce(
+    (acc, values, itemIndex) => ({
+      ...acc,
+      ...makeBindValues({ columns, values, variablePrefix: `item_${itemIndex}_` }),
+    }),
+    {},
+  )
+
+  return [sql`INSERT INTO ${tableName} (${keysStr}) VALUES ${valuesStrs}`, bindValues]
+}
+
+export const insertOrIgnoreRow = <TColumns extends SqliteDsl.Columns>({
+  columns,
+  tableName,
+  values: values_,
+  returnRow,
+}: {
+  tableName: string
+  columns: TColumns
+  values: ClientTypes.DecodedValuesForColumns<TColumns>
+  returnRow: boolean
+}): [string, BindValues] => {
+  const values = filterUndefinedFields(values_)
+  const keysStr = Object.keys(values).join(', ')
+  const valuesStr = Object.keys(values)
+    .map((_) => `$${_}`)
+    .join(', ')
+
+  const bindValues = makeBindValues({ columns, values })
+  const returningStmt = returnRow ? 'RETURNING *' : ''
+
+  return [sql`INSERT OR IGNORE INTO ${tableName} (${keysStr}) VALUES (${valuesStr}) ${returningStmt}`, bindValues]
+}
+
+export const updateRows = <TColumns extends SqliteDsl.Columns>({
+  columns,
+  tableName,
+  updateValues: updateValues_,
+  where,
+}: {
+  columns: TColumns
+  tableName: string
+  updateValues: Partial<ClientTypes.DecodedValuesForColumnsAll<TColumns>>
+  where: ClientTypes.WhereValuesForColumns<TColumns>
+}): [string, BindValues] => {
+  const updateValues = filterUndefinedFields(updateValues_)
+
+  // TODO return an Option instead of `select 1` if there are no update values
+  if (Object.keys(updateValues).length === 0) {
+    return [sql`select 1`, {}]
+  }
+
+  const updateValueStr = Object.keys(updateValues)
+    .map((columnName) => `${columnName} = $update_${columnName}`)
+    .join(', ')
+
+  const bindValues = {
+    ...makeBindValues({ columns, values: updateValues, variablePrefix: 'update_' }),
+    ...makeBindValues({ columns, values: where, variablePrefix: 'where_', skipNil: true }),
+  }
+
+  const whereSql = buildWhereSql({ where })
+  const whereModifier = whereSql === '' ? '' : `WHERE ${whereSql}`
+
+  return [sql`UPDATE ${tableName} SET ${updateValueStr} ${whereModifier}`, bindValues]
+}
+
+export const deleteRows = <TColumns extends SqliteDsl.Columns>({
+  columns,
+  tableName,
+  where,
+}: {
+  columns: TColumns
+  tableName: string
+  where: ClientTypes.WhereValuesForColumns<TColumns>
+}): [string, BindValues] => {
+  const bindValues = {
+    ...makeBindValues({ columns, values: where, variablePrefix: 'where_', skipNil: true }),
+  }
+
+  const whereSql = buildWhereSql({ where })
+  const whereModifier = whereSql === '' ? '' : `WHERE ${whereSql}`
+
+  return [sql`DELETE FROM ${tableName} ${whereModifier}`, bindValues]
+}
+
+export const upsertRow = <TColumns extends SqliteDsl.Columns>({
+  tableName,
+  columns,
+  createValues: createValues_,
+  updateValues: updateValues_,
+  where,
+}: {
+  tableName: string
+  columns: TColumns
+  createValues: ClientTypes.DecodedValuesForColumns<TColumns>
+  updateValues: Partial<ClientTypes.DecodedValuesForColumnsAll<TColumns>>
+  // TODO where VALUES are actually not used here. Maybe adjust API?
+  where: ClientTypes.WhereValuesForColumns<TColumns>
+}): [string, BindValues] => {
+  const createValues = filterUndefinedFields(createValues_)
+  const updateValues = filterUndefinedFields(updateValues_)
+
+  const keysStr = Object.keys(createValues).join(', ')
+
+  const createValuesStr = Object.keys(createValues)
+    .map((_) => `$create_${_}`)
+    .join(', ')
+
+  const conflictStr = Object.keys(where).join(', ')
+
+  const updateValueStr = Object.keys(updateValues)
+    .map((columnName) => `${columnName} = $update_${columnName}`)
+    .join(', ')
+
+  const bindValues = {
+    ...makeBindValues({ columns, values: createValues, variablePrefix: 'create_' }),
+    ...makeBindValues({ columns, values: updateValues, variablePrefix: 'update_' }),
+  }
+
+  return [
+    sql`
+      INSERT INTO ${tableName} (${keysStr})
+       VALUES (${createValuesStr})
+       ON CONFLICT (${conflictStr}) DO UPDATE SET ${updateValueStr}
+    `,
+    bindValues,
+  ]
+}
+
+export const createTable = ({
+  table,
+  tableName,
+}: {
+  table: SqliteDsl.TableDefinition<any, SqliteDsl.Columns>
+  tableName: string
+}): string => {
+  const primaryKeys = Object.entries(table.columns)
+    .filter(([_, columnDef]) => columnDef.primaryKey)
+    .map(([columnName, _]) => columnName)
+  const columnDefStrs = Object.entries(table.columns).map(([columnName, columnDef]) => {
+    const nullModifier = columnDef.nullable === true ? '' : 'NOT NULL'
+    const defaultModifier = columnDef.default._tag === 'None' ? '' : `DEFAULT ${columnDef.default.value}`
+    return sql`${columnName} ${columnDef.columnType} ${nullModifier} ${defaultModifier}`
+  })
+
+  if (primaryKeys.length > 0) {
+    columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
+  }
+
+  return sql`CREATE TABLE ${tableName} (${columnDefStrs.join(', ')});`
+}
+
+export const makeBindValues = <TColumns extends SqliteDsl.Columns, TKeys extends keyof TColumns>({
+  columns,
+  values,
+  variablePrefix = '',
+  skipNil,
+}: {
+  columns: TColumns
+  values: Partial<Record<TKeys, any>>
+  variablePrefix?: string
+  /** So far only used to prepare `where` statements */
+  skipNil?: boolean
+}): Record<string, any> => {
+  const codecMap = pipe(
+    columns,
+    objectEntries,
+    ReadonlyArray.map(([columnName, columnDef]) => [
+      columnName,
+      (value: any) => {
+        if (columnDef.nullable === true && (value === null || value === undefined)) return null
+        const res = Schema.encodeEither(columnDef.schema)(value)
+        if (res._tag === 'Left') {
+          const parseErrorStr = TreeFormatter.formatErrorSync(res.left)
+          const expectedSchemaStr = String(columnDef.schema.ast)
+
+          console.error(
+            `\
+Error making bind values for SQL query for column "${columnName}".
+
+Expected schema: ${expectedSchemaStr}
+
+Error: ${parseErrorStr}
+
+Value:`,
+            value,
+          )
+          debugger
+          throw res.left
+        } else {
+          return res.right
+        }
+      },
+    ]),
+    Object.fromEntries,
+  )
+
+  return pipe(
+    Object.entries(values)
+      // NOTE null/undefined values are handled via explicit SQL syntax and don't need to be provided as bind values
+      .filter(([, value]) => skipNil !== true || (value !== null && value !== undefined))
+      .flatMap(([columnName, value]: [string, any]) => {
+        const codec = codecMap[columnName] ?? shouldNeverHappen(`No codec found for column "${columnName}"`)
+        // remap complex where-values with `op`
+        if (typeof value === 'object' && value !== null && 'op' in value) {
+          switch (value.op) {
+            case 'in': {
+              return value.val.map((value: any, i: number) => [`${variablePrefix}${columnName}_${i}`, codec(value)])
+            }
+            case '=':
+            case '>':
+            case '<': {
+              return [[`${variablePrefix}${columnName}`, codec(value.val)]]
+            }
+            default: {
+              throw new Error(`Unknown op: ${value.op}`)
+            }
+          }
+        } else {
+          return [[`${variablePrefix}${columnName}`, codec(value)]]
+        }
+      }),
+    Object.fromEntries,
+  )
+}
+
+const buildWhereSql = <TColumns extends SqliteDsl.Columns>({
+  where,
+}: {
+  where: ClientTypes.WhereValuesForColumns<TColumns>
+}) => {
+  const getWhereOp = (columnName: string, value: ClientTypes.WhereValueForDecoded<any>) => {
+    if (value === null) {
+      return `IS NULL`
+    } else if (typeof value === 'object' && typeof value.op === 'string' && ClientTypes.isValidWhereOp(value.op)) {
+      return `${value.op} $where_${columnName}`
+    } else if (typeof value === 'object' && typeof value.op === 'string' && value.op === 'in') {
+      return `in (${value.val.map((_: any, i: number) => `$where_${columnName}_${i}`).join(', ')})`
+    } else {
+      return `= $where_${columnName}`
+    }
+  }
+
+  return pipe(
+    where,
+    objectEntries,
+    ReadonlyArray.map(([columnName, value]) => `${columnName} ${getWhereOp(columnName, value)}`),
+    ReadonlyArray.join(' AND '),
+  )
+}
+
+// TODO better typing
+const filterUndefinedFields = <T extends Record<string, any>>(obj: T): T => {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined)) as T
+}

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

@@ -0,0 +1,135 @@
+import type { SqliteDsl } from '@livestore/db-schema'
+
+import type { BindValues } from './sql-queries.js'
+import * as SqlQueries from './sql-queries.js'
+import type * as ClientTypes from './types.js'
+
+export type SqlQuery = [stmt: string, bindValues: BindValues, tableName: string]
+
+export const makeSqlQueryBuilder = <TSchema extends SqliteDsl.DbSchema>(schema: TSchema) => {
+  const findManyRows = <TTableName extends keyof TSchema & string>({
+    tableName,
+    where,
+    limit,
+  }: {
+    tableName: TTableName
+    where: ClientTypes.WhereValuesForTable<TSchema, TTableName>
+    limit?: number
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.findManyRows({ columns, tableName, where, limit })
+    return [stmt, bindValues, tableName]
+  }
+
+  const countRows = <TTableName extends keyof TSchema & string>({
+    tableName,
+    where,
+  }: {
+    tableName: TTableName
+    where: ClientTypes.WhereValuesForTable<TSchema, TTableName>
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.countRows({ columns, tableName, where })
+    return [stmt, bindValues, tableName]
+  }
+
+  const insertRow = <TTableName extends keyof TSchema & string>({
+    tableName,
+    values,
+    options = { orReplace: false },
+  }: {
+    tableName: TTableName
+    values: ClientTypes.DecodedValuesForTable<TSchema, TTableName>
+    options?: { orReplace: boolean }
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.insertRow({ columns, tableName, values, options })
+    return [stmt, bindValues, tableName]
+  }
+
+  const insertRows = <TTableName extends keyof TSchema & string>({
+    tableName,
+    valuesArray,
+  }: {
+    tableName: TTableName
+    valuesArray: ClientTypes.DecodedValuesForTable<TSchema, TTableName>[]
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.insertRows({ columns, tableName, valuesArray })
+    return [stmt, bindValues, tableName]
+  }
+
+  const insertOrIgnoreRow = <TTableName extends keyof TSchema & string>({
+    tableName,
+    values,
+    returnRow = false,
+  }: {
+    tableName: TTableName
+    values: ClientTypes.DecodedValuesForTable<TSchema, TTableName>
+    returnRow?: boolean
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.insertOrIgnoreRow({ columns, tableName, values, returnRow })
+    return [stmt, bindValues, tableName]
+  }
+
+  const updateRows = <TTableName extends keyof TSchema & string>({
+    tableName,
+    updateValues,
+    where,
+  }: {
+    tableName: TTableName
+    updateValues: Partial<ClientTypes.DecodedValuesForTableAll<TSchema, TTableName>>
+    where: ClientTypes.WhereValuesForTable<TSchema, TTableName>
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.updateRows({ columns, tableName, updateValues, where })
+    return [stmt, bindValues, tableName]
+  }
+
+  const deleteRows = <TTableName extends keyof TSchema & string>({
+    tableName,
+    where,
+  }: {
+    tableName: TTableName
+    where: ClientTypes.WhereValuesForTable<TSchema, TTableName>
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.deleteRows({ columns, tableName, where })
+    return [stmt, bindValues, tableName]
+  }
+
+  const upsertRow = <TTableName extends keyof TSchema & string>({
+    tableName,
+    createValues,
+    updateValues,
+    where,
+  }: {
+    tableName: TTableName
+    createValues: ClientTypes.DecodedValuesForTable<TSchema, TTableName>
+    updateValues: Partial<ClientTypes.DecodedValuesForTableAll<TSchema, TTableName>>
+    // TODO where VALUES are actually not used here. Maybe adjust API?
+    where: ClientTypes.WhereValuesForTable<TSchema, TTableName>
+  }): [string, BindValues, TTableName] => {
+    const columns = schema[tableName]!.columns
+    const [stmt, bindValues] = SqlQueries.upsertRow({
+      columns,
+      tableName,
+      createValues: createValues as any, // TODO investigate why types don't match
+      updateValues,
+      where,
+    })
+    return [stmt, bindValues, tableName]
+  }
+
+  return {
+    findManyRows,
+    countRows,
+    insertRow,
+    insertRows,
+    insertOrIgnoreRow,
+    updateRows,
+    deleteRows,
+    upsertRow,
+  }
+}

package/src/sql-queries/types.ts

@@ -0,0 +1,97 @@
+import type { Prettify, SqliteDsl } from '@livestore/db-schema'
+import type { Schema } from '@livestore/utils/effect'
+
+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']>
+}
+
+export type DecodedValuesForTablePretty<
+  TSchema extends SqliteDsl.DbSchema,
+  TTableName extends keyof TSchema,
+> = Prettify<DecodedValuesForTable<TSchema, TTableName>>
+
+export type DecodedValuesForTable<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = Partial<
+  Pick<DecodedValuesForTableAll<TSchema, TTableName>, GetNullableColumnNamesForTable<TSchema, TTableName>>
+> &
+  Omit<DecodedValuesForTableAll<TSchema, TTableName>, GetNullableColumnNamesForTable<TSchema, TTableName>>
+
+export type DecodedValuesForTableOrNull<
+  TSchema extends SqliteDsl.DbSchema,
+  TTableName extends keyof TSchema,
+> = NullableObj<
+  Pick<DecodedValuesForTableAll<TSchema, TTableName>, GetNullableColumnNamesForTable<TSchema, TTableName>>
+> &
+  Omit<DecodedValuesForTableAll<TSchema, TTableName>, GetNullableColumnNamesForTable<TSchema, TTableName>>
+
+export type WhereValuesForTable<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = PartialOrNull<{
+  [K in keyof DecodedValuesForTableAll<TSchema, TTableName>]: WhereValueForDecoded<
+    DecodedValuesForTableAll<TSchema, TTableName>[K]
+  >
+}>
+
+export type WhereValueForDecoded<TDecoded> = TDecoded | { op: WhereOp; val: TDecoded } | { op: 'in'; val: TDecoded[] }
+export type WhereOp = '>' | '<' | '='
+
+export const isValidWhereOp = (op: string): op is WhereOp => {
+  const validWhereOps = ['>', '<', '=']
+  return validWhereOps.includes(op)
+}
+
+export type EncodedValuesForTableAll<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = {
+  [K in keyof GetColumns<TSchema, TTableName>]: Schema.Schema.Type<GetColumn<TSchema, TTableName, K>['schema']>
+}
+
+export type EncodedValuesForTable<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = Partial<
+  Pick<EncodedValuesForTableAll<TSchema, TTableName>, GetNullableColumnNamesForTable<TSchema, TTableName>>
+> &
+  Omit<EncodedValuesForTableAll<TSchema, TTableName>, GetNullableColumnNamesForTable<TSchema, TTableName>>
+
+export type GetNullableColumnNamesForTable<
+  TSchema extends SqliteDsl.DbSchema,
+  TTableName extends keyof TSchema,
+> = keyof {
+  [K in keyof GetColumns<TSchema, TTableName> as GetColumn<TSchema, TTableName, K>['nullable'] extends true
+    ? K
+    : never]: {}
+}
+
+export type GetColumns<
+  TSchema extends SqliteDsl.DbSchema,
+  TTableName extends keyof TSchema,
+> = TSchema[TTableName]['columns']
+
+export type GetColumn<
+  TSchema extends SqliteDsl.DbSchema,
+  TTableName extends keyof TSchema,
+  TColumnName extends keyof TSchema[TTableName]['columns'],
+> = TSchema[TTableName]['columns'][TColumnName]
+
+export type DecodedValuesForColumnsAll<TColumns extends SqliteDsl.Columns> = {
+  [K in keyof TColumns]: Schema.Schema.Type<TColumns[K]['schema']>
+}
+
+export type DecodedValuesForColumns<TColumns extends SqliteDsl.Columns> = Partial<
+  Pick<DecodedValuesForColumnsAll<TColumns>, GetNullableColumnNames<TColumns>>
+> &
+  Omit<DecodedValuesForColumnsAll<TColumns>, GetNullableColumnNames<TColumns>>
+
+export type EncodedValuesForColumnsAll<TColumns extends SqliteDsl.Columns> = {
+  [K in keyof TColumns]: Schema.Schema.Encoded<TColumns[K]['schema']>
+}
+
+export type EncodedValuesForColumns<TColumns extends SqliteDsl.Columns> = Partial<
+  Pick<EncodedValuesForColumnsAll<TColumns>, GetNullableColumnNames<TColumns>>
+> &
+  Omit<EncodedValuesForColumnsAll<TColumns>, GetNullableColumnNames<TColumns>>
+
+export type WhereValuesForColumns<TColumns extends SqliteDsl.Columns> = PartialOrNull<{
+  [K in keyof EncodedValuesForColumns<TColumns>]: WhereValueForDecoded<DecodedValuesForColumnsAll<TColumns>[K]>
+}>
+
+export type GetNullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
+  [K in keyof TColumns as TColumns[K] extends SqliteDsl.ColumnDefinition<any, true> ? K : never]: unknown
+}
+
+export type PartialOrNull<T> = { [P in keyof T]?: T[P] | null }
+
+export type NullableObj<T> = { [P in keyof T]: T[P] | null }

package/src/sync/index.ts

@@ -0,0 +1 @@
+export * from './sync.js'

package/src/sync/next/ambient.d.ts

@@ -0,0 +1,3 @@
+declare module 'graphology' {
+  export * from 'graphology-types'
+}