@ronin/compiler 0.15.0 → 0.16.0

package/dist/index.d.ts

@@ -391,7 +391,9 @@ type MultipleRecordResult<T = ResultRecord> = {
 type AmountResult = {
     amount: number;
 };
-type Result<T = ResultRecord> = SingleRecordResult<T> | MultipleRecordResult<T> | AmountResult;
+type RegularResult<T = ResultRecord> = SingleRecordResult<T> | MultipleRecordResult<T> | AmountResult;
+type ExpandedResult<T = ResultRecord> = Record<Model['slug'], RegularResult<T>>;
+type Result<T = ResultRecord> = RegularResult<T> | ExpandedResult<T>;
 
 interface TransactionOptions {
     /** A list of models that already exist in the database. */
@@ -407,8 +409,8 @@ declare class Transaction {
     statements: Array<Statement>;
     models: Array<Model>;
     constructor(queries: Array<Query>, options?: TransactionOptions);
-    formatResults<Record>(results: Array<Array<ObjectRow>>, raw?: false): Array<Result<Record>>;
-    formatResults<Record>(results: Array<Array<RawRow>>, raw?: true): Array<Result<Record>>;
+    formatResults<RecordType>(results: Array<Array<ObjectRow>>, raw?: false): Array<Result<RecordType>>;
+    formatResults<RecordType>(results: Array<Array<RawRow>>, raw?: true): Array<Result<RecordType>>;
 }
 
 declare const CLEAN_ROOT_MODEL: PublicModel;

package/dist/index.js

@@ -566,8 +566,14 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
 // src/instructions/using.ts
 var handleUsing = (model, instructions) => {
   const normalizedUsing = Array.isArray(instructions.using) ? Object.fromEntries(instructions.using.map((presetSlug) => [presetSlug, null])) : instructions.using;
+  if ("links" in normalizedUsing) {
+    for (const field of model.fields) {
+      if (field.type !== "link" || field.kind === "many") continue;
+      normalizedUsing[field.slug] = null;
+    }
+  }
   for (const presetSlug in normalizedUsing) {
-    if (!Object.hasOwn(normalizedUsing, presetSlug)) continue;
+    if (!Object.hasOwn(normalizedUsing, presetSlug) || presetSlug === "links") continue;
     const arg = normalizedUsing[presetSlug];
     const preset = model.presets?.find((preset2) => preset2.slug === presetSlug);
     if (!preset) {
@@ -1509,6 +1515,7 @@ var ROOT_MODEL = {
     { slug: "presets", type: "json", defaultValue: "{}" }
   ]
 };
+var ROOT_MODEL_WITH_ATTRIBUTES = addDefaultModelAttributes(ROOT_MODEL, true);
 var getSystemModels = (models, model) => {
   const addedModels = [];
   for (const field of model.fields || []) {
@@ -1990,14 +1997,14 @@ var Transaction = class {
    * @returns The composed SQL statements.
    */
   #compileQueries = (queries, models, options) => {
-    const modelsWithAttributes = [ROOT_MODEL, ...models].map((model) => {
+    const modelsWithAttributes = models.map((model) => {
       return addDefaultModelAttributes(model, true);
     });
     const modelsWithFields = [
       ...modelsWithAttributes.flatMap((model) => {
         return getSystemModels(modelsWithAttributes, model);
       }),
-      ...modelsWithAttributes
+      ...[ROOT_MODEL_WITH_ATTRIBUTES, ...modelsWithAttributes]
     ].map((model) => {
       return addDefaultModelFields(model, true);
     });
@@ -2005,7 +2012,19 @@ var Transaction = class {
       return addDefaultModelPresets(modelsWithFields, model);
     });
     const statements = [];
-    for (const query of queries) {
+    const expandedQueries = queries.flatMap((query, expansionIndex) => {
+      const { queryType, queryModel, queryInstructions } = splitQuery(query);
+      if (queryModel === "all") {
+        return modelsWithAttributes.map((model) => {
+          const query2 = {
+            [queryType]: { [model.pluralSlug]: queryInstructions }
+          };
+          return { query: query2, expansionIndex };
+        });
+      }
+      return { query };
+    });
+    for (const { query, expansionIndex } of expandedQueries) {
       const { dependencies, main, selectedFields } = compileQueryInput(
         query,
         modelsWithPresets,
@@ -2019,7 +2038,8 @@ var Transaction = class {
         ...subStatements.map((statement) => ({
           ...statement,
           query,
-          selectedFields
+          selectedFields,
+          expansionIndex
         }))
       );
     }
@@ -2119,10 +2139,19 @@ var Transaction = class {
         return Object.values(row);
       });
     });
-    const formattedResults = normalizedResults.map(
-      (rows, index) => {
-        const { returning, query, selectedFields } = this.#internalStatements[index];
-        if (!returning) return null;
+    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") {
+            if (!finalResults[expansionIndex]) finalResults[expansionIndex] = {};
+            finalResults[expansionIndex][queryModel] = result2;
+          } else {
+            finalResults.push(result2);
+          }
+          return finalResults;
+        };
         const { queryType, queryModel, queryInstructions } = splitQuery(query);
         const model = getModelBySlug(this.models, queryModel);
         const isMeta = queryModel === "model" || queryModel === "models";
@@ -2130,32 +2159,32 @@ var Transaction = class {
           model.fields.map((field) => [field.slug, field.type])
         );
         if (queryType === "count") {
-          return { amount: rows[0][0] };
+          return addResult({ amount: rows[0][0] });
         }
         const single = queryModel !== model.pluralSlug;
         if (single) {
-          return {
+          return addResult({
             record: rows[0] ? this.#formatRows(selectedFields, rows, true, isMeta) : null,
             modelFields
-          };
+          });
         }
         const pageSize = queryInstructions?.limitedTo;
-        const output = {
+        const result = {
           records: this.#formatRows(selectedFields, rows, false, isMeta),
           modelFields
         };
-        if (pageSize && output.records.length > 0) {
-          if (output.records.length > pageSize) {
+        if (pageSize && result.records.length > 0) {
+          if (result.records.length > pageSize) {
             if (queryInstructions?.before) {
-              output.records.shift();
+              result.records.shift();
             } else {
-              output.records.pop();
+              result.records.pop();
             }
             const direction = queryInstructions?.before ? "moreBefore" : "moreAfter";
-            const lastRecord = output.records.at(
+            const lastRecord = result.records.at(
               direction === "moreAfter" ? -1 : 0
             );
-            output[direction] = generatePaginationCursor(
+            result[direction] = generatePaginationCursor(
               model,
               queryInstructions.orderedBy,
               lastRecord
@@ -2163,20 +2192,20 @@ var Transaction = class {
           }
           if (queryInstructions?.before || queryInstructions?.after) {
             const direction = queryInstructions?.before ? "moreAfter" : "moreBefore";
-            const firstRecord = output.records.at(
+            const firstRecord = result.records.at(
               direction === "moreAfter" ? -1 : 0
             );
-            output[direction] = generatePaginationCursor(
+            result[direction] = generatePaginationCursor(
               model,
               queryInstructions.orderedBy,
               firstRecord
             );
           }
         }
-        return output;
-      }
+        return addResult(result);
+      },
+      []
     );
-    return formattedResults.filter((result) => result !== null);
   }
 };
 var CLEAN_ROOT_MODEL = omit(ROOT_MODEL, ["system"]);

package/package.json

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