@ronin/compiler 0.17.21 → 0.17.22

package/dist/index.d.ts

@@ -258,6 +258,8 @@ type InternalModelField = ModelField & {
     mountingPath: string;
     /** A custom value that was provided in the query, which is not stored in the DB. */
     mountedValue?: unknown;
+    /** If this is set, the field is used during formatting, but not exposed afterward. */
+    excluded?: boolean;
 };
 type ModelIndexField<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
     /** The collating sequence used for text placed inside the field. */

package/dist/index.js

@@ -141,8 +141,11 @@ var omit = (obj, properties) => Object.fromEntries(
 var getProperty = (obj, path) => {
   return path.split(".").reduce((acc, key) => acc?.[key], obj);
 };
+var getPathSegments = (path) => {
+  return path.split(/[.[\]]/g).filter((segment) => segment.trim().length > 0);
+};
 var setProperty = (obj, path, value) => {
-  const segments = path.split(/[.[\]]/g).filter((x) => !!x.trim());
+  const segments = getPathSegments(path);
   const _set = (node) => {
     if (segments.length > 1) {
       const key = segments.shift();
@@ -157,6 +160,20 @@ var setProperty = (obj, path, value) => {
   };
   _set(obj);
 };
+var deleteProperty = (obj, path) => {
+  const segments = getPathSegments(path);
+  const _delete = (node, segs) => {
+    const key = segs[0];
+    if (segs.length === 1) {
+      delete node[key];
+    } else if (node[key] && typeof node[key] === "object" && node[key] !== null) {
+      const shouldCleanup = _delete(node[key], segs.slice(1));
+      if (shouldCleanup) delete node[key];
+    }
+    return Object.keys(node).length === 0;
+  };
+  _delete(obj, segments);
+};
 var splitQuery = (query) => {
   const queryType = Object.keys(query)[0];
   const queryModel = Object.keys(query[queryType])[0];
@@ -379,7 +396,7 @@ var handleOrderedBy = (model, instruction) => {
 };
 
 // src/instructions/selecting.ts
-var handleSelecting = (models, model, statementParams, single, instructions, options = { inlineDefaults: false }) => {
+var handleSelecting = (models, model, statementParams, queryType, single, instructions, options = { inlineDefaults: false }) => {
   let isJoining = false;
   const selectedFields = filterSelectedFields(
     model,
@@ -403,9 +420,9 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
     for (const [key, value] of Object.entries(flatObject)) {
       const symbol2 = getQuerySymbol(value);
       if (symbol2?.type === "query") {
-        const { queryType, queryModel, queryInstructions } = splitQuery(symbol2.value);
+        const { queryType: queryType2, queryModel, queryInstructions } = splitQuery(symbol2.value);
         const subQueryModel = getModelBySlug(models, queryModel);
-        if (queryType === "count") {
+        if (queryType2 === "count") {
           const subSelect = compileQueryInput(symbol2.value, models, statementParams, {
             parentModel: { ...model, tableAlias: model.table },
             inlineDefaults: options.inlineDefaults
@@ -427,10 +444,13 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
           models,
           { ...subQueryModel, tableAlias: `including_${subMountingPath}` },
           statementParams,
+          queryType2,
           subSingle,
           {
             selecting: queryInstructions?.selecting,
-            including: queryInstructions?.including
+            including: queryInstructions?.including,
+            orderedBy: queryInstructions?.orderedBy,
+            limitedTo: queryInstructions?.limitedTo
           },
           { ...options, mountingPath: subMountingPath }
         );
@@ -454,6 +474,20 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
       });
     }
   }
+  if (queryType === "get" && !single && typeof instructions.limitedTo !== "undefined") {
+    const orderedFields = Object.values(instructions.orderedBy || {}).flat().map((fieldSlug) => {
+      return getFieldFromModel(model, fieldSlug, { instructionName: "orderedBy" });
+    });
+    for (const orderedField of orderedFields) {
+      const { field } = orderedField;
+      if (selectedFields.some(({ slug }) => slug === field.slug)) continue;
+      selectedFields.push({
+        slug: field.slug,
+        mountingPath: field.slug,
+        excluded: true
+      });
+    }
+  }
   const columns = selectedFields.map((selectedField) => {
     if (selectedField.mountedValue) {
       return `${selectedField.mountedValue} as "${selectedField.slug}"`;
@@ -1077,14 +1111,29 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
       }
     });
   }
+  if (!single && (queryType === "get" && instructions?.limitedTo || queryType === "count" && (instructions?.before || instructions?.after))) {
+    instructions = instructions || {};
+    instructions.orderedBy = instructions.orderedBy || {};
+    instructions.orderedBy.ascending = instructions.orderedBy.ascending || [];
+    instructions.orderedBy.descending = instructions.orderedBy.descending || [];
+    if (![
+      ...instructions.orderedBy.ascending,
+      ...instructions.orderedBy.descending
+    ].includes("ronin.createdAt")) {
+      instructions.orderedBy.descending.push("ronin.createdAt");
+    }
+  }
   const { columns, isJoining, selectedFields } = handleSelecting(
     models,
     model,
     statementParams,
+    queryType,
     single,
     {
       selecting: instructions?.selecting,
-      including: instructions?.including
+      including: instructions?.including,
+      orderedBy: instructions?.orderedBy,
+      limitedTo: instructions?.limitedTo
     },
     // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
     { inlineDefaults: options?.inlineDefaults || false }
@@ -1156,18 +1205,6 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     );
     if (withStatement.length > 0) conditions.push(withStatement);
   }
-  if (!single && (queryType === "get" && instructions?.limitedTo || queryType === "count" && (instructions?.before || instructions?.after))) {
-    instructions = instructions || {};
-    instructions.orderedBy = instructions.orderedBy || {};
-    instructions.orderedBy.ascending = instructions.orderedBy.ascending || [];
-    instructions.orderedBy.descending = instructions.orderedBy.descending || [];
-    if (![
-      ...instructions.orderedBy.ascending,
-      ...instructions.orderedBy.descending
-    ].includes("ronin.createdAt")) {
-      instructions.orderedBy.descending.push("ronin.createdAt");
-    }
-  }
   if (instructions && (typeof instructions.before !== "undefined" || typeof instructions.after !== "undefined")) {
     if (single) {
       throw new RoninError({
@@ -2309,6 +2346,12 @@ var Transaction = class {
         );
       }
     }
+    for (const field of selectedFields) {
+      if (!field.excluded) continue;
+      for (const record of result.records) {
+        deleteProperty(record, field.slug);
+      }
+    }
     return result;
   }
   /**

package/package.json

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