@ronin/compiler 0.10.3-leo-ron-1083-experimental-217 → 0.10.3-leo-ron-1083-experimental-219

package/dist/index.d.ts

@@ -6005,6 +6005,45 @@ type AmountResult = {
 };
 type Result = SingleRecordResult | MultipleRecordResult | AmountResult;
 
+/**
+ * A list of placeholders that can be located inside queries after those queries were
+ * serialized into JSON objects.
+ *
+ * These placeholders are used to represent special keys and values. For example, if a
+ * query is nested into a query, the nested query will be marked with `__RONIN_QUERY`,
+ * which allows for distinguishing that nested query from an object of instructions.
+ */
+declare const QUERY_SYMBOLS: {
+    readonly QUERY: "__RONIN_QUERY";
+    readonly EXPRESSION: "__RONIN_EXPRESSION";
+    readonly FIELD: "__RONIN_FIELD_";
+    readonly FIELD_PARENT: "__RONIN_FIELD_PARENT_";
+    readonly FIELD_PARENT_OLD: "__RONIN_FIELD_PARENT_OLD_";
+    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';
+interface Issue {
+    message: string;
+    path: Array<string | number>;
+}
+interface Details {
+    message: string;
+    code: RoninErrorCode;
+    field?: string;
+    fields?: Array<string>;
+    issues?: Array<Issue>;
+    queries?: Array<Query> | null;
+}
+declare class RoninError extends Error {
+    code: Details['code'];
+    field?: Details['field'];
+    fields?: Details['fields'];
+    issues?: Details['issues'];
+    queries?: Details['queries'];
+    constructor(details: Details);
+}
+
 interface TransactionOptions {
     /** A list of models that already exist in the database. */
     models?: Array<PublicModel>;
@@ -6037,4 +6076,4 @@ declare class Transaction {
 
 declare const CLEAN_ROOT_MODEL: PublicModel;
 
-export { type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, type Query, CLEAN_ROOT_MODEL as ROOT_MODEL, type Result, type Statement, Transaction };
+export { type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, QUERY_SYMBOLS, type Query, CLEAN_ROOT_MODEL as ROOT_MODEL, type Result, RoninError, type Statement, Transaction };

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/utils/helpers.ts
 import { init as cuid } from "@paralleldrive/cuid2";
-var RONIN_MODEL_SYMBOLS = {
+var QUERY_SYMBOLS = {
   // Represents a sub query.
   QUERY: "__RONIN_QUERY",
   // Represents an expression that should be evaluated.
@@ -17,7 +17,7 @@ var RONIN_MODEL_SYMBOLS = {
   VALUE: "__RONIN_VALUE"
 };
 var RONIN_MODEL_FIELD_REGEX = new RegExp(
-  `${RONIN_MODEL_SYMBOLS.FIELD}[_a-zA-Z0-9.]+`,
+  `${QUERY_SYMBOLS.FIELD}[_a-zA-Z0-9.]+`,
   "g"
 );
 var MODEL_ENTITY_ERROR_CODES = {
@@ -68,16 +68,16 @@ var isObject = (value) => value != null && typeof value === "object" && Array.is
 var getSymbol = (value) => {
   if (!isObject(value)) return null;
   const objectValue = value;
-  if (RONIN_MODEL_SYMBOLS.QUERY in objectValue) {
+  if (QUERY_SYMBOLS.QUERY in objectValue) {
     return {
       type: "query",
-      value: objectValue[RONIN_MODEL_SYMBOLS.QUERY]
+      value: objectValue[QUERY_SYMBOLS.QUERY]
     };
   }
-  if (RONIN_MODEL_SYMBOLS.EXPRESSION in objectValue) {
+  if (QUERY_SYMBOLS.EXPRESSION in objectValue) {
     return {
       type: "expression",
-      value: objectValue[RONIN_MODEL_SYMBOLS.EXPRESSION]
+      value: objectValue[QUERY_SYMBOLS.EXPRESSION]
     };
   }
   return null;
@@ -151,15 +151,15 @@ var prepareStatementValue = (statementParams, value) => {
 };
 var parseFieldExpression = (model, instructionName, expression, parentModel) => {
   return expression.replace(RONIN_MODEL_FIELD_REGEX, (match) => {
-    let toReplace = RONIN_MODEL_SYMBOLS.FIELD;
+    let toReplace = QUERY_SYMBOLS.FIELD;
     let rootModel = model;
-    if (match.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT)) {
+    if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT)) {
       rootModel = parentModel;
-      toReplace = RONIN_MODEL_SYMBOLS.FIELD_PARENT;
-      if (match.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD)) {
-        rootModel.tableAlias = toReplace = RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD;
-      } else if (match.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW)) {
-        rootModel.tableAlias = toReplace = RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
+      toReplace = QUERY_SYMBOLS.FIELD_PARENT;
+      if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT_OLD)) {
+        rootModel.tableAlias = toReplace = QUERY_SYMBOLS.FIELD_PARENT_OLD;
+      } else if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT_NEW)) {
+        rootModel.tableAlias = toReplace = QUERY_SYMBOLS.FIELD_PARENT_NEW;
       }
     }
     const fieldSlug = match.replace(toReplace, "");
@@ -238,7 +238,7 @@ var composeConditions = (models, model, statementParams, instructionName, value,
           }
         };
         recordTarget = {
-          [RONIN_MODEL_SYMBOLS.QUERY]: subQuery
+          [QUERY_SYMBOLS.QUERY]: subQuery
         };
       }
       return composeConditions(
@@ -348,7 +348,7 @@ var getModelBySlug = (models, slug) => {
 };
 var composeAssociationModelSlug = (model, field) => convertToCamelCase(`ronin_link_${model.slug}_${field.slug}`);
 var getFieldSelector = (model, field, fieldPath, instructionName) => {
-  const symbol = model.tableAlias?.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT) ? `${model.tableAlias.replace(RONIN_MODEL_SYMBOLS.FIELD_PARENT, "").slice(0, -1)}.` : "";
+  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") {
     const dotParts = fieldPath.split(".");
@@ -544,14 +544,14 @@ var addDefaultModelPresets = (list, model) => {
         instructions: {
           including: {
             [field.slug]: {
-              [RONIN_MODEL_SYMBOLS.QUERY]: {
+              [QUERY_SYMBOLS.QUERY]: {
                 get: {
                   [relatedModel.slug]: {
                     with: {
                       // Compare the `id` field of the related model to the link field on
                       // the root model (`field.slug`).
                       id: {
-                        [RONIN_MODEL_SYMBOLS.EXPRESSION]: `${RONIN_MODEL_SYMBOLS.FIELD_PARENT}${field.slug}`
+                        [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}${field.slug}`
                       }
                     }
                   }
@@ -579,12 +579,12 @@ var addDefaultModelPresets = (list, model) => {
       instructions: {
         including: {
           [presetSlug]: {
-            [RONIN_MODEL_SYMBOLS.QUERY]: {
+            [QUERY_SYMBOLS.QUERY]: {
               get: {
                 [pluralSlug]: {
                   with: {
                     [childField.slug]: {
-                      [RONIN_MODEL_SYMBOLS.EXPRESSION]: `${RONIN_MODEL_SYMBOLS.FIELD_PARENT}id`
+                      [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
                     }
                   }
                 }
@@ -851,11 +851,11 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         statementParts.push(`OF (${fieldSelectors.join(", ")})`);
       }
       statementParts.push("ON", `"${existingModel.table}"`);
-      if (trigger.filter || trigger.effects.some((query2) => findInObject(query2, RONIN_MODEL_SYMBOLS.FIELD))) {
+      if (trigger.filter || trigger.effects.some((query2) => findInObject(query2, QUERY_SYMBOLS.FIELD))) {
         statementParts.push("FOR EACH ROW");
       }
       if (trigger.filter) {
-        const tableAlias = trigger.action === "DELETE" ? RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD : RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
+        const tableAlias = trigger.action === "DELETE" ? QUERY_SYMBOLS.FIELD_PARENT_OLD : QUERY_SYMBOLS.FIELD_PARENT_NEW;
         const withStatement = handleWith(
           models,
           { ...existingModel, tableAlias },
@@ -877,7 +877,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
     }
     dependencyStatements.push({ statement, params });
   }
-  const field = `${RONIN_MODEL_SYMBOLS.FIELD}${pluralType}`;
+  const field = `${QUERY_SYMBOLS.FIELD}${pluralType}`;
   let json;
   switch (action) {
     case "create": {
@@ -941,7 +941,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       model: {
         with: { slug: modelSlug },
         to: {
-          [pluralType]: { [RONIN_MODEL_SYMBOLS.EXPRESSION]: json }
+          [pluralType]: { [QUERY_SYMBOLS.EXPRESSION]: json }
         }
       }
     }
@@ -1060,8 +1060,8 @@ var handleFor = (model, instructions) => {
     if (arg !== null) {
       findInObject(
         replacedForFilter,
-        RONIN_MODEL_SYMBOLS.VALUE,
-        (match) => match.replace(RONIN_MODEL_SYMBOLS.VALUE, arg)
+        QUERY_SYMBOLS.VALUE,
+        (match) => match.replace(QUERY_SYMBOLS.VALUE, arg)
       );
     }
     for (const subInstruction in replacedForFilter) {
@@ -1207,7 +1207,7 @@ var handleSelecting = (models, model, statementParams, instructions, options) =>
           const value2 = parseFieldExpression(
             { ...queryModel, tableAlias: tableName },
             "including",
-            `${RONIN_MODEL_SYMBOLS.FIELD}${field.slug}`
+            `${QUERY_SYMBOLS.FIELD}${field.slug}`
           );
           return {
             key: `${tableName}.${field.slug}`,
@@ -1607,6 +1607,8 @@ var Transaction = class {
 };
 var CLEAN_ROOT_MODEL = omit(ROOT_MODEL, ["system"]);
 export {
+  QUERY_SYMBOLS,
   CLEAN_ROOT_MODEL as ROOT_MODEL,
+  RoninError,
   Transaction
 };

package/package.json

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