@ronin/compiler 0.10.1 → 0.10.2-leo-ron-1083-experimental-211

package/README.md

@@ -103,7 +103,24 @@ 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
+  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 SQLite (and all other 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.
+  // 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 any duplicated column name is aliased.
+  expandColumns: true
 });
 ```
 

package/dist/index.d.ts

@@ -6005,13 +6005,22 @@ type AmountResult = {
 };
 type Result = SingleRecordResult | MultipleRecordResult | AmountResult;
 
+interface TransactionOptions {
+    /** A list of models that already exist in the database. */
+    models?: Array<PublicModel>;
+    /**
+     * Place statement parameters directly inside the statement strings instead of
+     * 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 {
     statements: Array<Statement>;
     models: Array<Model>;
     private queries;
-    constructor(queries: Array<Query>, options?: Parameters<typeof this.compileQueries>[2] & {
-        models?: Array<PublicModel>;
-    });
+    constructor(queries: Array<Query>, options?: TransactionOptions);
     /**
      * Composes SQL statements for the provided RONIN queries.
      *

package/dist/index.js

@@ -102,6 +102,9 @@ var expand = (obj) => {
     return res;
   }, {});
 };
+var getProperty = (obj, path) => {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+};
 var splitQuery = (query) => {
   const queryType = Object.keys(query)[0];
   const queryModel = Object.keys(query[queryType])[0];
@@ -939,9 +942,24 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
   };
 };
 
-// src/instructions/before-after.ts
+// src/utils/pagination.ts
 var CURSOR_SEPARATOR = ",";
 var CURSOR_NULL_PLACEHOLDER = "RONIN_NULL";
+var generatePaginationCursor = (model, orderedBy, record) => {
+  const { ascending = [], descending = [] } = orderedBy || {};
+  const keys = [...ascending, ...descending];
+  if (keys.length === 0) keys.push("ronin.createdAt");
+  const cursors = keys.map((fieldSlug) => {
+    const property = getProperty(record, fieldSlug);
+    if (property === null || property === void 0) return CURSOR_NULL_PLACEHOLDER;
+    const { field } = getFieldFromModel(model, fieldSlug, "orderedBy");
+    if (field.type === "date") return new Date(property).getTime();
+    return property;
+  });
+  return cursors.map((cursor) => encodeURIComponent(String(cursor))).join(CURSOR_SEPARATOR);
+};
+
+// src/instructions/before-after.ts
 var handleBeforeOrAfter = (model, statementParams, instructions) => {
   if (!(instructions.before || instructions.after)) {
     throw new RoninError({
@@ -1212,6 +1230,11 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
   if (symbol?.type === "query") {
     let { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
     const subQueryModel = getModelBySlug(models, subQueryModelSlug);
+    if (subQueryInstructions?.selecting) {
+      const currentFields = new Set(subQueryInstructions.selecting);
+      currentFields.add("id");
+      subQueryInstructions.selecting = Array.from(currentFields);
+    }
     const subQuerySelectedFields = subQueryInstructions?.selecting;
     const subQueryIncludedFields = subQueryInstructions?.including;
     const subQueryFields = [
@@ -1234,7 +1257,19 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
         ...subQueryInstructions.including
       };
     }
-    return compileQueryInput(symbol.value, models, statementParams).main.statement;
+    let statement2 = "";
+    if (subQuerySelectedFields) {
+      const selectedFields = [
+        ...subQueryFields,
+        ...defaultFieldsToAdd.map(([key]) => key)
+      ];
+      const columns = selectedFields.map((field) => {
+        return getFieldFromModel(model, field, "to").fieldSelector;
+      });
+      statement2 = `(${columns.join(", ")}) `;
+    }
+    statement2 += compileQueryInput(symbol.value, models, statementParams).main.statement;
+    return statement2;
   }
   Object.assign(toInstruction, defaultFields);
   for (const fieldSlug in toInstruction) {
@@ -1498,11 +1533,47 @@ var Transaction = class {
     return expand(formattedRecord);
   }
   prepareResults(results) {
-    return results.map((result, index) => {
+    const relevantResults = results.filter((_, index) => {
+      return this.statements[index].returning;
+    });
+    return relevantResults.map((result, index) => {
       const query = this.queries.at(-index);
-      const { queryModel } = splitQuery(query);
+      const { queryType, queryModel, queryInstructions } = splitQuery(query);
       const model = getModelBySlug(this.models, queryModel);
-      return { record: this.formatRecord(model, result[0]) };
+      if (queryType === "count") {
+        return { amount: result[0]["COUNT(*)"] };
+      }
+      const single = queryModel !== model.pluralSlug;
+      if (single) {
+        return { record: this.formatRecord(model, result[0]) };
+      }
+      const pageSize = queryInstructions?.limitedTo;
+      const output = {
+        records: result.map((resultItem) => {
+          return this.formatRecord(model, resultItem);
+        })
+      };
+      if (pageSize && output.records.length > 0) {
+        if (queryInstructions?.before || queryInstructions?.after) {
+          const direction = queryInstructions?.before ? "moreAfter" : "moreBefore";
+          const firstRecord = output.records[0];
+          output[direction] = generatePaginationCursor(
+            model,
+            queryInstructions.orderedBy,
+            firstRecord
+          );
+        }
+        if (output.records.length > pageSize) {
+          const direction = queryInstructions?.before ? "moreBefore" : "moreAfter";
+          const lastRecord = output.records.pop();
+          output[direction] = generatePaginationCursor(
+            model,
+            queryInstructions.orderedBy,
+            lastRecord
+          );
+        }
+      }
+      return output;
     });
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.10.1",
+  "version": "0.10.2-leo-ron-1083-experimental-211",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {