@ronin/compiler 0.10.3-leo-ron-1083-experimental-215 → 0.10.3-leo-ron-1083-experimental-217

package/dist/index.js

@@ -17,7 +17,7 @@ var RONIN_MODEL_SYMBOLS = {
   VALUE: "__RONIN_VALUE"
 };
 var RONIN_MODEL_FIELD_REGEX = new RegExp(
-  `${RONIN_MODEL_SYMBOLS.FIELD}[_a-zA-Z0-9]+`,
+  `${RONIN_MODEL_SYMBOLS.FIELD}[_a-zA-Z0-9.]+`,
   "g"
 );
 var MODEL_ENTITY_ERROR_CODES = {
@@ -1190,7 +1190,8 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
     return getFieldFromModel(model, slug, "selecting").fieldSelector;
   }).join(", ") : "*";
   if (instructions.including) {
-    const filteredObject = Object.entries(instructions.including).flatMap(([key, value]) => {
+    const flatObject = flatten(instructions.including);
+    const filteredObject = Object.entries(flatObject).flatMap(([key, value]) => {
       const symbol = getSymbol(value);
       if (symbol?.type === "query") {
         isJoining = true;
@@ -1202,27 +1203,28 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
           if (field.type === "group") return null;
           return model.fields.some((modelField) => modelField.slug === field.slug);
         }).filter((item) => item !== null);
-        return duplicatedFields.map((field) => ({
-          key: `${tableName}.${field.slug}`,
-          value: {
-            [RONIN_MODEL_SYMBOLS.EXPRESSION]: `${RONIN_MODEL_SYMBOLS.FIELD}${field.slug}`
-          }
-        }));
+        return duplicatedFields.map((field) => {
+          const value2 = parseFieldExpression(
+            { ...queryModel, tableAlias: tableName },
+            "including",
+            `${RONIN_MODEL_SYMBOLS.FIELD}${field.slug}`
+          );
+          return {
+            key: `${tableName}.${field.slug}`,
+            value: value2
+          };
+        });
+      }
+      if (symbol?.type === "expression") {
+        value = `(${parseFieldExpression(model, "including", symbol.value)})`;
+      } else {
+        value = prepareStatementValue(statementParams, value);
       }
       return { key, value };
     }).filter((entry) => entry !== null).map((entry) => [entry.key, entry.value]);
-    const newObjectEntries = Object.entries(flatten(Object.fromEntries(filteredObject)));
-    if (newObjectEntries.length > 0) {
+    if (filteredObject.length > 0) {
       statement += ", ";
-      statement += newObjectEntries.map(([key, value]) => {
-        const symbol = getSymbol(value);
-        if (symbol?.type === "expression") {
-          value = `(${parseFieldExpression(model, "including", symbol.value)})`;
-        } else {
-          value = prepareStatementValue(statementParams, value);
-        }
-        return `${value} as "${key}"`;
-      }).join(", ");
+      statement += filteredObject.map(([key, value]) => `${value} as "${key}"`).join(", ");
     }
   }
   return { columns: statement, isJoining };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.10.3-leo-ron-1083-experimental-215",
+  "version": "0.10.3-leo-ron-1083-experimental-217",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {