@ignisia/sql 0.2.0 → 0.2.2

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { Column } from './column/index.js';
+export { Database } from './database/index.js';
+export { Migration } from './migration/index.js';
+export { QueryBuilder } from './query/index.js';
+export { Table } from './table/index.js';

package/dist/{chunk-CIWX3UCZ.js → esm/migration/index.js}

@@ -46,6 +46,4 @@ var Migration = class _Migration {
   }
 };
 
-export {
-  Migration
-};
+export { Migration };

package/dist/esm/migration/runner.d.ts

@@ -0,0 +1,3 @@
+declare function runMigration(filePath: string, direction: 'up' | 'down'): Promise<void>;
+
+export { runMigration };

package/dist/{migration → esm/migration}/runner.js

@@ -1,16 +1,5 @@
-import {
-  Table
-} from "../chunk-KVCIOW7L.js";
-import "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-WVJGTZFI.js";
-import {
-  Column
-} from "../chunk-GY7R637S.js";
-import "../chunk-G3LSCLIQ.js";
-import "../chunk-GLOHF5CP.js";
+import { Column } from '../column/index.js';
+import { Table } from '../table/index.js';
 
 // src/migration/runner.ts
 var nameColumn = Column.define({
@@ -64,6 +53,5 @@ async function runMigration(filePath, direction) {
     return query.delete().where('ignisia_migration."name"', "eq", fileName).exec();
   });
 }
-export {
-  runMigration
-};
+
+export { runMigration };

package/dist/esm/migration/type.js

@@ -0,0 +1 @@
+

package/dist/esm/query/builder.js

@@ -0,0 +1,67 @@
+import { quoteIdentifier } from '../utilities.js';
+import { getTableSelectName } from './utilities.js';
+
+// src/query/builder.ts
+function buildSelectQuery(q) {
+  const from = getTableSelectName(q);
+  const columns = [];
+  if (q.definition.select?.length) {
+    for (const col of q.definition.select) {
+      if (typeof col === "object") {
+        const alias = quoteIdentifier(col.as.replace(/"/g, ""));
+        columns.push(`${col.column} AS ${alias}`);
+        continue;
+      }
+      if (!col.endsWith("*")) {
+        const alias = quoteIdentifier(col.replace(/"/g, ""));
+        columns.push(`${col} AS ${alias}`);
+        continue;
+      }
+      columns.push(col);
+    }
+  }
+  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}`;
+}
+
+export { buildDeleteQuery, buildInsertQuery, buildSelectQuery, buildUpdateQuery };

package/dist/esm/query/condition.js

@@ -0,0 +1,98 @@
+import { LogicalOperator, ConditionClause, AcceptedOperator } from './constants.js';
+import { rawCol } from './helper.js';
+import { getCondition } from './utilities.js';
+
+// 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
+  );
+}
+
+export { addCondition, addRawCondition, having, or, rawHaving, rawOr, rawWhere, where };

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

@@ -0,0 +1,63 @@
+declare const LogicalOperator: {
+    readonly AND: "AND";
+    readonly OR: "OR";
+};
+type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+declare const ConditionClause: {
+    readonly WHERE: "WHERE";
+    readonly HAVING: "HAVING";
+};
+type ConditionClause = (typeof ConditionClause)[keyof typeof ConditionClause];
+declare const AcceptedOperator: {
+    readonly EQ: "eq";
+    readonly NE: "ne";
+    readonly GT: "gt";
+    readonly LT: "lt";
+    readonly GTE: "gte";
+    readonly LTE: "lte";
+    readonly IN: "in";
+    readonly NOT_IN: "notIn";
+    readonly LIKE: "like";
+    readonly NOT_LIKE: "notLike";
+    readonly ILIKE: "ilike";
+    readonly NOT_ILIKE: "notILike";
+    readonly IS_NULL: "isNull";
+    readonly IS_NOT_NULL: "isNotNull";
+    readonly BETWEEN: "between";
+    readonly NOT_BETWEEN: "notBetween";
+};
+type AcceptedOperator = (typeof AcceptedOperator)[keyof typeof AcceptedOperator];
+declare const QueryType: {
+    readonly SELECT: "SELECT";
+    readonly INSERT: "INSERT";
+    readonly UPDATE: "UPDATE";
+    readonly DELETE: "DELETE";
+};
+type QueryType = (typeof QueryType)[keyof typeof QueryType];
+declare const OrderBy: {
+    readonly ASC: "ASC";
+    readonly DESC: "DESC";
+};
+type OrderBy = (typeof OrderBy)[keyof typeof OrderBy];
+declare const AggregationFunction: {
+    readonly COUNT: "COUNT";
+    readonly SUM: "SUM";
+    readonly MIN: "MIN";
+    readonly MAX: "MAX";
+    readonly AVG: "AVG";
+};
+type AggregationFunction = (typeof AggregationFunction)[keyof typeof AggregationFunction];
+declare const AcceptedJoin: {
+    readonly INNER: "INNER";
+    readonly LEFT: "LEFT";
+    readonly RIGHT: "RIGHT";
+    readonly NATURAL: "NATURAL";
+};
+type AcceptedJoin = (typeof AcceptedJoin)[keyof typeof AcceptedJoin];
+declare const QueryHooksType: {
+    readonly AFTER: "after";
+    readonly BEFORE: "before";
+};
+type QueryHooksType = (typeof QueryHooksType)[keyof typeof QueryHooksType];
+
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/{chunk-62FKD35V.js → esm/query/constants.js}

@@ -53,13 +53,4 @@ var QueryHooksType = {
   BEFORE: "before"
 };
 
-export {
-  LogicalOperator,
-  ConditionClause,
-  AcceptedOperator,
-  QueryType,
-  OrderBy,
-  AggregationFunction,
-  AcceptedJoin,
-  QueryHooksType
-};
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/esm/query/contract.js

@@ -0,0 +1 @@
+

package/dist/esm/query/helper.js

@@ -0,0 +1,31 @@
+import { QueryBuilder } from './index.js';
+import { deepClone } from '../utilities.js';
+
+// src/query/helper.ts
+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/esm/query/index.js

@@ -0,0 +1,196 @@
+import { quoteIdentifier } from '../utilities.js';
+import { rawWhere, rawHaving, rawOr, where, having, or } from './condition.js';
+import { AcceptedJoin, QueryType } from './constants.js';
+import { alias, clone, aggregateCol, col } from './helper.js';
+import { addJoin } from './join.js';
+import { toQuery, toString, exec } from './sql.js';
+import { getTimestamp, getParanoid } from './utilities.js';
+
+// src/query/index.ts
+var QueryBuilder = 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;
+  }
+};
+
+export { QueryBuilder };

package/dist/{chunk-FYSNJAGD.js → esm/query/join.js}

@@ -14,6 +14,4 @@ function addJoin(query, joinType, alias, joinTable, baseColumn, joinColumn) {
   return query;
 }
 
-export {
-  addJoin
-};
+export { addJoin };

package/dist/esm/query/sql.js

@@ -0,0 +1,100 @@
+import { buildDeleteQuery, buildUpdateQuery, buildInsertQuery, buildSelectQuery } from './builder.js';
+import { QueryType, QueryHooksType } from './constants.js';
+import { getWhereConditions, getGroupByConditions, parseAliasedRow } from './utilities.js';
+
+// 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
+    })
+  );
+}
+
+export { buildQuery, exec, toQuery, toString };

package/dist/esm/query/types.js

@@ -0,0 +1 @@
+