@ronin/compiler 0.15.0 → 0.16.0-leo-ron-1099-1-experimental-365

package/dist/index.d.ts

@@ -391,7 +391,11 @@ type MultipleRecordResult<T = ResultRecord> = {
 type AmountResult = {
     amount: number;
 };
-type Result<T = ResultRecord> = SingleRecordResult<T> | MultipleRecordResult<T> | AmountResult;
+type RegularResult<T = ResultRecord> = SingleRecordResult<T> | MultipleRecordResult<T> | AmountResult;
+type ExpandedResult<T = ResultRecord> = {
+    models: Record<Model['slug'], RegularResult<T>>;
+};
+type Result<T = ResultRecord> = RegularResult<T> | ExpandedResult<T>;
 
 interface TransactionOptions {
     /** A list of models that already exist in the database. */
@@ -407,10 +411,10 @@ declare class Transaction {
     statements: Array<Statement>;
     models: Array<Model>;
     constructor(queries: Array<Query>, options?: TransactionOptions);
-    formatResults<Record>(results: Array<Array<ObjectRow>>, raw?: false): Array<Result<Record>>;
-    formatResults<Record>(results: Array<Array<RawRow>>, raw?: true): Array<Result<Record>>;
+    formatResults<RecordType>(results: Array<Array<ObjectRow>>, raw?: false): Array<Result<RecordType>>;
+    formatResults<RecordType>(results: Array<Array<RawRow>>, raw?: true): Array<Result<RecordType>>;
 }
 
 declare const CLEAN_ROOT_MODEL: PublicModel;
 
-export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type AlterQuery, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, type CreateQuery, type DropQuery, type GetInstructions, type GetQuery, type GetInstructions as GetQueryInstructions, type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, QUERY_SYMBOLS, type Query, type QueryInstructionType as QueryInstruction, type QuerySchemaType, type QueryType, CLEAN_ROOT_MODEL as ROOT_MODEL, type RemoveInstructions, type RemoveQuery, type RemoveInstructions as RemoveQueryInstructions, type Result, type ResultRecord, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, type StoredObject, Transaction, type WithInstruction, getQuerySymbol };
+export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type AlterQuery, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, type CreateQuery, type DropQuery, type ExpandedResult, type GetInstructions, type GetQuery, type GetInstructions as GetQueryInstructions, type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, QUERY_SYMBOLS, type Query, type QueryInstructionType as QueryInstruction, type QuerySchemaType, type QueryType, CLEAN_ROOT_MODEL as ROOT_MODEL, type RegularResult, type RemoveInstructions, type RemoveQuery, type RemoveInstructions as RemoveQueryInstructions, type Result, type ResultRecord, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, type StoredObject, Transaction, type WithInstruction, getQuerySymbol };

package/dist/index.js

@@ -566,8 +566,14 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
 // src/instructions/using.ts
 var handleUsing = (model, instructions) => {
   const normalizedUsing = Array.isArray(instructions.using) ? Object.fromEntries(instructions.using.map((presetSlug) => [presetSlug, null])) : instructions.using;
+  if ("links" in normalizedUsing) {
+    for (const field of model.fields) {
+      if (field.type !== "link" || field.kind === "many") continue;
+      normalizedUsing[field.slug] = null;
+    }
+  }
   for (const presetSlug in normalizedUsing) {
-    if (!Object.hasOwn(normalizedUsing, presetSlug)) continue;
+    if (!Object.hasOwn(normalizedUsing, presetSlug) || presetSlug === "links") continue;
     const arg = normalizedUsing[presetSlug];
     const preset = model.presets?.find((preset2) => preset2.slug === presetSlug);
     if (!preset) {
@@ -1509,6 +1515,7 @@ var ROOT_MODEL = {
     { slug: "presets", type: "json", defaultValue: "{}" }
   ]
 };
+var ROOT_MODEL_WITH_ATTRIBUTES = addDefaultModelAttributes(ROOT_MODEL, true);
 var getSystemModels = (models, model) => {
   const addedModels = [];
   for (const field of model.fields || []) {
@@ -1990,14 +1997,14 @@ var Transaction = class {
    * @returns The composed SQL statements.
    */
   #compileQueries = (queries, models, options) => {
-    const modelsWithAttributes = [ROOT_MODEL, ...models].map((model) => {
+    const modelsWithAttributes = models.map((model) => {
       return addDefaultModelAttributes(model, true);
     });
     const modelsWithFields = [
       ...modelsWithAttributes.flatMap((model) => {
         return getSystemModels(modelsWithAttributes, model);
       }),
-      ...modelsWithAttributes
+      ...[ROOT_MODEL_WITH_ATTRIBUTES, ...modelsWithAttributes]
     ].map((model) => {
       return addDefaultModelFields(model, true);
     });
@@ -2005,7 +2012,19 @@ var Transaction = class {
       return addDefaultModelPresets(modelsWithFields, model);
     });
     const statements = [];
-    for (const query of queries) {
+    const expandedQueries = queries.flatMap((query, expansionIndex) => {
+      const { queryType, queryModel, queryInstructions } = splitQuery(query);
+      if (queryModel === "all") {
+        return modelsWithAttributes.map((model) => {
+          const query2 = {
+            [queryType]: { [model.pluralSlug]: queryInstructions }
+          };
+          return { query: query2, expansionIndex };
+        });
+      }
+      return { query };
+    });
+    for (const { query, expansionIndex } of expandedQueries) {
       const { dependencies, main, selectedFields } = compileQueryInput(
         query,
         modelsWithPresets,
@@ -2019,7 +2038,8 @@ var Transaction = class {
         ...subStatements.map((statement) => ({
           ...statement,
           query,
-          selectedFields
+          selectedFields,
+          expansionIndex
         }))
       );
     }
@@ -2119,10 +2139,20 @@ var Transaction = class {
         return Object.values(row);
       });
     });
-    const formattedResults = normalizedResults.map(
-      (rows, index) => {
-        const { returning, query, selectedFields } = this.#internalStatements[index];
-        if (!returning) return null;
+    return normalizedResults.reduce(
+      (finalResults, rows, index) => {
+        const { returning, query, selectedFields, expansionIndex } = this.#internalStatements[index];
+        if (!returning) return finalResults;
+        const addResult = (result2) => {
+          if (typeof expansionIndex !== "undefined") {
+            let match = finalResults[expansionIndex];
+            if (!match) match = finalResults[expansionIndex] = { models: {} };
+            match.models[queryModel] = result2;
+          } else {
+            finalResults.push(result2);
+          }
+          return finalResults;
+        };
         const { queryType, queryModel, queryInstructions } = splitQuery(query);
         const model = getModelBySlug(this.models, queryModel);
         const isMeta = queryModel === "model" || queryModel === "models";
@@ -2130,32 +2160,32 @@ var Transaction = class {
           model.fields.map((field) => [field.slug, field.type])
         );
         if (queryType === "count") {
-          return { amount: rows[0][0] };
+          return addResult({ amount: rows[0][0] });
         }
         const single = queryModel !== model.pluralSlug;
         if (single) {
-          return {
+          return addResult({
             record: rows[0] ? this.#formatRows(selectedFields, rows, true, isMeta) : null,
             modelFields
-          };
+          });
         }
         const pageSize = queryInstructions?.limitedTo;
-        const output = {
+        const result = {
           records: this.#formatRows(selectedFields, rows, false, isMeta),
           modelFields
         };
-        if (pageSize && output.records.length > 0) {
-          if (output.records.length > pageSize) {
+        if (pageSize && result.records.length > 0) {
+          if (result.records.length > pageSize) {
             if (queryInstructions?.before) {
-              output.records.shift();
+              result.records.shift();
             } else {
-              output.records.pop();
+              result.records.pop();
             }
             const direction = queryInstructions?.before ? "moreBefore" : "moreAfter";
-            const lastRecord = output.records.at(
+            const lastRecord = result.records.at(
               direction === "moreAfter" ? -1 : 0
             );
-            output[direction] = generatePaginationCursor(
+            result[direction] = generatePaginationCursor(
               model,
               queryInstructions.orderedBy,
               lastRecord
@@ -2163,20 +2193,20 @@ var Transaction = class {
           }
           if (queryInstructions?.before || queryInstructions?.after) {
             const direction = queryInstructions?.before ? "moreAfter" : "moreBefore";
-            const firstRecord = output.records.at(
+            const firstRecord = result.records.at(
               direction === "moreAfter" ? -1 : 0
             );
-            output[direction] = generatePaginationCursor(
+            result[direction] = generatePaginationCursor(
               model,
               queryInstructions.orderedBy,
               firstRecord
             );
           }
         }
-        return output;
-      }
+        return addResult(result);
+      },
+      []
     );
-    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.15.0",
+  "version": "0.16.0-leo-ron-1099-1-experimental-365",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {