@ronin/compiler 0.9.0 → 0.10.0

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 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. */
@@ -5957,17 +5961,25 @@ interface Model<T extends Array<ModelField> = Array<ModelField>> {
      */
     tableAlias?: string;
     /**
-     * If the model is used to associate two models with each other (in the case of
-     * many-cardinality link fields), this property should contain the field slug to which
-     * the associative model should be mounted on the source model.
+     * Details that identify the model as a model that was automatically created by RONIN,
+     * instead of being manually created by a developer.
      */
-    associationSlug?: string;
+    system?: {
+        /** The model that caused the system model to get created. */
+        model: string | 'root';
+        /**
+         * If the model is used to associate two models with each other (in the case of
+         * many-cardinality link fields), this property should contain the field slug to
+         * which the associative model should be mounted on the source model.
+         */
+        associationSlug?: string;
+    };
     fields: T;
     indexes?: Array<ModelIndex<T>>;
     triggers?: Array<ModelTrigger<T>>;
     presets?: Array<ModelPreset>;
 }
-type PublicModel<T extends Array<ModelField> = Array<ModelField>> = Omit<Partial<Model<T>>, 'slug' | 'identifiers' | 'associationSlug' | 'table' | 'tableAlias'> & {
+type PublicModel<T extends Array<ModelField> = Array<ModelField>> = Omit<Partial<Model<T>>, 'slug' | 'identifiers' | 'system' | 'table' | 'tableAlias'> & {
     slug: Required<Model['slug']>;
     identifiers?: Partial<Model['identifiers']>;
 };

package/dist/index.js

@@ -20,6 +20,12 @@ var RONIN_MODEL_FIELD_REGEX = new RegExp(
   `${RONIN_MODEL_SYMBOLS.FIELD}[_a-zA-Z0-9]+`,
   "g"
 );
+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 {
   code;
   field;
@@ -459,67 +465,67 @@ var SYSTEM_FIELDS = [
     slug: "ronin.updatedBy"
   }
 ];
-var SYSTEM_MODELS = [
-  {
-    slug: "model",
-    identifiers: {
-      name: "name",
-      slug: "slug"
-    },
-    // This name mimics the `sqlite_schema` table in SQLite.
-    table: "ronin_schema",
-    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", type: "group" },
-      { slug: "identifiers.name", type: "string" },
-      { slug: "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: "{}" }
-    ]
-  }
-];
-var addSystemModels = (models) => {
-  const associativeModels = models.flatMap((model) => {
-    const addedModels = [];
-    for (const field of model.fields || []) {
-      if (field.type === "link" && !field.slug.startsWith("ronin.")) {
-        const relatedModel = getModelBySlug(models, field.target);
-        let fieldSlug = relatedModel.slug;
-        if (field.kind === "many") {
-          fieldSlug = composeAssociationModelSlug(model, field);
-          addedModels.push({
-            pluralSlug: fieldSlug,
-            slug: fieldSlug,
-            associationSlug: field.slug,
-            fields: [
-              {
-                slug: "source",
-                type: "link",
-                target: model.slug
-              },
-              {
-                slug: "target",
-                type: "link",
-                target: relatedModel.slug
-              }
-            ]
-          });
-        }
+var ROOT_MODEL = {
+  slug: "model",
+  identifiers: {
+    name: "name",
+    slug: "slug"
+  },
+  // This name mimics the `sqlite_schema` table in SQLite.
+  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", type: "group" },
+    { slug: "identifiers.name", type: "string" },
+    { slug: "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: "{}" }
+  ]
+};
+var getSystemModels = (models, model) => {
+  const addedModels = [];
+  for (const field of model.fields || []) {
+    if (field.type === "link" && !field.slug.startsWith("ronin.")) {
+      const relatedModel = getModelBySlug(models, field.target);
+      let fieldSlug = relatedModel.slug;
+      if (field.kind === "many") {
+        fieldSlug = composeAssociationModelSlug(model, field);
+        addedModels.push({
+          pluralSlug: fieldSlug,
+          slug: fieldSlug,
+          system: {
+            model: model.slug,
+            associationSlug: field.slug
+          },
+          fields: [
+            {
+              slug: "source",
+              type: "link",
+              target: model.slug
+            },
+            {
+              slug: "target",
+              type: "link",
+              target: relatedModel.slug
+            }
+          ]
+        });
       }
     }
-    return addedModels;
-  });
-  return [...SYSTEM_MODELS, ...associativeModels, ...models];
+  }
+  return addedModels;
 };
 var addDefaultModelPresets = (list, model) => {
   const defaultPresets = [];
@@ -561,7 +567,7 @@ var addDefaultModelPresets = (list, model) => {
   for (const childMatch of childModels) {
     const { model: childModel, field: childField } = childMatch;
     const pluralSlug = childModel.pluralSlug;
-    const presetSlug = childModel.associationSlug || pluralSlug;
+    const presetSlug = childModel.system?.associationSlug || pluralSlug;
     defaultPresets.push({
       instructions: {
         including: {
@@ -617,6 +623,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")`;
@@ -641,6 +648,14 @@ var formatModelEntity = (type, entities) => {
   });
   return entries ? Object.fromEntries(entries) : void 0;
 };
+var composeSystemModelStatement = (models, dependencyStatements, action, systemModel) => {
+  const { system: _, ...systemModelClean } = systemModel;
+  const query = {
+    [action]: { model: action === "create" ? systemModelClean : systemModelClean.slug }
+  };
+  const statement = compileQueryInput(query, models, []);
+  dependencyStatements.push(...statement.dependencies);
+};
 var transformMetaQuery = (models, dependencyStatements, statementParams, query) => {
   const { queryType } = splitQuery(query);
   const subAltering = query.alter && !("to" in query.alter);
@@ -669,16 +684,16 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
     }
   }
   if (!(modelSlug && slug)) return query;
-  const tableAction = ["model", "index", "trigger"].includes(entity) ? action.toUpperCase() : "ALTER";
-  const tableName = convertToSnakeCase(pluralize(modelSlug));
   const model = action === "create" && entity === "model" ? null : getModelBySlug(models, modelSlug);
-  const statement = `${tableAction} TABLE "${tableName}"`;
   if (entity === "model") {
     let queryTypeDetails;
     if (action === "create") {
       const newModel = jsonValue;
       const modelWithFields = addDefaultModelFields(newModel, true);
-      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
+      const modelWithPresets = addDefaultModelPresets(
+        [...models, modelWithFields],
+        modelWithFields
+      );
       const entities = Object.fromEntries(
         Object.entries(PLURAL_MODEL_ENTITIES).map(([type, pluralType2]) => {
           const list = modelWithPresets[pluralType2];
@@ -687,7 +702,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       );
       const columns = modelWithPresets.fields.map((field2) => getFieldStatement(models, modelWithPresets, field2)).filter(Boolean);
       dependencyStatements.push({
-        statement: `${statement} (${columns.join(", ")})`,
+        statement: `CREATE TABLE "${modelWithPresets.table}" (${columns.join(", ")})`,
         params: []
       });
       models.push(modelWithPresets);
@@ -696,16 +711,23 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         if (entities[entity2]) finalModel[entity2] = entities[entity2];
       }
       queryTypeDetails = { to: finalModel };
+      getSystemModels(models, modelWithPresets).map((systemModel) => {
+        return composeSystemModelStatement(
+          models,
+          dependencyStatements,
+          "create",
+          systemModel
+        );
+      });
     }
     if (action === "alter" && model) {
       const newModel = jsonValue;
       const modelWithFields = addDefaultModelFields(newModel, false);
       const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
-      const newSlug = modelWithPresets.pluralSlug;
-      if (newSlug) {
-        const newTable = convertToSnakeCase(newSlug);
+      const newTableName = modelWithPresets.table;
+      if (newTableName) {
         dependencyStatements.push({
-          statement: `${statement} RENAME TO "${newTable}"`,
+          statement: `ALTER TABLE "${model.table}" RENAME TO "${newTableName}"`,
           params: []
         });
       }
@@ -719,8 +741,16 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
     }
     if (action === "drop" && model) {
       models.splice(models.indexOf(model), 1);
-      dependencyStatements.push({ statement, params: [] });
+      dependencyStatements.push({ statement: `DROP TABLE "${model.table}"`, params: [] });
       queryTypeDetails = { with: { slug } };
+      models.filter(({ system }) => system?.model === model.slug).map((systemModel) => {
+        return composeSystemModelStatement(
+          models,
+          dependencyStatements,
+          "drop",
+          systemModel
+        );
+      });
     }
     const queryTypeAction = action === "create" ? "add" : action === "alter" ? "set" : "remove";
     return {
@@ -729,14 +759,30 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       }
     };
   }
-  if (entity === "field" && 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)) {
+    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 (entity === "field") {
+    const statement = `ALTER TABLE "${existingModel.table}"`;
     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) {
@@ -746,41 +792,45 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         });
       }
     } else if (action === "drop") {
-      dependencyStatements.push({
-        statement: `${statement} DROP COLUMN "${slug}"`,
-        params: []
-      });
+      const existingField = existingEntity;
+      if (!(existingField.type === "link" && existingField.kind === "many")) {
+        dependencyStatements.push({
+          statement: `${statement} DROP COLUMN "${slug}"`,
+          params: []
+        });
+      }
     }
   }
-  if (entity === "index" && model) {
+  const statementAction = action.toUpperCase();
+  if (entity === "index") {
     const index = jsonValue;
     const indexName = convertToSnakeCase(slug);
     const params = [];
-    let statement2 = `${tableAction}${index?.unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
+    let statement = `${statementAction}${index?.unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
     if (action === "create") {
       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}`;
         return fieldSelector;
       });
-      statement2 += ` ON "${tableName}" (${columns.join(", ")})`;
+      statement += ` ON "${existingModel.table}" (${columns.join(", ")})`;
       if (index.filter) {
-        const withStatement = handleWith(models, model, params, index.filter);
-        statement2 += ` WHERE (${withStatement})`;
+        const withStatement = handleWith(models, existingModel, params, index.filter);
+        statement += ` WHERE (${withStatement})`;
       }
     }
-    dependencyStatements.push({ statement: statement2, params });
+    dependencyStatements.push({ statement, params });
   }
-  if (entity === "trigger" && model) {
+  if (entity === "trigger") {
     const triggerName = convertToSnakeCase(slug);
     const params = [];
-    let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
+    let statement = `${statementAction} TRIGGER "${triggerName}"`;
     if (action === "create") {
       const trigger = jsonValue;
       const statementParts = [`${trigger.when} ${trigger.action}`];
@@ -793,11 +843,11 @@ 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(", ")})`);
       }
-      statementParts.push("ON", `"${tableName}"`);
+      statementParts.push("ON", `"${existingModel.table}"`);
       if (trigger.filter || trigger.effects.some((query2) => findInObject(query2, RONIN_MODEL_SYMBOLS.FIELD))) {
         statementParts.push("FOR EACH ROW");
       }
@@ -805,7 +855,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,34 +864,55 @@ 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");
       statementParts.push(effectStatements.join("; "));
       if (effectStatements.length > 1) statementParts.push("END");
-      statement2 += ` ${statementParts.join(" ")}`;
+      statement += ` ${statementParts.join(" ")}`;
     }
-    dependencyStatements.push({ statement: statement2, params });
+    dependencyStatements.push({ statement, params });
   }
-  const pluralType = PLURAL_MODEL_ENTITIES[entity];
   const field = `${RONIN_MODEL_SYMBOLS.FIELD}${pluralType}`;
   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];
+      targetEntity.splice(targetEntityIndex, 1);
     }
   }
+  const currentSystemModels = models.filter(({ system }) => {
+    return system?.model === existingModel.slug;
+  });
+  const newSystemModels = getSystemModels(models, existingModel);
+  for (const systemModel of currentSystemModels) {
+    const exists = newSystemModels.find((model2) => model2.slug === systemModel.slug);
+    if (exists) continue;
+    composeSystemModelStatement(models, dependencyStatements, "drop", systemModel);
+  }
+  for (const systemModel of newSystemModels) {
+    const exists = currentSystemModels.find((model2) => model2.slug === systemModel.slug);
+    if (exists) continue;
+    composeSystemModelStatement(models, dependencyStatements, "create", systemModel);
+  }
   return {
     set: {
       model: {
@@ -1212,13 +1283,19 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
 };
 
 // src/utils/index.ts
-var compileQueryInput = (query, models, statementParams, options) => {
+var compileQueryInput = (defaultQuery, models, statementParams, options) => {
+  const dependencyStatements = [];
+  const query = transformMetaQuery(
+    models,
+    dependencyStatements,
+    statementParams,
+    defaultQuery
+  );
   const parsedQuery = splitQuery(query);
   const { queryType, queryModel, queryInstructions } = parsedQuery;
   const model = getModelBySlug(models, queryModel);
   const single = queryModel !== model.pluralSlug;
   let instructions = formatIdentifiers(model, queryInstructions);
-  const dependencyStatements = [];
   const returning = options?.returning ?? true;
   if (instructions && Object.hasOwn(instructions, "for")) {
     instructions = handleFor(model, instructions);
@@ -1370,7 +1447,11 @@ var Transaction = class {
    * @returns The composed SQL statements.
    */
   compileQueries = (queries, models, options) => {
-    const modelList = addSystemModels(models).map((model) => {
+    const modelList = [
+      ROOT_MODEL,
+      ...models.flatMap((model) => getSystemModels(models, model)),
+      ...models
+    ].map((model) => {
       return addDefaultModelFields(model, true);
     });
     const modelListWithPresets = modelList.map((model) => {
@@ -1379,17 +1460,10 @@ var Transaction = class {
     const dependencyStatements = [];
     const mainStatements = [];
     for (const query of queries) {
-      const statementValues = options?.inlineParams ? null : [];
-      const transformedQuery = transformMetaQuery(
-        modelListWithPresets,
-        dependencyStatements,
-        statementValues,
-        query
-      );
       const result = compileQueryInput(
-        transformedQuery,
+        query,
         modelListWithPresets,
-        statementValues
+        options?.inlineParams ? null : []
       );
       dependencyStatements.push(...result.dependencies);
       mainStatements.push(result.main);

package/package.json

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