@ignisia/sql 0.3.0 → 0.4.1

package/dist/esm/query/utilities.js

@@ -1,7 +1,6 @@
 import './index.js';
-import { Dialect } from '../table/constants.js';
 import { quoteIdentifier } from '../utilities.js';
-import { AcceptedOperator, QueryType } from './constants.js';
+import { QueryType } from './constants.js';
 
 // src/query/utilities.ts
 function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
@@ -14,50 +13,6 @@ function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
     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();
@@ -71,13 +26,13 @@ function getTimestamp(table) {
       if (typeof table.timestamp.createdAt === "string") {
         createdAt = table.timestamp.createdAt;
       }
-      isHasCreatedAt = table.timestamp.createdAt === false;
+      isHasCreatedAt = table.timestamp.createdAt !== false;
     }
     if (isCustomTimestamp) {
       if (typeof table.timestamp.updatedAt === "string") {
         updatedAt = table.timestamp.updatedAt;
       }
-      isHasUpdatedAt = table.timestamp.updatedAt === false;
+      isHasUpdatedAt = table.timestamp.updatedAt !== false;
     }
   }
   return {
@@ -104,23 +59,6 @@ function getParanoid(table) {
     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;
@@ -182,5 +120,23 @@ function parseAliasedRow({
   }
   return result;
 }
+function sanitizeParams(params) {
+  return params.map((param) => {
+    if (param === null || typeof param === "string" || typeof param === "number" || typeof param === "boolean" || typeof param === "bigint") {
+      return param;
+    }
+    if (param === void 0) {
+      return null;
+    }
+    if (param instanceof Date) {
+      return param.toISOString();
+    }
+    try {
+      return JSON.stringify(param);
+    } catch {
+      return null;
+    }
+  });
+}
 
-export { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow };
+export { getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, parseAliasedRow, sanitizeParams };

package/dist/esm/table/index.d.ts

@@ -1,8 +1,8 @@
-export { T as Table } from '../index-BdpoD4zk.js';
+export { T as Table } from '../index-CARBkj9h.js';
 import '../column/index.js';
 import './constants.js';
-import '../column/constants.js';
+import 'bun';
 import '../types.js';
 import '../query/constants.js';
-import 'bun';
+import '../column/constants.js';
 import '../column/types.js';

package/dist/esm/table/types.d.ts

@@ -1,8 +1,8 @@
 import 'bun';
-export { E as ExecOptions, M as MergeTimestampParanoid, x as TableOptions, y as TableOutput, a as TimestampOptions } from '../index-BdpoD4zk.js';
+export { K as ExecOptions, M as MergeTimestampParanoid, H as TableOptions, I as TableOutput, c as TimestampOptions } from '../index-CARBkj9h.js';
 import '../column/index.js';
 import './constants.js';
-import '../column/constants.js';
 import '../types.js';
 import '../query/constants.js';
+import '../column/constants.js';
 import '../column/types.js';

package/dist/esm/table/utilities.d.ts

@@ -1,8 +1,8 @@
 import '../column/constants.js';
 import '../column/index.js';
 import './constants.js';
-export { t as createdAt, w as defineColumns, v as deletedAt, u as updatedAt } from '../index-BdpoD4zk.js';
+export { y as createdAt, F as defineColumns, B as deletedAt, z as updatedAt } from '../index-CARBkj9h.js';
 import '../column/types.js';
+import 'bun';
 import '../types.js';
 import '../query/constants.js';
-import 'bun';

package/dist/esm/types.d.ts

@@ -1,3 +1,7 @@
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type BuildTuple<N extends number, T extends unknown[] = []> = T['length'] extends N ? T : BuildTuple<N, [...T, unknown]>;
+type Add<A extends number, B extends number, Result extends unknown[] = [...BuildTuple<A>, ...BuildTuple<B>]> = Result['length'] extends number ? Result['length'] : never;
+type Subtract<A extends number, B extends number> = BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest] ? Rest['length'] : never;
+type Multiply<A extends number, B extends number, Result extends unknown[] = []> = B extends 0 ? Result['length'] : Multiply<A, Subtract<B, 1>, [...Result, ...BuildTuple<A>]>;
 
-export type { UnionToIntersection };
+export type { Add, BuildTuple, Multiply, Subtract, UnionToIntersection };

package/dist/esm/utilities.d.ts

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

package/dist/esm/utilities.js

@@ -12,8 +12,29 @@ function deepClone(obj) {
   }
   return obj;
 }
+function cloneArray(arr) {
+  if (arr.length === 0) return [];
+  if (typeof arr[0] === "object" && arr[0] !== null) {
+    return arr.map((item) => ({ ...item }));
+  }
+  return arr.slice();
+}
+function cloneDefinition(def) {
+  const clone = {};
+  for (const key in def) {
+    const val = def[key];
+    if (val === null || typeof val !== "object") {
+      clone[key] = val;
+    } else if (Array.isArray(val)) {
+      clone[key] = cloneArray(val);
+    } else {
+      clone[key] = { ...val };
+    }
+  }
+  return clone;
+}
 function quoteIdentifier(identifier) {
   return `"${identifier.replace(/"/g, '""')}"`;
 }
 
-export { deepClone, quoteIdentifier };
+export { cloneDefinition, deepClone, quoteIdentifier };

package/package.json

@@ -3,7 +3,7 @@
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "type": "module",
   "exports": {
     ".": {
@@ -42,6 +42,11 @@
       "import": "./dist/esm/query/index.js",
       "require": "./dist/cjs/query/index.js"
     },
+    "./query/condition": {
+      "types": "./dist/esm/query/condition/index.d.ts",
+      "import": "./dist/esm/query/condition/index.js",
+      "require": "./dist/cjs/query/condition/index.js"
+    },
     "./table": {
       "types": "./dist/esm/table/index.d.ts",
       "import": "./dist/esm/table/index.js",
@@ -63,16 +68,17 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/krsbx/aio-web.git"
+    "url": "git+https://github.com/krsbx/ignisia.git"
   },
   "bugs": {
-    "url": "https://github.com/krsbx/aio-web/issues"
+    "url": "https://github.com/krsbx/ignisia/issues"
   },
   "keywords": [
     "bun",
     "sql",
     "database",
     "sqlite",
-    "postgres"
+    "postgres",
+    "mysql"
   ]
-}
+}

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

@@ -1,8 +0,0 @@
-export { N as addCondition, I as addRawCondition, V as having, U as or, L as rawHaving, K as rawOr, J as rawWhere, O as where } from '../index-CnQVnCEI.cjs';
-import '../column/index.cjs';
-import './constants.cjs';
-import '../column/constants.cjs';
-import '../types.cjs';
-import 'bun';
-import '../table/constants.cjs';
-import '../column/types.cjs';

package/dist/cjs/query/condition.js

@@ -1,109 +0,0 @@
-'use strict';
-
-var constants = require('./constants');
-var helper = require('./helper');
-var utilities = require('./utilities');
-
-function addRawCondition(query, clause, column, logical, params) {
-  const validClause = clause.toLowerCase();
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const condition = column(helper.rawCol);
-  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
-  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
-  if (!query.definition.params) query.definition.params = [];
-  if (typeof params === "undefined") {
-    return query;
-  }
-  if (Array.isArray(params)) {
-    query.definition.params.push(...params);
-  } else {
-    query.definition.params.push(params);
-  }
-  return query;
-}
-function rawWhere(column, params) {
-  return addRawCondition(
-    this,
-    constants.ConditionClause.WHERE,
-    column,
-    constants.LogicalOperator.AND,
-    params
-  );
-}
-function rawOr(column, params) {
-  return addRawCondition(
-    this,
-    constants.ConditionClause.WHERE,
-    column,
-    constants.LogicalOperator.OR,
-    params
-  );
-}
-function rawHaving(column, params) {
-  return addRawCondition(
-    this,
-    constants.ConditionClause.HAVING,
-    column,
-    constants.LogicalOperator.AND,
-    params
-  );
-}
-function addCondition(query, clause, column, operator, value, logical) {
-  if (!query.table.dialect) {
-    throw new Error("No DB Dialect defined");
-  }
-  const validClause = clause.toLowerCase();
-  const condition = utilities.getCondition(query.table.dialect, column, operator, value);
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
-  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
-  if (operator === constants.AcceptedOperator.IS_NULL || operator === constants.AcceptedOperator.IS_NOT_NULL) {
-    return query;
-  }
-  if (!query.definition.params) query.definition.params = [];
-  if (Array.isArray(value)) {
-    query.definition.params.push(...value);
-  } else {
-    query.definition.params.push(value);
-  }
-  return query;
-}
-function where(column, operator, value) {
-  return addCondition(
-    this,
-    constants.ConditionClause.WHERE,
-    column,
-    operator,
-    value || null,
-    constants.LogicalOperator.AND
-  );
-}
-function or(column, operator, value) {
-  return addCondition(
-    this,
-    constants.ConditionClause.WHERE,
-    column,
-    operator,
-    value || null,
-    constants.LogicalOperator.OR
-  );
-}
-function having(column, operator, value) {
-  return addCondition(
-    this,
-    constants.ConditionClause.HAVING,
-    column,
-    operator,
-    value,
-    constants.LogicalOperator.AND
-  );
-}
-
-exports.addCondition = addCondition;
-exports.addRawCondition = addRawCondition;
-exports.having = having;
-exports.or = or;
-exports.rawHaving = rawHaving;
-exports.rawOr = rawOr;
-exports.rawWhere = rawWhere;
-exports.where = where;

package/dist/esm/query/condition.d.ts

@@ -1,8 +0,0 @@
-export { N as addCondition, I as addRawCondition, V as having, U as or, L as rawHaving, K as rawOr, J as rawWhere, O as where } from '../index-BdpoD4zk.js';
-import '../column/index.js';
-import './constants.js';
-import '../column/constants.js';
-import '../types.js';
-import 'bun';
-import '../table/constants.js';
-import '../column/types.js';

package/dist/esm/query/condition.js

@@ -1,101 +0,0 @@
-import { LogicalOperator, ConditionClause, AcceptedOperator } from './constants.js';
-import { rawCol } from './helper.js';
-import { getCondition } from './utilities.js';
-
-// src/query/condition.ts
-function addRawCondition(query, clause, column, logical, params) {
-  const validClause = clause.toLowerCase();
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const condition = column(rawCol);
-  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
-  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
-  if (!query.definition.params) query.definition.params = [];
-  if (typeof params === "undefined") {
-    return query;
-  }
-  if (Array.isArray(params)) {
-    query.definition.params.push(...params);
-  } else {
-    query.definition.params.push(params);
-  }
-  return query;
-}
-function rawWhere(column, params) {
-  return addRawCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    LogicalOperator.AND,
-    params
-  );
-}
-function rawOr(column, params) {
-  return addRawCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    LogicalOperator.OR,
-    params
-  );
-}
-function rawHaving(column, params) {
-  return addRawCondition(
-    this,
-    ConditionClause.HAVING,
-    column,
-    LogicalOperator.AND,
-    params
-  );
-}
-function addCondition(query, clause, column, operator, value, logical) {
-  if (!query.table.dialect) {
-    throw new Error("No DB Dialect defined");
-  }
-  const validClause = clause.toLowerCase();
-  const condition = getCondition(query.table.dialect, column, operator, value);
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
-  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
-  if (operator === AcceptedOperator.IS_NULL || operator === AcceptedOperator.IS_NOT_NULL) {
-    return query;
-  }
-  if (!query.definition.params) query.definition.params = [];
-  if (Array.isArray(value)) {
-    query.definition.params.push(...value);
-  } else {
-    query.definition.params.push(value);
-  }
-  return query;
-}
-function where(column, operator, value) {
-  return addCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    operator,
-    value || null,
-    LogicalOperator.AND
-  );
-}
-function or(column, operator, value) {
-  return addCondition(
-    this,
-    ConditionClause.WHERE,
-    column,
-    operator,
-    value || null,
-    LogicalOperator.OR
-  );
-}
-function having(column, operator, value) {
-  return addCondition(
-    this,
-    ConditionClause.HAVING,
-    column,
-    operator,
-    value,
-    LogicalOperator.AND
-  );
-}
-
-export { addCondition, addRawCondition, having, or, rawHaving, rawOr, rawWhere, where };