@ronin/compiler 0.11.0 → 0.11.1-default-value-experimental-230

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

@@ -20,6 +20,7 @@ var RONIN_MODEL_FIELD_REGEX = new RegExp(
   `${QUERY_SYMBOLS.FIELD}[_a-zA-Z0-9.]+`,
   "g"
 );
+var RAW_FIELD_TYPES = ["string", "number", "boolean"];
 var composeIncludedTableAlias = (fieldSlug) => `including_${fieldSlug}`;
 var MODEL_ENTITY_ERROR_CODES = {
   field: "FIELD_NOT_FOUND",
@@ -131,6 +132,25 @@ var expand = (obj) => {
 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) {
+      const key = segments.shift();
+      const nextIsNum = !Number.isNaN(Number.parseInt(segments[0]));
+      if (typeof node[key] !== "object" || node[key] === null) {
+        node[key] = nextIsNum ? [] : {};
+      }
+      _set(node[key]);
+    } else {
+      node[segments[0]] = value;
+    }
+  };
+  const cloned = structuredClone(obj);
+  _set(cloned);
+  return cloned;
+};
 var splitQuery = (query) => {
   const queryType = Object.keys(query)[0];
   const queryModel = Object.keys(query[queryType])[0];
@@ -623,7 +643,7 @@ var getFieldStatement = (models, model, field) => {
   if (field.unique === true) statement += " UNIQUE";
   if (field.required === true) statement += " NOT NULL";
   if (typeof field.defaultValue !== "undefined")
-    statement += ` DEFAULT ${field.defaultValue}`;
+    statement += ` DEFAULT ${typeof field.defaultValue === "string" ? `'${field.defaultValue}'` : field.defaultValue}`;
   if (field.collation) statement += ` COLLATE ${field.collation}`;
   if (field.increment === true) statement += " AUTOINCREMENT";
   if (typeof field.check !== "undefined") {
@@ -1131,12 +1151,8 @@ 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,
         { ...relatedModel, tableAlias },
@@ -1149,6 +1165,7 @@ var handleIncluding = (models, model, statementParams, instruction) => {
       );
       statement += ` ON (${subStatement})`;
     }
+    if (!single) tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
   }
   return { statement, tableSubQuery };
 };
@@ -1203,7 +1220,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 +1232,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;
@@ -1227,6 +1248,10 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
         newValue = prepareStatementValue(statementParams, value);
       }
       instructions.including[key] = newValue;
+      loadedFields.push({
+        slug: key,
+        type: RAW_FIELD_TYPES.includes(typeof value) ? typeof value : "string"
+      });
     }
   }
   const expandColumns = isJoining && options?.expandColumns;
@@ -1578,23 +1603,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;
+        let usableRowIndex = rowIndex;
+        if (parentFieldSlug) {
+          if (rows.length === 1) {
+            newSlug = `${parentFieldSlug}.${field.slug}`;
+          } else {
+            newSlug = `${parentFieldSlug}[${rowIndex}].${field.slug}`;
+            usableRowIndex = 0;
+          }
+        }
+        records[usableRowIndex] = setProperty(records[usableRowIndex], 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 +1665,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.11.0",
+  "version": "0.11.1-default-value-experimental-230",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {