@ronin/compiler 0.9.0-leo-ron-1083-experimental-200 → 0.9.0-leo-ron-1083-experimental-202

package/README.md

@@ -52,6 +52,9 @@ const transaction = new Transaction([
 
 transaction.statements;
 // [{
+//   statement: 'CREATE TABLE "accounts" ...',
+//   params: []
+// }, {
 //   statement: 'SELECT * FROM "accounts"',
 //   params: [],
 //   returning: true,

package/dist/index.d.ts

@@ -5919,6 +5919,10 @@ type ModelTriggerField<T extends Array<ModelField> = Array<ModelField>> = {
     slug: T[number]['slug'];
 };
 type ModelTrigger<T extends Array<ModelField> = Array<ModelField>> = {
+    /**
+     * The identifier of the index.
+     */
+    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. */

package/dist/index.js

@@ -617,6 +617,7 @@ var getFieldStatement = (models, model, field) => {
     statement += ` GENERATED ALWAYS AS (${parseFieldExpression(model, "to", symbol?.value)}) ${kind}`;
   }
   if (field.type === "link") {
+    if (field.kind === "many") return null;
     const actions = field.actions || {};
     const targetTable = getModelBySlug(models, field.target).table;
     statement += ` REFERENCES ${targetTable}("id")`;
@@ -729,14 +730,18 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       }
     };
   }
-  if (entity === "field" && model) {
+  const existingModel = model;
+  if (entity === "field") {
     if (action === "create") {
       const field2 = jsonValue;
       field2.type = field2.type || "string";
-      dependencyStatements.push({
-        statement: `${statement} ADD COLUMN ${getFieldStatement(models, model, field2)}`,
-        params: []
-      });
+      const fieldStatement = getFieldStatement(models, existingModel, field2);
+      if (fieldStatement) {
+        dependencyStatements.push({
+          statement: `${statement} ADD COLUMN ${fieldStatement}`,
+          params: []
+        });
+      }
     } else if (action === "alter") {
       const newSlug = jsonValue?.slug;
       if (newSlug) {
@@ -752,7 +757,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       });
     }
   }
-  if (entity === "index" && model) {
+  if (entity === "index") {
     const index = jsonValue;
     const indexName = convertToSnakeCase(slug);
     const params = [];
@@ -761,9 +766,9 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       const columns = index.fields.map((field2) => {
         let fieldSelector = "";
         if ("slug" in field2) {
-          ({ fieldSelector } = getFieldFromModel(model, field2.slug, "to"));
+          ({ fieldSelector } = getFieldFromModel(existingModel, field2.slug, "to"));
         } else if ("expression" in field2) {
-          fieldSelector = parseFieldExpression(model, "to", field2.expression);
+          fieldSelector = parseFieldExpression(existingModel, "to", field2.expression);
         }
         if (field2.collation) fieldSelector += ` COLLATE ${field2.collation}`;
         if (field2.order) fieldSelector += ` ${field2.order}`;
@@ -771,13 +776,13 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       });
       statement2 += ` ON "${tableName}" (${columns.join(", ")})`;
       if (index.filter) {
-        const withStatement = handleWith(models, model, params, index.filter);
+        const withStatement = handleWith(models, existingModel, params, index.filter);
         statement2 += ` WHERE (${withStatement})`;
       }
     }
     dependencyStatements.push({ statement: statement2, params });
   }
-  if (entity === "trigger" && model) {
+  if (entity === "trigger") {
     const triggerName = convertToSnakeCase(slug);
     const params = [];
     let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
@@ -793,7 +798,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
           });
         }
         const fieldSelectors = trigger.fields.map((field2) => {
-          return getFieldFromModel(model, field2.slug, "to").fieldSelector;
+          return getFieldFromModel(existingModel, field2.slug, "to").fieldSelector;
         });
         statementParts.push(`OF (${fieldSelectors.join(", ")})`);
       }
@@ -805,7 +810,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         const tableAlias = trigger.action === "DELETE" ? RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD : RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
         const withStatement = handleWith(
           models,
-          { ...model, tableAlias },
+          { ...existingModel, tableAlias },
           params,
           trigger.filter
         );
@@ -814,7 +819,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       const effectStatements = trigger.effects.map((effectQuery) => {
         return compileQueryInput(effectQuery, models, params, {
           returning: false,
-          parentModel: model
+          parentModel: existingModel
         }).main.statement;
       });
       if (effectStatements.length > 1) statementParts.push("BEGIN");
@@ -826,20 +831,42 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
   }
   const pluralType = PLURAL_MODEL_ENTITIES[entity];
   const field = `${RONIN_MODEL_SYMBOLS.FIELD}${pluralType}`;
+  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: {
+        field: "FIELD_NOT_FOUND",
+        index: "INDEX_NOT_FOUND",
+        trigger: "TRIGGER_NOT_FOUND",
+        preset: "PRESET_NOT_FOUND"
+      }[entity]
+    });
+  }
   let json;
   switch (action) {
     case "create": {
       const value = prepareStatementValue(statementParams, jsonValue);
       json = `json_insert(${field}, '$.${slug}', ${value})`;
+      existingModel[pluralType] = [
+        ...existingModel[pluralType] || [],
+        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];
+      targetEntity[targetEntityIndex] = jsonValue;
       break;
     }
     case "drop": {
       json = `json_remove(${field}, '$.${slug}')`;
+      const targetEntity = existingModel[pluralType];
+      delete targetEntity[targetEntityIndex];
     }
   }
   return {

package/package.json

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