@ronin/compiler 0.14.0 → 0.14.1

package/dist/index.d.ts

@@ -169,7 +169,7 @@ type ModelFieldBasics = {
      * The value that should be inserted into the field in the case that no value was
      * explicitly provided for it when a record is created.
      */
-    defaultValue?: unknown;
+    defaultValue?: Expression | unknown;
     /**
      * An expression that should be evaluated to form the value of the field. The
      * expression can either be VIRTUAL (evaluated whenever a record is read) or STORED

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,93 +401,95 @@ 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 symbol = getSymbol(instructions.including);
+    if (symbol?.type === "query") {
+      instructions.including.ronin_root = { ...instructions.including };
+      delete instructions.including[QUERY_SYMBOLS.QUERY];
+    }
     const flatObject = flatten(instructions.including);
-    instructions.including = {};
     for (const [key, value] of Object.entries(flatObject)) {
-      const symbol = getSymbol(value);
-      if (symbol?.type === "query") {
-        const { queryModel, queryInstructions } = splitQuery(symbol.value);
+      const symbol2 = getSymbol(value);
+      if (symbol2?.type === "query") {
+        const { queryModel, queryInstructions } = splitQuery(symbol2.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 = key === "ronin_root" ? options.mountingPath : `${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;
-      if (symbol?.type === "expression") {
-        newValue = `(${parseFieldExpression(model, "including", symbol.value)})`;
+      let mountedValue = value;
+      if (symbol2?.type === "expression") {
+        mountedValue = `(${parseFieldExpression(model, "including", symbol2.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 (options.mountingPath) {
+      return `${fieldSelector} as "${options.mountingPath}.${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 +611,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 +621,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 +753,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   return {
     dependencies: dependencyStatements,
     main: mainStatement,
-    loadedFields
+    selectedFields
   };
 };
 
@@ -1215,15 +1227,59 @@ var addDefaultModelPresets = (list, model) => {
   const defaultPresets = [];
   for (const field of model.fields || []) {
     if (field.type === "link" && !field.slug.startsWith("ronin.")) {
-      const relatedModel = getModelBySlug(list, field.target);
-      if (field.kind === "many") continue;
+      const targetModel = getModelBySlug(list, field.target);
+      if (field.kind === "many") {
+        const systemModel = list.find(({ system }) => {
+          return system?.model === model.id && system?.associationSlug === field.slug;
+        });
+        if (!systemModel) continue;
+        const preset = {
+          instructions: {
+            // Perform a LEFT JOIN that adds the associative table.
+            including: {
+              [field.slug]: {
+                [QUERY_SYMBOLS.QUERY]: {
+                  get: {
+                    [systemModel.pluralSlug]: {
+                      // ON associative_table.source = origin_model.id
+                      with: {
+                        source: {
+                          [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
+                        }
+                      },
+                      // Perform a LEFT JOIN that adds the target model table.
+                      including: {
+                        [QUERY_SYMBOLS.QUERY]: {
+                          get: {
+                            [targetModel.slug]: {
+                              // ON target_model.id = associative_table.target
+                              with: {
+                                id: {
+                                  [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}target`
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          slug: field.slug
+        };
+        defaultPresets.push(preset);
+        continue;
+      }
       defaultPresets.push({
         instructions: {
           including: {
             [field.slug]: {
               [QUERY_SYMBOLS.QUERY]: {
                 get: {
-                  [relatedModel.slug]: {
+                  [targetModel.slug]: {
                     with: {
                       // Compare the `id` field of the related model to the link field on
                       // the root model (`field.slug`).
@@ -1242,6 +1298,7 @@ var addDefaultModelPresets = (list, model) => {
     }
   }
   const childModels = list.map((subModel) => {
+    if (subModel.system?.associationSlug) return null;
     const field = subModel.fields?.find((field2) => {
       return field2.type === "link" && field2.target === model.slug;
     });
@@ -1299,8 +1356,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 +1960,7 @@ var Transaction = class {
         ...subStatements.map((statement) => ({
           ...statement,
           query,
-          fields: result.loadedFields
+          selectedFields: result.selectedFields
         }))
       );
     }
@@ -1912,12 +1971,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") {
@@ -1938,17 +1993,13 @@ var Transaction = class {
         records.push(record);
         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]);
-        },
-        []
-      );
-      for (const parentField of joinFields) {
-        const currentValue = existingRecord[parentField];
-        const newValue = record[parentField];
+      const joinFields = fields.reduce((acc, { mountingPath }) => {
+        if (mountingPath.includes("[0]")) acc.add(mountingPath.split("[0]")[0]);
+        return acc;
+      }, /* @__PURE__ */ new Set());
+      for (const arrayField of joinFields.values()) {
+        const currentValue = existingRecord[arrayField];
+        const newValue = record[arrayField];
         currentValue.push(...newValue);
       }
     }
@@ -1976,11 +2027,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 +2041,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.14.0",
+  "version": "0.14.1",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {