sumak 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 productdevbook
+
+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,200 @@
+<p align="center">
+  <br>
+  <img src=".github/assets/cover.jpg" alt="pamuk — Type-safe SQL query builder" width="100%">
+  <br><br>
+  <b style="font-size: 2em;">pamuk</b>
+  <br><br>
+  Type-safe SQL query builder with powerful SQL printers.
+  <br>
+  Zero dependencies, AST-first, hookable, tree-shakeable. Pure TypeScript, works everywhere.
+  <br><br>
+  <a href="https://npmjs.com/package/pamuk"><img src="https://img.shields.io/npm/v/pamuk?style=flat&colorA=18181B&colorB=e11d48" alt="npm version"></a>
+  <a href="https://npmjs.com/package/pamuk"><img src="https://img.shields.io/npm/dm/pamuk?style=flat&colorA=18181B&colorB=e11d48" alt="npm downloads"></a>
+  <a href="https://bundlephobia.com/result?p=pamuk"><img src="https://img.shields.io/bundlephobia/minzip/pamuk?style=flat&colorA=18181B&colorB=e11d48" alt="bundle size"></a>
+  <a href="https://github.com/productdevbook/pamuk/blob/main/LICENSE"><img src="https://img.shields.io/github/license/productdevbook/pamuk?style=flat&colorA=18181B&colorB=e11d48" alt="license"></a>
+</p>
+
+## Quick Start
+
+```sh
+npm install pamuk
+```
+
+```ts
+import { pamuk, pgDialect, serial, text, boolean, integer } from "pamuk";
+
+const db = pamuk({
+  dialect: pgDialect(),
+  tables: {
+    users: {
+      id: serial().primaryKey(),
+      name: text().notNull(),
+      email: text().notNull(),
+      active: boolean().defaultTo(true),
+    },
+    posts: {
+      id: serial().primaryKey(),
+      title: text().notNull(),
+      userId: integer().references("users", "id"),
+    },
+  },
+});
+```
+
+## Query Building
+
+```ts
+// SELECT
+db.selectFrom("users")
+  .select("id", "name")
+  .where(({ age, active }) => and(age.gte(18), active.eq(true)))
+  .orderBy("name")
+  .limit(10)
+  .compile(db.printer());
+// → SELECT "id", "name" FROM "users" WHERE ("age" >= $1 AND "active" = $2) ORDER BY "name" ASC LIMIT 10
+
+// INSERT
+db.insertInto("users")
+  .values({
+    name: "Alice",
+    email: "alice@example.com",
+  })
+  .returningAll()
+  .compile(db.printer());
+
+// UPDATE
+db.update("users")
+  .set({ active: false })
+  .where(({ id }) => id.eq(1))
+  .compile(db.printer());
+
+// DELETE
+db.deleteFrom("users")
+  .where(({ id }) => id.eq(1))
+  .returning("id")
+  .compile(db.printer());
+```
+
+## Joins
+
+```ts
+db.selectFrom("users")
+  .innerJoin("posts", ({ users, posts }) => users.id.eqCol(posts.userId))
+  .compile(db.printer());
+// → SELECT * FROM "users" INNER JOIN "posts" ON ("users"."id" = "posts"."userId")
+```
+
+## Tree Shaking
+
+Import only the dialect you need:
+
+```ts
+import { pamuk } from "pamuk";
+import { pgDialect } from "pamuk/pg";
+import { mysqlDialect } from "pamuk/mysql";
+import { sqliteDialect } from "pamuk/sqlite";
+import { serial, text } from "pamuk/schema";
+```
+
+## Dialects
+
+Same query, different SQL:
+
+```ts
+// PostgreSQL  → SELECT "id" FROM "users" WHERE ("id" = $1)
+// MySQL       → SELECT `id` FROM `users` WHERE (`id` = ?)
+// SQLite      → SELECT "id" FROM "users" WHERE ("id" = ?)
+```
+
+## Plugins
+
+```ts
+import { WithSchemaPlugin, SoftDeletePlugin, CamelCasePlugin } from "pamuk";
+
+const db = pamuk({
+  dialect: pgDialect(),
+  plugins: [
+    new WithSchemaPlugin("public"),
+    new SoftDeletePlugin({ tables: ["users"] }),
+  ],
+  tables: { ... },
+});
+
+// SELECT * FROM "public"."users" WHERE ("deleted_at" IS NULL)
+```
+
+## Hooks
+
+```ts
+// Query logging
+db.hook("query:after", (ctx) => {
+  console.log(`[SQL] ${ctx.query.sql}`);
+});
+
+// Add request tracing
+db.hook("query:after", (ctx) => {
+  return {
+    ...ctx.query,
+    sql: `${ctx.query.sql} /* request_id=${requestId} */`,
+  };
+});
+
+// Modify AST before compilation
+db.hook("select:before", (ctx) => {
+  // Add tenant isolation, audit filters, etc.
+});
+
+// Transform results
+db.hook("result:transform", (rows) => {
+  return rows.map(toCamelCase);
+});
+
+// Unregister
+const off = db.hook("query:before", handler);
+off();
+```
+
+## Expression API
+
+```ts
+.where(({ id }) => id.eq(42))              // "id" = $1
+.where(({ name }) => name.like("%ali%"))    // "name" LIKE '%ali%'
+.where(({ age }) => age.between(18, 65))    // "age" BETWEEN $1 AND $2
+.where(({ id }) => id.in([1, 2, 3]))       // "id" IN ($1, $2, $3)
+.where(({ bio }) => bio.isNull())           // "bio" IS NULL
+.where(({ email }) => email.isNotNull())    // "email" IS NOT NULL
+.where(({ a, b }) =>                        // ("a" > $1 AND "b" != $2)
+  and(a.gt(0), b.neq("x")),
+)
+.where(({ a, b }) =>                        // ("a" = $1 OR "b" = $2)
+  or(a.eq(1), b.eq(2)),
+)
+```
+
+## Why lale?
+
+|                    | lale              | Drizzle         | Kysely         |
+| ------------------ | ----------------- | --------------- | -------------- |
+| **Architecture**   | AST-first         | Template        | AST (98 nodes) |
+| **Type inference** | Auto (no codegen) | Auto            | Manual DB type |
+| **Plugin system**  | Hooks + plugins   | None            | Plugins only   |
+| **SQL printer**    | Wadler algebra    | Template concat | String append  |
+| **Dependencies**   | 0                 | 0               | 0              |
+| **Node types**     | ~35 (focused)     | Config objects  | 98 (complex)   |
+| **API style**      | Callback proxy    | Method chain    | Method chain   |
+
+## Architecture
+
+```
+Schema → Builder → AST → Plugin/Hook → Printer → SQL
+```
+
+- **Schema Layer** — `defineTable()`, `ColumnType<S,I,U>`, auto type inference
+- **Builder Layer** — `Lale<DB>`, `TypedSelectBuilder<DB,TB,O>`, proxy-based expressions
+- **AST Layer** — ~35 frozen node types, discriminated unions, visitor pattern
+- **Plugin Layer** — `LalePlugin` interface, `Hookable` lifecycle hooks
+- **Printer Layer** — `BasePrinter` with dialect subclasses, Wadler document algebra
+
+## License
+
+[MIT](./LICENSE)

package/dist/_chunks/base.mjs

@@ -0,0 +1 @@
+function e(e,t){switch(t){case`pg`:case`sqlite`:return`"${e.replaceAll(`"`,`""`)}"`;case`mysql`:return`\`${e.replaceAll("`","``")}\``}}function t(t,n,r){return r?`${e(r,n)}.${e(t,n)}`:e(t,n)}function n(e,t){switch(t){case`pg`:return`$${e+1}`;case`mysql`:case`sqlite`:return`?`}}var r=class{params=[];dialect;constructor(e){this.dialect=e}print(e){return this.params=[],{sql:this.printNode(e),params:[...this.params]}}printNode(e){switch(e.type){case`select`:return this.printSelect(e);case`insert`:return this.printInsert(e);case`update`:return this.printUpdate(e);case`delete`:return this.printDelete(e);default:return this.printExpression(e)}}printSelect(e){let t=[];e.ctes.length>0&&t.push(this.printCTEs(e.ctes)),t.push(`SELECT`),e.distinct&&t.push(`DISTINCT`),e.columns.length===0?t.push(`*`):t.push(e.columns.map(e=>this.printExpression(e)).join(`, `)),e.from&&(t.push(`FROM`),e.from.type===`subquery`?t.push(this.printSubquery(e.from)):t.push(this.printTableRef(e.from)));for(let n of e.joins)t.push(this.printJoin(n));return e.where&&t.push(`WHERE`,this.printExpression(e.where)),e.groupBy.length>0&&t.push(`GROUP BY`,e.groupBy.map(e=>this.printExpression(e)).join(`, `)),e.having&&t.push(`HAVING`,this.printExpression(e.having)),e.orderBy.length>0&&t.push(`ORDER BY`,e.orderBy.map(e=>this.printOrderBy(e)).join(`, `)),e.limit&&t.push(`LIMIT`,this.printExpression(e.limit)),e.offset&&t.push(`OFFSET`,this.printExpression(e.offset)),e.setOp&&t.push(e.setOp.op,this.printSelect(e.setOp.query)),e.forUpdate&&t.push(`FOR UPDATE`),t.join(` `)}printInsert(t){let n=[];t.ctes.length>0&&n.push(this.printCTEs(t.ctes)),n.push(`INSERT INTO`,this.printTableRef(t.table)),t.columns.length>0&&n.push(`(${t.columns.map(t=>e(t,this.dialect)).join(`, `)})`),n.push(`VALUES`);let r=t.values.map(e=>`(${e.map(e=>this.printExpression(e)).join(`, `)})`);return n.push(r.join(`, `)),t.onConflict&&n.push(this.printOnConflict(t.onConflict)),t.returning.length>0&&n.push(`RETURNING`,t.returning.map(e=>this.printExpression(e)).join(`, `)),n.join(` `)}printOnConflict(t){let n=[`ON CONFLICT`];if(t.columns.length>0&&n.push(`(${t.columns.map(t=>e(t,this.dialect)).join(`, `)})`),t.action===`nothing`)n.push(`DO NOTHING`);else{n.push(`DO UPDATE SET`);let r=t.action.set.map(t=>`${e(t.column,this.dialect)} = ${this.printExpression(t.value)}`);n.push(r.join(`, `))}return t.where&&n.push(`WHERE`,this.printExpression(t.where)),n.join(` `)}printUpdate(t){let n=[];t.ctes.length>0&&n.push(this.printCTEs(t.ctes)),n.push(`UPDATE`,this.printTableRef(t.table),`SET`);let r=t.set.map(t=>`${e(t.column,this.dialect)} = ${this.printExpression(t.value)}`);return n.push(r.join(`, `)),t.from&&n.push(`FROM`,this.printTableRef(t.from)),t.where&&n.push(`WHERE`,this.printExpression(t.where)),t.returning.length>0&&n.push(`RETURNING`,t.returning.map(e=>this.printExpression(e)).join(`, `)),n.join(` `)}printDelete(e){let t=[];return e.ctes.length>0&&t.push(this.printCTEs(e.ctes)),t.push(`DELETE FROM`,this.printTableRef(e.table)),e.where&&t.push(`WHERE`,this.printExpression(e.where)),e.returning.length>0&&t.push(`RETURNING`,e.returning.map(e=>this.printExpression(e)).join(`, `)),t.join(` `)}printExpression(e){switch(e.type){case`column_ref`:return this.printColumnRef(e);case`literal`:return this.printLiteral(e);case`binary_op`:return this.printBinaryOp(e);case`unary_op`:return this.printUnaryOp(e);case`function_call`:return this.printFunctionCall(e);case`param`:return this.printParam(e);case`raw`:return this.printRaw(e);case`subquery`:return this.printSubquery(e);case`between`:return this.printBetween(e);case`in`:return this.printIn(e);case`is_null`:return this.printIsNull(e);case`cast`:return this.printCast(e);case`exists`:return this.printExists(e);case`star`:return this.printStar(e);case`case`:return this.printCase(e);case`json_access`:return this.printJsonAccess(e);case`array_expr`:return this.printArrayExpr(e);case`window_function`:return this.printWindowFunction(e)}}printColumnRef(t){let n=t.table?`${e(t.table,this.dialect)}.${e(t.column,this.dialect)}`:e(t.column,this.dialect);return t.alias&&(n+=` AS ${e(t.alias,this.dialect)}`),n}printLiteral(e){return e.value===null?`NULL`:typeof e.value==`boolean`?e.value?`TRUE`:`FALSE`:typeof e.value==`number`?String(e.value):`'${String(e.value).replaceAll(`'`,`''`)}'`}printBinaryOp(e){return`(${this.printExpression(e.left)} ${e.op} ${this.printExpression(e.right)})`}printUnaryOp(e){return e.position===`postfix`?`(${this.printExpression(e.operand)} ${e.op})`:`(${e.op} ${this.printExpression(e.operand)})`}printFunctionCall(t){let n=`${t.name}(${t.args.map(e=>this.printExpression(e)).join(`, `)})`;return t.alias&&(n+=` AS ${e(t.alias,this.dialect)}`),n}printParam(e){return this.params.push(e.value),n(this.params.length-1,this.dialect)}printRaw(e){return this.params.push(...e.params),e.sql}printSubquery(t){let n=`(${this.printSelect(t.query)})`;return t.alias&&(n+=` AS ${e(t.alias,this.dialect)}`),n}printBetween(e){let t=e.negated?`NOT `:``;return`(${this.printExpression(e.expr)} ${t}BETWEEN ${this.printExpression(e.low)} AND ${this.printExpression(e.high)})`}printIn(e){let t=e.negated?`NOT `:``;return Array.isArray(e.values)?`(${this.printExpression(e.expr)} ${t}IN (${e.values.map(e=>this.printExpression(e)).join(`, `)}))`:`(${this.printExpression(e.expr)} ${t}IN (${this.printSelect(e.values)}))`}printIsNull(e){let t=e.negated?` NOT`:``;return`(${this.printExpression(e.expr)} IS${t} NULL)`}printCase(e){let t=[`CASE`];e.operand&&t.push(this.printExpression(e.operand));for(let n of e.whens)t.push(`WHEN`,this.printExpression(n.condition),`THEN`,this.printExpression(n.result));return e.else_&&t.push(`ELSE`,this.printExpression(e.else_)),t.push(`END`),t.join(` `)}printCast(e){return`CAST(${this.printExpression(e.expr)} AS ${e.dataType})`}printExists(e){return`(${e.negated?`NOT `:``}EXISTS (${this.printSelect(e.query)}))`}printStar(t){return t.table?`${e(t.table,this.dialect)}.*`:`*`}printTableRef(n){let r=t(n.name,this.dialect,n.schema);return n.alias&&(r+=` AS ${e(n.alias,this.dialect)}`),r}printJoin(e){let t=[];return t.push(`${e.joinType} JOIN`),e.table.type===`subquery`?t.push(this.printSubquery(e.table)):t.push(this.printTableRef(e.table)),e.on&&t.push(`ON`,this.printExpression(e.on)),t.join(` `)}printOrderBy(e){let t=`${this.printExpression(e.expr)} ${e.direction}`;return e.nulls&&(t+=` NULLS ${e.nulls}`),t}printCTEs(t){return`${t.some(e=>e.recursive)?`WITH RECURSIVE`:`WITH`} ${t.map(t=>`${e(t.name,this.dialect)} AS (${this.printSelect(t.query)})`).join(`, `)}`}printJsonAccess(t){let n=`${this.printExpression(t.expr)}${t.operator}${this.printLiteral({type:`literal`,value:t.path})}`;return t.alias&&(n+=` AS ${e(t.alias,this.dialect)}`),n}printArrayExpr(e){return`ARRAY[${e.elements.map(e=>this.printExpression(e)).join(`, `)}]`}printWindowFunction(t){let n=[];n.push(this.printFunctionCall(t.fn)),n.push(`OVER`);let r=[];return t.partitionBy.length>0&&r.push(`PARTITION BY ${t.partitionBy.map(e=>this.printExpression(e)).join(`, `)}`),t.orderBy.length>0&&r.push(`ORDER BY ${t.orderBy.map(e=>this.printOrderBy(e)).join(`, `)}`),t.frame&&r.push(this.printFrameSpec(t.frame)),n.push(`(${r.join(` `)})`),t.alias&&n.push(`AS`,e(t.alias,this.dialect)),n.join(` `)}printFrameSpec(e){let t=this.printFrameBound(e.start);return e.end?`${e.kind} BETWEEN ${t} AND ${this.printFrameBound(e.end)}`:`${e.kind} ${t}`}printFrameBound(e){switch(e.type){case`unbounded_preceding`:return`UNBOUNDED PRECEDING`;case`preceding`:return`${e.value} PRECEDING`;case`current_row`:return`CURRENT ROW`;case`following`:return`${e.value} FOLLOWING`;case`unbounded_following`:return`UNBOUNDED FOLLOWING`}}};export{t as i,n,e as r,r as t};

package/dist/_chunks/errors.mjs

@@ -0,0 +1 @@
+var e=class extends Error{constructor(e){super(e),this.name=`PamukError`}},t=class extends e{constructor(e){super(e),this.name=`InvalidExpressionError`}},n=class extends e{constructor(e,t){super(`${t} is not supported in ${e}`),this.name=`UnsupportedDialectFeatureError`}},r=class extends e{constructor(e){super(`Cannot build ${e}: missing required clauses`),this.name=`EmptyQueryError`}};export{n as i,t as n,e as r,r as t};

package/dist/_chunks/index.d.mts

@@ -0,0 +1,119 @@
+/**
+ * Three-phase column type: Select, Insert, Update.
+ *
+ * S = type returned on SELECT
+ * I = type accepted on INSERT
+ * U = type accepted on UPDATE
+ */
+interface ColumnType<S, I = S, U = I> {
+  readonly __select: S;
+  readonly __insert: I;
+  readonly __update: U;
+}
+/** DB generates this value (autoincrement, default). Optional on INSERT/UPDATE. */
+type Generated<T> = ColumnType<T, T | undefined, T | undefined>;
+/** DB always generates (identity always). Never provided by user. */
+type GeneratedAlways<T> = ColumnType<T, never, never>;
+/** Extract the SELECT type from a column. */
+type SelectType<C> = C extends ColumnType<infer S, any, any> ? S : C;
+/** Extract the INSERT type from a column. */
+type InsertType<C> = C extends ColumnType<any, infer I, any> ? I : C;
+/** Extract the UPDATE type from a column. */
+type UpdateType<C> = C extends ColumnType<any, any, infer U> ? U : C;
+/** Make all properties nullable. */
+type Nullable$1<T> = { [K in keyof T]: T[K] | null };
+/**
+ * Infer a SELECT row type from a table column map.
+ * Every column present, nullable columns include null.
+ */
+type Selectable<T> = { [K in keyof T]: SelectType<T[K]> };
+/**
+ * Infer an INSERT row type from a table column map.
+ * Required columns: non-nullable without default.
+ * Optional columns: nullable, has default, or generated.
+ */
+type Insertable<T> = { [K in keyof T as IsRequired<T[K]> extends true ? K : never]: InsertType<T[K]> } & { [K in keyof T as IsRequired<T[K]> extends true ? never : K]?: InsertType<T[K]> };
+/**
+ * Infer an UPDATE row type. All columns optional.
+ */
+type Updateable<T> = { [K in keyof T]?: UpdateType<T[K]> };
+/**
+ * A column is required on INSERT if its InsertType does NOT include undefined or never.
+ */
+type IsRequired<C> = InsertType<C> extends never ? false : undefined extends InsertType<C> ? false : true;
+interface ColumnDef {
+  readonly dataType: string;
+  readonly isNotNull: boolean;
+  readonly hasDefault: boolean;
+  readonly isPrimaryKey: boolean;
+  readonly isGenerated: boolean;
+  readonly references?: {
+    table: string;
+    column: string;
+  };
+}
+declare class ColumnBuilder<S, I = S, U = I> {
+  /** @internal */
+  readonly _def: ColumnDef;
+  /** Phantom type — never exists at runtime */
+  readonly _type: ColumnType<S, I, U>;
+  constructor(dataType: string, def?: Partial<ColumnDef>);
+  notNull(): ColumnBuilder<Exclude<S, null>, Exclude<I, null>, Exclude<U, null>>;
+  nullable(): ColumnBuilder<S | null, I | null | undefined, U | null | undefined>;
+  defaultTo(_value: I): ColumnBuilder<S, I | undefined, U>;
+  primaryKey(): ColumnBuilder<S, I, U>;
+  references(table: string, column: string): ColumnBuilder<S, I, U>;
+}
+declare function integer(): ColumnBuilder<number, number, number>;
+declare function bigint(): ColumnBuilder<bigint, bigint | number, bigint | number>;
+declare function smallint(): ColumnBuilder<number, number, number>;
+declare function serial(): ColumnBuilder<number, number | undefined, number>;
+declare function bigserial(): ColumnBuilder<bigint, bigint | undefined, bigint>;
+declare function text(): ColumnBuilder<string, string, string>;
+declare function varchar(length?: number): ColumnBuilder<string, string, string>;
+declare function char(length?: number): ColumnBuilder<string, string, string>;
+declare function boolean(): ColumnBuilder<boolean, boolean, boolean>;
+declare function timestamp(): ColumnBuilder<Date, Date | string, Date | string>;
+declare function timestamptz(): ColumnBuilder<Date, Date | string, Date | string>;
+declare function date(): ColumnBuilder<Date, Date | string, Date | string>;
+declare function time(): ColumnBuilder<string, string, string>;
+declare function uuid(): ColumnBuilder<string, string, string>;
+declare function json<T = unknown>(): ColumnBuilder<T, T, T>;
+declare function jsonb<T = unknown>(): ColumnBuilder<T, T, T>;
+declare function numeric(precision?: number, scale?: number): ColumnBuilder<string, string | number, string | number>;
+declare function real(): ColumnBuilder<number, number, number>;
+declare function doublePrecision(): ColumnBuilder<number, number, number>;
+declare function bytea(): ColumnBuilder<Buffer, Buffer | Uint8Array, Buffer | Uint8Array>;
+declare function enumType<T extends string>(...values: [T, ...T[]]): ColumnBuilder<T, T, T>;
+interface TableDefinition<TName extends string = string, TColumns extends Record<string, ColumnBuilder<any, any, any>> = Record<string, ColumnBuilder<any, any, any>>> {
+  readonly name: TName;
+  readonly columns: TColumns;
+}
+/**
+ * Define a table schema with typed columns.
+ *
+ * ```ts
+ * const users = defineTable("users", {
+ *   id: serial().primaryKey(),
+ *   name: text().notNull(),
+ *   email: text().notNull(),
+ *   active: boolean().defaultTo(true),
+ * });
+ * ```
+ */
+declare function defineTable<TName extends string, TColumns extends Record<string, ColumnBuilder<any, any, any>>>(name: TName, columns: TColumns): TableDefinition<TName, TColumns>;
+/**
+ * Extract the column type map from a table definition.
+ * Used to build the DB type.
+ *
+ * ```ts
+ * type DB = {
+ *   users: InferTable<typeof usersTable>;
+ *   posts: InferTable<typeof postsTable>;
+ * };
+ * ```
+ */
+type InferTable<T extends TableDefinition> = T extends TableDefinition<any, infer Cols> ? { [K in keyof Cols]: Cols[K] extends ColumnBuilder<infer S, infer I, infer U> ? ColumnType<S, I, U> : never } : never;
+/** Make all properties of T nullable */
+type Nullable<T> = { [K in keyof T]: T[K] | null };
+export { GeneratedAlways as A, time as C, varchar as D, uuid as E, Selectable as F, UpdateType as I, Updateable as L, Insertable as M, Nullable$1 as N, ColumnType as O, SelectType as P, text as S, timestamptz as T, jsonb as _, ColumnBuilder as a, serial as b, bigserial as c, char as d, date as f, json as g, integer as h, defineTable as i, InsertType as j, Generated as k, boolean as l, enumType as m, InferTable as n, ColumnDef as o, doublePrecision as p, TableDefinition as r, bigint as s, Nullable as t, bytea as u, numeric as v, timestamp as w, smallint as x, real as y };

package/dist/_chunks/mysql.d.mts

@@ -0,0 +1,8 @@
+import { S as InsertNode, j as SelectNode, n as BasePrinter, t as Dialect } from "./types.mjs";
+declare class MysqlPrinter extends BasePrinter {
+  constructor();
+  protected printInsert(node: InsertNode): string;
+  protected printSelect(node: SelectNode): string;
+}
+declare function mysqlDialect(): Dialect;
+export { MysqlPrinter as n, mysqlDialect as t };

package/dist/_chunks/mysql.mjs

@@ -0,0 +1 @@
+import{t as e}from"./base.mjs";import{i as t}from"./errors.mjs";var n=class extends e{constructor(){super(`mysql`)}printInsert(e){if(e.returning.length>0)throw new t(`mysql`,`RETURNING`);return super.printInsert(e)}printSelect(e){return e.forUpdate,super.printSelect(e)}};function r(){return{name:`mysql`,createPrinter(){return new n}}}export{n,r as t};

package/dist/_chunks/pg.d.mts

@@ -0,0 +1,7 @@
+import { S as InsertNode, n as BasePrinter, t as Dialect } from "./types.mjs";
+declare class PgPrinter extends BasePrinter {
+  constructor();
+  protected printInsert(node: InsertNode): string;
+}
+declare function pgDialect(): Dialect;
+export { PgPrinter as n, pgDialect as t };

package/dist/_chunks/pg.mjs

@@ -0,0 +1 @@
+import{t as e}from"./base.mjs";var t=class extends e{constructor(){super(`pg`)}printInsert(e){return super.printInsert(e)}};function n(){return{name:`pg`,createPrinter(){return new t}}}export{t as n,n as t};

package/dist/_chunks/schema.mjs

@@ -0,0 +1 @@
+var e=class e{_def;constructor(e,t){this._def={dataType:e,isNotNull:!1,hasDefault:!1,isPrimaryKey:!1,isGenerated:!1,...t}}notNull(){return new e(this._def.dataType,{...this._def,isNotNull:!0})}nullable(){return new e(this._def.dataType,{...this._def,isNotNull:!1})}defaultTo(t){return new e(this._def.dataType,{...this._def,hasDefault:!0})}primaryKey(){return new e(this._def.dataType,{...this._def,isPrimaryKey:!0,isNotNull:!0})}references(t,n){return new e(this._def.dataType,{...this._def,references:{table:t,column:n}})}};function t(){return new e(`integer`)}function n(){return new e(`bigint`)}function r(){return new e(`smallint`)}function i(){return new e(`serial`,{hasDefault:!0,isNotNull:!0,isPrimaryKey:!0})}function a(){return new e(`bigserial`,{hasDefault:!0,isNotNull:!0})}function o(){return new e(`text`)}function s(t){return new e(t?`varchar(${t})`:`varchar`)}function c(t){return new e(t?`char(${t})`:`char`)}function l(){return new e(`boolean`)}function u(){return new e(`timestamp`)}function d(){return new e(`timestamptz`)}function f(){return new e(`date`)}function p(){return new e(`time`)}function m(){return new e(`uuid`)}function h(){return new e(`json`)}function g(){return new e(`jsonb`)}function _(t,n){return new e(t==null?`numeric`:n==null?`numeric(${t})`:`numeric(${t},${n})`)}function v(){return new e(`real`)}function y(){return new e(`double precision`)}function b(){return new e(`bytea`)}function x(...t){return new e(`enum(${t.map(e=>`'${e}'`).join(`,`)})`)}function S(e,t){return Object.freeze({name:e,columns:t})}export{s as C,m as S,r as _,l as a,u as b,f as c,t as d,h as f,i as g,v as h,a as i,y as l,_ as m,e as n,b as o,g as p,n as r,c as s,S as t,x as u,o as v,d as x,p as y};

package/dist/_chunks/sqlite.d.mts

@@ -0,0 +1,8 @@
+import { S as InsertNode, j as SelectNode, n as BasePrinter, t as Dialect } from "./types.mjs";
+declare class SqlitePrinter extends BasePrinter {
+  constructor();
+  protected printSelect(node: SelectNode): string;
+  protected printInsert(node: InsertNode): string;
+}
+declare function sqliteDialect(): Dialect;
+export { SqlitePrinter as n, sqliteDialect as t };

package/dist/_chunks/sqlite.mjs

@@ -0,0 +1 @@
+import{t as e}from"./base.mjs";import{i as t}from"./errors.mjs";var n=class extends e{constructor(){super(`sqlite`)}printSelect(e){if(e.forUpdate)throw new t(`sqlite`,`FOR UPDATE`);return super.printSelect(e)}printInsert(e){return super.printInsert(e)}};function r(){return{name:`sqlite`,createPrinter(){return new n}}}export{n,r as t};

package/dist/_chunks/types.d.mts

@@ -0,0 +1,274 @@
+type SQLDialect = "pg" | "mysql" | "sqlite";
+interface CompiledQuery {
+  sql: string;
+  params: readonly unknown[];
+}
+type Primitive = string | number | boolean | null;
+type OrderDirection = "ASC" | "DESC";
+type JoinType = "INNER" | "LEFT" | "RIGHT" | "FULL" | "CROSS";
+type SetOperator = "UNION" | "UNION ALL" | "INTERSECT" | "EXCEPT";
+interface DialectConfig {
+  name: SQLDialect;
+  quoteIdentifier(name: string): string;
+  formatParam(index: number): string;
+}
+type ASTNode = SelectNode | InsertNode | UpdateNode | DeleteNode | ExpressionNode;
+type ExpressionNode = ColumnRefNode | LiteralNode | BinaryOpNode | UnaryOpNode | FunctionCallNode | ParamNode | RawNode | SubqueryNode | BetweenNode | InNode | IsNullNode | CaseNode | CastNode | ExistsNode | StarNode | JsonAccessNode | ArrayExprNode | WindowFunctionNode;
+interface ColumnRefNode {
+  type: "column_ref";
+  table?: string;
+  column: string;
+  alias?: string;
+}
+interface LiteralNode {
+  type: "literal";
+  value: string | number | boolean | null;
+}
+interface BinaryOpNode {
+  type: "binary_op";
+  op: string;
+  left: ExpressionNode;
+  right: ExpressionNode;
+}
+interface UnaryOpNode {
+  type: "unary_op";
+  op: string;
+  operand: ExpressionNode;
+  position: "prefix" | "postfix";
+}
+interface FunctionCallNode {
+  type: "function_call";
+  name: string;
+  args: ExpressionNode[];
+  alias?: string;
+}
+interface ParamNode {
+  type: "param";
+  index: number;
+  value: unknown;
+}
+interface RawNode {
+  type: "raw";
+  sql: string;
+  params: unknown[];
+}
+interface SubqueryNode {
+  type: "subquery";
+  query: SelectNode;
+  alias?: string;
+}
+interface BetweenNode {
+  type: "between";
+  expr: ExpressionNode;
+  low: ExpressionNode;
+  high: ExpressionNode;
+  negated: boolean;
+}
+interface InNode {
+  type: "in";
+  expr: ExpressionNode;
+  values: ExpressionNode[] | SelectNode;
+  negated: boolean;
+}
+interface IsNullNode {
+  type: "is_null";
+  expr: ExpressionNode;
+  negated: boolean;
+}
+interface CaseNode {
+  type: "case";
+  operand?: ExpressionNode;
+  whens: {
+    condition: ExpressionNode;
+    result: ExpressionNode;
+  }[];
+  else_?: ExpressionNode;
+}
+interface CastNode {
+  type: "cast";
+  expr: ExpressionNode;
+  dataType: string;
+}
+interface ExistsNode {
+  type: "exists";
+  query: SelectNode;
+  negated: boolean;
+}
+interface StarNode {
+  type: "star";
+  table?: string;
+}
+interface TableRefNode {
+  type: "table_ref";
+  name: string;
+  alias?: string;
+  schema?: string;
+}
+interface JoinNode {
+  type: "join";
+  joinType: JoinType;
+  table: TableRefNode | SubqueryNode;
+  on?: ExpressionNode;
+}
+interface JsonAccessNode {
+  type: "json_access";
+  expr: ExpressionNode;
+  path: string;
+  operator: "->" | "->>" | "#>" | "#>>";
+  alias?: string;
+}
+interface ArrayExprNode {
+  type: "array_expr";
+  elements: ExpressionNode[];
+}
+type FrameKind = "ROWS" | "RANGE" | "GROUPS";
+type FrameBound = {
+  type: "unbounded_preceding";
+} | {
+  type: "preceding";
+  value: number;
+} | {
+  type: "current_row";
+} | {
+  type: "following";
+  value: number;
+} | {
+  type: "unbounded_following";
+};
+interface FrameSpec {
+  kind: FrameKind;
+  start: FrameBound;
+  end?: FrameBound;
+}
+interface WindowFunctionNode {
+  type: "window_function";
+  fn: FunctionCallNode;
+  partitionBy: ExpressionNode[];
+  orderBy: OrderByNode[];
+  frame?: FrameSpec;
+  alias?: string;
+}
+interface OrderByNode {
+  expr: ExpressionNode;
+  direction: OrderDirection;
+  nulls?: "FIRST" | "LAST";
+}
+interface CTENode {
+  name: string;
+  query: SelectNode;
+  recursive: boolean;
+}
+interface SelectNode {
+  type: "select";
+  distinct: boolean;
+  columns: ExpressionNode[];
+  from?: TableRefNode | SubqueryNode;
+  joins: JoinNode[];
+  where?: ExpressionNode;
+  groupBy: ExpressionNode[];
+  having?: ExpressionNode;
+  orderBy: OrderByNode[];
+  limit?: ExpressionNode;
+  offset?: ExpressionNode;
+  ctes: CTENode[];
+  setOp?: {
+    op: SetOperator;
+    query: SelectNode;
+  };
+  forUpdate: boolean;
+}
+interface InsertNode {
+  type: "insert";
+  table: TableRefNode;
+  columns: string[];
+  values: ExpressionNode[][];
+  returning: ExpressionNode[];
+  onConflict?: OnConflictNode;
+  ctes: CTENode[];
+}
+interface OnConflictNode {
+  columns: string[];
+  action: "nothing" | {
+    set: {
+      column: string;
+      value: ExpressionNode;
+    }[];
+  };
+  where?: ExpressionNode;
+}
+interface UpdateNode {
+  type: "update";
+  table: TableRefNode;
+  set: {
+    column: string;
+    value: ExpressionNode;
+  }[];
+  where?: ExpressionNode;
+  returning: ExpressionNode[];
+  from?: TableRefNode;
+  ctes: CTENode[];
+}
+interface DeleteNode {
+  type: "delete";
+  table: TableRefNode;
+  where?: ExpressionNode;
+  returning: ExpressionNode[];
+  ctes: CTENode[];
+}
+declare function tableRef(name: string, alias?: string, schema?: string): TableRefNode;
+declare function createSelectNode(): SelectNode;
+declare function createInsertNode(table: TableRefNode): InsertNode;
+declare function createUpdateNode(table: TableRefNode): UpdateNode;
+declare function createDeleteNode(table: TableRefNode): DeleteNode;
+type PrintMode = "compact" | "formatted" | "debug";
+interface PrinterOptions {
+  dialect: SQLDialect;
+  mode?: PrintMode;
+  indent?: string;
+  width?: number;
+}
+interface Printer {
+  print(node: ASTNode): CompiledQuery;
+}
+declare class BasePrinter implements Printer {
+  protected params: unknown[];
+  protected dialect: SQLDialect;
+  constructor(dialect: SQLDialect);
+  print(node: ASTNode): CompiledQuery;
+  protected printNode(node: ASTNode): string;
+  protected printSelect(node: SelectNode): string;
+  protected printInsert(node: InsertNode): string;
+  protected printOnConflict(node: OnConflictNode): string;
+  protected printUpdate(node: UpdateNode): string;
+  protected printDelete(node: DeleteNode): string;
+  protected printExpression(node: ExpressionNode): string;
+  protected printColumnRef(node: ColumnRefNode): string;
+  protected printLiteral(node: LiteralNode): string;
+  protected printBinaryOp(node: BinaryOpNode): string;
+  protected printUnaryOp(node: UnaryOpNode): string;
+  protected printFunctionCall(node: FunctionCallNode): string;
+  protected printParam(node: ParamNode): string;
+  protected printRaw(node: RawNode): string;
+  protected printSubquery(node: SubqueryNode): string;
+  protected printBetween(node: BetweenNode): string;
+  protected printIn(node: InNode): string;
+  protected printIsNull(node: IsNullNode): string;
+  protected printCase(node: CaseNode): string;
+  protected printCast(node: CastNode): string;
+  protected printExists(node: ExistsNode): string;
+  protected printStar(node: StarNode): string;
+  protected printTableRef(ref: TableRefNode): string;
+  protected printJoin(node: JoinNode): string;
+  protected printOrderBy(node: OrderByNode): string;
+  protected printCTEs(ctes: CTENode[]): string;
+  protected printJsonAccess(node: JsonAccessNode): string;
+  protected printArrayExpr(node: ArrayExprNode): string;
+  protected printWindowFunction(node: WindowFunctionNode): string;
+  protected printFrameSpec(frame: FrameSpec): string;
+  protected printFrameBound(bound: FrameBound): string;
+}
+interface Dialect {
+  name: SQLDialect;
+  createPrinter(): Printer;
+}
+export { RawNode as A, createSelectNode as B, IsNullNode as C, OnConflictNode as D, LiteralNode as E, UnaryOpNode as F, JoinType as G, tableRef as H, UpdateNode as I, SQLDialect as J, OrderDirection as K, WindowFunctionNode as L, StarNode as M, SubqueryNode as N, OrderByNode as O, TableRefNode as P, createDeleteNode as R, InsertNode as S, JsonAccessNode as T, CompiledQuery as U, createUpdateNode as V, DialectConfig as W, SetOperator as Y, FrameBound as _, PrinterOptions as a, FunctionCallNode as b, BetweenNode as c, CaseNode as d, CastNode as f, ExpressionNode as g, ExistsNode as h, Printer as i, SelectNode as j, ParamNode as k, BinaryOpNode as l, DeleteNode as m, BasePrinter as n, ASTNode as o, ColumnRefNode as p, Primitive as q, PrintMode as r, ArrayExprNode as s, Dialect as t, CTENode as u, FrameKind as v, JoinNode as w, InNode as x, FrameSpec as y, createInsertNode as z };