@ignisia/sql 0.2.1 → 0.3.0

package/dist/cjs/migration/runner.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var column = require('../column');
+var table = require('../table');
+
+const nameColumn = column.Column.define({
+  type: "TEXT",
+  length: 255
+}).primaryKey().notNull();
+const runAtColumn = column.Column.define({
+  type: "DATETIME"
+}).notNull();
+let migrationTable = null;
+async function runMigration(filePath, direction) {
+  const migrationFile = await import(filePath);
+  const fileName = filePath.split("/").pop();
+  if (!migrationFile || !migrationFile.migration) {
+    throw new Error(
+      'Invalid migration file! A migration file must export a migration as "migration"'
+    );
+  }
+  const { migration } = migrationFile;
+  if (!migrationTable) {
+    migrationTable = table.Table.define({
+      name: "ignisia_migration",
+      columns: {
+        name: nameColumn,
+        runAt: runAtColumn
+      },
+      dialect: migration.db.dialect
+    });
+    migrationTable.client = migration.db.client;
+    await migrationTable.create({});
+  }
+  const fn = migration[direction];
+  if (!fn)
+    throw new Error("No migration function found for direction: " + direction);
+  const [lastRun] = await migrationTable.query().select("ignisia_migration.*").limit(1).where('ignisia_migration."name"', "eq", fileName).exec();
+  if (lastRun) {
+    console.log("Migration already run!");
+    console.log("Run At	: " + new Date(lastRun.runAt).toDateString());
+    console.log("Name	: " + fileName);
+    return;
+  }
+  const query = migrationTable.query();
+  await migration.db.client.transaction(async () => {
+    await fn();
+    if (direction === "up") {
+      return query.insert({
+        name: fileName,
+        runAt: (/* @__PURE__ */ new Date()).toISOString()
+      }).exec();
+    }
+    return query.delete().where('ignisia_migration."name"', "eq", fileName).exec();
+  });
+}
+
+exports.runMigration = runMigration;

package/dist/cjs/migration/type.d.cts

@@ -0,0 +1,20 @@
+import { Column } from '../column/index.cjs';
+import { D as Database } from '../index-2jl8MRfX.cjs';
+import { T as Table } from '../index-CnQVnCEI.cjs';
+import { Dialect } from '../table/constants.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import 'bun';
+import '../query/constants.cjs';
+import '../types.cjs';
+
+interface MigrationOptions<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
+    db: Database<DbDialect, Tables>;
+    up: (() => Promise<void>) | null;
+    down: (() => Promise<void>) | null;
+}
+interface MigrationFn<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
+    (db: Database<DbDialect, Tables>): Promise<void>;
+}
+
+export type { MigrationFn, MigrationOptions };

package/dist/cjs/migration/type.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/query/builder.d.cts

@@ -0,0 +1,15 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-CnQVnCEI.cjs';
+import { Column } from '../column/index.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import './constants.cjs';
+import 'bun';
+import '../table/constants.cjs';
+import '../column/types.cjs';
+
+declare function buildSelectQuery<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>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
+declare function buildInsertQuery<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>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
+declare function buildUpdateQuery<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>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
+declare function buildDeleteQuery<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>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
+
+export { buildDeleteQuery, buildInsertQuery, buildSelectQuery, buildUpdateQuery };

package/dist/cjs/query/builder.js

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

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

@@ -0,0 +1,8 @@
+export { N as addCondition, I as addRawCondition, V as having, U as or, L as rawHaving, K as rawOr, J as rawWhere, O as where } from '../index-CnQVnCEI.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import 'bun';
+import '../table/constants.cjs';
+import '../column/types.cjs';

package/dist/cjs/query/condition.js

@@ -0,0 +1,109 @@
+'use strict';
+
+var constants = require('./constants');
+var helper = require('./helper');
+var utilities = require('./utilities');
+
+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
+  );
+}
+function addCondition(query, clause, column, operator, value, logical) {
+  if (!query.table.dialect) {
+    throw new Error("No DB Dialect defined");
+  }
+  const validClause = clause.toLowerCase();
+  const condition = utilities.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 === constants.AcceptedOperator.IS_NULL || operator === constants.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,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.AND
+  );
+}
+function or(column, operator, value) {
+  return addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.OR
+  );
+}
+function having(column, operator, value) {
+  return addCondition(
+    this,
+    constants.ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    constants.LogicalOperator.AND
+  );
+}
+
+exports.addCondition = addCondition;
+exports.addRawCondition = addRawCondition;
+exports.having = having;
+exports.or = or;
+exports.rawHaving = rawHaving;
+exports.rawOr = rawOr;
+exports.rawWhere = rawWhere;
+exports.where = where;

package/dist/cjs/query/constants.js

@@ -0,0 +1,64 @@
+'use strict';
+
+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"
+};
+
+exports.AcceptedJoin = AcceptedJoin;
+exports.AcceptedOperator = AcceptedOperator;
+exports.AggregationFunction = AggregationFunction;
+exports.ConditionClause = ConditionClause;
+exports.LogicalOperator = LogicalOperator;
+exports.OrderBy = OrderBy;
+exports.QueryHooksType = QueryHooksType;
+exports.QueryType = QueryType;

package/dist/cjs/query/contract.d.cts

@@ -0,0 +1,8 @@
+import 'bun';
+export { Y as QueryConditionContract, X as QueryTransformerContract } from '../index-CnQVnCEI.cjs';
+import '../column/index.cjs';
+import '../table/constants.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import '../column/types.cjs';

package/dist/cjs/query/contract.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/cjs/query/helper.d.cts

@@ -0,0 +1,8 @@
+export { H as aggregateCol, z as alias, B as clone, G as col, F as rawCol } from '../index-CnQVnCEI.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import 'bun';
+import '../table/constants.cjs';
+import '../column/types.cjs';

package/dist/cjs/query/helper.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var _ = require('.');
+var utilities = require('../utilities');
+
+function alias(alias2) {
+  this.definition.baseAlias = alias2;
+  return this;
+}
+function clone() {
+  const query = new _.QueryBuilder(this.table);
+  Object.assign(query.definition, utilities.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
+  };
+}
+
+exports.aggregateCol = aggregateCol;
+exports.alias = alias;
+exports.clone = clone;
+exports.col = col;
+exports.rawCol = rawCol;

package/dist/cjs/query/index.d.cts

@@ -0,0 +1,8 @@
+import '../column/index.cjs';
+export { f as QueryBuilder } from '../index-CnQVnCEI.cjs';
+import './constants.cjs';
+import '../table/constants.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+import 'bun';

package/dist/cjs/query/index.js

@@ -0,0 +1,206 @@
+'use strict';
+
+var utilities = require('../utilities');
+var condition = require('./condition');
+var constants = require('./constants');
+var helper = require('./helper');
+var join = require('./join');
+var sql = require('./sql');
+var utilities$1 = require('./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 = helper.alias.bind(this);
+    this.clone = helper.clone.bind(this);
+    this.toQuery = sql.toQuery.bind(this);
+    this.toString = sql.toString.bind(this);
+    this.exec = sql.exec.bind(this);
+    this.rawWhere = condition.rawWhere.bind(this);
+    this.rawHaving = condition.rawHaving.bind(this);
+    this.rawAnd = this.rawWhere;
+    this.rawOr = condition.rawOr.bind(this);
+    this.where = condition.where.bind(this);
+    this.having = condition.having.bind(this);
+    this.and = this.where;
+    this.or = condition.or.bind(this);
+  }
+  leftJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return join.addJoin(
+      this,
+      constants.AcceptedJoin.LEFT,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  rightJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return join.addJoin(
+      this,
+      constants.AcceptedJoin.RIGHT,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  innerJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return join.addJoin(
+      this,
+      constants.AcceptedJoin.INNER,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  naturalJoin(joinTable, alias2, baseColumn, joinColumn) {
+    return join.addJoin(
+      this,
+      constants.AcceptedJoin.NATURAL,
+      alias2,
+      joinTable,
+      baseColumn,
+      joinColumn
+    );
+  }
+  distinct() {
+    this.definition.distinct = true;
+    return this;
+  }
+  aggregate(...aggregates) {
+    this.definition.aggregates = aggregates.map(
+      (aggregate) => aggregate(helper.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}.${utilities.quoteIdentifier(colName)}`
+      );
+    } else {
+      columns = columns.map((column) => {
+        if (typeof column === "function") {
+          return column(helper.col);
+        }
+        return column;
+      });
+    }
+    this.definition.select = columns;
+    this.definition.queryType = constants.QueryType.SELECT;
+    return this;
+  }
+  insert(...values) {
+    this.definition.queryType = constants.QueryType.INSERT;
+    if (!this.definition.insertValues) this.definition.insertValues = [];
+    const {
+      isWithTimestamp,
+      isHasCreatedAt,
+      isHasUpdatedAt,
+      createdAt,
+      updatedAt,
+      timestamp
+    } = utilities$1.getTimestamp(this.table);
+    if (isWithTimestamp) {
+      values = values.map((row) => ({
+        ...row,
+        ...isHasCreatedAt && {
+          [createdAt]: row[createdAt] ?? timestamp
+        },
+        ...isHasUpdatedAt && {
+          [updatedAt]: row[updatedAt] ?? timestamp
+        }
+      }));
+    }
+    this.definition.insertValues = values;
+    return this;
+  }
+  update(values) {
+    const { isWithTimestamp, isHasUpdatedAt, updatedAt, timestamp } = utilities$1.getTimestamp(this.table);
+    if (isWithTimestamp && isHasUpdatedAt) {
+      values = {
+        ...values,
+        [updatedAt]: values[updatedAt] ?? timestamp
+      };
+    }
+    this.definition.queryType = constants.QueryType.UPDATE;
+    this.definition.updateValues = values;
+    return this;
+  }
+  delete() {
+    const { isWithParanoid, deletedAt, timestamp } = utilities$1.getParanoid(this.table);
+    if (isWithParanoid) {
+      return this.update({
+        [deletedAt]: timestamp
+      });
+    }
+    this.definition.queryType = constants.QueryType.DELETE;
+    return this;
+  }
+  infer() {
+    return null;
+  }
+}
+
+exports.QueryBuilder = QueryBuilder;

package/dist/cjs/query/join.d.cts

@@ -0,0 +1,17 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-CnQVnCEI.cjs';
+import { Column } from '../column/index.cjs';
+import { AcceptedJoin } from './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import 'bun';
+import '../table/constants.cjs';
+import '../column/types.cjs';
+
+declare function addJoin<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>, JoinType extends AcceptedJoin, JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, BaseColName extends `${Alias}."${keyof TableRef['columns'] & string}"`, JoinColName extends `${JoinAlias}."${keyof JoinTable['columns'] & string}"`, FinalJoinedTables extends JoinedTables & {
+    [K in JoinAlias]: JoinTable;
+}>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, joinType: JoinType, alias: JoinAlias, joinTable: JoinTable, baseColumn: BaseColName, joinColumn: JoinColName): QueryBuilder<Alias, TableRef, FinalJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
+    joins: string[];
+    joinedTables: FinalJoinedTables;
+}>;
+
+export { addJoin };

package/dist/cjs/query/join.js

@@ -0,0 +1,18 @@
+'use strict';
+
+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;
+}
+
+exports.addJoin = addJoin;