@ronin/compiler 0.17.0-leo-ron-1099-experimental-376 → 0.17.0

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 ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
+type ModelIndexField<T extends Array<ModelField> = Array<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: keyof T;
+    slug: T[number]['slug'];
 } | {
     /** The field expression for which the index should be created. */
     expression: string;
 });
-type ModelIndex<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
+type ModelIndex<T extends Array<ModelField> = Array<ModelField>> = {
     /**
      * The list of fields in the model for which the index should be created.
      */
@@ -281,7 +281,7 @@ type ModelIndex<T extends ModelEntityList<ModelField> = ModelEntityList<ModelFie
     /**
      * 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,16 +292,18 @@ type ModelIndex<T extends ModelEntityList<ModelField> = ModelEntityList<ModelFie
      */
     filter?: WithInstruction;
 };
-type ModelTriggerField<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
+type ModelTriggerField<T extends Array<ModelField> = Array<ModelField>> = {
     /**
      * The slug of the field that should cause the trigger to fire if the value of the
      * field has changed.
      */
-    slug: keyof T;
+    slug: T[number]['slug'];
 };
-type ModelTrigger<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = {
-    /** The identifier of the trigger. */
-    slug: string;
+type ModelTrigger<T extends Array<ModelField> = Array<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. */
@@ -322,18 +324,15 @@ type ModelPreset = {
     /** The query instructions that should be applied when the preset is used. */
     instructions: GetInstructions;
 };
-type ModelEntityList<T extends {
-    slug: string;
-}> = Record<NonNullable<T['slug']>, Partial<T>>;
-interface Model<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> {
+interface Model<T extends Array<ModelField> = Array<ModelField>> {
     id: string;
     name: string;
     pluralName: string;
     slug: string;
     pluralSlug: string;
     identifiers: {
-        name: keyof T;
-        slug: keyof T;
+        name: T[number]['slug'];
+        slug: T[number]['slug'];
     };
     idPrefix: string;
     /** The name of the table in SQLite. */
@@ -358,11 +357,11 @@ interface Model<T extends ModelEntityList<ModelField> = ModelEntityList<ModelFie
         associationSlug?: string;
     };
     fields: T;
-    indexes?: ModelEntityList<ModelIndex<T>>;
-    triggers?: ModelEntityList<ModelTrigger<T>>;
-    presets?: ModelEntityList<ModelPreset>;
+    indexes?: Array<ModelIndex<T>>;
+    triggers?: Array<ModelTrigger<T>>;
+    presets?: Array<ModelPreset>;
 }
-type PublicModel<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = Omit<Partial<Model<T>>, 'slug' | 'identifiers' | 'system' | 'tableAlias'> & {
+type PublicModel<T extends Array<ModelField> = Array<ModelField>> = Omit<Partial<Model<T>>, 'slug' | 'identifiers' | 'system' | 'tableAlias'> & {
     slug: Required<Model['slug']>;
     identifiers?: Partial<Model['identifiers']>;
 };

package/dist/index.js

@@ -587,24 +587,22 @@ 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 [fieldSlug, field] of Object.entries(model.fields)) {
+    for (const field of model.fields) {
       if (field.type !== "link" || field.kind === "many") continue;
-      normalizedUsing[fieldSlug] = null;
+      normalizedUsing[field.slug] = null;
     }
   }
   for (const presetSlug in normalizedUsing) {
     if (!Object.hasOwn(normalizedUsing, presetSlug) || presetSlug === "links") continue;
     const arg = normalizedUsing[presetSlug];
-    const preset = model.presets?.[presetSlug];
+    const preset = model.presets?.find((preset2) => preset2.slug === 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,
@@ -829,16 +827,13 @@ var matchSelectedFields = (fields, pattern) => {
   return fields.filter((field) => regex2.test(field.slug));
 };
 var filterSelectedFields = (model, instruction) => {
-  const mappedFields = Object.entries(model.fields).map(
-    ([fieldSlug, field]) => ({ slug: fieldSlug, ...field })
-  );
-  if (!instruction) return mappedFields;
+  if (!instruction) return model.fields;
   let selectedFields = [];
   for (const pattern of instruction) {
     const isNegative = pattern.startsWith("!");
     const cleanPattern = isNegative ? pattern.slice(1) : pattern;
     const matchedFields = matchSelectedFields(
-      isNegative ? selectedFields : mappedFields,
+      isNegative ? selectedFields : model.fields,
       cleanPattern
     );
     if (isNegative) {
@@ -927,7 +922,7 @@ var composeConditions = (models, model, statementParams, instructionName, value,
     return conditions.join(" AND ");
   }
   if (options.fieldSlug) {
-    const childField = Object.keys(model.fields).some((slug) => {
+    const childField = model.fields.some(({ slug }) => {
       return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
     });
     if (!childField) {
@@ -1287,19 +1282,19 @@ var addDefaultModelAttributes = (model, isNew) => {
     copiedModel[setting] = generator(copiedModel[base]);
   }
   const newFields = copiedModel.fields || [];
-  if (isNew || Object.keys(newFields).length > 0) {
+  if (isNew || newFields.length > 0) {
     if (!copiedModel.identifiers) copiedModel.identifiers = {};
     if (!copiedModel.identifiers.name) {
-      const suitableField = Object.entries(newFields).find(
-        ([fieldSlug, field]) => field.type === "string" && field.required === true && ["name"].includes(fieldSlug)
+      const suitableField = newFields.find(
+        (field) => field.type === "string" && field.required === true && ["name"].includes(field.slug)
       );
-      copiedModel.identifiers.name = suitableField?.[0] || "id";
+      copiedModel.identifiers.name = suitableField?.slug || "id";
     }
     if (!copiedModel.identifiers.slug) {
-      const suitableField = Object.entries(newFields).find(
-        ([fieldSlug, field]) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(fieldSlug)
+      const suitableField = newFields.find(
+        (field) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(field.slug)
       );
-      copiedModel.identifiers.slug = suitableField?.[0] || "id";
+      copiedModel.identifiers.slug = suitableField?.slug || "id";
     }
   }
   return copiedModel;
@@ -1307,32 +1302,29 @@ var addDefaultModelAttributes = (model, isNew) => {
 var addDefaultModelFields = (model, isNew) => {
   const copiedModel = { ...model };
   const existingFields = copiedModel.fields || [];
-  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 };
+  if (isNew || existingFields.length > 0) {
+    const additionalFields = getSystemFields(copiedModel.idPrefix).filter((newField) => {
+      return !existingFields.some(({ slug }) => slug === newField.slug);
+    });
+    copiedModel.fields = [...additionalFields, ...existingFields];
   }
   return copiedModel;
 };
 var addDefaultModelPresets = (list, model) => {
-  const defaultPresets = {};
-  for (const [fieldSlug, rest] of Object.entries(model.fields || {})) {
-    const field = { slug: fieldSlug, ...rest };
-    if (field.type === "link" && !fieldSlug.startsWith("ronin.")) {
+  const defaultPresets = [];
+  for (const field of model.fields || []) {
+    if (field.type === "link" && !field.slug.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 preset2 = {
+        const preset = {
           instructions: {
             // Perform a LEFT JOIN that adds the associative table.
             including: {
-              [fieldSlug]: {
+              [field.slug]: {
                 [QUERY_SYMBOLS.QUERY]: {
                   get: {
                     [systemModel.pluralSlug]: {
@@ -1363,15 +1355,16 @@ var addDefaultModelPresets = (list, model) => {
                 }
               }
             }
-          }
+          },
+          slug: field.slug
         };
-        defaultPresets[fieldSlug] = preset2;
+        defaultPresets.push(preset);
         continue;
       }
-      const preset = {
+      defaultPresets.push({
         instructions: {
           including: {
-            [fieldSlug]: {
+            [field.slug]: {
               [QUERY_SYMBOLS.QUERY]: {
                 get: {
                   [targetModel.slug]: {
@@ -1387,24 +1380,24 @@ var addDefaultModelPresets = (list, model) => {
               }
             }
           }
-        }
-      };
-      defaultPresets[fieldSlug] = preset;
+        },
+        slug: field.slug
+      });
     }
   }
   const childModels = list.map((subModel) => {
     if (subModel.system?.associationSlug) return null;
-    const field = Object.entries(subModel.fields).find(([_, field2]) => {
+    const field = subModel.fields?.find((field2) => {
       return field2.type === "link" && field2.target === model.slug;
     });
     if (!field) return null;
-    return { model: subModel, field: { slug: field[0], ...field[1] } };
+    return { model: subModel, field };
   }).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;
-    const preset = {
+    defaultPresets.push({
       instructions: {
         including: {
           [presetSlug]: {
@@ -1421,18 +1414,16 @@ var addDefaultModelPresets = (list, model) => {
             }
           }
         }
-      }
-    };
-    defaultPresets[presetSlug] = preset;
+      },
+      slug: presetSlug
+    });
   }
-  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 };
+  if (defaultPresets.length > 0) {
+    const existingPresets = model.presets || [];
+    const additionalPresets = defaultPresets.filter((newPreset) => {
+      return !existingPresets.some(({ slug }) => slug === newPreset.slug);
+    });
+    model.presets = [...additionalPresets, ...existingPresets];
   }
   return model;
 };
@@ -1464,12 +1455,7 @@ 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 = Object.entries(model.fields).map(
-    ([fieldSlug, field]) => ({
-      slug: fieldSlug,
-      ...field
-    })
-  );
+  const modelFields = model.fields || [];
   let modelField;
   if (fieldPath.includes(".")) {
     modelField = modelFields.find((field) => field.slug === fieldPath.split(".")[0]);
@@ -1493,36 +1479,36 @@ function getFieldFromModel(model, fieldPath, source, shouldThrow = true) {
   const fieldSelector = getFieldSelector(model, modelField, fieldPath, writingField);
   return { field: modelField, fieldSelector };
 }
-var getSystemFields = (idPrefix) => ({
-  id: {
+var getSystemFields = (idPrefix) => [
+  {
     name: "ID",
     type: "string",
     slug: "id",
     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: {
@@ -1533,43 +1519,43 @@ var ROOT_MODEL = {
   table: "ronin_schema",
   // Indicates that the model was automatically generated by RONIN.
   system: { model: "root" },
-  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" },
+  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" },
     // 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.
-    fields: { type: "json", defaultValue: "{}" },
-    indexes: { type: "json", defaultValue: "{}" },
-    triggers: { type: "json", defaultValue: "{}" },
-    presets: { type: "json", defaultValue: "{}" }
-  }
+    { slug: "fields", type: "json", defaultValue: "{}" },
+    { slug: "indexes", type: "json", defaultValue: "{}" },
+    { slug: "triggers", type: "json", defaultValue: "{}" },
+    { slug: "presets", type: "json", defaultValue: "{}" }
+  ]
 };
 var ROOT_MODEL_WITH_ATTRIBUTES = addDefaultModelAttributes(ROOT_MODEL, true);
 var getSystemModels = (models, model) => {
   const addedModels = [];
-  for (const [fieldSlug, rest] of Object.entries(model.fields || {})) {
-    const field = { slug: fieldSlug, ...rest };
-    if (field.type === "link" && !fieldSlug.startsWith("ronin.")) {
+  for (const field of model.fields || []) {
+    if (field.type === "link" && !field.slug.startsWith("ronin.")) {
       const relatedModel = getModelBySlug(models, field.target);
-      let fieldSlug2 = relatedModel.slug;
+      let fieldSlug = relatedModel.slug;
       if (field.kind === "many") {
-        fieldSlug2 = composeAssociationModelSlug(model, field);
+        fieldSlug = composeAssociationModelSlug(model, field);
         addedModels.push({
-          pluralSlug: fieldSlug2,
-          slug: fieldSlug2,
+          pluralSlug: fieldSlug,
+          slug: fieldSlug,
           system: {
             model: model.id,
             associationSlug: field.slug
           },
-          fields: {
-            source: {
+          fields: [
+            {
+              slug: "source",
               type: "link",
               target: model.slug,
               actions: {
@@ -1577,7 +1563,8 @@ var getSystemModels = (models, model) => {
                 onUpdate: "CASCADE"
               }
             },
-            target: {
+            {
+              slug: "target",
               type: "link",
               target: relatedModel.slug,
               actions: {
@@ -1585,7 +1572,7 @@ var getSystemModels = (models, model) => {
                 onUpdate: "CASCADE"
               }
             }
-          }
+          ]
         });
       }
     }
@@ -1649,6 +1636,13 @@ 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, inlineDefaults, systemModel, newModel) => {
   const { system: _, ...systemModelClean } = systemModel;
   const query = {
@@ -1671,11 +1665,11 @@ var handleSystemModels = (models, dependencyStatements, previousModel, newModel,
       oldSystemModel.system?.model === newSystemModel.system?.model
     ];
     if (oldSystemModel.system?.associationSlug) {
-      const oldFieldIndex = Object.keys(previousModel.fields).findIndex((slug) => {
-        return slug === newSystemModel.system?.associationSlug;
+      const oldFieldIndex = previousModel.fields.findIndex((item) => {
+        return item.slug === newSystemModel.system?.associationSlug;
       });
-      const newFieldIndex = Object.keys(newModel.fields).findIndex((slug) => {
-        return slug === oldSystemModel.system?.associationSlug;
+      const newFieldIndex = newModel.fields.findIndex((item) => {
+        return item.slug === oldSystemModel.system?.associationSlug;
       });
       conditions.push(oldFieldIndex === newFieldIndex);
     }
@@ -1731,7 +1725,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;
+        slug = item.slug || `${entity}Slug`;
         jsonValue = { slug, ...item };
       }
       if ("alter" in query.alter && query.alter.alter) jsonValue = query.alter.alter.to;
@@ -1749,24 +1743,20 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
         [...models, modelWithFields],
         modelWithFields
       );
-      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
+      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)];
         })
-      ).filter(Boolean);
+      );
       models.push(modelWithPresets);
       dependencyStatements.push({
         statement: `CREATE TABLE "${modelWithPresets.table}" (${columns.join(", ")})`,
@@ -1776,27 +1766,28 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
         ["index", "indexes"],
         ["trigger", "triggers"]
       ]) {
-        const entityList = modelWithPresets[pluralModelEntity];
-        if (!entityList) continue;
-        for (const [itemSlug, item] of Object.entries(entityList)) {
+        const entityValue = modelWithPresets[pluralModelEntity];
+        if (!entityValue) continue;
+        for (const item of entityValue) {
           const query2 = {
             alter: {
               model: modelWithPresets.slug,
               create: {
-                [modelEntity]: { slug: itemSlug, ...item }
+                [modelEntity]: item
               }
             }
           };
-          const tempModels = [
-            ...models.filter((model2) => model2.slug !== modelWithPresets.slug),
-            { ...modelWithPresets, indexes: {}, triggers: {} }
-          ];
-          transformMetaQuery(tempModels, dependencyStatements, null, query2, {
+          transformMetaQuery(models, dependencyStatements, null, query2, {
             inlineDefaults: options.inlineDefaults
           });
         }
       }
-      queryTypeDetails = { with: modelWithPresets };
+      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 };
       getSystemModels(models, modelWithPresets).map((systemModel) => {
         return handleSystemModel(
           models,
@@ -1861,13 +1852,16 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
   const modelBeforeUpdate = structuredClone(model);
   const existingModel = model;
   const pluralType = PLURAL_MODEL_ENTITIES[entity];
-  const existingEntity = existingModel[pluralType]?.[slug];
-  if ((action === "alter" || action === "drop") && !existingEntity) {
+  const targetEntityIndex = existingModel[pluralType]?.findIndex(
+    (entity2) => entity2.slug === slug
+  );
+  if ((action === "alter" || action === "drop") && (typeof targetEntityIndex === "undefined" || targetEntityIndex === -1)) {
     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.`,
@@ -1904,7 +1898,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
       }
     } else if (action === "drop" && !existingLinkField) {
       const systemFields = getSystemFields(existingModel.idPrefix);
-      const isSystemField = slug in systemFields;
+      const isSystemField = systemFields.some((field2) => field2.slug === slug);
       if (isSystemField) {
         throw new RoninError({
           message: `The ${entity} "${slug}" is a system ${entity} and cannot be removed.`,
@@ -2008,33 +2002,23 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
     case "create": {
       const value = prepareStatementValue(statementParams, jsonValue);
       json = `json_insert(${field}, '$.${slug}', ${value})`;
-      if (!existingModel[pluralType]) existingModel[pluralType] = {};
-      existingModel[pluralType][slug] = jsonValue;
+      existingModel[pluralType] = [
+        ...existingModel[pluralType] || [],
+        jsonValue
+      ];
       break;
     }
     case "alter": {
-      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}))`;
-      }
+      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);
       break;
     }
     case "drop": {
       json = `json_remove(${field}, '$.${slug}')`;
-      const targetEntities = existingModel[pluralType];
-      delete targetEntities[slug];
+      const targetEntity = existingModel[pluralType];
+      targetEntity.splice(targetEntityIndex, 1);
     }
   }
   handleSystemModels(
@@ -2126,7 +2110,7 @@ var Transaction = class {
     this.models = modelsWithPresets;
     return statements;
   };
-  #formatRows(fields, rows, single) {
+  #formatRows(fields, rows, single, isMeta) {
     const records = [];
     for (const row of rows) {
       const record = fields.reduce((acc, field, fieldIndex) => {
@@ -2139,6 +2123,11 @@ 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 };
@@ -2232,8 +2221,9 @@ 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(
-          Object.entries(model.fields).map(([slug, rest]) => [slug, rest.type])
+          model.fields.map((field) => [field.slug, field.type])
         );
         if (queryType === "count") {
           return addResult({ amount: rows[0][0] });
@@ -2241,13 +2231,13 @@ var Transaction = class {
         const single = queryModel !== model.pluralSlug;
         if (single) {
           return addResult({
-            record: rows[0] ? this.#formatRows(selectedFields, rows, true) : null,
+            record: rows[0] ? this.#formatRows(selectedFields, rows, true, isMeta) : null,
             modelFields
           });
         }
         const pageSize = queryInstructions?.limitedTo;
         const result = {
-          records: this.#formatRows(selectedFields, rows, false),
+          records: this.#formatRows(selectedFields, rows, false, isMeta),
           modelFields
         };
         if (pageSize && result.records.length > 0) {

package/package.json

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