@devbro/neko-sql 0.1.16 → 0.1.18

package/dist/index.js

@@ -76,7 +76,8 @@ var Query = class _Query {
     having: [],
     orderBy: [],
     limit: null,
-    offset: null
+    offset: null,
+    alias: null
   };
   table(tableName) {
     this.parts.table = tableName;
@@ -166,7 +167,15 @@ var Query = class _Query {
     return this.grammar.toSql(this);
   }
   async get() {
-    return await this.connection?.runQuery(this.toSql());
+    let sql = this.toSql();
+    return await this.connection?.runQuery(sql);
+  }
+  async first() {
+    let rc = await this.connection?.runQuery(this.toSql());
+    if (rc && Array.isArray(rc) && rc.length > 0) {
+      return rc[0];
+    }
+    return void 0;
   }
   async count() {
     const csql = this.grammar.compileCount(this);
@@ -232,9 +241,14 @@ var Query = class _Query {
   crossJoin(table, conditions) {
     return this.join(table, "cross", conditions);
   }
+  alias(alias) {
+    this.parts.alias = alias;
+    return this;
+  }
 };
 
 // src/QueryGrammar.mts
+var import_sql_tokenizer = require("sql-tokenizer");
 function toUpperFirst(str) {
   return str.substring(0, 1).toUpperCase() + str.substring(1);
 }
@@ -255,79 +269,118 @@ var QueryGrammar = class {
     "offset"
   ];
   toSql(query) {
-    let sql = "";
+    let rc = this.toSqlParts(query);
+    rc.sql = this.joinArray(rc.parts);
+    return rc;
+  }
+  toSqlParts(query) {
+    let parts = [];
     let bindings = [];
     for (const part of this.sqlParts) {
       const funcName = "compile" + toUpperFirst(part);
       const r = this[funcName](query.parts[part]);
-      if (!sql) {
-        sql = r.sql;
-      } else if (r.sql) {
-        sql += " " + r.sql;
-      }
       bindings = [...bindings, ...r.bindings];
+      parts = [...parts, ...r.parts];
     }
-    return { sql, bindings };
+    return {
+      sql: "",
+      bindings,
+      parts
+    };
   }
   compileCount(query) {
     let sql = "";
     let bindings = [];
+    let parts = [];
     for (const part of this.sqlParts) {
-      let parts = query.parts[part];
+      let parts2 = query.parts[part];
       if (part === "select") {
-        parts = ["count(*) as count"];
+        parts2 = ["count(*) as count"];
       }
       const funcName = "compile" + toUpperFirst(part);
-      const r = this[funcName](parts);
-      if (!sql) {
-        sql = r.sql;
-      } else if (r.sql) {
-        sql += " " + r.sql;
-      }
+      const r = this[funcName](parts2);
       bindings = [...bindings, ...r.bindings];
+      parts = [...parts, ...r.parts];
     }
-    return { sql, bindings };
+    return { sql, parts, bindings };
   }
   compileSelect(selects) {
-    const rc = selects.map((v) => {
-      return v;
-    }).join(", ");
-    return { sql: "select " + rc, bindings: [] };
+    const parts = ["select"];
+    selects.map((v) => {
+      parts.push(v);
+      parts.push(",");
+    });
+    parts.pop();
+    return { sql: this.joinArray(parts), parts, bindings: [] };
   }
-  compileTable(tableName) {
+  joinArray(arr) {
     let rc = "";
+    let last = "";
+    for (const a of arr) {
+      if (a === ",") {
+        rc += a;
+      } else if (last === "(" || last === " " || a === ")") {
+        rc += a;
+      } else if (a === "") {
+        rc += "";
+      } else {
+        rc += " " + a;
+      }
+      last = a;
+    }
+    return rc.trim();
+  }
+  compileTable(tableName) {
+    let parts = [];
     if (tableName.length) {
-      rc = "from " + tableName;
+      parts.push("from");
+      parts.push(tableName);
     }
-    return { sql: rc, bindings: [] };
+    return { sql: parts.join(" "), parts, bindings: [] };
   }
   compileJoin(joins) {
     let sql = "";
     let bindings = [];
+    let parts = [];
     for (const j of joins) {
-      sql += " " + j.type + " join " + j.table + " on ";
-      const where = this.compileWhere(j.conditions);
-      if (where.sql.startsWith("where ")) {
-        where.sql = where.sql.substring("where ".length);
+      let table = "";
+      let table_bindings = [];
+      parts.push(j.type);
+      parts.push("join");
+      if (typeof j.table === "string") {
+        parts.push(j.table);
+      } else {
+        const subQuery = j.table;
+        const { parts: parts2, bindings: bindings2 } = subQuery.toSql();
+        parts = [...parts, "(", ...parts2, ")", "as", subQuery.parts.alias || "subquery"];
+        table_bindings = bindings2;
       }
-      sql += "(";
-      sql += where.sql;
-      sql += ")";
-      bindings = [...bindings, ...where.bindings];
+      parts.push("on");
+      const where = this.compileWhere(j.conditions);
+      const where_parts = where.parts;
+      where_parts.shift();
+      parts.push("(");
+      parts = [...parts, ...where_parts];
+      parts.push(")");
+      bindings = [...bindings, ...table_bindings, ...where.bindings];
     }
-    return { sql, bindings };
+    return { sql, parts, bindings };
   }
   compileWhere(wheres) {
     let sql = "";
     let bindings = [];
+    let parts = [];
     for (const w of wheres) {
       sql += " " + w.joinCondition + " ";
+      parts.push(w.joinCondition);
       if (w.negateCondition) {
         sql += "not ";
+        parts.push("not");
       }
       const funcName = "compileWhere" + toUpperFirst(w.type);
       const wh = this[funcName](w);
       sql += wh.sql;
+      parts = parts.concat(wh.parts);
       bindings = [...bindings, ...wh.bindings];
     }
     if (sql.startsWith(" and ")) {
@@ -335,211 +388,239 @@ var QueryGrammar = class {
     } else if (sql.startsWith(" or ")) {
       sql = "where " + sql.substring(" or ".length);
     }
-    return { sql, bindings };
+    if (parts.length > 0) {
+      parts[0] = "where";
+    }
+    return { sql, parts, bindings };
   }
   compileWhereNested(w) {
     const subQuery = w.query;
-    const { sql, bindings } = subQuery.grammar.compileWhere(subQuery.parts.where);
+    let parts = [];
+    const { sql, parts: parts2, bindings } = subQuery.grammar.compileWhere(subQuery.parts.where);
     let sql2 = sql.replace(/^where /, "");
+    parts2.shift();
+    parts.push("(");
+    parts = parts.concat(parts2);
+    parts.push(")");
     return {
       sql: `(${sql2})`,
+      parts,
       bindings
     };
   }
   compileWhereOperation(w) {
     if (w.operation.toLowerCase() === "in" && Array.isArray(w.value)) {
       return {
-        sql: `${w.column} = ANY(${this.getVariablePlaceholder()})`,
+        sql: `${w.column} = ANY( ? )`,
+        parts: [w.column, " = ANY(", "?", ")"],
         bindings: [w.value]
       };
     }
     return {
-      sql: `${w.column} ${w.operation} ${this.getVariablePlaceholder()}`,
+      sql: `${w.column} ${w.operation} ?`,
+      parts: [w.column, w.operation, "?"],
       bindings: [w.value]
     };
   }
   compileWhereOperationColumn(w) {
     return {
       sql: `${w.column1} ${w.operation} ${w.column2}`,
+      parts: [w.column1, w.operation, w.column2],
       bindings: []
     };
   }
   compileWhereRaw(w) {
-    let sql = w.sql.replace(/\?/g, () => this.getVariablePlaceholder());
+    const tokenize = (0, import_sql_tokenizer.sqlTokenizer)();
     return {
-      sql,
+      sql: w.sql,
+      parts: tokenize(w.sql).filter((t) => t !== " "),
       bindings: w.bindings
     };
   }
   compileOrderBy(orderBy) {
     let rc = "";
+    let parts = [];
     if (orderBy.length) {
       rc = "order by " + orderBy.join(", ");
+      parts.push("order by");
+      parts = parts.concat(orderBy);
     }
-    return { sql: rc, bindings: [] };
+    return { sql: rc, parts, bindings: [] };
   }
   compileLimit(limit) {
     let rc = "";
+    let parts = [];
     if (limit !== null) {
       rc = "limit " + limit;
+      parts.push("limit");
+      parts.push(limit);
     }
-    return { sql: rc, bindings: [] };
+    return { sql: rc, parts, bindings: [] };
   }
   compileOffset(offset) {
     let rc = "";
+    let parts = [];
     if (offset !== null) {
       rc = "offset " + offset;
+      parts.push("offset");
+      parts.push(offset);
     }
-    return { sql: rc, bindings: [] };
+    return { sql: rc, parts, bindings: [] };
   }
   compileWhereNull(w) {
     return {
       sql: `${w.column} is null`,
+      parts: [w.column, "is", "null"],
       bindings: []
     };
   }
   compileInsert(query, data) {
-    let sql = "insert into " + query.parts.table + " (";
+    let parts = ["insert", "into", query.parts.table, "("];
     const columns = [];
     const bindings = [];
     const values = [];
     for (const [k, v] of Object.entries(data)) {
-      columns.push(k);
+      parts.push(k);
+      parts.push(",");
+    }
+    parts.pop();
+    parts = parts.concat([")", "values", "("]);
+    for (const [k, v] of Object.entries(data)) {
+      parts.push("?");
       bindings.push(v);
-      values.push(this.getVariablePlaceholder());
+      parts.push(",");
     }
-    sql += columns.join(", ") + ") values (" + values + ")";
-    return { sql, bindings };
+    parts.pop();
+    parts.push(")");
+    return { sql: parts.join(" "), parts, bindings };
   }
   compileUpdate(query, data) {
-    let sql = "update " + query.parts.table + " set ";
     const bindings = [];
+    let parts = ["update", query.parts.table, "set"];
     const setParts = [];
     for (const [k, v] of Object.entries(data)) {
-      setParts.push(`${k} = ${this.getVariablePlaceholder()}`);
+      parts = parts.concat([k, "=", "?", ","]);
+      setParts.push(`${k} = ?`);
       bindings.push(v);
     }
-    sql += setParts.join(", ");
+    parts.pop();
     const where_csql = this.compileWhere(query.parts.where);
-    sql += " " + where_csql.sql;
+    parts = parts.concat(where_csql.parts);
     bindings.push(...where_csql.bindings);
-    return { sql, bindings };
+    return { sql: parts.join(" "), parts, bindings };
   }
   compileDelete(query) {
     let sql = "delete from " + query.parts.table;
+    let parts = ["delete", "from", query.parts.table];
     const where_csql = this.compileWhere(query.parts.where);
     sql += " " + where_csql.sql;
-    return { sql, bindings: where_csql.bindings };
+    parts = parts.concat(where_csql.parts);
+    return { sql, parts, bindings: where_csql.bindings };
   }
   compileUpsert(query, data, conflictFields, updateFields) {
-    let sql = "insert into " + query.parts.table + " (";
-    const columns = [];
+    let parts = [];
     const bindings = [];
-    const values = [];
-    for (const [k, v] of Object.entries(data)) {
-      columns.push(k);
-      bindings.push(v);
-      values.push(this.getVariablePlaceholder());
-    }
-    sql += columns.join(", ") + ") values (" + values + ")";
-    sql += " on conflict (" + conflictFields.join(", ") + ") do update set ";
+    let isql = this.compileInsert(query, data);
+    parts = isql.parts;
+    bindings.push(...isql.bindings);
+    parts = parts.concat(["on", "conflict", "(", ...conflictFields, ")", "do", "update", "set"]);
     const setParts = [];
     for (const f of updateFields) {
       setParts.push(`${f} = excluded.${f}`);
+      setParts.push(`,`);
     }
-    sql += setParts.join(", ");
+    setParts.pop();
+    parts = parts.concat(setParts);
     const where_csql = this.compileWhere(query.parts.where);
-    sql += " " + where_csql.sql;
+    parts = parts.concat(where_csql.parts);
     bindings.push(...where_csql.bindings);
-    return { sql, bindings };
+    return { sql: parts.join(" "), parts, bindings };
   }
   compileGroupBy(groupBy) {
     let rc = "";
+    let parts = [];
     if (groupBy.length) {
       rc = "group by " + groupBy.join(", ");
+      parts.push("group by");
+      parts = parts.concat(groupBy);
     }
-    return { sql: rc, bindings: [] };
+    return { sql: rc, parts, bindings: [] };
   }
   compileHaving(having) {
     let sql = "";
     let bindings = [];
+    let parts = [];
     for (const w of having) {
       sql += " " + w.joinCondition + " ";
+      parts.push(w.joinCondition);
       if (w.negateCondition) {
         sql += "not ";
+        parts.push("not");
       }
       const funcName = "compileHaving" + toUpperFirst(w.type);
       const wh = this[funcName](w);
+      parts = parts.concat(wh.parts);
       sql += wh.sql;
       bindings = [...bindings, ...wh.bindings];
     }
-    if (sql.startsWith(" and ")) {
-      sql = "having " + sql.substring(" and ".length);
-    } else if (sql.startsWith(" or ")) {
-      sql = "having " + sql.substring(" or ".length);
+    if (parts.length > 0) {
+      parts[0] = "having";
     }
-    return { sql, bindings };
+    return { sql: parts.join(" "), parts, bindings };
   }
   compileHavingOperation(w) {
     return {
-      sql: `${w.column} ${w.operation} ${this.getVariablePlaceholder()}`,
+      sql: `${w.column} ${w.operation} ?`,
+      parts: [w.column, w.operation, "?"],
       bindings: [w.value]
     };
   }
   compileHavingRaw(w) {
     return {
       sql: w.sql,
+      parts: w.sql.split(" "),
       bindings: w.bindings
     };
   }
 };
 
 // src/databases/postgresql/PostgresqlQueryGrammar.mts
+var import_neko_helper = require("@devbro/neko-helper");
 var PostgresqlQueryGrammar = class extends QueryGrammar {
   static {
     __name(this, "PostgresqlQueryGrammar");
   }
-  parameterIndex;
   constructor() {
     super();
-    this.parameterIndex = 1;
   }
   toSql(query) {
-    this.parameterIndex = 1;
     return super.toSql(query);
   }
-  getVariablePlaceholder() {
-    return "$" + this.parameterIndex++;
-  }
   compileInsert(query, data) {
-    this.parameterIndex = 1;
     return super.compileInsert(query, data);
   }
   compileInsertGetId(query, data, options = { primaryKey: ["id"] }) {
-    this.parameterIndex = 1;
     const rc = super.compileInsert(query, data);
     rc.sql += ` RETURNING ${options.primaryKey.join(", ")}`;
+    rc.parts = rc.parts.concat(["RETURNING", ...(0, import_neko_helper.intersperse)(options.primaryKey, ",")]);
     return rc;
   }
   compileUpdate(query, data) {
-    this.parameterIndex = 1;
     return super.compileUpdate(query, data);
   }
   compileDelete(query) {
-    this.parameterIndex = 1;
     return super.compileDelete(query);
   }
   compileUpsert(query, data, conflictFields, updateFields) {
-    this.parameterIndex = 1;
     return super.compileUpsert(query, data, conflictFields, updateFields);
   }
   compileCount(query) {
-    this.parameterIndex = 1;
     return super.compileCount(query);
   }
 };
 
 // src/Expression.mts
+var import_sql_tokenizer2 = require("sql-tokenizer");
 var Expression = class {
   constructor(sql = "", bindings = []) {
     this.sql = sql;
@@ -549,7 +630,8 @@ var Expression = class {
     __name(this, "Expression");
   }
   toCompiledSql() {
-    return { sql: this.sql, bindings: this.bindings };
+    const tokenize = (0, import_sql_tokenizer2.sqlTokenizer)(this.sql);
+    return { sql: this.sql, bindings: this.bindings, parts: tokenize(this.sql) };
   }
 };
 
@@ -793,13 +875,14 @@ var SchemaGrammar = class {
       });
     }
     sql += [columns, primaryKeys, ...foreignKeys].join(",") + ")";
-    const compiledSql = { sql, bindings: [] };
+    const compiledSql = { sql, parts: [], bindings: [] };
     if (blueprint.indexes.length > 0) {
       const indexSqls = blueprint.indexes.map((index) => {
         return this.compileIndex(blueprint.tableName, index);
       });
       return {
         sql: [compiledSql.sql, ...indexSqls.map((idx) => idx.sql)].join("; "),
+        parts: [],
         bindings: compiledSql.bindings
       };
     }
@@ -819,9 +902,9 @@ var SchemaGrammar = class {
     }
     let compiledSql;
     if (alterStatements.length > 0) {
-      compiledSql = { sql: sql.join(" "), bindings: [] };
+      compiledSql = { sql: sql.join(" "), parts: [], bindings: [] };
     } else {
-      compiledSql = { sql: sql.join(" ") + " ", bindings: [] };
+      compiledSql = { sql: sql.join(" ") + " ", parts: [], bindings: [] };
     }
     if (blueprint.indexes.length > 0) {
       const indexSqls = blueprint.indexes.map((index) => {
@@ -829,6 +912,7 @@ var SchemaGrammar = class {
       });
       return {
         sql: [compiledSql.sql, ...indexSqls.map((idx) => idx.sql)].join("; "),
+        parts: [],
         bindings: compiledSql.bindings
       };
     }
@@ -908,20 +992,26 @@ var SchemaGrammar = class {
   compileTables(schema = void 0) {
     return {
       sql: "select c.relname as name, n.nspname as schema, pg_total_relation_size(c.oid) as size, obj_description(c.oid, 'pg_class') as comment from pg_class c, pg_namespace n where c.relkind in ('r', 'p') and n.oid = c.relnamespace and " + this.compileSchemaWhereClause(schema, "n.nspname") + " order by n.nspname, c.relname",
+      parts: [],
       bindings: []
     };
   }
   compileTableExists(tableName, schema = "") {
     return {
       sql: "select exists (select 1 from pg_class c, pg_namespace n where n.nspname = " + (schema ? this.escape(schema) : "current_schema()") + " and c.relname = $1 and c.relkind in ('r', 'p') and n.oid = c.relnamespace)",
+      parts: [],
       bindings: [tableName]
     };
   }
   compileDropTable(tableName) {
-    return { sql: `drop table ${this.doubleQuoteString(tableName)}`, bindings: [] };
+    return { sql: `drop table ${this.doubleQuoteString(tableName)}`, parts: [], bindings: [] };
   }
   compileDropTableIfExists(tableName) {
-    return { sql: `drop table if exists ${this.doubleQuoteString(tableName)}`, bindings: [] };
+    return {
+      sql: `drop table if exists ${this.doubleQuoteString(tableName)}`,
+      parts: [],
+      bindings: []
+    };
   }
   compileSchemaWhereClause(schema, column) {
     if (Array.isArray(schema) && schema.length > 0) {
@@ -960,7 +1050,7 @@ var SchemaGrammar = class {
     const uniqueKeyword = index.unique ? "unique " : "";
     const indexType = index._type ? ` using ${index._type}` : "";
     const sql = `create ${uniqueKeyword}index ${indexName} on ${tableName}${indexType} (${index.columns.join(", ")})`;
-    return { sql, bindings: [] };
+    return { sql, parts: [], bindings: [] };
   }
 };
 
@@ -979,7 +1069,7 @@ var Schema = class {
     structMethod(blueprint);
     const grammar = new SchemaGrammar();
     const sql = grammar.toSql(blueprint);
-    await this.connection?.runQuery({ sql, bindings: [] });
+    await this.connection?.runQuery({ sql, parts: [], bindings: [] });
   }
   async alterTable(tableName, structMethod) {
     const blueprint = new Blueprint();
@@ -987,7 +1077,7 @@ var Schema = class {
     structMethod(blueprint);
     const grammar = new SchemaGrammar();
     const sql = grammar.toSql(blueprint);
-    await this.connection?.runQuery({ sql, bindings: [] });
+    await this.connection?.runQuery({ sql, parts: [], bindings: [] });
   }
   async dropTable(tableName) {
     const grammar = new SchemaGrammar();
@@ -1043,7 +1133,12 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
     return true;
   }
   async runQuery(sql) {
-    const result = await this.connection?.query(sql.sql, sql.bindings);
+    let counter = 1;
+    let sql2 = sql.sql;
+    if (sql.parts && sql.parts.length > 0) {
+      sql2 = sql.parts.map((v) => v === "?" ? "$" + counter++ : v).join(" ");
+    }
+    const result = await this.connection?.query(sql2, sql.bindings);
     return result?.rows;
   }
   async runCursor(sql) {