@sigitex/outlaw 1.0.0

package/src/schemaBuilder/schemaBuilder.types.ts

@@ -0,0 +1,139 @@
+// oxlint-disable typescript/no-explicit-any
+import type { CheckExpression, ColumnData, ColumnRef, IndexData, TableData, ViewData } from "./metadata"
+import type { Mapping } from "./Mapping"
+
+export type SchemaMembers = {
+  readonly [key: string]: AnyBuildTable | BuildView<any> | BuildIndex
+}
+
+export type TablesOf<M extends SchemaMembers> = {
+  [K in keyof M as M[K] extends AnyBuildTable ? K : never]: M[K]
+}
+
+export type ViewsOf<M extends SchemaMembers> = {
+  [K in keyof M as M[K] extends BuildView<any> ? K : never]: M[K]
+}
+
+export type IndexesOf<M extends SchemaMembers> = {
+  [K in keyof M as M[K] extends BuildIndex ? K : never]: M[K]
+}
+
+export type Schema<M extends SchemaMembers> = {
+  readonly tables: TablesOf<M>
+  readonly views: ViewsOf<M>
+  readonly indexes: IndexesOf<M>
+}
+
+export type ColumnNames<Columns> = { readonly [K in keyof Columns]: string }
+
+export type BuildColumns = {
+  readonly [columnName: string]: BuildColumn<any, any>
+}
+
+export type InferColumn<BC> = BC extends BuildColumn<infer Type, infer Defined>
+  ? "notNull" extends Defined
+    ? Type
+    : "primaryKey" extends Defined
+      ? Type
+      : Type | null
+  : never
+
+export type InferTable<BT> = BT extends BuildTable<infer Columns>
+  ? { [K in keyof Columns]: InferColumn<Columns[K]> }
+  : never
+
+export type RefBy = {
+  readonly _tag: "RefBy"
+  readonly table: AnyBuildTable
+  readonly column: string
+  readonly value: unknown
+}
+
+type BuildTableDSL<DefineColumns> = {
+  readonly $kind: "table"
+  primaryKey: (...columns: (keyof DefineColumns)[]) => BuildTable<DefineColumns>
+  unique: (...columns: (keyof DefineColumns)[]) => BuildTable<DefineColumns>
+  check: (expression: string | ((columns: ColumnNames<DefineColumns>, table: TableData) => string)) => BuildTable<DefineColumns>
+  select(all: "*"): SchemaSelect<DefineColumns, DefineColumns>
+  select<C extends keyof DefineColumns>(...columns: C[]): SchemaSelect<Pick<DefineColumns, C>, DefineColumns>
+  readonly by: {
+    readonly [K in keyof DefineColumns]: (
+      value: InferColumn<DefineColumns[K]>,
+    ) => RefBy
+  }
+  readonly $meta: TableData
+  readonly infer: InferTable<BuildTable<DefineColumns>>
+}
+
+export type BuildTable<DefineColumns> = BuildTableDSL<DefineColumns> & {
+  readonly [K in keyof DefineColumns]: ColumnRef
+}
+
+export type AnyBuildTable = {
+  readonly $kind: "table"
+  readonly $meta: TableData
+  readonly [key: string]: unknown
+}
+
+// oxlint-disable-next-line no-unused-vars
+export type BuildView<SelectColumns = unknown> = {
+  readonly $kind: "view"
+  readonly $meta: ViewData
+  readonly $tableData: TableData
+}
+
+export type BuildIndex = {
+  readonly $kind: "index"
+  readonly $meta: IndexData
+}
+
+/** Schema-level select builder — tracks column types without requiring a connection. */
+export type SchemaSelect<SelectColumns, Columns> = {
+  where<Column extends keyof Columns>(column: Column, value: unknown): SchemaSelect<SelectColumns, Columns>
+  where<Column extends keyof Columns>(column: Column, operator: string): SchemaSelect<SelectColumns, Columns>
+  where<Column extends keyof Columns>(column: Column, operator: string, value: unknown): SchemaSelect<SelectColumns, Columns>
+  orderBy(sorts: [keyof Columns, "asc" | "desc"][]): SchemaSelect<SelectColumns, Columns>
+  limit(n: number): SchemaSelect<SelectColumns, Columns>
+  offset(n: number): SchemaSelect<SelectColumns, Columns>
+  join<JC>(table: BuildTable<JC>): SchemaSelect<SelectColumns & JC, Columns & JC>
+  leftJoin<JC>(table: BuildTable<JC>): SchemaSelect<SelectColumns & JC, Columns & JC>
+  on(left: ColumnRef, operator: string, right: ColumnRef): SchemaSelect<SelectColumns, Columns>
+}
+
+export type BuildColumn<Type, Defined extends string> = Omit<
+  {
+    readonly notNull: BuildColumn<Type, Defined | "notNull">
+    readonly primaryKey: BuildColumn<Type, Defined | "primaryKey"> &
+      BuildPrimaryKey<Type, Defined | "primaryKey">
+    readonly default: (sql: string) => BuildColumn<Type, Defined | "default">
+    readonly unique: BuildColumn<Type, Defined | "unique">
+    readonly check: (expression: CheckExpression) => BuildColumn<Type, Defined | "check">
+    readonly foreignKey: BuildForeignKey<Type, Defined>
+    readonly map: BuildColumnMap<Type, Defined>
+  },
+  Defined
+>
+
+export type BuildColumnInner = BuildColumn<any, never> & {
+  $meta: Partial<ColumnData>
+}
+
+export type BuildPrimaryKey<Type, Defined extends string> = {
+  readonly autoincrement: BuildColumn<Type, Defined>
+}
+
+export type BuildForeignKey<Type, Defined extends string> = {
+  readonly references: (
+    ref: ColumnRef,
+  ) => BuildColumn<Type, Defined | "foreignKey">
+}
+
+export type BuildColumnMap<Type, Defined extends string> = {
+  readonly boolean: BuildColumn<boolean, Defined | "map">
+  readonly timestamp: BuildColumn<Date, Defined | "map">
+  readonly date: BuildColumn<Date, Defined | "map">
+  readonly json: <T>() => BuildColumn<T, Defined | "map">
+} & {
+  <To>(mapping: Mapping<Type, To>): BuildColumn<To, Defined | "map">
+  <To>(): BuildColumn<To, Defined | "map">
+}

package/src/schemaGenerator/generateCreateIndex.ts

@@ -0,0 +1,18 @@
+import { join, newline, print } from "@sigitex/print"
+import { Format } from "../framework"
+import type { IndexData } from "../schemaBuilder"
+
+export function generateCreateIndex(index: IndexData) {
+  return print([
+    "create ",
+    index.unique && "unique ",
+    "index ",
+    Format.name(index.name),
+    " on ",
+    Format.name(index.table),
+    " (",
+    join(", ", index.columns, Format.name),
+    ");",
+    newline,
+  ])
+}

package/src/schemaGenerator/generateCreateTable.ts

@@ -0,0 +1,68 @@
+import { indent, newline, print } from "@sigitex/print"
+import { Format } from "../framework"
+import type { CheckExpression, ColumnData, TableData } from "../schemaBuilder"
+
+export function generateCreateTable(table: TableData) {
+  const columnNames = Object.fromEntries(table.columns.map(c => [c.name, c.name]))
+  return print([
+    "create table ",
+    Format.name(table.name),
+    " (",
+    indent(
+      table.columns.map((column, c) => [
+        c > 0 && [",", newline],
+        Format.name(column.name),
+        " ",
+        column.datatype,
+        column.primaryKey && [
+          " primary key",
+          column.primaryKey.autoincrement && " autoincrement",
+        ],
+        column.notNull && " not null",
+        column.unique && " unique",
+        column.default && [" default ", column.default],
+        column.check && [" check(", resolveColumnCheck(column.check, column), ")"],
+      ]),
+      table.columns
+        .filter(({ foreignKey }) => foreignKey)
+        .map((column) => [
+          ",",
+          newline,
+          "foreign key (",
+          Format.name(column.name),
+          ") references ",
+          Format.name(column.foreignKey?.table),
+          " (",
+          Format.name(column.foreignKey?.column),
+          ")",
+        ]),
+      table.constraints.map((constraint) => [
+        ",",
+        newline,
+        constraint.type === "primaryKey" && "primary key",
+        constraint.type === "unique" && "unique",
+        (constraint.type === "primaryKey" || constraint.type === "unique") && [
+          " (",
+          constraint.columns.map((fkColumn, c) => [
+            c > 0 && ", ",
+            Format.name(fkColumn),
+          ]),
+          ")",
+        ],
+        constraint.type === "check" && [
+          "check(",
+          typeof constraint.expression === "function"
+            ? constraint.expression(columnNames, table)
+            : constraint.expression,
+          ")",
+        ],
+      ]),
+    ),
+    ");",
+    newline,
+  ])
+}
+
+function resolveColumnCheck(check: CheckExpression, column: ColumnData): string {
+  return typeof check === "function" ? check(column.name, column) : check
+}

package/src/schemaGenerator/generateCreateView.ts

@@ -0,0 +1,13 @@
+import { newline, print } from "@sigitex/print"
+import { Format } from "../framework"
+import type { ViewData } from "../schemaBuilder"
+
+export function generateCreateView(view: ViewData) {
+  return print([
+    "create view ",
+    Format.name(view.name),
+    " as ",
+    view.sql,
+    newline,
+  ])
+}

package/src/schemaGenerator/index.ts

@@ -0,0 +1,3 @@
+export * from "./generateCreateTable"
+export * from "./generateCreateIndex"
+export * from "./generateCreateView"