@ignisia/sql 0.2.0 → 0.2.1

package/dist/migration/index.js

@@ -1,6 +1,48 @@
-import {
-  Migration
-} from "../chunk-CIWX3UCZ.js";
-export {
-  Migration
-};
+class Migration {
+  db;
+  _up;
+  _down;
+  constructor(options) {
+    this.db = options.db;
+    this._up = options.up;
+    this._down = options.down;
+  }
+  get up() {
+    return this._up;
+  }
+  get down() {
+    return this._down;
+  }
+  static setUp(migrator, fn) {
+    migrator._up = () => fn(migrator.db);
+    return migrator;
+  }
+  static setDown(migrator, fn) {
+    migrator._down = () => fn(migrator.db);
+    return migrator;
+  }
+  static define(db, options) {
+    const migration = new Migration({
+      db,
+      up: options?.up ? () => options.up(db) : null,
+      down: options?.down ? () => options.down(db) : null
+    });
+    return {
+      migration,
+      setUp(fn) {
+        return Migration.setUp(
+          migration,
+          fn
+        );
+      },
+      setDown(fn) {
+        return Migration.setDown(
+          migration,
+          fn
+        );
+      }
+    };
+  }
+}
+
+export { Migration };

package/dist/migration/runner.js

@@ -1,26 +1,14 @@
-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';
+import { Table } from '../table';
 
-// src/migration/runner.ts
-var nameColumn = Column.define({
+const nameColumn = Column.define({
   type: "TEXT",
   length: 255
 }).primaryKey().notNull();
-var runAtColumn = Column.define({
+const runAtColumn = Column.define({
   type: "DATETIME"
 }).notNull();
-var migrationTable = null;
+let migrationTable = null;
 async function runMigration(filePath, direction) {
   const migrationFile = await import(filePath);
   const fileName = filePath.split("/").pop();
@@ -64,6 +52,5 @@ async function runMigration(filePath, direction) {
     return query.delete().where('ignisia_migration."name"', "eq", fileName).exec();
   });
 }
-export {
-  runMigration
-};
+
+export { runMigration };

package/dist/migration/type.js

@@ -0,0 +1 @@
+

package/dist/query/builder.js

@@ -1,16 +1,66 @@
-import {
-  buildDeleteQuery,
-  buildInsertQuery,
-  buildSelectQuery,
-  buildUpdateQuery
-} from "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  buildDeleteQuery,
-  buildInsertQuery,
-  buildSelectQuery,
-  buildUpdateQuery
-};
+import { quoteIdentifier } from '../utilities';
+import { getTableSelectName } from './utilities';
+
+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/query/condition.js

@@ -1,24 +1,97 @@
-import {
-  addCondition,
-  addRawCondition,
-  having,
-  or,
-  rawHaving,
-  rawOr,
-  rawWhere,
-  where
-} from "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  addCondition,
-  addRawCondition,
-  having,
-  or,
-  rawHaving,
-  rawOr,
-  rawWhere,
-  where
-};
+import { LogicalOperator, ConditionClause, AcceptedOperator } from './constants';
+import { rawCol } from './helper';
+import { getCondition } from './utilities';
+
+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/query/constants.js

@@ -1,20 +1,55 @@
-import {
-  AcceptedJoin,
-  AcceptedOperator,
-  AggregationFunction,
-  ConditionClause,
-  LogicalOperator,
-  OrderBy,
-  QueryHooksType,
-  QueryType
-} from "../chunk-62FKD35V.js";
-export {
-  AcceptedJoin,
-  AcceptedOperator,
-  AggregationFunction,
-  ConditionClause,
-  LogicalOperator,
-  OrderBy,
-  QueryHooksType,
-  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.js

@@ -0,0 +1 @@
+

package/dist/query/helper.js

@@ -1,18 +1,30 @@
-import {
-  aggregateCol,
-  alias,
-  clone,
-  col,
-  rawCol
-} from "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.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.js

@@ -1,10 +1,195 @@
-import {
-  QueryBuilder
-} from "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.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.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 };