@sigitex/outlaw 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2026 Sigitex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# Outlaw
+
+It's sqlite.
+
+`bun add @sigitex/outlaw`
+
+> **Note:** This package currently exports TypeScript sources directly. A TypeScript-compatible runtime or bundler (Bun, etc.) is required.
+
+- TODO: conform to "adapts-to" stuff

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@sigitex/outlaw",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "Sigitex",
+    "url": "http://github.com/sigitex"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sigitex/outlaw.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    },
+    "./bun": "./src/bun/index.ts",
+    "./cloudflare": "./src/cloudflare/index.ts"
+  },
+  "types": "./src/index.ts",
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250425.0",
+    "@commitlint/cli": "^20.5.3",
+    "@commitlint/config-conventional": "^20.5.3",
+    "@markwylde/semantic-release-gitea": "^2.2.0",
+    "@semantic-release/exec": "^7.0.3",
+    "@types/bun": "^1.3.13",
+    "@types/fast-json-stable-stringify": "^2.1.2",
+    "@typescript/native-preview": "beta",
+    "husky": "^9.1.7",
+    "multi-semantic-release": "^3.1.0",
+    "oxfmt": "^0.47.0",
+    "oxlint": "^1.62.0",
+    "semantic-release": "^25.0.3"
+  },
+  "dependencies": {
+    "@sigitex/print": "*",
+    "fast-json-stable-stringify": "^2.1.0",
+    "sqlstring-sqlite": "^0.1.1"
+  },
+  "scripts": {
+    "prepare": "husky",
+    "lint": "oxlint",
+    "check": "tsgo --build",
+    "test": "bun test --pass-with-no-tests --tsconfig-override tsconfig.test.json"
+  },
+  "files": [
+    "src"
+  ],
+  "version": "1.0.0"
+}

package/src/api/DatabaseTable.ts

@@ -0,0 +1,51 @@
+// oxlint-disable typescript/no-explicit-any
+import type { Delete, Connection, Insert, Select, TableApi, Update } from "./api.types"
+import type { TableData } from "../schemaBuilder"
+import {
+  DeleteBuilder,
+  InsertBuilder,
+  SelectBuilder,
+  UpdateBuilder,
+} from "../queryBuilder"
+
+export class DatabaseTable implements TableApi<any> {
+  private connection: Connection
+  private table: TableData
+
+  constructor(connection: Connection, table: TableData) {
+    this.connection = connection
+    this.table = table
+  }
+
+  select(all: "*"): Select<any, any>
+  select<Column extends string>(columns: Column[]): Select<Pick<any, any>, any>
+  select(
+    columns: "*" | string[],
+  ): Select<any, any> | Select<Pick<any, any>, any> {
+    return new SelectBuilder(this.connection, this.table, columns)
+  }
+
+  insert(row: Partial<any>): Insert<any, any, number>
+  insert<Column extends string | number | symbol>(
+    columns: Column[],
+    rows: Pick<any, Column>[],
+  ): Insert<Column, any, number>
+  insert(
+    columnsOrRow: any,
+    rows?: any,
+  ): Insert<any, any, number> | Insert<any, any, number> {
+    if (rows) {
+      return new InsertBuilder(this.connection, this.table, columnsOrRow, rows)
+    }
+    const row = columnsOrRow as Record<string, unknown>
+    return new InsertBuilder(this.connection, this.table, Object.keys(row), [row])
+  }
+
+  update(row: Partial<any>): Update<any, number> {
+    return new UpdateBuilder(this.connection, this.table, row)
+  }
+
+  delete(): Delete<TableData, number> {
+    return new DeleteBuilder(this.connection, this.table)
+  }
+}

package/src/api/DatabaseView.ts

@@ -0,0 +1,22 @@
+// oxlint-disable typescript/no-explicit-any
+import type { Connection, Select, ViewApi } from "./api.types"
+import type { TableData } from "../schemaBuilder"
+import { SelectBuilder } from "../queryBuilder"
+
+export class DatabaseView implements ViewApi<any> {
+  private connection: Connection
+  private tableData: TableData
+
+  constructor(connection: Connection, tableData: TableData) {
+    this.connection = connection
+    this.tableData = tableData
+  }
+
+  select(all: "*"): Select<any, any>
+  select<Column extends string>(columns: Column[]): Select<Pick<any, any>, any>
+  select(
+    columns: "*" | string[],
+  ): Select<any, any> | Select<Pick<any, any>, any> {
+    return new SelectBuilder(this.connection, this.tableData, columns)
+  }
+}

package/src/api/api.types.ts

@@ -0,0 +1,200 @@
+// oxlint-disable typescript/consistent-type-definitions
+// oxlint-disable typescript/no-explicit-any
+import type { BINARY_OPERATORS, UNARY_OPERATORS } from "../queryBuilder"
+import type {
+  BuildColumn,
+  BuildTable,
+  BuildView,
+  ColumnRef,
+  SchemaMembers,
+  TablesOf,
+  ViewsOf,
+} from "../schemaBuilder"
+
+// Utilities
+
+export type ElementOf<ArrayType extends readonly unknown[]> =
+  ArrayType extends readonly (infer ElementType)[] ? ElementType : never
+
+export type InsertRecord<R> = Partial<R> &
+  Pick<
+    R,
+    {
+      [P in keyof R]: R[P] extends Exclude<R[P], null> ? P : never
+    }[keyof R]
+  >
+
+// Deconstruction
+
+export type ColumnsOf<BT> =
+  BT extends BuildTable<infer Columns> ? Columns : never
+
+export type ColumnTypeOf<BC> =
+  BC extends BuildColumn<infer Type, infer Constraints>
+    ? Constraints extends "notNull" | "primaryKey"
+      ? Type
+      : Type | null
+    : never
+
+export type ColumnTypesOf<BCS> = {
+  readonly [BCK in keyof BCS]: ColumnTypeOf<BCS[BCK]>
+}
+
+// API
+
+export type DefaultRow = Record<string, unknown>
+
+export type Connection = {
+  readonly query: <Row = DefaultRow>(sql: string) => Promise<Row[]>
+  readonly script: (statements: string[]) => Promise<void>
+  readonly reset?: () => Promise<void>
+}
+
+export type DatabaseApi<M extends SchemaMembers> = {
+  readonly [K in keyof TablesOf<M>]: TableApi<ColumnsOf<TablesOf<M>[K]>>
+} & {
+  readonly [K in keyof ViewsOf<M>]: ViewApi<ColumnsOfView<ViewsOf<M>[K]>>
+} & {
+  readonly connection: Connection
+}
+
+export type ColumnsOfView<BV> = BV extends BuildView<infer Columns> ? Columns : never
+
+export type ViewApi<Columns> = {
+  /** Issue a `SELECT *` query to the API. */
+  select(all: "*"): Select<Columns, Columns>
+  /** Issue a `SELECT` query to the API with the chosen columns. */
+  select<Column extends keyof Columns>(
+    ...columns: Column[]
+  ): Select<Pick<Columns, Column>, Columns>
+}
+
+export type TableApi<Columns> = {
+  /** Issue a `SELECT *` query to the API. */
+  select(all: "*"): Select<Columns, Columns>
+  /** Issue a `SELECT` query to the API with the chosen columns. */
+  select<Column extends keyof Columns>(
+    ...columns: Column[]
+  ): Select<Pick<Columns, Column>, Columns>
+  /** Issue an `INSERT` statement. */
+  insert<InsertColumns extends Partial<ColumnTypesOf<Columns>>>(
+    ...rows: InsertColumns[]
+  ): Insert<InsertColumns, Columns, number>
+  /** Issue an `UPDATE` statement. */
+  update(row: Partial<ColumnTypesOf<Columns>>): Update<Columns, number>
+  /** Issue a `DELETE` statement. */
+  delete(): Delete<Columns, number>
+}
+
+/* Represents queries/statments with a `WHERE` clause. */
+export interface HasWhereClause<Columns> {
+  /** Add a condition where the given column equals the given value. */
+  where<Column extends keyof Columns>(
+    column: Column,
+    value: Columns[Column],
+  ): this
+  /** Add a unary `WHERE` condition. */
+  where<Column extends keyof Columns>(
+    column: Column,
+    operator: UnaryOperator,
+  ): this
+  /** Add a binary `WHERE` condition. */
+  where<Column extends keyof Columns>(
+    column: Column,
+    operator: BinaryOperator,
+    value: ColumnTypeOf<Columns[Column]>,
+  ): this
+}
+
+/** Select query API. */
+export interface Select<SelectColumns, Columns>
+  extends HasWhereClause<Columns> {
+  /** Issue the query, expecting an array of results. */
+  fetch(): Promise<ColumnTypesOf<SelectColumns>[]>
+  /** Issue the query, returning a single result, or throwing.. */
+  first(): Promise<ColumnTypesOf<SelectColumns>>
+  /** Add a `LIMIT` clause. */
+  limit(n: number): this
+  /** Add an `OFFSET` clause. */
+  offset(n: number): this
+  /** Add an `ORDER BY` sort expression. */
+  orderBy(sorts: [keyof Columns, "asc" | "desc"][]): this
+
+  /** Inner join on a table. */
+  join<JC>(
+    table: BuildTable<JC>,
+  ): Select<SelectColumns & ColumnTypesOf<JC>, Columns & JC>
+  /** Inner join on a subquery. */
+  join<SC>(
+    query: Select<SC, any>,
+  ): Select<SelectColumns & ColumnTypesOf<SC>, Columns & SC>
+
+  /** Left join on a table — joined columns become nullable. */
+  leftJoin<JC>(
+    table: BuildTable<JC>,
+  ): Select<SelectColumns & Partial<ColumnTypesOf<JC>>, Columns & JC>
+  /** Left join on a subquery — joined columns become nullable. */
+  leftJoin<SC>(
+    query: Select<SC, any>,
+  ): Select<SelectColumns & Partial<ColumnTypesOf<SC>>, Columns & SC>
+
+  /** Right join on a table. */
+  rightJoin<JC>(
+    table: BuildTable<JC>,
+  ): Select<SelectColumns & ColumnTypesOf<JC>, Columns & JC>
+  /** Right join on a subquery. */
+  rightJoin<SC>(
+    query: Select<SC, any>,
+  ): Select<SelectColumns & ColumnTypesOf<SC>, Columns & SC>
+
+  /** Cross join on a table. */
+  crossJoin<JC>(
+    table: BuildTable<JC>,
+  ): Select<SelectColumns & ColumnTypesOf<JC>, Columns & JC>
+  /** Cross join on a subquery. */
+  crossJoin<SC>(
+    query: Select<SC, any>,
+  ): Select<SelectColumns & ColumnTypesOf<SC>, Columns & SC>
+
+  /** Add an ON condition to the most recent join. */
+  on(left: ColumnRef, operator: BinaryOperator, right: ColumnRef): this
+}
+
+/** Insert statement API. */
+export interface Insert<InsertColumns, Columns, Returning> {
+  /** Execute the statement. */
+  execute(): Promise<Returning>
+  /** Specify a `RETURNING *` clause. */
+  returning(all: "*"): Insert<InsertColumns, Columns, ColumnTypesOf<Columns>[]>
+  /** Specify a `RETURNING` clause with the chosen columns. */
+  returning<Column extends keyof Columns>(
+    ...columns: Column[]
+  ): Insert<InsertColumns, Columns, ColumnTypesOf<Pick<Columns, Column>>[]>
+}
+
+/** Update statement API. */
+export interface Update<Columns, Returning> extends HasWhereClause<Columns> {
+  /** Execute the statement. */
+  execute(): Promise<Returning>
+  /** Specify a `RETURNING *` clause. */
+  returning(all: "*"): Update<Columns, Columns[]>
+  /** Specify a `RETURNING` clause with the chosen columns. */
+  returning<Column extends keyof Columns>(
+    columns: Column[],
+  ): Update<Columns, Pick<Columns, Column>[]>
+}
+
+/** Delete statement API. */
+export interface Delete<Columns, Returning> extends HasWhereClause<Columns> {
+  /** Execute the statement. */
+  execute(): Promise<Returning>
+  /** Specify a `RETURNING *` clause. */
+  returning(all: "*"): Delete<Columns, Columns[]>
+  /** Specify a `RETURNING` clause with the chosen columns. */
+  returning<Column extends keyof Columns>(
+    columns: Column[],
+  ): Delete<Columns, Pick<Columns, Column>[]>
+}
+
+export type UnaryOperator = ElementOf<typeof UNARY_OPERATORS>
+export type BinaryOperator = ElementOf<typeof BINARY_OPERATORS>

package/src/api/createDatabase.ts

@@ -0,0 +1,24 @@
+import type { BuildTable, BuildView, SchemaMembers, Schema } from "../schemaBuilder"
+import type { Connection, DatabaseApi } from "./api.types"
+import { DatabaseTable } from "./DatabaseTable"
+import { DatabaseView } from "./DatabaseView"
+
+export function createDatabase<M extends SchemaMembers>(
+  connection: Connection,
+  schema: Schema<M>,
+) {
+  const api = { connection }
+  for (const [property, member] of Object.entries(schema.tables)) {
+    const table = member as BuildTable<unknown>
+    Object.defineProperty(api, property, {
+      value: new DatabaseTable(connection, table.$meta),
+    })
+  }
+  for (const [property, member] of Object.entries(schema.views)) {
+    const view = member as BuildView
+    Object.defineProperty(api, property, {
+      value: new DatabaseView(connection, view.$tableData),
+    })
+  }
+  return api as DatabaseApi<M>
+}

package/src/api/index.ts

@@ -0,0 +1,4 @@
+export * from "./api.types"
+export * from "./DatabaseTable"
+export * from "./DatabaseView"
+export * from "./createDatabase"

package/src/bun/bun.ts

@@ -0,0 +1,27 @@
+import type { Database } from "bun:sqlite"
+import type { DefaultRow, Connection } from "../api/api.types"
+
+export class BunConnection implements Connection {
+  private readonly db: Database
+
+  constructor(db: Database) {
+    this.db = db
+  }
+
+  async query<Row = DefaultRow>(sql: string) {
+    return this.db.query(sql).all() as Row[]
+  }
+
+  async script(statements: string[]) {
+    this.db.run("BEGIN")
+    try {
+      for (const s of statements) {
+        this.db.run(s)
+      }
+      this.db.run("COMMIT")
+    } catch (error) {
+      this.db.run("ROLLBACK")
+      throw error
+    }
+  }
+}

package/src/bun/index.ts

@@ -0,0 +1 @@
+export * from "./bun"

package/src/cloudflare/cloudflare.ts

@@ -0,0 +1,18 @@
+import type { D1Database } from "@cloudflare/workers-types"
+import type { DefaultRow, Connection } from "../api/api.types"
+
+export class CloudflareConnection implements Connection {
+  private readonly d1: D1Database
+
+  constructor(d1: D1Database) {
+    this.d1 = d1
+  }
+
+  async query<Row = DefaultRow>(sql: string) {
+    return (await this.d1.prepare(sql).run()).results as Row[]
+  }
+
+  async script(statements: string[]) {
+    await this.d1.batch(statements.map((s) => this.d1.prepare(s)))
+  }
+}

package/src/cloudflare/index.ts

@@ -0,0 +1 @@
+export * from "./cloudflare"

package/src/console.ts

@@ -0,0 +1,14 @@
+// oxlint-disable typescript/consistent-type-definitions
+declare global {
+  interface Console {
+    log(...args: unknown[]): void
+    error(...args: unknown[]): void
+    warn(...args: unknown[]): void
+    info(...args: unknown[]): void
+    debug(...args: unknown[]): void
+  }
+
+  var console: Console
+}
+
+export {}

package/src/cowboyMigration/Compare.ts

@@ -0,0 +1,97 @@
+import type {
+  ColumnData,
+  TableCheckData,
+  TableConstraintData,
+  TableData,
+} from "../schemaBuilder"
+
+export namespace Compare {
+  export function table(ta: TableData, tb: TableData) {
+    if (ta.columns.length !== tb.columns.length) {
+      return false
+    }
+    if (ta.constraints.length !== tb.constraints.length) {
+      return false
+    }
+    for (let c = 0; c < ta.columns.length; c++) {
+      const ca = ta.columns[c]
+      const cb = tb.columns[c]
+      const equals = columnEquals(ca, cb)
+      if (!equals) {
+        return false
+      }
+    }
+    for (let c = 0; c < ta.constraints.length; c++) {
+      const ca = ta.constraints[c]
+      const cb = tb.constraints[c]
+      const equals = constraintEquals(ca, cb, ta, tb)
+      if (!equals) {
+        return false
+      }
+    }
+    return true
+  }
+
+  function columnEquals(a: ColumnData, b: ColumnData) {
+    return (
+      a.name === b.name &&
+      a.datatype === b.datatype &&
+      a.default === b.default &&
+      a.notNull === b.notNull &&
+      a.unique === b.unique &&
+      typeEquals(a.primaryKey, b.primaryKey) &&
+      a.primaryKey?.autoincrement === b.primaryKey?.autoincrement &&
+      typeEquals(a.foreignKey, b.foreignKey) &&
+      a.foreignKey?.column === b.foreignKey?.column &&
+      a.foreignKey?.table === b.foreignKey?.table &&
+      resolveColumnCheck(a) === resolveColumnCheck(b)
+    )
+  }
+
+  function constraintEquals(
+    a: TableConstraintData,
+    b: TableConstraintData,
+    ta: TableData,
+    tb: TableData,
+  ) {
+    if (a.type !== b.type) {
+      return false
+    }
+    if (a.type === "check" && b.type === "check") {
+      return (
+        resolveTableCheck(a.expression, ta) ===
+        resolveTableCheck(b.expression, tb)
+      )
+    }
+    if (a.type !== "check" && b.type !== "check") {
+      return a.columns.join(" ") === b.columns.join(" ")
+    }
+    return false
+  }
+
+  function resolveColumnCheck(col: ColumnData): string | undefined {
+    if (col.check == null) {
+      return undefined
+    }
+    return typeof col.check === "function"
+      ? col.check(col.name, col)
+      : col.check
+  }
+
+  function resolveTableCheck(
+    expression: TableCheckData["expression"],
+    table: TableData,
+  ): string {
+    if (typeof expression === "function") {
+      const columnNames = Object.fromEntries(
+        table.columns.map((c) => [c.name, c.name]),
+      )
+      return expression(columnNames, table)
+    }
+    return expression
+  }
+
+  function typeEquals(a: unknown, b: unknown) {
+    return typeof a === typeof b
+  }
+}

package/src/cowboyMigration/CowboyConnection.ts

@@ -0,0 +1,57 @@
+import type { Fixtures, Schema, SchemaMembers, Seeds } from "../schemaBuilder"
+import type { Connection, DefaultRow } from "../api"
+import type { SchemaHack } from "./cowboyMigration.types"
+import { CowboyMigrator } from "./CowboyMigrator"
+import { CowboySeeder } from "./CowboySeeder"
+
+export type CowboyOptions = {
+  hacks?: SchemaHack[]
+  seeds?: Seeds
+  fixtures?: Fixtures
+  runFixtures?: boolean
+}
+
+export class CowboyConnection implements Connection {
+  private readonly raw: Connection
+  private readonly schema: Schema<SchemaMembers>
+  private readonly options: CowboyOptions
+  private shotFirst = false
+
+  constructor(raw: Connection, schema: Schema<SchemaMembers>, options?: CowboyOptions) {
+    this.raw = raw
+    this.schema = schema
+    this.options = options ?? {}
+  }
+
+  async query<Row = DefaultRow>(sql: string) {
+    if (!this.shotFirst) {
+      await this.shotgun()
+    }
+    return this.raw.query(sql) as Promise<Row[]>
+  }
+
+  async script(statements: string[]) {
+    if (!this.shotFirst) {
+      await this.shotgun()
+    }
+    await this.raw.script(statements)
+  }
+
+  async reset() {
+    this.shotFirst = false
+  }
+
+  private async shotgun() {
+    this.shotFirst = true
+    await new CowboyMigrator(this.raw, this.schema, this.options.hacks ?? []).migrate()
+    const hasSeeds = this.options.seeds || (this.options.runFixtures && this.options.fixtures)
+    if (hasSeeds) {
+      await new CowboySeeder(
+        this.raw,
+        this.options.seeds ?? {},
+        this.options.fixtures ?? {},
+        this.options.runFixtures ?? false,
+      ).seed()
+    }
+  }
+}