@ronin/compiler 0.17.0 → 0.17.1-leo-ron-1099-experimental-378

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']>, Omit<T, 'slug'>>;
+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']>;
 };

package/dist/index.js

@@ -587,22 +587,25 @@ 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, rest] of Object.entries(model.fields)) {
+      const field = { slug: fieldSlug, ...rest };
       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,
@@ -827,13 +830,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) {
@@ -922,7 +928,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) {
@@ -1282,19 +1288,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;
@@ -1302,29 +1308,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]: {
@@ -1355,16 +1364,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]: {
@@ -1380,24 +1388,25 @@ 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(([fieldSlug, rest]) => {
+      const field2 = { slug: fieldSlug, ...rest };
       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]: {
@@ -1414,16 +1423,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;
 };
@@ -1455,7 +1466,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]);
@@ -1479,36 +1495,31 @@ 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: 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"
+    type: "string"
   },
-  {
+  "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"
+    type: "string"
   }
-];
+});
 var ROOT_MODEL = {
   slug: "model",
   identifiers: {
@@ -1519,43 +1530,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: {
@@ -1563,8 +1574,7 @@ var getSystemModels = (models, model) => {
                 onUpdate: "CASCADE"
               }
             },
-            {
-              slug: "target",
+            target: {
               type: "link",
               target: relatedModel.slug,
               actions: {
@@ -1572,7 +1582,7 @@ var getSystemModels = (models, model) => {
                 onUpdate: "CASCADE"
               }
             }
-          ]
+          }
         });
       }
     }
@@ -1636,13 +1646,6 @@ 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 = {
@@ -1665,11 +1668,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);
     }
@@ -1725,7 +1728,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;
@@ -1743,20 +1746,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(", ")})`,
@@ -1766,28 +1773,27 @@ 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),
+            { ...modelWithPresets, indexes: {}, triggers: {} }
+          ];
+          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,
@@ -1852,16 +1858,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.`,
@@ -1898,7 +1901,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.`,
@@ -2002,23 +2005,33 @@ 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(
@@ -2110,7 +2123,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) => {
@@ -2123,11 +2136,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 };
@@ -2221,9 +2229,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] });
@@ -2231,13 +2238,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.17.0",
+  "version": "0.17.1-leo-ron-1099-experimental-378",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {