@ignisia/sql 0.1.0 → 0.2.1

package/dist/query/utilities.js

@@ -1,24 +1,175 @@
-import {
-  getCondition,
-  getGroupByConditions,
-  getParanoid,
-  getTableColumnNames,
-  getTableSelectName,
-  getTimestamp,
-  getWhereConditions,
-  parseAliasedRow
-} from "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  getCondition,
-  getGroupByConditions,
-  getParanoid,
-  getTableColumnNames,
-  getTableSelectName,
-  getTimestamp,
-  getWhereConditions,
-  parseAliasedRow
-};
+import '.';
+import { Dialect } from '../table/constants';
+import { quoteIdentifier } from '../utilities';
+import { AcceptedOperator, QueryType } from './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 AcceptedOperator.EQ:
+      return `${column} = ?`;
+    case AcceptedOperator.NE:
+      return `${column} != ?`;
+    case AcceptedOperator.GT:
+      return `${column} > ?`;
+    case AcceptedOperator.LT:
+      return `${column} < ?`;
+    case AcceptedOperator.GTE:
+      return `${column} >= ?`;
+    case AcceptedOperator.LTE:
+      return `${column} <= ?`;
+    case AcceptedOperator.IN:
+      return `${column} IN (${value.map(() => "?").join(", ")})`;
+    case AcceptedOperator.NOT_IN:
+      return `${column} NOT IN (${value.map(() => "?").join(", ")})`;
+    case AcceptedOperator.LIKE:
+      return `${column} LIKE ?`;
+    case AcceptedOperator.NOT_LIKE:
+      return `${column} NOT LIKE ?`;
+    case AcceptedOperator.ILIKE:
+      if (dialect === Dialect.POSTGRES) {
+        return `${column} ILIKE ?`;
+      }
+      return `LOWER(${column}) LIKE LOWER(?)`;
+    case AcceptedOperator.NOT_ILIKE:
+      if (dialect === Dialect.POSTGRES) {
+        return `${column} NOT ILIKE ?`;
+      }
+      return `LOWER(${column}) NOT LIKE LOWER(?)`;
+    case AcceptedOperator.IS_NULL:
+      return `${column} IS NULL`;
+    case AcceptedOperator.IS_NOT_NULL:
+      return `${column} IS NOT NULL`;
+    case AcceptedOperator.BETWEEN:
+      return `${column} BETWEEN ? AND ?`;
+    case 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 === 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}.${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 !== 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}.${quoteIdentifier(column)}`).join(" ");
+        }
+        return col;
+      });
+    const from = q.definition.baseAlias ?? q.table.name;
+    return Object.keys(q.table.columns).map(
+      (col) => `${from}.${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;
+}
+
+export { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow };

package/dist/table/constants.js

@@ -1,6 +1,6 @@
-import {
-  Dialect
-} from "../chunk-GLOHF5CP.js";
-export {
-  Dialect
+const Dialect = {
+  POSTGRES: "postgres",
+  SQLITE: "sqlite"
 };
+
+export { Dialect };

package/dist/table/index.d.ts

@@ -1,4 +1,4 @@
-export { T as Table } from '../index-DJhQVUY3.js';
+export { T as Table } from '../index-FMT0YEO7.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';

package/dist/table/index.js

@@ -1,14 +1,52 @@
-import {
-  Table
-} from "../chunk-W2DR3ZVK.js";
-import "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-WVJGTZFI.js";
-import "../chunk-GY7R637S.js";
-import "../chunk-G3LSCLIQ.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  Table
-};
+import { QueryBuilder } from '../query';
+import { defineColumns } from './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 = 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 QueryBuilder(this);
+  }
+}
+
+export { Table };

package/dist/table/types.d.ts

@@ -1,4 +1,4 @@
-export { M as MergeTimestampParanoid, p as TableOptions, q as TableOutput, a as TimestampOptions } from '../index-DJhQVUY3.js';
+export { M as MergeTimestampParanoid, s as TableOptions, t as TableOutput, a as TimestampOptions } from '../index-FMT0YEO7.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';

package/dist/table/types.js

@@ -0,0 +1 @@
+

package/dist/table/utilities.d.ts

@@ -1,7 +1,7 @@
 import '../column/constants.js';
 import '../column/index.js';
 import './constants.js';
-export { m as createdAt, o as defineColumns, n as deletedAt, u as updatedAt } from '../index-DJhQVUY3.js';
+export { p as createdAt, r as defineColumns, q as deletedAt, u as updatedAt } from '../index-FMT0YEO7.js';
 import '../column/types.js';
 import '../types.js';
 import '../query/constants.js';

package/dist/table/utilities.js

@@ -1,15 +1,50 @@
-import {
-  createdAt,
-  defineColumns,
-  deletedAt,
-  updatedAt
-} from "../chunk-WVJGTZFI.js";
-import "../chunk-GY7R637S.js";
-import "../chunk-G3LSCLIQ.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  createdAt,
-  defineColumns,
-  deletedAt,
-  updatedAt
-};
+import { Column } from '../column';
+
+const createdAt = Column.define({
+  type: "DATETIME"
+}).default("CURRENT_TIMESTAMP");
+const updatedAt = Column.define({
+  type: "DATETIME"
+});
+const deletedAt = 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;
+}
+
+export { createdAt, defineColumns, deletedAt, updatedAt };

package/dist/types.js

@@ -0,0 +1 @@
+

package/dist/utilities.js

@@ -1,8 +1,18 @@
-import {
-  deepClone,
-  quoteIdentifier
-} from "./chunk-Y7FSRHH3.js";
-export {
-  deepClone,
-  quoteIdentifier
-};
+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, '""')}"`;
+}
+
+export { deepClone, quoteIdentifier };

package/package.json

@@ -2,8 +2,43 @@
   "name": "@ignisia/sql",
   "module": "dist/index.js",
   "types": "./dist/index.d.ts",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    },
+    "./**/*": {
+      "import": "./dist/**/*.js",
+      "types": "./dist/**/*.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./column": {
+      "import": "./dist/column/index.js",
+      "types": "./dist/column/index.d.ts"
+    },
+    "./database": {
+      "import": "./dist/database/index.js",
+      "types": "./dist/database/index.d.ts"
+    },
+    "./migration": {
+      "import": "./dist/migration/index.js",
+      "types": "./dist/migration/index.d.ts"
+    },
+    "./query": {
+      "import": "./dist/query/index.js",
+      "types": "./dist/query/index.d.ts"
+    },
+    "./table": {
+      "import": "./dist/table/index.js",
+      "types": "./dist/table/index.d.ts"
+    }
+  },
   "scripts": {
     "build": "bun run build.ts"
   },
@@ -17,4 +52,4 @@
   "files": [
     "dist"
   ]
-}
+}

package/dist/chunk-4DQRB5XS.js

@@ -1,94 +0,0 @@
-import {
-  DatabasePsql,
-  DatabaseSqlite
-} from "./chunk-HKTHKQLK.js";
-import {
-  addColumn,
-  dropColumn,
-  renameColumn
-} from "./chunk-JF7OSNH4.js";
-import {
-  createTable,
-  dropTable,
-  renameTable
-} from "./chunk-D2ASIT4Q.js";
-import {
-  alterColumnType,
-  dropColumnDefault,
-  dropColumnNotNull,
-  setColumnDefault
-} from "./chunk-V4OMHVJN.js";
-import {
-  Dialect
-} from "./chunk-GLOHF5CP.js";
-
-// src/database/index.ts
-var Database = class _Database {
-  dialect;
-  defintion;
-  tables;
-  client;
-  createTable;
-  renameTable;
-  dropTable;
-  addColumn;
-  renameColumn;
-  dropColumn;
-  alterColumnType;
-  setColumnDefault;
-  dropColumnDefault;
-  setColumnNotNull;
-  dropColumnNotNull;
-  constructor(options) {
-    this.dialect = options.dialect;
-    this.tables = options.tables ?? {};
-    this.defintion = {
-      dialect: options.dialect,
-      config: options.config
-    };
-    this.client = options.dialect === Dialect.POSTGRES ? new DatabasePsql(options.config) : new DatabaseSqlite(options.config);
-    if (options.tables) {
-      for (const tableName in options.tables) {
-        options.tables[tableName].database = this.client;
-      }
-    }
-    this.createTable = createTable.bind(this);
-    this.renameTable = renameTable.bind(this);
-    this.dropTable = dropTable.bind(this);
-    this.addColumn = addColumn.bind(this);
-    this.renameColumn = renameColumn.bind(this);
-    this.dropColumn = dropColumn.bind(this);
-    this.alterColumnType = alterColumnType.bind(
-      this
-    );
-    this.setColumnDefault = setColumnDefault.bind(
-      this
-    );
-    this.dropColumnDefault = dropColumnDefault.bind(
-      this
-    );
-    this.setColumnNotNull = setColumnDefault.bind(
-      this
-    );
-    this.dropColumnNotNull = dropColumnNotNull.bind(
-      this
-    );
-  }
-  table(tableName) {
-    if (!this.tables[tableName]) {
-      throw new Error(`Table ${tableName} does not exist`);
-    }
-    const table = this.tables[tableName];
-    return table.query();
-  }
-  async transaction(fn) {
-    return this.client.transaction(fn);
-  }
-  static define(options) {
-    return new _Database(options);
-  }
-};
-
-export {
-  Database
-};

package/dist/chunk-CIWX3UCZ.js

@@ -1,51 +0,0 @@
-// src/migration/index.ts
-var Migration = class _Migration {
-  db;
-  _up;
-  _down;
-  constructor(options) {
-    this.db = options.db;
-    this._up = options.up;
-    this._down = options.down;
-  }
-  get up() {
-    return this._up;
-  }
-  get down() {
-    return this._down;
-  }
-  static setUp(migrator, fn) {
-    migrator._up = () => fn(migrator.db);
-    return migrator;
-  }
-  static setDown(migrator, fn) {
-    migrator._down = () => fn(migrator.db);
-    return migrator;
-  }
-  static define(db, options) {
-    const migration = new _Migration({
-      db,
-      up: options?.up ? () => options.up(db) : null,
-      down: options?.down ? () => options.down(db) : null
-    });
-    return {
-      migration,
-      setUp(fn) {
-        return _Migration.setUp(
-          migration,
-          fn
-        );
-      },
-      setDown(fn) {
-        return _Migration.setDown(
-          migration,
-          fn
-        );
-      }
-    };
-  }
-};
-
-export {
-  Migration
-};

package/dist/chunk-D2ASIT4Q.js

@@ -1,44 +0,0 @@
-import {
-  Table
-} from "./chunk-W2DR3ZVK.js";
-
-// src/database/table.ts
-async function createTable(tableName, columns, options) {
-  const table = Table.define({
-    name: tableName,
-    dialect: this.dialect,
-    columns,
-    ...options
-  });
-  table.database = this.client;
-  this.tables[tableName] = table;
-  if (!this?.client) {
-    throw new Error("Database not connected");
-  }
-  while (this.client.status === "connecting") {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  await table.create(this.client);
-  return this;
-}
-async function renameTable(oldName, newName) {
-  await this.client.exec(`ALTER TABLE ${oldName} RENAME TO ${newName};`);
-  this.tables[newName] = this.tables[oldName];
-  delete this.tables[oldName];
-  return this;
-}
-async function dropTable(tableName) {
-  if (!this.tables[tableName]) {
-    await this.client.exec(`DROP TABLE IF EXISTS ${tableName};`);
-    return this;
-  }
-  await this.tables[tableName].drop(this.client);
-  delete this.tables[tableName];
-  return this;
-}
-
-export {
-  createTable,
-  renameTable,
-  dropTable
-};

package/dist/chunk-FYSNJAGD.js

@@ -1,19 +0,0 @@
-// src/query/join.ts
-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;
-}
-
-export {
-  addJoin
-};