@ronin/compiler 0.10.3-leo-ron-1083-experimental-224 → 0.11.0-leo-ron-1083-experimental-225

package/dist/index.d.ts

@@ -5989,8 +5989,11 @@ type ObjectRow = Record<string, unknown>;
 type NativeRecord = Record<string, unknown> & {
     id: string;
     ronin: {
+        locked: boolean;
         createdAt: Date;
+        createdBy: string | null;
         updatedAt: Date;
+        updatedBy: string | null;
     };
 };
 type SingleRecordResult = {
@@ -6072,7 +6075,7 @@ declare class Transaction {
      * @returns The composed SQL statements.
      */
     private compileQueries;
-    private formatRow;
+    private formatRows;
     formatResults(results: Array<Array<RawRow>>, raw?: true): Array<Result>;
     formatResults(results: Array<Array<ObjectRow>>, raw?: false): Array<Result>;
 }

package/dist/index.js

@@ -131,6 +131,32 @@ var expand = (obj) => {
 var getProperty = (obj, path) => {
   return path.split(".").reduce((acc, key) => acc?.[key], obj);
 };
+var toInt = (value, defaultValue) => {
+  const def = defaultValue === void 0 ? 0 : defaultValue;
+  if (value === null || value === void 0) return def;
+  const result = Number.parseInt(value);
+  return Number.isNaN(result) ? def : result;
+};
+var setProperty = (initial, path, value) => {
+  if (!initial) return setProperty({}, path, value);
+  if (!path || value === void 0) return initial;
+  const segments = path.split(/[.[\]]/g).filter((x) => !!x.trim());
+  const _set = (node) => {
+    if (segments.length > 1) {
+      const key = segments.shift();
+      const nextIsNum = toInt(segments[0], null) !== null;
+      if (typeof node[key] !== "object" || node[key] === null) {
+        node[key] = nextIsNum ? [] : {};
+      }
+      _set(node[key]);
+    } else {
+      node[segments[0]] = value;
+    }
+  };
+  const cloned = structuredClone(initial);
+  _set(cloned);
+  return cloned;
+};
 var splitQuery = (query) => {
   const queryType = Object.keys(query)[0];
   const queryModel = Object.keys(query[queryType])[0];
@@ -1131,11 +1157,10 @@ var handleIncluding = (models, model, statementParams, instruction) => {
       relatedTableSelector = `(${subSelect.main.statement})`;
     }
     statement += `${joinType} JOIN ${relatedTableSelector} as ${tableAlias}`;
-    model.tableAlias = model.table;
+    model.tableAlias = model.tableAlias || model.table;
     if (joinType === "LEFT") {
       if (!single) {
         tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
-        model.tableAlias = `sub_${model.table}`;
       }
       const subStatement = composeConditions(
         models,
@@ -1203,7 +1228,11 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
         isJoining = true;
         const { queryModel, queryInstructions } = splitQuery(symbol.value);
         const subQueryModel = getModelBySlug(models, queryModel);
-        const tableName = composeIncludedTableAlias(key);
+        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);
         }) : subQueryModel.fields;
@@ -1211,11 +1240,11 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
           loadedFields.push({ ...field, parentField: key });
           if (options?.expandColumns) {
             const newValue2 = parseFieldExpression(
-              { ...subQueryModel, tableAlias: tableName },
+              { ...subQueryModel, tableAlias },
               "including",
               `${QUERY_SYMBOLS.FIELD}${field.slug}`
             );
-            instructions.including[`${tableName}.${field.slug}`] = newValue2;
+            instructions.including[`${tableAlias}.${field.slug}`] = newValue2;
           }
         }
         continue;
@@ -1578,23 +1607,34 @@ var Transaction = class {
     this.models = modelListWithPresets;
     return [...dependencyStatements, ...mainStatements];
   };
-  formatRow(fields, row) {
-    const record = {};
-    for (let index = 0; index < row.length; index++) {
-      const value = row[index];
-      const field = fields[index];
-      let newSlug = field.slug;
-      let newValue = value;
-      const parentFieldSlug = field.parentField;
-      if (parentFieldSlug) {
-        newSlug = `${parentFieldSlug}.${field.slug}`;
-      }
-      if (field.type === "json") {
-        newValue = JSON.parse(value);
+  formatRows(fields, rows, single) {
+    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;
+        if (field.type === "json") {
+          newValue = JSON.parse(value);
+        } else if (field.type === "boolean") {
+          newValue = Boolean(value);
+        }
+        const parentFieldSlug = field.parentField;
+        if (parentFieldSlug) {
+          if (rows.length === 1) {
+            newSlug = `${parentFieldSlug}.${field.slug}`;
+          } else {
+            const fieldPath = `${parentFieldSlug}[${rowIndex}].${field.slug}`;
+            records[0] = setProperty(records[0], fieldPath, newValue);
+            continue;
+          }
+        }
+        records[rowIndex] = setProperty(records[rowIndex], newSlug, newValue);
       }
-      record[newSlug] = newValue;
     }
-    return expand(record);
+    return single ? records[0] : records;
   }
   /**
    * Format the results returned from the database into RONIN records.
@@ -1629,11 +1669,11 @@ var Transaction = class {
       }
       const single = queryModel !== model.pluralSlug;
       if (single) {
-        return { record: this.formatRow(fields, rows[0]) };
+        return { record: rows[0] ? this.formatRows(fields, rows, single) : null };
       }
       const pageSize = queryInstructions?.limitedTo;
       const output = {
-        records: rows.map((row) => this.formatRow(fields, row))
+        records: this.formatRows(fields, rows, single)
       };
       if (pageSize && output.records.length > 0) {
         if (queryInstructions?.before || queryInstructions?.after) {

package/package.json

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