@ronin/compiler 0.18.2 → 0.18.3-invalid-json-experimental-442

package/dist/index.d.ts

@@ -21,14 +21,12 @@ declare const QUERY_SYMBOLS: {
     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 QueryTypeEnum = (typeof DML_QUERY_TYPES)[number];
 type ModelQueryTypeEnum = (typeof DDL_QUERY_TYPES)[number];
-type ModelEntityEnum = 'field' | 'index' | 'trigger' | 'preset';
+type ModelEntityEnum = 'field' | 'index' | 'preset';
 type FieldValue = string | number | boolean | null | unknown;
 type FieldSelector = Record<string, FieldValue | StoredObject>;
 type StoredObject = {
@@ -126,11 +124,10 @@ type CreateQuery = {
 };
 type AlterQuery = {
     model: string;
-    to?: Partial<Omit<PublicModel, 'fields' | 'indexes' | 'triggers' | 'presets' | 'idPrefix'>>;
+    to?: Partial<Omit<PublicModel, 'fields' | 'indexes' | 'presets' | 'idPrefix'>>;
     create?: {
         field?: Omit<ModelField, 'system'>;
         index?: Omit<ModelIndex, 'system'>;
-        trigger?: Omit<ModelTrigger, 'system'>;
         preset?: Omit<ModelPreset, 'system'>;
     };
     alter?: {
@@ -139,9 +136,6 @@ type AlterQuery = {
     } | {
         index?: string;
         to?: Partial<Omit<ModelIndex, 'system'>>;
-    } | {
-        trigger?: string;
-        to?: Omit<ModelTrigger, 'system'>;
     } | {
         preset?: string;
         to?: Omit<ModelPreset, 'system'>;
@@ -298,30 +292,6 @@ type ModelIndex<T extends ModelEntityList<ModelField> = ModelEntityList<ModelFie
      */
     filter?: WithInstruction;
 };
-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: keyof T;
-};
-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. */
-    when: 'BEFORE' | 'DURING' | 'AFTER';
-    /** A list of queries that should be executed when the trigger fires. */
-    effects: Array<Record<typeof QUERY_SYMBOLS.QUERY, Query>>;
-    /** A list of field slugs for which the trigger should fire. */
-    fields?: Array<ModelTriggerField<T>>;
-    /**
-     * An object containing query instructions used to determine whether the trigger should
-     * fire, or not.
-     */
-    filter?: WithInstruction;
-};
 type ModelPreset = {
     /** The visual display name of the preset. */
     name?: string;
@@ -369,7 +339,6 @@ interface Model<T extends ModelEntityList<ModelField> = ModelEntityList<ModelFie
     };
     fields: T;
     indexes?: ModelEntityList<ModelIndex<T>>;
-    triggers?: ModelEntityList<ModelTrigger<T>>;
     presets?: ModelEntityList<ModelPreset>;
 }
 type PublicModel<T extends ModelEntityList<ModelField> = ModelEntityList<ModelField>> = Omit<Partial<Model<T>>, 'slug' | 'identifiers' | 'system' | 'tableAlias'> & {
@@ -423,7 +392,7 @@ type ExpandedResult<T = ResultRecord> = {
 };
 type Result<T = ResultRecord> = RegularResult<T> | ExpandedResult<T>;
 
-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';
+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' | 'INVALID_FIELD_VALUE' | 'EXISTING_MODEL_ENTITY' | 'REQUIRED_MODEL_ENTITY' | 'MUTUALLY_EXCLUSIVE_INSTRUCTIONS' | 'MISSING_INSTRUCTION' | 'MISSING_FIELD';
 interface Issue {
     message: string;
     path: Array<string | number>;
@@ -499,4 +468,4 @@ declare class Transaction {
 
 declare const CLEAN_ROOT_MODEL: PublicModel;
 
-export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type AlterQuery, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, type CreateQuery, DDL_QUERY_TYPES, DML_QUERY_TYPES, DML_QUERY_TYPES_READ, DML_QUERY_TYPES_WRITE, type DropQuery, type ExpandedResult, type GetInstructions, type GetQuery, type GetInstructions as GetQueryInstructions, type ListQuery, type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, QUERY_SYMBOLS, QUERY_TYPES, type Query, type QueryInstructionType as QueryInstruction, type QuerySchemaType, type QueryType, CLEAN_ROOT_MODEL as ROOT_MODEL, type RegularResult, type RemoveInstructions, type RemoveQuery, type RemoveInstructions as RemoveQueryInstructions, type Result, type ResultRecord, type ResultRecordBase, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, type StoredObject, Transaction, type WithInstruction, getQuerySymbol };
+export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type AlterQuery, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, type CreateQuery, DDL_QUERY_TYPES, DML_QUERY_TYPES, DML_QUERY_TYPES_READ, DML_QUERY_TYPES_WRITE, type DropQuery, type ExpandedResult, type GetInstructions, type GetQuery, type GetInstructions as GetQueryInstructions, type ListQuery, type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, QUERY_SYMBOLS, QUERY_TYPES, type Query, type QueryInstructionType as QueryInstruction, type QuerySchemaType, type QueryType, CLEAN_ROOT_MODEL as ROOT_MODEL, type RegularResult, type RemoveInstructions, type RemoveQuery, type RemoveInstructions as RemoveQueryInstructions, type Result, type ResultRecord, type ResultRecordBase, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, type StoredObject, Transaction, type WithInstruction, getQuerySymbol };

package/dist/index.js

@@ -16,10 +16,6 @@ var QUERY_SYMBOLS = {
   FIELD: "__RONIN_FIELD_",
   // Represents the value of a field in the model of a parent query.
   FIELD_PARENT: "__RONIN_FIELD_PARENT_",
-  // Represents the old value of a field in the parent model. Used for triggers.
-  FIELD_PARENT_OLD: "__RONIN_FIELD_PARENT_OLD_",
-  // Represents the new value of a field in the parent model. Used for triggers.
-  FIELD_PARENT_NEW: "__RONIN_FIELD_PARENT_NEW_",
   // Represents a value provided to a query preset.
   VALUE: "__RONIN_VALUE"
 };
@@ -46,7 +42,6 @@ var composeMountingPath = (single, key, mountingPath) => {
 var MODEL_ENTITY_ERROR_CODES = {
   field: "FIELD_NOT_FOUND",
   index: "INDEX_NOT_FOUND",
-  trigger: "TRIGGER_NOT_FOUND",
   preset: "PRESET_NOT_FOUND"
 };
 var RoninError = class extends Error {
@@ -1318,11 +1313,6 @@ var parseFieldExpression = (model, instructionName, expression, parentModel) =>
     if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT)) {
       rootModel = parentModel;
       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, "");
     const field = getFieldFromModel(rootModel, fieldSlug, { instructionName });
@@ -1381,8 +1371,18 @@ var composeConditions = (models, model, statementParams, instructionName, value,
         instructionName
       });
       const { field: modelField } = fieldDetails || {};
-      const consumeJSON = (modelField?.type === "json" || modelField?.type === "blob") && instructionName === "to";
-      if (modelField && !(isObject(value) || Array.isArray(value)) || getQuerySymbol(value) || consumeJSON) {
+      const fieldIsJSON = (modelField?.type === "json" || modelField?.type === "blob") && instructionName === "to";
+      const valueIsJSON = isObject(value) || (modelField?.type === "blob" ? null : Array.isArray(value));
+      if (!valueIsJSON || getQuerySymbol(value) || fieldIsJSON) {
+        if (modelField && fieldIsJSON && !valueIsJSON) {
+          const messagePrefix = "The provided field value is not";
+          const message = modelField.type === "json" ? `${messagePrefix} valid JSON. Only objects and arrays should be provided. Other types of values should be stored in their respective primitive field types.` : `${messagePrefix} a valid Blob reference.`;
+          throw new RoninError({
+            message,
+            field: modelField?.slug,
+            code: "INVALID_FIELD_VALUE"
+          });
+        }
         return composeFieldValues(
           models,
           model,
@@ -1622,7 +1622,6 @@ var ROOT_MODEL = {
     // which makes the statement shorter.
     fields: { type: "json", defaultValue: {} },
     indexes: { type: "json", defaultValue: {} },
-    triggers: { type: "json", defaultValue: {} },
     presets: { type: "json", defaultValue: {} }
   }
 };
@@ -1709,11 +1708,11 @@ var getFieldStatement = (models, model, field) => {
     const modelList = models.some((item) => item.slug === model.slug) ? models : [...models, model];
     const targetTable = getModelBySlug(modelList, field.target).table;
     statement += ` REFERENCES ${targetTable}("id")`;
-    for (const trigger in actions) {
-      if (!Object.hasOwn(actions, trigger)) continue;
-      const triggerName = trigger.toUpperCase().slice(2);
-      const action = actions[trigger];
-      statement += ` ON ${triggerName} ${action}`;
+    for (const cause in actions) {
+      if (!Object.hasOwn(actions, cause)) continue;
+      const causeName = cause.toUpperCase().slice(2);
+      const action = actions[cause];
+      statement += ` ON ${causeName} ${action}`;
     }
   }
   return statement;
@@ -1721,7 +1720,6 @@ var getFieldStatement = (models, model, field) => {
 var PLURAL_MODEL_ENTITIES = {
   field: "fields",
   index: "indexes",
-  trigger: "triggers",
   preset: "presets"
 };
 var PLURAL_MODEL_ENTITIES_VALUES = Object.values(PLURAL_MODEL_ENTITIES);
@@ -1854,29 +1852,23 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
         statement: `CREATE TABLE "${modelWithPresets.table}" (${columns.join(", ")})`,
         params: []
       });
-      for (const [modelEntity, pluralModelEntity] of [
-        ["index", "indexes"],
-        ["trigger", "triggers"]
-      ]) {
-        const entityList = modelWithPresets[pluralModelEntity];
-        if (!entityList) continue;
-        for (const [itemSlug, item] of Object.entries(entityList)) {
-          const query2 = {
-            alter: {
-              model: modelWithPresets.slug,
-              create: {
-                [modelEntity]: { slug: itemSlug, ...item }
-              }
+      const entityList = modelWithPresets.indexes;
+      for (const [itemSlug, item] of Object.entries(entityList || {})) {
+        const query2 = {
+          alter: {
+            model: modelWithPresets.slug,
+            create: {
+              index: { slug: itemSlug, ...item }
             }
-          };
-          const tempModels = [
-            ...models.filter((model2) => model2.slug !== modelWithPresets.slug),
-            { ...modelWithPresets, indexes: {}, triggers: {} }
-          ];
-          transformMetaQuery(tempModels, dependencyStatements, null, query2, {
-            inlineDefaults: options.inlineDefaults
-          });
-        }
+          }
+        };
+        const tempModels = [
+          ...models.filter((model2) => model2.slug !== modelWithPresets.slug),
+          { ...modelWithPresets, indexes: {} }
+        ];
+        transformMetaQuery(tempModels, dependencyStatements, null, query2, {
+          inlineDefaults: options.inlineDefaults
+        });
       }
       queryTypeDetails = { with: modelWithPresets };
       getSystemModels(models, modelWithPresets).map((systemModel) => {
@@ -2034,56 +2026,6 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
     }
     dependencyStatements.push({ statement, params: [] });
   }
-  if (entity === "trigger") {
-    const triggerName = convertToSnakeCase(slug);
-    let statement = `${statementAction} TRIGGER "${triggerName}"`;
-    if (action === "create") {
-      const trigger = jsonValue;
-      const statementParts = [`${trigger.when} ${trigger.action}`];
-      if (trigger.fields) {
-        if (trigger.action !== "UPDATE") {
-          throw new RoninError({
-            message: `When ${actionReadable} ${PLURAL_MODEL_ENTITIES[entity]}, targeting specific fields requires the \`UPDATE\` action.`,
-            code: "INVALID_MODEL_VALUE",
-            fields: ["action"]
-          });
-        }
-        const fieldSelectors = trigger.fields.map((field2) => {
-          return getFieldFromModel(existingModel, field2.slug, {
-            modelEntityType: "trigger",
-            modelEntityName: triggerName
-          }).fieldSelector;
-        });
-        statementParts.push(`OF (${fieldSelectors.join(", ")})`);
-      }
-      statementParts.push("ON", `"${existingModel.table}"`);
-      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" ? QUERY_SYMBOLS.FIELD_PARENT_OLD : QUERY_SYMBOLS.FIELD_PARENT_NEW;
-        const withStatement = handleWith(
-          models,
-          { ...existingModel, tableAlias },
-          null,
-          trigger.filter
-        );
-        statementParts.push("WHEN", `(${withStatement})`);
-      }
-      const effectStatements = trigger.effects.map((effectQuery) => {
-        return compileQueryInput(effectQuery[QUERY_SYMBOLS.QUERY], models, null, {
-          returning: false,
-          parentModel: existingModel,
-          inlineDefaults: options.inlineDefaults
-        }).main.statement;
-      });
-      statementParts.push("BEGIN");
-      statementParts.push(`${effectStatements.join("; ")};`);
-      statementParts.push("END");
-      statement += ` ${statementParts.join(" ")}`;
-    }
-    dependencyStatements.push({ statement, params: [] });
-  }
   const field = `${QUERY_SYMBOLS.FIELD}${pluralType}`;
   let json;
   switch (action) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.18.2",
+  "version": "0.18.3-invalid-json-experimental-442",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {