@ronin/compiler 0.8.4 → 0.8.5

package/dist/index.js

@@ -318,151 +318,6 @@ var handleWith = (models, model, statementParams, instruction, parentModel) => {
   return `(${subStatement})`;
 };
 
-// src/utils/meta.ts
-var PLURAL_MODEL_ENTITIES = {
-  field: "fields",
-  index: "indexes",
-  trigger: "triggers",
-  preset: "presets"
-};
-var transformMetaQuery = (models, dependencyStatements, statementParams, query) => {
-  if (query.create) {
-    const init = query.create.model;
-    const details = "to" in query.create ? { slug: init, ...query.create.to } : init;
-    const modelWithFields = addDefaultModelFields(details, true);
-    const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
-    const instructions = {
-      to: modelWithPresets
-    };
-    addModelQueries(models, dependencyStatements, {
-      queryType: "add",
-      queryModel: "model",
-      queryInstructions: instructions
-    });
-    return {
-      add: {
-        model: instructions
-      }
-    };
-  }
-  if (query.drop) {
-    const slug = query.drop.model;
-    const instructions = {
-      with: { slug }
-    };
-    addModelQueries(models, dependencyStatements, {
-      queryType: "remove",
-      queryModel: "model",
-      queryInstructions: instructions
-    });
-    return {
-      remove: {
-        model: instructions
-      }
-    };
-  }
-  if (query.alter) {
-    const slug = query.alter.model;
-    if ("to" in query.alter) {
-      const modelWithFields = addDefaultModelFields(query.alter.to, false);
-      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
-      const instructions = {
-        with: { slug },
-        to: modelWithPresets
-      };
-      addModelQueries(models, dependencyStatements, {
-        queryType: "set",
-        queryModel: "model",
-        queryInstructions: instructions
-      });
-      return {
-        set: {
-          model: instructions
-        }
-      };
-    }
-    if ("create" in query.alter) {
-      const type2 = Object.keys(query.alter.create)[0];
-      const pluralType2 = PLURAL_MODEL_ENTITIES[type2];
-      const item = query.alter.create[type2];
-      const completeItem = { slug: item.slug || `${type2}Slug`, ...item };
-      addModelQueries(models, dependencyStatements, {
-        queryType: "add",
-        queryModel: type2,
-        queryInstructions: {
-          to: {
-            model: { slug },
-            ...completeItem
-          }
-        }
-      });
-      const value = prepareStatementValue(statementParams, completeItem);
-      const json2 = `json_insert(${RONIN_MODEL_SYMBOLS.FIELD}${pluralType2}, '$.${completeItem.slug}', ${value})`;
-      const expression2 = { [RONIN_MODEL_SYMBOLS.EXPRESSION]: json2 };
-      return {
-        set: {
-          model: {
-            with: { slug },
-            to: {
-              [pluralType2]: expression2
-            }
-          }
-        }
-      };
-    }
-    if ("alter" in query.alter) {
-      const type2 = Object.keys(query.alter.alter)[0];
-      const pluralType2 = PLURAL_MODEL_ENTITIES[type2];
-      const itemSlug2 = query.alter.alter[type2];
-      const newItem = query.alter.alter.to;
-      addModelQueries(models, dependencyStatements, {
-        queryType: "set",
-        queryModel: type2,
-        queryInstructions: {
-          with: { model: { slug }, slug: itemSlug2 },
-          to: newItem
-        }
-      });
-      const value = prepareStatementValue(statementParams, newItem);
-      const json2 = `json_patch(${RONIN_MODEL_SYMBOLS.FIELD}${pluralType2}, '$.${itemSlug2}', ${value})`;
-      const expression2 = { [RONIN_MODEL_SYMBOLS.EXPRESSION]: json2 };
-      return {
-        set: {
-          model: {
-            with: { slug },
-            to: {
-              [pluralType2]: expression2
-            }
-          }
-        }
-      };
-    }
-    const type = Object.keys(query.alter.drop)[0];
-    const pluralType = PLURAL_MODEL_ENTITIES[type];
-    const itemSlug = query.alter.drop[type];
-    addModelQueries(models, dependencyStatements, {
-      queryType: "remove",
-      queryModel: type,
-      queryInstructions: {
-        with: { model: { slug }, slug: itemSlug }
-      }
-    });
-    const json = `json_insert(${RONIN_MODEL_SYMBOLS.FIELD}${pluralType}, '$.${itemSlug}')`;
-    const expression = { [RONIN_MODEL_SYMBOLS.EXPRESSION]: json };
-    return {
-      set: {
-        model: {
-          with: { slug },
-          to: {
-            [pluralType]: expression
-          }
-        }
-      }
-    };
-  }
-  return query;
-};
-
 // src/utils/model.ts
 import title from "title";
 var getModelBySlug = (models, slug) => {
@@ -733,9 +588,9 @@ var addDefaultModelPresets = (list, model) => {
   return model;
 };
 var mappedInstructions = {
-  add: "to",
-  set: "with",
-  remove: "with"
+  create: "to",
+  alter: "with",
+  drop: "with"
 };
 var typesInSQLite = {
   link: "TEXT",
@@ -777,49 +632,179 @@ var getFieldStatement = (models, model, field) => {
   }
   return statement;
 };
-var addModelQueries = (models, dependencyStatements, queryDetails) => {
-  const { queryType, queryModel, queryInstructions } = queryDetails;
-  if (!["add", "set", "remove"].includes(queryType)) return;
-  if (!["model", "field", "index", "trigger", "preset"].includes(queryModel)) return;
-  const instructionName = mappedInstructions[queryType];
+var PLURAL_MODEL_ENTITIES = {
+  field: "fields",
+  index: "indexes",
+  trigger: "triggers",
+  preset: "presets"
+};
+var transformMetaQuery = (models, dependencyStatements, statementParams, query) => {
+  const { queryType } = splitQuery(query);
+  let action = queryType;
+  let entity = "model";
+  let queryInstructions;
+  if (query.create) {
+    const init = query.create.model;
+    const details = "to" in query.create ? { slug: init, ...query.create.to } : init;
+    queryInstructions = {
+      to: details
+    };
+  }
+  if (query.drop) {
+    queryInstructions = {
+      with: { slug: query.drop.model }
+    };
+  }
+  if (query.alter) {
+    const modelSlugTest = query.alter.model;
+    if ("to" in query.alter) {
+      queryInstructions = {
+        with: { slug: modelSlugTest },
+        to: query.alter.to
+      };
+    } else {
+      action = Object.keys(query.alter).filter(
+        (key) => key !== "model"
+      )[0];
+      const details = query.alter[action];
+      entity = Object.keys(details)[0];
+      let jsonSlug = details[entity];
+      let jsonValue2;
+      if ("create" in query.alter) {
+        const item = query.alter.create[entity];
+        jsonSlug = item.slug || `${entity}Slug`;
+        jsonValue2 = { slug: jsonSlug, ...item };
+        queryInstructions = {
+          to: {
+            model: { slug: modelSlugTest },
+            ...jsonValue2
+          }
+        };
+      }
+      if ("alter" in query.alter) {
+        jsonValue2 = query.alter.alter.to;
+        queryInstructions = {
+          with: { model: { slug: modelSlugTest }, slug: jsonSlug },
+          to: jsonValue2
+        };
+      }
+      if ("drop" in query.alter) {
+        queryInstructions = {
+          with: { model: { slug: modelSlugTest }, slug: jsonSlug }
+        };
+      }
+    }
+  }
+  if (!queryInstructions) return query;
+  const instructionName = mappedInstructions[action];
   const instructionList = queryInstructions[instructionName];
   let tableAction = "ALTER";
-  let queryTypeReadable = null;
-  switch (queryType) {
-    case "add": {
-      if (queryModel === "model" || queryModel === "index" || queryModel === "trigger") {
+  let actionReadable = null;
+  switch (action) {
+    case "create": {
+      if (entity === "model" || entity === "index" || entity === "trigger") {
         tableAction = "CREATE";
       }
-      queryTypeReadable = "creating";
+      actionReadable = "creating";
       break;
     }
-    case "set": {
-      if (queryModel === "model") tableAction = "ALTER";
-      queryTypeReadable = "updating";
+    case "alter": {
+      if (entity === "model") tableAction = "ALTER";
+      actionReadable = "updating";
       break;
     }
-    case "remove": {
-      if (queryModel === "model" || queryModel === "index" || queryModel === "trigger") {
+    case "drop": {
+      if (entity === "model" || entity === "index" || entity === "trigger") {
         tableAction = "DROP";
       }
-      queryTypeReadable = "deleting";
+      actionReadable = "deleting";
       break;
     }
   }
   const slug = instructionList?.slug?.being || instructionList?.slug;
   const modelInstruction = instructionList?.model;
   const modelSlug = modelInstruction?.slug?.being || modelInstruction?.slug;
-  const usableSlug = queryModel === "model" ? slug : modelSlug;
+  const usableSlug = entity === "model" ? slug : modelSlug;
   const tableName = convertToSnakeCase(pluralize(usableSlug));
-  const targetModel = queryModel === "model" && queryType === "add" ? null : getModelBySlug(models, usableSlug);
-  if (queryModel === "index") {
+  const targetModel = entity === "model" && action === "create" ? null : getModelBySlug(models, usableSlug);
+  const statement = `${tableAction} TABLE "${tableName}"`;
+  if (entity === "model") {
+    let queryTypeDetails;
+    if (action === "create") {
+      const modelWithFields = addDefaultModelFields(queryInstructions.to, true);
+      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
+      const { fields } = modelWithPresets;
+      const columns = fields.map((field) => getFieldStatement(models, modelWithPresets, field)).filter(Boolean);
+      dependencyStatements.push({
+        statement: `${statement} (${columns.join(", ")})`,
+        params: []
+      });
+      models.push(modelWithPresets);
+      queryTypeDetails = { to: modelWithPresets };
+    }
+    if (action === "alter") {
+      const modelWithFields = addDefaultModelFields(queryInstructions.to, false);
+      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
+      const newSlug = modelWithPresets.pluralSlug;
+      if (newSlug) {
+        const newTable = convertToSnakeCase(newSlug);
+        dependencyStatements.push({
+          statement: `${statement} RENAME TO "${newTable}"`,
+          params: []
+        });
+      }
+      Object.assign(targetModel, modelWithPresets);
+      queryTypeDetails = {
+        with: {
+          slug: usableSlug
+        },
+        to: modelWithPresets
+      };
+    }
+    if (action === "drop") {
+      models.splice(models.indexOf(targetModel), 1);
+      dependencyStatements.push({ statement, params: [] });
+      queryTypeDetails = {
+        with: { slug: usableSlug }
+      };
+    }
+    const queryTypeAction = action === "create" ? "add" : action === "alter" ? "set" : "remove";
+    return {
+      [queryTypeAction]: {
+        model: queryTypeDetails
+      }
+    };
+  }
+  if (entity === "field") {
+    if (action === "create") {
+      if (!instructionList.type) instructionList.type = "string";
+      dependencyStatements.push({
+        statement: `${statement} ADD COLUMN ${getFieldStatement(models, targetModel, instructionList)}`,
+        params: []
+      });
+    } else if (action === "alter") {
+      const newSlug = queryInstructions.to?.slug;
+      if (newSlug) {
+        dependencyStatements.push({
+          statement: `${statement} RENAME COLUMN "${slug}" TO "${newSlug}"`,
+          params: []
+        });
+      }
+    } else if (action === "drop") {
+      dependencyStatements.push({
+        statement: `${statement} DROP COLUMN "${slug}"`,
+        params: []
+      });
+    }
+  }
+  if (entity === "index") {
     const indexName = convertToSnakeCase(slug);
     const unique = instructionList?.unique;
     const filterQuery = instructionList?.filter;
     const fields = instructionList?.fields;
     const params = [];
     let statement2 = `${tableAction}${unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
-    if (queryType === "add") {
+    if (action === "create") {
       const model = targetModel;
       const columns = fields.map((field) => {
         let fieldSelector = "";
@@ -844,23 +829,22 @@ var addModelQueries = (models, dependencyStatements, queryDetails) => {
       }
     }
     dependencyStatements.push({ statement: statement2, params });
-    return;
   }
-  if (queryModel === "trigger") {
+  if (entity === "trigger") {
     const triggerName = convertToSnakeCase(slug);
     const params = [];
     let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
-    if (queryType === "add") {
+    if (action === "create") {
       const currentModel = targetModel;
-      const { when, action } = instructionList;
-      const statementParts = [`${when} ${action}`];
+      const { when, action: action2 } = instructionList;
+      const statementParts = [`${when} ${action2}`];
       const effectQueries = instructionList?.effects;
       const filterQuery = instructionList?.filter;
       const fields = instructionList?.fields;
       if (fields) {
-        if (action !== "UPDATE") {
+        if (action2 !== "UPDATE") {
           throw new RoninError({
-            message: `When ${queryTypeReadable} ${PLURAL_MODEL_ENTITIES[queryModel]}, targeting specific fields requires the \`UPDATE\` action.`,
+            message: `When ${actionReadable} ${PLURAL_MODEL_ENTITIES[entity]}, targeting specific fields requires the \`UPDATE\` action.`,
             code: "INVALID_MODEL_VALUE",
             fields: ["action"]
           });
@@ -871,11 +855,11 @@ var addModelQueries = (models, dependencyStatements, queryDetails) => {
         statementParts.push(`OF (${fieldSelectors.join(", ")})`);
       }
       statementParts.push("ON", `"${tableName}"`);
-      if (filterQuery || effectQueries.some((query) => findInObject(query, RONIN_MODEL_SYMBOLS.FIELD))) {
+      if (filterQuery || effectQueries.some((query2) => findInObject(query2, RONIN_MODEL_SYMBOLS.FIELD))) {
         statementParts.push("FOR EACH ROW");
       }
       if (filterQuery) {
-        const tableAlias = action === "DELETE" ? RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD : RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
+        const tableAlias = action2 === "DELETE" ? RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD : RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
         const withStatement = handleWith(
           models,
           { ...currentModel, tableAlias },
@@ -896,57 +880,23 @@ var addModelQueries = (models, dependencyStatements, queryDetails) => {
       statement2 += ` ${statementParts.join(" ")}`;
     }
     dependencyStatements.push({ statement: statement2, params });
-    return;
-  }
-  const statement = `${tableAction} TABLE "${tableName}"`;
-  if (queryModel === "model") {
-    if (queryType === "add") {
-      const newModel = queryInstructions.to;
-      const { fields } = newModel;
-      const columns = fields.map((field) => getFieldStatement(models, newModel, field)).filter(Boolean);
-      dependencyStatements.push({
-        statement: `${statement} (${columns.join(", ")})`,
-        params: []
-      });
-      models.push(newModel);
-    } else if (queryType === "set") {
-      const newSlug = queryInstructions.to?.pluralSlug;
-      if (newSlug) {
-        const newTable = convertToSnakeCase(newSlug);
-        dependencyStatements.push({
-          statement: `${statement} RENAME TO "${newTable}"`,
-          params: []
-        });
-      }
-      Object.assign(targetModel, queryInstructions.to);
-    } else if (queryType === "remove") {
-      models.splice(models.indexOf(targetModel), 1);
-      dependencyStatements.push({ statement, params: [] });
-    }
-    return;
   }
-  if (queryModel === "field") {
-    if (queryType === "add") {
-      if (!instructionList.type) instructionList.type = "string";
-      dependencyStatements.push({
-        statement: `${statement} ADD COLUMN ${getFieldStatement(models, targetModel, instructionList)}`,
-        params: []
-      });
-    } else if (queryType === "set") {
-      const newSlug = queryInstructions.to?.slug;
-      if (newSlug) {
-        dependencyStatements.push({
-          statement: `${statement} RENAME COLUMN "${slug}" TO "${newSlug}"`,
-          params: []
-        });
+  const pluralType = PLURAL_MODEL_ENTITIES[entity];
+  const jsonAction = action === "create" ? "insert" : action === "alter" ? "patch" : "remove";
+  const jsonValue = action === "create" ? { ...instructionList, model: void 0 } : action === "alter" ? queryInstructions.to : null;
+  let json = `json_${jsonAction}(${RONIN_MODEL_SYMBOLS.FIELD}${pluralType}, '$.${slug}'`;
+  if (jsonValue) json += `, ${prepareStatementValue(statementParams, jsonValue)}`;
+  json += ")";
+  return {
+    set: {
+      model: {
+        with: { slug: usableSlug },
+        to: {
+          [pluralType]: { [RONIN_MODEL_SYMBOLS.EXPRESSION]: json }
+        }
       }
-    } else if (queryType === "remove") {
-      dependencyStatements.push({
-        statement: `${statement} DROP COLUMN "${slug}"`,
-        params: []
-      });
     }
-  }
+  };
 };
 
 // src/instructions/before-after.ts

package/package.json

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