@ronin/compiler 0.17.7 → 0.17.8-leo-ron-1099-experimental-396

package/dist/index.d.ts

@@ -117,6 +117,14 @@ type AddQuery = Record<string, Omit<CombinedInstructions, 'with' | 'using'> & {
 }>;
 type RemoveQuery = Record<string, Omit<CombinedInstructions, 'to'>>;
 type CountQuery = Record<string, Omit<CombinedInstructions, 'to'> | null>;
+type AllQueryInstructions = {
+    for?: string;
+};
+type AllQuery = {
+    all: AllQueryInstructions | null;
+};
+type GetAllQuery = AllQuery;
+type CountAllQuery = AllQuery;
 type GetInstructions = Omit<CombinedInstructions, 'to'>;
 type SetInstructions = Omit<CombinedInstructions, 'to'> & {
     to: FieldSelector;
@@ -158,11 +166,11 @@ type DropQuery = {
     model: string;
 };
 type Query = {
-    get?: GetQuery;
+    get?: GetQuery | GetAllQuery;
     set?: SetQuery;
     add?: AddQuery;
     remove?: RemoveQuery;
-    count?: CountQuery;
+    count?: CountQuery | CountAllQuery;
     create?: CreateQuery;
     alter?: AlterQuery;
     drop?: DropQuery;
@@ -261,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;
@@ -415,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 if 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,11 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     }
   );
   if (query === null)
-    return { dependencies: [], main: dependencyStatements[0], selectedFields: [] };
+    return {
+      dependencies: [],
+      main: dependencyStatements[0],
+      selectedFields: []
+    };
   const parsedQuery = splitQuery(query);
   const { queryType, queryModel, queryInstructions } = parsedQuery;
   const model = getModelBySlug(models, queryModel);
@@ -1719,7 +1723,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
   const action = subAltering && query.alter ? Object.keys(query.alter).filter((key) => key !== "model")[0] : queryType;
   const actionReadable = action === "create" ? "creating" : action === "alter" ? "altering" : "dropping";
   const entity = subAltering && query.alter ? Object.keys(query.alter[action])[0] : "model";
-  let slug = entity === "model" && action === "create" ? null : query[queryType].model;
+  let slug = entity === "model" && action === "create" ? null : query[queryType] && "model" in query[queryType] ? query[queryType].model : null;
   let modelSlug = slug;
   let jsonValue;
   if ("create" in query && query.create) {
@@ -2065,21 +2069,21 @@ 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: [] }));
+    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,19 +2099,33 @@ var Transaction = class {
       return addDefaultModelPresets(modelsWithFields, model);
     });
     const statements = [];
-    const expandedQueries = queries.flatMap((query, expansionIndex) => {
+    const expandedQueries = this.#internalQueries.flatMap(({ query }, expansionIndex) => {
       const { queryType, queryModel, queryInstructions } = splitQuery(query);
       if (queryModel === "all") {
-        return modelsWithAttributes.map((model) => {
+        const { for: forInstruction, ...restInstructions } = queryInstructions || {};
+        let modelList = modelsWithAttributes;
+        if (forInstruction) {
+          const mainModel = getModelBySlug(modelsWithAttributes, forInstruction);
+          modelList = Object.values(mainModel.fields || {}).filter((field) => field.type === "link").map((field) => {
+            return modelsWithAttributes.find(
+              (model) => model.slug === field.target
+            );
+          });
+        }
+        this.#internalQueries[expansionIndex].affectedModels = modelList.map(
+          (model) => model.slug
+        );
+        return modelList.map((model) => {
           const query2 = {
-            [queryType]: { [model.pluralSlug]: queryInstructions }
+            [queryType]: { [model.pluralSlug]: restInstructions }
           };
           return { query: query2, expansionIndex };
         });
       }
       return { query };
     });
-    for (const { query, expansionIndex } of expandedQueries) {
+    for (let index = 0; index < expandedQueries.length; index++) {
+      const { query, expansionIndex } = expandedQueries[index];
       const { dependencies, main, selectedFields } = compileQueryInput(
         query,
         modelsWithPresets,
@@ -2119,14 +2137,8 @@ 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
-        }))
-      );
+      const queryIndex = typeof expansionIndex === "undefined" ? index : expansionIndex;
+      this.#internalQueries[queryIndex].selectedFields = selectedFields;
     }
     this.models = modelsWithPresets;
     return statements;
@@ -2200,6 +2212,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 if 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.
    *
@@ -2213,78 +2287,49 @@ 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, 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" && affectedModels) {
+          const modelList = affectedModels.map((slug) => {
+            return getModelBySlug(this.models, slug);
+          });
+          const models = {};
+          for (const model of modelList) {
+            const result = this.formatIndividualResult(
+              queryType,
+              queryInstructions,
               model,
-              queryInstructions.orderedBy,
-              firstRecord
+              absoluteResults[resultIndex++],
+              selectedFields,
+              false
             );
+            models[model.pluralSlug] = result;
           }
+          finalResults.push({ models });
+        } else {
+          const model = getModelBySlug(this.models, queryModel);
+          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.7",
+  "version": "0.17.8-leo-ron-1099-experimental-396",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {