@sigitex/outlaw 1.0.0

package/src/queryGenerator/generateInsert.ts

@@ -0,0 +1,29 @@
+import { join, newline, print } from "@sigitex/print"
+import { Format } from "../framework"
+import type { InsertCommand } from "../queryBuilder"
+import { Clause } from "./Clause"
+
+export function generateInsert({
+  table,
+  columns,
+  rows,
+  returning,
+}: InsertCommand) {
+  return print([
+    "insert into ",
+    Format.name(table),
+    " (",
+    join(", ", columns, Format.name),
+    ")",
+    newline,
+    "values ",
+    rows.map((row, i) => [
+      i > 0 && ", ",
+      "(",
+      columns.map((col, c) => [c > 0 && ", ", Format.value(row[col])]),
+      ")",
+    ]),
+    newline,
+    returning && Clause.returning(returning),
+  ])
+}

package/src/queryGenerator/generateSelect.ts

@@ -0,0 +1,89 @@
+import { indent, join, newline, type Node, print } from "@sigitex/print"
+import { Format } from "../framework"
+import type { JoinClause, OrderBySort, SelectQuery } from "../queryBuilder"
+import { Clause } from "./Clause"
+
+export function generateSelect(query: SelectQuery) {
+  return print([generateSelectNode(query)])
+}
+
+export function generateSelectNode({
+  selected,
+  table,
+  conditions,
+  limit,
+  offset,
+  orderBy,
+  joins,
+}: SelectQuery): Node {
+  const hasJoins = !!joins?.length
+  const aliasMap = hasJoins ? buildAliasMap(table, joins!) : undefined
+  return [
+    "select ",
+    selected &&
+      join(", ", selected, (col: string) =>
+        hasJoins ? qualifyColumn(table, col) : Format.name(col),
+      ),
+    !selected &&
+      (hasJoins ? allColumnsQualified(table, joins!, aliasMap!) : "*"),
+    newline,
+    "from ",
+    Format.name(table),
+    newline,
+    hasJoins && Clause.joins(joins!, aliasMap!),
+    conditions?.length &&
+      Clause.where(conditions, hasJoins ? table : undefined),
+    limit && ["limit ", Format.number(limit), newline],
+    offset && ["offset ", Format.number(offset), newline],
+    orderBy && orderByClause(orderBy),
+  ]
+}
+
+function buildAliasMap(
+  baseTable: string,
+  joins: JoinClause[],
+): Map<JoinClause, string> {
+  const map = new Map<JoinClause, string>()
+  const used = new Set([baseTable])
+
+  for (const clause of joins) {
+    const sourceName =
+      clause.target.kind === "table" ? clause.target.name : clause.target.table
+    let alias = sourceName
+    let i = 1
+    while (used.has(alias)) {
+      alias = `${sourceName}_${i++}`
+    }
+    used.add(alias)
+    map.set(clause, alias)
+  }
+  return map
+}
+
+function qualifyColumn(baseTable: string, column: string): string {
+  return `${Format.name(baseTable)}.${Format.name(column)}`
+}
+
+function allColumnsQualified(
+  table: string,
+  joins: JoinClause[],
+  aliasMap: Map<JoinClause, string>,
+): Node {
+  const names = [table, ...joins.map((j) => aliasMap.get(j)!)]
+  return names.map((t, i) => [i > 0 && ", ", Format.name(t), ".*"])
+}
+
+function orderByClause(orderBy: OrderBySort[]): Node {
+  return [
+    "order by ",
+    indent(
+      orderBy.map(({ column, direction }, index) => [
+        index > 0 && ", ",
+        Format.name(column),
+        " ",
+        direction,
+        newline,
+      ]),
+    ),
+  ]
+}

package/src/queryGenerator/generateUpdate.ts

@@ -0,0 +1,29 @@
+import { indent, newline, print } from "@sigitex/print"
+import { Format } from "../framework"
+import type { UpdateCommand } from "../queryBuilder"
+import { Clause } from "./Clause"
+
+export function generateUpdate({
+  table,
+  assignments,
+  conditions,
+  returning,
+}: UpdateCommand) {
+  const columns = Object.keys(assignments)
+  return print([
+    "update ",
+    Format.name(table),
+    newline,
+    "set ",
+    indent(
+      columns.map((col, i) => [
+        i > 0 && [",", newline],
+        Format.name(col),
+        " = ",
+        Format.value(assignments[col]),
+      ]),
+    ),
+    conditions?.length && Clause.where(conditions),
+    returning && Clause.returning(returning),
+  ])
+}

package/src/queryGenerator/index.ts

@@ -0,0 +1,4 @@
+export * from "./generateSelect"
+export * from "./generateInsert"
+export * from "./generateUpdate"
+export * from "./generateDelete"

package/src/reflection/Reflector.ts

@@ -0,0 +1,47 @@
+import type { Connection } from "../api"
+import type { TableListItem } from "./reflection.types"
+
+export class Reflector {
+  private readonly connection: Connection
+  private tableListItems: TableListItem[] | undefined = undefined
+
+  constructor(connection: Connection) {
+    this.connection = connection
+  }
+
+  async hasTable(tableName: string) {
+    return (await this.getTableList()).some(
+      ({ name, type }) => type === "table" && name === tableName,
+    )
+  }
+
+  async isMissingTable(tableName: string) {
+    return !(await this.hasTable(tableName))
+  }
+
+  async hasView(viewName: string) {
+    return (await this.getTableList()).some(
+      ({ name, type }) => type === "view" && name === viewName,
+    )
+  }
+
+  async hasIndex(indexName: string) {
+    const results = await this.connection.query<{ name: string }>(
+      `select name from sqlite_master where type = 'index' and name = '${indexName}'`,
+    )
+    return results.length > 0
+  }
+
+  invalidate() {
+    this.tableListItems = undefined
+  }
+
+  private async getTableList() {
+    if (this.tableListItems === undefined) {
+      const results =
+        await this.connection.query<TableListItem>("pragma table_list")
+      this.tableListItems = results.filter(({ schema }) => schema === "main")
+    }
+    return this.tableListItems
+  }
+}

package/src/reflection/index.ts

@@ -0,0 +1,2 @@
+export * from "./reflection.types"
+export * from "./Reflector"

package/src/reflection/reflection.types.ts

@@ -0,0 +1,12 @@
+export type TableListType = "table" | "view" | "shadow" | "virtual"
+
+export type TableListItem = {
+  readonly schema: string
+  readonly name: string
+  readonly type: TableListType
+  /** Number of columns **/
+  readonly ncol: number
+  /** WITHOUT ROWID */
+  readonly wr: number
+  strict: number
+}

package/src/schemaBuilder/Mapping.ts

@@ -0,0 +1,44 @@
+export type Mapping<From, To> = {
+  from(value: From): To
+  to(value: To): From
+}
+
+export namespace Mapping {
+  export const boolean: Mapping<number, boolean> = {
+    from(n) {
+      return n !== 0
+    },
+    to(b) {
+      return b ? 1 : 0
+    },
+  }
+
+  export const timestamp: Mapping<number, Date> = {
+    from(n) {
+      return new Date(n)
+    },
+    to(d) {
+      return d.getTime()
+    },
+  }
+
+  export const date: Mapping<string, Date> = {
+    from(s) {
+      return new Date(s)
+    },
+    to(d) {
+      return d.toISOString()
+    },
+  }
+
+  export function json<T>(): Mapping<string, T> {
+    return {
+      from(s) {
+        return JSON.parse(s) as T
+      },
+      to(o) {
+        return JSON.stringify(o)
+      },
+    }
+  }
+}

package/src/schemaBuilder/columnBuilders.ts

@@ -0,0 +1,67 @@
+// oxlint-disable typescript/no-explicit-any
+import type { CheckExpression, ColumnData, ColumnRef, MappingData } from "./metadata"
+import { Mapping } from "./Mapping"
+import type {
+  BuildColumn,
+  BuildColumnInner,
+  BuildColumnMap,
+  BuildPrimaryKey,
+} from "./schemaBuilder.types"
+
+export const text: BuildColumn<string, never> = composeColumn({
+  datatype: "text",
+})
+export const integer: BuildColumn<number, never> = composeColumn({
+  datatype: "integer",
+})
+export const real: BuildColumn<number, never> = composeColumn({
+  datatype: "real",
+})
+export const blob: BuildColumn<ArrayBuffer, never> = composeColumn({
+  datatype: "blob",
+})
+
+function composeColumn(
+  $meta: Partial<ColumnData>,
+): BuildColumnInner & BuildPrimaryKey<any, never> {
+  return {
+    $meta,
+    get notNull() {
+      return composeColumn({ ...$meta, notNull: true })
+    },
+    get primaryKey() {
+      return composeColumn({ ...$meta, primaryKey: { autoincrement: false } })
+    },
+    get autoincrement() {
+      return composeColumn({ ...$meta, primaryKey: { autoincrement: true } })
+    },
+    default(sql) {
+      return composeColumn({ ...$meta, default: sql })
+    },
+    check(expression: CheckExpression) {
+      return composeColumn({ ...$meta, check: expression })
+    },
+    get unique() {
+      return composeColumn({ ...$meta, unique: true })
+    },
+    get foreignKey() {
+      return {
+        references(ref: ColumnRef) {
+          return composeColumn({
+            ...$meta,
+            foreignKey: ref,
+          })
+        },
+      }
+    },
+    get map(): BuildColumnMap<any, never> {
+      const custom = (mapping?: MappingData) =>
+        composeColumn(mapping ? { ...$meta, mapping } : $meta)
+      custom.boolean = composeColumn({ ...$meta, mapping: Mapping.boolean })
+      custom.timestamp = composeColumn({ ...$meta, mapping: Mapping.timestamp })
+      custom.date = composeColumn({ ...$meta, mapping: Mapping.date })
+      custom.json = () => composeColumn({ ...$meta, mapping: Mapping.json() })
+      return custom as BuildColumnMap<any, never>
+    },
+  }
+}

package/src/schemaBuilder/createFixture.ts

@@ -0,0 +1,112 @@
+// oxlint-disable typescript/no-explicit-any
+import type { AnyBuildTable, InferTable, RefBy } from "./schemaBuilder.types"
+
+export type Fixtures = {
+  [key: string]: Fixture<any>
+}
+
+export type Seeds = Fixtures
+
+export type FixtureRow<Table> = {
+  [K in keyof InferTable<Table>]: InferTable<Table>[K] | RefBy
+}
+
+export type Fixture<Table> = {
+  table: Table
+  rows: FixtureRow<Table>[]
+}
+
+export namespace Fixture {
+  export function isRefBy(value: unknown): value is RefBy {
+    return (
+      value != null &&
+      typeof value === "object" &&
+      (value as any)._tag === "RefBy"
+    )
+  }
+}
+
+// TODO: just call it Row<Table>, avoid this alias
+type Row<Table> = InferTable<Table>
+
+type AllowRefBy<T> = T | RefBy
+
+export type FixtureTemplate<Table> = {
+  [K in keyof Row<Table>]?: AllowRefBy<Row<Table>[K]> | (() => Row<Table>[K])
+}
+
+type TemplateKeys<Template> = keyof {
+  [K in keyof Template as Template[K] extends undefined ? never : K]: true
+}
+
+type NullableKeys<T> = {
+  [K in keyof T]: null extends T[K] ? K : never
+}[keyof T]
+
+type RequiredRows<Table, Template> = {
+  [K in keyof Omit<
+    Row<Table>,
+    TemplateKeys<Template> | NullableKeys<Row<Table>>
+  >]: AllowRefBy<Row<Table>[K]>
+}
+
+type OptionalRows<Table, Template> = Partial<{
+  [K in (TemplateKeys<Template> | NullableKeys<Row<Table>>) &
+    keyof Row<Table>]: AllowRefBy<Row<Table>[K]>
+}>
+
+export type FixtureRows<Table, Template> = RequiredRows<Table, Template> &
+  OptionalRows<Table, Template>
+
+export function createFixture<
+  Table extends AnyBuildTable,
+  const Template extends FixtureTemplate<Table>,
+>(
+  table: Table,
+  template: Template,
+  rows: FixtureRows<Table, Template>[],
+): Fixture<Table>
+
+export function createFixture<Table extends AnyBuildTable>(
+  table: Table,
+  rows: InferTable<Table>[],
+): Fixture<Table>
+
+export function createFixture(
+  table: AnyBuildTable,
+  templateOrRows: Record<string, unknown> | Record<string, unknown>[],
+  maybeRows?: Record<string, unknown>[],
+): Fixture<AnyBuildTable> {
+  if (Array.isArray(templateOrRows)) {
+    return { table, rows: templateOrRows } as any
+  }
+
+  const template = templateOrRows
+  const rows = maybeRows!
+
+  const nullableKeys = table.$meta.columns
+    .filter((col) => !col.notNull && !col.primaryKey)
+    .map((col) => col.name)
+
+  return {
+    table,
+    rows: rows.map((row) => {
+      const result: Record<string, unknown> = { ...row }
+      for (const key of nullableKeys) {
+        if (!(key in result) && !(key in template)) {
+          result[key] = null
+        }
+      }
+      for (const key in template) {
+        if (key in row) {
+          continue
+        }
+        const value = template[key]
+        result[key] = typeof value === "function" ? value() : value
+      }
+      return result
+    }),
+  } as any
+}
+
+export const createSeed = createFixture

package/src/schemaBuilder/createIndex.ts

@@ -0,0 +1,33 @@
+import type { ColumnRef, IndexData } from "./metadata"
+import type { BuildIndex } from "./schemaBuilder.types"
+
+export function createIndex(name: string): IndexOn {
+  return {
+    on(...columns: ColumnRef[]) {
+      return finalize(name, columns, false)
+    },
+  }
+}
+
+export function createUniqueIndex(name: string): IndexOn {
+  return {
+    on(...columns: ColumnRef[]) {
+      return finalize(name, columns, true)
+    },
+  }
+}
+
+type IndexOn = {
+  on(...columns: ColumnRef[]): BuildIndex
+}
+
+function finalize(name: string, columns: ColumnRef[], unique: boolean): BuildIndex {
+  const $meta: IndexData = {
+    kind: "index",
+    name,
+    table: columns[0].table,
+    columns: columns.map(c => c.column),
+    unique,
+  }
+  return { $kind: "index", $meta }
+}

package/src/schemaBuilder/createSchema.ts

@@ -0,0 +1,23 @@
+import type { Schema, SchemaMembers } from "./schemaBuilder.types"
+
+export function createSchema<M extends SchemaMembers>(
+  members: M,
+): Schema<M> {
+  const tables: Record<string, unknown> = {}
+  const views: Record<string, unknown> = {}
+  const indexes: Record<string, unknown> = {}
+  for (const [key, member] of Object.entries(members)) {
+    switch (member.$kind) {
+      case "table":
+        tables[key] = member
+        break
+      case "view":
+        views[key] = member
+        break
+      case "index":
+        indexes[key] = member
+        break
+    }
+  }
+  return { tables, views, indexes } as Schema<M>
+}

package/src/schemaBuilder/createTable.ts

@@ -0,0 +1,80 @@
+import type { ColumnData, ColumnRef, TableData } from "./metadata"
+import type {
+  BuildColumns,
+  BuildColumnInner,
+  BuildTable,
+} from "./schemaBuilder.types"
+import { SelectQueryBuilder } from "../queryBuilder/SelectQueryBuilder"
+
+export function createTable<Columns extends BuildColumns>(
+  name: string,
+  defineColumns: Columns,
+): BuildTable<Columns> {
+  const columns = Object.entries(defineColumns).map<ColumnData>(
+    ([name, define]) => {
+      const meta = (define as BuildColumnInner).$meta
+      return {
+        name,
+        datatype: meta.datatype!,
+        default: meta.default,
+        foreignKey: meta.foreignKey,
+        notNull: !!meta.notNull,
+        primaryKey: meta.primaryKey,
+        unique: !!meta.unique,
+        mapping: meta.mapping,
+        check: meta.check,
+      }
+    },
+  )
+  const $meta: TableData = {
+    name,
+    columns,
+    constraints: [],
+  }
+  const by = new Proxy({}, {
+    get(_, col: string) {
+      return (value: unknown) => ({
+        _tag: "RefBy" as const,
+        table: defineTable,
+        column: col,
+        value,
+      })
+    },
+  })
+  function select(...columns: ("*" | string)[]) {
+    if (columns[0] === "*" || columns.length === 0) {
+      return new SelectQueryBuilder($meta, "*")
+    }
+    return new SelectQueryBuilder($meta, columns)
+  }
+  const defineTable = { $kind: "table" as const, $meta, by, primaryKey, unique, check, select } as unknown as BuildTable<Columns>
+  for (const col of Object.keys(defineColumns)) {
+    // oxlint-disable-next-line typescript/no-explicit-any
+    ;(defineTable as any)[col] = { table: name, column: col } satisfies ColumnRef
+  }
+  return defineTable
+
+  function primaryKey(...columns: (keyof Columns)[]) {
+    $meta.constraints.push({
+      type: "primaryKey",
+      columns: columns as string[],
+    })
+    return defineTable
+  }
+
+  function unique(...columns: (keyof Columns)[]) {
+    $meta.constraints.push({
+      type: "unique",
+      columns: columns as string[],
+    })
+    return defineTable
+  }
+
+  function check(expression: string | ((columns: Record<string, string>, table: TableData) => string)) {
+    $meta.constraints.push({
+      type: "check",
+      expression,
+    })
+    return defineTable
+  }
+}

package/src/schemaBuilder/createView.ts

@@ -0,0 +1,21 @@
+// oxlint-disable typescript/no-explicit-any
+import { print } from "@sigitex/print"
+import { generateSelectNode } from "../queryGenerator/generateSelect"
+import type { SelectQueryBuilder } from "../queryBuilder/SelectQueryBuilder"
+import type { TableData, ViewData } from "./metadata"
+import type { BuildView, SchemaSelect } from "./schemaBuilder.types"
+
+export function createView<SelectColumns>(
+  name: string,
+  queryBuilder: SchemaSelect<SelectColumns, any>,
+): BuildView<SelectColumns> {
+  const builder = queryBuilder as unknown as SelectQueryBuilder
+  const sql = print([generateSelectNode(builder.query)])
+  const $meta: ViewData = { kind: "view", name, sql }
+  const allColumns = [
+    ...builder.table.columns,
+    ...(builder.query.joins?.flatMap(j => j.target.tableData.columns) ?? []),
+  ]
+  const $tableData: TableData = { name, columns: allColumns, constraints: [] }
+  return { $kind: "view", $meta, $tableData }
+}

package/src/schemaBuilder/index.ts

@@ -0,0 +1,9 @@
+export * from "./Mapping"
+export * from "./metadata"
+export * from "./schemaBuilder.types"
+export * from "./createSchema"
+export * from "./createTable"
+export * from "./createIndex"
+export * from "./createView"
+export * from "./columnBuilders"
+export * from "./createFixture"

package/src/schemaBuilder/metadata.ts

@@ -0,0 +1,73 @@
+// oxlint-disable typescript/no-explicit-any
+export type Text = "text"
+export type Integer = "integer"
+export type Real = "real"
+export type Blob = "blob"
+
+export type Datatype = Text | Integer | Real | Blob
+
+export type JSType = string | number | ArrayBuffer
+
+export type MappingData = { from(value: any): any; to(value: any): any }
+
+export type TableData = {
+  readonly name: string
+  readonly columns: ColumnData[]
+  readonly constraints: TableConstraintData[]
+}
+
+export type CheckExpression = string | ((name: string, column: ColumnData) => string)
+
+export type ColumnData = {
+  readonly name: string
+  readonly datatype: Datatype
+  readonly notNull: boolean
+  readonly primaryKey: PrimaryKeyData | undefined
+  readonly default: string | undefined
+  readonly unique: boolean
+  readonly foreignKey: ForeignKeyData | undefined
+  readonly mapping: MappingData | undefined
+  readonly check: CheckExpression | undefined
+}
+
+export type ColumnRef = {
+  readonly table: string
+  readonly column: string
+}
+
+export type ForeignKeyData = ColumnRef
+
+export type TableConstraintData = TablePrimaryKeyData | TableUniqueData | TableCheckData
+
+export type TablePrimaryKeyData = {
+  readonly type: "primaryKey"
+  readonly columns: string[]
+}
+
+export type TableUniqueData = {
+  readonly type: "unique"
+  readonly columns: string[]
+}
+
+export type TableCheckData = {
+  readonly type: "check"
+  readonly expression: string | ((columns: Record<string, string>, table: TableData) => string)
+}
+
+export type PrimaryKeyData = {
+  readonly autoincrement: boolean
+}
+
+export type IndexData = {
+  readonly kind: "index"
+  readonly name: string
+  readonly table: string
+  readonly columns: string[]
+  readonly unique: boolean
+}
+
+export type ViewData = {
+  readonly kind: "view"
+  readonly name: string
+  readonly sql: string
+}