@ignisia/sql 0.2.1 → 0.2.2

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,7 @@
+export { H as addCondition, B as addRawCondition, K as having, J as or, G as rawHaving, F as rawOr, E as rawWhere, I as where } from '../index-CwiFQh0I.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import '../table/constants.cjs';
+import '../column/types.cjs';

package/dist/cjs/query/condition.js

@@ -0,0 +1,106 @@
+'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) {
+  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,
+    constants.LogicalOperator.AND
+  );
+}
+function or(column, operator, value) {
+  return addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value,
+    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,7 @@
+export { N as QueryConditionContract, L as QueryTransformerContract } from '../index-CwiFQh0I.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import '../table/constants.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,7 @@
+export { z as aggregateCol, v as alias, w as clone, y as col, x as rawCol } from '../index-CwiFQh0I.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+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,7 @@
+import '../column/index.cjs';
+export { d as QueryBuilder } from '../index-CwiFQh0I.cjs';
+import './constants.cjs';
+import '../table/constants.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';

package/dist/cjs/query/index.js

@@ -0,0 +1,197 @@
+'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, createdAt, updatedAt, timestamp } = utilities$1.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 } = utilities$1.getTimestamp(this.table);
+    if (isWithTimestamp) {
+      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,16 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-CwiFQh0I.cjs';
+import { Column } from '../column/index.cjs';
+import { AcceptedJoin } from './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+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;

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

@@ -0,0 +1,17 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-CwiFQh0I.cjs';
+import { Column } from '../column/index.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import './constants.cjs';
+import '../table/constants.cjs';
+import '../column/types.cjs';
+
+declare function buildQuery(query: string): string;
+declare function toQuery<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>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): {
+    query: string;
+    params: unknown[] | null | undefined;
+};
+declare function toString<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>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): string;
+declare function exec<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>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, Output extends Query['_output'] = Query['_output']>(this: Query): Promise<Output>;
+
+export { buildQuery, exec, toQuery, toString };

package/dist/cjs/query/sql.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var builder = require('./builder');
+var constants = require('./constants');
+var utilities = require('./utilities');
+
+function buildQuery(query) {
+  let index = 0;
+  return query.replace(/\?/g, () => {
+    index++;
+    return `$${index}`;
+  });
+}
+function toQuery() {
+  let sql = "";
+  switch (this.definition.queryType) {
+    case constants.QueryType.SELECT:
+      sql = builder.buildSelectQuery(this);
+      break;
+    case constants.QueryType.INSERT:
+      sql = builder.buildInsertQuery(this);
+      break;
+    case constants.QueryType.UPDATE:
+      sql = builder.buildUpdateQuery(this);
+      break;
+    case constants.QueryType.DELETE:
+      sql = builder.buildDeleteQuery(this);
+      break;
+    default:
+      throw new Error("No query type defined");
+  }
+  if (this.definition?.joins?.length) {
+    sql += ` ${this.definition.joins.join(" ")}`;
+  }
+  const whereConditions = utilities.getWhereConditions(this);
+  if (whereConditions.length) {
+    sql += ` WHERE ${whereConditions.join(" ")}`;
+  }
+  const groupByConditions = utilities.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 === constants.QueryType.UPDATE || this.definition.queryType === constants.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: constants.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: constants.QueryHooksType.AFTER
+      });
+    }
+  }
+  return result.map(
+    (r) => utilities.parseAliasedRow({
+      row: r,
+      selects: this.definition.select ?? [],
+      root: this.definition?.baseAlias ?? this.table.name
+    })
+  );
+}
+
+exports.buildQuery = buildQuery;
+exports.exec = exec;
+exports.toQuery = toQuery;
+exports.toString = toString;

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

@@ -0,0 +1,7 @@
+import '../column/index.cjs';
+import '../column/constants.cjs';
+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-CwiFQh0I.cjs';
+import '../types.cjs';
+import './constants.cjs';
+import '../table/constants.cjs';
+import '../column/types.cjs';

package/dist/cjs/query/types.js

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