@ignisia/sql 0.2.0 → 0.2.2

package/dist/esm/query/utilities.js

@@ -0,0 +1,176 @@
+import './index.js';
+import { Dialect } from '../table/constants.js';
+import { quoteIdentifier } from '../utilities.js';
+import { AcceptedOperator, QueryType } from './constants.js';
+
+// src/query/utilities.ts
+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/esm/table/constants.d.ts

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

package/dist/{chunk-GLOHF5CP.js → esm/table/constants.js}

@@ -4,6 +4,4 @@ var Dialect = {
   SQLITE: "sqlite"
 };
 
-export {
-  Dialect
-};
+export { Dialect };

package/dist/{chunk-KVCIOW7L.js → esm/table/index.js}

@@ -1,9 +1,5 @@
-import {
-  QueryBuilder
-} from "./chunk-EIUC7HJS.js";
-import {
-  defineColumns
-} from "./chunk-WVJGTZFI.js";
+import { QueryBuilder } from '../query/index.js';
+import { defineColumns } from './utilities.js';
 
 // src/table/index.ts
 var Table = class _Table {
@@ -54,6 +50,4 @@ var Table = class _Table {
   }
 };
 
-export {
-  Table
-};
+export { Table };

package/dist/esm/table/types.js

@@ -0,0 +1 @@
+

package/dist/{chunk-WVJGTZFI.js → esm/table/utilities.js}

@@ -1,6 +1,4 @@
-import {
-  Column
-} from "./chunk-GY7R637S.js";
+import { Column } from '../column/index.js';
 
 // src/table/utilities.ts
 var createdAt = Column.define({
@@ -17,8 +15,6 @@ function defineColumns(options) {
     ...options.columns
   };
   const tracker = {
-    createdAt: "createdAt",
-    updatedAt: "updatedAt",
     deletedAt: "deletedAt"
   };
   if (options.timestamp) {
@@ -52,9 +48,4 @@ function defineColumns(options) {
   return columns;
 }
 
-export {
-  createdAt,
-  updatedAt,
-  deletedAt,
-  defineColumns
-};
+export { createdAt, defineColumns, deletedAt, updatedAt };

package/dist/esm/types.d.ts

@@ -0,0 +1,3 @@
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+export type { UnionToIntersection };

package/dist/esm/types.js

@@ -0,0 +1 @@
+

package/dist/esm/utilities.d.ts

@@ -0,0 +1,4 @@
+declare function deepClone<T>(obj: T): T;
+declare function quoteIdentifier<T extends string, U extends `"${T}"`>(identifier: T): U;
+
+export { deepClone, quoteIdentifier };

package/dist/{chunk-Y7FSRHH3.js → esm/utilities.js}

@@ -16,7 +16,4 @@ function quoteIdentifier(identifier) {
   return `"${identifier.replace(/"/g, '""')}"`;
 }
 
-export {
-  deepClone,
-  quoteIdentifier
-};
+export { deepClone, quoteIdentifier };

package/package.json

@@ -1,9 +1,53 @@
 {
   "name": "@ignisia/sql",
-  "module": "dist/index.js",
-  "types": "./dist/index.d.ts",
-  "version": "0.2.0",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "version": "0.2.2",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./*": {
+      "types": "./dist/esm/*.d.ts",
+      "import": "./dist/esm/*.js",
+      "require": "./dist/cjs/*.js"
+    },
+    "./**/*": {
+      "types": "./dist/esm/**/*.d.ts",
+      "import": "./dist/esm/**/*.js",
+      "require": "./dist/cjs/**/*.js"
+    },
+    "./package.json": "./package.json",
+    "./column": {
+      "types": "./dist/esm/column/index.d.ts",
+      "import": "./dist/esm/column/index.js",
+      "require": "./dist/cjs/column/index.js"
+    },
+    "./database": {
+      "types": "./dist/esm/database/index.d.ts",
+      "import": "./dist/esm/database/index.js",
+      "require": "./dist/cjs/database/index.js"
+    },
+    "./migration": {
+      "types": "./dist/esm/migration/index.d.ts",
+      "import": "./dist/esm/migration/index.js",
+      "require": "./dist/cjs/migration/index.js"
+    },
+    "./query": {
+      "types": "./dist/esm/query/index.d.ts",
+      "import": "./dist/esm/query/index.js",
+      "require": "./dist/cjs/query/index.js"
+    },
+    "./table": {
+      "types": "./dist/esm/table/index.d.ts",
+      "import": "./dist/esm/table/index.js",
+      "require": "./dist/cjs/table/index.js"
+    }
+  },
   "scripts": {
     "build": "bun run build.ts"
   },
@@ -16,5 +60,19 @@
   },
   "files": [
     "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krsbx/aio-web.git"
+  },
+  "bugs": {
+    "url": "https://github.com/krsbx/aio-web/issues"
+  },
+  "keywords": [
+    "bun",
+    "sql",
+    "database",
+    "sqlite",
+    "postgres"
   ]
-}
+}