@ronin/compiler 0.14.9 → 0.14.10

package/README.md

@@ -70,7 +70,7 @@ executed and their results can be formatted by the compiler as well:
 
 ```typescript
 // Passing `rawResults` (rows being arrays of values) provided by the database (ideal)
-const results: Array<Result> = transaction.formatResults(rawResults);
+const results: Array<Result> = transaction.formatResults(rawResults, true);
 
 // Passing `objectResults` (rows being objects) provided by a driver
 const results: Array<Result> = transaction.formatResults(objectResults, false);
@@ -127,26 +127,7 @@ new Transaction(queries, {
   // Instead of returning an array of parameters for every statement (which allows for
   // preventing SQL injections), all parameters are inlined directly into the SQL strings.
   // This option should only be used if the generated SQL will be manually verified.
-  inlineParams: true,
-
-  // By default, in the generated SQL statements, the compiler does not alias columns if
-  // multiple different tables with the same column names are being joined. Only the table
-  // names themselves are aliased.
-  //
-  // This ensures the cleanest possible SQL statements in conjunction with the default
-  // behavior of SQL databases, where the result of a statement is a list (array) of
-  // values, which are inherently not prone to conflicts.
-  //
-  // If the driver being used instead returns an object for every row, the driver must
-  // ensure the uniqueness of every key in that object, which means prefixing duplicated
-  // column names with the name of the respective table, if multiple tables are joined
-  // (example for an object key: "table_name.column_name").
-  //
-  // Drivers that return objects for rows offer this behavior as an option that is
-  // usually called "expand columns". If the driver being used does not offer such an
-  // option, you can instead activate the option in the compiler, which results in longer
-  // SQL statements because all column names are aliased.
-  expandColumns: true
+  inlineParams: true
 });
 ```
 

package/dist/index.d.ts

@@ -394,8 +394,6 @@ interface TransactionOptions {
      * separating them out into a dedicated `params` array.
      */
     inlineParams?: boolean;
-    /** Alias column names that are duplicated when joining multiple tables. */
-    expandColumns?: boolean;
 }
 declare class Transaction {
     #private;

package/dist/index.js

@@ -25,12 +25,13 @@ var CURRENT_TIME_EXPRESSION = {
 };
 var MOUNTING_PATH_SUFFIX = /(.*?)(\{(\d+)\})?$/;
 var composeMountingPath = (single, key, mountingPath) => {
-  const subMountingPath = key === "ronin_root" ? mountingPath ? mountingPath.replace(
-    MOUNTING_PATH_SUFFIX,
-    (_, p, __, n) => `${p}{${n ? +n + 1 : 1}}`
-  ) : void 0 : `${mountingPath ? `${mountingPath}.` : ""}${single ? key : `${key}[0]`}`;
-  const tableAlias = `including_${subMountingPath || key}`;
-  return { subMountingPath, tableAlias };
+  if (key === "ronin_root") {
+    return mountingPath ? mountingPath.replace(
+      MOUNTING_PATH_SUFFIX,
+      (_, p, __, n) => `${p}{${n ? +n + 1 : 1}}`
+    ) : key;
+  }
+  return `${mountingPath ? `${mountingPath}.` : ""}${single ? key : `${key}[0]`}`;
 };
 var MODEL_ENTITY_ERROR_CODES = {
   field: "FIELD_NOT_FOUND",
@@ -318,11 +319,12 @@ var handleIncluding = (models, model, statementParams, single, instruction, opti
     let joinType = "LEFT";
     let relatedTableSelector = `"${relatedModel.table}"`;
     const subSingle = queryModel !== relatedModel.pluralSlug;
-    const { tableAlias, subMountingPath } = composeMountingPath(
+    const subMountingPath = composeMountingPath(
       subSingle,
       ephemeralFieldSlug,
       options.mountingPath
     );
+    const tableAlias = `including_${subMountingPath}`;
     if (!modifiableQueryInstructions?.with) {
       joinType = "CROSS";
       if (subSingle) {
@@ -419,12 +421,11 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
     instructions.selecting
   ).filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => {
     const newField = { ...field, mountingPath: field.slug };
-    if (options.mountingPath) {
+    if (options.mountingPath && options.mountingPath !== "ronin_root") {
       newField.mountingPath = `${options.mountingPath.replace(/\{\d+\}/g, "")}.${field.slug}`;
     }
     return newField;
   });
-  if (instructions.selecting) options.expandColumns = true;
   const joinedSelectedFields = [];
   const joinedColumns = [];
   if (instructions.including) {
@@ -440,18 +441,13 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
         const { queryModel, queryInstructions } = splitQuery(symbol2.value);
         const subQueryModel = getModelBySlug(models, queryModel);
         isJoining = true;
-        if (queryInstructions?.selecting) options.expandColumns = true;
         const subSingle = queryModel !== subQueryModel.pluralSlug;
         if (!model.tableAlias)
           model.tableAlias = single && !subSingle ? `sub_${model.table}` : model.table;
-        const { tableAlias, subMountingPath } = composeMountingPath(
-          subSingle,
-          key,
-          options.mountingPath
-        );
+        const subMountingPath = composeMountingPath(subSingle, key, options.mountingPath);
         const { columns: nestedColumns, selectedFields: nestedSelectedFields } = handleSelecting(
           models,
-          { ...subQueryModel, tableAlias },
+          { ...subQueryModel, tableAlias: `including_${subMountingPath}` },
           statementParams,
           subSingle,
           {
@@ -478,11 +474,7 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
       });
     }
   }
-  let columns = ["*"];
-  const fieldsToExpand = options.expandColumns ? selectedFields : selectedFields.filter(
-    (loadedField) => typeof loadedField.mountedValue !== "undefined"
-  );
-  const extraColumns = fieldsToExpand.map((selectedField) => {
+  const columns = selectedFields.map((selectedField) => {
     if (selectedField.mountedValue) {
       return `${selectedField.mountedValue} as "${selectedField.slug}"`;
     }
@@ -494,11 +486,6 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
     }
     return fieldSelector;
   });
-  if (options.expandColumns) {
-    columns = extraColumns;
-  } else if (extraColumns) {
-    columns.push(...extraColumns);
-  }
   columns.push(...joinedColumns);
   selectedFields.push(...joinedSelectedFields);
   return { columns: columns.join(", "), isJoining, selectedFields };
@@ -631,6 +618,15 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   if (instructions && Object.hasOwn(instructions, "for")) {
     instructions = handleFor(model, instructions);
   }
+  if (queryType === "count") {
+    if (!instructions) instructions = {};
+    instructions.selecting = ["amount"];
+    instructions.including = Object.assign(instructions?.including || {}, {
+      amount: {
+        [QUERY_SYMBOLS.EXPRESSION]: "COUNT(*)"
+      }
+    });
+  }
   const { columns, isJoining, selectedFields } = handleSelecting(
     models,
     model,
@@ -639,12 +635,12 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     {
       selecting: instructions?.selecting,
       including: instructions?.including
-    },
-    options
+    }
   );
   let statement = "";
   switch (queryType) {
     case "get":
+    case "count":
       statement += `SELECT ${columns} FROM `;
       break;
     case "set":
@@ -656,9 +652,6 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     case "remove":
       statement += "DELETE FROM ";
       break;
-    case "count":
-      statement += `SELECT COUNT(${columns}) FROM `;
-      break;
   }
   let isJoiningMultipleRows = false;
   if (isJoining) {
@@ -753,7 +746,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     statement += handleLimitedTo(single, instructions?.limitedTo);
   }
   if (["add", "set", "remove"].includes(queryType) && returning) {
-    statement += "RETURNING * ";
+    statement += `RETURNING ${columns}`;
   }
   const mainStatement = {
     statement: statement.trimEnd(),
@@ -1390,13 +1383,9 @@ var composeAssociationModelSlug = (model, field) => convertToCamelCase(`ronin_li
 var getFieldSelector = (model, field, fieldPath, writing) => {
   const symbol = model.tableAlias?.startsWith(QUERY_SYMBOLS.FIELD_PARENT) ? `${model.tableAlias.replace(QUERY_SYMBOLS.FIELD_PARENT, "").slice(0, -1)}.` : "";
   const tablePrefix = symbol || (model.tableAlias ? `"${model.tableAlias}".` : "");
-  if ((field.type === "json" || field.type === "blob") && !writing) {
-    const dotParts = fieldPath.split(".");
-    const columnName = tablePrefix + dotParts.shift();
-    if (dotParts.length > 0) {
-      const jsonField = dotParts.join(".");
-      return `json_extract(${columnName}, '$.${jsonField}')`;
-    }
+  if ((field.type === "json" || field.type === "blob") && !writing && fieldPath.length > field.slug.length) {
+    const jsonField = fieldPath.replace(`${field.slug}.`, "");
+    return `json_extract(${tablePrefix + field.slug}, '$.${jsonField}')`;
   }
   return `${tablePrefix}"${fieldPath}"`;
 };
@@ -1988,8 +1977,7 @@ var Transaction = class {
       const { dependencies, main, selectedFields } = compileQueryInput(
         query,
         modelsWithPresets,
-        options?.inlineParams ? null : [],
-        { expandColumns: options?.expandColumns }
+        options?.inlineParams ? null : []
       );
       const preDependencies = dependencies.filter(({ after }) => !after);
       const postDependencies = dependencies.map(({ after, ...rest }) => after ? rest : null).filter((item) => item != null);
@@ -2083,18 +2071,19 @@ var Transaction = class {
    *
    * @param results - A list of results from the database, where each result is an array
    * of rows.
-   * @param raw - By default, rows are expected to be arrays of values, which is how SQL
-   * databases return rows by default. If the driver being used returns rows as objects
-   * instead, this option should be set to `false`.
+   * @param raw - By default, rows are expected to be objects. If the driver being used
+   * returns rows as arrays of values (which is how SQL databases return rows directly),
+   * this option should be set to `true`.
    *
    * @returns A list of formatted RONIN results, where each result is either a single
    * RONIN record, an array of RONIN records, or a RONIN count result.
    */
-  formatResults(results, raw = true) {
-    const normalizedResults = raw ? results : results.map((rows) => {
+  formatResults(results, raw = false) {
+    const normalizedResults = raw ? results : results.map((rows, index) => {
+      const { query } = this.#internalStatements[index];
       return rows.map((row) => {
         if (Array.isArray(row)) return row;
-        if (row["COUNT(*)"]) return [row["COUNT(*)"]];
+        if (query.count) return [row.amount];
         return Object.values(row);
       });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.14.9",
+  "version": "0.14.10",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {