@ronin/compiler 0.11.6 → 0.11.7-leo-ron-1071-experimental-248

package/dist/index.d.ts

@@ -5998,16 +5998,18 @@ type NativeRecord = Record<string, unknown> & {
 };
 type SingleRecordResult<T = NativeRecord> = {
     record: T | null;
+    modelFields: Record<ModelField['slug'], ModelField['type']>;
 };
-type MultipleRecordResult = {
-    records: Array<NativeRecord>;
+type MultipleRecordResult<T = NativeRecord> = {
+    records: Array<T>;
     moreAfter?: string;
     moreBefore?: string;
+    modelFields: Record<ModelField['slug'], ModelField['type']>;
 };
 type AmountResult = {
     amount: number;
 };
-type Result = SingleRecordResult | MultipleRecordResult | AmountResult;
+type Result<T = NativeRecord> = SingleRecordResult<T> | MultipleRecordResult<T> | AmountResult;
 
 /**
  * A list of placeholders that can be located inside queries after those queries were
@@ -6062,8 +6064,7 @@ interface TransactionOptions {
 declare class Transaction {
     statements: Array<Statement>;
     models: Array<Model>;
-    private queries;
-    private fields;
+    private internalStatements;
     constructor(queries: Array<Query>, options?: TransactionOptions);
     /**
      * Composes SQL statements for the provided RONIN queries.

package/dist/index.js

@@ -1570,14 +1570,12 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
 
 // src/index.ts
 var Transaction = class {
-  statements;
+  statements = [];
   models = [];
-  queries;
-  fields = [];
+  internalStatements = [];
   constructor(queries, options) {
     const models = options?.models || [];
-    this.statements = this.compileQueries(queries, models, options);
-    this.queries = queries;
+    this.compileQueries(queries, models, options);
   }
   /**
    * Composes SQL statements for the provided RONIN queries.
@@ -1607,8 +1605,15 @@ var Transaction = class {
         options?.inlineParams ? null : [],
         { expandColumns: options?.expandColumns }
       );
-      statements.push(...result.dependencies, result.main);
-      this.fields.push(result.loadedFields);
+      const subStatements = [...result.dependencies, result.main];
+      this.statements.push(...subStatements);
+      this.internalStatements.push(
+        ...subStatements.map((statement) => ({
+          ...statement,
+          query,
+          fields: result.loadedFields
+        }))
+      );
     }
     this.models = modelListWithPresets;
     return statements;
@@ -1655,31 +1660,35 @@ var Transaction = class {
    * 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;
-    });
-    const normalizedResults = raw ? relevantResults : relevantResults.map((rows) => {
+    const normalizedResults = raw ? results : results.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 formattedResults = normalizedResults.map((rows, index) => {
+      const { returning, query, fields: rawModelFields } = this.internalStatements[index];
+      if (!returning) return null;
       const { queryType, queryModel, queryInstructions } = splitQuery(query);
       const model = getModelBySlug(this.models, queryModel);
+      const modelFields = Object.fromEntries(
+        model.fields.map((field) => [field.slug, field.type])
+      );
       if (queryType === "count") {
         return { amount: rows[0][0] };
       }
       const single = queryModel !== model.pluralSlug;
       if (single) {
-        return { record: rows[0] ? this.formatRows(fields, rows, single) : null };
+        return {
+          record: rows[0] ? this.formatRows(rawModelFields, rows, single) : null,
+          modelFields
+        };
       }
       const pageSize = queryInstructions?.limitedTo;
       const output = {
-        records: this.formatRows(fields, rows, single)
+        records: this.formatRows(rawModelFields, rows, single),
+        modelFields
       };
       if (pageSize && output.records.length > 0) {
         if (output.records.length > pageSize) {
@@ -1712,6 +1721,7 @@ var Transaction = class {
       }
       return output;
     });
+    return formattedResults.filter((result) => result !== null);
   }
 };
 var CLEAN_ROOT_MODEL = omit(ROOT_MODEL, ["system"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.11.6",
+  "version": "0.11.7-leo-ron-1071-experimental-248",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {