@vanit-co/sql-ts 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vanit
+
+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,460 @@
+# @vanit-co/sql-ts
+
+A TypeScript SQL query builder using tagged template literals. Write plain SQL with safe, automatic parameter binding and properly quoted identifiers. No DSL to learn, no magic, no ORM.
+
+Supports **MySQL** (`?` placeholders, `` ` `` backtick identifiers) and **PostgreSQL** (`$n` placeholders, `"` double-quote identifiers) out of the box.
+
+## Installation
+
+```sh
+npm install @vanit-co/sql-ts
+```
+
+## Quick example
+
+```ts
+import { schema, select, where, all } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+
+const query = select`SELECT ${all(users)} FROM ${users} WHERE ${users.id} = ${42}`
+
+// PostgreSQL
+console.log(query.text)   // SELECT "users"."id" ,"users"."email" FROM "users" "users" WHERE "users"."id" = $1
+console.log(query.values) // [42]
+
+// MySQL
+console.log(query.sql)    // SELECT `users`.`id` ,`users`.`email` FROM `users` `users` WHERE `users`.`id` = ?
+```
+
+---
+
+## Core concepts
+
+### Schema
+
+Define your tables once. The schema carries table and column metadata used by the template tags to produce properly quoted, prefixed identifiers.
+
+```ts
+import { schema } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+
+// With a table alias (useful for self-joins or verbose table names)
+const u = schema({ table: 'users', columns: ['id', 'email'], alias: 'u' })
+```
+
+`schema` takes:
+| field | type | description |
+|-------|------|-------------|
+| `table` | `string` | The actual table name in the database |
+| `columns` | `string[]` | Column names to expose as typed properties |
+| `alias` | `string` (optional) | Alias used for prefixing columns; defaults to `table` |
+
+After calling `schema`, the returned object has a typed property for each column (`users.id`, `users.email`, etc.).
+
+---
+
+### Result object
+
+Every template tag and statement builder returns a `Result` object with three properties:
+
+| property | description |
+|----------|-------------|
+| `.sql` | Query string in MySQL format (`?` placeholders, backtick-quoted identifiers) |
+| `.text` | Query string in PostgreSQL format (`$n` placeholders, double-quote identifiers) |
+| `.values` | Array of bind values in order, ready to pass to your database driver |
+
+Pass these directly to your driver:
+
+```ts
+// node-postgres (pg)
+await client.query(query)
+
+// mysql2
+await connection.query(query)
+```
+
+---
+
+## Template tag functions
+
+### `sql`
+
+The base tag. Interpolated plain values become bind parameters. Interpolated schema tables become their bare name identifier; columns become their bare column name identifier (no table prefix).
+
+```ts
+import { sql } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+
+// Plain values → bind parameters
+const q1 = sql`SELECT * FROM users WHERE id = ${42}`
+q1.text   // SELECT * FROM users WHERE id = $1
+q1.values // [42]
+
+// Schema table → quoted identifier (name only)
+const q2 = sql`FROM ${users}`
+q2.text   // FROM "users"
+
+// Schema column → quoted identifier (name only, no prefix)
+const q3 = sql`SELECT ${users.id}`
+q3.text   // SELECT "id"
+```
+
+### `select` (alias: `s`)
+
+Like `sql`, but schema tables are rendered as `"name" "alias"` and columns are rendered as `"alias"."column"`. Use this for `SELECT`, `FROM`, `JOIN`, and `WHERE` clauses when you want fully qualified column references.
+
+```ts
+import { select, s, schema } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+const u = schema({ table: 'users', columns: ['id', 'email'], alias: 'u' })
+
+// Table → name + alias
+select`FROM ${users}`.text  // FROM "users" "users"
+select`FROM ${u}`.text      // FROM "users" "u"
+
+// Column → alias.column
+select`SELECT ${users.email}`.text  // SELECT "users"."email"
+select`SELECT ${u.email}`.text      // SELECT "u"."email"
+
+// Mix with values
+select`SELECT ${users.id} WHERE id = ${7}`.text    // SELECT "users"."id" WHERE id = $1
+select`SELECT ${users.id} WHERE id = ${7}`.values  // [7]
+
+// Short alias
+s`SELECT ${users.id}`.text  // SELECT "users"."id"
+```
+
+### `selectAs` (alias: `sa`)
+
+Same as `select` for tables, but columns are rendered as `"alias"."column" as "alias_column"`. Use this when fetching from multiple joined tables and you want unambiguous aliased column names in the result set.
+
+```ts
+import { selectAs, sa, schema } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+const u = schema({ table: 'users', columns: ['id', 'email'], alias: 'u' })
+
+selectAs`SELECT ${users.id}`.text   // SELECT "users"."id" as "users_id"
+selectAs`SELECT ${users.email}`.text // SELECT "users"."email" as "users_email"
+
+// With alias
+sa`SELECT ${u.email}`.text  // SELECT "u"."email" as "u_email"
+```
+
+### `join` (alias: `j`) and `where` (alias: `w`)
+
+These are identical to `select`. They exist as semantic aliases so your query construction reads naturally.
+
+```ts
+import { select, join, j, where, w, schema } from '@vanit-co/sql-ts'
+
+const posts = schema({ table: 'posts', columns: ['id', 'user_id', 'title'] })
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+
+const q = select`SELECT ${posts.title}, ${users.email}`
+const fromClause  = join`FROM ${posts}`
+const joinClause  = join`JOIN ${users} ON ${posts.user_id} = ${users.id}`
+const whereClause = where`WHERE ${users.id} = ${99}`
+```
+
+---
+
+## Column helpers: `all` and `pick`
+
+Use these inside any template tag to expand multiple columns at once.
+
+### `all(...tables)`
+
+Expands every column from one or more schema tables.
+
+```ts
+import { select, selectAs, schema, all } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+const posts = schema({ table: 'posts', columns: ['title', 'body'] })
+
+// Single table
+select`SELECT ${all(users)}`.text
+// SELECT "users"."id" ,"users"."email"
+
+// Multiple tables
+select`SELECT ${all(users, posts)}`.text
+// SELECT "users"."id" ,"users"."email" ,"posts"."title" ,"posts"."body"
+
+// With selectAs for aliased columns
+selectAs`SELECT ${all(users)}`.text
+// SELECT "users"."id" as "users_id" ,"users"."email" as "users_email"
+```
+
+### `pick(...columns)`
+
+Expands a specific subset of columns from any tables.
+
+```ts
+import { select, selectAs, schema, pick } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email', 'name'] })
+const posts = schema({ table: 'posts', columns: ['title', 'body'] })
+
+// Pick from one table
+select`SELECT ${pick(users.id, users.email)}`.text
+// SELECT "users"."id" ,"users"."email"
+
+// Pick from different tables
+select`SELECT ${pick(users.id, posts.title)}`.text
+// SELECT "users"."id" ,"posts"."title"
+
+// With selectAs
+selectAs`SELECT ${pick(users.id, users.email)}`.text
+// SELECT "users"."id" as "users_id" ,"users"."email" as "users_email"
+```
+
+---
+
+## Statement builders: `insert` and `update`
+
+### `insert(table, ...rows)`
+
+Builds a parameterised `INSERT` statement. Accepts one or more row objects. Column names from the first row are used; table and column names are properly quoted identifiers (never bind params).
+
+```ts
+import { schema, insert } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+
+// Single row
+const q1 = insert(users, { id: 1, email: 'alice@example.com' })
+q1.text    // insert into "users" ("id" ,"email") values ($1 ,$2)
+q1.values  // [1, 'alice@example.com']
+
+// Multiple rows
+const q2 = insert(users,
+  { id: 1, email: 'alice@example.com' },
+  { id: 2, email: 'bob@example.com' }
+)
+q2.text    // insert into "users" ("id" ,"email") values ($1 ,$2) ,($3 ,$4)
+q2.values  // [1, 'alice@example.com', 2, 'bob@example.com']
+```
+
+### `update(table, colsVals)`
+
+Builds a parameterised `UPDATE ... SET ...` statement (without a `WHERE` clause — compose that separately using `concat`).
+
+```ts
+import { schema, update } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+
+const q = update(users, { email: 'new@example.com' })
+q.text    // update "users" set "email" = $1
+q.values  // ['new@example.com']
+
+// Multiple columns
+const q2 = update(users, { id: 99, email: 'updated@example.com' })
+q2.text    // update "users" set "id" = $1 ,"email" = $2
+q2.values  // [99, 'updated@example.com']
+```
+
+---
+
+## Fragment utilities: `concat` and `empty`
+
+### `concat`
+
+Joins two `Fragment` objects into one. `concat` is curried — `concat(right)(left)` appends `right` after `left`.
+
+```ts
+import { select, where, concat, schema } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'] })
+
+const base   = select`SELECT ${users.id} FROM ${users}`
+const clause = where`WHERE ${users.id} = ${5}`
+
+const full = concat(clause)(base)
+full.text    // SELECT "users"."id" FROM "users" "users" WHERE "users"."id" = $1
+full.values  // [5]
+```
+
+You can also use the `.append` method on a `Result`:
+
+```ts
+const full = base.append(where`WHERE ${users.id} = ${5}`)
+```
+
+
+**Composing queries with `pipe`**
+
+Because `concat` is curried, it fits naturally into a `pipe`. Each `concat(fragment)` call becomes one step in the pipeline, appending a fragment to the result of the previous step.
+
+Using **ramda** (already a dependency of this package):
+
+```ts
+import { pipe } from 'ramda'
+import { schema, selectAs, join, where, concat, all } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'], alias: 'u' })
+const posts = schema({ table: 'posts', columns: ['id', 'user_id', 'title'], alias: 'p' })
+
+const buildQuery = (userId: number) =>
+  pipe(
+    concat(join`  JOIN ${users} ON ${posts.user_id} = ${users.id}`),
+    concat(where` WHERE ${users.id} = ${userId}`)
+  )(selectAs`SELECT ${all(users, posts)} FROM ${posts}`)
+
+const q = buildQuery(42)
+q.text
+// SELECT "u"."id" as "u_id" ,"u"."email" as "u_email"
+//        ,"p"."id" as "p_id" ,"p"."user_id" as "p_user_id" ,"p"."title" as "p_title"
+// FROM "posts" "p"
+//   JOIN "users" "u" ON "p"."user_id" = "u"."id"
+//  WHERE "u"."id" = $1
+q.values // [42]
+```
+
+Using **Effect** (`pipe` is data-first, which many find more readable):
+
+```ts
+import { pipe } from 'effect'
+import { schema, selectAs, join, where, concat, all } from '@vanit-co/sql-ts'
+
+const q = pipe(
+  selectAs`SELECT ${all(users, posts)} FROM ${posts}`,
+  concat(join`  JOIN ${users} ON ${posts.user_id} = ${users.id}`),
+  concat(where` WHERE ${users.id} = ${42}`)
+)
+```
+
+### `empty`
+
+An empty fragment. Acts as the identity element for `concat` — useful as the starting value when accumulating fragments conditionally.
+
+```ts
+import { pipe, reduce } from 'ramda'
+import { schema, select, join, where, concat, empty, all, Fragment } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'], alias: 'u' })
+const posts = schema({ table: 'posts', columns: ['id', 'user_id', 'title'], alias: 'p' })
+
+type Filters = { userId?: number; titleLike?: string }
+
+const buildPostsQuery = ({ userId, titleLike }: Filters) => {
+  const clauses: Fragment[] = [
+    select`SELECT ${all(users, posts)} FROM ${posts}`,
+    join`  JOIN ${users} ON ${posts.user_id} = ${users.id}`,
+    userId    ? where` WHERE ${users.id} = ${userId}`          : empty,
+    titleLike ? where`   AND ${posts.title} LIKE ${titleLike}` : empty,
+  ]
+
+  return reduce(
+    (acc: Fragment, clause: Fragment) => concat(clause)(acc),
+    empty,
+    clauses
+  )
+}
+
+const q = buildPostsQuery({ userId: 7, titleLike: '%TypeScript%' })
+q.text
+// SELECT "u"."id" as "u_id" ,"u"."email" as "u_email"
+//        ,"p"."id" as "p_id" ,"p"."user_id" as "p_user_id" ,"p"."title" as "p_title"
+// FROM "posts" "p"
+//   JOIN "users" "u" ON "p"."user_id" = "u"."id"
+//  WHERE "u"."id" = $1
+//    AND "p"."title" LIKE $2
+q.values // [7, '%TypeScript%']
+```
+
+---
+
+## Dialect functions: `toMysql` and `toPostgres`
+
+Convert any `Fragment` directly to a dialect-specific result. The template tags already expose `.sql` and `.text` on their return value, but you can call these directly when working with raw fragments.
+
+```ts
+import { toMysql, toPostgres } from '@vanit-co/sql-ts'
+
+const result = toPostgres(someFragment)
+// { text: 'SELECT ... WHERE id = $1', values: [42] }
+
+const mysqlResult = toMysql(someFragment)
+// { sql: 'SELECT ... WHERE id = ?', values: [42] }
+```
+
+---
+
+## Escaping and raw SQL: `raw`
+
+By default, every interpolated value is treated as a bind parameter. Use `raw` to inject an unescaped SQL snippet directly into the query string. **Only use `raw` with trusted, static strings.**
+
+```ts
+import { sql, raw } from '@vanit-co/sql-ts'
+
+const q = sql`SELECT ${raw('COUNT(*)')} AS total FROM users`
+q.text    // SELECT COUNT(*) AS total FROM users
+q.values  // []
+```
+
+---
+
+## Prepared statements: `preparedStatementName`
+
+Attach a name to a `Result` for use with named prepared statements (e.g., `pg`'s `{ name, text, values }` query format).
+
+```ts
+import { sql, preparedStatementName } from '@vanit-co/sql-ts'
+
+const q = sql`SELECT * FROM users WHERE id = ${1}`
+const named = preparedStatementName(q, 'get-user-by-id')
+
+named.name   // 'get-user-by-id'
+named.text   // SELECT * FROM users WHERE id = $1
+named.values // [1]
+
+// Pass to pg:
+await client.query({ name: named.name, text: named.text, values: named.values })
+```
+
+`preparedStatementName` does not mutate the original result — it returns a new object.
+
+---
+
+## Full query example
+
+```ts
+import { schema, select, selectAs, join, where, all, insert, update, concat } from '@vanit-co/sql-ts'
+
+const users = schema({ table: 'users', columns: ['id', 'email'], alias: 'u' })
+const posts = schema({ table: 'posts', columns: ['id', 'user_id', 'title'], alias: 'p' })
+
+// SELECT with JOIN
+const query = selectAs`SELECT ${all(users, posts)} FROM ${posts}`
+  .append(join`JOIN ${users} ON ${posts.user_id} = ${users.id}`)
+  .append(where`WHERE ${users.id} = ${42}`)
+
+query.text
+// SELECT "u"."id" as "u_id" ,"u"."email" as "u_email" ,"p"."id" as "p_id" ,"p"."user_id" as "p_user_id" ,"p"."title" as "p_title"
+// FROM "posts" "p"
+// JOIN "users" "u" ON "p"."user_id" = "u"."id"
+// WHERE "u"."id" = $1
+query.values // [42]
+
+// INSERT
+const ins = insert(users, { id: 1, email: 'alice@example.com' })
+ins.text    // insert into "users" ("id" ,"email") values ($1 ,$2)
+ins.values  // [1, 'alice@example.com']
+
+// UPDATE
+const upd = update(users, { email: 'new@example.com' })
+upd.text    // update "users" set "email" = $1
+upd.values  // ['new@example.com']
+```
+
+---
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+type Result = {
+    append: (s: Fragment) => Fragment;
+    name?: string;
+    sql: string;
+    text: string;
+    values: Array<any>;
+} & Fragment;
+declare const preparedStatementName: (r: Result, n: string) => Result;
+
+type Fragment = {
+    readonly strings: ReadonlyArray<string>;
+    readonly binds: ReadonlyArray<unknown>;
+};
+declare const concat: (right: Fragment) => (left: Fragment) => Result;
+declare const empty: Fragment;
+
+type MysqlResult = {
+    readonly sql: string;
+    readonly values: ReadonlyArray<unknown>;
+};
+type PostgresResult = {
+    readonly text: string;
+    readonly values: ReadonlyArray<unknown>;
+};
+declare const toMysql: (s: Fragment) => MysqlResult;
+declare const toPostgres: (s: Fragment) => PostgresResult;
+
+type Table = {
+    readonly name: string;
+    readonly alias: string;
+};
+type Column = {
+    readonly name: string;
+    readonly prefix: string;
+};
+type SchemaColumn<T extends string> = {
+    [K in T]: {
+        [KC in symbol]: Column;
+    };
+};
+type SchemaTable<T extends string> = {
+    readonly [KT in symbol]: Table;
+} & SchemaColumn<T>;
+type Params<T extends string> = {
+    readonly table: string;
+    readonly columns: ReadonlyArray<T>;
+    readonly alias?: string;
+};
+declare const schema: <T extends string>({ table, columns, alias }: Params<T>) => SchemaTable<T>;
+
+declare const sql: (strings: TemplateStringsArray, ...binds: Array<any>) => Result;
+declare const select: (strings: TemplateStringsArray, ...binds: Array<any>) => Result;
+declare const selectAs: (strings: TemplateStringsArray, ...binds: Array<any>) => Result;
+declare const join: (strings: TemplateStringsArray, ...binds: Array<any>) => Result;
+declare const where: (strings: TemplateStringsArray, ...binds: Array<any>) => Result;
+declare const insert: <T extends string>(table: SchemaTable<T>, ...colsVals: Array<{ [K in T]?: any; }>) => Result;
+declare const update: <T extends string>(table: SchemaTable<T>, colsVals: { [K in T]?: any; }) => Result;
+
+type Value = {
+    readonly [K in symbol]: boolean;
+} & {
+    content: any;
+};
+
+declare const all: (...tables: Array<SchemaTable<string>>) => Value;
+declare const pick: (...columns: Array<{
+    [key: symbol]: Column;
+}>) => Value;
+declare const raw: (content: string) => Value;
+
+export { all, concat, empty, insert, join as j, join, pick, preparedStatementName, raw, select as s, selectAs as sa, schema, select, selectAs, sql, toMysql, toPostgres, update, where as w, where };

package/dist/index.js

@@ -0,0 +1,172 @@
+'use strict';
+
+var ramda = require('ramda');
+
+// for schema
+const SYM_COLUMN = Symbol('sql-ts/column');
+const SYM_MULTIPLE_COLUMNS = Symbol('sql-ts/multipleColumns');
+const SYM_TABLE = Symbol('sql-ts/table');
+// for fragment
+const SYM_RAW = Symbol('sql-ts/raw');
+const SYM_IDENTIFIER = Symbol('sql-ts/identifier');
+
+const zipLongest = (l1, l2) => {
+    const maxLength = Math.max(l1.length, l2.length);
+    return Array.from({ length: maxLength }, (_, i) => [l1[i], l2[i]]);
+};
+
+const preparedStatementName = (r, n) => ({ ...r, name: n });
+const result = (s) => ({
+    ...s,
+    append: (x) => concat(x)(s),
+    get sql() {
+        return toMysql(s).sql;
+    },
+    get text() {
+        return toPostgres(s).text;
+    },
+    get values() {
+        return s.binds.filter((x) => !(x[SYM_RAW] || x[SYM_IDENTIFIER]));
+    }
+});
+
+const concat = (right) => (left) => {
+    const lastLeft = left.strings[left.strings.length - 1] ?? '';
+    const firstRight = right.strings[0] ?? '';
+    return result(fragment([...left.strings.slice(0, -1), lastLeft + firstRight, ...right.strings.slice(1)], [...left.binds, ...right.binds]));
+};
+const fragment = (strings, binds) => {
+    if (strings.length !== binds.length + 1)
+        throw new Error(`Malformed fragment: ${strings.length} strings for ${binds.length} values`);
+    return Object.freeze({ strings, binds });
+};
+const empty = fragment([''], []);
+const stringfyIdentifierAndRaw = (quote = '') => (s) => {
+    const fn = ([strings, binds, merge], [ss, bs]) => {
+        if (bs && bs[SYM_RAW]) {
+            return [strings, binds, [...merge, ss, bs.content]];
+        }
+        else if (bs && bs[SYM_IDENTIFIER]) {
+            return [strings, binds, [...merge, ss, (quote + bs.content + quote)]];
+        }
+        else if (bs) {
+            return [[...strings, merge.join('') + ss], [...binds, bs], []];
+        }
+        else {
+            return [[...strings, merge.join('') + ss], binds, []];
+        }
+    };
+    const [ns, nb] = zipLongest(s.strings, s.binds).reduce(fn, [[], [], []]);
+    return fragment(ns, nb);
+};
+
+const toMysql = (s) => {
+    const ss = stringfyIdentifierAndRaw('`')(s);
+    return { sql: [...ss.strings].join('?'), values: ss.binds };
+};
+const toPostgres = (s) => {
+    const ss = stringfyIdentifierAndRaw('"')(s);
+    return {
+        text: ss.strings[0] + ramda.zipWith((i, str) => `$${i}${str}`, ramda.range(1, ss.binds.length + 1), ss.strings.slice(1)).join(''),
+        values: ss.binds
+    };
+};
+
+const makeColumns = (prefix, cols) => cols.reduce((a, key) => ({ ...a, [key]: { [SYM_COLUMN]: { name: key, prefix } } }), {});
+const schema = ({ table, columns, alias }) => {
+    const resolvedAlias = alias ?? table;
+    return {
+        [SYM_TABLE]: { name: table, alias: resolvedAlias },
+        ...makeColumns(resolvedAlias, columns)
+    };
+};
+
+const identifier = (content) => ({ [SYM_IDENTIFIER]: true, content });
+
+const transformer = (table, column) => ([ss, bs]) => {
+    if (bs === undefined)
+        return [[ss]];
+    if (bs[SYM_TABLE])
+        return table(ss, bs[SYM_TABLE]);
+    if (bs[SYM_COLUMN])
+        return column(ss, bs[SYM_COLUMN]);
+    if (bs[SYM_MULTIPLE_COLUMNS])
+        return bs.content
+            .flatMap((c, i) => i === 0 ? column(ss, c) : column(' ,', c));
+    return [[ss, bs]];
+};
+const tableWithAlias = (s, t) => [
+    [s, identifier(t.name)],
+    [' ', identifier(t.alias)]
+];
+const prefixedColumn = (s, c) => [
+    [s, identifier(c.prefix)],
+    ['.', identifier(c.name)]
+];
+const pure = transformer((s, t) => [[s, identifier(t.name)]], (s, c) => [[s, identifier(c.name)]]);
+const prefix = transformer(tableWithAlias, prefixedColumn);
+const alias = transformer(tableWithAlias, (s, c) => [
+    ...prefixedColumn(s, c),
+    [' as ', identifier(`${c.prefix}_${c.name}`)]
+]);
+const buildTag = (fn) => (strings, ...binds) => {
+    const [s, v] = ramda.transpose(zipLongest(strings, binds).flatMap(fn));
+    return result(fragment(s, v ?? []));
+};
+const sql = buildTag(pure);
+const select = buildTag(prefix);
+const selectAs = buildTag(alias);
+const join = select;
+const where = select;
+const insert = (table, ...colsVals) => {
+    const tableName = table[SYM_TABLE].name;
+    const columns = Object.keys(colsVals[0]);
+    const colStrings = columns.map((_, i) => i === 0 ? ' (' : ' ,');
+    const colBinds = columns.map(c => identifier(c));
+    const [valStrings, valBinds] = colsVals.reduce(([ss, bs], row, rowIdx) => {
+        const rowStrings = columns.map((_, colIdx) => colIdx === 0 ? (rowIdx === 0 ? ') values (' : ') ,(') : ' ,');
+        return [[...ss, ...rowStrings], [...bs, ...columns.map(c => row[c])]];
+    }, [[], []]);
+    return result(fragment(['insert into ', ...colStrings, ...valStrings, ')'], [identifier(tableName), ...colBinds, ...valBinds]));
+};
+const update = (table, colsVals) => {
+    const tableName = table[SYM_TABLE].name;
+    const entries = Object.entries(colsVals);
+    const [strings, binds] = entries.reduce(([ss, bs], [colName, value], i) => [[...ss, i === 0 ? ' set ' : ' ,', ' = '], [...bs, identifier(colName), value]], [['update '], [identifier(tableName)]]);
+    return result(fragment([...strings, ''], binds));
+};
+
+const all = (...tables) => ({
+    [SYM_MULTIPLE_COLUMNS]: true,
+    content: tables.flatMap(t => Object.values(t).map(x => x[SYM_COLUMN]))
+});
+const pick = (...columns) => ({
+    [SYM_MULTIPLE_COLUMNS]: true,
+    content: columns.map(x => x[SYM_COLUMN])
+});
+const raw = (content) => ({
+    [SYM_RAW]: true,
+    content
+});
+
+exports.all = all;
+exports.concat = concat;
+exports.empty = empty;
+exports.insert = insert;
+exports.j = join;
+exports.join = join;
+exports.pick = pick;
+exports.preparedStatementName = preparedStatementName;
+exports.raw = raw;
+exports.s = select;
+exports.sa = selectAs;
+exports.schema = schema;
+exports.select = select;
+exports.selectAs = selectAs;
+exports.sql = sql;
+exports.toMysql = toMysql;
+exports.toPostgres = toPostgres;
+exports.update = update;
+exports.w = where;
+exports.where = where;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@vanit-co/sql-ts",
+  "version": "0.0.1",
+  "description": "A TypeScript SQL query builder using tagged template literals. Write plain SQL with safe, automatic parameter binding and properly quoted identifiers. No DSL to learn, no magic, no ORM.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "./dist/index.js",
+    "./dist/index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "build": "npx rollup --config --bundleConfigAsCjs"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/ramda": "^0.31.1",
+    "rollup": "^4.60.0",
+    "rollup-plugin-dts": "^6.4.1",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.0"
+  },
+  "dependencies": {
+    "ramda": "^0.32.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vanit-co/sql-ts.git"
+  },
+  "keywords": [
+    "sql",
+    "query",
+    "postgres",
+    "pg",
+    "mysql",
+    "mysql2"
+  ],
+  "author": "Geovanny Silva",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vanit-co/sql-ts/issues"
+  },
+  "homepage": "https://github.com/vanit-co/sql-ts#readme"
+}