@ronin/compiler 0.2.2 → 0.3.0

package/dist/index.js

@@ -1,8 +1,15 @@
 // src/utils/index.ts
 import { init as cuid } from "@paralleldrive/cuid2";
 var RONIN_SCHEMA_SYMBOLS = {
+  // Represents a sub query.
   QUERY: "__RONIN_QUERY",
+  // Represents the value of a field in a schema.
   FIELD: "__RONIN_FIELD_",
+  // Represents the old value of a field in a schema. Used for triggers.
+  FIELD_OLD: "__RONIN_FIELD_OLD_",
+  // Represents the new value of a field in a schema. Used for triggers.
+  FIELD_NEW: "__RONIN_FIELD_NEW_",
+  // Represents a value provided to a query preset.
   VALUE: "__RONIN_VALUE"
 };
 var RoninError = class extends Error {
@@ -44,15 +51,22 @@ var convertToCamelCase = (str) => {
   return sanitize(str).split(SPLIT_REGEX).map((part, index) => index === 0 ? part.toLowerCase() : capitalize(part)).join("");
 };
 var isObject = (value) => value != null && typeof value === "object" && Array.isArray(value) === false;
-var replaceInObject = (obj, pattern, replacer) => {
+var findInObject = (obj, pattern, replacer) => {
+  let found = false;
   for (const key in obj) {
     const value = obj[key];
     if (isObject(value)) {
-      replaceInObject(value, pattern, replacer);
+      found = findInObject(value, pattern, replacer);
     } else if (typeof value === "string" && value.startsWith(pattern)) {
-      obj[key] = value.replace(pattern, replacer);
+      found = true;
+      if (replacer) {
+        obj[key] = value.replace(pattern, replacer);
+      } else {
+        return found;
+      }
     }
   }
+  return found;
 };
 var flatten = (obj, prefix = "", res = {}) => {
   for (const key in obj) {
@@ -81,6 +95,209 @@ var splitQuery = (query) => {
   return { queryType, querySchema, queryInstructions };
 };
 
+// src/utils/statement.ts
+var prepareStatementValue = (statementValues, value, bindNull = false) => {
+  if (!bindNull && value === null) return "NULL";
+  let formattedValue = value;
+  if (Array.isArray(value) || isObject(value)) {
+    formattedValue = JSON.stringify(value);
+  } else if (typeof value === "boolean") {
+    formattedValue = value ? 1 : 0;
+  }
+  const index = statementValues.push(formattedValue);
+  return `?${index}`;
+};
+var composeFieldValues = (schemas, schema, statementValues, instructionName, value, options) => {
+  const { field: schemaField, fieldSelector: selector } = getFieldFromSchema(
+    schema,
+    options.fieldSlug,
+    instructionName,
+    options.rootTable
+  );
+  const isSubQuery = isObject(value) && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY);
+  const collectStatementValue = options.type !== "fields";
+  let conditionSelector = selector;
+  let conditionValue = value;
+  if (isSubQuery && collectStatementValue) {
+    conditionValue = `(${compileQueryInput(
+      value[RONIN_SCHEMA_SYMBOLS.QUERY],
+      schemas,
+      { statementValues }
+    ).readStatement})`;
+  } else if (typeof value === "string" && value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD)) {
+    let targetTable = `"${options.rootTable}"`;
+    let toReplace = RONIN_SCHEMA_SYMBOLS.FIELD;
+    if (value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD_OLD)) {
+      targetTable = "OLD";
+      toReplace = RONIN_SCHEMA_SYMBOLS.FIELD_OLD;
+    } else if (value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD_NEW)) {
+      targetTable = "NEW";
+      toReplace = RONIN_SCHEMA_SYMBOLS.FIELD_NEW;
+    }
+    conditionSelector = `${options.customTable ? `"${options.customTable}".` : ""}"${schemaField.slug}"`;
+    conditionValue = `${targetTable}."${value.replace(toReplace, "")}"`;
+  } else if (schemaField.type === "json" && instructionName === "to") {
+    conditionSelector = `"${schemaField.slug}"`;
+    if (collectStatementValue) {
+      const preparedValue = prepareStatementValue(statementValues, value, false);
+      conditionValue = `IIF(${conditionSelector} IS NULL, ${preparedValue}, json_patch(${conditionSelector}, ${preparedValue}))`;
+    }
+  } else if (collectStatementValue) {
+    conditionValue = prepareStatementValue(statementValues, value, false);
+  }
+  if (options.type === "fields") return conditionSelector;
+  if (options.type === "values") return conditionValue;
+  return `${conditionSelector} ${WITH_CONDITIONS[options.condition || "being"](conditionValue, value)}`;
+};
+var composeConditions = (schemas, schema, statementValues, instructionName, value, options) => {
+  const isNested = isObject(value) && Object.keys(value).length > 0;
+  if (isNested && Object.keys(value).every((key) => key in WITH_CONDITIONS)) {
+    const conditions = Object.entries(value).map(
+      ([conditionType, checkValue]) => composeConditions(schemas, schema, statementValues, instructionName, checkValue, {
+        ...options,
+        condition: conditionType
+      })
+    );
+    return conditions.join(" AND ");
+  }
+  if (options.fieldSlug) {
+    const fieldDetails = getFieldFromSchema(
+      schema,
+      options.fieldSlug,
+      instructionName,
+      options.rootTable
+    );
+    const { field: schemaField } = fieldDetails;
+    const consumeJSON = schemaField.type === "json" && instructionName === "to";
+    const isSubQuery = isNested && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY);
+    if (!(isObject(value) || Array.isArray(value)) || isSubQuery || consumeJSON) {
+      return composeFieldValues(
+        schemas,
+        schema,
+        statementValues,
+        instructionName,
+        value,
+        { ...options, fieldSlug: options.fieldSlug }
+      );
+    }
+    if (schemaField.type === "reference" && isNested) {
+      const keys = Object.keys(value);
+      const values = Object.values(value);
+      let recordTarget;
+      if (keys.length === 1 && keys[0] === "id") {
+        recordTarget = values[0];
+      } else {
+        const relatedSchema = getSchemaBySlug(schemas, schemaField.target.slug);
+        const subQuery = {
+          get: {
+            [relatedSchema.slug]: {
+              with: value,
+              selecting: ["id"]
+            }
+          }
+        };
+        recordTarget = {
+          [RONIN_SCHEMA_SYMBOLS.QUERY]: subQuery
+        };
+      }
+      return composeConditions(
+        schemas,
+        schema,
+        statementValues,
+        instructionName,
+        recordTarget,
+        options
+      );
+    }
+  }
+  if (isNested) {
+    const conditions = Object.entries(value).map(([field, value2]) => {
+      const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
+      return composeConditions(schemas, schema, statementValues, instructionName, value2, {
+        ...options,
+        fieldSlug: nestedFieldSlug
+      });
+    });
+    const joiner = instructionName === "to" ? ", " : " AND ";
+    if (instructionName === "to") return `${conditions.join(joiner)}`;
+    return conditions.length === 1 ? conditions[0] : options.fieldSlug ? `(${conditions.join(joiner)})` : conditions.join(joiner);
+  }
+  if (Array.isArray(value)) {
+    const conditions = value.map(
+      (filter) => composeConditions(
+        schemas,
+        schema,
+        statementValues,
+        instructionName,
+        filter,
+        options
+      )
+    );
+    return conditions.join(" OR ");
+  }
+  throw new RoninError({
+    message: `The \`with\` instruction must not contain an empty field. The following fields are empty: \`${options.fieldSlug}\`. If you meant to query by an empty field, try using \`null\` instead.`,
+    code: "INVALID_WITH_VALUE",
+    queries: null
+  });
+};
+var formatIdentifiers = ({ identifiers }, queryInstructions) => {
+  if (!queryInstructions) return queryInstructions;
+  const type = "with" in queryInstructions ? "with" : null;
+  if (!type) return queryInstructions;
+  const nestedInstructions = queryInstructions[type];
+  if (!nestedInstructions || Array.isArray(nestedInstructions))
+    return queryInstructions;
+  const newNestedInstructions = { ...nestedInstructions };
+  for (const oldKey of Object.keys(newNestedInstructions)) {
+    if (oldKey !== "titleIdentifier" && oldKey !== "slugIdentifier") continue;
+    const identifierName = oldKey === "titleIdentifier" ? "title" : "slug";
+    const value = newNestedInstructions[oldKey];
+    const newKey = identifiers?.[identifierName] || "id";
+    newNestedInstructions[newKey] = value;
+    delete newNestedInstructions[oldKey];
+  }
+  return {
+    ...queryInstructions,
+    [type]: newNestedInstructions
+  };
+};
+
+// src/instructions/with.ts
+var getMatcher = (value, negative) => {
+  if (negative) {
+    if (value === null) return "IS NOT";
+    return "!=";
+  }
+  if (value === null) return "IS";
+  return "=";
+};
+var WITH_CONDITIONS = {
+  being: (value, baseValue) => `${getMatcher(baseValue, false)} ${value}`,
+  notBeing: (value, baseValue) => `${getMatcher(baseValue, true)} ${value}`,
+  startingWith: (value) => `LIKE ${value}%`,
+  notStartingWith: (value) => `NOT LIKE ${value}%`,
+  endingWith: (value) => `LIKE %${value}`,
+  notEndingWith: (value) => `NOT LIKE %${value}`,
+  containing: (value) => `LIKE %${value}%`,
+  notContaining: (value) => `NOT LIKE %${value}%`,
+  greaterThan: (value) => `> ${value}`,
+  greaterOrEqual: (value) => `>= ${value}`,
+  lessThan: (value) => `< ${value}`,
+  lessOrEqual: (value) => `<= ${value}`
+};
+var handleWith = (schemas, schema, statementValues, instruction, rootTable) => {
+  const subStatement = composeConditions(
+    schemas,
+    schema,
+    statementValues,
+    "with",
+    instruction,
+    { rootTable }
+  );
+  return `(${subStatement})`;
+};
+
 // src/utils/schema.ts
 import title from "title";
 var getSchemaBySlug = (schemas, slug) => {
@@ -101,7 +318,8 @@ var getTableForSchema = (schema) => {
 var composeMetaSchemaSlug = (suffix) => convertToCamelCase(`ronin_${suffix}`);
 var composeAssociationSchemaSlug = (schema, field) => composeMetaSchemaSlug(`${schema.pluralSlug}_${field.slug}`);
 var getFieldSelector = (field, fieldPath, rootTable) => {
-  const tablePrefix = rootTable ? `"${rootTable}".` : "";
+  const symbol = rootTable?.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD) ? `${rootTable.replace(RONIN_SCHEMA_SYMBOLS.FIELD, "").slice(0, -1)}.` : "";
+  const tablePrefix = symbol || (rootTable ? `"${rootTable}".` : "");
   if (field.type === "json") {
     const dotParts = fieldPath.split(".");
     const columnName = tablePrefix + dotParts.shift();
@@ -234,6 +452,20 @@ var SYSTEM_SCHEMAS = [
       { slug: "unique", type: "boolean" },
       { slug: "filter", type: "json" }
     ]
+  },
+  {
+    name: "Trigger",
+    pluralName: "Triggers",
+    slug: "trigger",
+    pluralSlug: "triggers",
+    fields: [
+      ...SYSTEM_FIELDS,
+      { slug: "slug", type: "string", required: true },
+      { slug: "schema", type: "reference", target: { slug: "schema" }, required: true },
+      { slug: "cause", type: "string", required: true },
+      { slug: "filter", type: "json" },
+      { slug: "effects", type: "json", required: true }
+    ]
   }
 ];
 var SYSTEM_SCHEMA_SLUGS = SYSTEM_SCHEMAS.flatMap(({ slug, pluralSlug }) => [
@@ -341,7 +573,7 @@ var getFieldStatement = (field) => {
   }
   return statement;
 };
-var addSchemaQueries = (queryDetails, writeStatements) => {
+var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements) => {
   const { queryType, querySchema, queryInstructions } = queryDetails;
   if (!["create", "set", "drop"].includes(queryType)) return;
   if (!SYSTEM_SCHEMA_SLUGS.includes(querySchema)) return;
@@ -352,7 +584,9 @@ var addSchemaQueries = (queryDetails, writeStatements) => {
   let queryTypeReadable = null;
   switch (queryType) {
     case "create": {
-      if (kind === "schemas" || kind === "indexes") tableAction = "CREATE";
+      if (kind === "schemas" || kind === "indexes" || kind === "triggers") {
+        tableAction = "CREATE";
+      }
       queryTypeReadable = "creating";
       break;
     }
@@ -362,7 +596,9 @@ var addSchemaQueries = (queryDetails, writeStatements) => {
       break;
     }
     case "drop": {
-      if (kind === "schemas" || kind === "indexes") tableAction = "DROP";
+      if (kind === "schemas" || kind === "indexes" || kind === "triggers") {
+        tableAction = "DROP";
+      }
       queryTypeReadable = "deleting";
       break;
     }
@@ -388,8 +624,58 @@ var addSchemaQueries = (queryDetails, writeStatements) => {
   if (kind === "indexes") {
     const indexName = convertToSnakeCase(slug);
     const unique = instructionList?.unique;
+    const filterQuery = instructionList?.filter;
     let statement2 = `${tableAction}${unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
-    if (queryType === "create") statement2 += ` ON "${tableName}"`;
+    if (queryType === "create") {
+      statement2 += ` ON "${tableName}"`;
+      if (filterQuery) {
+        const targetSchema = getSchemaBySlug(schemas, schemaSlug);
+        const withStatement = handleWith(
+          schemas,
+          targetSchema,
+          statementValues,
+          filterQuery
+        );
+        statement2 += ` WHERE (${withStatement})`;
+      }
+    }
+    writeStatements.push(statement2);
+    return;
+  }
+  if (kind === "triggers") {
+    const triggerName = convertToSnakeCase(slug);
+    let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
+    if (queryType === "create") {
+      const cause = slugToName(instructionList?.cause).toUpperCase();
+      const statementParts = [cause, "ON", `"${tableName}"`];
+      const effectQueries = instructionList?.effects;
+      const filterQuery = instructionList?.filter;
+      if (filterQuery || effectQueries.some((query) => findInObject(query, RONIN_SCHEMA_SYMBOLS.FIELD))) {
+        statementParts.push("FOR EACH ROW");
+      }
+      if (filterQuery) {
+        const targetSchema = getSchemaBySlug(schemas, schemaSlug);
+        const tablePlaceholder = cause.endsWith("DELETE") ? RONIN_SCHEMA_SYMBOLS.FIELD_OLD : RONIN_SCHEMA_SYMBOLS.FIELD_NEW;
+        const withStatement = handleWith(
+          schemas,
+          targetSchema,
+          statementValues,
+          filterQuery,
+          tablePlaceholder
+        );
+        statementParts.push("WHEN", `(${withStatement})`);
+      }
+      const effectStatements = effectQueries.map((effectQuery) => {
+        return compileQueryInput(effectQuery, schemas, {
+          statementValues,
+          disableReturning: true
+        }).readStatement;
+      });
+      if (effectStatements.length > 1) statementParts.push("BEGIN");
+      statementParts.push(effectStatements.join("; "));
+      if (effectStatements.length > 1) statementParts.push("END");
+      statement2 += ` ${statementParts.join(" ")}`;
+    }
     writeStatements.push(statement2);
     return;
   }
@@ -447,200 +733,6 @@ var pluralize = (word) => {
   return `${word}s`;
 };
 
-// src/instructions/with.ts
-var getMatcher = (value, negative) => {
-  if (negative) {
-    if (value === null) return "IS NOT";
-    return "!=";
-  }
-  if (value === null) return "IS";
-  return "=";
-};
-var WITH_CONDITIONS = {
-  being: (value, baseValue) => `${getMatcher(baseValue, false)} ${value}`,
-  notBeing: (value, baseValue) => `${getMatcher(baseValue, true)} ${value}`,
-  startingWith: (value) => `LIKE ${value}%`,
-  notStartingWith: (value) => `NOT LIKE ${value}%`,
-  endingWith: (value) => `LIKE %${value}`,
-  notEndingWith: (value) => `NOT LIKE %${value}`,
-  containing: (value) => `LIKE %${value}%`,
-  notContaining: (value) => `NOT LIKE %${value}%`,
-  greaterThan: (value) => `> ${value}`,
-  greaterOrEqual: (value) => `>= ${value}`,
-  lessThan: (value) => `< ${value}`,
-  lessOrEqual: (value) => `<= ${value}`
-};
-var handleWith = (schemas, schema, statementValues, instruction, rootTable) => {
-  const subStatement = composeConditions(
-    schemas,
-    schema,
-    statementValues,
-    "with",
-    instruction,
-    { rootTable }
-  );
-  return `(${subStatement})`;
-};
-
-// src/utils/statement.ts
-var prepareStatementValue = (statementValues, value, bindNull = false) => {
-  if (!bindNull && value === null) return "NULL";
-  let formattedValue = value;
-  if (Array.isArray(value) || isObject(value)) {
-    formattedValue = JSON.stringify(value);
-  } else if (typeof value === "boolean") {
-    formattedValue = value ? 1 : 0;
-  }
-  const index = statementValues.push(formattedValue);
-  return `?${index}`;
-};
-var composeFieldValues = (schemas, schema, statementValues, instructionName, value, options) => {
-  const { field: schemaField, fieldSelector: selector } = getFieldFromSchema(
-    schema,
-    options.fieldSlug,
-    instructionName,
-    options.rootTable
-  );
-  const isSubQuery = isObject(value) && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY);
-  const collectStatementValue = options.type !== "fields";
-  let conditionSelector = selector;
-  let conditionValue = value;
-  if (isSubQuery && collectStatementValue) {
-    conditionValue = `(${compileQueryInput(
-      value[RONIN_SCHEMA_SYMBOLS.QUERY],
-      schemas,
-      { statementValues }
-    ).readStatement})`;
-  } else if (typeof value === "string" && value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD)) {
-    conditionSelector = `"${options.customTable}"."${schemaField.slug}"`;
-    conditionValue = `"${options.rootTable}"."${value.replace(RONIN_SCHEMA_SYMBOLS.FIELD, "")}"`;
-  } else if (schemaField.type === "json" && instructionName === "to") {
-    conditionSelector = `"${schemaField.slug}"`;
-    if (collectStatementValue) {
-      const preparedValue = prepareStatementValue(statementValues, value, false);
-      conditionValue = `IIF(${conditionSelector} IS NULL, ${preparedValue}, json_patch(${conditionSelector}, ${preparedValue}))`;
-    }
-  } else if (collectStatementValue) {
-    conditionValue = prepareStatementValue(statementValues, value, false);
-  }
-  if (options.type === "fields") return conditionSelector;
-  if (options.type === "values") return conditionValue;
-  return `${conditionSelector} ${WITH_CONDITIONS[options.condition || "being"](conditionValue, value)}`;
-};
-var composeConditions = (schemas, schema, statementValues, instructionName, value, options) => {
-  const isNested = isObject(value) && Object.keys(value).length > 0;
-  if (isNested && Object.keys(value).every((key) => key in WITH_CONDITIONS)) {
-    const conditions = Object.entries(value).map(
-      ([conditionType, checkValue]) => composeConditions(schemas, schema, statementValues, instructionName, checkValue, {
-        ...options,
-        condition: conditionType
-      })
-    );
-    return conditions.join(" AND ");
-  }
-  if (options.fieldSlug) {
-    const fieldDetails = getFieldFromSchema(
-      schema,
-      options.fieldSlug,
-      instructionName,
-      options.rootTable
-    );
-    const { field: schemaField } = fieldDetails;
-    const consumeJSON = schemaField.type === "json" && instructionName === "to";
-    const isSubQuery = isNested && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY);
-    if (!(isObject(value) || Array.isArray(value)) || isSubQuery || consumeJSON) {
-      return composeFieldValues(
-        schemas,
-        schema,
-        statementValues,
-        instructionName,
-        value,
-        { ...options, fieldSlug: options.fieldSlug }
-      );
-    }
-    if (schemaField.type === "reference" && isNested) {
-      const keys = Object.keys(value);
-      const values = Object.values(value);
-      let recordTarget;
-      if (keys.length === 1 && keys[0] === "id") {
-        recordTarget = values[0];
-      } else {
-        const relatedSchema = getSchemaBySlug(schemas, schemaField.target.slug);
-        const subQuery = {
-          get: {
-            [relatedSchema.slug]: {
-              with: value,
-              selecting: ["id"]
-            }
-          }
-        };
-        recordTarget = {
-          [RONIN_SCHEMA_SYMBOLS.QUERY]: subQuery
-        };
-      }
-      return composeConditions(
-        schemas,
-        schema,
-        statementValues,
-        instructionName,
-        recordTarget,
-        options
-      );
-    }
-  }
-  if (isNested) {
-    const conditions = Object.entries(value).map(([field, value2]) => {
-      const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
-      return composeConditions(schemas, schema, statementValues, instructionName, value2, {
-        ...options,
-        fieldSlug: nestedFieldSlug
-      });
-    });
-    const joiner = instructionName === "to" ? ", " : " AND ";
-    if (instructionName === "to") return `${conditions.join(joiner)}`;
-    return conditions.length === 1 ? conditions[0] : options.fieldSlug ? `(${conditions.join(joiner)})` : conditions.join(joiner);
-  }
-  if (Array.isArray(value)) {
-    const conditions = value.map(
-      (filter) => composeConditions(
-        schemas,
-        schema,
-        statementValues,
-        instructionName,
-        filter,
-        options
-      )
-    );
-    return conditions.join(" OR ");
-  }
-  throw new RoninError({
-    message: `The \`with\` instruction must not contain an empty field. The following fields are empty: \`${options.fieldSlug}\`. If you meant to query by an empty field, try using \`null\` instead.`,
-    code: "INVALID_WITH_VALUE",
-    queries: null
-  });
-};
-var formatIdentifiers = ({ identifiers }, queryInstructions) => {
-  if (!queryInstructions) return queryInstructions;
-  const type = "with" in queryInstructions ? "with" : null;
-  if (!type) return queryInstructions;
-  const nestedInstructions = queryInstructions[type];
-  if (!nestedInstructions || Array.isArray(nestedInstructions))
-    return queryInstructions;
-  const newNestedInstructions = { ...nestedInstructions };
-  for (const oldKey of Object.keys(newNestedInstructions)) {
-    if (oldKey !== "titleIdentifier" && oldKey !== "slugIdentifier") continue;
-    const identifierName = oldKey === "titleIdentifier" ? "title" : "slug";
-    const value = newNestedInstructions[oldKey];
-    const newKey = identifiers?.[identifierName] || "id";
-    newNestedInstructions[newKey] = value;
-    delete newNestedInstructions[oldKey];
-  }
-  return {
-    ...queryInstructions,
-    [type]: newNestedInstructions
-  };
-};
-
 // src/instructions/before-after.ts
 var CURSOR_SEPARATOR = ",";
 var CURSOR_NULL_PLACEHOLDER = "RONIN_NULL";
@@ -734,7 +826,7 @@ var handleFor = (schemas, schema, statementValues, instruction, rootTable) => {
       });
     }
     const replacedForFilter = structuredClone(forFilter);
-    replaceInObject(
+    findInObject(
       replacedForFilter,
       RONIN_SCHEMA_SYMBOLS.VALUE,
       (match) => match.replace(RONIN_SCHEMA_SYMBOLS.VALUE, args)
@@ -999,7 +1091,7 @@ var compileQueryInput = (query, defaultSchemas, options) => {
   let table = getTableForSchema(schema);
   const statementValues = options?.statementValues || [];
   const writeStatements = [];
-  addSchemaQueries(parsedQuery, writeStatements);
+  addSchemaQueries(schemas, statementValues, parsedQuery, writeStatements);
   const columns = handleSelecting(schema, statementValues, {
     selecting: instructions?.selecting,
     including: instructions?.including

package/package.json

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