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

package/dist/index.d.ts

@@ -372,8 +372,8 @@ declare class Transaction {
     statements: Array<Statement>;
     models: Array<Model>;
     constructor(queries: Array<Query>, options?: TransactionOptions);
-    formatResults<Record>(results: Array<Array<RawRow>>, raw?: true): Array<Result<Record>>;
     formatResults<Record>(results: Array<Array<ObjectRow>>, raw?: false): Array<Result<Record>>;
+    formatResults<Record>(results: Array<Array<RawRow>>, raw?: true): Array<Result<Record>>;
 }
 
 declare const CLEAN_ROOT_MODEL: PublicModel;

package/dist/index.js

@@ -125,7 +125,6 @@ var getProperty = (obj, path) => {
   return path.split(".").reduce((acc, key) => acc?.[key], obj);
 };
 var setProperty = (obj, path, value) => {
-  if (!obj) return setProperty({}, path, value);
   const segments = path.split(/[.[\]]/g).filter((x) => !!x.trim());
   const _set = (node) => {
     if (segments.length > 1) {
@@ -139,9 +138,7 @@ var setProperty = (obj, path, value) => {
       node[segments[0]] = value;
     }
   };
-  const cloned = structuredClone(obj);
-  _set(cloned);
-  return cloned;
+  _set(obj);
 };
 var splitQuery = (query) => {
   const queryType = Object.keys(query)[0];
@@ -302,7 +299,7 @@ var handleFor = (model, instructions) => {
 };
 
 // src/instructions/including.ts
-var handleIncluding = (models, model, statementParams, instruction) => {
+var handleIncluding = (models, model, statementParams, single, instruction) => {
   let statement = "";
   let tableSubQuery;
   for (const ephemeralFieldSlug in instruction) {
@@ -315,10 +312,10 @@ var handleIncluding = (models, model, statementParams, instruction) => {
     let joinType = "LEFT";
     let relatedTableSelector = `"${relatedModel.table}"`;
     const tableAlias = composeIncludedTableAlias(ephemeralFieldSlug);
-    const single = queryModel !== relatedModel.pluralSlug;
+    const subSingle = queryModel !== relatedModel.pluralSlug;
     if (!modifiableQueryInstructions?.with) {
       joinType = "CROSS";
-      if (single) {
+      if (subSingle) {
         if (!modifiableQueryInstructions) modifiableQueryInstructions = {};
         modifiableQueryInstructions.limitedTo = 1;
       }
@@ -350,7 +347,19 @@ var handleIncluding = (models, model, statementParams, instruction) => {
       );
       statement += ` ON (${subStatement})`;
     }
-    if (!single) tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
+    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 };
 };
@@ -392,11 +401,23 @@ var handleOrderedBy = (model, instruction) => {
 };
 
 // src/instructions/selecting.ts
-var handleSelecting = (models, model, statementParams, 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 = {};
@@ -406,73 +427,65 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
         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 single = queryModel !== subQueryModel.pluralSlug;
-        if (!single) {
-          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");
-          })
+        const subSingle = queryModel !== subQueryModel.pluralSlug;
+        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: key });
-          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
@@ -594,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);
@@ -604,10 +617,11 @@ 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,
+    single,
     {
       selecting: instructions?.selecting,
       including: instructions?.including
@@ -638,6 +652,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
       models,
       model,
       statementParams,
+      single,
       instructions?.including
     );
     if (tableSubQuery) {
@@ -734,7 +749,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   return {
     dependencies: dependencyStatements,
     main: mainStatement,
-    loadedFields
+    selectedFields
   };
 };
 
@@ -1292,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}"`;
 };
@@ -1894,7 +1911,7 @@ var Transaction = class {
         ...subStatements.map((statement) => ({
           ...statement,
           query,
-          fields: result.loadedFields
+          selectedFields: result.selectedFields
         }))
       );
     }
@@ -1903,38 +1920,40 @@ var Transaction = class {
   };
   #formatRows(fields, rows, single, isMeta) {
     const records = [];
-    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
-      const row = rows[rowIndex];
-      for (let valueIndex = 0; valueIndex < row.length; valueIndex++) {
-        const value = row[valueIndex];
-        const field = fields[valueIndex];
-        let newSlug = field.slug;
-        let newValue = value;
+    for (const row of rows) {
+      const record = fields.reduce((acc, field, fieldIndex) => {
+        const newSlug = field.mountingPath;
+        let newValue = row[fieldIndex];
         if (field.type === "json") {
-          newValue = JSON.parse(value);
+          newValue = JSON.parse(newValue);
         } else if (field.type === "boolean") {
-          newValue = Boolean(value);
-        }
-        const parentFieldSlug = field.parentField;
-        let usableRowIndex = rowIndex;
-        if (parentFieldSlug) {
-          if (rows.length === 1) {
-            newSlug = `${parentFieldSlug}.${field.slug}`;
-          } else {
-            newSlug = `${parentFieldSlug}[${rowIndex}].${field.slug}`;
-            usableRowIndex = 0;
-          }
+          newValue = Boolean(newValue);
         }
         if (isMeta && PLURAL_MODEL_ENTITIES_VALUES.includes(newSlug)) {
           newValue = newValue ? Object.entries(newValue).map(([slug, attributes]) => {
             return { slug, ...attributes };
           }) : [];
         }
-        records[usableRowIndex] = setProperty(
-          records[usableRowIndex],
-          newSlug,
-          newValue
-        );
+        setProperty(acc, newSlug, newValue);
+        return acc;
+      }, {});
+      const existingRecord = record.id ? records.find((existingRecord2) => {
+        return existingRecord2.id === record.id;
+      }) : null;
+      if (!existingRecord) {
+        records.push(record);
+        continue;
+      }
+      const joinFields = fields.reduce(
+        (acc, { mountingPath }) => {
+          return mountingPath.includes("[0]") && !acc.includes(mountingPath.split("[0]")[0]) ? acc.concat([mountingPath.split("[0]")[0]]) : acc;
+        },
+        []
+      );
+      for (const arrayField of joinFields) {
+        const currentValue = existingRecord[arrayField];
+        const newValue = record[arrayField];
+        currentValue.push(...newValue);
       }
     }
     return single ? records[0] : records;
@@ -1961,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);
@@ -1979,13 +1994,13 @@ var Transaction = class {
         const single = queryModel !== model.pluralSlug;
         if (single) {
           return {
-            record: rows[0] ? this.#formatRows(rawModelFields, rows, single, isMeta) : null,
+            record: rows[0] ? this.#formatRows(selectedFields, rows, true, isMeta) : null,
             modelFields
           };
         }
         const pageSize = queryInstructions?.limitedTo;
         const output = {
-          records: this.#formatRows(rawModelFields, rows, single, 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",
+  "version": "0.14.0-leo-ron-1099-1-experimental-311",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {