bun-query-builder 0.1.58 → 0.1.60

package/dist/bin/cli.js

@@ -12062,6 +12062,13 @@ function createSQLiteSQL(filename) {
   sqlFunction._wrapper = wrapper;
   return sqlFunction;
 }
+function sqliteFileFromUrl(url) {
+  const stripped = url.replace(/^(?:sqlite|sqlite3|file):/i, "");
+  if (stripped === url)
+    return url;
+  const path = stripped.startsWith("///") ? stripped.slice(2) : stripped.startsWith("//") ? stripped.slice(2) : stripped;
+  return path || ":memory:";
+}
 function createConnectionString(dialect, dbConfig) {
   if ((dialect === "postgres" || dialect === "mysql" || dialect === "singlestore") && process19.env.DB_CONNECTION === dialect) {
     const e = process19.env;
@@ -12075,7 +12082,7 @@ function createConnectionString(dialect, dbConfig) {
     return `${scheme}://${envUser}:${envPass}@${envHost}${envPort ? `:${envPort}` : ""}/${envDb}${ssl2}`;
   }
   if (dbConfig.url) {
-    return dbConfig.url;
+    return dialect === "sqlite" ? sqliteFileFromUrl(dbConfig.url) : dbConfig.url;
   }
   const { database, username, password, host = "localhost", port, ssl } = dbConfig;
   const sslQ = ssl || process19.env.DB_SSL === "true" || process19.env.DB_SSL === "1" ? "?ssl=true" : "";
@@ -12351,9 +12358,37 @@ var init_benchmark = __esm(() => {
   init_src2();
 });
 
+// src/inflect.ts
+function stripTrailingS(name) {
+  return name.endsWith("s") ? name.slice(0, -1) : name;
+}
+function inflectSingular(name) {
+  if (name.endsWith("ies") && name.length > 3) {
+    const stem = name.slice(0, -3);
+    const prev = stem[stem.length - 1];
+    if (prev && !"aeiou".includes(prev))
+      return `${stem}y`;
+  }
+  if (name.endsWith("es") && name.length > 2) {
+    const stem = name.slice(0, -2);
+    if (stem.endsWith("s") || stem.endsWith("x") || stem.endsWith("ch") || stem.endsWith("sh"))
+      return stem;
+  }
+  if (name.endsWith("s") && !name.endsWith("ss") && !name.endsWith("us") && !name.endsWith("is"))
+    return name.slice(0, -1);
+  return name;
+}
+function singularizerFor(strategy) {
+  if (strategy === "none")
+    return (name) => name;
+  if (strategy === "inflect")
+    return inflectSingular;
+  return stripTrailingS;
+}
+
 // src/pivot.ts
 function defaultSingularize(name) {
-  return name.endsWith("s") ? name.slice(0, -1) : name;
+  return singularizerFor(config5.relations?.singularizeStrategy)(name);
 }
 function resolvePivot(meta, parentTable, relationKey, options = {}) {
   const singularize = options.singularize ?? defaultSingularize;
@@ -12430,6 +12465,9 @@ function* iterateAllPivots(meta, options = {}) {
     }
   }
 }
+var init_pivot = __esm(() => {
+  init_config();
+});
 
 // src/client.ts
 function isRawExpression(expr) {
@@ -12610,7 +12648,13 @@ class QueryCache {
     this.cache.clear();
   }
   setMaxSize(size) {
-    this.maxSize = size;
+    this.maxSize = Math.max(0, Math.floor(size));
+    while (this.cache.size > this.maxSize) {
+      const lruKey = this.cache.keys().next().value;
+      if (lruKey === undefined)
+        break;
+      this.cache.delete(lruKey);
+    }
   }
 }
 function isRetriableTxError(err) {
@@ -12715,8 +12759,7 @@ function computeBackoffMs(attempt, cfg) {
   const max = Math.max(base, cfg?.maxMs ?? 2000);
   let ms = Math.min(max, base * factor ** Math.max(0, attempt - 1));
   if (cfg?.jitter) {
-    const jitter = Math.random() * ms * 0.2;
-    ms = ms - jitter / 2;
+    ms = Math.min(max, ms * (0.9 + Math.random() * 0.2));
   }
   return Math.floor(ms);
 }
@@ -12968,11 +13011,7 @@ function createQueryBuilder(state) {
     const pivotColumns = new Map;
     const pivotConfigRelations = new Set;
     let cacheTtl = 60000;
-    const singularize = (name) => {
-      if (config5.relations.singularizeStrategy === "none")
-        return name;
-      return name.endsWith("s") ? name.slice(0, -1) : name;
-    };
+    const singularize = (name) => singularizerFor(config5.relations.singularizeStrategy)(name);
     const resolvePivotLocal = (relationKey) => {
       if (!meta)
         return null;
@@ -15448,6 +15487,7 @@ function createQueryBuilder(state) {
           const colCount = keys.length;
           const totalParams = rowCount * colCount;
           params.length = totalParams;
+          const columnList = isPostgres ? keys.map((k) => quoteId(k)).join(",") : keys.join(",");
           if (rowCount === 1) {
             if (!isPostgres) {
               let cols = quoteId(keys[0]);
@@ -15460,7 +15500,6 @@ function createQueryBuilder(state) {
               }
               sqlText = `INSERT INTO ${quoteId(table)}(${cols})VALUES(${placeholders})`;
             } else {
-              const columnList = keys.map((k) => quoteId(k)).join(",");
               sqlText = `INSERT INTO ${quoteId(table)}(${columnList})VALUES(`;
               for (let c = 0;c < colCount; c++) {
                 if (c > 0)
@@ -15471,8 +15510,8 @@ function createQueryBuilder(state) {
               sqlText += ")";
             }
           } else {
-            const columnList = keys.map((k) => quoteId(k)).join(",");
-            sqlText = `INSERT INTO ${quoteId(table)}(${columnList})VALUES`;
+            const columnList2 = keys.map((k) => quoteId(k)).join(",");
+            sqlText = `INSERT INTO ${quoteId(table)}(${columnList2})VALUES`;
             let pidx = 0;
             for (let r = 0;r < rowCount; r++) {
               const row = rows[r];
@@ -16028,11 +16067,13 @@ function createQueryBuilder(state) {
       }
     },
     async savepoint(fn) {
+      if (state?.inTransaction !== true)
+        throw new Error("savepoint() must be called inside a transaction");
       const s = _sql;
       if (!s || typeof s.savepoint !== "function")
-        throw new Error("savepoint() must be called inside a transaction");
+        throw new Error("savepoint() is not supported by the active connection");
       return await s.savepoint(async (sp) => {
-        const qb = createQueryBuilder({ sql: sp, meta, schema });
+        const qb = createQueryBuilder({ sql: sp, meta, schema, inTransaction: true });
         return await fn(qb);
       });
     },
@@ -16449,6 +16490,7 @@ var SQL_PATTERNS, SAFE_WHERE_OPERATORS, warnedSqlFragmentContexts, queryCache, r
 var init_client = __esm(() => {
   init_config();
   init_db();
+  init_pivot();
   SQL_PATTERNS = {
     SELECT_STAR: /^SELECT\s+\*/i,
     SELECT: /^SELECT\s+/i,
@@ -17049,7 +17091,7 @@ var init_db_info = __esm(() => {
 // src/actions/db-optimize.ts
 import process22 from "process";
 async function dbOptimize(options = {}) {
-  const dialect = options.dialect || process22.env.DB_DIALECT || "postgres";
+  const dialect = options.dialect || process22.env.DB_DIALECT || config5.dialect || "postgres";
   const aggressive = options.aggressive || false;
   if (options.verbose) {
     console.log(`Optimizing ${dialect} database${aggressive ? " (aggressive mode)" : ""}...`);
@@ -17144,7 +17186,7 @@ var init_db_optimize = __esm(() => {
 // src/actions/db-wipe.ts
 import process23 from "process";
 async function dbWipe(options = {}) {
-  const dialect = options.dialect || process23.env.DB_DIALECT || "postgres";
+  const dialect = options.dialect || process23.env.DB_DIALECT || config5.dialect || "postgres";
   if (options.verbose) {
     console.log(`Wiping all tables from ${dialect} database...`);
   }
@@ -18762,7 +18804,7 @@ async function resetDatabase(dir, opts = {}) {
   if (!dir) {
     dir = join9(process25.cwd(), "app/Models");
   }
-  const dialect = opts.dialect || "postgres";
+  const dialect = opts.dialect || config5.dialect || "postgres";
   const driver = getDialectDriver(dialect);
   const workspaceRoot = getWorkspaceRoot();
   try {
@@ -18862,7 +18904,7 @@ async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
-  const dialect = String(opts.dialect || "postgres");
+  const dialect = String(opts.dialect || config5.dialect || "postgres");
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
   if (existsSync16(snapshotPath)) {
     unlinkSync(snapshotPath);
@@ -20018,6 +20060,23 @@ var init_actions = __esm(() => {
   init_wait_ready();
 });
 
+// src/relation-utils.ts
+function normalizeRelationEntry(entry) {
+  if (typeof entry === "string")
+    return { model: entry };
+  if (entry && typeof entry === "object" && typeof entry.model === "string") {
+    const e = entry;
+    return { model: e.model, foreignKey: e.foreignKey, onDelete: e.onDelete };
+  }
+  return null;
+}
+function normalizeRelationList(rel) {
+  if (!rel)
+    return [];
+  const entries = Array.isArray(rel) ? rel : typeof rel === "object" ? Object.values(rel) : [];
+  return entries.map(normalizeRelationEntry).filter((x) => x !== null);
+}
+
 // ../../node_modules/@stacksjs/ts-faker/dist/chunk-aggdkeg4.js
 import { existsSync as zS } from "fs";
 import { join as YS } from "path";
@@ -24676,6 +24735,13 @@ function normalizeAttributeKeys(data) {
   }
   return result;
 }
+function normalizeAttributeKeysInPlace(data) {
+  for (const key in data) {
+    if (toSnakeCase(key) !== key)
+      return normalizeAttributeKeys(data);
+  }
+  return data;
+}
 function findAttributeDef(attrs, key) {
   if (attrs[key])
     return attrs[key];
@@ -24697,7 +24763,7 @@ class ModelInstance {
   _relations = {};
   constructor(definition, attributes = {}) {
     this._definition = definition;
-    this._attributes = normalizeAttributeKeys({ ...attributes });
+    this._attributes = normalizeAttributeKeysInPlace({ ...attributes });
     this._original = null;
     const btmKeys = collectBelongsToManyKeys(definition);
     if (btmKeys.size === 0)
@@ -24753,12 +24819,12 @@ class ModelInstance {
   only(keys) {
     const out = {};
     for (const k2 of keys) {
-      out[k2] = this._attributes[k2];
+      out[k2] = this._attributes[toSnakeCase(k2)];
     }
     return out;
   }
   except(keys) {
-    const drop = new Set(keys.map((k2) => k2));
+    const drop = new Set(keys.map((k2) => toSnakeCase(k2)));
     const out = {};
     for (const k2 of Object.keys(this._attributes)) {
       if (!drop.has(k2))
@@ -24786,7 +24852,8 @@ class ModelInstance {
     if (this._original === null)
       return false;
     if (column) {
-      return this._attributes[column] !== this._original[column];
+      const key = toSnakeCase(column);
+      return this._attributes[key] !== this._original[key];
     }
     return Object.keys(this._attributes).some((k2) => this._attributes[k2] !== this._original[k2]);
   }
@@ -24795,7 +24862,7 @@ class ModelInstance {
   }
   getOriginal(column) {
     const orig = this.getOriginalAttributes();
-    return orig[column];
+    return orig[toSnakeCase(column)];
   }
   getChanges() {
     if (this._original === null)
@@ -24834,7 +24901,7 @@ class ModelInstance {
     const setters = this._definition.set || {};
     for (const [key, setter] of Object.entries(setters)) {
       if (this.isDirty(key)) {
-        this._attributes[key] = setter(this._attributes);
+        this._attributes[toSnakeCase(key)] = setter(this._attributes);
       }
     }
     if (this._attributes[pk]) {
@@ -24997,6 +25064,9 @@ class ModelInstance {
     return json;
   }
 }
+function sqlColumn(name) {
+  return toSnakeCase(name);
+}
 function toSnakeCase(str) {
   let cached = snakeCaseCache.get(str);
   if (cached !== undefined)
@@ -25045,6 +25115,34 @@ function resolveRelation(definition, relationName) {
     }
     return null;
   }
+  function findBelongsToEntry() {
+    const rel = definition.belongsTo;
+    if (!rel)
+      return null;
+    const lower = relationName.toLowerCase();
+    const unwrap = (entry) => {
+      if (typeof entry === "string")
+        return { model: entry };
+      if (entry && typeof entry === "object" && typeof entry.model === "string")
+        return { model: entry.model, foreignKey: entry.foreignKey };
+      return null;
+    };
+    if (Array.isArray(rel)) {
+      for (const item of rel) {
+        const e2 = unwrap(item);
+        if (e2 && e2.model.toLowerCase() === lower)
+          return e2;
+      }
+      return null;
+    }
+    if (typeof rel === "object") {
+      for (const [key, value] of Object.entries(rel)) {
+        if (key === relationName || key.toLowerCase() === lower)
+          return unwrap(value);
+      }
+    }
+    return null;
+  }
   function findBelongsToManyEntry() {
     const rel = definition.belongsToMany;
     if (!rel)
@@ -25084,12 +25182,13 @@ function resolveRelation(definition, relationName) {
     const foreignKey = toSnakeCase(parentName) + "_id";
     return { type: "hasOne", relatedModelName: hasOneModel, relatedTable, foreignKey, localKey: parentPk };
   }
-  const belongsToModel = findModelName(definition.belongsTo);
-  if (belongsToModel) {
+  const belongsToEntry = findBelongsToEntry();
+  if (belongsToEntry) {
+    const belongsToModel = belongsToEntry.model;
     const relatedModel = getModelFromRegistry(belongsToModel);
     const relatedTable = relatedModel?.getTable?.() || toTableName(belongsToModel);
     const relatedPk = relatedModel?.getDefinition?.()?.primaryKey || "id";
-    const foreignKey = toSnakeCase(belongsToModel) + "_id";
+    const foreignKey = belongsToEntry.foreignKey || `${toSnakeCase(belongsToModel)}_id`;
     return { type: "belongsTo", relatedModelName: belongsToModel, relatedTable, foreignKey, localKey: relatedPk };
   }
   const found = findBelongsToManyEntry();
@@ -25111,12 +25210,12 @@ function resolveRelation(definition, relationName) {
       }
       pivotTable = throughModel.getTable?.() || throughModel.getDefinition?.()?.table || toTableName(config6.through);
     } else {
-      const a2 = parentTable.endsWith("s") ? parentTable.slice(0, -1) : parentTable;
-      const b2 = relatedTable.endsWith("s") ? relatedTable.slice(0, -1) : relatedTable;
+      const a2 = singularizeWord(parentTable);
+      const b2 = singularizeWord(relatedTable);
       pivotTable = [a2, b2].sort().join("_");
     }
-    const pivotFkParent = config6?.foreignKey || `${parentTable.endsWith("s") ? parentTable.slice(0, -1) : parentTable}_id`;
-    const pivotFkRelated = config6?.relatedKey || `${relatedTable.endsWith("s") ? relatedTable.slice(0, -1) : relatedTable}_id`;
+    const pivotFkParent = config6?.foreignKey || `${singularizeWord(parentTable)}_id`;
+    const pivotFkRelated = config6?.relatedKey || `${singularizeWord(relatedTable)}_id`;
     const pivotColumns = [];
     if (config6?.pivot?.columns) {
       for (const k2 of Object.keys(config6.pivot.columns))
@@ -25184,8 +25283,17 @@ function resolveRelation(definition, relationName) {
     return hot;
   return null;
 }
+function distinctParentIds(instances, pk) {
+  const seen = new Set;
+  for (const i2 of instances) {
+    const v2 = i2.get(pk);
+    if (v2 != null)
+      seen.add(v2);
+  }
+  return [...seen];
+}
 function singularizeWord(table) {
-  return table.endsWith("s") ? table.slice(0, -1) : table;
+  return singularizerFor(config5.relations?.singularizeStrategy)(table);
 }
 
 class BelongsToManyRelationBuilder {
@@ -25588,7 +25696,7 @@ class ModelQueryBuilder {
   }
   whereNotBetween(column, range) {
     assertValidIdentifier(column, "whereNotBetween(column)");
-    const col = column;
+    const col = sqlColumn(column);
     this._wheres.push({
       raw: `(${col} < ? OR ${col} > ?)`,
       rawParams: [range[0], range[1]],
@@ -25634,7 +25742,10 @@ class ModelQueryBuilder {
     return this;
   }
   with(...relations) {
-    this._withRelations = relations;
+    for (const r2 of relations) {
+      if (!this._withRelations.includes(r2))
+        this._withRelations.push(r2);
+    }
     return this;
   }
   getWithRelations() {
@@ -25650,13 +25761,14 @@ class ModelQueryBuilder {
         if (w.rawParams && w.rawParams.length > 0)
           params.push(...w.rawParams);
       } else if (w.value === null) {
-        clause = w.operator === "=" ? `${w.column} IS NULL` : `${w.column} IS NOT NULL`;
+        const col = sqlColumn(w.column);
+        clause = w.operator === "=" ? `${col} IS NULL` : `${col} IS NOT NULL`;
       } else if (w.operator === "in" || w.operator === "not in") {
         const arr = w.value;
-        clause = `${w.column} ${w.operator.toUpperCase()} (${arr.map(() => "?").join(", ")})`;
+        clause = `${sqlColumn(w.column)} ${w.operator.toUpperCase()} (${arr.map(() => "?").join(", ")})`;
         params.push(...arr);
       } else {
-        clause = `${w.column} ${w.operator} ?`;
+        clause = `${sqlColumn(w.column)} ${w.operator} ?`;
         params.push(w.value);
       }
       clauses.push(i2 === 0 ? clause : `${w.boolean.toUpperCase()} ${clause}`);
@@ -25677,13 +25789,14 @@ class ModelQueryBuilder {
   }
   buildQuery() {
     const params = [];
-    let sql2 = `SELECT ${this._select.join(", ")} FROM ${this._definition.table}`;
+    const cols = this._select.map((c2) => c2 === "*" ? c2 : sqlColumn(c2));
+    let sql2 = `SELECT ${cols.join(", ")} FROM ${this._definition.table}`;
     const whereBody = this.composeWhere(params);
     if (whereBody) {
       sql2 += ` WHERE ${whereBody}`;
     }
     if (this._orderBy.length > 0) {
-      sql2 += ` ORDER BY ${this._orderBy.map((o2) => `${o2.column} ${o2.direction.toUpperCase()}`).join(", ")}`;
+      sql2 += ` ORDER BY ${this._orderBy.map((o2) => `${sqlColumn(o2.column)} ${o2.direction.toUpperCase()}`).join(", ")}`;
     }
     if (this._limit !== undefined)
       sql2 += ` LIMIT ${this._limit}`;
@@ -25697,165 +25810,168 @@ class ModelQueryBuilder {
   async eagerLoadRelations(instances) {
     if (instances.length === 0 || this._withRelations.length === 0)
       return;
+    await Promise.all(this._withRelations.map((r2) => this.eagerLoadRelation(r2, instances)));
+  }
+  async eagerLoadRelation(relationName, instances) {
     const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
-    for (const relationName of this._withRelations) {
-      const cacheKey = `${this._definition.name}:${relationName}`;
-      let rel = relationCache.get(cacheKey);
-      if (rel === undefined) {
-        rel = resolveRelation(this._definition, relationName);
-        if (relationCache.size >= RELATION_CACHE_MAX)
-          relationCache.clear();
-        relationCache.set(cacheKey, rel);
-      }
-      if (!rel)
-        continue;
-      if (rel.type === "hasMany" || rel.type === "hasOne") {
-        const parentIds = instances.map((i2) => i2.get(pk)).filter((id) => id != null);
-        if (parentIds.length === 0)
-          continue;
-        const placeholders = parentIds.map(() => "?").join(", ");
-        const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.foreignKey} IN (${placeholders})`, parentIds);
-        const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
-        const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
-        if (rel.type === "hasMany") {
-          const grouped = new Map;
-          for (const row of rows) {
-            const fkVal = row[rel.foreignKey];
-            if (!grouped.has(fkVal))
-              grouped.set(fkVal, []);
-            grouped.get(fkVal).push(row);
-          }
-          for (const instance of instances) {
-            const related = grouped.get(instance.get(pk)) || [];
-            instance.setRelation(relationName, related.map((r2) => new ModelInstance(relDef, r2)));
-          }
-        } else {
-          const byFk = new Map;
-          for (const row of rows) {
-            byFk.set(row[rel.foreignKey], row);
-          }
-          for (const instance of instances) {
-            const row = byFk.get(instance.get(pk));
-            instance.setRelation(relationName, row ? new ModelInstance(relDef, row) : null);
-          }
+    const cacheKey = `${this._definition.name}:${relationName}`;
+    let rel = relationCache.get(cacheKey);
+    if (rel === undefined) {
+      rel = resolveRelation(this._definition, relationName);
+      if (relationCache.size >= RELATION_CACHE_MAX)
+        relationCache.clear();
+      relationCache.set(cacheKey, rel);
+    }
+    if (!rel)
+      return;
+    if (rel.type === "hasMany" || rel.type === "hasOne") {
+      const parentIds = distinctParentIds(instances, pk);
+      if (parentIds.length === 0)
+        return;
+      const placeholders = parentIds.map(() => "?").join(", ");
+      const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.foreignKey} IN (${placeholders})`, parentIds);
+      const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
+      const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
+      if (rel.type === "hasMany") {
+        const grouped = new Map;
+        for (const row of rows) {
+          const fkVal = row[rel.foreignKey];
+          if (!grouped.has(fkVal))
+            grouped.set(fkVal, []);
+          grouped.get(fkVal).push(row);
         }
-      }
-      if (rel.type === "belongsTo") {
-        const fkSet = new Set;
-        for (const i2 of instances) {
-          const v2 = i2._attributes[rel.foreignKey];
-          if (v2 != null)
-            fkSet.add(v2);
+        for (const instance of instances) {
+          const related = grouped.get(instance.get(pk)) || [];
+          instance.setRelation(relationName, related.map((r2) => new ModelInstance(relDef, r2)));
         }
-        const uniqueFkValues = [...fkSet];
-        if (uniqueFkValues.length === 0)
-          continue;
-        const placeholders = uniqueFkValues.map(() => "?").join(", ");
-        const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.localKey} IN (${placeholders})`, uniqueFkValues);
-        const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
-        const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
-        const byPk = new Map;
+      } else {
+        const byFk = new Map;
         for (const row of rows) {
-          byPk.set(row[rel.localKey], row);
+          const k2 = row[rel.foreignKey];
+          if (!byFk.has(k2))
+            byFk.set(k2, row);
         }
         for (const instance of instances) {
-          const fkVal = instance._attributes[rel.foreignKey];
-          const row = byPk.get(fkVal);
+          const row = byFk.get(instance.get(pk));
           instance.setRelation(relationName, row ? new ModelInstance(relDef, row) : null);
         }
       }
-      if (rel.type === "belongsToMany") {
-        const parentIds = instances.map((i2) => i2.get(pk)).filter((id) => id != null);
-        if (parentIds.length === 0)
-          continue;
-        if (!rel.pivotTable || !rel.pivotFkParent || !rel.pivotFkRelated)
-          continue;
-        const pivotPlaceholders = parentIds.map(() => "?").join(", ");
-        const pivotRows = await exec.all(`SELECT * FROM ${rel.pivotTable} WHERE ${rel.pivotFkParent} IN (${pivotPlaceholders})`, parentIds);
-        if (pivotRows.length === 0) {
-          for (const instance of instances)
-            instance.setRelation(relationName, []);
-          continue;
-        }
-        const relatedIdSet = new Set;
-        for (const p2 of pivotRows) {
-          const v2 = p2[rel.pivotFkRelated];
-          if (v2 != null)
-            relatedIdSet.add(v2);
-        }
-        const relatedIds = [...relatedIdSet];
-        const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
-        const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
-        const relatedPk = relDef?.primaryKey || "id";
-        let relatedRows = [];
-        if (relatedIds.length > 0) {
-          const relPlaceholders = relatedIds.map(() => "?").join(", ");
-          relatedRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${relatedPk} IN (${relPlaceholders})`, relatedIds);
-        }
-        const relatedByPk = new Map;
-        for (const r2 of relatedRows)
-          relatedByPk.set(r2[relatedPk], r2);
-        const pivotByParent = new Map;
-        for (const p2 of pivotRows) {
-          const key = p2[rel.pivotFkParent];
-          if (!pivotByParent.has(key))
-            pivotByParent.set(key, []);
-          pivotByParent.get(key).push(p2);
-        }
-        const pivotKnownKeys = new Set([rel.pivotFkParent, rel.pivotFkRelated]);
-        for (const instance of instances) {
-          const parentVal = instance.get(pk);
-          const myPivots = pivotByParent.get(parentVal) || [];
-          const relatedInstances = myPivots.map((p2) => {
-            const relRow = relatedByPk.get(p2[rel.pivotFkRelated]);
-            if (!relRow)
-              return null;
-            const inst = new ModelInstance(relDef, relRow);
-            const extras = {};
-            for (const [k2, v2] of Object.entries(p2)) {
-              if (!pivotKnownKeys.has(k2))
-                extras[k2] = v2;
-            }
-            inst.pivot = extras;
-            return inst;
-          }).filter((x2) => x2 !== null);
-          instance.setRelation(relationName, relatedInstances);
-        }
+    }
+    if (rel.type === "belongsTo") {
+      const fkSet = new Set;
+      for (const i2 of instances) {
+        const v2 = i2._attributes[rel.foreignKey];
+        if (v2 != null)
+          fkSet.add(v2);
       }
-      if (rel.type === "hasManyThrough" || rel.type === "hasOneThrough") {
-        const parentIds = instances.map((i2) => i2.get(pk)).filter((id) => id != null);
-        if (parentIds.length === 0)
-          continue;
-        const throughPk = rel.throughLocalKey || "id";
-        const throughPh = parentIds.map(() => "?").join(", ");
-        const throughRows = await exec.all(`SELECT ${throughPk}, ${rel.throughForeignKey} FROM ${rel.throughTable} WHERE ${rel.throughForeignKey} IN (${throughPh})`, parentIds);
-        if (throughRows.length === 0) {
-          for (const instance of instances)
-            instance.setRelation(relationName, rel.type === "hasManyThrough" ? [] : null);
+      const uniqueFkValues = [...fkSet];
+      if (uniqueFkValues.length === 0)
+        return;
+      const placeholders = uniqueFkValues.map(() => "?").join(", ");
+      const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.localKey} IN (${placeholders})`, uniqueFkValues);
+      const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
+      const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
+      const byPk = new Map;
+      for (const row of rows) {
+        byPk.set(row[rel.localKey], row);
+      }
+      for (const instance of instances) {
+        const fkVal = instance._attributes[rel.foreignKey];
+        const row = byPk.get(fkVal);
+        instance.setRelation(relationName, row ? new ModelInstance(relDef, row) : null);
+      }
+    }
+    if (rel.type === "belongsToMany") {
+      const parentIds = distinctParentIds(instances, pk);
+      if (parentIds.length === 0)
+        return;
+      if (!rel.pivotTable || !rel.pivotFkParent || !rel.pivotFkRelated)
+        return;
+      const pivotPlaceholders = parentIds.map(() => "?").join(", ");
+      const pivotRows = await exec.all(`SELECT * FROM ${rel.pivotTable} WHERE ${rel.pivotFkParent} IN (${pivotPlaceholders})`, parentIds);
+      if (pivotRows.length === 0) {
+        for (const instance of instances)
+          instance.setRelation(relationName, []);
+        return;
+      }
+      const relatedIdSet = new Set;
+      for (const p2 of pivotRows) {
+        const v2 = p2[rel.pivotFkRelated];
+        if (v2 != null)
+          relatedIdSet.add(v2);
+      }
+      const relatedIds = [...relatedIdSet];
+      const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
+      const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
+      const relatedPk = relDef?.primaryKey || "id";
+      let relatedRows = [];
+      if (relatedIds.length > 0) {
+        const relPlaceholders = relatedIds.map(() => "?").join(", ");
+        relatedRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${relatedPk} IN (${relPlaceholders})`, relatedIds);
+      }
+      const relatedByPk = new Map;
+      for (const r2 of relatedRows)
+        relatedByPk.set(r2[relatedPk], r2);
+      const pivotByParent = new Map;
+      for (const p2 of pivotRows) {
+        const key = p2[rel.pivotFkParent];
+        if (!pivotByParent.has(key))
+          pivotByParent.set(key, []);
+        pivotByParent.get(key).push(p2);
+      }
+      const pivotKnownKeys = new Set([rel.pivotFkParent, rel.pivotFkRelated]);
+      for (const instance of instances) {
+        const parentVal = instance.get(pk);
+        const myPivots = pivotByParent.get(parentVal) || [];
+        const relatedInstances = myPivots.map((p2) => {
+          const relRow = relatedByPk.get(p2[rel.pivotFkRelated]);
+          if (!relRow)
+            return null;
+          const inst = new ModelInstance(relDef, relRow);
+          const extras = {};
+          for (const [k2, v2] of Object.entries(p2)) {
+            if (!pivotKnownKeys.has(k2))
+              extras[k2] = v2;
+          }
+          inst.pivot = extras;
+          return inst;
+        }).filter((x2) => x2 !== null);
+        instance.setRelation(relationName, relatedInstances);
+      }
+    }
+    if (rel.type === "hasManyThrough" || rel.type === "hasOneThrough") {
+      const parentIds = distinctParentIds(instances, pk);
+      if (parentIds.length === 0)
+        return;
+      const throughPk = rel.throughLocalKey || "id";
+      const throughPh = parentIds.map(() => "?").join(", ");
+      const throughRows = await exec.all(`SELECT ${throughPk}, ${rel.throughForeignKey} FROM ${rel.throughTable} WHERE ${rel.throughForeignKey} IN (${throughPh})`, parentIds);
+      if (throughRows.length === 0) {
+        for (const instance of instances)
+          instance.setRelation(relationName, rel.type === "hasManyThrough" ? [] : null);
+        return;
+      }
+      const throughToParent = new Map;
+      for (const t2 of throughRows)
+        throughToParent.set(t2[throughPk], t2[rel.throughForeignKey]);
+      const throughIds = [...new Set(throughRows.map((t2) => t2[throughPk]))];
+      const targetPh = throughIds.map(() => "?").join(", ");
+      const targetRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.targetForeignKey} IN (${targetPh})`, throughIds);
+      const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
+      const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
+      const byParent = new Map;
+      for (const row of targetRows) {
+        const parentVal = throughToParent.get(row[rel.targetForeignKey]);
+        if (parentVal == null)
           continue;
-        }
-        const throughToParent = new Map;
-        for (const t2 of throughRows)
-          throughToParent.set(t2[throughPk], t2[rel.throughForeignKey]);
-        const throughIds = [...new Set(throughRows.map((t2) => t2[throughPk]))];
-        const targetPh = throughIds.map(() => "?").join(", ");
-        const targetRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.targetForeignKey} IN (${targetPh})`, throughIds);
-        const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
-        const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
-        const byParent = new Map;
-        for (const row of targetRows) {
-          const parentVal = throughToParent.get(row[rel.targetForeignKey]);
-          if (parentVal == null)
-            continue;
-          if (!byParent.has(parentVal))
-            byParent.set(parentVal, []);
-          byParent.get(parentVal).push(new ModelInstance(relDef, row));
-        }
-        for (const instance of instances) {
-          const group = byParent.get(instance.get(pk)) || [];
-          instance.setRelation(relationName, rel.type === "hasManyThrough" ? group : group[0] ?? null);
-        }
+        if (!byParent.has(parentVal))
+          byParent.set(parentVal, []);
+        byParent.get(parentVal).push(new ModelInstance(relDef, row));
+      }
+      for (const instance of instances) {
+        const group = byParent.get(instance.get(pk)) || [];
+        instance.setRelation(relationName, rel.type === "hasManyThrough" ? group : group[0] ?? null);
       }
     }
   }
@@ -25915,7 +26031,8 @@ class ModelQueryBuilder {
     assertValidIdentifier(column, "increment(column)");
     const exec = getExecutor();
     const params = [amount];
-    let sql2 = `UPDATE ${this._definition.table} SET ${column} = ${column} + ?`;
+    const incCol = sqlColumn(column);
+    let sql2 = `UPDATE ${this._definition.table} SET ${incCol} = ${incCol} + ?`;
     if (timestampsEnabled(this._definition)) {
       sql2 += `, updated_at = ?`;
       params.push(formatNow());
@@ -25973,26 +26090,27 @@ class ModelQueryBuilder {
     assertValidIdentifier(column, "pluck(column)");
     const exec = getExecutor();
     const params = [];
-    let sql2 = `SELECT ${column} FROM ${this._definition.table}`;
+    const pluckCol = sqlColumn(column);
+    let sql2 = `SELECT ${pluckCol} FROM ${this._definition.table}`;
     const whereBody = this.composeWhere(params);
     if (whereBody) {
       sql2 += ` WHERE ${whereBody}`;
     }
     if (this._orderBy.length > 0) {
-      sql2 += ` ORDER BY ${this._orderBy.map((o2) => `${o2.column} ${o2.direction.toUpperCase()}`).join(", ")}`;
+      sql2 += ` ORDER BY ${this._orderBy.map((o2) => `${sqlColumn(o2.column)} ${o2.direction.toUpperCase()}`).join(", ")}`;
     }
     if (this._limit !== undefined)
       sql2 += ` LIMIT ${this._limit}`;
     if (this._offset !== undefined)
       sql2 += ` OFFSET ${this._offset}`;
     const rows = await exec.all(sql2, params);
-    return rows.map((r2) => r2[column]);
+    return rows.map((r2) => r2[pluckCol]);
   }
   async aggregate(fn, column) {
     assertValidIdentifier(column, `${fn}(column)`);
     const exec = getExecutor();
     const params = [];
-    let sql2 = `SELECT ${fn}(${column}) as v FROM ${this._definition.table}`;
+    let sql2 = `SELECT ${fn}(${sqlColumn(column)}) as v FROM ${this._definition.table}`;
     const whereBody = this.composeWhere(params);
     if (whereBody) {
       sql2 += ` WHERE ${whereBody}`;
@@ -26031,7 +26149,7 @@ class ModelQueryBuilder {
   async update(data) {
     const exec = getExecutor();
     const entries = Object.entries(data);
-    const sets = entries.map(([k2]) => `${k2} = ?`).join(", ");
+    const sets = entries.map(([k2]) => `${sqlColumn(k2)} = ?`).join(", ");
     const params = entries.map(([, v2]) => v2);
     if (timestampsEnabled(this._definition)) {
       params.push(formatNow());
@@ -26193,12 +26311,19 @@ function createModel(definition) {
 }
 async function createTableFromModel(definition) {
   const exec = getExecutor();
-  const pk = definition.primaryKey || "id";
+  const pk = toSnakeCase(definition.primaryKey || "id");
   const columns = [];
+  const emitted = new Set([pk]);
   columns.push(definition.autoIncrement !== false ? `${pk} INTEGER PRIMARY KEY AUTOINCREMENT` : `${pk} INTEGER PRIMARY KEY`);
-  if (definition.traits?.useUuid)
+  if (definition.traits?.useUuid) {
     columns.push("uuid TEXT UNIQUE");
-  for (const [name, attr] of Object.entries(definition.attributes)) {
+    emitted.add("uuid");
+  }
+  for (const [attrName, attr] of Object.entries(definition.attributes)) {
+    const name = toSnakeCase(attrName);
+    if (emitted.has(name))
+      continue;
+    emitted.add(name);
     let colType = "TEXT";
     if (attr.type === "number")
       colType = "INTEGER";
@@ -26219,10 +26344,23 @@ async function createTableFromModel(definition) {
     }
     columns.push(colDef);
   }
+  for (const rel of normalizeRelationList(definition.belongsTo)) {
+    const name = rel.foreignKey ?? `${toSnakeCase(rel.model)}_id`;
+    if (emitted.has(name))
+      continue;
+    emitted.add(name);
+    columns.push(`${name} INTEGER`);
+  }
   if (timestampsEnabled(definition)) {
-    columns.push("created_at TEXT", "updated_at TEXT");
+    for (const c2 of ["created_at", "updated_at"]) {
+      if (emitted.has(c2))
+        continue;
+      emitted.add(c2);
+      columns.push(`${c2} TEXT`);
+    }
   }
-  if (softDeletesEnabled(definition)) {
+  if (softDeletesEnabled(definition) && !emitted.has("deleted_at")) {
+    emitted.add("deleted_at");
     columns.push("deleted_at TEXT");
   }
   await exec.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`, []);
@@ -26265,7 +26403,7 @@ async function seedModel(definition, count, faker) {
     const data = {};
     for (const [name, attr] of Object.entries(definition.attributes)) {
       if (attr.factory)
-        data[name] = attr.factory(faker);
+        data[toSnakeCase(name)] = attr.factory(faker);
     }
     if (timestampsEnabled(definition)) {
       const now = formatNow();
@@ -27766,23 +27904,6 @@ async function loadModels(options) {
 }
 var init_loader = () => {};
 
-// src/relation-utils.ts
-function normalizeRelationEntry(entry) {
-  if (typeof entry === "string")
-    return { model: entry };
-  if (entry && typeof entry === "object" && typeof entry.model === "string") {
-    const e2 = entry;
-    return { model: e2.model, foreignKey: e2.foreignKey, onDelete: e2.onDelete };
-  }
-  return null;
-}
-function normalizeRelationList(rel) {
-  if (!rel)
-    return [];
-  const entries = Array.isArray(rel) ? rel : typeof rel === "object" ? Object.values(rel) : [];
-  return entries.map(normalizeRelationEntry).filter((x2) => x2 !== null);
-}
-
 // src/meta.ts
 function buildSchemaMeta(models) {
   const modelToTable = {};
@@ -27877,6 +27998,9 @@ function info2(message) {
 function snakeCase(str) {
   return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/(\d)([A-Z])/gi, "$1_$2").toLowerCase();
 }
+function singularizeTable(table) {
+  return singularizerFor(config5.relations?.singularizeStrategy)(table);
+}
 function findWorkspaceRoot6(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname12(currentPath)) {
@@ -28265,7 +28389,7 @@ function buildMigrationPlan2(models, options) {
     const model = models[modelName];
     const traits = model?.traits ?? {};
     const modelTable = model.table || `${String(model.name).toLowerCase()}s`;
-    const singular = modelTable.replace(/s$/, "");
+    const singular = singularizeTable(modelTable);
     if (traits.likeable) {
       const opts = typeof traits.likeable === "object" ? traits.likeable : {};
       const likeTable = opts.table || `${modelTable}_likes`;
@@ -28332,7 +28456,7 @@ function buildMigrationPlan2(models, options) {
     if (!btm || typeof btm !== "object" || Array.isArray(btm))
       continue;
     const parentTable = model.table || `${String(model.name).toLowerCase()}s`;
-    const parentSingular = parentTable.replace(/s$/, "");
+    const parentSingular = singularizeTable(parentTable);
     for (const [relKey, value] of Object.entries(btm)) {
       const cfg = value;
       if (!cfg || typeof cfg !== "object")
@@ -28345,7 +28469,7 @@ function buildMigrationPlan2(models, options) {
       const relatedModelName = cfg.model;
       const relatedRaw = models[relatedModelName];
       const relatedTable = relatedRaw?.table || `${String(relatedModelName).toLowerCase()}s`;
-      const relatedSingular = relatedTable.replace(/s$/, "");
+      const relatedSingular = singularizeTable(relatedTable);
       const pivotTable = cfg.table || [parentSingular, relatedSingular].sort().join("_");
       const fkParent = cfg.foreignKey || `${parentSingular}_id`;
       const fkRelated = cfg.relatedKey || `${relatedSingular}_id`;
@@ -28979,6 +29103,7 @@ var init_src2 = __esm(() => {
   init_loader();
   init_meta();
   init_migrations();
+  init_pivot();
   init_orm();
   init_sqlite_pragmas();
 });
@@ -31022,7 +31147,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.58";
+var version2 = "0.1.60";
 
 // bin/cli.ts
 init_actions();