@ignisia/sql 0.2.1 → 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/{column → esm/column}/constants.js

@@ -1,6 +1,7 @@
-import { Dialect } from '../table/constants';
+import { Dialect } from '../table/constants.js';
 
-const AcceptedColumnTypes = {
+// src/column/constants.ts
+var AcceptedColumnTypes = {
   INTEGER: "INTEGER",
   STRING: "STRING",
   BOOLEAN: "BOOLEAN",
@@ -20,7 +21,7 @@ const AcceptedColumnTypes = {
   ENUM: "ENUM",
   SERIAL: "SERIAL"
 };
-const ColumnTypeMapping = {
+var ColumnTypeMapping = {
   [AcceptedColumnTypes.INTEGER]: {
     [Dialect.SQLITE]: "INTEGER",
     [Dialect.POSTGRES]: "INTEGER"

package/dist/{column → esm/column}/index.js

@@ -1,7 +1,8 @@
-import { Dialect } from '../table/constants';
-import { ColumnTypeMapping, AcceptedColumnTypes } from './constants';
+import { Dialect } from '../table/constants.js';
+import { ColumnTypeMapping, AcceptedColumnTypes } from './constants.js';
 
-class Column {
+// src/column/index.ts
+var Column = class _Column {
   definition;
   type;
   length;
@@ -27,7 +28,7 @@ class Column {
     };
   }
   static define(options) {
-    return new Column(options);
+    return new _Column(options);
   }
   autoIncrement() {
     this.definition.autoIncrement = true;
@@ -100,6 +101,6 @@ class Column {
   infer() {
     return null;
   }
-}
+};
 
 export { Column };

package/dist/esm/column/types.js

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

package/dist/{database → esm/database}/alter.js

@@ -1,5 +1,6 @@
-import { Dialect } from '../table/constants';
+import { Dialect } from '../table/constants.js';
 
+// src/database/alter.ts
 async function alterColumnType(tableName, columnName, newType) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support ALTER COLUMN TYPE directly.");

package/dist/{database → esm/database}/column.js

@@ -1,5 +1,6 @@
-import { Dialect } from '../table/constants';
+import { Dialect } from '../table/constants.js';
 
+// src/database/column.ts
 async function addColumn(tableName, columnName, column) {
   await this.client.exec(
     `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${column.toString()};`

package/dist/{database → esm/database}/index.js

@@ -1,11 +1,12 @@
-import '../table';
-import { Dialect } from '../table/constants';
-import { alterColumnType, setColumnDefault, dropColumnDefault, dropColumnNotNull } from './alter';
-import { addColumn, renameColumn, dropColumn } from './column';
-import { createTable, renameTable, dropTable } from './table';
-import { DatabasePsql, DatabaseSqlite } from './wrapper';
+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';
 
-class Database {
+// src/database/index.ts
+var Database = class _Database {
   hooks;
   dialect;
   defintion;
@@ -85,8 +86,8 @@ class Database {
     return this.client.transaction(fn);
   }
   static define(options) {
-    return new Database(options);
+    return new _Database(options);
   }
-}
+};
 
 export { Database };

package/dist/{database → esm/database}/table.js

@@ -1,5 +1,6 @@
-import { Table } from '../table';
+import { Table } from '../table/index.js';
 
+// src/database/table.ts
 async function createTable(tableName, columns, options) {
   const table = Table.define({
     name: tableName,

package/dist/{database → esm/database}/wrapper.js

@@ -1,8 +1,9 @@
 import { SQL } from 'bun';
 import { Database } from 'bun:sqlite';
-import { Dialect } from '../table/constants';
+import { Dialect } from '../table/constants.js';
 
-class DatabasePsql {
+// src/database/wrapper.ts
+var DatabasePsql = class {
   dialect;
   options;
   client;
@@ -48,8 +49,8 @@ class DatabasePsql {
       throw err;
     }
   }
-}
-class DatabaseSqlite {
+};
+var DatabaseSqlite = class {
   dialect;
   options;
   client;
@@ -87,6 +88,6 @@ class DatabaseSqlite {
       throw err;
     }
   }
-}
+};
 
 export { DatabasePsql, DatabaseSqlite };

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { Column } from './column/index.js';
+export { Database } from './database/index.js';
+export { Migration } from './migration/index.js';
+export { QueryBuilder } from './query/index.js';
+export { Table } from './table/index.js';