@ronin/compiler 0.14.0-leo-ron-1099-1-experimental-315 → 0.14.0-leo-ron-1099-1-experimental-317

package/dist/index.d.ts

@@ -169,7 +169,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

package/dist/index.js

@@ -1227,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`).
@@ -1254,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;
     });

package/package.json

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