@ignisia/sql 0.4.0 → 0.4.2

package/dist/esm/query/sql.js

@@ -1,8 +1,9 @@
 import { Dialect } from '../table/constants.js';
 import { buildDeleteQuery, buildUpdateQuery, buildInsertQuery, buildSelectQuery } from './builder.js';
+import { compileJoin, compileAst } from './compiler.js';
 import { QueryType, QueryHooksType } from './constants.js';
 import { buildExplainQuery } from './explain.js';
-import { getWhereConditions, getGroupByConditions, sanitizeParams, parseAliasedRow } from './utilities.js';
+import { getGroupByConditions, sanitizeParams, parseAliasedRow } from './utilities.js';
 
 // src/query/sql.ts
 function buildQuery(query) {
@@ -12,17 +13,18 @@ function buildQuery(query) {
     return `$${index}`;
   });
 }
-function toQuery(dialect) {
+function toQuery(dialect = this.table.dialect) {
+  const params = [];
   const parts = [];
   switch (this.definition.queryType) {
     case QueryType.SELECT:
       parts.push(buildSelectQuery(this));
       break;
     case QueryType.INSERT:
-      parts.push(buildInsertQuery(this));
+      parts.push(buildInsertQuery(this, params));
       break;
     case QueryType.UPDATE:
-      parts.push(buildUpdateQuery(this));
+      parts.push(buildUpdateQuery(this, params));
       break;
     case QueryType.DELETE:
       parts.push(buildDeleteQuery(this));
@@ -31,33 +33,39 @@ function toQuery(dialect) {
       throw new Error("No query type defined");
   }
   if (this.definition?.joins?.length) {
-    parts.push(this.definition.joins.join(" "));
+    const joinParts = this.definition.joins.map(
+      (join) => compileJoin(dialect, join, params)
+    );
+    parts.push(...joinParts);
   }
-  const whereConditions = getWhereConditions(this);
-  if (whereConditions.length) {
-    parts.push(`WHERE ${whereConditions.join(" ")}`);
+  if (this.definition.where) {
+    const whereConditions = compileAst(dialect, this.definition.where, params);
+    parts.push(`WHERE ${whereConditions}`);
   }
   const groupByConditions = getGroupByConditions(this);
   if (groupByConditions.length) {
     parts.push(`GROUP BY ${groupByConditions.join(", ")}`);
   }
-  if (this.definition?.having?.length) {
-    parts.push(`HAVING ${this.definition.having.join(" ")}`);
+  if (this.definition?.having) {
+    const havingConditions = compileAst(
+      dialect,
+      this.definition.having,
+      params
+    );
+    parts.push(`HAVING ${havingConditions}`);
   }
   if (this.definition?.orderBy?.length) {
     parts.push(
       `ORDER BY ${this.definition.orderBy.map((order) => `${order.column} ${order.direction}`).join(", ")}`
     );
   }
-  if (this.definition?.limit !== null) {
+  if (this.definition?.limit != null) {
     parts.push("LIMIT ?");
-    if (!this.definition.params) this.definition.params = [];
-    this.definition.params.push(this.definition.limit);
+    params.push(this.definition.limit);
   }
-  if (this.definition?.offset !== null) {
+  if (this.definition?.offset != null) {
     parts.push("OFFSET ?");
-    if (!this.definition.params) this.definition.params = [];
-    this.definition.params.push(this.definition.offset);
+    params.push(this.definition.offset);
   }
   if (this.definition.queryType === QueryType.UPDATE || this.definition.queryType === QueryType.DELETE) {
     if (dialect !== Dialect.MYSQL) {
@@ -65,7 +73,7 @@ function toQuery(dialect) {
     }
   }
   const sql = buildQuery(parts.join(" "));
-  return { query: `${sql};`, params: this.definition.params };
+  return { query: `${sql};`, params };
 }
 function toString() {
   return this.toQuery().query;
@@ -121,15 +129,24 @@ async function exec(tx) {
       });
     }
   }
-  let result = await client.exec({
+  let result = [];
+  let mySqlResult = [];
+  if (isMySQL && isDelete) {
+    const query2 = this.clone().select(`${this.table.name}.*`);
+    mySqlResult = await client.exec({
+      sql: query2.toQuery().query,
+      params,
+      tx
+    });
+  }
+  result = await client.exec({
     sql: query,
     params,
     tx
   });
-  if (isMySQL && isReturning) {
-    const query2 = this.clone();
-    query2.definition.queryType = QueryType.SELECT;
-    result = await client.exec({
+  if (isMySQL && isUpdate) {
+    const query2 = this.clone().select(`${this.table.name}.*`);
+    mySqlResult = await client.exec({
       sql: query2.toQuery().query,
       params,
       tx
@@ -145,7 +162,7 @@ async function exec(tx) {
       });
     }
   }
-  return result.map(
+  return (isMySQL && isReturning ? mySqlResult : result).map(
     (r) => parseAliasedRow({
       row: r,
       selects: this.definition.select ?? [],

package/dist/esm/query/types.d.ts

@@ -1,7 +1,7 @@
 import 'bun';
 import '../column/index.js';
 import '../column/constants.js';
-export { u as AcceptedInsertValues, t as AcceptedOrderBy, v as AcceptedUpdateValues, w as AggregateColumn, A as AliasedColumn, C as ColumnSelector, E as ExplainOptions, Q as QueryDefinition, p as QueryHooks, y as QueryOutput, s as QueryRunHooks, z as QueryRunHooksOptions, R as RawColumn, x as SelectQueryOutput, m as SelectableColumn, k as StrictColumnSelector, W as WhereValue } from '../index-CjurLJdK.js';
+export { r as AcceptedInsertValues, q as AcceptedOrderBy, s as AcceptedUpdateValues, t as AggregateColumn, A as AliasedColumn, C as ColumnSelector, E as ExplainOptions, Q as QueryDefinition, n as QueryHooks, v as QueryOutput, p as QueryRunHooks, w as QueryRunHooksOptions, R as RawColumn, u as SelectQueryOutput, d as SelectableColumn, S as StrictColumnSelector, W as WhereValue } from '../index-CsVPGz2o.js';
 import '../types.js';
 import './constants.js';
 import '../table/constants.js';

package/dist/esm/query/utilities.d.ts

@@ -1,17 +1,16 @@
-import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, A as AliasedColumn, m as SelectableColumn } from '../index-CjurLJdK.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, c as QueryBuilder, A as AliasedColumn, d as SelectableColumn } from '../index-CsVPGz2o.js';
 import { Column } from '../column/index.js';
-import { Dialect } from '../table/constants.js';
-import { AcceptedOperator } from './constants.js';
 import 'bun';
 import '../types.js';
+import './constants.js';
 import '../column/constants.js';
+import '../table/constants.js';
 import '../column/types.js';
 
 declare function getTableColumnNames<ColName extends string, BaseAlias extends string, BaseTable extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>>(column: ColName, baseAlias: BaseAlias, baseTable: BaseTable, joinedTables: JoinedTables): {
     from: string;
     columns: string[];
 };
-declare function getCondition<DbDialect extends Dialect, ColName extends string, Operator extends AcceptedOperator, Value extends WhereValue<Column>[Operator]>(dialect: DbDialect, column: ColName, operator: Operator, value: Value): string;
 declare function getTimestamp<TableRef extends Table<string, Record<string, Column>>>(table: TableRef): {
     isWithTimestamp: boolean;
     timestamp: Date;
@@ -25,7 +24,6 @@ declare function getParanoid<TableRef extends Table<string, Record<string, Colum
     timestamp: Date;
     deletedAt: string;
 };
-declare function getWhereConditions<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(q: Query): string[];
 declare function getGroupByConditions<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(q: Query): (string | AliasedColumn<ColumnSelector<Alias, TableRef, JoinedTables>, string>)[];
 declare function getTableSelectName<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(q: Query): string;
 declare function parseAliasedRow({ row, selects, root, }: {
@@ -35,4 +33,4 @@ declare function parseAliasedRow({ row, selects, root, }: {
 }): Record<string, any>;
 declare function sanitizeParams(params: unknown[]): (string | number | bigint | boolean | null)[];
 
-export { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow, sanitizeParams };
+export { getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, parseAliasedRow, sanitizeParams };

package/dist/esm/query/utilities.js

@@ -1,7 +1,6 @@
 import './index.js';
-import { Dialect } from '../table/constants.js';
 import { quoteIdentifier } from '../utilities.js';
-import { AcceptedOperator, QueryType } from './constants.js';
+import { QueryType } from './constants.js';
 
 // src/query/utilities.ts
 function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
@@ -14,102 +13,6 @@ function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
     columns
   };
 }
-function getCondition(dialect, column, operator, value) {
-  switch (operator) {
-    case AcceptedOperator.EQ:
-      return `${column} = ?`;
-    case AcceptedOperator.NE:
-      return `${column} != ?`;
-    case AcceptedOperator.GT:
-      return `${column} > ?`;
-    case AcceptedOperator.LT:
-      return `${column} < ?`;
-    case AcceptedOperator.GTE:
-      return `${column} >= ?`;
-    case AcceptedOperator.LTE:
-      return `${column} <= ?`;
-    case AcceptedOperator.IN:
-      return `${column} IN (${value.map(() => "?").join(", ")})`;
-    case AcceptedOperator.NOT_IN:
-      return `${column} NOT IN (${value.map(() => "?").join(", ")})`;
-    case AcceptedOperator.LIKE:
-      return `${column} LIKE ?`;
-    case AcceptedOperator.NOT_LIKE:
-      return `${column} NOT LIKE ?`;
-    case AcceptedOperator.ILIKE:
-      if (dialect === Dialect.POSTGRES) {
-        return `${column} ILIKE ?`;
-      }
-      return `LOWER(${column}) LIKE LOWER(?)`;
-    case AcceptedOperator.NOT_ILIKE:
-      if (dialect === Dialect.POSTGRES) {
-        return `${column} NOT ILIKE ?`;
-      }
-      return `LOWER(${column}) NOT LIKE LOWER(?)`;
-    case AcceptedOperator.IS_NULL:
-      return `${column} IS NULL`;
-    case AcceptedOperator.IS_NOT_NULL:
-      return `${column} IS NOT NULL`;
-    case AcceptedOperator.BETWEEN:
-      return `${column} BETWEEN ? AND ?`;
-    case AcceptedOperator.NOT_BETWEEN:
-      return `${column} NOT BETWEEN ? AND ?`;
-    case AcceptedOperator.STARTS_WITH:
-      return `${column} LIKE ?`;
-    case AcceptedOperator.ENDS_WITH:
-      return `${column} LIKE ?`;
-    case AcceptedOperator.REG_EXP: {
-      switch (dialect) {
-        case Dialect.POSTGRES:
-          return `${column} ~ ?`;
-        case Dialect.MYSQL:
-          return `${column} REGEXP ?`;
-        case Dialect.SQLITE:
-          return `${column} GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    case AcceptedOperator.NOT_REG_EXP: {
-      switch (dialect) {
-        case Dialect.POSTGRES:
-          return `${column} !~ ?`;
-        case Dialect.MYSQL:
-          return `${column} NOT REGEXP ?`;
-        case Dialect.SQLITE:
-          return `${column} NOT GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    case AcceptedOperator.RLIKE: {
-      switch (dialect) {
-        case Dialect.POSTGRES:
-          return `${column} ~* ?`;
-        case Dialect.MYSQL:
-          return `${column} RLIKE ?`;
-        case Dialect.SQLITE:
-          return `${column} GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    case AcceptedOperator.NOT_RLIKE: {
-      switch (dialect) {
-        case Dialect.POSTGRES:
-          return `${column} !~* ?`;
-        case Dialect.MYSQL:
-          return `${column} NOT RLIKE ?`;
-        case Dialect.SQLITE:
-          return `${column} NOT GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    default:
-      throw new Error("Invalid operator");
-  }
-}
 function getTimestamp(table) {
   const isWithTimestamp = !!table.timestamp;
   const timestamp = /* @__PURE__ */ new Date();
@@ -156,23 +59,6 @@ function getParanoid(table) {
     deletedAt
   };
 }
-function getWhereConditions(q) {
-  if (q.definition.queryType === QueryType.INSERT) return [];
-  const conditions = [];
-  const base = q.definition.baseAlias ?? q.table.name;
-  const { isWithParanoid, deletedAt } = getParanoid(q.table);
-  const withDeleted = !!q.definition.withDeleted;
-  const isHasConditions = !!q.definition.where?.length;
-  if (!withDeleted && isWithParanoid) {
-    const suffix = isHasConditions ? " AND" : "";
-    const column = `${base}.${quoteIdentifier(deletedAt)}`;
-    conditions.unshift(`${column} IS NULL${suffix}`);
-  }
-  if (q.definition.where?.length) {
-    conditions.push(...q.definition.where);
-  }
-  return conditions;
-}
 function getGroupByConditions(q) {
   if (q.definition.queryType !== QueryType.SELECT) return [];
   if (q.definition.groupBy?.length) return q.definition.groupBy;
@@ -253,4 +139,4 @@ function sanitizeParams(params) {
   });
 }
 
-export { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow, sanitizeParams };
+export { getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, parseAliasedRow, sanitizeParams };

package/dist/esm/table/index.d.ts

@@ -1,4 +1,4 @@
-export { T as Table } from '../index-CjurLJdK.js';
+export { T as Table } from '../index-CsVPGz2o.js';
 import '../column/index.js';
 import './constants.js';
 import 'bun';

package/dist/esm/table/types.d.ts

@@ -1,5 +1,5 @@
 import 'bun';
-export { X as ExecOptions, M as MergeTimestampParanoid, U as TableOptions, V as TableOutput, f as TimestampOptions } from '../index-CjurLJdK.js';
+export { K as ExecOptions, M as MergeTimestampParanoid, H as TableOptions, I as TableOutput, h as TimestampOptions } from '../index-CsVPGz2o.js';
 import '../column/index.js';
 import './constants.js';
 import '../types.js';

package/dist/esm/table/utilities.d.ts

@@ -1,7 +1,7 @@
 import '../column/constants.js';
 import '../column/index.js';
 import './constants.js';
-export { K as createdAt, O as defineColumns, N as deletedAt, L as updatedAt } from '../index-CjurLJdK.js';
+export { y as createdAt, F as defineColumns, B as deletedAt, z as updatedAt } from '../index-CsVPGz2o.js';
 import '../column/types.js';
 import 'bun';
 import '../types.js';

package/package.json

@@ -3,7 +3,7 @@
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "exports": {
     ".": {
@@ -68,10 +68,10 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/krsbx/aio-web.git"
+    "url": "git+https://github.com/krsbx/ignisia.git"
   },
   "bugs": {
-    "url": "https://github.com/krsbx/aio-web/issues"
+    "url": "https://github.com/krsbx/ignisia/issues"
   },
   "keywords": [
     "bun",
@@ -81,4 +81,4 @@
     "postgres",
     "mysql"
   ]
-}
+}

package/dist/cjs/query/condition/raw.d.cts

@@ -1,8 +0,0 @@
-export { c as addRawCondition, e as rawHaving, d as rawOr, r as rawWhere } from '../../index-CHxuUiO4.cjs';
-import '../../column/index.cjs';
-import '../constants.cjs';
-import 'bun';
-import '../../types.cjs';
-import '../../column/constants.cjs';
-import '../../table/constants.cjs';
-import '../../column/types.cjs';

package/dist/cjs/query/condition/raw.js

@@ -1,54 +0,0 @@
-'use strict';
-
-var constants = require('../constants');
-var helper = require('../helper');
-
-function addRawCondition(query, clause, column, logical, params) {
-  const validClause = clause.toLowerCase();
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const condition = column(helper.rawCol);
-  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
-  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
-  if (!query.definition.params) query.definition.params = [];
-  if (typeof params === "undefined") {
-    return query;
-  }
-  if (Array.isArray(params)) {
-    query.definition.params.push(...params);
-  } else {
-    query.definition.params.push(params);
-  }
-  return query;
-}
-function rawWhere(column, params) {
-  return addRawCondition(
-    this,
-    constants.ConditionClause.WHERE,
-    column,
-    constants.LogicalOperator.AND,
-    params
-  );
-}
-function rawOr(column, params) {
-  return addRawCondition(
-    this,
-    constants.ConditionClause.WHERE,
-    column,
-    constants.LogicalOperator.OR,
-    params
-  );
-}
-function rawHaving(column, params) {
-  return addRawCondition(
-    this,
-    constants.ConditionClause.HAVING,
-    column,
-    constants.LogicalOperator.AND,
-    params
-  );
-}
-
-exports.addRawCondition = addRawCondition;
-exports.rawHaving = rawHaving;
-exports.rawOr = rawOr;
-exports.rawWhere = rawWhere;

package/dist/esm/query/condition/raw.d.ts

@@ -1,8 +0,0 @@
-export { c as addRawCondition, e as rawHaving, d as rawOr, r as rawWhere } from '../../index-CjurLJdK.js';
-import '../../column/index.js';
-import '../constants.js';
-import 'bun';
-import '../../types.js';
-import '../../column/constants.js';
-import '../../table/constants.js';
-import '../../column/types.js';

package/dist/esm/query/condition/raw.js

@@ -1,50 +0,0 @@
-import { LogicalOperator, ConditionClause } from '../constants.js';
-import { rawCol } from '../helper.js';
-
-// src/query/condition/raw.ts
-function addRawCondition(query, clause, column, logical, params) {
-  const validClause = clause.toLowerCase();
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const condition = column(rawCol);
-  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
-  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
-  if (!query.definition.params) query.definition.params = [];
-  if (typeof params === "undefined") {
-    return query;
-  }
-  if (Array.isArray(params)) {
-    query.definition.params.push(...params);
-  } else {
-    query.definition.params.push(params);
-  }
-  return query;
-}
-function rawWhere(column, params) {
-  return addRawCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    LogicalOperator.AND,
-    params
-  );
-}
-function rawOr(column, params) {
-  return addRawCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    LogicalOperator.OR,
-    params
-  );
-}
-function rawHaving(column, params) {
-  return addRawCondition(
-    this,
-    ConditionClause.HAVING,
-    column,
-    LogicalOperator.AND,
-    params
-  );
-}
-
-export { addRawCondition, rawHaving, rawOr, rawWhere };