@ignisia/sql 0.2.0 → 0.2.2

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

@@ -0,0 +1,34 @@
+import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder, A as AliasedColumn, e as SelectableColumn } from '../index-CwiFQh0I.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 '../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;
+};
+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,184 @@
+'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 createdAt = "createdAt";
+  let updatedAt = "updatedAt";
+  if (isWithTimestamp) {
+    const isCustomTimestamp = typeof table.timestamp === "object";
+    if (isCustomTimestamp && table.timestamp.createdAt) {
+      createdAt = table.timestamp.createdAt;
+    }
+    if (isCustomTimestamp && table.timestamp.updatedAt) {
+      updatedAt = table.timestamp.updatedAt;
+    }
+  }
+  return {
+    isWithTimestamp,
+    timestamp,
+    createdAt,
+    updatedAt
+  };
+}
+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.js

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

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

@@ -0,0 +1,7 @@
+export { T as Table } from '../index-CwiFQh0I.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/index.js

@@ -0,0 +1,54 @@
+'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;
+    this.name = options.name;
+    this.columns = options.columns;
+    this.paranoid = options.paranoid || null;
+    this.timestamp = options.timestamp || null;
+    this.client = null;
+    for (const column of Object.values(this.columns)) {
+      column.dialect(options.dialect);
+    }
+  }
+  infer() {
+    return null;
+  }
+  static define(options) {
+    const columns = utilities.defineColumns(options);
+    return new Table({
+      ...options,
+      columns
+    });
+  }
+  async create(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);
+    return this;
+  }
+  async drop(db = this.client) {
+    if (!db) throw new Error("Database client not defined");
+    const sql = `DROP TABLE IF EXISTS ${this.name};`;
+    await db.exec(sql);
+    return this;
+  }
+  query() {
+    return new query.QueryBuilder(this);
+  }
+}
+
+exports.Table = Table;

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

@@ -0,0 +1,7 @@
+export { M as MergeTimestampParanoid, s as TableOptions, t as TableOutput, a as TimestampOptions } from '../index-CwiFQh0I.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,7 @@
+import '../column/constants.cjs';
+import '../column/index.cjs';
+import './constants.cjs';
+export { p as createdAt, r as defineColumns, q as deletedAt, u as updatedAt } from '../index-CwiFQh0I.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+import '../query/constants.cjs';

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;

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

@@ -0,0 +1,97 @@
+declare const AcceptedColumnTypes: {
+    readonly INTEGER: "INTEGER";
+    readonly STRING: "STRING";
+    readonly BOOLEAN: "BOOLEAN";
+    readonly DATE: "DATE";
+    readonly FLOAT: "FLOAT";
+    readonly DECIMAL: "DECIMAL";
+    readonly BIGINT: "BIGINT";
+    readonly TEXT: "TEXT";
+    readonly BLOB: "BLOB";
+    readonly JSON: "JSON";
+    readonly VARCHAR: "VARCHAR";
+    readonly TIME: "TIME";
+    readonly TIMESTAMP: "TIMESTAMP";
+    readonly DOUBLE: "DOUBLE";
+    readonly DATETIME: "DATETIME";
+    readonly DATEONLY: "DATEONLY";
+    readonly ENUM: "ENUM";
+    readonly SERIAL: "SERIAL";
+};
+type AcceptedColumnTypes = (typeof AcceptedColumnTypes)[keyof typeof AcceptedColumnTypes];
+declare const ColumnTypeMapping: {
+    readonly INTEGER: {
+        readonly sqlite: "INTEGER";
+        readonly postgres: "INTEGER";
+    };
+    readonly STRING: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "VARCHAR";
+    };
+    readonly BOOLEAN: {
+        readonly sqlite: "INTEGER";
+        readonly postgres: "BOOLEAN";
+    };
+    readonly DATE: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "DATE";
+    };
+    readonly FLOAT: {
+        readonly sqlite: "REAL";
+        readonly postgres: "FLOAT";
+    };
+    readonly DECIMAL: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "DECIMAL";
+    };
+    readonly BIGINT: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "BIGINT";
+    };
+    readonly TEXT: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TEXT";
+    };
+    readonly BLOB: {
+        readonly sqlite: "BLOB";
+        readonly postgres: "BYTEA";
+    };
+    readonly JSON: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "JSONB";
+    };
+    readonly VARCHAR: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "VARCHAR";
+    };
+    readonly TIME: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TIME";
+    };
+    readonly TIMESTAMP: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TIMESTAMP";
+    };
+    readonly DOUBLE: {
+        readonly sqlite: "REAL";
+        readonly postgres: "DOUBLE PRECISION";
+    };
+    readonly DATETIME: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TIMESTAMP";
+    };
+    readonly DATEONLY: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "DATE";
+    };
+    readonly ENUM: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TEXT";
+    };
+    readonly SERIAL: {
+        readonly sqlite: "INTEGER AUTOINCREMENT";
+        readonly postgres: "SERIAL";
+    };
+};
+
+export { AcceptedColumnTypes, ColumnTypeMapping };

package/dist/{chunk-G3LSCLIQ.js → esm/column/constants.js}

@@ -1,6 +1,4 @@
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
+import { Dialect } from '../table/constants.js';
 
 // src/column/constants.ts
 var AcceptedColumnTypes = {
@@ -98,7 +96,4 @@ var ColumnTypeMapping = {
   }
 };
 
-export {
-  AcceptedColumnTypes,
-  ColumnTypeMapping
-};
+export { AcceptedColumnTypes, ColumnTypeMapping };

package/dist/{chunk-GY7R637S.js → esm/column/index.js}

@@ -1,10 +1,5 @@
-import {
-  AcceptedColumnTypes,
-  ColumnTypeMapping
-} from "./chunk-G3LSCLIQ.js";
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
+import { Dialect } from '../table/constants.js';
+import { ColumnTypeMapping, AcceptedColumnTypes } from './constants.js';
 
 // src/column/index.ts
 var Column = class _Column {
@@ -108,6 +103,4 @@ var Column = class _Column {
   }
 };
 
-export {
-  Column
-};
+export { Column };

package/dist/esm/column/types.js

@@ -0,0 +1 @@
+import './constants.js';

package/dist/{chunk-V4OMHVJN.js → esm/database/alter.js}

@@ -1,6 +1,4 @@
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
+import { Dialect } from '../table/constants.js';
 
 // src/database/alter.ts
 async function alterColumnType(tableName, columnName, newType) {
@@ -87,10 +85,4 @@ async function dropColumnNotNull(tableName, columnName) {
   return this;
 }
 
-export {
-  alterColumnType,
-  setColumnDefault,
-  dropColumnDefault,
-  setColumnNotNull,
-  dropColumnNotNull
-};
+export { alterColumnType, dropColumnDefault, dropColumnNotNull, setColumnDefault, setColumnNotNull };

package/dist/{chunk-JF7OSNH4.js → esm/database/column.js}

@@ -1,6 +1,4 @@
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
+import { Dialect } from '../table/constants.js';
 
 // src/database/column.ts
 async function addColumn(tableName, columnName, column) {
@@ -33,8 +31,4 @@ async function dropColumn(tableName, columnName) {
   return this;
 }
 
-export {
-  addColumn,
-  renameColumn,
-  dropColumn
-};
+export { addColumn, dropColumn, renameColumn };

package/dist/esm/database/contract.js

@@ -0,0 +1 @@
+

package/dist/{chunk-UI7U54OT.js → esm/database/index.js}

@@ -1,26 +1,9 @@
-import {
-  DatabasePsql,
-  DatabaseSqlite
-} from "./chunk-HKTHKQLK.js";
-import {
-  addColumn,
-  dropColumn,
-  renameColumn
-} from "./chunk-JF7OSNH4.js";
-import {
-  createTable,
-  dropTable,
-  renameTable
-} from "./chunk-OYM2PNYZ.js";
-import {
-  alterColumnType,
-  dropColumnDefault,
-  dropColumnNotNull,
-  setColumnDefault
-} from "./chunk-V4OMHVJN.js";
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
+import '../table/index.js';
+import { Dialect } from '../table/constants.js';
+import { alterColumnType, setColumnDefault, dropColumnDefault, dropColumnNotNull } from './alter.js';
+import { addColumn, renameColumn, dropColumn } from './column.js';
+import { createTable, renameTable, dropTable } from './table.js';
+import { DatabasePsql, DatabaseSqlite } from './wrapper.js';
 
 // src/database/index.ts
 var Database = class _Database {
@@ -107,6 +90,4 @@ var Database = class _Database {
   }
 };
 
-export {
-  Database
-};
+export { Database };

package/dist/{chunk-OYM2PNYZ.js → esm/database/table.js}

@@ -1,6 +1,4 @@
-import {
-  Table
-} from "./chunk-KVCIOW7L.js";
+import { Table } from '../table/index.js';
 
 // src/database/table.ts
 async function createTable(tableName, columns, options) {
@@ -37,8 +35,4 @@ async function dropTable(tableName) {
   return this;
 }
 
-export {
-  createTable,
-  renameTable,
-  dropTable
-};
+export { createTable, dropTable, renameTable };

package/dist/esm/database/types.js

@@ -0,0 +1 @@
+

package/dist/{chunk-HKTHKQLK.js → esm/database/wrapper.js}

@@ -1,10 +1,8 @@
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
+import { SQL } from 'bun';
+import { Database } from 'bun:sqlite';
+import { Dialect } from '../table/constants.js';
 
 // src/database/wrapper.ts
-import { SQL } from "bun";
-import { Database as Sqlite } from "bun:sqlite";
 var DatabasePsql = class {
   dialect;
   options;
@@ -61,11 +59,11 @@ var DatabaseSqlite = class {
     this.dialect = Dialect.SQLITE;
     this.options = options;
     this.status = "connecting";
-    this.client = new Sqlite(options.filename);
+    this.client = new Database(options.filename);
     this.status = "connected";
   }
   async connect() {
-    this.client = new Sqlite(this.options.filename);
+    this.client = new Database(this.options.filename);
     this.status = "connected";
     return this;
   }
@@ -92,7 +90,4 @@ var DatabaseSqlite = class {
   }
 };
 
-export {
-  DatabasePsql,
-  DatabaseSqlite
-};
+export { DatabasePsql, DatabaseSqlite };