@ronin/compiler 0.16.5 → 0.17.0-leo-ron-1099-experimental-373

package/README.md

@@ -127,7 +127,12 @@ new Transaction(queries, {
   // Instead of returning an array of parameters for every statement (which allows for
   // preventing SQL injections), all parameters are inlined directly into the SQL strings.
   // This option should only be used if the generated SQL will be manually verified.
-  inlineParams: true
+  inlineParams: true,
+
+  // By default, the compiler relies on dynamic column default values for computing the
+  // values of all meta fields (such as `id`, `ronin.createdAt`, etc). In order to compute
+  // those values at the time of insertion instead, use this option.
+  inlineDefaults: true
 });
 ```
 

package/dist/index.d.ts

@@ -261,19 +261,19 @@ type ModelField = ModelFieldBasics & ({
     /** Whether the field should be related to one record, or many records. */
     kind: 'many';
 });
-type ModelIndexField<T extends Array<ModelField> = Array<ModelField>> = {
+type ModelIndexField<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
     /** The collating sequence used for text placed inside the field. */
     collation?: ModelFieldCollation;
     /** How the records in the index should be ordered. */
     order?: 'ASC' | 'DESC';
 } & ({
     /** The field slug for which the index should be created. */
-    slug: T[number]['slug'];
+    slug: keyof T;
 } | {
     /** The field expression for which the index should be created. */
     expression: string;
 });
-type ModelIndex<T extends Array<ModelField> = Array<ModelField>> = {
+type ModelIndex<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
     /**
      * The list of fields in the model for which the index should be created.
      */
@@ -281,7 +281,7 @@ type ModelIndex<T extends Array<ModelField> = Array<ModelField>> = {
     /**
      * The identifier of the index.
      */
-    slug?: string;
+    slug: string;
     /**
      * Whether only one record with a unique value for the provided fields will be allowed.
      */
@@ -292,18 +292,16 @@ type ModelIndex<T extends Array<ModelField> = Array<ModelField>> = {
      */
     filter?: WithInstruction;
 };
-type ModelTriggerField<T extends Array<ModelField> = Array<ModelField>> = {
+type ModelTriggerField<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
     /**
      * The slug of the field that should cause the trigger to fire if the value of the
      * field has changed.
      */
-    slug: T[number]['slug'];
+    slug: keyof T;
 };
-type ModelTrigger<T extends Array<ModelField> = Array<ModelField>> = {
-    /**
-     * The identifier of the trigger.
-     */
-    slug?: string;
+type ModelTrigger<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
+    /** The identifier of the trigger. */
+    slug: string;
     /** The type of query for which the trigger should fire. */
     action: 'INSERT' | 'UPDATE' | 'DELETE';
     /** When the trigger should fire in the case that a matching query is executed. */
@@ -324,15 +322,18 @@ type ModelPreset = {
     /** The query instructions that should be applied when the preset is used. */
     instructions: GetInstructions;
 };
-interface Model<T extends Array<ModelField> = Array<ModelField>> {
+type ModelEntityList<T extends {
+    slug: string;
+}> = Record<NonNullable<T['slug']>, Partial<T>>;
+interface Model<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> {
     id: string;
     name: string;
     pluralName: string;
     slug: string;
     pluralSlug: string;
     identifiers: {
-        name: T[number]['slug'];
-        slug: T[number]['slug'];
+        name: keyof T;
+        slug: keyof T;
     };
     idPrefix: string;
     /** The name of the table in SQLite. */
@@ -357,11 +358,11 @@ interface Model<T extends Array<ModelField> = Array<ModelField>> {
         associationSlug?: string;
     };
     fields: T;
-    indexes?: Array<ModelIndex<T>>;
-    triggers?: Array<ModelTrigger<T>>;
-    presets?: Array<ModelPreset>;
+    indexes?: ModelEntityList<ModelIndex<T>>;
+    triggers?: ModelEntityList<ModelTrigger<T>>;
+    presets?: ModelEntityList<ModelPreset>;
 }
-type PublicModel<T extends Array<ModelField> = Array<ModelField>> = Omit<Partial<Model<T>>, 'slug' | 'identifiers' | 'system' | 'tableAlias'> & {
+type PublicModel<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = Omit<Partial<Model<T>>, 'slug' | 'identifiers' | 'system' | 'tableAlias'> & {
     slug: Required<Model['slug']>;
     identifiers?: Partial<Model['identifiers']>;
 };
@@ -404,6 +405,10 @@ interface TransactionOptions {
      * separating them out into a dedicated `params` array.
      */
     inlineParams?: boolean;
+    /**
+     * Whether to compute default field values as part of the generated statement.
+     */
+    inlineDefaults?: boolean;
 }
 declare class Transaction {
     #private;

package/dist/index.js

@@ -23,6 +23,12 @@ var RAW_FIELD_TYPES = ["string", "number", "boolean"];
 var CURRENT_TIME_EXPRESSION = {
   [QUERY_SYMBOLS.EXPRESSION]: `strftime('%Y-%m-%dT%H:%M:%f', 'now') || 'Z'`
 };
+var ID_EXPRESSION = (idPrefix) => ({
+  // Since default values in SQLite cannot rely on other columns, we unfortunately
+  // cannot rely on the `idPrefix` column here. Instead, we need to inject it directly
+  // into the expression as a static string.
+  [QUERY_SYMBOLS.EXPRESSION]: `'${idPrefix}_' || lower(substr(hex(randomblob(12)), 1, 16))`
+});
 var MOUNTING_PATH_SUFFIX = /(.*?)(\{(\d+)\})?$/;
 var composeMountingPath = (single, key, mountingPath) => {
   if (key === "ronin_root") {
@@ -257,7 +263,9 @@ var handleBeforeOrAfter = (model, statementParams, queryType, instructions) => {
 };
 
 // src/instructions/including.ts
-var handleIncluding = (models, model, statementParams, single, instruction, options = {}) => {
+var handleIncluding = (models, model, statementParams, single, instruction, options = {
+  inlineDefaults: false
+}) => {
   let statement = "";
   let tableSubQuery;
   for (const ephemeralFieldSlug in instruction) {
@@ -293,7 +301,7 @@ var handleIncluding = (models, model, statementParams, single, instruction, opti
         },
         models,
         statementParams,
-        { parentModel: model }
+        { parentModel: model, inlineDefaults: options.inlineDefaults }
       );
       relatedTableSelector = `(${subSelect.main.statement})`;
     }
@@ -322,7 +330,7 @@ var handleIncluding = (models, model, statementParams, single, instruction, opti
         statementParams,
         subSingle,
         modifiableQueryInstructions.including,
-        { mountingPath: subMountingPath }
+        { mountingPath: subMountingPath, inlineDefaults: options.inlineDefaults }
       );
       statement += ` ${subIncluding.statement}`;
     }
@@ -367,7 +375,7 @@ var handleOrderedBy = (model, instruction) => {
 };
 
 // src/instructions/selecting.ts
-var handleSelecting = (models, model, statementParams, single, instructions, options = {}) => {
+var handleSelecting = (models, model, statementParams, single, instructions, options = { inlineDefaults: false }) => {
   let isJoining = false;
   const selectedFields = filterSelectedFields(
     model,
@@ -395,7 +403,8 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
         const subQueryModel = getModelBySlug(models, queryModel);
         if (queryType === "count") {
           const subSelect = compileQueryInput(symbol2.value, models, statementParams, {
-            parentModel: { ...model, tableAlias: model.table }
+            parentModel: { ...model, tableAlias: model.table },
+            inlineDefaults: options.inlineDefaults
           });
           selectedFields.push({
             slug: key,
@@ -457,16 +466,23 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
 };
 
 // src/instructions/to.ts
-var handleTo = (models, model, statementParams, queryType, dependencyStatements, instructions, parentModel) => {
+var handleTo = (models, model, statementParams, queryType, dependencyStatements, instructions, options) => {
   const { with: withInstruction, to: toInstruction } = instructions;
   const defaultFields = {};
-  if (queryType === "set" || toInstruction.ronin) {
-    defaultFields.ronin = {
+  const inlineDefaultInsertionFields = queryType === "add" && options?.inlineDefaults;
+  if (inlineDefaultInsertionFields) {
+    defaultFields.id = toInstruction.id || ID_EXPRESSION(model.idPrefix);
+  }
+  if (queryType === "add" || queryType === "set" || toInstruction.ronin) {
+    const defaults = {
+      // If records are being created, set their creation time.
+      ...inlineDefaultInsertionFields ? { createdAt: CURRENT_TIME_EXPRESSION } : {},
       // If records are being updated, bump their update time.
-      ...queryType === "set" ? { updatedAt: CURRENT_TIME_EXPRESSION } : {},
+      ...queryType === "set" || inlineDefaultInsertionFields ? { updatedAt: CURRENT_TIME_EXPRESSION } : {},
       // Allow for overwriting the default values provided above.
       ...toInstruction.ronin
     };
+    if (Object.keys(defaults).length > 0) defaultFields.ronin = defaults;
   }
   const symbol = getQuerySymbol(toInstruction);
   if (symbol?.type === "query") {
@@ -492,7 +508,10 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
       });
       statement2 = `(${columns.join(", ")}) `;
     }
-    statement2 += compileQueryInput(symbol.value, models, statementParams).main.statement;
+    statement2 += compileQueryInput(symbol.value, models, statementParams, {
+      // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
+      inlineDefaults: options?.inlineDefaults || false
+    }).main.statement;
     return statement2;
   }
   Object.assign(toInstruction, defaultFields);
@@ -520,7 +539,8 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
           },
           models,
           [],
-          { returning: false }
+          // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
+          { returning: false, inlineDefaults: options?.inlineDefaults || false }
         ).main;
         dependencyStatements.push({ ...query, after: true });
       };
@@ -541,7 +561,7 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
     }
   }
   let statement = composeConditions(models, model, statementParams, "to", toInstruction, {
-    parentModel,
+    parentModel: options?.parentModel,
     type: queryType === "add" ? "fields" : void 0
   });
   if (queryType === "add") {
@@ -552,7 +572,7 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
       "to",
       toInstruction,
       {
-        parentModel,
+        parentModel: options?.parentModel,
         type: "values"
       }
     );
@@ -567,22 +587,24 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
 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) {
+    for (const [fieldSlug, field] of Object.entries(model.fields)) {
       if (field.type !== "link" || field.kind === "many") continue;
-      normalizedUsing[field.slug] = null;
+      normalizedUsing[fieldSlug] = null;
     }
   }
   for (const presetSlug in normalizedUsing) {
     if (!Object.hasOwn(normalizedUsing, presetSlug) || presetSlug === "links") continue;
     const arg = normalizedUsing[presetSlug];
-    const preset = model.presets?.find((preset2) => preset2.slug === presetSlug);
+    const preset = model.presets?.[presetSlug];
     if (!preset) {
       throw new RoninError({
         message: `Preset "${presetSlug}" does not exist in model "${model.name}".`,
         code: "PRESET_NOT_FOUND"
       });
     }
-    const replacedUsingFilter = structuredClone(preset.instructions);
+    const replacedUsingFilter = structuredClone(
+      preset.instructions
+    );
     if (arg !== null) {
       findInObject(
         replacedUsingFilter,
@@ -625,7 +647,11 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     models,
     dependencyStatements,
     statementParams,
-    defaultQuery
+    defaultQuery,
+    {
+      // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
+      inlineDefaults: options?.inlineDefaults || false
+    }
   );
   if (query === null)
     return { dependencies: [], main: dependencyStatements[0], selectedFields: [] };
@@ -655,7 +681,9 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     {
       selecting: instructions?.selecting,
       including: instructions?.including
-    }
+    },
+    // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
+    { inlineDefaults: options?.inlineDefaults || false }
   );
   let statement = "";
   switch (queryType) {
@@ -709,7 +737,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
       queryType,
       dependencyStatements,
       { with: instructions.with, to: instructionValue },
-      options?.parentModel
+      options
     );
     statement += `${toStatement} `;
   }
@@ -801,13 +829,16 @@ var matchSelectedFields = (fields, pattern) => {
   return fields.filter((field) => regex2.test(field.slug));
 };
 var filterSelectedFields = (model, instruction) => {
-  if (!instruction) return model.fields;
+  const mappedFields = Object.entries(model.fields).map(
+    ([fieldSlug, field]) => ({ slug: fieldSlug, ...field })
+  );
+  if (!instruction) return mappedFields;
   let selectedFields = [];
   for (const pattern of instruction) {
     const isNegative = pattern.startsWith("!");
     const cleanPattern = isNegative ? pattern.slice(1) : pattern;
     const matchedFields = matchSelectedFields(
-      isNegative ? selectedFields : model.fields,
+      isNegative ? selectedFields : mappedFields,
       cleanPattern
     );
     if (isNegative) {
@@ -896,7 +927,7 @@ var composeConditions = (models, model, statementParams, instructionName, value,
     return conditions.join(" AND ");
   }
   if (options.fieldSlug) {
-    const childField = model.fields.some(({ slug }) => {
+    const childField = Object.keys(model.fields).some((slug) => {
       return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
     });
     if (!childField) {
@@ -1256,19 +1287,19 @@ var addDefaultModelAttributes = (model, isNew) => {
     copiedModel[setting] = generator(copiedModel[base]);
   }
   const newFields = copiedModel.fields || [];
-  if (isNew || newFields.length > 0) {
+  if (isNew || Object.keys(newFields).length > 0) {
     if (!copiedModel.identifiers) copiedModel.identifiers = {};
     if (!copiedModel.identifiers.name) {
-      const suitableField = newFields.find(
-        (field) => field.type === "string" && field.required === true && ["name"].includes(field.slug)
+      const suitableField = Object.entries(newFields).find(
+        ([fieldSlug, field]) => field.type === "string" && field.required === true && ["name"].includes(fieldSlug)
       );
-      copiedModel.identifiers.name = suitableField?.slug || "id";
+      copiedModel.identifiers.name = suitableField?.[0] || "id";
     }
     if (!copiedModel.identifiers.slug) {
-      const suitableField = newFields.find(
-        (field) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(field.slug)
+      const suitableField = Object.entries(newFields).find(
+        ([fieldSlug, field]) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(fieldSlug)
       );
-      copiedModel.identifiers.slug = suitableField?.slug || "id";
+      copiedModel.identifiers.slug = suitableField?.[0] || "id";
     }
   }
   return copiedModel;
@@ -1276,29 +1307,32 @@ var addDefaultModelAttributes = (model, isNew) => {
 var addDefaultModelFields = (model, isNew) => {
   const copiedModel = { ...model };
   const existingFields = copiedModel.fields || [];
-  if (isNew || existingFields.length > 0) {
-    const additionalFields = getSystemFields(copiedModel.idPrefix).filter((newField) => {
-      return !existingFields.some(({ slug }) => slug === newField.slug);
-    });
-    copiedModel.fields = [...additionalFields, ...existingFields];
+  if (isNew || Object.keys(existingFields).length > 0) {
+    const additionalFields = Object.fromEntries(
+      Object.entries(getSystemFields(copiedModel.idPrefix)).filter(([newFieldSlug]) => {
+        return !Object.hasOwn(existingFields, newFieldSlug);
+      })
+    );
+    copiedModel.fields = { ...additionalFields, ...existingFields };
   }
   return copiedModel;
 };
 var addDefaultModelPresets = (list, model) => {
-  const defaultPresets = [];
-  for (const field of model.fields || []) {
-    if (field.type === "link" && !field.slug.startsWith("ronin.")) {
+  const defaultPresets = {};
+  for (const [fieldSlug, rest] of Object.entries(model.fields || {})) {
+    const field = { slug: fieldSlug, ...rest };
+    if (field.type === "link" && !fieldSlug.startsWith("ronin.")) {
       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 = {
+        const preset2 = {
           instructions: {
             // Perform a LEFT JOIN that adds the associative table.
             including: {
-              [field.slug]: {
+              [fieldSlug]: {
                 [QUERY_SYMBOLS.QUERY]: {
                   get: {
                     [systemModel.pluralSlug]: {
@@ -1329,16 +1363,15 @@ var addDefaultModelPresets = (list, model) => {
                 }
               }
             }
-          },
-          slug: field.slug
+          }
         };
-        defaultPresets.push(preset);
+        defaultPresets[fieldSlug] = preset2;
         continue;
       }
-      defaultPresets.push({
+      const preset = {
         instructions: {
           including: {
-            [field.slug]: {
+            [fieldSlug]: {
               [QUERY_SYMBOLS.QUERY]: {
                 get: {
                   [targetModel.slug]: {
@@ -1354,24 +1387,24 @@ var addDefaultModelPresets = (list, model) => {
               }
             }
           }
-        },
-        slug: field.slug
-      });
+        }
+      };
+      defaultPresets[fieldSlug] = preset;
     }
   }
   const childModels = list.map((subModel) => {
     if (subModel.system?.associationSlug) return null;
-    const field = subModel.fields?.find((field2) => {
+    const field = Object.entries(subModel.fields).find(([_, field2]) => {
       return field2.type === "link" && field2.target === model.slug;
     });
     if (!field) return null;
-    return { model: subModel, field };
+    return { model: subModel, field: { slug: field[0], ...field[1] } };
   }).filter((match) => match !== null);
   for (const childMatch of childModels) {
     const { model: childModel, field: childField } = childMatch;
     const pluralSlug = childModel.pluralSlug;
     const presetSlug = childModel.system?.associationSlug || pluralSlug;
-    defaultPresets.push({
+    const preset = {
       instructions: {
         including: {
           [presetSlug]: {
@@ -1388,16 +1421,18 @@ var addDefaultModelPresets = (list, model) => {
             }
           }
         }
-      },
-      slug: presetSlug
-    });
+      }
+    };
+    defaultPresets[presetSlug] = preset;
   }
-  if (defaultPresets.length > 0) {
-    const existingPresets = model.presets || [];
-    const additionalPresets = defaultPresets.filter((newPreset) => {
-      return !existingPresets.some(({ slug }) => slug === newPreset.slug);
-    });
-    model.presets = [...additionalPresets, ...existingPresets];
+  if (Object.keys(defaultPresets).length > 0) {
+    const existingPresets = model.presets;
+    const additionalPresets = Object.fromEntries(
+      Object.entries(defaultPresets).filter(([newPresetSlug]) => {
+        return !existingPresets?.[newPresetSlug];
+      })
+    );
+    model.presets = { ...additionalPresets, ...existingPresets };
   }
   return model;
 };
@@ -1429,7 +1464,12 @@ function getFieldFromModel(model, fieldPath, source, shouldThrow = true) {
   const writingField = "instructionName" in source ? source.instructionName === "to" : true;
   const errorTarget = "instructionName" in source ? `\`${source.instructionName}\`` : `${source.modelEntityType} "${source.modelEntityName}"`;
   const errorPrefix = `Field "${fieldPath}" defined for ${errorTarget}`;
-  const modelFields = model.fields || [];
+  const modelFields = Object.entries(model.fields).map(
+    ([fieldSlug, field]) => ({
+      slug: fieldSlug,
+      ...field
+    })
+  );
   let modelField;
   if (fieldPath.includes(".")) {
     modelField = modelFields.find((field) => field.slug === fieldPath.split(".")[0]);
@@ -1453,41 +1493,36 @@ function getFieldFromModel(model, fieldPath, source, shouldThrow = true) {
   const fieldSelector = getFieldSelector(model, modelField, fieldPath, writingField);
   return { field: modelField, fieldSelector };
 }
-var getSystemFields = (idPrefix) => [
-  {
+var getSystemFields = (idPrefix) => ({
+  id: {
     name: "ID",
     type: "string",
     slug: "id",
-    defaultValue: {
-      // Since default values in SQLite cannot rely on other columns, we unfortunately
-      // cannot rely on the `idPrefix` column here. Instead, we need to inject it directly
-      // into the expression as a static string.
-      [QUERY_SYMBOLS.EXPRESSION]: `'${idPrefix}_' || lower(substr(hex(randomblob(12)), 1, 16))`
-    }
+    defaultValue: ID_EXPRESSION(idPrefix)
   },
-  {
+  "ronin.createdAt": {
     name: "RONIN - Created At",
     type: "date",
     slug: "ronin.createdAt",
     defaultValue: CURRENT_TIME_EXPRESSION
   },
-  {
+  "ronin.createdBy": {
     name: "RONIN - Created By",
     type: "string",
     slug: "ronin.createdBy"
   },
-  {
+  "ronin.updatedAt": {
     name: "RONIN - Updated At",
     type: "date",
     slug: "ronin.updatedAt",
     defaultValue: CURRENT_TIME_EXPRESSION
   },
-  {
+  "ronin.updatedBy": {
     name: "RONIN - Updated By",
     type: "string",
     slug: "ronin.updatedBy"
   }
-];
+});
 var ROOT_MODEL = {
   slug: "model",
   identifiers: {
@@ -1498,43 +1533,43 @@ var ROOT_MODEL = {
   table: "ronin_schema",
   // Indicates that the model was automatically generated by RONIN.
   system: { model: "root" },
-  fields: [
-    { slug: "name", type: "string" },
-    { slug: "pluralName", type: "string" },
-    { slug: "slug", type: "string" },
-    { slug: "pluralSlug", type: "string" },
-    { slug: "idPrefix", type: "string" },
-    { slug: "table", type: "string" },
-    { slug: "identifiers.name", type: "string" },
-    { slug: "identifiers.slug", type: "string" },
+  fields: {
+    name: { type: "string" },
+    pluralName: { type: "string" },
+    slug: { type: "string" },
+    pluralSlug: { type: "string" },
+    idPrefix: { type: "string" },
+    table: { type: "string" },
+    "identifiers.name": { type: "string" },
+    "identifiers.slug": { type: "string" },
     // Providing an empty object as a default value allows us to use `json_insert`
     // without needing to fall back to an empty object in the insertion statement,
     // which makes the statement shorter.
-    { slug: "fields", type: "json", defaultValue: "{}" },
-    { slug: "indexes", type: "json", defaultValue: "{}" },
-    { slug: "triggers", type: "json", defaultValue: "{}" },
-    { slug: "presets", type: "json", defaultValue: "{}" }
-  ]
+    fields: { type: "json", defaultValue: "{}" },
+    indexes: { type: "json", defaultValue: "{}" },
+    triggers: { type: "json", defaultValue: "{}" },
+    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 || []) {
-    if (field.type === "link" && !field.slug.startsWith("ronin.")) {
+  for (const [fieldSlug, rest] of Object.entries(model.fields || {})) {
+    const field = { slug: fieldSlug, ...rest };
+    if (field.type === "link" && !fieldSlug.startsWith("ronin.")) {
       const relatedModel = getModelBySlug(models, field.target);
-      let fieldSlug = relatedModel.slug;
+      let fieldSlug2 = relatedModel.slug;
       if (field.kind === "many") {
-        fieldSlug = composeAssociationModelSlug(model, field);
+        fieldSlug2 = composeAssociationModelSlug(model, field);
         addedModels.push({
-          pluralSlug: fieldSlug,
-          slug: fieldSlug,
+          pluralSlug: fieldSlug2,
+          slug: fieldSlug2,
           system: {
             model: model.id,
             associationSlug: field.slug
           },
-          fields: [
-            {
-              slug: "source",
+          fields: {
+            source: {
               type: "link",
               target: model.slug,
               actions: {
@@ -1542,8 +1577,7 @@ var getSystemModels = (models, model) => {
                 onUpdate: "CASCADE"
               }
             },
-            {
-              slug: "target",
+            target: {
               type: "link",
               target: relatedModel.slug,
               actions: {
@@ -1551,7 +1585,7 @@ var getSystemModels = (models, model) => {
                 onUpdate: "CASCADE"
               }
             }
-          ]
+          }
         });
       }
     }
@@ -1615,14 +1649,7 @@ var PLURAL_MODEL_ENTITIES = {
   preset: "presets"
 };
 var PLURAL_MODEL_ENTITIES_VALUES = Object.values(PLURAL_MODEL_ENTITIES);
-var formatModelEntity = (type, entities) => {
-  const entries = entities?.map((entity) => {
-    const { slug, ...rest } = "slug" in entity ? entity : { slug: `${type}Slug`, ...entity };
-    return [slug, rest];
-  });
-  return entries ? Object.fromEntries(entries) : void 0;
-};
-var handleSystemModel = (models, dependencyStatements, action, systemModel, newModel) => {
+var handleSystemModel = (models, dependencyStatements, action, inlineDefaults, systemModel, newModel) => {
   const { system: _, ...systemModelClean } = systemModel;
   const query = {
     [action]: { model: action === "create" ? systemModelClean : systemModelClean.slug }
@@ -1631,10 +1658,10 @@ var handleSystemModel = (models, dependencyStatements, action, systemModel, newM
     const { system: _2, ...newModelClean } = newModel;
     query.alter.to = newModelClean;
   }
-  const statement = compileQueryInput(query, models, []);
+  const statement = compileQueryInput(query, models, [], { inlineDefaults });
   dependencyStatements.push(...statement.dependencies);
 };
-var handleSystemModels = (models, dependencyStatements, previousModel, newModel) => {
+var handleSystemModels = (models, dependencyStatements, previousModel, newModel, inlineDefaults) => {
   const currentSystemModels = models.filter(({ system }) => {
     return system?.model === newModel.id;
   });
@@ -1644,11 +1671,11 @@ var handleSystemModels = (models, dependencyStatements, previousModel, newModel)
       oldSystemModel.system?.model === newSystemModel.system?.model
     ];
     if (oldSystemModel.system?.associationSlug) {
-      const oldFieldIndex = previousModel.fields.findIndex((item) => {
-        return item.slug === newSystemModel.system?.associationSlug;
+      const oldFieldIndex = Object.keys(previousModel.fields).findIndex((slug) => {
+        return slug === newSystemModel.system?.associationSlug;
       });
-      const newFieldIndex = newModel.fields.findIndex((item) => {
-        return item.slug === oldSystemModel.system?.associationSlug;
+      const newFieldIndex = Object.keys(newModel.fields).findIndex((slug) => {
+        return slug === oldSystemModel.system?.associationSlug;
       });
       conditions.push(oldFieldIndex === newFieldIndex);
     }
@@ -1658,19 +1685,32 @@ var handleSystemModels = (models, dependencyStatements, previousModel, newModel)
     const exists = newSystemModels.find(matchSystemModels.bind(null, systemModel));
     if (exists) {
       if (exists.slug !== systemModel.slug) {
-        handleSystemModel(models, dependencyStatements, "alter", systemModel, exists);
+        handleSystemModel(
+          models,
+          dependencyStatements,
+          "alter",
+          inlineDefaults,
+          systemModel,
+          exists
+        );
       }
       continue;
     }
-    handleSystemModel(models, dependencyStatements, "drop", systemModel);
+    handleSystemModel(models, dependencyStatements, "drop", inlineDefaults, systemModel);
   }
   for (const systemModel of newSystemModels) {
     const exists = currentSystemModels.find(matchSystemModels.bind(null, systemModel));
     if (exists) continue;
-    handleSystemModel(models, dependencyStatements, "create", systemModel);
+    handleSystemModel(
+      models,
+      dependencyStatements,
+      "create",
+      inlineDefaults,
+      systemModel
+    );
   }
 };
-var transformMetaQuery = (models, dependencyStatements, statementParams, query) => {
+var transformMetaQuery = (models, dependencyStatements, statementParams, query, options) => {
   const { queryType } = splitQuery(query);
   const subAltering = "alter" in query && query.alter && !("to" in query.alter);
   const action = subAltering && query.alter ? Object.keys(query.alter).filter((key) => key !== "model")[0] : queryType;
@@ -1691,7 +1731,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       slug = query.alter[action][entity];
       if ("create" in query.alter) {
         const item = query.alter.create[entity];
-        slug = item.slug || `${entity}Slug`;
+        slug = item.slug;
         jsonValue = { slug, ...item };
       }
       if ("alter" in query.alter && query.alter.alter) jsonValue = query.alter.alter.to;
@@ -1709,20 +1749,24 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         [...models, modelWithFields],
         modelWithFields
       );
-      modelWithPresets.fields = modelWithPresets.fields.map((field2) => ({
-        ...field2,
-        // Default field type.
-        type: field2.type || "string",
-        // Default field name.
-        name: field2.name || slugToName(field2.slug)
-      }));
-      const columns = modelWithPresets.fields.map((field2) => getFieldStatement(models, modelWithPresets, field2)).filter(Boolean);
-      const entities = Object.fromEntries(
-        Object.entries(PLURAL_MODEL_ENTITIES).map(([type, pluralType2]) => {
-          const list = modelWithPresets[pluralType2];
-          return [pluralType2, formatModelEntity(type, list)];
-        })
+      modelWithPresets.fields = Object.fromEntries(
+        Object.entries(modelWithPresets.fields).map(([fieldSlug, rest]) => [
+          fieldSlug,
+          {
+            ...rest,
+            // Default field type.
+            type: rest.type || "string",
+            // Default field name.
+            name: rest.name || slugToName(fieldSlug)
+          }
+        ])
       );
+      const columns = Object.entries(modelWithPresets.fields).map(
+        ([fieldSlug, rest]) => getFieldStatement(models, modelWithPresets, {
+          slug: fieldSlug,
+          ...rest
+        })
+      ).filter(Boolean);
       models.push(modelWithPresets);
       dependencyStatements.push({
         statement: `CREATE TABLE "${modelWithPresets.table}" (${columns.join(", ")})`,
@@ -1732,28 +1776,35 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         ["index", "indexes"],
         ["trigger", "triggers"]
       ]) {
-        const entityValue = modelWithPresets[pluralModelEntity];
-        if (!entityValue) continue;
-        for (const item of entityValue) {
+        const entityList = modelWithPresets[pluralModelEntity];
+        if (!entityList) continue;
+        for (const [itemSlug, item] of Object.entries(entityList)) {
           const query2 = {
             alter: {
               model: modelWithPresets.slug,
               create: {
-                [modelEntity]: item
+                [modelEntity]: { slug: itemSlug, ...item }
               }
             }
           };
-          transformMetaQuery(models, dependencyStatements, null, query2);
+          const tempModels = [
+            ...models.filter((model2) => model2.slug !== modelWithPresets.slug),
+            { slug: modelWithPresets.slug, fields: modelWithPresets.fields }
+          ];
+          transformMetaQuery(tempModels, dependencyStatements, null, query2, {
+            inlineDefaults: options.inlineDefaults
+          });
         }
       }
-      const modelWithObjects = Object.assign({}, modelWithPresets);
-      for (const entity2 in entities) {
-        if (!Object.hasOwn(entities, entity2)) continue;
-        Object.defineProperty(modelWithObjects, entity2, { value: entities[entity2] });
-      }
-      queryTypeDetails = { with: modelWithObjects };
+      queryTypeDetails = { with: modelWithPresets };
       getSystemModels(models, modelWithPresets).map((systemModel) => {
-        return handleSystemModel(models, dependencyStatements, "create", systemModel);
+        return handleSystemModel(
+          models,
+          dependencyStatements,
+          "create",
+          options.inlineDefaults,
+          systemModel
+        );
       });
     }
     if (action === "alter" && model) {
@@ -1776,14 +1827,26 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         },
         to: modelWithPresets
       };
-      handleSystemModels(models, dependencyStatements, modelBeforeUpdate2, model);
+      handleSystemModels(
+        models,
+        dependencyStatements,
+        modelBeforeUpdate2,
+        model,
+        options.inlineDefaults
+      );
     }
     if (action === "drop" && model) {
       models.splice(models.indexOf(model), 1);
       dependencyStatements.push({ statement: `DROP TABLE "${model.table}"`, params: [] });
       queryTypeDetails = { with: { slug } };
       models.filter(({ system }) => system?.model === model.id).map((systemModel) => {
-        return handleSystemModel(models, dependencyStatements, "drop", systemModel);
+        return handleSystemModel(
+          models,
+          dependencyStatements,
+          "drop",
+          options.inlineDefaults,
+          systemModel
+        );
       });
     }
     const modelSlug2 = "to" in queryTypeDetails ? queryTypeDetails?.to?.slug : "with" in queryTypeDetails ? queryTypeDetails?.with?.slug : void 0;
@@ -1798,16 +1861,13 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
   const modelBeforeUpdate = structuredClone(model);
   const existingModel = model;
   const pluralType = PLURAL_MODEL_ENTITIES[entity];
-  const targetEntityIndex = existingModel[pluralType]?.findIndex(
-    (entity2) => entity2.slug === slug
-  );
-  if ((action === "alter" || action === "drop") && (typeof targetEntityIndex === "undefined" || targetEntityIndex === -1)) {
+  const existingEntity = existingModel[pluralType]?.[slug];
+  if ((action === "alter" || action === "drop") && !existingEntity) {
     throw new RoninError({
       message: `No ${entity} with slug "${slug}" defined in model "${existingModel.name}".`,
       code: MODEL_ENTITY_ERROR_CODES[entity]
     });
   }
-  const existingEntity = existingModel[pluralType]?.[targetEntityIndex];
   if (action === "create" && existingEntity) {
     throw new RoninError({
       message: `A ${entity} with the slug "${slug}" already exists.`,
@@ -1844,7 +1904,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       }
     } else if (action === "drop" && !existingLinkField) {
       const systemFields = getSystemFields(existingModel.idPrefix);
-      const isSystemField = systemFields.some((field2) => field2.slug === slug);
+      const isSystemField = slug in systemFields;
       if (isSystemField) {
         throw new RoninError({
           message: `The ${entity} "${slug}" is a system ${entity} and cannot be removed.`,
@@ -1931,7 +1991,8 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       const effectStatements = trigger.effects.map((effectQuery) => {
         return compileQueryInput(effectQuery, models, null, {
           returning: false,
-          parentModel: existingModel
+          parentModel: existingModel,
+          inlineDefaults: options.inlineDefaults
         }).main.statement;
       });
       statementParts.push("BEGIN");
@@ -1947,26 +2008,42 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
     case "create": {
       const value = prepareStatementValue(statementParams, jsonValue);
       json = `json_insert(${field}, '$.${slug}', ${value})`;
-      existingModel[pluralType] = [
-        ...existingModel[pluralType] || [],
-        jsonValue
-      ];
+      if (!existingModel[pluralType]) existingModel[pluralType] = {};
+      existingModel[pluralType][slug] = jsonValue;
       break;
     }
     case "alter": {
-      const value = prepareStatementValue(statementParams, jsonValue);
-      json = `json_set(${field}, '$.${slug}', json_patch(json_extract(${field}, '$.${slug}'), ${value}))`;
-      const targetEntity = existingModel[pluralType];
-      Object.assign(targetEntity[targetEntityIndex], jsonValue);
+      const targetEntities = existingModel[pluralType];
+      if (jsonValue?.slug && jsonValue.slug !== slug) {
+        const { slug: newSlug, ...entityValue } = jsonValue;
+        Object.defineProperty(
+          targetEntities,
+          newSlug,
+          Object.getOwnPropertyDescriptor(targetEntities, slug)
+        );
+        delete targetEntities[slug];
+        const value = prepareStatementValue(statementParams, entityValue);
+        json = `json_insert(json_remove(${field}, '$.${slug}'), '$.${newSlug}', ${value})`;
+      } else {
+        Object.assign(targetEntities[slug], jsonValue);
+        const value = prepareStatementValue(statementParams, jsonValue);
+        json = `json_set(${field}, '$.${slug}', json_patch(json_extract(${field}, '$.${slug}'), ${value}))`;
+      }
       break;
     }
     case "drop": {
       json = `json_remove(${field}, '$.${slug}')`;
-      const targetEntity = existingModel[pluralType];
-      targetEntity.splice(targetEntityIndex, 1);
+      const targetEntities = existingModel[pluralType];
+      delete targetEntities[slug];
     }
   }
-  handleSystemModels(models, dependencyStatements, modelBeforeUpdate, existingModel);
+  handleSystemModels(
+    models,
+    dependencyStatements,
+    modelBeforeUpdate,
+    existingModel,
+    options.inlineDefaults
+  );
   return {
     set: {
       model: {
@@ -2029,7 +2106,9 @@ var Transaction = class {
       const { dependencies, main, selectedFields } = compileQueryInput(
         query,
         modelsWithPresets,
-        options?.inlineParams ? null : []
+        options?.inlineParams ? null : [],
+        // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
+        { inlineDefaults: options?.inlineDefaults || false }
       );
       const preDependencies = dependencies.filter(({ after }) => !after);
       const postDependencies = dependencies.map(({ after, ...rest }) => after ? rest : null).filter((item) => item != null);
@@ -2047,7 +2126,7 @@ var Transaction = class {
     this.models = modelsWithPresets;
     return statements;
   };
-  #formatRows(fields, rows, single, isMeta) {
+  #formatRows(fields, rows, single) {
     const records = [];
     for (const row of rows) {
       const record = fields.reduce((acc, field, fieldIndex) => {
@@ -2060,11 +2139,6 @@ var Transaction = class {
             newValue = Boolean(newValue);
           }
         }
-        if (isMeta && PLURAL_MODEL_ENTITIES_VALUES.includes(newSlug)) {
-          newValue = newValue ? Object.entries(newValue).map(([slug, attributes]) => {
-            return { slug, ...attributes };
-          }) : [];
-        }
         const { parentField, parentIsArray } = (() => {
           const lastDotIndex = newSlug.lastIndexOf(".");
           if (lastDotIndex === -1) return { parentField: null };
@@ -2158,9 +2232,8 @@ var Transaction = class {
         };
         const { queryType, queryModel, queryInstructions } = splitQuery(query);
         const model = getModelBySlug(this.models, queryModel);
-        const isMeta = queryModel === "model" || queryModel === "models";
         const modelFields = Object.fromEntries(
-          model.fields.map((field) => [field.slug, field.type])
+          Object.entries(model.fields).map(([slug, rest]) => [slug, rest.type])
         );
         if (queryType === "count") {
           return addResult({ amount: rows[0][0] });
@@ -2168,13 +2241,13 @@ var Transaction = class {
         const single = queryModel !== model.pluralSlug;
         if (single) {
           return addResult({
-            record: rows[0] ? this.#formatRows(selectedFields, rows, true, isMeta) : null,
+            record: rows[0] ? this.#formatRows(selectedFields, rows, true) : null,
             modelFields
           });
         }
         const pageSize = queryInstructions?.limitedTo;
         const result = {
-          records: this.#formatRows(selectedFields, rows, false, isMeta),
+          records: this.#formatRows(selectedFields, rows, false),
           modelFields
         };
         if (pageSize && result.records.length > 0) {

package/package.json

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