@ronin/compiler 0.14.0 → 0.14.1-leo-ron-1099-1-experimental-318

package/dist/index.d.ts

@@ -36,6 +36,22 @@ declare class RoninError extends Error {
     queries?: Details['queries'];
     constructor(details: Details);
 }
+/**
+ * Checks if the provided value contains a RONIN model symbol (a represenation of a
+ * particular entity inside a query, such as an expression or a sub query) and returns
+ * its type and value.
+ *
+ * @param value - The value that should be checked.
+ *
+ * @returns The type and value of the symbol, if the provided value contains one.
+ */
+declare const getQuerySymbol: (value: unknown) => {
+    type: "query";
+    value: Query;
+} | {
+    type: "expression";
+    value: string;
+} | null;
 
 type QueryTypeEnum = 'get' | 'set' | 'add' | 'remove' | 'count';
 type ModelQueryTypeEnum = 'create' | 'alter' | 'drop';
@@ -169,7 +185,7 @@ type ModelFieldBasics = {
      * The value that should be inserted into the field in the case that no value was
      * explicitly provided for it when a record is created.
      */
-    defaultValue?: unknown;
+    defaultValue?: Expression | unknown;
     /**
      * An expression that should be evaluated to form the value of the field. The
      * expression can either be VIRTUAL (evaluated whenever a record is read) or STORED
@@ -378,4 +394,4 @@ declare class Transaction {
 
 declare const CLEAN_ROOT_MODEL: PublicModel;
 
-export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, 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, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, Transaction, type WithInstruction };
+export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, 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, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, Transaction, type WithInstruction, getQuerySymbol };

package/dist/index.js

@@ -70,7 +70,7 @@ var convertToCamelCase = (str) => {
   return sanitize(str).split(SPLIT_REGEX).map((part, index) => index === 0 ? part.toLowerCase() : capitalize(part)).join("");
 };
 var isObject = (value) => value != null && typeof value === "object" && Array.isArray(value) === false;
-var getSymbol = (value) => {
+var getQuerySymbol = (value) => {
   if (!isObject(value)) return null;
   const objectValue = value;
   if (QUERY_SYMBOLS.QUERY in objectValue) {
@@ -110,7 +110,7 @@ var flatten = (obj, prefix = "", res = {}) => {
     if (!Object.hasOwn(obj, key)) continue;
     const path = prefix ? `${prefix}.${key}` : key;
     const value = obj[key];
-    if (typeof value === "object" && value !== null && !getSymbol(value)) {
+    if (typeof value === "object" && value !== null && !getQuerySymbol(value)) {
       flatten(value, path, res);
     } else {
       res[path] = value;
@@ -304,7 +304,7 @@ var handleIncluding = (models, model, statementParams, single, instruction) => {
   let tableSubQuery;
   for (const ephemeralFieldSlug in instruction) {
     if (!Object.hasOwn(instruction, ephemeralFieldSlug)) continue;
-    const symbol = getSymbol(instruction[ephemeralFieldSlug]);
+    const symbol = getQuerySymbol(instruction[ephemeralFieldSlug]);
     if (symbol?.type !== "query") continue;
     const { queryType, queryModel, queryInstructions } = splitQuery(symbol.value);
     let modifiableQueryInstructions = queryInstructions;
@@ -350,6 +350,16 @@ var handleIncluding = (models, model, statementParams, single, instruction) => {
     if (single && !subSingle) {
       tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
     }
+    if (modifiableQueryInstructions?.including) {
+      const subIncluding = handleIncluding(
+        models,
+        { ...relatedModel, tableAlias },
+        statementParams,
+        subSingle,
+        modifiableQueryInstructions.including
+      );
+      statement += ` ${subIncluding.statement}`;
+    }
   }
   return { statement, tableSubQuery };
 };
@@ -373,7 +383,7 @@ var handleOrderedBy = (model, instruction) => {
     if (statement.length > 0) {
       statement += ", ";
     }
-    const symbol = getSymbol(item.value);
+    const symbol = getQuerySymbol(item.value);
     const instructionName = item.order === "ASC" ? "orderedBy.ascending" : "orderedBy.descending";
     if (symbol?.type === "expression") {
       statement += `(${parseFieldExpression(model, instructionName, symbol.value)}) ${item.order}`;
@@ -391,93 +401,95 @@ var handleOrderedBy = (model, instruction) => {
 };
 
 // src/instructions/selecting.ts
-var handleSelecting = (models, model, statementParams, single, instructions, options) => {
-  let loadedFields = [];
-  let expandColumns = false;
-  let statement = "*";
+var handleSelecting = (models, model, statementParams, single, instructions, options = {}) => {
   let isJoining = false;
+  const selectedFields = (instructions.selecting ? instructions.selecting.map((slug) => {
+    const { field } = getFieldFromModel(model, slug, {
+      instructionName: "selecting"
+    });
+    return field;
+  }) : model.fields).filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => {
+    const newField = { ...field, mountingPath: field.slug };
+    if (options.mountingPath) {
+      newField.mountingPath = `${options.mountingPath}.${field.slug}`;
+    }
+    return newField;
+  });
+  if (instructions.selecting) options.expandColumns = true;
+  const joinedSelectedFields = [];
+  const joinedColumns = [];
   if (instructions.including) {
+    const symbol = getQuerySymbol(instructions.including);
+    if (symbol?.type === "query") {
+      instructions.including.ronin_root = { ...instructions.including };
+      delete instructions.including[QUERY_SYMBOLS.QUERY];
+    }
     const flatObject = flatten(instructions.including);
-    instructions.including = {};
     for (const [key, value] of Object.entries(flatObject)) {
-      const symbol = getSymbol(value);
-      if (symbol?.type === "query") {
-        const { queryModel, queryInstructions } = splitQuery(symbol.value);
+      const symbol2 = getQuerySymbol(value);
+      if (symbol2?.type === "query") {
+        const { queryModel, queryInstructions } = splitQuery(symbol2.value);
         const subQueryModel = getModelBySlug(models, queryModel);
         isJoining = true;
-        expandColumns = Boolean(options?.expandColumns || queryInstructions?.selecting);
+        if (queryInstructions?.selecting) options.expandColumns = true;
         const tableAlias = composeIncludedTableAlias(key);
         const subSingle = queryModel !== subQueryModel.pluralSlug;
-        if (single && !subSingle) {
-          model.tableAlias = `sub_${model.table}`;
-        }
-        const queryModelFields = queryInstructions?.selecting ? subQueryModel.fields.filter((field) => {
-          return queryInstructions.selecting?.includes(field.slug);
-        }) : (
-          // Exclude link fields with cardinality "many", since those don't exist as columns.
-          subQueryModel.fields.filter((field) => {
-            return !(field.type === "link" && field.kind === "many");
-          })
+        if (!model.tableAlias)
+          model.tableAlias = single && !subSingle ? `sub_${model.table}` : model.table;
+        const subMountingPath = key === "ronin_root" ? options.mountingPath : `${options?.mountingPath ? `${options?.mountingPath}.` : ""}${subSingle ? key : `${key}[0]`}`;
+        const { columns: nestedColumns, selectedFields: nestedSelectedFields } = handleSelecting(
+          models,
+          { ...subQueryModel, tableAlias },
+          statementParams,
+          subSingle,
+          {
+            selecting: queryInstructions?.selecting,
+            including: queryInstructions?.including
+          },
+          { ...options, mountingPath: subMountingPath }
         );
-        for (const field of queryModelFields) {
-          loadedFields.push({
-            ...field,
-            parentField: {
-              slug: key,
-              single: subSingle
-            }
-          });
-          if (expandColumns) {
-            const newValue2 = parseFieldExpression(
-              { ...subQueryModel, tableAlias },
-              "including",
-              `${QUERY_SYMBOLS.FIELD}${field.slug}`
-            );
-            instructions.including[`${tableAlias}.${field.slug}`] = newValue2;
-          }
-        }
+        if (nestedColumns !== "*") joinedColumns.push(nestedColumns);
+        joinedSelectedFields.push(...nestedSelectedFields);
         continue;
       }
-      let newValue = value;
-      if (symbol?.type === "expression") {
-        newValue = `(${parseFieldExpression(model, "including", symbol.value)})`;
+      let mountedValue = value;
+      if (symbol2?.type === "expression") {
+        mountedValue = `(${parseFieldExpression(model, "including", symbol2.value)})`;
       } else {
-        newValue = prepareStatementValue(statementParams, value);
+        mountedValue = prepareStatementValue(statementParams, value);
       }
-      instructions.including[key] = newValue;
-      loadedFields.push({
+      selectedFields.push({
         slug: key,
-        type: RAW_FIELD_TYPES.includes(typeof value) ? typeof value : "string"
+        mountingPath: key,
+        type: RAW_FIELD_TYPES.includes(typeof value) ? typeof value : "string",
+        mountedValue
       });
     }
   }
-  if (expandColumns) {
-    instructions.selecting = model.fields.filter((field) => !(field.type === "link" && field.kind === "many")).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, {
-        instructionName: "selecting"
-      });
-      selectedFields.push(field);
-      return fieldSelector;
-    }).join(", ");
-    loadedFields = [...selectedFields, ...loadedFields];
-  } else {
-    loadedFields = [
-      ...model.fields.filter(
-        (field) => !(field.type === "link" && field.kind === "many")
-      ),
-      ...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 };
+  let columns = ["*"];
+  const fieldsToExpand = options.expandColumns ? selectedFields : selectedFields.filter(
+    (loadedField) => typeof loadedField.mountedValue !== "undefined"
+  );
+  const extraColumns = fieldsToExpand.map((selectedField) => {
+    if (selectedField.mountedValue) {
+      return `${selectedField.mountedValue} as "${selectedField.slug}"`;
+    }
+    const { fieldSelector } = getFieldFromModel(model, selectedField.slug, {
+      instructionName: "selecting"
+    });
+    if (options.mountingPath) {
+      return `${fieldSelector} as "${options.mountingPath}.${selectedField.slug}"`;
+    }
+    return fieldSelector;
+  });
+  if (options.expandColumns) {
+    columns = extraColumns;
+  } else if (extraColumns) {
+    columns.push(...extraColumns);
+  }
+  columns.push(...joinedColumns);
+  selectedFields.push(...joinedSelectedFields);
+  return { columns: columns.join(", "), isJoining, selectedFields };
 };
 
 // src/instructions/to.ts
@@ -492,7 +504,7 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
       ...toInstruction.ronin
     };
   }
-  const symbol = getSymbol(toInstruction);
+  const symbol = getQuerySymbol(toInstruction);
   if (symbol?.type === "query") {
     const { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
     const subQueryModel = getModelBySlug(models, subQueryModelSlug);
@@ -599,7 +611,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     defaultQuery
   );
   if (query === null)
-    return { dependencies: [], main: dependencyStatements[0], loadedFields: [] };
+    return { dependencies: [], main: dependencyStatements[0], selectedFields: [] };
   const parsedQuery = splitQuery(query);
   const { queryType, queryModel, queryInstructions } = parsedQuery;
   const model = getModelBySlug(models, queryModel);
@@ -609,7 +621,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   if (instructions && Object.hasOwn(instructions, "for")) {
     instructions = handleFor(model, instructions);
   }
-  const { columns, isJoining, loadedFields } = handleSelecting(
+  const { columns, isJoining, selectedFields } = handleSelecting(
     models,
     model,
     statementParams,
@@ -741,7 +753,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   return {
     dependencies: dependencyStatements,
     main: mainStatement,
-    loadedFields
+    selectedFields
   };
 };
 
@@ -790,7 +802,7 @@ var composeFieldValues = (models, model, statementParams, instructionName, value
     { instructionName }
   );
   const collectStatementValue = options.type !== "fields";
-  const symbol = getSymbol(value);
+  const symbol = getQuerySymbol(value);
   let conditionMatcher = "=";
   let conditionValue = value;
   if (options.condition) {
@@ -836,7 +848,7 @@ var composeConditions = (models, model, statementParams, instructionName, value,
       });
       const { field: modelField } = fieldDetails || {};
       const consumeJSON = modelField?.type === "json" && instructionName === "to";
-      if (modelField && !(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
+      if (modelField && !(isObject(value) || Array.isArray(value)) || getQuerySymbol(value) || consumeJSON) {
         return composeFieldValues(
           models,
           model,
@@ -1215,15 +1227,59 @@ var addDefaultModelPresets = (list, model) => {
   const defaultPresets = [];
   for (const field of model.fields || []) {
     if (field.type === "link" && !field.slug.startsWith("ronin.")) {
-      const relatedModel = getModelBySlug(list, field.target);
-      if (field.kind === "many") continue;
+      const targetModel = getModelBySlug(list, field.target);
+      if (field.kind === "many") {
+        const systemModel = list.find(({ system }) => {
+          return system?.model === model.id && system?.associationSlug === field.slug;
+        });
+        if (!systemModel) continue;
+        const preset = {
+          instructions: {
+            // Perform a LEFT JOIN that adds the associative table.
+            including: {
+              [field.slug]: {
+                [QUERY_SYMBOLS.QUERY]: {
+                  get: {
+                    [systemModel.pluralSlug]: {
+                      // ON associative_table.source = origin_model.id
+                      with: {
+                        source: {
+                          [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
+                        }
+                      },
+                      // Perform a LEFT JOIN that adds the target model table.
+                      including: {
+                        [QUERY_SYMBOLS.QUERY]: {
+                          get: {
+                            [targetModel.slug]: {
+                              // ON target_model.id = associative_table.target
+                              with: {
+                                id: {
+                                  [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}target`
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          slug: field.slug
+        };
+        defaultPresets.push(preset);
+        continue;
+      }
       defaultPresets.push({
         instructions: {
           including: {
             [field.slug]: {
               [QUERY_SYMBOLS.QUERY]: {
                 get: {
-                  [relatedModel.slug]: {
+                  [targetModel.slug]: {
                     with: {
                       // Compare the `id` field of the related model to the link field on
                       // the root model (`field.slug`).
@@ -1242,6 +1298,7 @@ var addDefaultModelPresets = (list, model) => {
     }
   }
   const childModels = list.map((subModel) => {
+    if (subModel.system?.associationSlug) return null;
     const field = subModel.fields?.find((field2) => {
       return field2.type === "link" && field2.target === model.slug;
     });
@@ -1299,8 +1356,10 @@ var getFieldSelector = (model, field, fieldPath, writing) => {
   if (field.type === "json" && !writing) {
     const dotParts = fieldPath.split(".");
     const columnName = tablePrefix + dotParts.shift();
-    const jsonField = dotParts.join(".");
-    return `json_extract(${columnName}, '$.${jsonField}')`;
+    if (dotParts.length > 0) {
+      const jsonField = dotParts.join(".");
+      return `json_extract(${columnName}, '$.${jsonField}')`;
+    }
   }
   return `${tablePrefix}"${fieldPath}"`;
 };
@@ -1448,7 +1507,7 @@ var getFieldStatement = (models, model, field) => {
   if (field.unique === true) statement += " UNIQUE";
   if (field.required === true) statement += " NOT NULL";
   if (typeof field.defaultValue !== "undefined") {
-    const symbol = getSymbol(field.defaultValue);
+    const symbol = getQuerySymbol(field.defaultValue);
     let value = typeof field.defaultValue === "string" ? `'${field.defaultValue}'` : field.defaultValue;
     if (symbol) value = `(${parseFieldExpression(model, "to", symbol.value)})`;
     statement += ` DEFAULT ${value}`;
@@ -1460,12 +1519,12 @@ var getFieldStatement = (models, model, field) => {
     statement += " AUTOINCREMENT";
   }
   if (typeof field.check !== "undefined") {
-    const symbol = getSymbol(field.check);
+    const symbol = getQuerySymbol(field.check);
     statement += ` CHECK (${parseFieldExpression(model, "to", symbol?.value)})`;
   }
   if (typeof field.computedAs !== "undefined") {
     const { kind, value } = field.computedAs;
-    const symbol = getSymbol(value);
+    const symbol = getQuerySymbol(value);
     statement += ` GENERATED ALWAYS AS (${parseFieldExpression(model, "to", symbol?.value)}) ${kind}`;
   }
   if (field.type === "link") {
@@ -1901,7 +1960,7 @@ var Transaction = class {
         ...subStatements.map((statement) => ({
           ...statement,
           query,
-          fields: result.loadedFields
+          selectedFields: result.selectedFields
         }))
       );
     }
@@ -1912,12 +1971,8 @@ var Transaction = class {
     const records = [];
     for (const row of rows) {
       const record = fields.reduce((acc, field, fieldIndex) => {
-        let newSlug = field.slug;
+        const newSlug = field.mountingPath;
         let newValue = row[fieldIndex];
-        if (field.parentField) {
-          const arrayKey = field.parentField.single ? "" : "[0]";
-          newSlug = `${field.parentField.slug}${arrayKey}.${field.slug}`;
-        }
         if (field.type === "json") {
           newValue = JSON.parse(newValue);
         } else if (field.type === "boolean") {
@@ -1938,17 +1993,13 @@ var Transaction = class {
         records.push(record);
         continue;
       }
-      const joinFields = fields.reduce(
-        (acc, field) => {
-          if (!field.parentField) return acc;
-          const { single: single2, slug } = field.parentField;
-          return single2 || acc.includes(slug) ? acc : acc.concat([slug]);
-        },
-        []
-      );
-      for (const parentField of joinFields) {
-        const currentValue = existingRecord[parentField];
-        const newValue = record[parentField];
+      const joinFields = fields.reduce((acc, { mountingPath }) => {
+        if (mountingPath.includes("[0]")) acc.add(mountingPath.split("[0]")[0]);
+        return acc;
+      }, /* @__PURE__ */ new Set());
+      for (const arrayField of joinFields.values()) {
+        const currentValue = existingRecord[arrayField];
+        const newValue = record[arrayField];
         currentValue.push(...newValue);
       }
     }
@@ -1976,11 +2027,7 @@ var Transaction = class {
     });
     const formattedResults = normalizedResults.map(
       (rows, index) => {
-        const {
-          returning,
-          query,
-          fields: rawModelFields
-        } = this.#internalStatements[index];
+        const { returning, query, selectedFields } = this.#internalStatements[index];
         if (!returning) return null;
         const { queryType, queryModel, queryInstructions } = splitQuery(query);
         const model = getModelBySlug(this.models, queryModel);
@@ -1994,13 +2041,13 @@ var Transaction = class {
         const single = queryModel !== model.pluralSlug;
         if (single) {
           return {
-            record: rows[0] ? this.#formatRows(rawModelFields, rows, true, isMeta) : null,
+            record: rows[0] ? this.#formatRows(selectedFields, rows, true, isMeta) : null,
             modelFields
           };
         }
         const pageSize = queryInstructions?.limitedTo;
         const output = {
-          records: this.#formatRows(rawModelFields, rows, false, isMeta),
+          records: this.#formatRows(selectedFields, rows, false, isMeta),
           modelFields
         };
         if (pageSize && output.records.length > 0) {
@@ -2043,5 +2090,6 @@ export {
   QUERY_SYMBOLS,
   CLEAN_ROOT_MODEL as ROOT_MODEL,
   RoninError,
-  Transaction
+  Transaction,
+  getQuerySymbol
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.14.0",
+  "version": "0.14.1-leo-ron-1099-1-experimental-318",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {