@ronin/compiler 0.13.9 → 0.13.10

package/dist/index.d.ts

@@ -15,7 +15,7 @@ declare const QUERY_SYMBOLS: {
     readonly FIELD_PARENT_NEW: "__RONIN_FIELD_PARENT_NEW_";
     readonly VALUE: "__RONIN_VALUE";
 };
-type RoninErrorCode = 'MODEL_NOT_FOUND' | 'FIELD_NOT_FOUND' | 'INDEX_NOT_FOUND' | 'TRIGGER_NOT_FOUND' | 'PRESET_NOT_FOUND' | 'INVALID_WITH_VALUE' | 'INVALID_TO_VALUE' | 'INVALID_INCLUDING_VALUE' | 'INVALID_FOR_VALUE' | 'INVALID_BEFORE_OR_AFTER_INSTRUCTION' | 'INVALID_MODEL_VALUE' | 'MUTUALLY_EXCLUSIVE_INSTRUCTIONS' | 'MISSING_INSTRUCTION' | 'MISSING_FIELD';
+type RoninErrorCode = 'MODEL_NOT_FOUND' | 'FIELD_NOT_FOUND' | 'INDEX_NOT_FOUND' | 'TRIGGER_NOT_FOUND' | 'PRESET_NOT_FOUND' | 'INVALID_WITH_VALUE' | 'INVALID_TO_VALUE' | 'INVALID_INCLUDING_VALUE' | 'INVALID_FOR_VALUE' | 'INVALID_BEFORE_OR_AFTER_INSTRUCTION' | 'INVALID_MODEL_VALUE' | 'EXISTING_MODEL_ENTITY' | 'REQUIRED_MODEL_ENTITY' | 'MUTUALLY_EXCLUSIVE_INSTRUCTIONS' | 'MISSING_INSTRUCTION' | 'MISSING_FIELD';
 interface Issue {
     message: string;
     path: Array<string | number>;

package/dist/index.js

@@ -184,7 +184,7 @@ var parseFieldExpression = (model, instructionName, expression, parentModel) =>
       }
     }
     const fieldSlug = match.replace(toReplace, "");
-    const field = getFieldFromModel(rootModel, fieldSlug, instructionName);
+    const field = getFieldFromModel(rootModel, fieldSlug, { instructionName });
     return field.fieldSelector;
   });
 };
@@ -192,7 +192,7 @@ var composeFieldValues = (models, model, statementParams, instructionName, value
   const { fieldSelector: conditionSelector } = getFieldFromModel(
     model,
     options.fieldSlug,
-    instructionName
+    { instructionName }
   );
   const collectStatementValue = options.type !== "fields";
   const symbol = getSymbol(value);
@@ -233,7 +233,9 @@ var composeConditions = (models, model, statementParams, instructionName, value,
       return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
     });
     if (!childField) {
-      const fieldDetails = getFieldFromModel(model, options.fieldSlug, instructionName);
+      const fieldDetails = getFieldFromModel(model, options.fieldSlug, {
+        instructionName
+      });
       const { field: modelField } = fieldDetails || {};
       const consumeJSON = modelField?.type === "json" && instructionName === "to";
       if (modelField && !(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
@@ -565,10 +567,10 @@ var getModelBySlug = (models, slug) => {
   return model;
 };
 var composeAssociationModelSlug = (model, field) => convertToCamelCase(`ronin_link_${model.slug}_${field.slug}`);
-var getFieldSelector = (model, field, fieldPath, instructionName) => {
+var getFieldSelector = (model, field, fieldPath, writing) => {
   const symbol = model.tableAlias?.startsWith(QUERY_SYMBOLS.FIELD_PARENT) ? `${model.tableAlias.replace(QUERY_SYMBOLS.FIELD_PARENT, "").slice(0, -1)}.` : "";
   const tablePrefix = symbol || (model.tableAlias ? `"${model.tableAlias}".` : "");
-  if (field.type === "json" && instructionName !== "to") {
+  if (field.type === "json" && !writing) {
     const dotParts = fieldPath.split(".");
     const columnName = tablePrefix + dotParts.shift();
     const jsonField = dotParts.join(".");
@@ -576,19 +578,16 @@ var getFieldSelector = (model, field, fieldPath, instructionName) => {
   }
   return `${tablePrefix}"${fieldPath}"`;
 };
-function getFieldFromModel(model, fieldPath, instructionName, shouldThrow = true) {
-  const errorPrefix = `Field "${fieldPath}" defined for \`${instructionName}\``;
+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 || [];
   let modelField;
   if (fieldPath.includes(".")) {
     modelField = modelFields.find((field) => field.slug === fieldPath.split(".")[0]);
     if (modelField?.type === "json") {
-      const fieldSelector2 = getFieldSelector(
-        model,
-        modelField,
-        fieldPath,
-        instructionName
-      );
+      const fieldSelector2 = getFieldSelector(model, modelField, fieldPath, writingField);
       return { field: modelField, fieldSelector: fieldSelector2 };
     }
   }
@@ -604,7 +603,7 @@ function getFieldFromModel(model, fieldPath, instructionName, shouldThrow = true
     }
     return null;
   }
-  const fieldSelector = getFieldSelector(model, modelField, fieldPath, instructionName);
+  const fieldSelector = getFieldSelector(model, modelField, fieldPath, writingField);
   return { field: modelField, fieldSelector };
 }
 var slugToName = (slug) => {
@@ -1015,6 +1014,13 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
     });
   }
   const existingEntity = existingModel[pluralType]?.[targetEntityIndex];
+  if (action === "create" && existingEntity) {
+    throw new RoninError({
+      message: `A ${entity} with the slug "${slug}" already exists.`,
+      code: "EXISTING_MODEL_ENTITY",
+      fields: ["slug"]
+    });
+  }
   if (entity === "field") {
     const statement = `ALTER TABLE "${existingModel.table}"`;
     const existingField = existingEntity;
@@ -1043,6 +1049,14 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         }
       }
     } else if (action === "drop" && !existingLinkField) {
+      const systemFields = getSystemFields(existingModel.idPrefix);
+      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.`,
+          code: "REQUIRED_MODEL_ENTITY"
+        });
+      }
       dependencyStatements.push({
         statement: `${statement} DROP COLUMN "${slug}"`,
         params: []
@@ -1055,10 +1069,20 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
     const indexName = convertToSnakeCase(slug);
     let statement = `${statementAction}${index?.unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
     if (action === "create") {
+      if (!Array.isArray(index.fields) || index.fields.length === 0) {
+        throw new RoninError({
+          message: `When ${actionReadable} ${PLURAL_MODEL_ENTITIES[entity]}, at least one field must be provided.`,
+          code: "INVALID_MODEL_VALUE",
+          fields: ["fields"]
+        });
+      }
       const columns = index.fields.map((field2) => {
         let fieldSelector = "";
         if ("slug" in field2) {
-          ({ fieldSelector } = getFieldFromModel(existingModel, field2.slug, "to"));
+          ({ fieldSelector } = getFieldFromModel(existingModel, field2.slug, {
+            modelEntityType: "index",
+            modelEntityName: indexName
+          }));
         } else if ("expression" in field2) {
           fieldSelector = parseFieldExpression(existingModel, "to", field2.expression);
         }
@@ -1089,7 +1113,10 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
           });
         }
         const fieldSelectors = trigger.fields.map((field2) => {
-          return getFieldFromModel(existingModel, field2.slug, "to").fieldSelector;
+          return getFieldFromModel(existingModel, field2.slug, {
+            modelEntityType: "trigger",
+            modelEntityName: triggerName
+          }).fieldSelector;
         });
         statementParts.push(`OF (${fieldSelectors.join(", ")})`);
       }
@@ -1201,7 +1228,9 @@ var generatePaginationCursor = (model, orderedBy, record) => {
   const cursors = keys.map((fieldSlug) => {
     const property = getProperty(record, fieldSlug);
     if (property === null || property === void 0) return CURSOR_NULL_PLACEHOLDER;
-    const { field } = getFieldFromModel(model, fieldSlug, "orderedBy");
+    const { field } = getFieldFromModel(model, fieldSlug, {
+      instructionName: "orderedBy"
+    });
     if (field.type === "date") return new Date(property).getTime();
     return property;
   });
@@ -1240,7 +1269,9 @@ var handleBeforeOrAfter = (model, statementParams, instructions) => {
     if (value === CURSOR_NULL_PLACEHOLDER) {
       return "NULL";
     }
-    const { field } = getFieldFromModel(model, key, "orderedBy");
+    const { field } = getFieldFromModel(model, key, {
+      instructionName: "orderedBy"
+    });
     if (field.type === "boolean") {
       return prepareStatementValue(statementParams, value === "true");
     }
@@ -1266,7 +1297,9 @@ var handleBeforeOrAfter = (model, statementParams, instructions) => {
     for (let j = 0; j <= i; j++) {
       const key = keys[j];
       const value = values[j];
-      let { field, fieldSelector } = getFieldFromModel(model, key, "orderedBy");
+      let { field, fieldSelector } = getFieldFromModel(model, key, {
+        instructionName: "orderedBy"
+      });
       if (j === i) {
         const closingParentheses = ")".repeat(condition.length);
         const operator = value === "NULL" ? "IS NOT" : compareOperators[j];
@@ -1418,7 +1451,7 @@ var handleOrderedBy = (model, instruction) => {
     const { field: modelField, fieldSelector } = getFieldFromModel(
       model,
       item.value,
-      instructionName
+      { instructionName }
     );
     const caseInsensitiveStatement = modelField.type === "string" ? " COLLATE NOCASE" : "";
     statement += `${fieldSelector}${caseInsensitiveStatement} ${item.order}`;
@@ -1488,11 +1521,9 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
     const usableModel = expandColumns ? { ...model, tableAlias: model.tableAlias || model.table } : model;
     const selectedFields = [];
     statement = instructions.selecting.map((slug) => {
-      const { field, fieldSelector } = getFieldFromModel(
-        usableModel,
-        slug,
-        "selecting"
-      );
+      const { field, fieldSelector } = getFieldFromModel(usableModel, slug, {
+        instructionName: "selecting"
+      });
       selectedFields.push(field);
       return fieldSelector;
     }).join(", ");
@@ -1542,12 +1573,12 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
       ) : []
     ];
     for (const field of subQueryFields || []) {
-      getFieldFromModel(model, field, "to");
+      getFieldFromModel(model, field, { instructionName: "to" });
     }
     let statement2 = "";
     if (subQuerySelectedFields) {
       const columns = subQueryFields.map((field) => {
-        return getFieldFromModel(model, field, "to").fieldSelector;
+        return getFieldFromModel(model, field, { instructionName: "to" }).fieldSelector;
       });
       statement2 = `(${columns.join(", ")}) `;
     }
@@ -1558,7 +1589,12 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
   for (const fieldSlug in toInstruction) {
     if (!Object.hasOwn(toInstruction, fieldSlug)) continue;
     const fieldValue = toInstruction[fieldSlug];
-    const fieldDetails = getFieldFromModel(model, fieldSlug, "to", false);
+    const fieldDetails = getFieldFromModel(
+      model,
+      fieldSlug,
+      { instructionName: "to" },
+      false
+    );
     if (fieldDetails?.field.type === "link" && fieldDetails.field.kind === "many") {
       delete toInstruction[fieldSlug];
       const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.13.9",
+  "version": "0.13.10",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {