@ronin/compiler 0.8.5 → 0.8.7

package/dist/index.d.ts

@@ -5985,4 +5985,4 @@ declare const compileQueries: (queries: Array<Query>, models: Array<PublicModel>
     inlineParams?: boolean;
 }) => Array<Statement>;
 
-export { type PublicModel as Model, type ModelField, type ModelIndex, type ModelTrigger, type Query, type Statement, compileQueries };
+export { type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, type Query, type Statement, compileQueries };

package/dist/index.js

@@ -587,11 +587,6 @@ var addDefaultModelPresets = (list, model) => {
   }
   return model;
 };
-var mappedInstructions = {
-  create: "to",
-  alter: "with",
-  drop: "with"
-};
 var typesInSQLite = {
   link: "TEXT",
   string: "TEXT",
@@ -638,112 +633,72 @@ var PLURAL_MODEL_ENTITIES = {
   trigger: "triggers",
   preset: "presets"
 };
+var formatModelEntity = (type, entities) => {
+  const entries = entities?.map((entity) => {
+    const { slug, ...rest } = "slug" in entity ? entity : { slug: `${type}Slug`, ...entity };
+    return [slug, rest];
+  });
+  return entries ? Object.fromEntries(entries) : void 0;
+};
 var transformMetaQuery = (models, dependencyStatements, statementParams, query) => {
   const { queryType } = splitQuery(query);
-  let action = queryType;
-  let entity = "model";
-  let queryInstructions;
+  const subAltering = query.alter && !("to" in query.alter);
+  const action = subAltering && query.alter ? Object.keys(query.alter).filter((key) => key !== "model")[0] : queryType;
+  const actionReadable = action === "create" ? "creating" : action === "alter" ? "altering" : "dropping";
+  const entity = subAltering && query.alter ? Object.keys(query.alter[action])[0] : "model";
+  let slug = entity === "model" && action === "create" ? null : query[queryType].model;
+  let modelSlug = slug;
+  let jsonValue;
   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 }
-    };
+    jsonValue = "to" in query.create ? { slug: init, ...query.create.to } : init;
+    slug = modelSlug = jsonValue.slug;
   }
   if (query.alter) {
-    const modelSlugTest = query.alter.model;
     if ("to" in query.alter) {
-      queryInstructions = {
-        with: { slug: modelSlugTest },
-        to: query.alter.to
-      };
+      jsonValue = 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;
+      slug = query.alter[action][entity];
       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 }
-        };
+        slug = item.slug || `${entity}Slug`;
+        jsonValue = { slug, ...item };
       }
+      if ("alter" in query.alter) jsonValue = query.alter.alter.to;
     }
   }
-  if (!queryInstructions) return query;
-  const instructionName = mappedInstructions[action];
-  const instructionList = queryInstructions[instructionName];
-  let tableAction = "ALTER";
-  let actionReadable = null;
-  switch (action) {
-    case "create": {
-      if (entity === "model" || entity === "index" || entity === "trigger") {
-        tableAction = "CREATE";
-      }
-      actionReadable = "creating";
-      break;
-    }
-    case "alter": {
-      if (entity === "model") tableAction = "ALTER";
-      actionReadable = "updating";
-      break;
-    }
-    case "drop": {
-      if (entity === "model" || entity === "index" || entity === "trigger") {
-        tableAction = "DROP";
-      }
-      actionReadable = "deleting";
-      break;
-    }
-  }
-  const slug = instructionList?.slug?.being || instructionList?.slug;
-  const modelInstruction = instructionList?.model;
-  const modelSlug = modelInstruction?.slug?.being || modelInstruction?.slug;
-  const usableSlug = entity === "model" ? slug : modelSlug;
-  const tableName = convertToSnakeCase(pluralize(usableSlug));
-  const targetModel = entity === "model" && action === "create" ? null : getModelBySlug(models, usableSlug);
+  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 modelWithFields = addDefaultModelFields(queryInstructions.to, true);
+      const newModel = jsonValue;
+      const modelWithFields = addDefaultModelFields(newModel, true);
       const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
-      const { fields } = modelWithPresets;
-      const columns = fields.map((field) => getFieldStatement(models, modelWithPresets, field)).filter(Boolean);
+      const entities = Object.fromEntries(
+        Object.entries(PLURAL_MODEL_ENTITIES).map(([type, pluralType2]) => {
+          const list = modelWithPresets[pluralType2];
+          return [pluralType2, formatModelEntity(type, list)];
+        })
+      );
+      const columns = modelWithPresets.fields.map((field) => getFieldStatement(models, modelWithPresets, field)).filter(Boolean);
       dependencyStatements.push({
         statement: `${statement} (${columns.join(", ")})`,
         params: []
       });
       models.push(modelWithPresets);
-      queryTypeDetails = { to: modelWithPresets };
+      const finalModel = Object.assign({}, modelWithPresets);
+      for (const entity2 in entities) {
+        if (entities[entity2]) finalModel[entity2] = entities[entity2];
+      }
+      queryTypeDetails = { to: finalModel };
     }
-    if (action === "alter") {
-      const modelWithFields = addDefaultModelFields(queryInstructions.to, false);
+    if (action === "alter" && model) {
+      const newModel = jsonValue;
+      const modelWithFields = addDefaultModelFields(newModel, false);
       const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
       const newSlug = modelWithPresets.pluralSlug;
       if (newSlug) {
@@ -753,20 +708,18 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
           params: []
         });
       }
-      Object.assign(targetModel, modelWithPresets);
+      Object.assign(model, modelWithPresets);
       queryTypeDetails = {
         with: {
-          slug: usableSlug
+          slug
         },
         to: modelWithPresets
       };
     }
-    if (action === "drop") {
-      models.splice(models.indexOf(targetModel), 1);
+    if (action === "drop" && model) {
+      models.splice(models.indexOf(model), 1);
       dependencyStatements.push({ statement, params: [] });
-      queryTypeDetails = {
-        with: { slug: usableSlug }
-      };
+      queryTypeDetails = { with: { slug } };
     }
     const queryTypeAction = action === "create" ? "add" : action === "alter" ? "set" : "remove";
     return {
@@ -775,15 +728,16 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       }
     };
   }
-  if (entity === "field") {
+  if (entity === "field" && model) {
     if (action === "create") {
-      if (!instructionList.type) instructionList.type = "string";
+      const field = jsonValue;
+      field.type = field.type || "string";
       dependencyStatements.push({
-        statement: `${statement} ADD COLUMN ${getFieldStatement(models, targetModel, instructionList)}`,
+        statement: `${statement} ADD COLUMN ${getFieldStatement(models, model, field)}`,
         params: []
       });
     } else if (action === "alter") {
-      const newSlug = queryInstructions.to?.slug;
+      const newSlug = jsonValue?.slug;
       if (newSlug) {
         dependencyStatements.push({
           statement: `${statement} RENAME COLUMN "${slug}" TO "${newSlug}"`,
@@ -797,81 +751,69 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
       });
     }
   }
-  if (entity === "index") {
+  if (entity === "index" && model) {
+    const index = jsonValue;
     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}"`;
+    let statement2 = `${tableAction}${index?.unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
     if (action === "create") {
-      const model = targetModel;
-      const columns = fields.map((field) => {
+      const columns = index.fields.map((field) => {
         let fieldSelector = "";
         if ("slug" in field) {
           ({ fieldSelector } = getFieldFromModel(model, field.slug, "to"));
         } else if ("expression" in field) {
-          fieldSelector = parseFieldExpression(model, "to", field.expression, model);
+          fieldSelector = parseFieldExpression(model, "to", field.expression);
         }
         if (field.collation) fieldSelector += ` COLLATE ${field.collation}`;
         if (field.order) fieldSelector += ` ${field.order}`;
         return fieldSelector;
       });
       statement2 += ` ON "${tableName}" (${columns.join(", ")})`;
-      if (filterQuery) {
-        const withStatement = handleWith(
-          models,
-          targetModel,
-          params,
-          filterQuery
-        );
+      if (index.filter) {
+        const withStatement = handleWith(models, model, params, index.filter);
         statement2 += ` WHERE (${withStatement})`;
       }
     }
     dependencyStatements.push({ statement: statement2, params });
   }
-  if (entity === "trigger") {
+  if (entity === "trigger" && model) {
     const triggerName = convertToSnakeCase(slug);
     const params = [];
     let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
     if (action === "create") {
-      const currentModel = targetModel;
-      const { when, action: action2 } = instructionList;
-      const statementParts = [`${when} ${action2}`];
-      const effectQueries = instructionList?.effects;
-      const filterQuery = instructionList?.filter;
-      const fields = instructionList?.fields;
-      if (fields) {
-        if (action2 !== "UPDATE") {
+      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 = fields.map((field) => {
-          return getFieldFromModel(currentModel, field.slug, "to").fieldSelector;
+        const fieldSelectors = trigger.fields.map((field) => {
+          return getFieldFromModel(model, field.slug, "to").fieldSelector;
         });
         statementParts.push(`OF (${fieldSelectors.join(", ")})`);
       }
       statementParts.push("ON", `"${tableName}"`);
-      if (filterQuery || effectQueries.some((query2) => findInObject(query2, RONIN_MODEL_SYMBOLS.FIELD))) {
+      if (trigger.filter || trigger.effects.some((query2) => findInObject(query2, RONIN_MODEL_SYMBOLS.FIELD))) {
         statementParts.push("FOR EACH ROW");
       }
-      if (filterQuery) {
-        const tableAlias = action2 === "DELETE" ? RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD : RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
+      if (trigger.filter) {
+        const tableAlias = trigger.action === "DELETE" ? RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD : RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
         const withStatement = handleWith(
           models,
-          { ...currentModel, tableAlias },
+          { ...model, tableAlias },
           params,
-          filterQuery
+          trigger.filter
         );
         statementParts.push("WHEN", `(${withStatement})`);
       }
-      const effectStatements = effectQueries.map((effectQuery) => {
+      const effectStatements = trigger.effects.map((effectQuery) => {
         return compileQueryInput(effectQuery, models, params, {
           returning: false,
-          parentModel: currentModel
+          parentModel: model
         }).main.statement;
       });
       if (effectStatements.length > 1) statementParts.push("BEGIN");
@@ -883,14 +825,13 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
   }
   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 },
+        with: { slug: modelSlug },
         to: {
           [pluralType]: { [RONIN_MODEL_SYMBOLS.EXPRESSION]: json }
         }

package/package.json

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