@ignisia/sql 0.3.0 → 0.4.0

package/dist/esm/query/condition/common.js

@@ -0,0 +1,56 @@
+import { ConditionClause, LogicalOperator } from '../constants.js';
+import { addCondition, addGroupCondition } from './core.js';
+
+// src/query/condition/common.ts
+function where(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    LogicalOperator.AND,
+    false
+  );
+}
+function or(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    LogicalOperator.OR,
+    false
+  );
+}
+function on(columnA, operator, columnB) {
+  return addCondition(
+    this,
+    ConditionClause.WHERE,
+    columnA,
+    operator,
+    columnB,
+    LogicalOperator.ON,
+    false
+  );
+}
+function having(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    LogicalOperator.AND,
+    false
+  );
+}
+function whereGroup(callback) {
+  return addGroupCondition(this, LogicalOperator.AND, callback, false);
+}
+function orGroup(callback) {
+  return addGroupCondition(this, LogicalOperator.OR, callback, false);
+}
+
+export { having, on, or, orGroup, where, whereGroup };

package/dist/esm/query/condition/core.d.ts

@@ -0,0 +1,8 @@
+export { a as addCondition, b as addGroupCondition } from '../../index-CjurLJdK.js';
+import '../../column/index.js';
+import '../constants.js';
+import 'bun';
+import '../../types.js';
+import '../../column/constants.js';
+import '../../table/constants.js';
+import '../../column/types.js';

package/dist/esm/query/condition/core.js

@@ -0,0 +1,55 @@
+import { QueryBuilder } from '../index.js';
+import { LogicalOperator, AcceptedOperator } from '../constants.js';
+import { getCondition } from '../utilities.js';
+
+// src/query/condition/core.ts
+function addCondition(query, clause, column, operator, value, logical, negate) {
+  if (!query.table.dialect) {
+    throw new Error("No DB Dialect defined");
+  }
+  const isOn = logical === LogicalOperator.ON;
+  const validClause = clause.toLowerCase();
+  let condition = getCondition(query.table.dialect, column, operator, value);
+  if (isOn) {
+    condition = condition.replace("?", value);
+  }
+  if (!query.definition[validClause]) query.definition[validClause] = [];
+  const logicalPrefix = query.definition[validClause].length > 0 ? isOn ? LogicalOperator.AND : logical : "";
+  const not = negate ? "NOT " : "";
+  query.definition[validClause].push(
+    `${logicalPrefix} ${not}${condition}`.trim()
+  );
+  if (operator === AcceptedOperator.IS_NULL || operator === AcceptedOperator.IS_NOT_NULL) {
+    return query;
+  }
+  if (!query.definition.params) query.definition.params = [];
+  if (!isOn) {
+    if (operator === AcceptedOperator.STARTS_WITH) {
+      query.definition.params.push(`${value}%`);
+    } else if (operator === AcceptedOperator.ENDS_WITH) {
+      query.definition.params.push(`%${value}`);
+    } else if (Array.isArray(value)) {
+      query.definition.params.push(...value);
+    } else {
+      query.definition.params.push(value);
+    }
+  }
+  return query;
+}
+function addGroupCondition(query, logical, callback, negate) {
+  const sub = callback(new QueryBuilder(query.table));
+  const subDef = sub.definition;
+  if (!subDef.where?.length) return query;
+  const not = negate ? "NOT " : "";
+  const grouped = `${not}(${subDef.where.join(" ")})`;
+  if (!query.definition.where) query.definition.where = [];
+  const logicalPrefix = query.definition.where.length > 0 ? logical : "";
+  query.definition.where.push(`${logicalPrefix} ${grouped}`.trim());
+  if (subDef.params?.length) {
+    if (!query.definition.params) query.definition.params = [];
+    query.definition.params.push(...subDef.params);
+  }
+  return query;
+}
+
+export { addCondition, addGroupCondition };

package/dist/esm/query/condition/index.d.ts

@@ -0,0 +1,10 @@
+export { having, on, or, orGroup, where, whereGroup } from './common.js';
+export { a as addCondition, b as addGroupCondition, c as addRawCondition, e as rawHaving, d as rawOr, r as rawWhere } from '../../index-CjurLJdK.js';
+export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup } from './not.js';
+import '../../column/index.js';
+import '../../table/constants.js';
+import '../../column/constants.js';
+import '../../column/types.js';
+import '../constants.js';
+import 'bun';
+import '../../types.js';

package/dist/esm/query/condition/index.js

@@ -0,0 +1,4 @@
+export * from './common.js';
+export * from './core.js';
+export * from './not.js';
+export * from './raw.js';

package/dist/esm/query/condition/not.d.ts

@@ -0,0 +1,34 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, W as WhereValue, l as QueryBuilder, n as QueryTransformerContract, o as QueryConditionContract } from '../../index-CjurLJdK.js';
+import { Column } from '../../column/index.js';
+import { AcceptedOperator } from '../constants.js';
+import 'bun';
+import '../../types.js';
+import '../../column/constants.js';
+import '../../table/constants.js';
+import '../../column/types.js';
+
+declare function whereNot<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function havingNot<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function orNot<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function whereNotGroup<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>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+declare function orNotGroup<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>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+
+export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup };

package/dist/esm/query/condition/not.js

@@ -0,0 +1,46 @@
+import '../index.js';
+import { ConditionClause, LogicalOperator } from '../constants.js';
+import { addCondition, addGroupCondition } from './core.js';
+
+// src/query/condition/not.ts
+function whereNot(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    LogicalOperator.AND,
+    true
+  );
+}
+function havingNot(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    LogicalOperator.AND,
+    true
+  );
+}
+function orNot(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    LogicalOperator.OR,
+    true
+  );
+}
+function whereNotGroup(callback) {
+  return addGroupCondition(this, LogicalOperator.AND, callback, true);
+}
+function orNotGroup(callback) {
+  return addGroupCondition(this, LogicalOperator.OR, callback, true);
+}
+
+export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup };

package/dist/esm/query/condition/raw.d.ts

@@ -0,0 +1,8 @@
+export { c as addRawCondition, e as rawHaving, d as rawOr, r as rawWhere } from '../../index-CjurLJdK.js';
+import '../../column/index.js';
+import '../constants.js';
+import 'bun';
+import '../../types.js';
+import '../../column/constants.js';
+import '../../table/constants.js';
+import '../../column/types.js';

package/dist/esm/query/condition/raw.js

@@ -0,0 +1,50 @@
+import { LogicalOperator, ConditionClause } from '../constants.js';
+import { rawCol } from '../helper.js';
+
+// src/query/condition/raw.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
+  );
+}
+
+export { addRawCondition, rawHaving, rawOr, rawWhere };

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

@@ -1,6 +1,7 @@
 declare const LogicalOperator: {
     readonly AND: "AND";
     readonly OR: "OR";
+    readonly ON: "ON";
 };
 type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
 declare const ConditionClause: {
@@ -25,6 +26,12 @@ declare const AcceptedOperator: {
     readonly IS_NOT_NULL: "isNotNull";
     readonly BETWEEN: "between";
     readonly NOT_BETWEEN: "notBetween";
+    readonly STARTS_WITH: "startsWith";
+    readonly ENDS_WITH: "endsWith";
+    readonly REG_EXP: "regExp";
+    readonly NOT_REG_EXP: "notRegExp";
+    readonly RLIKE: "rlike";
+    readonly NOT_RLIKE: "notRlike";
 };
 type AcceptedOperator = (typeof AcceptedOperator)[keyof typeof AcceptedOperator];
 declare const QueryType: {
@@ -51,6 +58,8 @@ declare const AcceptedJoin: {
     readonly INNER: "INNER";
     readonly LEFT: "LEFT";
     readonly RIGHT: "RIGHT";
+    readonly FULL: "FULL OUTER";
+    readonly CROSS: "CROSS";
     readonly NATURAL: "NATURAL";
 };
 type AcceptedJoin = (typeof AcceptedJoin)[keyof typeof AcceptedJoin];
@@ -59,5 +68,22 @@ declare const QueryHooksType: {
     readonly BEFORE: "before";
 };
 type QueryHooksType = (typeof QueryHooksType)[keyof typeof QueryHooksType];
+declare const ExplainFormat: {
+    readonly JSON: "JSON";
+    readonly TEXT: "TEXT";
+    readonly YAML: "YAML";
+    readonly XML: "XML";
+};
+type ExplainFormat = (typeof ExplainFormat)[keyof typeof ExplainFormat];
+declare const ExplainClause: {
+    readonly FORMAT: "FORMAT";
+    readonly ANALYZE: "ANALYZE";
+    readonly VERBOSE: "VERBOSE";
+    readonly COSTS: "COSTS";
+    readonly BUFFERS: "BUFFERS";
+    readonly SUMMARY: "SUMMARY";
+    readonly TIMING: "TIMING";
+};
+type ExplainClause = (typeof ExplainClause)[keyof typeof ExplainClause];
 
-export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, ExplainClause, ExplainFormat, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/esm/query/constants.js

@@ -1,7 +1,8 @@
 // src/query/constants.ts
 var LogicalOperator = {
   AND: "AND",
-  OR: "OR"
+  OR: "OR",
+  ON: "ON"
 };
 var ConditionClause = {
   WHERE: "WHERE",
@@ -23,7 +24,13 @@ var AcceptedOperator = {
   IS_NULL: "isNull",
   IS_NOT_NULL: "isNotNull",
   BETWEEN: "between",
-  NOT_BETWEEN: "notBetween"
+  NOT_BETWEEN: "notBetween",
+  STARTS_WITH: "startsWith",
+  ENDS_WITH: "endsWith",
+  REG_EXP: "regExp",
+  NOT_REG_EXP: "notRegExp",
+  RLIKE: "rlike",
+  NOT_RLIKE: "notRlike"
 };
 var QueryType = {
   SELECT: "SELECT",
@@ -46,11 +53,28 @@ var AcceptedJoin = {
   INNER: "INNER",
   LEFT: "LEFT",
   RIGHT: "RIGHT",
+  FULL: "FULL OUTER",
+  CROSS: "CROSS",
   NATURAL: "NATURAL"
 };
 var QueryHooksType = {
   AFTER: "after",
   BEFORE: "before"
 };
+var ExplainFormat = {
+  JSON: "JSON",
+  TEXT: "TEXT",
+  YAML: "YAML",
+  XML: "XML"
+};
+var ExplainClause = {
+  FORMAT: "FORMAT",
+  ANALYZE: "ANALYZE",
+  VERBOSE: "VERBOSE",
+  COSTS: "COSTS",
+  BUFFERS: "BUFFERS",
+  SUMMARY: "SUMMARY",
+  TIMING: "TIMING"
+};
 
-export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, ExplainClause, ExplainFormat, LogicalOperator, OrderBy, QueryHooksType, QueryType };

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

@@ -1,8 +1,8 @@
 import 'bun';
-export { Y as QueryConditionContract, X as QueryTransformerContract } from '../index-BdpoD4zk.js';
+export { o as QueryConditionContract, n as QueryTransformerContract } from '../index-CjurLJdK.js';
 import '../column/index.js';
 import '../table/constants.js';
 import './constants.js';
-import '../column/constants.js';
 import '../types.js';
+import '../column/constants.js';
 import '../column/types.js';

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

@@ -0,0 +1,12 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, E as ExplainOptions } from '../index-CjurLJdK.js';
+import { Column } from '../column/index.js';
+import 'bun';
+import '../types.js';
+import './constants.js';
+import '../column/constants.js';
+import '../table/constants.js';
+import '../column/types.js';
+
+declare function buildExplainQuery<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>, options: Partial<ExplainOptions>): string;
+
+export { buildExplainQuery };

package/dist/esm/query/explain.js

@@ -0,0 +1,64 @@
+import { Dialect } from '../table/constants.js';
+import { ExplainClause } from './constants.js';
+
+// src/query/explain.ts
+function buildPostgresExplainQuery(options) {
+  const clauses = [];
+  if (options?.format) {
+    clauses.push(`${ExplainClause.FORMAT} ${options.format}`);
+  }
+  if (options?.analyze) {
+    clauses.push(ExplainClause.ANALYZE);
+    if (options?.summary != null) {
+      clauses.push(
+        `${ExplainClause.SUMMARY} ${options.summary ? "ON" : "OFF"}`
+      );
+    }
+    if (options?.timing != null)
+      clauses.push(`${ExplainClause.TIMING} ${options.timing ? "ON" : "OFF"}`);
+  }
+  if (options?.verbose) {
+    clauses.push(`${ExplainClause.VERBOSE} ${options.verbose ? "ON" : "OFF"}`);
+  }
+  if (options?.costs != null) {
+    clauses.push(`${ExplainClause.COSTS} ${options.costs ? "ON" : "OFF"}`);
+  }
+  if (options?.buffers != null) {
+    clauses.push(`${ExplainClause.BUFFERS} ${options.buffers ? "ON" : "OFF"}`);
+  }
+  if (clauses.length === 0) {
+    return "EXPLAIN ";
+  }
+  return `EXPLAIN (${clauses.join(", ")})`;
+}
+function buildMySqlExplainQuery(options) {
+  const clauses = [];
+  if (options.analyze) {
+    clauses.push(ExplainClause.ANALYZE);
+  }
+  if (options.format) {
+    clauses.push(`${ExplainClause.FORMAT}=${options.format}`);
+  }
+  if (clauses.length > 1) {
+    throw new Error("Only one explain clause is allowed");
+  }
+  return `EXPLAIN ${clauses.join(" ")}`;
+}
+function buildSqliteExplainQuery() {
+  const clauses = ["QUERY PLAN"];
+  return `EXPLAIN ${clauses.join(" ")}`;
+}
+function buildExplainQuery(q, options) {
+  switch (q.table.dialect) {
+    case Dialect.POSTGRES:
+      return buildPostgresExplainQuery(options);
+    case Dialect.MYSQL:
+      return buildMySqlExplainQuery(options);
+    case Dialect.SQLITE:
+      return buildSqliteExplainQuery();
+    default:
+      throw new Error(`Dialect ${q.table.dialect} is not supported`);
+  }
+}
+
+export { buildExplainQuery };

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

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

package/dist/esm/query/helper.js

@@ -1,5 +1,5 @@
 import { QueryBuilder } from './index.js';
-import { deepClone } from '../utilities.js';
+import { cloneDefinition } from '../utilities.js';
 
 // src/query/helper.ts
 function alias(alias2) {
@@ -8,7 +8,7 @@ function alias(alias2) {
 }
 function clone() {
   const query = new QueryBuilder(this.table);
-  Object.assign(query.definition, deepClone(this.definition));
+  Object.assign(query.definition, cloneDefinition(this.definition));
   return query;
 }
 function rawCol(column) {

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

@@ -1,8 +1,8 @@
 import '../column/index.js';
-export { f as QueryBuilder } from '../index-BdpoD4zk.js';
+export { l as QueryBuilder } from '../index-CjurLJdK.js';
+import '../types.js';
 import './constants.js';
 import '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';
-import '../types.js';
 import 'bun';