weifuwu 0.27.3 → 0.27.5

package/README.md

@@ -407,24 +407,6 @@ Options: `dir`, `defaultLocale`, `cookie`, `param`, `header`
 
 ### Standalone utilities
 
-#### mailer()
-
-```ts
-import { mailer } from 'weifuwu'
-
-const m = mailer({
-  host: 'smtp.example.com',
-  port: 587,
-  auth: { user: '...', pass: '...' },
-  from: 'noreply@example.com',
-})
-
-await m.send({ to: 'user@example.com', subject: 'Hello', text: '...' })
-await m.close()
-```
-
-Options: `host`, `port`, `auth`, `from`, `secure`
-
 #### SSE
 
 ```ts
@@ -519,6 +501,5 @@ Creates a minimal API project with `app.ts`, `index.ts`, and TypeScript config.
 - `graphql`, `@graphql-tools/schema` — GraphQL
 - `ws` — WebSocket
 - `zod` — Schema validation
-- `nodemailer` — Email
 
 Zero build tools. Zero frontend framework dependencies.

package/dist/cli.js

@@ -92,6 +92,19 @@ async function cmdInit(name, opts) {
   );
   await writeFile(join(targetDir, ".gitignore"), "node_modules\n.env\n");
   await writeFile(join(targetDir, ".env"), "PORT=3000\n");
+  await writeFile(
+    join(targetDir, "AGENTS.md"),
+    [
+      "# Project Guide for AI Agents",
+      "",
+      "Before making any changes to this project, first read the weifuwu framework documentation:",
+      "",
+      "./node_modules/weifuwu/README.md",
+      "",
+      "This file contains the framework API reference, conventions, and patterns used throughout the codebase.",
+      ""
+    ].join("\n")
+  );
   if (!opts.skipInstall) {
     console.log("\nInstalling dependencies...");
     execSync("npm install", { cwd: targetDir, stdio: "inherit" });

package/dist/index.d.ts

@@ -55,7 +55,5 @@ export { i18n } from './middleware/i18n.ts';
 export type { I18nOptions, I18nInjected } from './middleware/i18n.ts';
 export { flash } from './middleware/flash.ts';
 export type { FlashOptions, FlashInjected, FlashModule } from './middleware/flash.ts';
-export { mailer } from './mailer.ts';
-export type { MailerOptions, MailOptions, Mailer } from './mailer.ts';
 export { csrf } from './middleware/csrf.ts';
 export type { CsrfOptions, CsrfInjected, CsrfModule } from './middleware/csrf.ts';

package/dist/index.js

@@ -1176,27 +1176,27 @@ var MIME_TYPES = {
 };
 
 // middleware/validate.ts
-function parseFormBody(text2) {
-  const params = new URLSearchParams(text2);
+function parseFormBody(text) {
+  const params = new URLSearchParams(text);
   const result = {};
   for (const [key, value] of params) {
     result[key] = value;
   }
   return result;
 }
-function parseBody(text2, ct) {
+function parseBody(text, ct) {
   if (ct.includes("application/x-www-form-urlencoded")) {
-    return parseFormBody(text2);
+    return parseFormBody(text);
   }
   const isExplicitJson = ct.includes("application/json") || ct.includes("+json") || ct.includes("text/") || ct.includes("*/json");
   const isNotSpecialMultipart = !ct.includes("multipart/form-data") && !ct.includes("application/x-www-form-urlencoded");
   if (isExplicitJson || isNotSpecialMultipart) {
     try {
-      return JSON.parse(text2);
+      return JSON.parse(text);
     } catch {
     }
   }
-  return text2;
+  return text;
 }
 function validate(schemas) {
   const mw = async (req, ctx, next) => {
@@ -1693,8 +1693,8 @@ function createSSEStream(iterable, opts) {
       async start(controller) {
         try {
           for await (const event of iterable) {
-            const text2 = event.type ? formatSSE(event.type, event) : formatSSEData(event);
-            controller.enqueue(encoder.encode(text2));
+            const text = event.type ? formatSSE(event.type, event) : formatSSEData(event);
+            controller.enqueue(encoder.encode(text));
           }
         } catch (e) {
           if (e instanceof Error && e.name !== "AbortError") {
@@ -2092,17 +2092,17 @@ async function createTestDb(options) {
   await adminSql.unsafe('CREATE SCHEMA IF NOT EXISTS "' + schema.replace(/"/g, '""') + '"');
   const schemaUrl = new URL(dbUrl);
   schemaUrl.searchParams.set("search_path", schema);
-  const sql2 = postgres2(schemaUrl.toString());
+  const sql = postgres2(schemaUrl.toString());
   await adminSql.end();
   return {
-    sql: sql2,
+    sql,
     url: schemaUrl.toString(),
     schema,
     destroy: async () => {
       const destroySql = postgres2(dbUrl);
       await destroySql.unsafe('DROP SCHEMA IF EXISTS "' + schema.replace(/"/g, '""') + '" CASCADE');
       await destroySql.end();
-      await sql2.end();
+      await sql.end();
     }
   };
 }
@@ -2121,15 +2121,15 @@ async function withTestDb(optionsOrFn, fn) {
   const resolvedUrl = dbUrl || process.env.TEST_DATABASE_URL || process.env.DATABASE_URL;
   if (!resolvedUrl) throw new Error("withTestDb: DATABASE_URL or TEST_DATABASE_URL required");
   const { default: postgres2 } = await import("postgres");
-  const sql2 = postgres2(resolvedUrl);
+  const sql = postgres2(resolvedUrl);
   try {
-    await sql2.begin(async (txSql) => {
+    await sql.begin(async (txSql) => {
       await callback(txSql);
       throw void 0;
     });
   } catch {
   } finally {
-    await sql2.end();
+    await sql.end();
   }
 }
 
@@ -2405,8 +2405,8 @@ function aiProvider(options) {
       if (!_embedModel) _embedModel = client.embedding(m);
       return _embedModel;
     },
-    async embed(text2) {
-      const result = await aiEmbed({ model: this.embeddingModel(), value: text2 });
+    async embed(text) {
+      const result = await aiEmbed({ model: this.embeddingModel(), value: text });
       return result.embedding;
     },
     async embedMany(texts) {
@@ -2444,440 +2444,6 @@ import { openai, createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 
 // postgres/client.ts
 import postgresFactory from "postgres";
-
-// postgres/schema/sql.ts
-var SQL = class {
-  /** Template string parts (interleaved with values). */
-  strings;
-  /** Bound parameter values. */
-  values;
-  constructor(strings, values) {
-    this.strings = strings;
-    this.values = values;
-  }
-  /** Serialize to a raw SQL string (interpolating values inline for DDL use). */
-  toSQL() {
-    let result = "";
-    for (let i = 0; i < this.strings.length; i++) {
-      result += this.strings[i];
-      if (i < this.values.length) {
-        result += String(this.values[i]);
-      }
-    }
-    return result;
-  }
-};
-
-// postgres/schema/columns.ts
-function toDDL(col) {
-  const parts = [`"${col.name}"`, col.sqlType];
-  if (col.isPrimaryKey) parts.push("PRIMARY KEY");
-  if (!col.isPrimaryKey && !col.isNullable) parts.push("NOT NULL");
-  if (col.isUnique) parts.push("UNIQUE");
-  if (col.defaultExpr) parts.push(`DEFAULT ${col.defaultExpr}`);
-  if (col.ref) {
-    parts.push(`REFERENCES "${col.ref.table}"("${col.ref.column}")`);
-    if (col.ref.onDelete) parts.push(`ON DELETE ${col.ref.onDelete.toUpperCase()}`);
-  }
-  return parts.join(" ");
-}
-
-// postgres/schema/where.ts
-function combine(conditions, joiner) {
-  if (conditions.length === 0) return new SQL([""], []);
-  const strings = ["("];
-  const values = [];
-  for (let i = 0; i < conditions.length; i++) {
-    if (i > 0) strings[strings.length - 1] += ` ${joiner} `;
-    const s = conditions[i];
-    for (let j = 0; j < s.strings.length; j++) {
-      strings[strings.length - 1] += s.strings[j];
-      if (j < s.values.length) {
-        strings.push("");
-        values.push(s.values[j]);
-      }
-    }
-  }
-  strings[strings.length - 1] += ")";
-  return new SQL(strings, values);
-}
-function and(...conditions) {
-  return combine(conditions, "AND");
-}
-
-// postgres/schema/table.ts
-var Table = class {
-  /** Database table name. */
-  tableName;
-  /** All column builders (order-preserving). */
-  columns;
-  /** Column builders keyed by property name. */
-  builders;
-  colEntries;
-  constructor(tableName, builders) {
-    this.tableName = tableName;
-    this.builders = builders;
-    this.columns = Object.values(builders);
-    this.colEntries = Object.entries(builders).map(([prop, col]) => ({
-      prop,
-      db: col.name,
-      auto: col.isAutoGenerate,
-      column: col
-    }));
-  }
-  /** Check if the table has a column with the given DB name. */
-  hasColumn(dbName) {
-    return this.colEntries.some((e) => e.db === dbName);
-  }
-  /**
-   * Bind this table schema to a SQL connection, returning a `BoundTable`
-   * that can run queries without passing `sql` to every call.
-   */
-  bind(sql2) {
-    return new BoundTable(sql2, this.tableName, this.builders);
-  }
-  /** Returns the primary key column name (DB name), or 'id' as fallback. */
-  get pkColumn() {
-    const entry = this.colEntries.find((e) => e.column.isPrimaryKey);
-    return entry ? entry.db : "id";
-  }
-  /** Adds `deleted_at IS NULL` condition if the table has soft delete and not explicitly excluded. */
-  _softDeleteFilter(where, opts) {
-    if (!this.hasColumn("deleted_at")) return null;
-    if (opts?.withDeleted) return null;
-    if (where && typeof where === "object" && !Array.isArray(where) && !(where instanceof SQL)) {
-      if ("deleted_at" in where) return null;
-    }
-    return '"deleted_at" IS NULL';
-  }
-  async create(sql2, opts) {
-    const colDDL = this.columns.map(toDDL);
-    let ddl = `CREATE TABLE IF NOT EXISTS "${this.tableName}" (
-  ${colDDL.join(",\n  ")}
-)`;
-    if (opts?.partitionBy) {
-      ddl += ` PARTITION BY ${opts.partitionBy.type} ("${opts.partitionBy.column}")`;
-    }
-    await sql2.unsafe(ddl);
-  }
-  async drop(sql2, opts) {
-    const cascade = opts?.cascade ? " CASCADE" : "";
-    await sql2.unsafe(`DROP TABLE IF EXISTS "${this.tableName}"${cascade}`);
-  }
-  async createIndex(sql2, columns, opts) {
-    const cols = Array.isArray(columns) ? columns : [columns];
-    const name = `"${this.tableName}_${cols.join("_")}${opts?.unique ? "_uidx" : "_idx"}"`;
-    const unique = opts?.unique ? "UNIQUE" : "";
-    const using = opts?.type ? `USING ${opts.type.toUpperCase()}` : "";
-    const colList = cols.map((c) => opts?.desc ? `"${c}" DESC` : `"${c}"`).join(", ");
-    const operator = opts?.operator ? ` ${opts.operator}` : "";
-    const ddl = `CREATE ${unique} INDEX IF NOT EXISTS ${name} ON "${this.tableName}" ${using} (${colList}${operator})`.replace(
-      /\s+/g,
-      " "
-    );
-    await sql2.unsafe(ddl);
-  }
-  async createUniqueIndex(sql2, columns) {
-    await this.createIndex(sql2, columns, { unique: true });
-  }
-  // --- Private helpers ---
-  _buildConditions(where, startIndex) {
-    const conditions = [];
-    const values = [];
-    let w = where;
-    if (Array.isArray(w)) {
-      w = w.length > 0 ? and(...w) : void 0;
-    }
-    if (w instanceof SQL) {
-      let fragment = "";
-      for (let i = 0; i < w.strings.length; i++) {
-        fragment += w.strings[i];
-        if (i < w.values.length) {
-          fragment += `$${startIndex + values.length + 1}`;
-          values.push(w.values[i]);
-        }
-      }
-      conditions.push(fragment);
-    } else {
-      for (const [prop, value] of Object.entries(w || {})) {
-        if (value === void 0) continue;
-        const entry = this.colEntries.find((e) => e.prop === prop);
-        const db = entry ? entry.db : prop;
-        conditions.push(`"${db}" = $${startIndex + values.length + 1}`);
-        values.push(value);
-      }
-    }
-    return { conditions, values };
-  }
-  _buildSET(data) {
-    const sets = [];
-    const values = [];
-    const d = data;
-    for (const { prop, db } of this.colEntries) {
-      if (prop in d && d[prop] !== void 0) {
-        const val = d[prop];
-        if (val instanceof SQL) {
-          sets.push(`"${db}" = ${val.toSQL()}`);
-        } else {
-          sets.push(`"${db}" = $${sets.length + 1}`);
-          values.push(val);
-        }
-      }
-    }
-    if (this.hasColumn("updated_at") && !d.updated_at) {
-      sets.push('"updated_at" = NOW()');
-    }
-    return { sets, values };
-  }
-  // --- CRUD ---
-  async insert(sql2, data) {
-    const filtered = {};
-    for (const { prop, db, auto } of this.colEntries) {
-      if (auto) continue;
-      const val = data[prop];
-      if (val !== void 0) {
-        filtered[db] = val;
-      }
-    }
-    const [row] = await sql2`
-      INSERT INTO ${sql2(this.tableName)} ${sql2(filtered)} RETURNING *
-    `;
-    return row;
-  }
-  async insertMany(sql2, data) {
-    const filtered = [];
-    for (const item of data) {
-      const row = {};
-      for (const { prop, db, auto } of this.colEntries) {
-        if (auto) continue;
-        const val = item[prop];
-        if (val !== void 0) {
-          row[db] = val;
-        }
-      }
-      filtered.push(row);
-    }
-    const rows = await sql2`
-      INSERT INTO ${sql2(this.tableName)} ${sql2(filtered)} RETURNING *
-    `;
-    return rows;
-  }
-  async read(sql2, id, opts) {
-    const pk = this.pkColumn;
-    const columns = opts?.select?.length ? opts.select.map((c) => `"${c}"`).join(", ") : "*";
-    const softDel = this._softDeleteFilter(null, opts);
-    const extraAnd = softDel ? ` AND ${softDel}` : "";
-    const [row] = await sql2.unsafe(
-      `SELECT ${columns} FROM "${this.tableName}" WHERE "${pk}" = $1${extraAnd} LIMIT 1`,
-      [id]
-    );
-    return row ?? void 0;
-  }
-  async readMany(sql2, where, opts) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    const softDel = this._softDeleteFilter(where, opts);
-    if (softDel) conditions.push(softDel);
-    const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    const [countRow] = await sql2.unsafe(
-      `SELECT COUNT(*) AS _total FROM "${this.tableName}"${whereClause}`,
-      values
-    );
-    const count = Number(countRow._total);
-    if (conditions.length === 0 && !opts?.orderBy && !opts?.limit && !opts?.offset && !opts?.select) {
-      const rows2 = await sql2`SELECT * FROM ${sql2(this.tableName)}`;
-      return { count, data: rows2 };
-    }
-    const columns = opts?.select?.length ? opts.select.map((c) => `"${c}"`).join(", ") : "*";
-    let query = `SELECT ${columns} FROM "${this.tableName}"${whereClause}`;
-    if (opts?.orderBy) {
-      const orders = Object.entries(opts.orderBy).map(([prop, dir]) => {
-        const entry = this.colEntries.find((e) => e.prop === prop);
-        return `"${entry?.db || prop}" ${dir.toUpperCase()}`;
-      }).join(", ");
-      query += ` ORDER BY ${orders}`;
-    }
-    if (opts?.limit) query += ` LIMIT ${opts.limit}`;
-    if (opts?.offset) query += ` OFFSET ${opts.offset}`;
-    const rows = await sql2.unsafe(query, values);
-    return { count, data: rows };
-  }
-  async update(sql2, id, data) {
-    const { sets, values: setValues } = this._buildSET(data);
-    if (sets.length === 0) return void 0;
-    const pk = this.pkColumn;
-    const [row] = await sql2.unsafe(
-      `UPDATE "${this.tableName}" SET ${sets.join(", ")} WHERE "${pk}" = $${setValues.length + 1} RETURNING *`,
-      [...setValues, id]
-    );
-    return row ?? void 0;
-  }
-  async updateMany(sql2, where, data) {
-    const { sets, values: setValues } = this._buildSET(data);
-    if (sets.length === 0) return 0;
-    const { conditions: wConditions, values: wValues } = this._buildConditions(
-      where,
-      setValues.length
-    );
-    if (wConditions.length === 0) return 0;
-    const rows = await sql2.unsafe(
-      `UPDATE "${this.tableName}" SET ${sets.join(", ")} WHERE ${wConditions.join(" AND ")} RETURNING 1`,
-      [...setValues, ...wValues]
-    );
-    return rows.length;
-  }
-  async delete(sql2, id) {
-    const pk = this.pkColumn;
-    if (this.hasColumn("deleted_at")) {
-      const [row2] = await sql2.unsafe(
-        `UPDATE "${this.tableName}" SET "deleted_at" = NOW() WHERE "${pk}" = $1 RETURNING *`,
-        [id]
-      );
-      return row2 ?? void 0;
-    }
-    const [row] = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE "${pk}" = $1 RETURNING *`,
-      [id]
-    );
-    return row ?? void 0;
-  }
-  async hardDelete(sql2, id) {
-    const pk = this.pkColumn;
-    const [row] = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE "${pk}" = $1 RETURNING *`,
-      [id]
-    );
-    return row ?? void 0;
-  }
-  async deleteMany(sql2, where) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    if (conditions.length === 0) return 0;
-    if (this.hasColumn("deleted_at")) {
-      const rows2 = await sql2.unsafe(
-        `UPDATE "${this.tableName}" SET "deleted_at" = NOW() WHERE ${conditions.join(" AND ")} RETURNING 1`,
-        values
-      );
-      return rows2.length;
-    }
-    const rows = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE ${conditions.join(" AND ")} RETURNING 1`,
-      values
-    );
-    return rows.length;
-  }
-  async hardDeleteMany(sql2, where) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    if (conditions.length === 0) return 0;
-    const rows = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE ${conditions.join(" AND ")} RETURNING 1`,
-      values
-    );
-    return rows.length;
-  }
-  async upsert(sql2, data, conflict) {
-    const filtered = {};
-    for (const { prop, db, auto } of this.colEntries) {
-      if (auto) continue;
-      const val = data[prop];
-      if (val !== void 0) {
-        filtered[db] = val;
-      }
-    }
-    const keys = Object.keys(filtered);
-    if (keys.length === 0) throw new Error("upsert: no data to insert");
-    const conflictCols = Array.isArray(conflict) ? conflict : [conflict];
-    const dbCols = keys.map((c) => `"${c}"`);
-    const placeholders = keys.map((_, i) => `$${i + 1}`);
-    const updateSet = keys.filter((k) => !conflictCols.includes(k)).map((k) => `"${k}" = EXCLUDED."${k}"`).join(", ");
-    if (!updateSet) {
-      const [row2] = await sql2.unsafe(
-        `INSERT INTO "${this.tableName}" (${dbCols.join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT (${conflictCols.map((c) => `"${c}"`).join(", ")}) DO NOTHING RETURNING *`,
-        Object.values(filtered)
-      );
-      return row2 ?? void 0;
-    }
-    const [row] = await sql2.unsafe(
-      `INSERT INTO "${this.tableName}" (${dbCols.join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT (${conflictCols.map((c) => `"${c}"`).join(", ")}) DO UPDATE SET ${updateSet} RETURNING *`,
-      Object.values(filtered)
-    );
-    return row;
-  }
-  async count(sql2, where) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    const softDel = this._softDeleteFilter(where);
-    if (softDel) conditions.push(softDel);
-    const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    const [row] = await sql2.unsafe(
-      `SELECT COUNT(*) AS _total FROM "${this.tableName}"${whereClause}`,
-      values
-    );
-    return Number(row._total);
-  }
-};
-var BoundTable = class _BoundTable {
-  inner;
-  sql;
-  /** The underlying table name. */
-  get tableName() {
-    return this.inner.tableName;
-  }
-  constructor(sql2, tableName, builders) {
-    this.inner = new Table(tableName, builders);
-    this.sql = sql2;
-  }
-  async create(opts) {
-    await this.inner.create(this.sql, opts);
-  }
-  async drop(opts) {
-    await this.inner.drop(this.sql, opts);
-  }
-  async createIndex(columns, opts) {
-    await this.inner.createIndex(this.sql, columns, opts);
-  }
-  async createUniqueIndex(columns) {
-    await this.inner.createUniqueIndex(this.sql, columns);
-  }
-  async insert(data) {
-    return await this.inner.insert(this.sql, data);
-  }
-  async insertMany(data) {
-    return await this.inner.insertMany(this.sql, data);
-  }
-  async read(id, opts) {
-    return await this.inner.read(this.sql, id, opts);
-  }
-  async readMany(where, opts) {
-    return await this.inner.readMany(this.sql, where, opts);
-  }
-  async update(id, data) {
-    return await this.inner.update(this.sql, id, data);
-  }
-  async updateMany(where, data) {
-    return await this.inner.updateMany(this.sql, where, data);
-  }
-  async delete(id) {
-    return await this.inner.delete(this.sql, id);
-  }
-  async hardDelete(id) {
-    return await this.inner.hardDelete(this.sql, id);
-  }
-  async deleteMany(where) {
-    return await this.inner.deleteMany(this.sql, where);
-  }
-  async hardDeleteMany(where) {
-    return await this.inner.hardDeleteMany(this.sql, where);
-  }
-  async upsert(data, conflict) {
-    return await this.inner.upsert(this.sql, data, conflict);
-  }
-  async count(where) {
-    return await this.inner.count(this.sql, where);
-  }
-  withSql(sql2) {
-    return new _BoundTable(sql2, this.inner.tableName, this.inner.builders);
-  }
-};
-
-// postgres/client.ts
 var MIGRATIONS_TABLE = "_weifuwu_migrations";
 var RETRYABLE_CODES = /* @__PURE__ */ new Set(["40P01", "40001"]);
 function isRetryable(err) {
@@ -2897,7 +2463,7 @@ function postgres(opts) {
     const sep2 = connStr.includes("?") ? "&" : "?";
     connStr = `${connStr}${sep2}options=-c%20statement_timeout%3D${stmtTimeout}`;
   }
-  const sql2 = postgresFactory(connStr, {
+  const sql = postgresFactory(connStr, {
     max: options.max,
     ssl: options.ssl,
     idle_timeout: options.idle_timeout,
@@ -2907,7 +2473,7 @@ function postgres(opts) {
     options.signal.addEventListener(
       "abort",
       () => {
-        sql2.end();
+        sql.end();
       },
       { once: true }
     );
@@ -2917,19 +2483,13 @@ function postgres(opts) {
   const _waiting = 0;
   const poolMax = options.max ?? 10;
   const mw = ((req, ctx, next) => {
-    ctx.sql = sql2;
+    ctx.sql = sql;
     return next(req, ctx);
   });
   mw.__meta = { injects: ["sql"], depends: [] };
-  mw.sql = sql2;
-  mw.table = ((tableOrSchema, builders) => {
-    if (typeof tableOrSchema === "string") {
-      return new BoundTable(sql2, tableOrSchema, builders);
-    }
-    return new BoundTable(sql2, tableOrSchema.tableName, tableOrSchema.builders);
-  });
+  mw.sql = sql;
   mw.migrate = async () => {
-    await sql2.unsafe(`
+    await sql.unsafe(`
       CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE}" (
         name TEXT PRIMARY KEY,
         applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
@@ -2937,13 +2497,13 @@ function postgres(opts) {
     `);
   };
   mw.markMigrated = async (moduleName) => {
-    await sql2.unsafe(
+    await sql.unsafe(
       `INSERT INTO "${MIGRATIONS_TABLE}" (name) VALUES ($1) ON CONFLICT DO NOTHING`,
       [moduleName]
     );
   };
   mw.isMigrated = async (moduleName) => {
-    const [row] = await sql2.unsafe(`SELECT 1 FROM "${MIGRATIONS_TABLE}" WHERE name = $1`, [
+    const [row] = await sql.unsafe(`SELECT 1 FROM "${MIGRATIONS_TABLE}" WHERE name = $1`, [
       moduleName
     ]);
     return !!row;
@@ -2952,7 +2512,7 @@ function postgres(opts) {
     const maxRetries = retryOpts?.maxRetries ?? 3;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
-        const result = await sql2.begin(fn);
+        const result = await sql.begin(fn);
         return result;
       } catch (err) {
         if (attempt < maxRetries && isRetryable(err)) {
@@ -2971,7 +2531,7 @@ function postgres(opts) {
     waiting: _waiting,
     max: poolMax
   });
-  mw.close = () => sql2.end({ timeout: closeTimeout });
+  mw.close = () => sql.end({ timeout: closeTimeout });
   return mw;
 }
 
@@ -3214,7 +2774,7 @@ function createMemoryQueue(opts) {
   return q;
 }
 function createPgQueue(opts) {
-  const sql2 = opts.pg.sql;
+  const sql = opts.pg.sql;
   const pollInterval = opts?.pollInterval ?? 200;
   const table = (opts?.prefix ?? "queue") + "_jobs";
   const handlers = /* @__PURE__ */ new Map();
@@ -3224,10 +2784,10 @@ function createPgQueue(opts) {
   const MAX_FAILED = 1e3;
   async function ensureTable() {
     if (ready) return;
-    await sql2.unsafe(
+    await sql.unsafe(
       `CREATE TABLE IF NOT EXISTS ${escapeIdent(table)} (id UUID PRIMARY KEY, type TEXT NOT NULL, payload JSONB NOT NULL DEFAULT '{}', run_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), schedule TEXT, status TEXT NOT NULL DEFAULT 'pending', error TEXT, failed_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT NOW())`
     );
-    await sql2.unsafe(
+    await sql.unsafe(
       `CREATE INDEX IF NOT EXISTS ${escapeIdent(table + "_run_at_idx")} ON ${escapeIdent(table)} (run_at, status)`
     );
     ready = true;
@@ -3237,12 +2797,12 @@ function createPgQueue(opts) {
     try {
       await handler(job);
       _processed++;
-      await sql2.unsafe(`DELETE FROM ${escapeIdent(table)} WHERE id = $1`, [job.id]);
+      await sql.unsafe(`DELETE FROM ${escapeIdent(table)} WHERE id = $1`, [job.id]);
     } catch (e) {
       _failed++;
       const msg = e.message;
       console.error("[queue] handler error:", msg);
-      await sql2.unsafe(
+      await sql.unsafe(
         `UPDATE ${escapeIdent(table)} SET status = 'failed', error = $2, failed_at = NOW() WHERE id = $1`,
         [job.id, msg]
       );
@@ -3252,7 +2812,7 @@ function createPgQueue(opts) {
     if (job.schedule) {
       try {
         const nextRun = cronNext(job.schedule);
-        await sql2.unsafe(
+        await sql.unsafe(
           `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
           [
             crypto4.randomUUID(),
@@ -3271,7 +2831,7 @@ function createPgQueue(opts) {
     if (!running) return;
     try {
       while (running && inflight < MAX_CONCURRENT) {
-        const rows = await sql2.unsafe(
+        const rows = await sql.unsafe(
           `UPDATE ${escapeIdent(table)} SET status = 'running' WHERE id = (SELECT id FROM ${escapeIdent(table)} WHERE run_at <= NOW() AND status = 'pending' ORDER BY run_at LIMIT 1 FOR UPDATE SKIP LOCKED) RETURNING *`
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
         );
@@ -3319,7 +2879,7 @@ function createPgQueue(opts) {
       } else {
         runAt = /* @__PURE__ */ new Date();
       }
-      await sql2.unsafe(
+      await sql.unsafe(
         `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
         [id, type, JSON.stringify(payload), runAt.toISOString(), opts2?.schedule || null]
       );
@@ -3345,7 +2905,7 @@ function createPgQueue(opts) {
     while (inflight > 0) await new Promise((r) => setTimeout(r, 50));
   };
   mw.jobs = async function jobs(limit) {
-    const rows = await sql2.unsafe(
+    const rows = await sql.unsafe(
       `SELECT * FROM ${escapeIdent(table)} WHERE status = 'pending' ORDER BY run_at LIMIT $1`,
       [limit ?? 50]
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3360,7 +2920,7 @@ function createPgQueue(opts) {
     }));
   };
   mw.failedJobs = async function failedJobs(limit) {
-    const rows = await sql2.unsafe(
+    const rows = await sql.unsafe(
       `SELECT * FROM ${escapeIdent(table)} WHERE status = 'failed' ORDER BY failed_at DESC LIMIT $1`,
       [limit ?? 50]
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3377,7 +2937,7 @@ function createPgQueue(opts) {
     }));
   };
   mw.retryFailed = async function retryFailed(jobId) {
-    const result = await sql2.unsafe(
+    const result = await sql.unsafe(
       `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE id = $1 AND status = 'failed' RETURNING id`,
       [jobId]
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3385,7 +2945,7 @@ function createPgQueue(opts) {
     return result.length > 0;
   };
   mw.retryAllFailed = async function retryAllFailed(type) {
-    const result = await sql2.unsafe(
+    const result = await sql.unsafe(
       type ? `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' AND type = $1 RETURNING id` : `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' RETURNING id`,
       type ? [type] : []
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3828,31 +3388,6 @@ function flash(options) {
   return mw;
 }
 
-// mailer.ts
-import { createTransport } from "nodemailer";
-function mailer(options) {
-  const sender = options.send;
-  const from = options.from;
-  let transporter = null;
-  if (!sender && options.transport) {
-    transporter = typeof options.transport === "string" ? createTransport(options.transport) : options.transport;
-  }
-  async function send(opts) {
-    if (sender) {
-      await sender(opts);
-      return;
-    }
-    if (!transporter) {
-      throw new Error("mailer: no transport configured \u2014 provide `transport` or `send` option");
-    }
-    await transporter.sendMail({ ...opts, from: opts.from ?? from });
-  }
-  async function close() {
-    transporter?.close();
-  }
-  return { send, close };
-}
-
 // middleware/csrf.ts
 function csrf(options) {
   const cookieName = options?.cookie ?? "_csrf";
@@ -3938,7 +3473,6 @@ export {
   isProd,
   loadEnv,
   logger,
-  mailer,
   openai,
   postgres,
   queue,

package/dist/postgres/index.d.ts

@@ -1,4 +1,3 @@
 export { postgres, MIGRATIONS_TABLE } from './client.ts';
 export { PgModule } from './module.ts';
 export type { PostgresOptions, PostgresClient, PostgresInjected } from './types.ts';
-export * from './schema/index.ts';

package/dist/postgres/module.d.ts

@@ -1,13 +1,9 @@
-import type { PostgresClient } from './types.ts';
 import type { SqlClient, Closeable } from '../types.ts';
-import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
+import type { PostgresClient } from './types.ts';
 export declare class PgModule implements Closeable {
     protected sql: SqlClient;
     protected pg: PostgresClient;
     constructor(pg: PostgresClient);
-    table<R extends Record<string, unknown>>(tableOrSchema: string | Table<R>, builders?: {
-        [K in keyof R]: ColumnBuilder<R[K]>;
-    }): BoundTable<R>;
     transaction<T>(fn: (sql: SqlClient) => Promise<T>, retryOpts?: {
         maxRetries?: number;
     }): Promise<T>;

package/dist/postgres/types.d.ts

@@ -1,5 +1,4 @@
 import type { SqlClient, Context, Middleware, Closeable } from '../types.ts';
-import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
 declare module '../types.ts' {
     interface Context {
         sql: SqlClient;
@@ -29,12 +28,6 @@ export interface PostgresClient extends Middleware<Context, Context & PostgresIn
     markMigrated: (moduleName: string) => Promise<void>;
     /** Check whether a module has already been migrated. */
     isMigrated: (moduleName: string) => Promise<boolean>;
-    table: {
-        <R extends Record<string, unknown>>(tableName: string, builders: {
-            [K in keyof R]: ColumnBuilder<R[K]>;
-        }): BoundTable<R>;
-        <R extends Record<string, unknown>>(schema: Table<R>): BoundTable<R>;
-    };
     transaction: <T>(fn: (sql: any) => Promise<T>, retryOpts?: {
         maxRetries?: number;
     }) => Promise<T>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "weifuwu",
   "type": "module",
-  "version": "0.27.3",
+  "version": "0.27.5",
   "description": "Web-standard HTTP microframework for Node.js — (req, ctx) => Response",
   "exports": {
     ".": "./dist/index.js"
@@ -31,7 +31,6 @@
     "ai": "^6",
     "graphql": "^16",
     "ioredis": "^5.11.0",
-    "nodemailer": "^8.0.10",
     "postgres": "^3.4.9",
     "ws": "^8",
     "zod": "^4.4.3"
@@ -48,7 +47,6 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^25.9.3",
-    "@types/nodemailer": "^6.4.17",
     "@types/ws": "^8.18.1",
     "esbuild": "^0.28.0",
     "eslint": "^10.5.0",

package/dist/mailer.d.ts

@@ -1,51 +0,0 @@
-import { type Transporter } from 'nodemailer';
-import type { Closeable } from './types.ts';
-/** Options for sending an email. */
-export interface MailOptions {
-    /** Recipient address(es). */
-    to: string | string[];
-    /** Email subject. */
-    subject: string;
-    /** Plain text body. */
-    text?: string;
-    /** HTML body. */
-    html?: string;
-    /** Sender address (overrides `MailerOptions.from`). */
-    from?: string;
-    /** CC recipient(s). */
-    cc?: string | string[];
-    /** BCC recipient(s). */
-    bcc?: string | string[];
-}
-/** Options for {@link mailer}. */
-export interface MailerOptions {
-    /** Nodemailer transport string or pre-built transporter object. */
-    transport?: string | Transporter;
-    /** Default sender address. */
-    from?: string;
-    /** Custom send function (bypasses nodemailer). */
-    send?: (opts: MailOptions) => Promise<void>;
-}
-/** Mailer instance returned by {@link mailer}. */
-export interface Mailer extends Closeable {
-    /** Send an email. */
-    send: (opts: MailOptions) => Promise<void>;
-    /** Close the nodemailer transport. */
-    close: () => Promise<void>;
-}
-/**
- * Create a mailer instance.
- *
- * ```ts
- * import { mailer } from 'weifuwu'
- *
- * const email = mailer({ transport: 'smtp://user:pass@smtp.example.com' })
- * await email.send({
- *   to: 'user@example.com',
- *   subject: 'Hello',
- *   text: 'Hello from weifuwu!',
- * })
- * await email.close()
- * ```
- */
-export declare function mailer(options: MailerOptions): Mailer;

package/dist/postgres/schema/columns.d.ts

@@ -1,99 +0,0 @@
-import { SQL } from './sql.ts';
-/** Reference to another table's column (foreign key). */
-export interface ColumnReference {
-    /** Referenced table name. */
-    table: string;
-    /** Referenced column name (default: `'id'`). */
-    column: string;
-    /** `ON DELETE` action (e.g. `'cascade'`, `'set null'`). */
-    onDelete?: string;
-}
-/**
- * Fluent column builder for DDL generation.
- *
- * ```ts
- * text('name').notNull().unique()
- * integer('user_id').references('users')
- * timestamptz('created_at').default(sql`NOW()`)
- * ```
- */
-export declare class ColumnBuilder<T> {
-    /** Column name. */
-    name: string;
-    /** SQL type string (e.g. `'TEXT'`, `'INTEGER'`). */
-    sqlType: string;
-    /** Whether this column is PRIMARY KEY. */
-    isPrimaryKey: boolean;
-    /** Whether this column allows NULL. */
-    isNullable: boolean;
-    /** Whether this column has a UNIQUE constraint. */
-    isUnique: boolean;
-    /** Whether the value is auto-generated (e.g. SERIAL, UUID defaults). */
-    isAutoGenerate: boolean;
-    /** DEFAULT expression as a raw SQL string. */
-    defaultExpr: string | null;
-    /** Foreign key reference, if any. */
-    ref: ColumnReference | null;
-    constructor(name: string, sqlType: string);
-    /** Mark as PRIMARY KEY (implies NOT NULL). */
-    primaryKey(): this;
-    /** Add NOT NULL constraint. */
-    notNull(): this;
-    /** Allow NULL values (default). */
-    nullable(): this;
-    /** Set a DEFAULT value. Accepts raw SQL, string, number, or boolean. */
-    default(expr: SQL | string | number | boolean): this;
-    /** Add UNIQUE constraint. */
-    unique(): this;
-    /** Add FOREIGN KEY reference to another table. */
-    references(table: string, column?: string, onDelete?: string): this;
-}
-/** Auto-incrementing integer primary key (`SERIAL`). */
-export declare function serial(name: string): ColumnBuilder<number>;
-/** UUID column. */
-export declare function uuid(name: string): ColumnBuilder<string>;
-/** TEXT column. */
-export declare function text(name: string): ColumnBuilder<string>;
-/** INTEGER column. */
-export declare function integer(name: string): ColumnBuilder<number>;
-/** BOOLEAN column (exported as `boolean`). */
-export declare function boolean_(name: string): ColumnBuilder<boolean>;
-export { boolean_ as boolean };
-/** TIMESTAMPTZ column (timestamp with time zone). */
-export declare function timestamptz(name: string): ColumnBuilder<string>;
-/** JSONB column (stores arbitrary JSON data). */
-export declare function jsonb<T = unknown>(name: string): ColumnBuilder<T>;
-/** TEXT[] column (PostgreSQL array of text). */
-export declare function textArray(name: string): ColumnBuilder<string[]>;
-/** Vector column for pgvector (embedding storage). Requires `dimensions`. */
-export declare function vector(name: string, dims: number): ColumnBuilder<number[]>;
-export interface PartitionByDef {
-    type: 'RANGE' | 'LIST' | 'HASH';
-    column: string;
-}
-export declare function partitionBy(type: 'range' | 'list' | 'hash', column: string): PartitionByDef;
-/**
- * Create a pair of `created_at` / `updated_at` timestamp columns
- * that default to `NOW()` and are NOT NULL.
- *
- * ```ts
- * pgTable('users', {
- *   id: serial('id').primaryKey(),
- *   name: text('name'),
- *   ...timestamps(),
- * })
- * ```
- */
-export declare function timestamps(): {
-    readonly created_at: ColumnBuilder<string>;
-    readonly updated_at: ColumnBuilder<string>;
-};
-/**
- * Convert a ColumnBuilder into a DDL column definition string.
- *
- * ```ts
- * toDDL(text('name').notNull())
- * // '"name" TEXT NOT NULL'
- * ```
- */
-export declare function toDDL(col: ColumnBuilder<unknown>): string;

package/dist/postgres/schema/index.d.ts

@@ -1,6 +0,0 @@
-export { sql, SQL } from './sql.ts';
-export { ColumnBuilder, serial, uuid, text, integer, boolean as boolean, boolean_, timestamptz, jsonb, textArray, vector, toDDL, partitionBy, timestamps, } from './columns.ts';
-export type { PartitionByDef } from './columns.ts';
-export { pgTable, Table, BoundTable } from './table.ts';
-export type { IndexOptions, FindOptions, CreateOptions } from './table.ts';
-export { eq, ne, gt, gte, lt, lte, isNull, isNotNull, like, contains, in_, and, or, not, } from './where.ts';

package/dist/postgres/schema/sql.d.ts

@@ -1,22 +0,0 @@
-/**
- * A parameterized SQL fragment with template strings and bound values.
- * Used internally by the schema builder and where helpers.
- */
-export declare class SQL {
-    /** Template string parts (interleaved with values). */
-    strings: TemplateStringsArray;
-    /** Bound parameter values. */
-    values: unknown[];
-    constructor(strings: TemplateStringsArray, values: unknown[]);
-    /** Serialize to a raw SQL string (interpolating values inline for DDL use). */
-    toSQL(): string;
-}
-/**
- * Tagged template helper for creating parameterized SQL fragments.
- *
- * ```ts
- * sql`NOW()`
- * sql`${column} ILIKE ${'%' + search + '%'}`
- * ```
- */
-export declare function sql(strings: TemplateStringsArray, ...values: unknown[]): SQL;

package/dist/postgres/schema/table.d.ts

@@ -1,141 +0,0 @@
-import type { SqlClient } from '../../types.ts';
-import { ColumnBuilder, type PartitionByDef } from './columns.ts';
-import { SQL } from './sql.ts';
-/** Options for table index creation. */
-export interface IndexOptions {
-    /** Whether the index should be UNIQUE. */
-    unique?: boolean;
-    /** Index type: btree (default), hnsw (pgvector), gin (JSONB). */
-    type?: 'btree' | 'hnsw' | 'gin';
-    /** Create index in DESC order. */
-    desc?: boolean;
-    /** Custom operator class (e.g. `vector_cosine_ops`). */
-    operator?: string;
-}
-/** Options for CREATE TABLE. */
-export interface CreateOptions {
-    /** Partition by clause (RANGE, LIST, or HASH). */
-    partitionBy?: PartitionByDef;
-}
-/** Options for find/read queries. */
-export interface FindOptions {
-    /** ORDER BY clause: `{ column: 'asc' | 'desc' }`. */
-    orderBy?: Record<string, 'asc' | 'desc'>;
-    /** LIMIT. */
-    limit?: number;
-    /** OFFSET. */
-    offset?: number;
-    /** Columns to SELECT (default: all). */
-    select?: string[];
-    /** Include soft-deleted rows (also sets `withDeleted` context). */
-    withDeleted?: boolean;
-}
-/**
- * Type-safe table schema + CRUD operations.
- *
- * Create an instance with {@link pgTable}, then call `.bind(sql)` to get a
- * `BoundTable` for running queries.
- *
- * ```ts
- * const users = pgTable('users', {
- *   id: serial('id').primaryKey(),
- *   name: text('name').notNull(),
- *   email: text('email').unique(),
- * })
- *
- * const db = users.bind(sql)
- * await db.create()
- * await db.insert({ name: 'Alice', email: 'a@b.com' })
- * const row = await db.findBy({ email: 'a@b.com' })
- * ```
- */
-export declare class Table<R extends Record<string, unknown>> {
-    /** Database table name. */
-    readonly tableName: string;
-    /** All column builders (order-preserving). */
-    readonly columns: ColumnBuilder<unknown>[];
-    /** Column builders keyed by property name. */
-    readonly builders: Record<string, ColumnBuilder<unknown>>;
-    private colEntries;
-    constructor(tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
-    /** Check if the table has a column with the given DB name. */
-    hasColumn(dbName: string): boolean;
-    /**
-     * Bind this table schema to a SQL connection, returning a `BoundTable`
-     * that can run queries without passing `sql` to every call.
-     */
-    bind(sql: SqlClient): BoundTable<R>;
-    /** Returns the primary key column name (DB name), or 'id' as fallback. */
-    private get pkColumn();
-    /** Adds `deleted_at IS NULL` condition if the table has soft delete and not explicitly excluded. */
-    private _softDeleteFilter;
-    create(sql: SqlClient, opts?: CreateOptions): Promise<void>;
-    drop(sql: SqlClient, opts?: {
-        cascade?: boolean;
-    }): Promise<void>;
-    createIndex(sql: SqlClient, columns: string | string[], opts?: IndexOptions): Promise<void>;
-    createUniqueIndex(sql: SqlClient, columns: string | string[]): Promise<void>;
-    private _buildConditions;
-    private _buildSET;
-    insert(sql: SqlClient, data: Partial<R>): Promise<R>;
-    insertMany(sql: SqlClient, data: Partial<R>[]): Promise<R[]>;
-    read(sql: SqlClient, id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
-    readMany(sql: SqlClient, where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
-        count: number;
-        data: R[];
-    }>;
-    update(sql: SqlClient, id: string | number, data: Partial<R>): Promise<R | undefined>;
-    updateMany(sql: SqlClient, where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
-    delete(sql: SqlClient, id: string | number): Promise<R | undefined>;
-    hardDelete(sql: SqlClient, id: string | number): Promise<R | undefined>;
-    deleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    hardDeleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    upsert(sql: SqlClient, data: Partial<R>, conflict: string | string[]): Promise<R>;
-    count(sql: SqlClient, where?: Partial<R> | SQL | SQL[]): Promise<number>;
-}
-export declare class BoundTable<R extends Record<string, unknown>> {
-    private inner;
-    private sql;
-    /** The underlying table name. */
-    get tableName(): string;
-    constructor(sql: SqlClient, tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
-    create(opts?: CreateOptions): Promise<void>;
-    drop(opts?: {
-        cascade?: boolean;
-    }): Promise<void>;
-    createIndex(columns: string | string[], opts?: IndexOptions): Promise<void>;
-    createUniqueIndex(columns: string | string[]): Promise<void>;
-    insert(data: Partial<R>): Promise<R>;
-    insertMany(data: Partial<R>[]): Promise<R[]>;
-    read(id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
-    readMany(where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
-        count: number;
-        data: R[];
-    }>;
-    update(id: string | number, data: Partial<R>): Promise<R | undefined>;
-    updateMany(where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
-    delete(id: string | number): Promise<R | undefined>;
-    hardDelete(id: string | number): Promise<R | undefined>;
-    deleteMany(where: Partial<R> | SQL | SQL[]): Promise<number>;
-    hardDeleteMany(where: Partial<R> | SQL | SQL[]): Promise<number>;
-    upsert(data: Partial<R>, conflict: string | string[]): Promise<R>;
-    count(where?: Partial<R> | SQL | SQL[]): Promise<number>;
-    withSql(sql: SqlClient): BoundTable<R>;
-}
-/**
- * Define a type-safe table schema.
- *
- * ```ts
- * const users = pgTable('users', {
- *   id: serial('id').primaryKey(),
- *   name: text('name').notNull(),
- *   email: text('email').unique(),
- * })
- *
- * // The generic type R preserves the column types:
- * // Table<{ id: number; name: string; email: string }>
- * ```
- */
-export declare function pgTable<R extends Record<string, unknown>>(tableName: string, builders: {
-    [K in keyof R]: ColumnBuilder<R[K]>;
-}): Table<R>;

package/dist/postgres/schema/where.d.ts

@@ -1,29 +0,0 @@
-import { SQL } from './sql.ts';
-/** Column equals value: `col = val`. */
-export declare function eq(col: string, val: unknown): SQL;
-/** Column not equals value: `col != val`. */
-export declare function ne(col: string, val: unknown): SQL;
-/** Column greater than value: `col > val`. */
-export declare function gt(col: string, val: unknown): SQL;
-/** Column greater than or equal value: `col >= val`. */
-export declare function gte(col: string, val: unknown): SQL;
-/** Column less than value: `col < val`. */
-export declare function lt(col: string, val: unknown): SQL;
-/** Column less than or equal value: `col <= val`. */
-export declare function lte(col: string, val: unknown): SQL;
-/** Column IS NULL. */
-export declare function isNull(col: string): SQL;
-/** Column IS NOT NULL. */
-export declare function isNotNull(col: string): SQL;
-/** Column LIKE pattern. */
-export declare function like(col: string, pattern: string): SQL;
-/** Negate a condition: `NOT (condition)`. */
-export declare function not(condition: SQL): SQL;
-/** JSONB containment: `col @> val` (does `col` contain `val`?). */
-export declare function contains(col: string, val: Record<string, unknown>): SQL;
-/** Column value is in array: `col = ANY(val)`. */
-export declare function in_(col: string, val: unknown[]): SQL;
-/** Combine conditions with AND. */
-export declare function and(...conditions: SQL[]): SQL;
-/** Combine conditions with OR. */
-export declare function or(...conditions: SQL[]): SQL;