@ronin/compiler 0.17.8 → 0.17.9-leo-ron-1099-experimental-398

package/dist/index.d.ts

@@ -269,6 +269,13 @@ type ModelField = ModelFieldBasics & ({
     /** Whether the field should be related to one record, or many records. */
     kind: 'many';
 });
+/** An extended version of `ModelField`, for internal use within the compiler. */
+type InternalModelField = ModelField & {
+    /** The path on the final record where the value of the field should be mounted. */
+    mountingPath: string;
+    /** A custom value that was provided in the query, which is not stored in the DB. */
+    mountedValue?: unknown;
+};
 type ModelIndexField<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
     /** The collating sequence used for text placed inside the field. */
     collation?: ModelFieldCollation;
@@ -423,6 +430,20 @@ declare class Transaction {
     statements: Array<Statement>;
     models: Array<Model>;
     constructor(queries: Array<Query>, options?: TransactionOptions);
+    /**
+     * Formats an individual result of a query (each query has one individual result).
+     *
+     * @param queryType - The type of query that is being executed.
+     * @param queryInstructions - The instructions of the query that is being executed.
+     * @param model - The model for which the query is being executed.
+     * @param rows - The rows that were returned from the database for the query (in the
+     * form of an array containing arrays that contain strings).
+     * @param selectedFields - The model fields that were selected by the query.
+     * @param single - Whether a single or multiple records are being affected by the query.
+     *
+     * @returns A formatted RONIN result for a particular query.
+     */
+    formatIndividualResult<RecordType>(queryType: QueryType, queryInstructions: CombinedInstructions, model: Model, rows: Array<Array<RawRow>>, selectedFields: Array<InternalModelField>, single: boolean): RegularResult<RecordType>;
     formatResults<RecordType>(results: Array<Array<ObjectRow>>, raw?: false): Array<Result<RecordType>>;
     formatResults<RecordType>(results: Array<Array<RawRow>>, raw?: true): Array<Result<RecordType>>;
 }

package/dist/index.js

@@ -1035,7 +1035,12 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     }
   );
   if (query === null)
-    return { dependencies: [], main: dependencyStatements[0], selectedFields: [] };
+    return {
+      dependencies: [],
+      main: dependencyStatements[0],
+      selectedFields: [],
+      model: ROOT_MODEL_WITH_ATTRIBUTES
+    };
   const parsedQuery = splitQuery(query);
   const { queryType, queryModel, queryInstructions } = parsedQuery;
   const model = getModelBySlug(models, queryModel);
@@ -1192,7 +1197,8 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   return {
     dependencies: dependencyStatements,
     main: mainStatement,
-    selectedFields
+    selectedFields,
+    model
   };
 };
 
@@ -2065,21 +2071,25 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
 var Transaction = class {
   statements = [];
   models = [];
-  #internalStatements = [];
+  #internalQueries = [];
   constructor(queries, options) {
     const models = options?.models || [];
-    this.#compileQueries(queries, models, options);
+    this.#internalQueries = queries.map((query) => ({
+      query,
+      selectedFields: [],
+      models: []
+    }));
+    this.#compileQueries(models, options);
   }
   /**
    * Composes SQL statements for the provided RONIN queries.
    *
-   * @param queries - The RONIN queries for which SQL statements should be composed.
    * @param models - A list of models.
    * @param options - Additional options to adjust the behavior of the statement generation.
    *
    * @returns The composed SQL statements.
    */
-  #compileQueries = (queries, models, options) => {
+  #compileQueries = (models, options) => {
     const modelsWithAttributes = models.map((model) => {
       return addDefaultModelAttributes(model, true);
     });
@@ -2095,30 +2105,33 @@ var Transaction = class {
       return addDefaultModelPresets(modelsWithFields, model);
     });
     const statements = [];
-    const expandedQueries = queries.flatMap((query, expansionIndex) => {
+    const expandedQueries = this.#internalQueries.flatMap(({ query }, index) => {
       const { queryType, queryModel, queryInstructions } = splitQuery(query);
       if (queryModel === "all") {
         const { for: forInstruction, ...restInstructions } = queryInstructions || {};
-        let modelList = modelsWithAttributes;
+        let modelList = modelsWithPresets.filter((model) => {
+          return model.slug !== ROOT_MODEL.slug;
+        });
         if (forInstruction) {
-          const mainModel = getModelBySlug(modelsWithAttributes, forInstruction);
+          const mainModel = getModelBySlug(modelList, forInstruction);
           modelList = Object.values(mainModel.fields || {}).filter((field) => field.type === "link").map((field) => {
-            return modelsWithAttributes.find(
+            return modelList.find(
               (model) => model.slug === field.target
             );
           });
         }
+        this.#internalQueries[index].models = modelList;
         return modelList.map((model) => {
           const query2 = {
             [queryType]: { [model.pluralSlug]: restInstructions }
           };
-          return { query: query2, expansionIndex };
+          return { query: query2, index };
         });
       }
-      return { query };
+      return { query, index };
     });
-    for (const { query, expansionIndex } of expandedQueries) {
-      const { dependencies, main, selectedFields } = compileQueryInput(
+    for (const { query, index } of expandedQueries) {
+      const { dependencies, main, selectedFields, model } = compileQueryInput(
         query,
         modelsWithPresets,
         options?.inlineParams ? null : [],
@@ -2129,14 +2142,10 @@ var Transaction = class {
       const postDependencies = dependencies.map(({ after, ...rest }) => after ? rest : null).filter((item) => item != null);
       const subStatements = [...preDependencies, main, ...postDependencies];
       this.statements.push(...subStatements);
-      this.#internalStatements.push(
-        ...subStatements.map((statement) => ({
-          ...statement,
-          query,
-          selectedFields,
-          expansionIndex
-        }))
-      );
+      this.#internalQueries[index].selectedFields = selectedFields;
+      if (this.#internalQueries[index].models.length === 0) {
+        this.#internalQueries[index].models = [model];
+      }
     }
     this.models = modelsWithPresets;
     return statements;
@@ -2210,6 +2219,68 @@ var Transaction = class {
     }
     return single ? records[0] : records;
   }
+  /**
+   * Formats an individual result of a query (each query has one individual result).
+   *
+   * @param queryType - The type of query that is being executed.
+   * @param queryInstructions - The instructions of the query that is being executed.
+   * @param model - The model for which the query is being executed.
+   * @param rows - The rows that were returned from the database for the query (in the
+   * form of an array containing arrays that contain strings).
+   * @param selectedFields - The model fields that were selected by the query.
+   * @param single - Whether a single or multiple records are being affected by the query.
+   *
+   * @returns A formatted RONIN result for a particular query.
+   */
+  formatIndividualResult(queryType, queryInstructions, model, rows, selectedFields, single) {
+    const modelFields = Object.fromEntries(
+      Object.entries(model.fields).map(([slug, rest]) => [slug, rest.type])
+    );
+    if (queryType === "count") {
+      return { amount: rows[0][0] };
+    }
+    if (single) {
+      return {
+        record: rows[0] ? this.#formatRows(selectedFields, rows, true) : null,
+        modelFields
+      };
+    }
+    const pageSize = queryInstructions?.limitedTo;
+    const result = {
+      records: this.#formatRows(selectedFields, rows, false),
+      modelFields
+    };
+    if (pageSize && result.records.length > 0) {
+      if (result.records.length > pageSize) {
+        if (queryInstructions?.before) {
+          result.records.shift();
+        } else {
+          result.records.pop();
+        }
+        const direction = queryInstructions?.before ? "moreBefore" : "moreAfter";
+        const lastRecord = result.records.at(
+          direction === "moreAfter" ? -1 : 0
+        );
+        result[direction] = generatePaginationCursor(
+          model,
+          queryInstructions.orderedBy,
+          lastRecord
+        );
+      }
+      if (queryInstructions?.before || queryInstructions?.after) {
+        const direction = queryInstructions?.before ? "moreAfter" : "moreBefore";
+        const firstRecord = result.records.at(
+          direction === "moreAfter" ? -1 : 0
+        );
+        result[direction] = generatePaginationCursor(
+          model,
+          queryInstructions.orderedBy,
+          firstRecord
+        );
+      }
+    }
+    return result;
+  }
   /**
    * Format the results returned from the database into RONIN records.
    *
@@ -2223,78 +2294,46 @@ var Transaction = class {
    * RONIN record, an array of RONIN records, or a RONIN count result.
    */
   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 (query.count) return [row.amount];
-        return Object.values(row);
-      });
-    });
-    return normalizedResults.reduce(
-      (finalResults, rows, index) => {
-        const { returning, query, selectedFields, expansionIndex } = this.#internalStatements[index];
-        if (!returning) return finalResults;
-        const addResult = (result2) => {
-          if (typeof expansionIndex !== "undefined") {
-            let match = finalResults[expansionIndex];
-            if (!match) match = finalResults[expansionIndex] = { models: {} };
-            match.models[queryModel] = result2;
-          } else {
-            finalResults.push(result2);
-          }
-          return finalResults;
-        };
+    const cleanResults = results.filter((_, index) => this.statements[index].returning);
+    let resultIndex = 0;
+    return this.#internalQueries.reduce(
+      (finalResults, internalQuery) => {
+        const { query, selectedFields, models: affectedModels } = internalQuery;
         const { queryType, queryModel, queryInstructions } = splitQuery(query);
-        const model = getModelBySlug(this.models, queryModel);
-        const modelFields = Object.fromEntries(
-          Object.entries(model.fields).map(([slug, rest]) => [slug, rest.type])
-        );
-        if (queryType === "count") {
-          return addResult({ amount: rows[0][0] });
-        }
-        const single = queryModel !== model.pluralSlug;
-        if (single) {
-          return addResult({
-            record: rows[0] ? this.#formatRows(selectedFields, rows, true) : null,
-            modelFields
+        const absoluteResults = raw ? cleanResults : cleanResults.map((rows) => {
+          return rows.map((row) => {
+            if (Array.isArray(row)) return row;
+            if (queryType === "count") return [row.amount];
+            return Object.values(row);
           });
-        }
-        const pageSize = queryInstructions?.limitedTo;
-        const result = {
-          records: this.#formatRows(selectedFields, rows, false),
-          modelFields
-        };
-        if (pageSize && result.records.length > 0) {
-          if (result.records.length > pageSize) {
-            if (queryInstructions?.before) {
-              result.records.shift();
-            } else {
-              result.records.pop();
-            }
-            const direction = queryInstructions?.before ? "moreBefore" : "moreAfter";
-            const lastRecord = result.records.at(
-              direction === "moreAfter" ? -1 : 0
-            );
-            result[direction] = generatePaginationCursor(
-              model,
-              queryInstructions.orderedBy,
-              lastRecord
-            );
-          }
-          if (queryInstructions?.before || queryInstructions?.after) {
-            const direction = queryInstructions?.before ? "moreAfter" : "moreBefore";
-            const firstRecord = result.records.at(
-              direction === "moreAfter" ? -1 : 0
-            );
-            result[direction] = generatePaginationCursor(
+        });
+        if (queryModel === "all") {
+          const models = {};
+          for (const model of affectedModels) {
+            const result = this.formatIndividualResult(
+              queryType,
+              queryInstructions,
               model,
-              queryInstructions.orderedBy,
-              firstRecord
+              absoluteResults[resultIndex++],
+              selectedFields,
+              false
             );
+            models[model.pluralSlug] = result;
           }
+          finalResults.push({ models });
+        } else {
+          const model = affectedModels[0];
+          const result = this.formatIndividualResult(
+            queryType,
+            queryInstructions,
+            model,
+            absoluteResults[resultIndex++],
+            selectedFields,
+            queryModel !== model.pluralSlug
+          );
+          finalResults.push(result);
         }
-        return addResult(result);
+        return finalResults;
       },
       []
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.17.8",
+  "version": "0.17.9-leo-ron-1099-experimental-398",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {