@ronin/compiler 0.10.3-leo-ron-1083-experimental-219 → 0.10.3-leo-ron-1083-experimental-221

package/README.md

@@ -65,9 +65,11 @@ Once the RONIN queries have been compiled down to SQL statements, the statements
 executed and their results can be formatted by the compiler as well:
 
 ```typescript
-// `rows` are provided by the database engine
+// Passing `rawResults` (rows being of arrays of values) provided by the database (ideal)
+const results: Array<Result> = transaction.formatResults(rawResults);
 
-const results: Array<Result> = transaction.prepareResults(rows);
+// Passing `objectResults` (rows being of objects) provided by a driver
+const results: Array<Result> = transaction.formatResults(objectResults, false);
 ```
 
 #### Root Model
@@ -133,12 +135,13 @@ new Transaction(queries, {
   //
   // If the driver being used instead returns an object for every row, the driver must
   // ensure the uniqueness of every key in that object, which means prefixing duplicated
-  // column names with the name of the respective table, if multiple tables are joined.
+  // column names with the name of the respective table, if multiple tables are joined
+  // (example for an object key: "table_name.column_name").
   //
   // Drivers that return objects for rows offer this behavior as an option that is
   // usually called "expand columns". If the driver being used does not offer such an
   // option, you can instead activate the option in the compiler, which results in longer
-  // SQL statements because any duplicated column name is aliased.
+  // SQL statements because all column names are aliased.
   expandColumns: true
 });
 ```

package/dist/index.d.ts

@@ -5867,7 +5867,7 @@ type ModelFieldBasics = {
     increment?: boolean;
 };
 type ModelFieldNormal = ModelFieldBasics & {
-    type: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'group';
+    type: 'string' | 'number' | 'boolean' | 'date' | 'json';
 };
 type ModelFieldReferenceAction = 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT' | 'NO ACTION';
 type ModelFieldReference = ModelFieldBasics & {
@@ -5984,7 +5984,8 @@ type PublicModel<T extends Array<ModelField> = Array<ModelField>> = Omit<Partial
     identifiers?: Partial<Model['identifiers']>;
 };
 
-type Row = Record<string, unknown>;
+type RawRow = Array<unknown>;
+type ObjectRow = Record<string, unknown>;
 type NativeRecord = Record<string, unknown> & {
     id: string;
     ronin: {
@@ -6059,6 +6060,7 @@ declare class Transaction {
     statements: Array<Statement>;
     models: Array<Model>;
     private queries;
+    private fields;
     constructor(queries: Array<Query>, options?: TransactionOptions);
     /**
      * Composes SQL statements for the provided RONIN queries.
@@ -6070,8 +6072,9 @@ declare class Transaction {
      * @returns The composed SQL statements.
      */
     private compileQueries;
-    private formatRecord;
-    prepareResults(results: Array<Array<Row>>): Array<Result>;
+    private formatRow;
+    formatResults(results: Array<Array<RawRow>>, raw?: true): Array<Result>;
+    formatResults(results: Array<Array<ObjectRow>>, raw?: false): Array<Result>;
 }
 
 declare const CLEAN_ROOT_MODEL: PublicModel;

package/dist/index.js

@@ -20,6 +20,7 @@ var RONIN_MODEL_FIELD_REGEX = new RegExp(
   `${QUERY_SYMBOLS.FIELD}[_a-zA-Z0-9.]+`,
   "g"
 );
+var composeIncludedTableAlias = (fieldSlug) => `including_${fieldSlug}`;
 var MODEL_ENTITY_ERROR_CODES = {
   field: "FIELD_NOT_FOUND",
   index: "INDEX_NOT_FOUND",
@@ -117,7 +118,11 @@ var omit = (obj, properties) => Object.fromEntries(
 var expand = (obj) => {
   return Object.entries(obj).reduce((res, [key, val]) => {
     key.split(".").reduce((acc, part, i, arr) => {
-      acc[part] = i === arr.length - 1 ? val : acc[part] || {};
+      if (i === arr.length - 1) {
+        acc[part] = val;
+      } else {
+        acc[part] = typeof acc[part] === "object" && acc[part] !== null ? acc[part] : {};
+      }
       return acc[part];
     }, res);
     return res;
@@ -208,47 +213,52 @@ var composeConditions = (models, model, statementParams, instructionName, value,
     return conditions.join(" AND ");
   }
   if (options.fieldSlug) {
-    const fieldDetails = getFieldFromModel(model, options.fieldSlug, instructionName);
-    const { field: modelField } = fieldDetails;
-    const consumeJSON = modelField.type === "json" && instructionName === "to";
-    if (!(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
-      return composeFieldValues(
-        models,
-        model,
-        statementParams,
-        instructionName,
-        value,
-        { ...options, fieldSlug: options.fieldSlug }
-      );
-    }
-    if (modelField.type === "link" && isNested) {
-      const keys = Object.keys(value);
-      const values = Object.values(value);
-      let recordTarget;
-      if (keys.length === 1 && keys[0] === "id") {
-        recordTarget = values[0];
-      } else {
-        const relatedModel = getModelBySlug(models, modelField.target);
-        const subQuery = {
-          get: {
-            [relatedModel.slug]: {
-              with: value,
-              selecting: ["id"]
+    const childField = model.fields.some(({ slug }) => {
+      return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
+    });
+    if (!childField) {
+      const fieldDetails = getFieldFromModel(model, options.fieldSlug, instructionName);
+      const { field: modelField } = fieldDetails || {};
+      const consumeJSON = modelField?.type === "json" && instructionName === "to";
+      if (modelField && !(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
+        return composeFieldValues(
+          models,
+          model,
+          statementParams,
+          instructionName,
+          value,
+          { ...options, fieldSlug: options.fieldSlug }
+        );
+      }
+      if (modelField?.type === "link" && isNested) {
+        const keys = Object.keys(value);
+        const values = Object.values(value);
+        let recordTarget;
+        if (keys.length === 1 && keys[0] === "id") {
+          recordTarget = values[0];
+        } else {
+          const relatedModel = getModelBySlug(models, modelField.target);
+          const subQuery = {
+            get: {
+              [relatedModel.slug]: {
+                with: value,
+                selecting: ["id"]
+              }
             }
-          }
-        };
-        recordTarget = {
-          [QUERY_SYMBOLS.QUERY]: subQuery
-        };
+          };
+          recordTarget = {
+            [QUERY_SYMBOLS.QUERY]: subQuery
+          };
+        }
+        return composeConditions(
+          models,
+          model,
+          statementParams,
+          instructionName,
+          recordTarget,
+          options
+        );
       }
-      return composeConditions(
-        models,
-        model,
-        statementParams,
-        instructionName,
-        recordTarget,
-        options
-      );
     }
   }
   if (isNested) {
@@ -358,7 +368,7 @@ var getFieldSelector = (model, field, fieldPath, instructionName) => {
   }
   return `${tablePrefix}"${fieldPath}"`;
 };
-var getFieldFromModel = (model, fieldPath, instructionName) => {
+function getFieldFromModel(model, fieldPath, instructionName, shouldThrow = true) {
   const errorPrefix = `Field "${fieldPath}" defined for \`${instructionName}\``;
   const modelFields = model.fields || [];
   let modelField;
@@ -376,16 +386,19 @@ var getFieldFromModel = (model, fieldPath, instructionName) => {
   }
   modelField = modelFields.find((field) => field.slug === fieldPath);
   if (!modelField) {
-    throw new RoninError({
-      message: `${errorPrefix} does not exist in model "${model.name}".`,
-      code: "FIELD_NOT_FOUND",
-      field: fieldPath,
-      queries: null
-    });
+    if (shouldThrow) {
+      throw new RoninError({
+        message: `${errorPrefix} does not exist in model "${model.name}".`,
+        code: "FIELD_NOT_FOUND",
+        field: fieldPath,
+        queries: null
+      });
+    }
+    return null;
   }
   const fieldSelector = getFieldSelector(model, modelField, fieldPath, instructionName);
   return { field: modelField, fieldSelector };
-};
+}
 var slugToName = (slug) => {
   const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
   return title(name);
@@ -441,11 +454,6 @@ var SYSTEM_FIELDS = [
     slug: "id",
     displayAs: "single-line"
   },
-  {
-    name: "RONIN",
-    type: "group",
-    slug: "ronin"
-  },
   {
     name: "RONIN - Locked",
     type: "boolean",
@@ -489,7 +497,6 @@ var ROOT_MODEL = {
     { slug: "pluralSlug", type: "string" },
     { slug: "idPrefix", type: "string" },
     { slug: "table", type: "string" },
-    { slug: "identifiers", type: "group" },
     { slug: "identifiers.name", type: "string" },
     { slug: "identifiers.slug", type: "string" },
     // Providing an empty object as a default value allows us to use `json_insert`
@@ -611,7 +618,6 @@ var typesInSQLite = {
   json: "TEXT"
 };
 var getFieldStatement = (models, model, field) => {
-  if (field.type === "group") return null;
   let statement = `"${field.slug}" ${typesInSQLite[field.type]}`;
   if (field.slug === "id") statement += " PRIMARY KEY";
   if (field.unique === true) statement += " UNIQUE";
@@ -1103,7 +1109,7 @@ var handleIncluding = (models, model, statementParams, instruction) => {
     const relatedModel = getModelBySlug(models, queryModel);
     let joinType = "LEFT";
     let relatedTableSelector = `"${relatedModel.table}"`;
-    const tableAlias = `including_${ephemeralFieldSlug}`;
+    const tableAlias = composeIncludedTableAlias(ephemeralFieldSlug);
     const single = queryModel !== relatedModel.pluralSlug;
     if (!modifiableQueryInstructions?.with) {
       joinType = "CROSS";
@@ -1185,49 +1191,69 @@ var handleOrderedBy = (model, instruction) => {
 
 // src/instructions/selecting.ts
 var handleSelecting = (models, model, statementParams, instructions, options) => {
+  let loadedFields = [];
+  let statement = "*";
   let isJoining = false;
-  let statement = instructions.selecting ? instructions.selecting.map((slug) => {
-    return getFieldFromModel(model, slug, "selecting").fieldSelector;
-  }).join(", ") : "*";
   if (instructions.including) {
     const flatObject = flatten(instructions.including);
-    const filteredObject = Object.entries(flatObject).flatMap(([key, value]) => {
+    instructions.including = {};
+    for (const [key, value] of Object.entries(flatObject)) {
       const symbol = getSymbol(value);
       if (symbol?.type === "query") {
         isJoining = true;
-        if (!options?.expandColumns) return null;
-        const { queryModel: queryModelSlug } = splitQuery(symbol.value);
-        const queryModel = getModelBySlug(models, queryModelSlug);
-        const tableName = `including_${key}`;
-        const duplicatedFields = queryModel.fields.filter((field) => {
-          if (field.type === "group") return null;
-          return model.fields.some((modelField) => modelField.slug === field.slug);
-        }).filter((item) => item !== null);
-        return duplicatedFields.map((field) => {
-          const value2 = parseFieldExpression(
-            { ...queryModel, tableAlias: tableName },
-            "including",
-            `${QUERY_SYMBOLS.FIELD}${field.slug}`
-          );
-          return {
-            key: `${tableName}.${field.slug}`,
-            value: value2
-          };
-        });
+        const { queryModel, queryInstructions } = splitQuery(symbol.value);
+        const subQueryModel = getModelBySlug(models, queryModel);
+        const tableName = composeIncludedTableAlias(key);
+        const queryModelFields = queryInstructions?.selecting ? subQueryModel.fields.filter((field) => {
+          return queryInstructions.selecting?.includes(field.slug);
+        }) : subQueryModel.fields;
+        for (const field of queryModelFields) {
+          loadedFields.push({ ...field, parentField: key });
+          if (options?.expandColumns) {
+            const newValue2 = parseFieldExpression(
+              { ...subQueryModel, tableAlias: tableName },
+              "including",
+              `${QUERY_SYMBOLS.FIELD}${field.slug}`
+            );
+            instructions.including[`${tableName}.${field.slug}`] = newValue2;
+          }
+        }
+        continue;
       }
+      let newValue = value;
       if (symbol?.type === "expression") {
-        value = `(${parseFieldExpression(model, "including", symbol.value)})`;
+        newValue = `(${parseFieldExpression(model, "including", symbol.value)})`;
       } else {
-        value = prepareStatementValue(statementParams, value);
+        newValue = prepareStatementValue(statementParams, value);
       }
-      return { key, value };
-    }).filter((entry) => entry !== null).map((entry) => [entry.key, entry.value]);
-    if (filteredObject.length > 0) {
-      statement += ", ";
-      statement += filteredObject.map(([key, value]) => `${value} as "${key}"`).join(", ");
+      instructions.including[key] = newValue;
     }
   }
-  return { columns: statement, isJoining };
+  const expandColumns = isJoining && options?.expandColumns;
+  if (expandColumns) {
+    instructions.selecting = model.fields.map((field) => field.slug);
+  }
+  if (instructions.selecting) {
+    const usableModel = expandColumns ? { ...model, tableAlias: model.tableAlias || model.table } : model;
+    const selectedFields = [];
+    statement = instructions.selecting.map((slug) => {
+      const { field, fieldSelector } = getFieldFromModel(
+        usableModel,
+        slug,
+        "selecting"
+      );
+      selectedFields.push(field);
+      return fieldSelector;
+    }).join(", ");
+    loadedFields = [...selectedFields, ...loadedFields];
+  } else {
+    loadedFields = [...model.fields, ...loadedFields];
+  }
+  if (instructions.including && Object.keys(instructions.including).length > 0) {
+    statement += ", ";
+    statement += Object.entries(instructions.including).map(([key, value]) => `${value} as "${key}"`).join(", ");
+  }
+  return { columns: statement, isJoining, loadedFields };
 };
 
 // src/instructions/to.ts
@@ -1294,8 +1320,8 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
   Object.assign(toInstruction, defaultFields);
   for (const fieldSlug in toInstruction) {
     const fieldValue = toInstruction[fieldSlug];
-    const fieldDetails = getFieldFromModel(model, fieldSlug, "to");
-    if (fieldDetails.field.type === "link" && fieldDetails.field.kind === "many") {
+    const fieldDetails = getFieldFromModel(model, fieldSlug, "to", false);
+    if (fieldDetails?.field.type === "link" && fieldDetails.field.kind === "many") {
       delete toInstruction[fieldSlug];
       const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);
       const composeStatement = (subQueryType, value) => {
@@ -1360,7 +1386,8 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     statementParams,
     defaultQuery
   );
-  if (query === null) return { dependencies: [], main: dependencyStatements[0] };
+  if (query === null)
+    return { dependencies: [], main: dependencyStatements[0], loadedFields: [] };
   const parsedQuery = splitQuery(query);
   const { queryType, queryModel, queryInstructions } = parsedQuery;
   const model = getModelBySlug(models, queryModel);
@@ -1370,7 +1397,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   if (instructions && Object.hasOwn(instructions, "for")) {
     instructions = handleFor(model, instructions);
   }
-  const { columns, isJoining } = handleSelecting(
+  const { columns, isJoining, loadedFields } = handleSelecting(
     models,
     model,
     statementParams,
@@ -1499,7 +1526,8 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   if (returning) mainStatement.returning = true;
   return {
     dependencies: dependencyStatements,
-    main: mainStatement
+    main: mainStatement,
+    loadedFields
   };
 };
 
@@ -1508,6 +1536,7 @@ var Transaction = class {
   statements;
   models = [];
   queries;
+  fields = [];
   constructor(queries, options) {
     const models = options?.models || [];
     this.statements = this.compileQueries(queries, models, options);
@@ -1544,42 +1573,67 @@ var Transaction = class {
       );
       dependencyStatements.push(...result.dependencies);
       mainStatements.push(result.main);
+      this.fields.push(result.loadedFields);
     }
     this.models = modelListWithPresets;
     return [...dependencyStatements, ...mainStatements];
   };
-  formatRecord(model, record) {
-    const formattedRecord = { ...record };
-    for (const key in record) {
-      const { field } = getFieldFromModel(model, key, "to");
+  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") {
-        formattedRecord[key] = JSON.parse(record[key]);
-        continue;
+        newValue = JSON.parse(value);
       }
-      formattedRecord[key] = record[key];
+      record[newSlug] = newValue;
     }
-    return expand(formattedRecord);
+    return expand(record);
   }
-  prepareResults(results) {
+  /**
+   * Format the results returned from the database into RONIN records.
+   *
+   * @param results - A list of results from the database, where each result is an array
+   * of rows.
+   * @param raw - By default, rows are expected to be arrays of values, which is how SQL
+   * databases return rows by default. If the driver being used returns rows as objects
+   * instead, this option should be set to `false`.
+   *
+   * @returns A list of formatted RONIN results, where each result is either a single
+   * RONIN record, an array of RONIN records, or a RONIN count result.
+   */
+  formatResults(results, raw = true) {
     const relevantResults = results.filter((_, index) => {
       return this.statements[index].returning;
     });
-    return relevantResults.map((result, index) => {
+    const normalizedResults = raw ? relevantResults : relevantResults.map((rows) => {
+      return rows.map((row) => {
+        if (Array.isArray(row)) return row;
+        if (row["COUNT(*)"]) return [row["COUNT(*)"]];
+        return Object.values(row);
+      });
+    });
+    return normalizedResults.map((rows, index) => {
       const query = this.queries.at(-index);
+      const fields = this.fields.at(-index);
       const { queryType, queryModel, queryInstructions } = splitQuery(query);
       const model = getModelBySlug(this.models, queryModel);
       if (queryType === "count") {
-        return { amount: result[0]["COUNT(*)"] };
+        return { amount: rows[0][0] };
       }
       const single = queryModel !== model.pluralSlug;
       if (single) {
-        return { record: this.formatRecord(model, result[0]) };
+        return { record: this.formatRow(fields, rows[0]) };
       }
       const pageSize = queryInstructions?.limitedTo;
       const output = {
-        records: result.map((resultItem) => {
-          return this.formatRecord(model, resultItem);
-        })
+        records: rows.map((row) => this.formatRow(fields, row))
       };
       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-219",
+  "version": "0.10.3-leo-ron-1083-experimental-221",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {