@ignisia/sql 0.2.1 → 0.3.0

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

@@ -0,0 +1,18 @@
+import { TransactionSQL } from 'bun';
+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 { Dialect } from '../table/constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import './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, dialect?: Dialect | null): {
+    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, tx?: TransactionSQL | null): Promise<Output>;
+
+export { buildQuery, exec, toQuery, toString };

package/dist/cjs/query/sql.js

@@ -0,0 +1,132 @@
+'use strict';
+
+var constants$1 = require('../table/constants');
+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(dialect) {
+  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) {
+    if (dialect !== constants$1.Dialect.MYSQL) {
+      sql += ` RETURNING *`;
+    }
+  }
+  sql = buildQuery(sql);
+  return { query: sql + ";", params: this.definition.params };
+}
+function toString() {
+  return this.toQuery().query;
+}
+async function exec(tx) {
+  const client = this.table.client;
+  const dialect = this.table.dialect;
+  const queryType = this.definition.queryType;
+  const isUpdate = queryType === constants.QueryType.UPDATE;
+  const isDelete = queryType === constants.QueryType.DELETE;
+  const isReturning = isUpdate || isDelete;
+  const isMySQL = dialect === constants$1.Dialect.MYSQL;
+  if (!client) {
+    throw new Error("Database client not defined");
+  }
+  if (!queryType) {
+    throw new Error("No query type defined");
+  }
+  const { query, params } = this.toQuery(dialect);
+  if (this.hooks?.before?.size) {
+    for (const hook of this.hooks.before.values()) {
+      hook({
+        query,
+        params,
+        type: queryType,
+        hook: constants.QueryHooksType.BEFORE
+      });
+    }
+  }
+  let result = await client.exec({
+    sql: query,
+    params,
+    tx
+  });
+  if (isMySQL && isReturning) {
+    const query2 = this.clone();
+    query2.definition.queryType = constants.QueryType.SELECT;
+    result = await client.exec({
+      sql: query2.toQuery().query,
+      params,
+      tx
+    });
+  }
+  if (this.hooks?.after?.size) {
+    for (const hook of this.hooks.after.values()) {
+      hook({
+        query,
+        params,
+        type: 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,8 @@
+import '../column/index.cjs';
+import '../column/constants.cjs';
+export { l as AcceptedInsertValues, k as AcceptedOrderBy, m as AcceptedUpdateValues, n as AggregateColumn, A as AliasedColumn, C as ColumnSelector, h as QuerHooks, Q as QueryDefinition, p as QueryOutput, j as QueryRunHooks, q as QueryRunHooksOptions, R as RawColumn, o as SelectQueryOutput, g as SelectableColumn, e as StrictColumnSelector, W as WhereValue } from '../index-CnQVnCEI.cjs';
+import '../types.cjs';
+import './constants.cjs';
+import '../table/constants.cjs';
+import '../column/types.cjs';
+import 'bun';

package/dist/cjs/query/types.js

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

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

@@ -0,0 +1,37 @@
+import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder, A as AliasedColumn, g as SelectableColumn } from '../index-CnQVnCEI.cjs';
+import { Column } from '../column/index.cjs';
+import { Dialect } from '../table/constants.cjs';
+import { AcceptedOperator } from './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import 'bun';
+import '../column/types.cjs';
+
+declare function getTableColumnNames<ColName extends string, BaseAlias extends string, BaseTable extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>>(column: ColName, baseAlias: BaseAlias, baseTable: BaseTable, joinedTables: JoinedTables): {
+    from: string;
+    columns: string[];
+};
+declare function getCondition<DbDialect extends Dialect, ColName extends string, Operator extends AcceptedOperator, Value extends WhereValue<Column>[Operator]>(dialect: DbDialect, column: ColName, operator: Operator, value: Value): string;
+declare function getTimestamp<TableRef extends Table<string, Record<string, Column>>>(table: TableRef): {
+    isWithTimestamp: boolean;
+    timestamp: Date;
+    createdAt: string;
+    updatedAt: string;
+    isHasUpdatedAt: boolean;
+    isHasCreatedAt: boolean;
+};
+declare function getParanoid<TableRef extends Table<string, Record<string, Column>>>(table: TableRef): {
+    isWithParanoid: boolean;
+    timestamp: Date;
+    deletedAt: string;
+};
+declare function getWhereConditions<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>>(q: Query): string[];
+declare function getGroupByConditions<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>>(q: Query): (string | AliasedColumn<ColumnSelector<Alias, TableRef, JoinedTables>, string>)[];
+declare function getTableSelectName<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>>(q: Query): string;
+declare function parseAliasedRow({ row, selects, root, }: {
+    row: Record<string, unknown>;
+    selects: SelectableColumn<string>[];
+    root?: string | null;
+}): Record<string, any>;
+
+export { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow };

package/dist/cjs/query/utilities.js

@@ -0,0 +1,194 @@
+'use strict';
+
+require('.');
+var constants$1 = require('../table/constants');
+var utilities = require('../utilities');
+var constants = require('./constants');
+
+function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
+  const [tableAlias] = column.split(".");
+  const isOnBase = tableAlias === baseAlias;
+  const from = isOnBase ? baseAlias : tableAlias;
+  const columns = isOnBase ? Object.keys(baseTable.columns) : Object.keys(joinedTables?.[from]?.columns ?? {});
+  return {
+    from,
+    columns
+  };
+}
+function getCondition(dialect, column, operator, value) {
+  switch (operator) {
+    case constants.AcceptedOperator.EQ:
+      return `${column} = ?`;
+    case constants.AcceptedOperator.NE:
+      return `${column} != ?`;
+    case constants.AcceptedOperator.GT:
+      return `${column} > ?`;
+    case constants.AcceptedOperator.LT:
+      return `${column} < ?`;
+    case constants.AcceptedOperator.GTE:
+      return `${column} >= ?`;
+    case constants.AcceptedOperator.LTE:
+      return `${column} <= ?`;
+    case constants.AcceptedOperator.IN:
+      return `${column} IN (${value.map(() => "?").join(", ")})`;
+    case constants.AcceptedOperator.NOT_IN:
+      return `${column} NOT IN (${value.map(() => "?").join(", ")})`;
+    case constants.AcceptedOperator.LIKE:
+      return `${column} LIKE ?`;
+    case constants.AcceptedOperator.NOT_LIKE:
+      return `${column} NOT LIKE ?`;
+    case constants.AcceptedOperator.ILIKE:
+      if (dialect === constants$1.Dialect.POSTGRES) {
+        return `${column} ILIKE ?`;
+      }
+      return `LOWER(${column}) LIKE LOWER(?)`;
+    case constants.AcceptedOperator.NOT_ILIKE:
+      if (dialect === constants$1.Dialect.POSTGRES) {
+        return `${column} NOT ILIKE ?`;
+      }
+      return `LOWER(${column}) NOT LIKE LOWER(?)`;
+    case constants.AcceptedOperator.IS_NULL:
+      return `${column} IS NULL`;
+    case constants.AcceptedOperator.IS_NOT_NULL:
+      return `${column} IS NOT NULL`;
+    case constants.AcceptedOperator.BETWEEN:
+      return `${column} BETWEEN ? AND ?`;
+    case constants.AcceptedOperator.NOT_BETWEEN:
+      return `${column} NOT BETWEEN ? AND ?`;
+    default:
+      throw new Error("Invalid operator");
+  }
+}
+function getTimestamp(table) {
+  const isWithTimestamp = !!table.timestamp;
+  const timestamp = /* @__PURE__ */ new Date();
+  let isHasCreatedAt = true;
+  let isHasUpdatedAt = true;
+  let createdAt = "createdAt";
+  let updatedAt = "updatedAt";
+  if (isWithTimestamp) {
+    const isCustomTimestamp = typeof table.timestamp === "object";
+    if (isCustomTimestamp) {
+      if (typeof table.timestamp.createdAt === "string") {
+        createdAt = table.timestamp.createdAt;
+      }
+      isHasCreatedAt = table.timestamp.createdAt === false;
+    }
+    if (isCustomTimestamp) {
+      if (typeof table.timestamp.updatedAt === "string") {
+        updatedAt = table.timestamp.updatedAt;
+      }
+      isHasUpdatedAt = table.timestamp.updatedAt === false;
+    }
+  }
+  return {
+    isWithTimestamp,
+    timestamp,
+    createdAt,
+    updatedAt,
+    isHasUpdatedAt,
+    isHasCreatedAt
+  };
+}
+function getParanoid(table) {
+  const isWithParanoid = !!table.paranoid;
+  const timestamp = /* @__PURE__ */ new Date();
+  let deletedAt = "deletedAt";
+  if (isWithParanoid) {
+    if (typeof table.paranoid === "string") {
+      deletedAt = table.paranoid;
+    }
+  }
+  return {
+    isWithParanoid,
+    timestamp,
+    deletedAt
+  };
+}
+function getWhereConditions(q) {
+  if (q.definition.queryType === constants.QueryType.INSERT) return [];
+  const conditions = [];
+  const base = q.definition.baseAlias ?? q.table.name;
+  const { isWithParanoid, deletedAt } = getParanoid(q.table);
+  const withDeleted = !!q.definition.withDeleted;
+  const isHasConditions = !!q.definition.where?.length;
+  if (!withDeleted && isWithParanoid) {
+    const suffix = isHasConditions ? " AND" : "";
+    const column = `${base}.${utilities.quoteIdentifier(deletedAt)}`;
+    conditions.unshift(`${column} IS NULL${suffix}`);
+  }
+  if (q.definition.where?.length) {
+    conditions.push(...q.definition.where);
+  }
+  return conditions;
+}
+function getGroupByConditions(q) {
+  if (q.definition.queryType !== constants.QueryType.SELECT) return [];
+  if (q.definition.groupBy?.length) return q.definition.groupBy;
+  if (q.definition.aggregates?.length) {
+    if (q.definition.select?.length)
+      return q.definition.select.map((col) => {
+        if (typeof col === "string" && col.endsWith("*")) {
+          const { from: from2, columns } = getTableColumnNames(
+            col,
+            q.definition.baseAlias ?? q.table.name,
+            q.table,
+            q.definition.joinedTables ?? {}
+          );
+          return columns.map((column) => `${from2}.${utilities.quoteIdentifier(column)}`).join(" ");
+        }
+        return col;
+      });
+    const from = q.definition.baseAlias ?? q.table.name;
+    return Object.keys(q.table.columns).map(
+      (col) => `${from}.${utilities.quoteIdentifier(col)}`
+    );
+  }
+  return [];
+}
+function getTableSelectName(q) {
+  if (!q.definition.baseAlias) return q.table.name;
+  return `${q.table.name} AS ${q.definition.baseAlias}`;
+}
+function parseAliasedRow({
+  row,
+  selects,
+  root = null
+}) {
+  let result = {};
+  for (const key in row) {
+    const [table, column] = key.split(".");
+    if (!column) {
+      const alias = selects.find(
+        (s) => typeof s === "object" && s.as === table
+      );
+      if (alias) {
+        const [oriTab] = alias.column.split(".");
+        if (!result[oriTab]) result[oriTab] = {};
+        result[oriTab][table] = row[key];
+        continue;
+      }
+      result[key] = row[key];
+      continue;
+    }
+    if (!result[table]) result[table] = {};
+    result[table][column] = row[key];
+  }
+  if (root) {
+    result = {
+      ...result,
+      ...result[root]
+    };
+    delete result[root];
+  }
+  return result;
+}
+
+exports.getCondition = getCondition;
+exports.getGroupByConditions = getGroupByConditions;
+exports.getParanoid = getParanoid;
+exports.getTableColumnNames = getTableColumnNames;
+exports.getTableSelectName = getTableSelectName;
+exports.getTimestamp = getTimestamp;
+exports.getWhereConditions = getWhereConditions;
+exports.parseAliasedRow = parseAliasedRow;

package/dist/cjs/table/constants.d.cts

@@ -0,0 +1,8 @@
+declare const Dialect: {
+    readonly POSTGRES: "postgres";
+    readonly MYSQL: "mysql";
+    readonly SQLITE: "sqlite";
+};
+type Dialect = (typeof Dialect)[keyof typeof Dialect];
+
+export { Dialect };

package/dist/cjs/table/constants.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const Dialect = {
+  POSTGRES: "postgres",
+  MYSQL: "mysql",
+  SQLITE: "sqlite"
+};
+
+exports.Dialect = Dialect;

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

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

package/dist/cjs/table/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var query = require('../query');
+var utilities = require('./utilities');
+
+class Table {
+  client;
+  _dialect;
+  name;
+  columns;
+  timestamp;
+  paranoid;
+  _output;
+  constructor(options) {
+    this._dialect = options.dialect || null;
+    this.name = options.name;
+    this.columns = options.columns;
+    this.paranoid = options.paranoid || null;
+    this.timestamp = options.timestamp || null;
+    this.client = null;
+    if (!this._dialect) return;
+    this.setColumnDialect(this._dialect);
+  }
+  infer() {
+    return null;
+  }
+  static define(options) {
+    const columns = utilities.defineColumns(options);
+    return new Table({
+      ...options,
+      columns
+    });
+  }
+  setColumnDialect(dialect) {
+    for (const column of Object.values(this.columns)) {
+      column.dialect(dialect);
+    }
+  }
+  get dialect() {
+    return this._dialect;
+  }
+  setDialect(dialect) {
+    this._dialect = dialect;
+    this.setColumnDialect(dialect);
+    return this;
+  }
+  async create(options = {}) {
+    const db = options.db || this.client;
+    if (!db) throw new Error("Database client not defined");
+    const sql = `CREATE TABLE IF NOT EXISTS ${this.name} (${Object.entries(
+      this.columns
+    ).map(([name, column]) => `${name} ${column.toQuery().query}`).join(", ")});`;
+    await db.exec({
+      sql,
+      tx: options.tx
+    });
+    return this;
+  }
+  async drop(options = {}) {
+    const db = options.db || this.client;
+    if (!db) throw new Error("Database client not defined");
+    const sql = `DROP TABLE IF EXISTS ${this.name};`;
+    await db.exec({
+      sql,
+      tx: options.tx
+    });
+    return this;
+  }
+  query() {
+    return new query.QueryBuilder(this);
+  }
+}
+
+exports.Table = Table;

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

@@ -0,0 +1,8 @@
+import 'bun';
+export { E as ExecOptions, M as MergeTimestampParanoid, x as TableOptions, y as TableOutput, a as TimestampOptions } from '../index-CnQVnCEI.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../types.cjs';
+import '../query/constants.cjs';
+import '../column/types.cjs';

package/dist/cjs/table/types.js

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

package/dist/cjs/table/utilities.d.cts

@@ -0,0 +1,8 @@
+import '../column/constants.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+export { t as createdAt, w as defineColumns, v as deletedAt, u as updatedAt } from '../index-CnQVnCEI.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+import '../query/constants.cjs';
+import 'bun';

package/dist/cjs/table/utilities.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var column = require('../column');
+
+const createdAt = column.Column.define({
+  type: "DATETIME"
+}).default("CURRENT_TIMESTAMP");
+const updatedAt = column.Column.define({
+  type: "DATETIME"
+});
+const deletedAt = column.Column.define({
+  type: "DATETIME"
+});
+function defineColumns(options) {
+  const columns = {
+    ...options.columns
+  };
+  const tracker = {
+    deletedAt: "deletedAt"
+  };
+  if (options.timestamp) {
+    const timestamp = {
+      createdAt: "createdAt",
+      updatedAt: "updatedAt"
+    };
+    if (typeof options.timestamp === "object") {
+      if (typeof options.timestamp.createdAt === "string") {
+        timestamp.createdAt = options.timestamp.createdAt;
+      }
+      if (typeof options.timestamp.updatedAt === "string") {
+        timestamp.updatedAt = options.timestamp.updatedAt;
+      }
+    }
+    if (!columns[timestamp.createdAt]) {
+      columns[timestamp.createdAt] = createdAt;
+    }
+    if (!columns[timestamp.updatedAt]) {
+      columns[timestamp.updatedAt] = updatedAt;
+    }
+  }
+  if (options.paranoid) {
+    if (typeof options.paranoid !== "boolean") {
+      tracker.deletedAt = options.paranoid;
+    }
+    if (!columns[tracker.deletedAt]) {
+      columns[tracker.deletedAt] = deletedAt;
+    }
+  }
+  return columns;
+}
+
+exports.createdAt = createdAt;
+exports.defineColumns = defineColumns;
+exports.deletedAt = deletedAt;
+exports.updatedAt = updatedAt;

package/dist/cjs/types.js

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

package/dist/cjs/utilities.js

@@ -0,0 +1,21 @@
+'use strict';
+
+function deepClone(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj && typeof obj === "object") {
+    const clonedObj = {};
+    for (const key in obj) {
+      clonedObj[key] = deepClone(obj[key]);
+    }
+    return clonedObj;
+  }
+  return obj;
+}
+function quoteIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+exports.deepClone = deepClone;
+exports.quoteIdentifier = quoteIdentifier;