@ignisia/sql 0.2.0 → 0.2.1

package/dist/chunk-EIUC7HJS.js

@@ -1,686 +0,0 @@
-import {
-  addJoin
-} from "./chunk-FYSNJAGD.js";
-import {
-  AcceptedJoin,
-  AcceptedOperator,
-  ConditionClause,
-  LogicalOperator,
-  QueryHooksType,
-  QueryType
-} from "./chunk-62FKD35V.js";
-import {
-  deepClone,
-  quoteIdentifier
-} from "./chunk-Y7FSRHH3.js";
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
-
-// src/query/utilities.ts
-function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
-  const [tableAlias] = column.split(".");
-  const isOnBase = tableAlias === baseAlias;
-  const from = isOnBase ? baseAlias : tableAlias;
-  const columns = isOnBase ? Object.keys(baseTable.columns) : Object.keys(joinedTables?.[from]?.columns ?? {});
-  return {
-    from,
-    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 ?`;
-    default:
-      throw new Error("Invalid operator");
-  }
-}
-function getTimestamp(table) {
-  const isWithTimestamp = !!table.timestamp;
-  const timestamp = /* @__PURE__ */ new Date();
-  let createdAt = "createdAt";
-  let updatedAt = "updatedAt";
-  if (isWithTimestamp) {
-    const isCustomTimestamp = typeof table.timestamp === "object";
-    if (isCustomTimestamp && table.timestamp.createdAt) {
-      createdAt = table.timestamp.createdAt;
-    }
-    if (isCustomTimestamp && table.timestamp.updatedAt) {
-      updatedAt = table.timestamp.updatedAt;
-    }
-  }
-  return {
-    isWithTimestamp,
-    timestamp,
-    createdAt,
-    updatedAt
-  };
-}
-function getParanoid(table) {
-  const isWithParanoid = !!table.paranoid;
-  const timestamp = /* @__PURE__ */ new Date();
-  let deletedAt = "deletedAt";
-  if (isWithParanoid) {
-    if (typeof table.paranoid === "string") {
-      deletedAt = table.paranoid;
-    }
-  }
-  return {
-    isWithParanoid,
-    timestamp,
-    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;
-  if (q.definition.aggregates?.length) {
-    if (q.definition.select?.length)
-      return q.definition.select.map((col2) => {
-        if (typeof col2 === "string" && col2.endsWith("*")) {
-          const { from: from2, columns } = getTableColumnNames(
-            col2,
-            q.definition.baseAlias ?? q.table.name,
-            q.table,
-            q.definition.joinedTables ?? {}
-          );
-          return columns.map((column) => `${from2}.${quoteIdentifier(column)}`).join(" ");
-        }
-        return col2;
-      });
-    const from = q.definition.baseAlias ?? q.table.name;
-    return Object.keys(q.table.columns).map(
-      (col2) => `${from}.${quoteIdentifier(col2)}`
-    );
-  }
-  return [];
-}
-function getTableSelectName(q) {
-  if (!q.definition.baseAlias) return q.table.name;
-  return `${q.table.name} AS ${q.definition.baseAlias}`;
-}
-function parseAliasedRow({
-  row,
-  selects,
-  root = null
-}) {
-  let result = {};
-  for (const key in row) {
-    const [table, column] = key.split(".");
-    if (!column) {
-      const alias2 = selects.find(
-        (s) => typeof s === "object" && s.as === table
-      );
-      if (alias2) {
-        const [oriTab] = alias2.column.split(".");
-        if (!result[oriTab]) result[oriTab] = {};
-        result[oriTab][table] = row[key];
-        continue;
-      }
-      result[key] = row[key];
-      continue;
-    }
-    if (!result[table]) result[table] = {};
-    result[table][column] = row[key];
-  }
-  if (root) {
-    result = {
-      ...result,
-      ...result[root]
-    };
-    delete result[root];
-  }
-  return result;
-}
-
-// src/query/condition.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
-  );
-}
-function addCondition(query, clause, column, operator, value, logical) {
-  const validClause = clause.toLowerCase();
-  const condition = getCondition(query.table.dialect, column, operator, value);
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
-  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
-  if (operator === AcceptedOperator.IS_NULL || operator === AcceptedOperator.IS_NOT_NULL) {
-    return query;
-  }
-  if (!query.definition.params) query.definition.params = [];
-  if (Array.isArray(value)) {
-    query.definition.params.push(...value);
-  } else {
-    query.definition.params.push(value);
-  }
-  return query;
-}
-function where(column, operator, value) {
-  return addCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    operator,
-    value,
-    LogicalOperator.AND
-  );
-}
-function or(column, operator, value) {
-  return addCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    operator,
-    value,
-    LogicalOperator.OR
-  );
-}
-function having(column, operator, value) {
-  return addCondition(
-    this,
-    ConditionClause.HAVING,
-    column,
-    operator,
-    value,
-    LogicalOperator.AND
-  );
-}
-
-// src/query/builder.ts
-function buildSelectQuery(q) {
-  const from = getTableSelectName(q);
-  const columns = [];
-  if (q.definition.select?.length) {
-    for (const col2 of q.definition.select) {
-      if (typeof col2 === "object") {
-        const alias2 = quoteIdentifier(col2.as.replace(/"/g, ""));
-        columns.push(`${col2.column} AS ${alias2}`);
-        continue;
-      }
-      if (!col2.endsWith("*")) {
-        const alias2 = quoteIdentifier(col2.replace(/"/g, ""));
-        columns.push(`${col2} AS ${alias2}`);
-        continue;
-      }
-      columns.push(col2);
-    }
-  }
-  if (q.definition?.aggregates) {
-    for (const aggregate of q.definition.aggregates) {
-      columns.push(
-        `${aggregate.fn}(${aggregate.column}) AS ${quoteIdentifier(aggregate.as)}`
-      );
-    }
-  }
-  const distinct = q.definition.distinct ? "DISTINCT " : "";
-  return `SELECT ${distinct}${columns.join(", ")} FROM ${from}`;
-}
-function buildInsertQuery(q) {
-  const rows = q.definition?.insertValues;
-  if (!rows?.length) {
-    throw new Error(`INSERT requires values`);
-  }
-  const keys = Object.keys(rows[0]);
-  const columns = keys.map(quoteIdentifier).join(", ");
-  const rowPlaceholders = `(${keys.map(() => "?").join(", ")})`;
-  const placeholders = rows.map(() => rowPlaceholders).join(", ");
-  q.definition.params = rows.flatMap(
-    (row) => keys.map((key) => row[key])
-  );
-  return `INSERT INTO ${q.table.name} (${columns}) VALUES ${placeholders} RETURNING *`;
-}
-function buildUpdateQuery(q) {
-  if (!q.definition?.updateValues) {
-    throw new Error(`UPDATE requires values`);
-  }
-  let keys = Object.keys(q.definition.updateValues);
-  const updateParams = keys.map(
-    (key) => q.definition.updateValues[key]
-  );
-  keys = keys.map(quoteIdentifier);
-  if (q.definition?.params) {
-    q.definition.params = [...updateParams, ...q.definition.params];
-  } else {
-    q.definition.params = updateParams;
-  }
-  return `UPDATE ${q.table.name} SET ${keys.map((key) => `${key} = ?`.trim()).join(", ")}`;
-}
-function buildDeleteQuery(q) {
-  return `DELETE FROM ${q.table.name}`;
-}
-
-// src/query/sql.ts
-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
-    })
-  );
-}
-
-// src/query/index.ts
-var QueryBuilder2 = class {
-  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;
-  }
-};
-
-// src/query/helper.ts
-function alias(alias2) {
-  this.definition.baseAlias = alias2;
-  return this;
-}
-function clone() {
-  const query = new QueryBuilder2(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 {
-  alias,
-  clone,
-  rawCol,
-  col,
-  aggregateCol,
-  getTableColumnNames,
-  getCondition,
-  getTimestamp,
-  getParanoid,
-  getWhereConditions,
-  getGroupByConditions,
-  getTableSelectName,
-  parseAliasedRow,
-  addRawCondition,
-  rawWhere,
-  rawOr,
-  rawHaving,
-  addCondition,
-  where,
-  or,
-  having,
-  buildSelectQuery,
-  buildInsertQuery,
-  buildUpdateQuery,
-  buildDeleteQuery,
-  buildQuery,
-  toQuery,
-  toString,
-  exec,
-  QueryBuilder2 as QueryBuilder
-};

package/dist/chunk-FYSNJAGD.js

@@ -1,19 +0,0 @@
-// src/query/join.ts
-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
-};