@ignisia/sql 0.1.0 → 0.2.1

package/dist/query/constants.js

@@ -1,18 +1,55 @@
-import {
-  AcceptedJoin,
-  AcceptedOperator,
-  AggregationFunction,
-  ConditionClause,
-  LogicalOperator,
-  OrderBy,
-  QueryType
-} from "../chunk-MG2S4V4N.js";
-export {
-  AcceptedJoin,
-  AcceptedOperator,
-  AggregationFunction,
-  ConditionClause,
-  LogicalOperator,
-  OrderBy,
-  QueryType
+const LogicalOperator = {
+  AND: "AND",
+  OR: "OR"
 };
+const ConditionClause = {
+  WHERE: "WHERE",
+  HAVING: "HAVING"
+};
+const AcceptedOperator = {
+  EQ: "eq",
+  NE: "ne",
+  GT: "gt",
+  LT: "lt",
+  GTE: "gte",
+  LTE: "lte",
+  IN: "in",
+  NOT_IN: "notIn",
+  LIKE: "like",
+  NOT_LIKE: "notLike",
+  ILIKE: "ilike",
+  NOT_ILIKE: "notILike",
+  IS_NULL: "isNull",
+  IS_NOT_NULL: "isNotNull",
+  BETWEEN: "between",
+  NOT_BETWEEN: "notBetween"
+};
+const QueryType = {
+  SELECT: "SELECT",
+  INSERT: "INSERT",
+  UPDATE: "UPDATE",
+  DELETE: "DELETE"
+};
+const OrderBy = {
+  ASC: "ASC",
+  DESC: "DESC"
+};
+const AggregationFunction = {
+  COUNT: "COUNT",
+  SUM: "SUM",
+  MIN: "MIN",
+  MAX: "MAX",
+  AVG: "AVG"
+};
+const AcceptedJoin = {
+  INNER: "INNER",
+  LEFT: "LEFT",
+  RIGHT: "RIGHT",
+  NATURAL: "NATURAL"
+};
+const QueryHooksType = {
+  AFTER: "after",
+  BEFORE: "before"
+};
+
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/query/contract.d.ts

@@ -1,4 +1,4 @@
-export { J as QueryConditionContract, I as QueryTransformerContract } from '../index-DJhQVUY3.js';
+export { N as QueryConditionContract, L as QueryTransformerContract } from '../index-FMT0YEO7.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';

package/dist/query/contract.js

@@ -0,0 +1 @@
+

package/dist/query/helper.d.ts

@@ -1,4 +1,4 @@
-export { w as aggregateCol, r as alias, s as clone, v as col, t as rawCol } from '../index-DJhQVUY3.js';
+export { z as aggregateCol, v as alias, w as clone, y as col, x as rawCol } from '../index-FMT0YEO7.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';

package/dist/query/helper.js

@@ -1,18 +1,30 @@
-import {
-  aggregateCol,
-  alias,
-  clone,
-  col,
-  rawCol
-} from "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  aggregateCol,
-  alias,
-  clone,
-  col,
-  rawCol
-};
+import { QueryBuilder } from '.';
+import { deepClone } from '../utilities';
+
+function alias(alias2) {
+  this.definition.baseAlias = alias2;
+  return this;
+}
+function clone() {
+  const query = new QueryBuilder(this.table);
+  Object.assign(query.definition, deepClone(this.definition));
+  return query;
+}
+function rawCol(column) {
+  return column;
+}
+function col(column, alias2) {
+  return {
+    column,
+    as: alias2
+  };
+}
+function aggregateCol(fn, column, alias2) {
+  return {
+    column,
+    as: alias2 ?? fn.toLowerCase(),
+    fn
+  };
+}
+
+export { aggregateCol, alias, clone, col, rawCol };

package/dist/query/index.d.ts

@@ -1,5 +1,5 @@
 import '../column/index.js';
-export { d as QueryBuilder } from '../index-DJhQVUY3.js';
+export { d as QueryBuilder } from '../index-FMT0YEO7.js';
 import './constants.js';
 import '../table/constants.js';
 import '../column/constants.js';

package/dist/query/index.js

@@ -1,10 +1,195 @@
-import {
-  QueryBuilder
-} from "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  QueryBuilder
-};
+import { quoteIdentifier } from '../utilities';
+import { rawWhere, rawHaving, rawOr, where, having, or } from './condition';
+import { AcceptedJoin, QueryType } from './constants';
+import { alias, clone, aggregateCol, col } from './helper';
+import { addJoin } from './join';
+import { toQuery, toString, exec } from './sql';
+import { getTimestamp, getParanoid } from './utilities';
+
+class QueryBuilder {
+  hooks;
+  table;
+  definition;
+  _output;
+  alias;
+  clone;
+  toQuery;
+  toString;
+  exec;
+  rawWhere;
+  rawAnd;
+  rawOr;
+  rawHaving;
+  where;
+  and;
+  or;
+  having;
+  constructor(table) {
+    this.hooks = {};
+    this.table = table;
+    this.definition = {
+      queryType: null,
+      select: null,
+      having: null,
+      where: null,
+      params: null,
+      limit: null,
+      offset: null,
+      groupBy: null,
+      insertValues: null,
+      updateValues: null,
+      orderBy: null,
+      aggregates: null,
+      joins: null,
+      distinct: null,
+      baseAlias: table.name,
+      joinedTables: null,
+      withDeleted: null
+    };
+    this.alias = alias.bind(this);
+    this.clone = clone.bind(this);
+    this.toQuery = toQuery.bind(this);
+    this.toString = toString.bind(this);
+    this.exec = exec.bind(this);
+    this.rawWhere = rawWhere.bind(this);
+    this.rawHaving = rawHaving.bind(this);
+    this.rawAnd = this.rawWhere;
+    this.rawOr = rawOr.bind(this);
+    this.where = where.bind(this);
+    this.having = having.bind(this);
+    this.and = this.where;
+    this.or = or.bind(this);
+  }
+  leftJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return addJoin(
+      this,
+      AcceptedJoin.LEFT,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  rightJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return addJoin(
+      this,
+      AcceptedJoin.RIGHT,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  innerJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return addJoin(
+      this,
+      AcceptedJoin.INNER,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  naturalJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return addJoin(
+      this,
+      AcceptedJoin.NATURAL,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  distinct() {
+    this.definition.distinct = true;
+    return this;
+  }
+  aggregate(...aggregates) {
+    this.definition.aggregates = aggregates.map(
+      (aggregate) => aggregate(aggregateCol)
+    );
+    return this;
+  }
+  groupBy(...columns) {
+    this.definition.groupBy = columns;
+    return this;
+  }
+  limit(limit) {
+    this.definition.limit = limit;
+    return this;
+  }
+  offset(offset) {
+    this.definition.offset = offset;
+    return this;
+  }
+  orderBy(...orderBy) {
+    if (!this.definition.orderBy) this.definition.orderBy = [];
+    this.definition.orderBy.push(...orderBy);
+    return this;
+  }
+  withDeleted() {
+    this.definition.withDeleted = true;
+    return this;
+  }
+  select(...columns) {
+    if (!columns.length) {
+      const base = this.definition.baseAlias ?? this.table.name;
+      columns = Object.keys(this.table.columns).map(
+        (colName) => `${base}.${quoteIdentifier(colName)}`
+      );
+    } else {
+      columns = columns.map((column) => {
+        if (typeof column === "function") {
+          return column(col);
+        }
+        return column;
+      });
+    }
+    this.definition.select = columns;
+    this.definition.queryType = QueryType.SELECT;
+    return this;
+  }
+  insert(...values) {
+    this.definition.queryType = QueryType.INSERT;
+    if (!this.definition.insertValues) this.definition.insertValues = [];
+    const { isWithTimestamp, createdAt, updatedAt, timestamp } = getTimestamp(
+      this.table
+    );
+    if (isWithTimestamp) {
+      values = values.map((row) => ({
+        ...row,
+        [createdAt]: row[createdAt] ?? timestamp,
+        [updatedAt]: row[updatedAt] ?? timestamp
+      }));
+    }
+    this.definition.insertValues = values;
+    return this;
+  }
+  update(values) {
+    const { isWithTimestamp, updatedAt, timestamp } = getTimestamp(this.table);
+    if (isWithTimestamp) {
+      values = {
+        ...values,
+        [updatedAt]: values[updatedAt] ?? timestamp
+      };
+    }
+    this.definition.queryType = QueryType.UPDATE;
+    this.definition.updateValues = values;
+    return this;
+  }
+  delete() {
+    const { isWithParanoid, deletedAt, timestamp } = getParanoid(this.table);
+    if (isWithParanoid) {
+      return this.update({
+        [deletedAt]: timestamp
+      });
+    }
+    this.definition.queryType = QueryType.DELETE;
+    return this;
+  }
+  infer() {
+    return null;
+  }
+}
+
+export { QueryBuilder };

package/dist/query/join.d.ts

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-DJhQVUY3.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-FMT0YEO7.js';
 import { Column } from '../column/index.js';
 import { AcceptedJoin } from './constants.js';
 import '../column/constants.js';

package/dist/query/join.js

@@ -1,6 +1,16 @@
-import {
-  addJoin
-} from "../chunk-FYSNJAGD.js";
-export {
-  addJoin
-};
+function addJoin(query, joinType, alias, joinTable, baseColumn, joinColumn) {
+  if (!query.definition.joins) query.definition.joins = [];
+  query.definition.joins.push(
+    `${joinType} JOIN ${joinTable.name} AS ${alias} ON ${baseColumn} = ${joinColumn}`
+  );
+  if (!query.definition.joinedTables) {
+    query.definition.joinedTables = {};
+  }
+  query.definition.joinedTables = {
+    ...query.definition.joinedTables,
+    [alias]: joinTable
+  };
+  return query;
+}
+
+export { addJoin };

package/dist/query/sql.d.ts

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-DJhQVUY3.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-FMT0YEO7.js';
 import { Column } from '../column/index.js';
 import '../column/constants.js';
 import '../types.js';

package/dist/query/sql.js

@@ -1,16 +1,99 @@
-import {
-  buildQuery,
-  exec,
-  toQuery,
-  toString
-} from "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  buildQuery,
-  exec,
-  toQuery,
-  toString
-};
+import { buildDeleteQuery, buildUpdateQuery, buildInsertQuery, buildSelectQuery } from './builder';
+import { QueryType, QueryHooksType } from './constants';
+import { getWhereConditions, getGroupByConditions, parseAliasedRow } from './utilities';
+
+function buildQuery(query) {
+  let index = 0;
+  return query.replace(/\?/g, () => {
+    index++;
+    return `$${index}`;
+  });
+}
+function toQuery() {
+  let sql = "";
+  switch (this.definition.queryType) {
+    case QueryType.SELECT:
+      sql = buildSelectQuery(this);
+      break;
+    case QueryType.INSERT:
+      sql = buildInsertQuery(this);
+      break;
+    case QueryType.UPDATE:
+      sql = buildUpdateQuery(this);
+      break;
+    case QueryType.DELETE:
+      sql = buildDeleteQuery(this);
+      break;
+    default:
+      throw new Error("No query type defined");
+  }
+  if (this.definition?.joins?.length) {
+    sql += ` ${this.definition.joins.join(" ")}`;
+  }
+  const whereConditions = getWhereConditions(this);
+  if (whereConditions.length) {
+    sql += ` WHERE ${whereConditions.join(" ")}`;
+  }
+  const groupByConditions = getGroupByConditions(this);
+  if (groupByConditions.length) {
+    sql += ` GROUP BY ${groupByConditions.join(", ")}`;
+  }
+  if (this.definition?.having?.length) {
+    sql += ` HAVING ${this.definition.having.join(" ")}`;
+  }
+  if (this.definition?.orderBy?.length) {
+    sql += ` ORDER BY ${this.definition.orderBy.map((order) => [order.column, order.direction].join(" ")).join(", ")}`;
+  }
+  if (this.definition?.limit !== null) {
+    sql += ` LIMIT ?`;
+    if (!this.definition.params) this.definition.params = [];
+    this.definition.params.push(this.definition.limit);
+  }
+  if (this.definition?.offset !== null) {
+    sql += ` OFFSET ?`;
+    if (!this.definition.params) this.definition.params = [];
+    this.definition.params.push(this.definition.offset);
+  }
+  if (this.definition.queryType === QueryType.UPDATE || this.definition.queryType === QueryType.DELETE) {
+    sql += ` RETURNING *`;
+  }
+  sql = buildQuery(sql);
+  return { query: sql + ";", params: this.definition.params };
+}
+function toString() {
+  return this.toQuery().query;
+}
+async function exec() {
+  if (!this.table.client) throw new Error("Database client not defined");
+  const { query, params } = this.toQuery();
+  if (this.hooks?.before?.size) {
+    for (const hook of this.hooks.before.values()) {
+      hook({
+        query,
+        params,
+        type: this.definition.queryType,
+        hook: QueryHooksType.BEFORE
+      });
+    }
+  }
+  const result = await this.table.client.exec(query, params);
+  if (this.hooks?.after?.size) {
+    for (const hook of this.hooks.after.values()) {
+      hook({
+        query,
+        params,
+        type: this.definition.queryType,
+        hook: QueryHooksType.AFTER
+      });
+    }
+  }
+  return result.map(
+    (r) => parseAliasedRow({
+      row: r,
+      selects: this.definition.select ?? [],
+      root: this.definition?.baseAlias ?? this.table.name
+    })
+  );
+}
+
+export { buildQuery, exec, toQuery, toString };

package/dist/query/types.d.ts

@@ -1,6 +1,6 @@
 import '../column/index.js';
 import '../column/constants.js';
-export { h as AcceptedInsertValues, g as AcceptedOrderBy, i as AcceptedUpdateValues, j as AggregateColumn, A as AliasedColumn, C as ColumnSelector, Q as QueryDefinition, l as QueryOutput, R as RawColumn, k as SelectQueryOutput, e as SelectableColumn, c as StrictColumnSelector, W as WhereValue } from '../index-DJhQVUY3.js';
+export { j as AcceptedInsertValues, i as AcceptedOrderBy, k as AcceptedUpdateValues, l as AggregateColumn, A as AliasedColumn, C as ColumnSelector, f as QuerHooks, Q as QueryDefinition, n as QueryOutput, h as QueryRunHooks, o as QueryRunHooksOptions, R as RawColumn, m as SelectQueryOutput, e as SelectableColumn, c as StrictColumnSelector, W as WhereValue } from '../index-FMT0YEO7.js';
 import '../types.js';
 import './constants.js';
 import '../table/constants.js';

package/dist/query/types.js

@@ -0,0 +1 @@
+

package/dist/query/utilities.d.ts

@@ -1,4 +1,4 @@
-import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder, A as AliasedColumn, e as SelectableColumn } from '../index-DJhQVUY3.js';
+import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder, A as AliasedColumn, e as SelectableColumn } from '../index-FMT0YEO7.js';
 import { Column } from '../column/index.js';
 import { Dialect } from '../table/constants.js';
 import { AcceptedOperator } from './constants.js';