@type32/tauri-sqlite-orm 0.2.15 → 0.4.0

package/dist/index.mjs

@@ -75,7 +75,10 @@ var TauriDialect = class {
 };
 
 // src/builders/select.ts
-import { sql } from "kysely";
+import { sql as sql2 } from "kysely";
+
+// src/operators.ts
+import { isExpression, sql } from "kysely";
 
 // src/serialization.ts
 function serializeValue(value, column) {
@@ -178,6 +181,83 @@ function deserializeValue(value, column) {
   return value;
 }
 
+// src/operators.ts
+var eq = (column, value, tableAlias) => {
+  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  const serialized = serializeValue(value, column);
+  return sql`${sql.ref(colRef)} = ${sql.val(serialized)}`;
+};
+var ne = (column, value, tableAlias) => {
+  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+  const serialized = serializeValue(value, column);
+  return sql`${sql.ref(colRef)} != ${sql.val(serialized)}`;
+};
+var and = (...conditions) => {
+  if (conditions.length === 0) return sql`1 = 1`;
+  if (conditions.length === 1) return conditions[0];
+  return sql`(${sql.join(conditions.map((c) => sql`(${c})`), sql` AND `)})`;
+};
+var or = (...conditions) => {
+  if (conditions.length === 0) return sql`1 = 1`;
+  if (conditions.length === 1) return conditions[0];
+  return sql`(${sql.join(conditions.map((c) => sql`(${c})`), sql` OR `)})`;
+};
+var not = (condition) => sql`NOT (${condition})`;
+var gt = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql`${sql.ref(column._.name)} > ${sql.val(serialized)}`;
+};
+var gte = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql`${sql.ref(column._.name)} >= ${sql.val(serialized)}`;
+};
+var lt = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql`${sql.ref(column._.name)} < ${sql.val(serialized)}`;
+};
+var lte = (column, value) => {
+  const serialized = serializeValue(value, column);
+  return sql`${sql.ref(column._.name)} <= ${sql.val(serialized)}`;
+};
+var like = (column, pattern) => sql`${sql.ref(column._.name)} LIKE ${sql.val(pattern)}`;
+var ilike = (column, pattern) => sql`${sql.ref(column._.name)} LIKE ${sql.val(pattern)} COLLATE NOCASE`;
+var startsWith = (column, value) => sql`${sql.ref(column._.name)} LIKE ${sql.val(`${value}%`)}`;
+var endsWith = (column, value) => sql`${sql.ref(column._.name)} LIKE ${sql.val(`%${value}`)}`;
+var contains = (column, value) => sql`${sql.ref(column._.name)} LIKE ${sql.val(`%${value}%`)}`;
+var isNull = (column) => sql`${sql.ref(column._.name)} IS NULL`;
+var isNotNull = (column) => sql`${sql.ref(column._.name)} IS NOT NULL`;
+var exists = (subquery2) => sql`EXISTS ${subquery2}`;
+var notExists = (subquery2) => sql`NOT EXISTS ${subquery2}`;
+var eqSubquery = (column, subquery2) => sql`${sql.ref(column._.name)} = (${subquery2})`;
+var neSubquery = (column, subquery2) => sql`${sql.ref(column._.name)} != (${subquery2})`;
+var gtSubquery = (column, subquery2) => sql`${sql.ref(column._.name)} > (${subquery2})`;
+var gteSubquery = (column, subquery2) => sql`${sql.ref(column._.name)} >= (${subquery2})`;
+var ltSubquery = (column, subquery2) => sql`${sql.ref(column._.name)} < (${subquery2})`;
+var lteSubquery = (column, subquery2) => sql`${sql.ref(column._.name)} <= (${subquery2})`;
+var inArray = (column, values) => {
+  if (isExpression(values)) {
+    return sql`${sql.ref(column._.name)} IN (${values})`;
+  }
+  const arr = values;
+  if (arr.length === 0) return sql`1 = 0`;
+  const serialized = arr.map((v) => sql.val(serializeValue(v, column)));
+  return sql`${sql.ref(column._.name)} IN (${sql.join(serialized)})`;
+};
+var notIn = (column, values) => {
+  if (isExpression(values)) {
+    return sql`${sql.ref(column._.name)} NOT IN (${values})`;
+  }
+  const arr = values;
+  if (arr.length === 0) return sql`1 = 1`;
+  const serialized = arr.map((v) => sql.val(serializeValue(v, column)));
+  return sql`${sql.ref(column._.name)} NOT IN (${sql.join(serialized)})`;
+};
+var between = (column, min2, max2) => {
+  const serializedMin = serializeValue(min2, column);
+  const serializedMax = serializeValue(max2, column);
+  return sql`${sql.ref(column._.name)} BETWEEN ${sql.val(serializedMin)} AND ${sql.val(serializedMax)}`;
+};
+
 // src/builders/select.ts
 function getDbNameToTsName(table) {
   const map = {};
@@ -239,7 +319,7 @@ var SelectQueryBuilder = class {
       this._builder = this._builder.orderBy(column, direction);
     } else {
       this._builder = this._builder.orderBy(
-        sql.ref(column._.name),
+        sql2.ref(column._.name),
         direction
       );
     }
@@ -256,7 +336,7 @@ var SelectQueryBuilder = class {
   groupBy(...columns) {
     for (const col of columns) {
       this._builder = this._builder.groupBy(
-        sql`${sql.ref(this._table._.name)}.${sql.ref(col._.name)}`
+        sql2`${sql2.ref(this._table._.name)}.${sql2.ref(col._.name)}`
       );
     }
     return this;
@@ -307,32 +387,62 @@ var SelectQueryBuilder = class {
           (col) => `${foreignAlias}.${col._.name} as "${foreignAlias}.${col._.name}"`
         );
         if (relation.type === "one" && relation.fields && relation.references) {
-          const onCondition = sql`${sql.join(
+          const onCondition = sql2`${sql2.join(
             relation.fields.map(
-              (field, i) => sql`${sql.ref(`${parentAlias}.${field._.name}`)} = ${sql.ref(`${foreignAlias}.${relation.references[i]._.name}`)}`
+              (field, i) => sql2`${sql2.ref(`${parentAlias}.${field._.name}`)} = ${sql2.ref(`${foreignAlias}.${relation.references[i]._.name}`)}`
             ),
-            sql` AND `
+            sql2` AND `
           )}`;
           this._builder = this._builder.leftJoin(
             `${foreignTable._.name} as ${foreignAlias}`,
             (join) => join.on(onCondition)
           ).select(aliasedCols);
         } else if (relation.type === "many") {
-          const refRelation = Object.entries(foreignTable.relations).find(
-            ([, r]) => r.foreignTable === parentTable
-          );
-          if (refRelation && refRelation[1].fields && refRelation[1].references) {
-            const [, relationConfig] = refRelation;
-            const onCondition = sql`${sql.join(
-              relationConfig.fields.map(
-                (field, i) => sql`${sql.ref(`${foreignAlias}.${field._.name}`)} = ${sql.ref(`${parentAlias}.${relationConfig.references[i]._.name}`)}`
-              ),
-              sql` AND `
-            )}`;
+          if (relation.junctionTable && relation.fromJunction && relation.toJunction) {
+            const junctionTable = relation.junctionTable;
+            const junctionAlias = `${foreignAlias}_jn`;
+            const fromJ = relation.fromJunction;
+            const toJ = relation.toJunction;
+            const join1 = sql2`${sql2.ref(`${parentAlias}.${fromJ.column._.name}`)} = ${sql2.ref(`${junctionAlias}.${fromJ.junctionColumn._.name}`)}`;
+            let join2 = sql2`${sql2.ref(`${junctionAlias}.${toJ.junctionColumn._.name}`)} = ${sql2.ref(`${foreignAlias}.${toJ.column._.name}`)}`;
+            if (relation.where) {
+              join2 = and(join2, relation.where(foreignAlias));
+            }
             this._builder = this._builder.leftJoin(
+              `${junctionTable._.name} as ${junctionAlias}`,
+              (join) => join.on(join1)
+            ).leftJoin(
               `${foreignTable._.name} as ${foreignAlias}`,
-              (join) => join.on(onCondition)
+              (join) => join.on(join2)
             ).select(aliasedCols);
+          } else {
+            let fields = relation.fields;
+            let references = relation.references;
+            if (!fields || !references) {
+              const refRelation = Object.entries(foreignTable.relations).find(
+                ([, r]) => r.foreignTable === parentTable
+              );
+              if (refRelation && refRelation[1].fields && refRelation[1].references) {
+                const [, relationConfig] = refRelation;
+                fields = relationConfig.fields;
+                references = relationConfig.references;
+              }
+            }
+            if (fields && references) {
+              let onCondition = sql2`${sql2.join(
+                fields.map(
+                  (field, i) => sql2`${sql2.ref(`${foreignAlias}.${field._.name}`)} = ${sql2.ref(`${parentAlias}.${references[i]._.name}`)}`
+                ),
+                sql2` AND `
+              )}`;
+              if (relation.where) {
+                onCondition = and(onCondition, relation.where(foreignAlias));
+              }
+              this._builder = this._builder.leftJoin(
+                `${foreignTable._.name} as ${foreignAlias}`,
+                (join) => join.on(onCondition)
+              ).select(aliasedCols);
+            }
           }
         }
         if (typeof include === "object" && include.with) {
@@ -428,6 +538,7 @@ var SelectQueryBuilder = class {
           const column = this._table._.columns[tsName];
           result[tsName] = column ? deserializeValue(value, column) : value;
         } else {
+          if (tableAlias.endsWith("_jn")) continue;
           const path = parseRelationPath(tableAlias, this._table._.name);
           if (path.length > 0) {
             const relationConfig = getNestedRelation(this._table, path);
@@ -506,12 +617,12 @@ var SelectQueryBuilder = class {
   }
   async exists() {
     this.applyIncludes();
-    const compiledResult = await this._builder.clearSelect().select(sql.raw("1").as("__exists__")).limit(1).execute();
+    const compiledResult = await this._builder.clearSelect().select(sql2.raw("1").as("__exists__")).limit(1).execute();
     return compiledResult.length > 0;
   }
   async count() {
     this.applyIncludes();
-    const result = await this._builder.clearSelect().select(sql`COUNT(*)`.as("count")).execute();
+    const result = await this._builder.clearSelect().select(sql2`COUNT(*)`.as("count")).execute();
     const row = result[0];
     const val = row ? row['"count"'] ?? row.count : void 0;
     return Number(val ?? 0);
@@ -521,7 +632,7 @@ var SelectQueryBuilder = class {
     const col = this._table._.columns[column];
     const alias2 = col._.name;
     const results = await this._builder.clearSelect().select(
-      sql.raw(`${this._table._.name}.${alias2}`).as(alias2)
+      sql2.raw(`${this._table._.name}.${alias2}`).as(alias2)
     ).execute();
     return results.map((row) => {
       const val = row['"' + alias2 + '"'] ?? row[alias2];
@@ -557,7 +668,7 @@ var SelectQueryBuilder = class {
 };
 
 // src/builders/update.ts
-import { sql as sql2 } from "kysely";
+import { sql as sql3 } from "kysely";
 
 // src/errors.ts
 var TauriORMError = class extends Error {
@@ -710,7 +821,7 @@ var UpdateQueryBuilder = class {
     }
     for (const op of this._incrementDecrementOps) {
       const sign = op.op === "increment" ? "+" : "-";
-      setMap[op.column] = sql2.raw(`${op.column} ${sign} ${op.value}`);
+      setMap[op.column] = sql3.raw(`${op.column} ${sign} ${op.value}`);
     }
     return setMap;
   }
@@ -1482,8 +1593,9 @@ var OneRelation = class extends Relation {
   }
 };
 var ManyRelation = class extends Relation {
-  constructor(foreignTable) {
+  constructor(foreignTable, config) {
     super(foreignTable);
+    this.config = config;
   }
 };
 var relations = (table, relationsCallback) => {
@@ -1501,7 +1613,9 @@ var relations = (table, relationsCallback) => {
         type: "one",
         foreignTable: relation.foreignTable,
         fields: relation.config?.fields,
-        references: relation.config?.references
+        references: relation.config?.references,
+        optional: relation.config?.optional,
+        alias: relation.config?.alias
       };
     } else if (relation instanceof ManyRelation) {
       table.relations[name] = {
@@ -1519,84 +1633,6 @@ var alias = (table, alias2) => {
   return table;
 };
 
-// src/operators.ts
-import { isExpression, sql as sql3 } from "kysely";
-var eq = (column, value, tableAlias) => {
-  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
-  const serialized = serializeValue(value, column);
-  return sql3`${sql3.ref(colRef)} = ${sql3.val(serialized)}`;
-};
-var ne = (column, value, tableAlias) => {
-  const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
-  const serialized = serializeValue(value, column);
-  return sql3`${sql3.ref(colRef)} != ${sql3.val(serialized)}`;
-};
-var and = (...conditions) => {
-  if (conditions.length === 0) return sql3`1 = 1`;
-  if (conditions.length === 1) return conditions[0];
-  return sql3`(${sql3.join(conditions.map((c) => sql3`(${c})`), sql3` AND `)})`;
-};
-var or = (...conditions) => {
-  if (conditions.length === 0) return sql3`1 = 1`;
-  if (conditions.length === 1) return conditions[0];
-  return sql3`(${sql3.join(conditions.map((c) => sql3`(${c})`), sql3` OR `)})`;
-};
-var not = (condition) => sql3`NOT (${condition})`;
-var gt = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return sql3`${sql3.ref(column._.name)} > ${sql3.val(serialized)}`;
-};
-var gte = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return sql3`${sql3.ref(column._.name)} >= ${sql3.val(serialized)}`;
-};
-var lt = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return sql3`${sql3.ref(column._.name)} < ${sql3.val(serialized)}`;
-};
-var lte = (column, value) => {
-  const serialized = serializeValue(value, column);
-  return sql3`${sql3.ref(column._.name)} <= ${sql3.val(serialized)}`;
-};
-var like = (column, pattern) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(pattern)}`;
-var ilike = (column, pattern) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(pattern)} COLLATE NOCASE`;
-var startsWith = (column, value) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(`${value}%`)}`;
-var endsWith = (column, value) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(`%${value}`)}`;
-var contains = (column, value) => sql3`${sql3.ref(column._.name)} LIKE ${sql3.val(`%${value}%`)}`;
-var isNull = (column) => sql3`${sql3.ref(column._.name)} IS NULL`;
-var isNotNull = (column) => sql3`${sql3.ref(column._.name)} IS NOT NULL`;
-var exists = (subquery2) => sql3`EXISTS ${subquery2}`;
-var notExists = (subquery2) => sql3`NOT EXISTS ${subquery2}`;
-var eqSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} = (${subquery2})`;
-var neSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} != (${subquery2})`;
-var gtSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} > (${subquery2})`;
-var gteSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} >= (${subquery2})`;
-var ltSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} < (${subquery2})`;
-var lteSubquery = (column, subquery2) => sql3`${sql3.ref(column._.name)} <= (${subquery2})`;
-var inArray = (column, values) => {
-  if (isExpression(values)) {
-    return sql3`${sql3.ref(column._.name)} IN (${values})`;
-  }
-  const arr = values;
-  if (arr.length === 0) return sql3`1 = 0`;
-  const serialized = arr.map((v) => sql3.val(serializeValue(v, column)));
-  return sql3`${sql3.ref(column._.name)} IN (${sql3.join(serialized)})`;
-};
-var notIn = (column, values) => {
-  if (isExpression(values)) {
-    return sql3`${sql3.ref(column._.name)} NOT IN (${values})`;
-  }
-  const arr = values;
-  if (arr.length === 0) return sql3`1 = 1`;
-  const serialized = arr.map((v) => sql3.val(serializeValue(v, column)));
-  return sql3`${sql3.ref(column._.name)} NOT IN (${sql3.join(serialized)})`;
-};
-var between = (column, min2, max2) => {
-  const serializedMin = serializeValue(min2, column);
-  const serializedMax = serializeValue(max2, column);
-  return sql3`${sql3.ref(column._.name)} BETWEEN ${sql3.val(serializedMin)} AND ${sql3.val(serializedMax)}`;
-};
-
 // src/aggregates.ts
 import { sql as sql4 } from "kysely";
 var count = (column) => sql4`COUNT(${column ? sql4.ref(column._.name) : sql4.raw("*")})`;
@@ -1633,6 +1669,126 @@ function numeric(name, config) {
 }
 var enumType = (name, values) => text(name, { enum: values });
 
+// src/relations-v2.ts
+function extractTables(schema) {
+  const tables = {};
+  for (const [key, value] of Object.entries(schema)) {
+    const v = value;
+    if (v && typeof v === "object" && v._?.name && v._?.columns && typeof v.relations === "object") {
+      tables[key] = v;
+    }
+  }
+  return tables;
+}
+function through(column, junctionColumn, junctionTable) {
+  return { column, junctionColumn, junctionTable };
+}
+function toArray(col) {
+  return Array.isArray(col) ? col : [col];
+}
+function isThroughRef(v) {
+  return v && typeof v === "object" && "column" in v && "junctionColumn" in v && "junctionTable" in v;
+}
+function buildTableRef(table) {
+  return { ...table._.columns };
+}
+function buildR(tables) {
+  const tableRefs = {};
+  const oneFns = {};
+  const manyFns = {};
+  for (const [tableKey, table] of Object.entries(tables)) {
+    tableRefs[tableKey] = buildTableRef(table);
+    const foreignTable = table;
+    oneFns[tableKey] = (opts) => {
+      return new OneRelation(foreignTable, {
+        fields: toArray(opts.from),
+        references: toArray(opts.to),
+        optional: opts.optional,
+        alias: opts.alias
+      });
+    };
+    manyFns[tableKey] = (opts) => {
+      if (!opts?.from || !opts?.to) return new ManyRelation(foreignTable);
+      if (isThroughRef(opts.from) && isThroughRef(opts.to)) {
+        return new ManyRelation(foreignTable, {
+          through: {
+            junctionTable: opts.from.junctionTable,
+            fromRef: { column: opts.from.column, junctionColumn: opts.from.junctionColumn },
+            toRef: { column: opts.to.column, junctionColumn: opts.to.junctionColumn }
+          },
+          optional: opts.optional,
+          alias: opts.alias,
+          where: opts.where
+        });
+      }
+      return new ManyRelation(foreignTable, {
+        from: toArray(opts.from),
+        to: toArray(opts.to),
+        optional: opts.optional,
+        alias: opts.alias,
+        where: opts.where
+      });
+    };
+  }
+  return {
+    ...tableRefs,
+    one: oneFns,
+    many: manyFns
+  };
+}
+function applyRelationsToTables(tables, relationsResult) {
+  for (const [tableKey, rels] of Object.entries(relationsResult)) {
+    const table = tables[tableKey];
+    if (!table) continue;
+    for (const [relName, relation] of Object.entries(rels)) {
+      if (relation instanceof OneRelation) {
+        table.relations[relName] = {
+          type: "one",
+          foreignTable: relation.foreignTable,
+          fields: relation.config?.fields,
+          references: relation.config?.references,
+          optional: relation.config?.optional,
+          alias: relation.config?.alias
+        };
+      } else if (relation instanceof ManyRelation) {
+        const config = relation.config;
+        if (config?.through) {
+          table.relations[relName] = {
+            type: "many",
+            foreignTable: relation.foreignTable,
+            junctionTable: config.through.junctionTable,
+            fromJunction: config.through.fromRef,
+            toJunction: config.through.toRef,
+            optional: config.optional,
+            alias: config.alias,
+            where: config.where
+          };
+        } else {
+          table.relations[relName] = {
+            type: "many",
+            foreignTable: relation.foreignTable,
+            fields: config ? config.to : void 0,
+            references: config ? config.from : void 0,
+            optional: config?.optional,
+            alias: config?.alias,
+            where: config?.where
+          };
+        }
+      }
+    }
+  }
+}
+function defineRelations(schema, callback) {
+  const tables = extractTables(schema);
+  const r = buildR(tables);
+  const result = callback(r);
+  applyRelationsToTables(tables, result);
+  return result;
+}
+function defineRelationsPart(schema, callback) {
+  return defineRelations(schema, callback);
+}
+
 // src/index.ts
 import { sql as sql5 } from "kysely";
 export {
@@ -1669,6 +1825,8 @@ export {
   contains,
   count,
   countDistinct,
+  defineRelations,
+  defineRelationsPart,
   desc,
   endsWith,
   enumType,
@@ -1708,5 +1866,6 @@ export {
   startsWith,
   subquery,
   sum,
-  text
+  text,
+  through
 };

package/dist/operators.d.ts

@@ -0,0 +1,30 @@
+import { Expression, SqlBool } from 'kysely';
+import { AnySQLiteColumn } from './types';
+export type Condition = Expression<SqlBool>;
+export declare const eq: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => Condition;
+export declare const ne: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => Condition;
+export declare const and: (...conditions: Condition[]) => Condition;
+export declare const or: (...conditions: Condition[]) => Condition;
+export declare const not: (condition: Condition) => Condition;
+export declare const gt: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const gte: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const lt: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const lte: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const like: (column: AnySQLiteColumn, pattern: string) => Condition;
+export declare const ilike: (column: AnySQLiteColumn, pattern: string) => Condition;
+export declare const startsWith: (column: AnySQLiteColumn, value: string) => Condition;
+export declare const endsWith: (column: AnySQLiteColumn, value: string) => Condition;
+export declare const contains: (column: AnySQLiteColumn, value: string) => Condition;
+export declare const isNull: (column: AnySQLiteColumn) => Condition;
+export declare const isNotNull: (column: AnySQLiteColumn) => Condition;
+export declare const exists: (subquery: Expression<any>) => Condition;
+export declare const notExists: (subquery: Expression<any>) => Condition;
+export declare const eqSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const neSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const gtSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const gteSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const ltSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const lteSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const inArray: <T>(column: AnySQLiteColumn, values: T[] | Expression<any>) => Condition;
+export declare const notIn: <T>(column: AnySQLiteColumn, values: T[] | Expression<any>) => Condition;
+export declare const between: <T>(column: AnySQLiteColumn, min: T, max: T) => Condition;

package/dist/operators.js

@@ -0,0 +1,84 @@
+import { isExpression, sql } from 'kysely';
+import { serializeValue } from './serialization';
+export const eq = (column, value, tableAlias) => {
+    const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(colRef)} = ${sql.val(serialized)}`;
+};
+export const ne = (column, value, tableAlias) => {
+    const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(colRef)} != ${sql.val(serialized)}`;
+};
+export const and = (...conditions) => {
+    if (conditions.length === 0)
+        return sql `1 = 1`;
+    if (conditions.length === 1)
+        return conditions[0];
+    return sql `(${sql.join(conditions.map(c => sql `(${c})`), sql ` AND `)})`;
+};
+export const or = (...conditions) => {
+    if (conditions.length === 0)
+        return sql `1 = 1`;
+    if (conditions.length === 1)
+        return conditions[0];
+    return sql `(${sql.join(conditions.map(c => sql `(${c})`), sql ` OR `)})`;
+};
+export const not = (condition) => sql `NOT (${condition})`;
+export const gt = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} > ${sql.val(serialized)}`;
+};
+export const gte = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} >= ${sql.val(serialized)}`;
+};
+export const lt = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} < ${sql.val(serialized)}`;
+};
+export const lte = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} <= ${sql.val(serialized)}`;
+};
+export const like = (column, pattern) => sql `${sql.ref(column._.name)} LIKE ${sql.val(pattern)}`;
+export const ilike = (column, pattern) => sql `${sql.ref(column._.name)} LIKE ${sql.val(pattern)} COLLATE NOCASE`;
+export const startsWith = (column, value) => sql `${sql.ref(column._.name)} LIKE ${sql.val(`${value}%`)}`;
+export const endsWith = (column, value) => sql `${sql.ref(column._.name)} LIKE ${sql.val(`%${value}`)}`;
+export const contains = (column, value) => sql `${sql.ref(column._.name)} LIKE ${sql.val(`%${value}%`)}`;
+export const isNull = (column) => sql `${sql.ref(column._.name)} IS NULL`;
+export const isNotNull = (column) => sql `${sql.ref(column._.name)} IS NOT NULL`;
+// SQLite rejects EXISTS ((subquery)); use single paren level
+export const exists = (subquery) => sql `EXISTS ${subquery}`;
+export const notExists = (subquery) => sql `NOT EXISTS ${subquery}`;
+export const eqSubquery = (column, subquery) => sql `${sql.ref(column._.name)} = (${subquery})`;
+export const neSubquery = (column, subquery) => sql `${sql.ref(column._.name)} != (${subquery})`;
+export const gtSubquery = (column, subquery) => sql `${sql.ref(column._.name)} > (${subquery})`;
+export const gteSubquery = (column, subquery) => sql `${sql.ref(column._.name)} >= (${subquery})`;
+export const ltSubquery = (column, subquery) => sql `${sql.ref(column._.name)} < (${subquery})`;
+export const lteSubquery = (column, subquery) => sql `${sql.ref(column._.name)} <= (${subquery})`;
+export const inArray = (column, values) => {
+    if (isExpression(values)) {
+        return sql `${sql.ref(column._.name)} IN (${values})`;
+    }
+    const arr = values;
+    if (arr.length === 0)
+        return sql `1 = 0`;
+    const serialized = arr.map(v => sql.val(serializeValue(v, column)));
+    return sql `${sql.ref(column._.name)} IN (${sql.join(serialized)})`;
+};
+export const notIn = (column, values) => {
+    if (isExpression(values)) {
+        return sql `${sql.ref(column._.name)} NOT IN (${values})`;
+    }
+    const arr = values;
+    if (arr.length === 0)
+        return sql `1 = 1`;
+    const serialized = arr.map(v => sql.val(serializeValue(v, column)));
+    return sql `${sql.ref(column._.name)} NOT IN (${sql.join(serialized)})`;
+};
+export const between = (column, min, max) => {
+    const serializedMin = serializeValue(min, column);
+    const serializedMax = serializeValue(max, column);
+    return sql `${sql.ref(column._.name)} BETWEEN ${sql.val(serializedMin)} AND ${sql.val(serializedMax)}`;
+};