@ronin/compiler 0.13.14-leo-ron-1099-1-experimental-310 → 0.14.0-leo-ron-1099-1-experimental-311

package/dist/index.js

@@ -350,6 +350,16 @@ var handleIncluding = (models, model, statementParams, single, instruction) => {
     if (single && !subSingle) {
       tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
     }
+    if (modifiableQueryInstructions?.including) {
+      const subIncluding = handleIncluding(
+        models,
+        { ...relatedModel, tableAlias },
+        statementParams,
+        subSingle,
+        modifiableQueryInstructions.including
+      );
+      statement += ` ${subIncluding.statement}`;
+    }
   }
   return { statement, tableSubQuery };
 };
@@ -391,11 +401,23 @@ var handleOrderedBy = (model, instruction) => {
 };
 
 // src/instructions/selecting.ts
-var handleSelecting = (models, model, statementParams, single, instructions, options) => {
-  let loadedFields = [];
-  let expandColumns = false;
-  let statement = "*";
+var handleSelecting = (models, model, statementParams, single, instructions, options = {}) => {
   let isJoining = false;
+  const selectedFields = (instructions.selecting ? instructions.selecting.map((slug) => {
+    const { field } = getFieldFromModel(model, slug, {
+      instructionName: "selecting"
+    });
+    return field;
+  }) : model.fields).filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => {
+    const newField = { ...field, mountingPath: field.slug };
+    if (options.mountingPath) {
+      newField.mountingPath = `${options.mountingPath}.${field.slug}`;
+    }
+    return newField;
+  });
+  if (instructions.selecting) options.expandColumns = true;
+  const joinedSelectedFields = [];
+  const joinedColumns = [];
   if (instructions.including) {
     const flatObject = flatten(instructions.including);
     instructions.including = {};
@@ -405,79 +427,65 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
         const { queryModel, queryInstructions } = splitQuery(symbol.value);
         const subQueryModel = getModelBySlug(models, queryModel);
         isJoining = true;
-        expandColumns = Boolean(options?.expandColumns || queryInstructions?.selecting);
+        if (queryInstructions?.selecting) options.expandColumns = true;
         const tableAlias = composeIncludedTableAlias(key);
         const subSingle = queryModel !== subQueryModel.pluralSlug;
-        if (single && !subSingle) {
-          model.tableAlias = `sub_${model.table}`;
-        }
-        const queryModelFields = queryInstructions?.selecting ? subQueryModel.fields.filter((field) => {
-          return queryInstructions.selecting?.includes(field.slug);
-        }) : (
-          // Exclude link fields with cardinality "many", since those don't exist as columns.
-          subQueryModel.fields.filter((field) => {
-            return !(field.type === "link" && field.kind === "many");
-          })
+        if (!model.tableAlias)
+          model.tableAlias = single && !subSingle ? `sub_${model.table}` : model.table;
+        const subMountingPath = `${options?.mountingPath ? `${options?.mountingPath}.` : ""}${subSingle ? key : `${key}[0]`}`;
+        const { columns: nestedColumns, selectedFields: nestedSelectedFields } = handleSelecting(
+          models,
+          { ...subQueryModel, tableAlias },
+          statementParams,
+          subSingle,
+          {
+            selecting: queryInstructions?.selecting,
+            including: queryInstructions?.including
+          },
+          { ...options, mountingPath: subMountingPath }
         );
-        for (const field of queryModelFields) {
-          loadedFields.push({
-            ...field,
-            parentField: {
-              slug: key,
-              single: subSingle
-            }
-          });
-          if (expandColumns) {
-            const newValue2 = parseFieldExpression(
-              { ...subQueryModel, tableAlias },
-              "including",
-              `${QUERY_SYMBOLS.FIELD}${field.slug}`
-            );
-            instructions.including[`${tableAlias}.${field.slug}`] = newValue2;
-          }
-        }
+        if (nestedColumns !== "*") joinedColumns.push(nestedColumns);
+        joinedSelectedFields.push(...nestedSelectedFields);
         continue;
       }
-      let newValue = value;
+      let mountedValue = value;
       if (symbol?.type === "expression") {
-        newValue = `(${parseFieldExpression(model, "including", symbol.value)})`;
+        mountedValue = `(${parseFieldExpression(model, "including", symbol.value)})`;
       } else {
-        newValue = prepareStatementValue(statementParams, value);
+        mountedValue = prepareStatementValue(statementParams, value);
       }
-      instructions.including[key] = newValue;
-      loadedFields.push({
+      selectedFields.push({
         slug: key,
-        type: RAW_FIELD_TYPES.includes(typeof value) ? typeof value : "string"
+        mountingPath: key,
+        type: RAW_FIELD_TYPES.includes(typeof value) ? typeof value : "string",
+        mountedValue
       });
     }
   }
-  if (expandColumns) {
-    instructions.selecting = model.fields.filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => field.slug);
-  }
-  if (instructions.selecting) {
-    const usableModel = expandColumns ? { ...model, tableAlias: model.tableAlias || model.table } : model;
-    const selectedFields = [];
-    statement = instructions.selecting.map((slug) => {
-      const { field, fieldSelector } = getFieldFromModel(usableModel, slug, {
-        instructionName: "selecting"
-      });
-      selectedFields.push(field);
-      return fieldSelector;
-    }).join(", ");
-    loadedFields = [...selectedFields, ...loadedFields];
-  } else {
-    loadedFields = [
-      ...model.fields.filter(
-        (field) => !(field.type === "link" && field.kind === "many")
-      ),
-      ...loadedFields
-    ];
-  }
-  if (instructions.including && Object.keys(instructions.including).length > 0) {
-    statement += ", ";
-    statement += Object.entries(instructions.including).map(([key, value]) => `${value} as "${key}"`).join(", ");
-  }
-  return { columns: statement, isJoining, loadedFields };
+  let columns = ["*"];
+  const fieldsToExpand = options.expandColumns ? selectedFields : selectedFields.filter(
+    (loadedField) => typeof loadedField.mountedValue !== "undefined"
+  );
+  const extraColumns = fieldsToExpand.map((selectedField) => {
+    if (selectedField.mountedValue) {
+      return `${selectedField.mountedValue} as "${selectedField.slug}"`;
+    }
+    const { fieldSelector } = getFieldFromModel(model, selectedField.slug, {
+      instructionName: "selecting"
+    });
+    if (model.tableAlias?.startsWith("including_")) {
+      return `${fieldSelector} as "${model.tableAlias}.${selectedField.slug}"`;
+    }
+    return fieldSelector;
+  });
+  if (options.expandColumns) {
+    columns = extraColumns;
+  } else if (extraColumns) {
+    columns.push(...extraColumns);
+  }
+  columns.push(...joinedColumns);
+  selectedFields.push(...joinedSelectedFields);
+  return { columns: columns.join(", "), isJoining, selectedFields };
 };
 
 // src/instructions/to.ts
@@ -599,7 +607,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     defaultQuery
   );
   if (query === null)
-    return { dependencies: [], main: dependencyStatements[0], loadedFields: [] };
+    return { dependencies: [], main: dependencyStatements[0], selectedFields: [] };
   const parsedQuery = splitQuery(query);
   const { queryType, queryModel, queryInstructions } = parsedQuery;
   const model = getModelBySlug(models, queryModel);
@@ -609,7 +617,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   if (instructions && Object.hasOwn(instructions, "for")) {
     instructions = handleFor(model, instructions);
   }
-  const { columns, isJoining, loadedFields } = handleSelecting(
+  const { columns, isJoining, selectedFields } = handleSelecting(
     models,
     model,
     statementParams,
@@ -741,7 +749,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   return {
     dependencies: dependencyStatements,
     main: mainStatement,
-    loadedFields
+    selectedFields
   };
 };
 
@@ -1299,8 +1307,10 @@ var getFieldSelector = (model, field, fieldPath, writing) => {
   if (field.type === "json" && !writing) {
     const dotParts = fieldPath.split(".");
     const columnName = tablePrefix + dotParts.shift();
-    const jsonField = dotParts.join(".");
-    return `json_extract(${columnName}, '$.${jsonField}')`;
+    if (dotParts.length > 0) {
+      const jsonField = dotParts.join(".");
+      return `json_extract(${columnName}, '$.${jsonField}')`;
+    }
   }
   return `${tablePrefix}"${fieldPath}"`;
 };
@@ -1901,7 +1911,7 @@ var Transaction = class {
         ...subStatements.map((statement) => ({
           ...statement,
           query,
-          fields: result.loadedFields
+          selectedFields: result.selectedFields
         }))
       );
     }
@@ -1912,12 +1922,8 @@ var Transaction = class {
     const records = [];
     for (const row of rows) {
       const record = fields.reduce((acc, field, fieldIndex) => {
-        let newSlug = field.slug;
+        const newSlug = field.mountingPath;
         let newValue = row[fieldIndex];
-        if (field.parentField) {
-          const arrayKey = field.parentField.single ? "" : "[0]";
-          newSlug = `${field.parentField.slug}${arrayKey}.${field.slug}`;
-        }
         if (field.type === "json") {
           newValue = JSON.parse(newValue);
         } else if (field.type === "boolean") {
@@ -1939,16 +1945,14 @@ var Transaction = class {
         continue;
       }
       const joinFields = fields.reduce(
-        (acc, field) => {
-          if (!field.parentField) return acc;
-          const { single: single2, slug } = field.parentField;
-          return single2 || acc.includes(slug) ? acc : acc.concat([slug]);
+        (acc, { mountingPath }) => {
+          return mountingPath.includes("[0]") && !acc.includes(mountingPath.split("[0]")[0]) ? acc.concat([mountingPath.split("[0]")[0]]) : acc;
         },
         []
       );
-      for (const parentField of joinFields) {
-        const currentValue = existingRecord[parentField];
-        const newValue = record[parentField];
+      for (const arrayField of joinFields) {
+        const currentValue = existingRecord[arrayField];
+        const newValue = record[arrayField];
         currentValue.push(...newValue);
       }
     }
@@ -1976,11 +1980,7 @@ var Transaction = class {
     });
     const formattedResults = normalizedResults.map(
       (rows, index) => {
-        const {
-          returning,
-          query,
-          fields: rawModelFields
-        } = this.#internalStatements[index];
+        const { returning, query, selectedFields } = this.#internalStatements[index];
         if (!returning) return null;
         const { queryType, queryModel, queryInstructions } = splitQuery(query);
         const model = getModelBySlug(this.models, queryModel);
@@ -1994,13 +1994,13 @@ var Transaction = class {
         const single = queryModel !== model.pluralSlug;
         if (single) {
           return {
-            record: rows[0] ? this.#formatRows(rawModelFields, rows, true, isMeta) : null,
+            record: rows[0] ? this.#formatRows(selectedFields, rows, true, isMeta) : null,
             modelFields
           };
         }
         const pageSize = queryInstructions?.limitedTo;
         const output = {
-          records: this.#formatRows(rawModelFields, rows, false, isMeta),
+          records: this.#formatRows(selectedFields, rows, false, isMeta),
           modelFields
         };
         if (pageSize && output.records.length > 0) {

package/package.json

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