@ronin/compiler 0.17.21 → 0.17.22-leo-ron-1140-experimental-431

package/dist/index.d.ts

@@ -115,6 +115,11 @@ type AddInstructions = Omit<CombinedInstructions, 'with' | 'using'> & {
 };
 type RemoveInstructions = Omit<CombinedInstructions, 'to'>;
 type CountInstructions = Omit<CombinedInstructions, 'to'>;
+type ListQuery = {
+    models?: null;
+} | {
+    model: string;
+};
 type CreateQuery = {
     model: string | PublicModel;
     to?: PublicModel;
@@ -152,6 +157,7 @@ type Query = {
     add?: AddQuery;
     remove?: RemoveQuery;
     count?: CountQuery | CountAllQuery;
+    list?: ListQuery;
     create?: CreateQuery;
     alter?: AlterQuery;
     drop?: DropQuery;
@@ -258,6 +264,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({
@@ -1752,6 +1789,12 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
   let slug = entity === "model" && action === "create" ? null : query[queryType] && "model" in query[queryType] ? query[queryType].model : null;
   let modelSlug = slug;
   let jsonValue;
+  if ("list" in query && query.list) {
+    if (slug) {
+      return { get: { model: { with: { slug } } } };
+    }
+    return { get: { models: {} } };
+  }
   if ("create" in query && query.create) {
     const init = query.create.model;
     jsonValue = "to" in query.create ? { slug: init, ...query.create.to } : init;
@@ -2309,6 +2352,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-leo-ron-1140-experimental-431",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {