@livestore/common 0.0.42-dev.0

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

@@ -0,0 +1,335 @@
+import { pipe, ReadonlyArray, Schema } from '@livestore/utils/effect'
+import type { SqliteDsl } from 'effect-db-schema'
+
+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 keysStr = Object.keys(values).join(', ')
+  const valuesStr = Object.keys(values)
+    .map((_) => `$${_}`)
+    .join(', ')
+
+  return [
+    sql`INSERT ${options.orReplace ? 'OR REPLACE' : ''} INTO ${tableName} (${keysStr}) VALUES (${valuesStr})`,
+    makeBindValues({ columns, values }),
+  ]
+}
+
+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 string>({
+  columns,
+  values,
+  variablePrefix = '',
+  skipNil,
+}: {
+  columns: TColumns
+  values: 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') {
+          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]) => {
+        // 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}`,
+                codecMap[columnName]!(value),
+              ])
+            }
+            case '=':
+            case '>':
+            case '<': {
+              return [[`${variablePrefix}${columnName}`, codecMap[columnName]!(value.val)]]
+            }
+            default: {
+              throw new Error(`Unknown op: ${value.op}`)
+            }
+          }
+        } else {
+          return [[`${variablePrefix}${columnName}`, codecMap[columnName]!(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 'effect-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 { Schema } from '@livestore/utils/effect'
+import type { Prettify, SqliteDsl } from 'effect-db-schema'
+
+export type DecodedValuesForTableAll<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = {
+  [K in keyof GetColumns<TSchema, TTableName>]: Schema.Schema.To<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.To<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.To<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.From<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]: {}
+}
+
+export type PartialOrNull<T> = { [P in keyof T]?: T[P] | null }
+
+export type NullableObj<T> = { [P in keyof T]: T[P] | null }

package/src/util.ts

@@ -0,0 +1,46 @@
+/// <reference lib="es2022" />
+
+import type { Brand } from '@livestore/utils/effect'
+
+export type ParamsObject = Record<string, SqlValue>
+export type SqlValue = string | number | Uint8Array | null
+
+export type Bindable = SqlValue[] | ParamsObject
+
+export type PreparedBindValues = Brand.Branded<Bindable, 'PreparedBindValues'>
+
+/**
+ * This is a tag function for tagged literals.
+ * it lets us get syntax highlighting on SQL queries in VSCode, but
+ * doesn't do anything at runtime.
+ * Code copied from: https://esdiscuss.org/topic/string-identity-template-tag
+ */
+export const sql = (template: TemplateStringsArray, ...args: unknown[]): string => {
+  let str = ''
+
+  for (const [i, arg] of args.entries()) {
+    str += template[i] + String(arg)
+  }
+
+  // eslint-disable-next-line unicorn/prefer-at
+  return str + template[template.length - 1]
+}
+
+/** Prepare bind values to send to SQLite
+/*  Add $ to the beginning of keys; which we use as our interpolation syntax
+/*  We also strip out any params that aren't used in the statement,
+/*  because rusqlite doesn't allow unused named params
+/*  TODO: Search for unused params via proper parsing, not string search
+**/
+export const prepareBindValues = (values: Bindable, statement: string): PreparedBindValues => {
+  if (Array.isArray(values)) return values as PreparedBindValues
+
+  const result: ParamsObject = {}
+  for (const [key, value] of Object.entries(values)) {
+    if (statement.includes(key)) {
+      result[`$${key}`] = value
+    }
+  }
+
+  return result as PreparedBindValues
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "include": ["./src"],
+  "references": [{ "path": "../../effect-db-schema" }, { "path": "../utils" }]
+}