@ignisia/sql 0.2.0 → 0.2.1

package/dist/query/sql.js

@@ -1,16 +1,99 @@
-import {
-  buildQuery,
-  exec,
-  toQuery,
-  toString
-} from "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  buildQuery,
-  exec,
-  toQuery,
-  toString
-};
+import { buildDeleteQuery, buildUpdateQuery, buildInsertQuery, buildSelectQuery } from './builder';
+import { QueryType, QueryHooksType } from './constants';
+import { getWhereConditions, getGroupByConditions, parseAliasedRow } from './utilities';
+
+function buildQuery(query) {
+  let index = 0;
+  return query.replace(/\?/g, () => {
+    index++;
+    return `$${index}`;
+  });
+}
+function toQuery() {
+  let sql = "";
+  switch (this.definition.queryType) {
+    case QueryType.SELECT:
+      sql = buildSelectQuery(this);
+      break;
+    case QueryType.INSERT:
+      sql = buildInsertQuery(this);
+      break;
+    case QueryType.UPDATE:
+      sql = buildUpdateQuery(this);
+      break;
+    case QueryType.DELETE:
+      sql = buildDeleteQuery(this);
+      break;
+    default:
+      throw new Error("No query type defined");
+  }
+  if (this.definition?.joins?.length) {
+    sql += ` ${this.definition.joins.join(" ")}`;
+  }
+  const whereConditions = getWhereConditions(this);
+  if (whereConditions.length) {
+    sql += ` WHERE ${whereConditions.join(" ")}`;
+  }
+  const groupByConditions = 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 === QueryType.UPDATE || this.definition.queryType === QueryType.DELETE) {
+    sql += ` RETURNING *`;
+  }
+  sql = buildQuery(sql);
+  return { query: sql + ";", params: this.definition.params };
+}
+function toString() {
+  return this.toQuery().query;
+}
+async function exec() {
+  if (!this.table.client) throw new Error("Database client not defined");
+  const { query, params } = this.toQuery();
+  if (this.hooks?.before?.size) {
+    for (const hook of this.hooks.before.values()) {
+      hook({
+        query,
+        params,
+        type: this.definition.queryType,
+        hook: QueryHooksType.BEFORE
+      });
+    }
+  }
+  const result = await this.table.client.exec(query, params);
+  if (this.hooks?.after?.size) {
+    for (const hook of this.hooks.after.values()) {
+      hook({
+        query,
+        params,
+        type: this.definition.queryType,
+        hook: QueryHooksType.AFTER
+      });
+    }
+  }
+  return result.map(
+    (r) => parseAliasedRow({
+      row: r,
+      selects: this.definition.select ?? [],
+      root: this.definition?.baseAlias ?? this.table.name
+    })
+  );
+}
+
+export { buildQuery, exec, toQuery, toString };

package/dist/query/types.js

@@ -0,0 +1 @@
+

package/dist/query/utilities.js

@@ -1,24 +1,175 @@
-import {
-  getCondition,
-  getGroupByConditions,
-  getParanoid,
-  getTableColumnNames,
-  getTableSelectName,
-  getTimestamp,
-  getWhereConditions,
-  parseAliasedRow
-} from "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.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.js

@@ -1,14 +1,52 @@
-import {
-  Table
-} from "../chunk-KVCIOW7L.js";
-import "../chunk-EIUC7HJS.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-62FKD35V.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-WVJGTZFI.js";
-import "../chunk-GY7R637S.js";
-import "../chunk-G3LSCLIQ.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.js

@@ -0,0 +1 @@
+

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.2.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-62FKD35V.js

@@ -1,65 +0,0 @@
-// src/query/constants.ts
-var LogicalOperator = {
-  AND: "AND",
-  OR: "OR"
-};
-var ConditionClause = {
-  WHERE: "WHERE",
-  HAVING: "HAVING"
-};
-var AcceptedOperator = {
-  EQ: "eq",
-  NE: "ne",
-  GT: "gt",
-  LT: "lt",
-  GTE: "gte",
-  LTE: "lte",
-  IN: "in",
-  NOT_IN: "notIn",
-  LIKE: "like",
-  NOT_LIKE: "notLike",
-  ILIKE: "ilike",
-  NOT_ILIKE: "notILike",
-  IS_NULL: "isNull",
-  IS_NOT_NULL: "isNotNull",
-  BETWEEN: "between",
-  NOT_BETWEEN: "notBetween"
-};
-var QueryType = {
-  SELECT: "SELECT",
-  INSERT: "INSERT",
-  UPDATE: "UPDATE",
-  DELETE: "DELETE"
-};
-var OrderBy = {
-  ASC: "ASC",
-  DESC: "DESC"
-};
-var AggregationFunction = {
-  COUNT: "COUNT",
-  SUM: "SUM",
-  MIN: "MIN",
-  MAX: "MAX",
-  AVG: "AVG"
-};
-var AcceptedJoin = {
-  INNER: "INNER",
-  LEFT: "LEFT",
-  RIGHT: "RIGHT",
-  NATURAL: "NATURAL"
-};
-var QueryHooksType = {
-  AFTER: "after",
-  BEFORE: "before"
-};
-
-export {
-  LogicalOperator,
-  ConditionClause,
-  AcceptedOperator,
-  QueryType,
-  OrderBy,
-  AggregationFunction,
-  AcceptedJoin,
-  QueryHooksType
-};

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
-};