@livestore/common 0.0.42-dev.0

package/src/schema/index.ts

@@ -0,0 +1,100 @@
+import { isReadonlyArray } from '@livestore/utils'
+import type { ReadonlyArray } from '@livestore/utils/effect'
+import type { SqliteDsl } from 'effect-db-schema'
+
+import {
+  type MutationDef,
+  type MutationDefMap,
+  type MutationDefRecord,
+  type RawSqlMutation,
+  rawSqlMutation,
+} from './mutations.js'
+import { systemTables } from './system-tables.js'
+import type { TableDef } from './table-def.js'
+
+export * from './system-tables.js'
+export * as DbSchema from './table-def.js'
+export * as ParseUtils from './parse-utils.js'
+export * from './mutations.js'
+
+export type LiveStoreSchema<
+  TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema,
+  TMutationsDefRecord extends MutationDefRecord = MutationDefRecord,
+> = {
+  /** Only used on type-level */
+  readonly _DbSchemaType: TDbSchema
+  /** Only used on type-level */
+  readonly _MutationDefMapType: TMutationsDefRecord
+
+  readonly tables: Map<string, TableDef>
+  readonly mutations: MutationDefMap
+}
+
+export type InputSchema = {
+  readonly tables: Record<string, TableDef> | ReadonlyArray<TableDef>
+  readonly mutations?: ReadonlyArray<MutationDef.Any> | Record<string, MutationDef.Any>
+}
+
+export const makeSchema = <TInputSchema extends InputSchema>(
+  /** Note when using the object-notation for tables/mutations, the object keys are ignored and not used as table/mutation names */
+  schema: TInputSchema,
+): LiveStoreSchema<
+  DbSchemaFromInputSchemaTables<TInputSchema['tables']>,
+  MutationDefRecordFromInputSchemaMutations<TInputSchema['mutations']>
+> => {
+  const inputTables: ReadonlyArray<TableDef> = Array.isArray(schema.tables)
+    ? schema.tables
+    : // TODO validate that table names are unique in this case
+      Object.values(schema.tables)
+
+  const tables = new Map<string, TableDef>()
+
+  for (const tableDef of inputTables) {
+    // TODO validate tables (e.g. index names are unique)
+    tables.set(tableDef.sqliteDef.ast.name, tableDef)
+  }
+
+  for (const tableDef of systemTables) {
+    tables.set(tableDef.sqliteDef.name, tableDef)
+  }
+
+  const mutations: MutationDefMap = new Map()
+
+  if (isReadonlyArray(schema.mutations)) {
+    for (const mutation of schema.mutations) {
+      mutations.set(mutation.name, mutation)
+    }
+  } else {
+    for (const [name, mutation] of Object.entries(schema.mutations ?? {})) {
+      mutations.set(name, mutation)
+    }
+  }
+
+  mutations.set('livestore.RawSql', rawSqlMutation)
+
+  return {
+    _DbSchemaType: Symbol('livestore.DbSchemaType') as any,
+    _MutationDefMapType: Symbol('livestore.MutationDefMapType') as any,
+    tables,
+    mutations,
+  } satisfies LiveStoreSchema
+}
+
+/**
+ * In case of ...
+ * - array: we use the table name of each array item (= table definition) as the object key
+ * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
+ */
+export type DbSchemaFromInputSchemaTables<TTables extends InputSchema['tables']> =
+  TTables extends ReadonlyArray<TableDef>
+    ? { [K in TTables[number] as K['sqliteDef']['name']]: K['sqliteDef'] }
+    : TTables extends Record<string, TableDef>
+      ? { [K in keyof TTables as TTables[K]['sqliteDef']['name']]: TTables[K]['sqliteDef'] }
+      : never
+
+export type MutationDefRecordFromInputSchemaMutations<TMutations extends InputSchema['mutations']> =
+  TMutations extends ReadonlyArray<MutationDef.Any>
+    ? { [K in TMutations[number] as K['name']]: K } & { 'livestore.RawSql': RawSqlMutation }
+    : TMutations extends { [name: string]: MutationDef.Any }
+      ? { [K in keyof TMutations as TMutations[K]['name']]: TMutations[K] } & { 'livestore.RawSql': RawSqlMutation }
+      : never

package/src/schema/mutations.ts

@@ -0,0 +1,128 @@
+import { cuid } from '@livestore/utils/cuid'
+import { Schema } from '@livestore/utils/effect'
+
+import type { BindValues } from '../sql-queries/sql-queries.js'
+import type { LiveStoreSchema } from './index.js'
+
+export type MutationDefMap = Map<string | 'livestore.RawSql', MutationDef.Any>
+export type MutationDefRecord = {
+  'livestore.RawSql': RawSqlMutation
+  [name: string]: MutationDef.Any
+}
+
+export type InternalMutationSchema<TRecord extends MutationDefRecord = MutationDefRecord> = {
+  _DefRecord: TRecord
+
+  map: Map<keyof TRecord, TRecord[keyof TRecord]>
+  schemaHashMap: Map<keyof TRecord, number>
+}
+
+export type MutationDef<TName extends string, TFrom, TTo> = {
+  name: TName
+  schema: Schema.Schema<TTo, TFrom>
+  sql:
+    | string
+    | ((args: TTo) =>
+        | string
+        | {
+            sql: string
+            /** Note args need to be manually encoded to `BindValues` when returning this argument */
+            bindValues: BindValues
+            writeTables?: ReadonlySet<string>
+          })
+
+  /** Helper function to construct mutation event */
+  (args: TTo): { mutation: TName; args: TTo; id: string }
+}
+
+export namespace MutationDef {
+  export type Any = MutationDef<string, any, any>
+}
+
+// TODO possibly also allow for mutation event subsumption behaviour
+export const defineMutation = <TName extends string, TFrom, TTo>(
+  name: TName,
+  schema: Schema.Schema<TTo, TFrom>,
+  sql: string | ((args: TTo) => string | { sql: string; bindValues: BindValues; writeTables?: ReadonlySet<string> }),
+): MutationDef<TName, TFrom, TTo> => {
+  const makeEvent = (args: TTo) => ({ mutation: name, args, id: cuid() })
+
+  Object.defineProperty(makeEvent, 'name', { value: name })
+  Object.defineProperty(makeEvent, 'schema', { value: schema })
+  Object.defineProperty(makeEvent, 'sql', { value: sql })
+
+  return makeEvent as MutationDef<TName, TFrom, TTo>
+}
+
+export const makeMutationDefRecord = <TInputRecord extends Record<string, MutationDef.Any>>(
+  inputRecord: TInputRecord,
+): {
+  [K in TInputRecord[keyof TInputRecord]['name']]: Extract<TInputRecord[keyof TInputRecord], { name: K }>
+} => {
+  const result: any = {}
+
+  for (const [name, def] of Object.entries(inputRecord)) {
+    result[name] = def
+  }
+
+  result['livestore.RawSql'] = rawSqlMutation
+
+  return result
+}
+
+export const rawSqlMutation = defineMutation(
+  'livestore.RawSql',
+  Schema.struct({
+    sql: Schema.string,
+    bindValues: Schema.optional(Schema.record(Schema.string, Schema.any)),
+    writeTables: Schema.optional(Schema.readonlySet(Schema.string)),
+  }),
+  ({ sql, bindValues, writeTables }) => ({ sql, bindValues: bindValues ?? {}, writeTables }),
+)
+
+export type RawSqlMutation = typeof rawSqlMutation
+export type RawSqlMutationEvent = ReturnType<typeof rawSqlMutation>
+
+export type MutationEvent<TMutationsDef extends MutationDef.Any> = {
+  mutation: TMutationsDef['name']
+  args: Schema.Schema.To<TMutationsDef['schema']>
+  id: string
+}
+
+export namespace MutationEvent {
+  export type Any = MutationEvent<MutationDef.Any>
+
+  export type ForSchema<TSchema extends LiveStoreSchema> = {
+    [K in keyof TSchema['_MutationDefMapType']]: MutationEvent<TSchema['_MutationDefMapType'][K]>
+  }[keyof TSchema['_MutationDefMapType']]
+}
+
+export type MutationEventSchema<TMutationsDefRecord extends MutationDefRecord> = Schema.Schema<
+  {
+    [K in keyof TMutationsDefRecord]: {
+      mutation: K
+      args: Schema.Schema.To<TMutationsDefRecord[K]['schema']>
+      id: string
+    }
+  }[keyof TMutationsDefRecord],
+  {
+    [K in keyof TMutationsDefRecord]: {
+      mutation: K
+      args: Schema.Schema.From<TMutationsDefRecord[K]['schema']>
+      id: string
+    }
+  }[keyof TMutationsDefRecord]
+>
+
+export const makeMutationEventSchema = <TMutationsDefRecord extends MutationDefRecord>(
+  mutationDefRecord: TMutationsDefRecord,
+): MutationEventSchema<TMutationsDefRecord> =>
+  Schema.union(
+    ...Object.values(mutationDefRecord).map((def) =>
+      Schema.struct({
+        mutation: Schema.literal(def.name),
+        args: def.schema,
+        id: Schema.string,
+      }),
+    ),
+  ) as any

package/src/schema/parse-utils.ts

@@ -0,0 +1,42 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import type { ReadonlyArray } from '@livestore/utils/effect'
+import { pipe, ReadonlyRecord, Schema, TreeFormatter } from '@livestore/utils/effect'
+import { SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+
+import { type FromColumns, type FromTable, getDefaultValuesDecoded, type TableDef } from './table-def.js'
+
+export const many = <TTableDef extends TableDef>(
+  table: TTableDef,
+): ((rawRows: ReadonlyArray<any>) => ReadonlyArray<FromTable.RowDecoded<TTableDef>>) => {
+  return Schema.decodeSync(Schema.array(table.schema)) as TODO
+}
+
+export const first =
+  <TTableDef extends TableDef>(
+    table: TTableDef,
+    fallback?: FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>,
+  ) =>
+  (rawRows: ReadonlyArray<any>) => {
+    const rows = Schema.decodeSync(Schema.array(table.schema))(rawRows)
+
+    if (rows.length === 0) {
+      const schemaDefaultValues = getDefaultValuesDecoded(table)
+
+      const defaultValuesResult = pipe(
+        table.sqliteDef.columns,
+        ReadonlyRecord.map((_column, columnName) => (fallback as any)?.[columnName] ?? schemaDefaultValues[columnName]),
+        Schema.validateEither(table.schema),
+      )
+
+      if (defaultValuesResult._tag === 'Right') {
+        return defaultValuesResult.right
+      } else {
+        console.error('decode error', TreeFormatter.formatError(defaultValuesResult.left))
+        return shouldNeverHappen(
+          `Expected query (for table ${table.sqliteDef.name}) to return at least one result but found none. Also can't fallback to default values as some were not provided.`,
+        )
+      }
+    }
+
+    return rows[0]!
+  }

package/src/schema/system-tables.ts

@@ -0,0 +1,22 @@
+// import { Schema as __Schema } from '@livestore/utils/effect'
+import { type SqliteAst as __SqliteAst, SqliteDsl } from 'effect-db-schema'
+
+import type { FromTable } from './table-def.js'
+import { table } from './table-def.js'
+
+export const SCHEMA_META_TABLE = '__livestore_schema'
+
+const schemaMetaTable = table(
+  SCHEMA_META_TABLE,
+  {
+    tableName: SqliteDsl.text({ primaryKey: true }),
+    schemaHash: SqliteDsl.integer({ nullable: false }),
+    /** ISO date format */
+    updatedAt: SqliteDsl.text({ nullable: false }),
+  },
+  { disableAutomaticIdColumn: true },
+)
+
+export type SchemaMetaRow = FromTable.RowDecoded<typeof schemaMetaTable>
+
+export const systemTables = [schemaMetaTable]

package/src/schema/table-def.ts

@@ -0,0 +1,274 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
+import type { Nullable, PrettifyFlat } from 'effect-db-schema'
+import { SqliteDsl } from 'effect-db-schema'
+
+export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
+
+export { type SqliteDsl } from 'effect-db-schema'
+
+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> }
+
+// /**
+//  * 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<
+  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.To<TSqliteDef['columns'][K]['schema']> }
+    >,
+    SqliteDsl.AnyIfConstained<
+      TSqliteDef['columns'],
+      { readonly [K in keyof TSqliteDef['columns']]: Schema.Schema.From<TSqliteDef['columns'][K]['schema']> }
+    >
+  >,
+> = {
+  sqliteDef: TSqliteDef
+  isSingleColumn: TIsSingleColumn
+  options: TOptions
+  schema: TSchema
+}
+
+export type TableOptionsInput = Partial<TableOptions & { indexes: SqliteDsl.Index[] }>
+
+export type TableOptions = {
+  /**
+   * Setting this to true will have the following consequences:
+   * - An `id` column will be added with `primaryKey: true` and `"singleton"` as default value and only allowed value
+   * - LiveStore will automatically create the singleton row when the table is created
+   * - LiveStore will fail if there is already a column defined with `primaryKey: true`
+   *
+   * @default false
+   */
+  isSingleton: boolean
+  // TODO
+  dynamicRegistration: boolean
+  disableAutomaticIdColumn: boolean
+}
+
+export const table = <
+  TName extends string,
+  TColumns extends SqliteDsl.Columns | SqliteDsl.ColumnDefinition<any, any>,
+  const TOptionsInput extends TableOptionsInput = TableOptionsInput,
+>(
+  name: TName,
+  columnOrColumns: TColumns,
+  // type?: TStateType,
+  options?: TOptionsInput,
+): TableDef<
+  SqliteDsl.TableDefinition<
+    TName,
+    PrettifyFlat<
+      WithId<TColumns extends SqliteDsl.Columns ? TColumns : { value: TColumns }, WithDefaults<TOptionsInput>>
+    >
+  >,
+  TColumns extends SqliteDsl.ColumnDefinition<any, any> ? true : false,
+  WithDefaults<TOptionsInput>
+> => {
+  const tablePath = name
+
+  const options_: TableOptions = {
+    isSingleton: options?.isSingleton ?? false,
+    dynamicRegistration: options?.dynamicRegistration ?? false,
+    disableAutomaticIdColumn: options?.disableAutomaticIdColumn ?? false,
+  }
+
+  const columns = (
+    SqliteDsl.isColumnDefinition(columnOrColumns) ? { value: columnOrColumns } : columnOrColumns
+  ) as SqliteDsl.Columns
+
+  if (options_.disableAutomaticIdColumn === true) {
+    if (columns.id === undefined && options_.isSingleton === true) {
+      shouldNeverHappen(
+        `Cannot create table ${name} with "isSingleton: true" because there is no column with name "id" and "disableAutomaticIdColumn: true" is set`,
+      )
+    }
+  } else if (columns.id === undefined && ReadonlyRecord.some(columns, (_) => _.primaryKey === true) === false) {
+    if (options_.isSingleton) {
+      columns.id = SqliteDsl.text({ schema: Schema.literal('singleton'), primaryKey: true, default: 'singleton' })
+    } else {
+      columns.id = SqliteDsl.text({ primaryKey: true })
+    }
+  }
+
+  const sqliteDef = SqliteDsl.table(tablePath, columns, options?.indexes ?? [])
+
+  if (options_.isSingleton) {
+    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.`,
+        )
+      }
+    }
+  }
+
+  const isSingleColumn = SqliteDsl.isColumnDefinition(columnOrColumns) === true
+
+  const schema = SqliteDsl.structSchemaForTable(sqliteDef)
+  const tableDef = { sqliteDef, isSingleColumn, options: options_, schema } satisfies TableDef
+
+  // if (dynamicallyRegisteredTables.has(tablePath)) {
+  //   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 {
+  //   dynamicallyRegisteredTables.set(tablePath, tableDef)
+  // }
+
+  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,
+  fallbackValues?: Record<string, any>,
+) =>
+  pipe(
+    tableDef.sqliteDef.columns,
+    ReadonlyRecord.filter((col, key) => {
+      if (fallbackValues?.[key] !== undefined) return true
+      if (key === 'id') return false
+      return col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false
+    }),
+    ReadonlyRecord.map((column, columnName) =>
+      fallbackValues?.[columnName] === undefined
+        ? 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)
+        : fallbackValues[columnName],
+    ),
+  )
+
+export const getDefaultValuesDecoded = <TTableDef extends TableDef>(
+  tableDef: TTableDef,
+  fallbackValues?: Record<string, any>,
+) =>
+  pipe(
+    tableDef.sqliteDef.columns,
+    ReadonlyRecord.filter((col, key) => {
+      if (fallbackValues?.[key] !== undefined) return true
+      if (key === 'id') return false
+      return col!.default._tag === 'None' || SqliteDsl.isSqlDefaultValue(col!.default.value) === false
+    }),
+    ReadonlyRecord.map((column, columnName) =>
+      fallbackValues?.[columnName] === undefined
+        ? 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)
+        : fallbackValues[columnName],
+    ),
+  )
+
+type WithId<TColumns extends SqliteDsl.Columns, TOptions extends TableOptions> = TColumns &
+  (TOptions['disableAutomaticIdColumn'] extends true
+    ? {}
+    : TOptions['isSingleton'] extends true
+      ? {
+          id: SqliteDsl.ColumnDefinition<'singleton', 'singleton'>
+        }
+      : {
+          id: SqliteDsl.ColumnDefinition<string, string>
+        })
+
+type WithDefaults<TOptionsInput extends TableOptionsInput> = {
+  isSingleton: TOptionsInput['isSingleton'] extends true ? true : false
+  dynamicRegistration: TOptionsInput['dynamicRegistration'] extends true ? true : false
+  disableAutomaticIdColumn: TOptionsInput['disableAutomaticIdColumn'] extends true ? true : false
+}
+
+export namespace FromTable {
+  // TODO this sometimes doesn't preserve the order of columns
+  export type RowDecoded<TTableDef extends TableDef> = PrettifyFlat<
+    Nullable<Pick<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>> &
+      Omit<RowDecodedAll<TTableDef>, NullableColumnNames<TTableDef>>
+  >
+
+  export type NullableColumnNames<TTableDef extends TableDef> = FromColumns.NullableColumnNames<
+    TTableDef['sqliteDef']['columns']
+  >
+
+  export type Columns<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: TTableDef['sqliteDef']['columns'][K]['columnType']
+  }
+
+  export type RowEncodeNonNullable<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.From<TTableDef['sqliteDef']['columns'][K]['schema']>
+  }
+
+  export type RowEncoded<TTableDef extends TableDef> = PrettifyFlat<
+    Nullable<Pick<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>> &
+      Omit<RowEncodeNonNullable<TTableDef>, NullableColumnNames<TTableDef>>
+  >
+
+  export type RowDecodedAll<TTableDef extends TableDef> = {
+    [K in keyof TTableDef['sqliteDef']['columns']]: Schema.Schema.To<TTableDef['sqliteDef']['columns'][K]['schema']>
+  }
+}
+
+export namespace FromColumns {
+  // TODO this sometimes doesn't preserve the order of columns
+  export type RowDecoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
+    Nullable<Pick<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>> &
+      Omit<RowDecodedAll<TColumns>, NullableColumnNames<TColumns>>
+  >
+
+  export type RowDecodedAll<TColumns extends SqliteDsl.Columns> = {
+    [K in keyof TColumns]: Schema.Schema.To<TColumns[K]['schema']>
+  }
+
+  export type RowEncoded<TColumns extends SqliteDsl.Columns> = PrettifyFlat<
+    Nullable<Pick<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>> &
+      Omit<RowEncodeNonNullable<TColumns>, NullableColumnNames<TColumns>>
+  >
+
+  export type RowEncodeNonNullable<TColumns extends SqliteDsl.Columns> = {
+    [K in keyof TColumns]: Schema.Schema.From<TColumns[K]['schema']>
+  }
+
+  export type NullableColumnNames<TColumns extends SqliteDsl.Columns> = keyof {
+    [K in keyof TColumns as TColumns[K]['default'] extends true ? K : never]: {}
+  }
+
+  export type RequiredInsertColumnNames<TColumns extends SqliteDsl.Columns> =
+    SqliteDsl.FromColumns.RequiredInsertColumnNames<TColumns>
+
+  export type InsertRowDecoded<TColumns extends SqliteDsl.Columns> = SqliteDsl.FromColumns.InsertRowDecoded<TColumns>
+}

package/src/sql-queries/index.ts

@@ -0,0 +1,3 @@
+export * from './sql-queries.js'
+export * from './sql-query-builder.js'
+export * from './types.js'

package/src/sql-queries/misc.ts

@@ -0,0 +1,2 @@
+export const objectEntries = <T extends Record<string, any>>(obj: T): [keyof T & string, T[keyof T]][] =>
+  Object.entries(obj) as [keyof T & string, T[keyof T]][]