@ronin/compiler 0.17.9 → 0.17.10-leo-ron-1099-experimental-400

package/dist/index.d.ts

@@ -118,7 +118,15 @@ 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;
+    /**
+     * Limit the list of models for which queries should be generated to only the models
+     * that the provided model links to.
+     */
+    for?: PublicModel['slug'];
+    /**
+     * Provide query instructions for specific models.
+     */
+    on?: Record<PublicModel['slug'], Omit<CombinedInstructions, 'to'> | null>;
 };
 type AllQuery = {
     all: AllQueryInstructions | null;

package/dist/index.js

@@ -1038,7 +1038,8 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     return {
       dependencies: [],
       main: dependencyStatements[0],
-      selectedFields: []
+      selectedFields: [],
+      model: ROOT_MODEL_WITH_ATTRIBUTES
     };
   const parsedQuery = splitQuery(query);
   const { queryType, queryModel, queryInstructions } = parsedQuery;
@@ -1196,7 +1197,8 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   return {
     dependencies: dependencyStatements,
     main: mainStatement,
-    selectedFields
+    selectedFields,
+    model
   };
 };
 
@@ -2072,7 +2074,11 @@ var Transaction = class {
   #internalQueries = [];
   constructor(queries, options) {
     const models = options?.models || [];
-    this.#internalQueries = queries.map((query) => ({ query, selectedFields: [] }));
+    this.#internalQueries = queries.map((query) => ({
+      query,
+      selectedFields: [],
+      models: []
+    }));
     this.#compileQueries(models, options);
   }
   /**
@@ -2099,34 +2105,42 @@ var Transaction = class {
       return addDefaultModelPresets(modelsWithFields, model);
     });
     const statements = [];
-    const expandedQueries = this.#internalQueries.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;
+        const {
+          for: forInstruction,
+          on: onInstruction,
+          ...restInstructions
+        } = queryInstructions || {};
+        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[expansionIndex].affectedModels = modelList.map(
-          (model) => model.slug
-        );
+        this.#internalQueries[index].models = modelList;
         return modelList.map((model) => {
+          const instructions = Object.assign(
+            {},
+            restInstructions,
+            onInstruction?.[model.pluralSlug]
+          );
           const query2 = {
-            [queryType]: { [model.pluralSlug]: restInstructions }
+            [queryType]: { [model.pluralSlug]: instructions }
           };
-          return { query: query2, expansionIndex };
+          return { query: query2, index };
         });
       }
-      return { query };
+      return { query, index };
     });
-    for (let index = 0; index < expandedQueries.length; index++) {
-      const { query, expansionIndex } = expandedQueries[index];
-      const { dependencies, main, selectedFields } = compileQueryInput(
+    for (const { query, index } of expandedQueries) {
+      const { dependencies, main, selectedFields, model } = compileQueryInput(
         query,
         modelsWithPresets,
         options?.inlineParams ? null : [],
@@ -2137,8 +2151,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);
-      const queryIndex = typeof expansionIndex === "undefined" ? index : expansionIndex;
-      this.#internalQueries[queryIndex].selectedFields = selectedFields;
+      this.#internalQueries[index].selectedFields = selectedFields;
+      if (this.#internalQueries[index].models.length === 0) {
+        this.#internalQueries[index].models = [model];
+      }
     }
     this.models = modelsWithPresets;
     return statements;
@@ -2291,7 +2307,7 @@ var Transaction = class {
     let resultIndex = 0;
     return this.#internalQueries.reduce(
       (finalResults, internalQuery) => {
-        const { query, selectedFields, affectedModels } = internalQuery;
+        const { query, selectedFields, models: affectedModels } = internalQuery;
         const { queryType, queryModel, queryInstructions } = splitQuery(query);
         const absoluteResults = raw ? cleanResults : cleanResults.map((rows) => {
           return rows.map((row) => {
@@ -2300,15 +2316,18 @@ var Transaction = class {
             return Object.values(row);
           });
         });
-        if (queryModel === "all" && affectedModels) {
-          const modelList = affectedModels.map((slug) => {
-            return getModelBySlug(this.models, slug);
-          });
+        if (queryModel === "all") {
           const models = {};
-          for (const model of modelList) {
+          const { on: onInstruction, ...restInstructions } = queryInstructions || {};
+          for (const model of affectedModels) {
+            const instructions = Object.assign(
+              {},
+              restInstructions,
+              onInstruction?.[model.pluralSlug]
+            );
             const result = this.formatIndividualResult(
               queryType,
-              queryInstructions,
+              instructions,
               model,
               absoluteResults[resultIndex++],
               selectedFields,
@@ -2318,7 +2337,7 @@ var Transaction = class {
           }
           finalResults.push({ models });
         } else {
-          const model = getModelBySlug(this.models, queryModel);
+          const model = affectedModels[0];
           const result = this.formatIndividualResult(
             queryType,
             queryInstructions,

package/package.json

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