@ronin/compiler 0.13.9 → 0.13.10-leo-ron-1099-experimental-304

package/dist/index.js

@@ -150,1623 +150,1679 @@ var splitQuery = (query) => {
   return { queryType, queryModel, queryInstructions };
 };
 
-// src/utils/statement.ts
-var replaceJSON = (key, value) => {
-  if (key === QUERY_SYMBOLS.EXPRESSION) return value.replaceAll(`'`, `''`);
-  return value;
+// src/utils/pagination.ts
+var CURSOR_SEPARATOR = ",";
+var CURSOR_NULL_PLACEHOLDER = "RONIN_NULL";
+var generatePaginationCursor = (model, orderedBy, record) => {
+  const { ascending = [], descending = [] } = orderedBy || {};
+  const keys = [...ascending, ...descending];
+  if (keys.length === 0) keys.push("ronin.createdAt");
+  const cursors = keys.map((fieldSlug) => {
+    const property = getProperty(record, fieldSlug);
+    if (property === null || property === void 0) return CURSOR_NULL_PLACEHOLDER;
+    const { field } = getFieldFromModel(model, fieldSlug, {
+      instructionName: "orderedBy"
+    });
+    if (field.type === "date") return new Date(property).getTime();
+    return property;
+  });
+  return cursors.map((cursor) => encodeURIComponent(String(cursor))).join(CURSOR_SEPARATOR);
 };
-var prepareStatementValue = (statementParams, value) => {
-  if (value === null) return "NULL";
-  if (!statementParams) {
-    const valueString = typeof value === "object" ? `json('${JSON.stringify(value, replaceJSON)}')` : `'${value.toString()}'`;
-    return valueString;
+
+// src/instructions/before-after.ts
+var handleBeforeOrAfter = (model, statementParams, instructions) => {
+  if (!(instructions.before || instructions.after)) {
+    throw new RoninError({
+      message: "The `before` or `after` instruction must not be empty.",
+      code: "MISSING_INSTRUCTION"
+    });
   }
-  let formattedValue = value;
-  if (Array.isArray(value) || isObject(value)) {
-    formattedValue = JSON.stringify(value);
-  } else if (typeof value === "boolean") {
-    formattedValue = value ? 1 : 0;
+  if (instructions.before && instructions.after) {
+    throw new RoninError({
+      message: "The `before` and `after` instructions cannot co-exist. Choose one.",
+      code: "MUTUALLY_EXCLUSIVE_INSTRUCTIONS"
+    });
   }
-  const index = statementParams.push(formattedValue);
-  return `?${index}`;
-};
-var parseFieldExpression = (model, instructionName, expression, parentModel) => {
-  return expression.replace(RONIN_MODEL_FIELD_REGEX, (match) => {
-    let toReplace = QUERY_SYMBOLS.FIELD;
-    let rootModel = model;
-    if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT)) {
-      rootModel = parentModel;
-      toReplace = QUERY_SYMBOLS.FIELD_PARENT;
-      if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT_OLD)) {
-        rootModel.tableAlias = toReplace = QUERY_SYMBOLS.FIELD_PARENT_OLD;
-      } else if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT_NEW)) {
-        rootModel.tableAlias = toReplace = QUERY_SYMBOLS.FIELD_PARENT_NEW;
-      }
+  if (!instructions.limitedTo) {
+    let message = "When providing a pagination cursor in the `before` or `after`";
+    message += " instruction, a `limitedTo` instruction must be provided as well, to";
+    message += " define the page size.";
+    throw new RoninError({
+      message,
+      code: "MISSING_INSTRUCTION"
+    });
+  }
+  const { ascending = [], descending = [] } = instructions.orderedBy || {};
+  const clause = instructions.with ? "AND " : "";
+  const chunks = (instructions.before || instructions.after).toString().split(CURSOR_SEPARATOR).map(decodeURIComponent);
+  const keys = [...ascending, ...descending];
+  const values = keys.map((key, index) => {
+    const value = chunks[index];
+    if (value === CURSOR_NULL_PLACEHOLDER) {
+      return "NULL";
     }
-    const fieldSlug = match.replace(toReplace, "");
-    const field = getFieldFromModel(rootModel, fieldSlug, instructionName);
-    return field.fieldSelector;
+    const { field } = getFieldFromModel(model, key, {
+      instructionName: "orderedBy"
+    });
+    if (field.type === "boolean") {
+      return prepareStatementValue(statementParams, value === "true");
+    }
+    if (field.type === "number") {
+      return prepareStatementValue(statementParams, Number.parseInt(value));
+    }
+    if (field.type === "date") {
+      return `'${new Date(Number.parseInt(value)).toJSON()}'`;
+    }
+    return prepareStatementValue(statementParams, value);
   });
-};
-var composeFieldValues = (models, model, statementParams, instructionName, value, options) => {
-  const { fieldSelector: conditionSelector } = getFieldFromModel(
-    model,
-    options.fieldSlug,
-    instructionName
-  );
-  const collectStatementValue = options.type !== "fields";
-  const symbol = getSymbol(value);
-  const syntax = WITH_CONDITIONS[options.condition || "being"](value);
-  let conditionValue = syntax[1];
-  if (symbol) {
-    if (symbol?.type === "expression") {
-      conditionValue = parseFieldExpression(
-        model,
-        instructionName,
-        symbol.value,
-        options.parentModel
-      );
+  const compareOperators = [
+    // Reverse the comparison operators if we're querying for records before.
+    ...new Array(ascending.length).fill(instructions.before ? "<" : ">"),
+    ...new Array(descending.length).fill(instructions.before ? ">" : "<")
+  ];
+  const conditions = new Array();
+  for (let i = 0; i < keys.length; i++) {
+    if (values[i] === "NULL" && compareOperators[i] === "<") {
+      continue;
     }
-    if (symbol.type === "query" && collectStatementValue) {
-      conditionValue = `(${compileQueryInput(symbol.value, models, statementParams).main.statement})`;
+    const condition = new Array();
+    for (let j = 0; j <= i; j++) {
+      const key = keys[j];
+      const value = values[j];
+      let { field, fieldSelector } = getFieldFromModel(model, key, {
+        instructionName: "orderedBy"
+      });
+      if (j === i) {
+        const closingParentheses = ")".repeat(condition.length);
+        const operator = value === "NULL" ? "IS NOT" : compareOperators[j];
+        const caseInsensitiveStatement = value !== "NULL" && field.type === "string" ? " COLLATE NOCASE" : "";
+        if (value !== "NULL" && operator === "<" && !["ronin.createdAt", "ronin.updatedAt"].includes(key)) {
+          fieldSelector = `IFNULL(${fieldSelector}, -1e999)`;
+        }
+        condition.push(
+          `(${fieldSelector} ${operator} ${value}${caseInsensitiveStatement})${closingParentheses}`
+        );
+      } else {
+        const operator = value === "NULL" ? "IS" : "=";
+        condition.push(`(${fieldSelector} ${operator} ${value} AND`);
+      }
     }
-  } else if (collectStatementValue) {
-    conditionValue = prepareStatementValue(statementParams, conditionValue);
+    conditions.push(condition.join(" "));
   }
-  if (options.type === "fields") return conditionSelector;
-  if (options.type === "values") return conditionValue;
-  return `${conditionSelector} ${syntax[0]} ${conditionValue}`;
+  return `${clause}(${conditions.join(" OR ")})`;
 };
-var composeConditions = (models, model, statementParams, 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(models, model, statementParams, instructionName, checkValue, {
-        ...options,
-        condition: conditionType
-      })
-    );
-    return conditions.join(" AND ");
-  }
-  if (options.fieldSlug) {
-    const childField = model.fields.some(({ slug }) => {
-      return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
-    });
-    if (!childField) {
-      const fieldDetails = getFieldFromModel(model, options.fieldSlug, instructionName);
-      const { field: modelField } = fieldDetails || {};
-      const consumeJSON = modelField?.type === "json" && instructionName === "to";
-      if (modelField && !(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
-        return composeFieldValues(
-          models,
-          model,
-          statementParams,
-          instructionName,
-          value,
-          { ...options, fieldSlug: options.fieldSlug }
-        );
-      }
-      if (modelField?.type === "link" && 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 relatedModel = getModelBySlug(models, modelField.target);
-          const subQuery = {
-            get: {
-              [relatedModel.slug]: {
-                with: value,
-                selecting: ["id"]
-              }
-            }
-          };
-          recordTarget = {
-            [QUERY_SYMBOLS.QUERY]: subQuery
+
+// src/instructions/for.ts
+var handleFor = (model, instructions) => {
+  const normalizedFor = Array.isArray(instructions.for) ? Object.fromEntries(instructions.for.map((presetSlug) => [presetSlug, null])) : instructions.for;
+  for (const presetSlug in normalizedFor) {
+    if (!Object.hasOwn(normalizedFor, presetSlug)) continue;
+    const arg = normalizedFor[presetSlug];
+    const preset = model.presets?.find((preset2) => preset2.slug === presetSlug);
+    if (!preset) {
+      throw new RoninError({
+        message: `Preset "${presetSlug}" does not exist in model "${model.name}".`,
+        code: "PRESET_NOT_FOUND"
+      });
+    }
+    const replacedForFilter = structuredClone(preset.instructions);
+    if (arg !== null) {
+      findInObject(
+        replacedForFilter,
+        QUERY_SYMBOLS.VALUE,
+        (match) => match.replace(QUERY_SYMBOLS.VALUE, arg)
+      );
+    }
+    for (const subInstruction in replacedForFilter) {
+      if (!Object.hasOwn(replacedForFilter, subInstruction)) continue;
+      const instructionName = subInstruction;
+      const currentValue = instructions[instructionName];
+      if (currentValue) {
+        let newValue;
+        if (Array.isArray(currentValue)) {
+          newValue = [
+            ...replacedForFilter[instructionName],
+            ...currentValue
+          ];
+        } else if (isObject(currentValue)) {
+          newValue = {
+            ...replacedForFilter[instructionName],
+            ...currentValue
           };
         }
-        return composeConditions(
-          models,
-          model,
-          statementParams,
-          instructionName,
-          recordTarget,
-          options
-        );
+        Object.assign(instructions, { [instructionName]: newValue });
+        continue;
       }
-    }
-  }
-  if (isNested) {
-    const conditions = Object.entries(value).map(([field, value2]) => {
-      const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
-      return composeConditions(models, model, statementParams, instructionName, value2, {
-        ...options,
-        fieldSlug: nestedFieldSlug
+      Object.assign(instructions, {
+        [instructionName]: replacedForFilter[instructionName]
       });
-    });
-    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(models, model, statementParams, 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
-  });
+  return instructions;
 };
-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 !== "nameIdentifier" && oldKey !== "slugIdentifier") continue;
-    const identifierName = oldKey === "nameIdentifier" ? "name" : "slug";
-    const value = newNestedInstructions[oldKey];
-    const newKey = identifiers[identifierName];
-    newNestedInstructions[newKey] = value;
-    delete newNestedInstructions[oldKey];
+
+// src/instructions/including.ts
+var handleIncluding = (models, model, statementParams, instruction) => {
+  let statement = "";
+  let tableSubQuery;
+  for (const ephemeralFieldSlug in instruction) {
+    if (!Object.hasOwn(instruction, ephemeralFieldSlug)) continue;
+    const symbol = getSymbol(instruction[ephemeralFieldSlug]);
+    if (symbol?.type !== "query") continue;
+    const { queryType, queryModel, queryInstructions } = splitQuery(symbol.value);
+    let modifiableQueryInstructions = queryInstructions;
+    const relatedModel = getModelBySlug(models, queryModel);
+    let joinType = "LEFT";
+    let relatedTableSelector = `"${relatedModel.table}"`;
+    const tableAlias = composeIncludedTableAlias(ephemeralFieldSlug);
+    const single = queryModel !== relatedModel.pluralSlug;
+    if (!modifiableQueryInstructions?.with) {
+      joinType = "CROSS";
+      if (single) {
+        if (!modifiableQueryInstructions) modifiableQueryInstructions = {};
+        modifiableQueryInstructions.limitedTo = 1;
+      }
+    }
+    if (modifiableQueryInstructions?.limitedTo || modifiableQueryInstructions?.orderedBy) {
+      const subSelect = compileQueryInput(
+        {
+          [queryType]: {
+            [queryModel]: modifiableQueryInstructions
+          }
+        },
+        models,
+        statementParams
+      );
+      relatedTableSelector = `(${subSelect.main.statement})`;
+    }
+    statement += `${joinType} JOIN ${relatedTableSelector} as ${tableAlias}`;
+    model.tableAlias = model.tableAlias || model.table;
+    if (joinType === "LEFT") {
+      const subStatement = composeConditions(
+        models,
+        { ...relatedModel, tableAlias },
+        statementParams,
+        "including",
+        queryInstructions?.with,
+        {
+          parentModel: model
+        }
+      );
+      statement += ` ON (${subStatement})`;
+    }
+    if (!single) tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
   }
-  return {
-    ...queryInstructions,
-    [type]: newNestedInstructions
-  };
+  return { statement, tableSubQuery };
 };
 
-// src/instructions/with.ts
-var getMatcher = (value, negative) => {
-  if (negative) {
-    if (value === null) return "IS NOT";
-    return "!=";
-  }
-  if (value === null) return "IS";
-  return "=";
+// src/instructions/limited-to.ts
+var handleLimitedTo = (single, instruction) => {
+  let amount;
+  if (instruction) amount = instruction + 1;
+  if (single) amount = 1;
+  return `LIMIT ${amount} `;
 };
-var WITH_CONDITIONS = {
-  being: (value) => [getMatcher(value, false), value],
-  notBeing: (value) => [getMatcher(value, 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]
+
+// src/instructions/ordered-by.ts
+var handleOrderedBy = (model, instruction) => {
+  let statement = "";
+  const items = [
+    ...(instruction.ascending || []).map((value) => ({ value, order: "ASC" })),
+    ...(instruction.descending || []).map((value) => ({ value, order: "DESC" }))
+  ];
+  for (const item of items) {
+    if (statement.length > 0) {
+      statement += ", ";
+    }
+    const symbol = getSymbol(item.value);
+    const instructionName = item.order === "ASC" ? "orderedBy.ascending" : "orderedBy.descending";
+    if (symbol?.type === "expression") {
+      statement += `(${parseFieldExpression(model, instructionName, symbol.value)}) ${item.order}`;
+      continue;
+    }
+    const { field: modelField, fieldSelector } = getFieldFromModel(
+      model,
+      item.value,
+      { instructionName }
+    );
+    const caseInsensitiveStatement = modelField.type === "string" ? " COLLATE NOCASE" : "";
+    statement += `${fieldSelector}${caseInsensitiveStatement} ${item.order}`;
+  }
+  return `ORDER BY ${statement}`;
 };
-var handleWith = (models, model, statementParams, instruction, parentModel) => {
-  const subStatement = composeConditions(
-    models,
-    model,
-    statementParams,
-    "with",
-    instruction,
-    { parentModel }
-  );
-  return `(${subStatement})`;
+
+// src/instructions/selecting.ts
+var handleSelecting = (models, model, statementParams, instructions, options) => {
+  let loadedFields = [];
+  let expandColumns = false;
+  let statement = "*";
+  let isJoining = false;
+  if (instructions.including) {
+    const flatObject = flatten(instructions.including);
+    instructions.including = {};
+    for (const [key, value] of Object.entries(flatObject)) {
+      const symbol = getSymbol(value);
+      if (symbol?.type === "query") {
+        const { queryModel, queryInstructions } = splitQuery(symbol.value);
+        const subQueryModel = getModelBySlug(models, queryModel);
+        isJoining = true;
+        expandColumns = Boolean(options?.expandColumns || queryInstructions?.selecting);
+        const tableAlias = composeIncludedTableAlias(key);
+        const single = queryModel !== subQueryModel.pluralSlug;
+        if (!single) {
+          model.tableAlias = `sub_${model.table}`;
+        }
+        const queryModelFields = queryInstructions?.selecting ? subQueryModel.fields.filter((field) => {
+          return queryInstructions.selecting?.includes(field.slug);
+        }) : (
+          // Exclude link fields with cardinality "many", since those don't exist as columns.
+          subQueryModel.fields.filter((field) => {
+            return !(field.type === "link" && field.kind === "many");
+          })
+        );
+        for (const field of queryModelFields) {
+          loadedFields.push({ ...field, parentField: key });
+          if (expandColumns) {
+            const newValue2 = parseFieldExpression(
+              { ...subQueryModel, tableAlias },
+              "including",
+              `${QUERY_SYMBOLS.FIELD}${field.slug}`
+            );
+            instructions.including[`${tableAlias}.${field.slug}`] = newValue2;
+          }
+        }
+        continue;
+      }
+      let newValue = value;
+      if (symbol?.type === "expression") {
+        newValue = `(${parseFieldExpression(model, "including", symbol.value)})`;
+      } else {
+        newValue = prepareStatementValue(statementParams, value);
+      }
+      instructions.including[key] = newValue;
+      loadedFields.push({
+        slug: key,
+        type: RAW_FIELD_TYPES.includes(typeof value) ? typeof value : "string"
+      });
+    }
+  }
+  if (expandColumns) {
+    instructions.selecting = model.fields.filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => field.slug);
+  }
+  if (instructions.selecting) {
+    const usableModel = expandColumns ? { ...model, tableAlias: model.tableAlias || model.table } : model;
+    const selectedFields = [];
+    statement = instructions.selecting.map((slug) => {
+      const { field, fieldSelector } = getFieldFromModel(usableModel, slug, {
+        instructionName: "selecting"
+      });
+      selectedFields.push(field);
+      return fieldSelector;
+    }).join(", ");
+    loadedFields = [...selectedFields, ...loadedFields];
+  } else {
+    loadedFields = [
+      ...model.fields.filter(
+        (field) => !(field.type === "link" && field.kind === "many")
+      ),
+      ...loadedFields
+    ];
+  }
+  if (instructions.including && Object.keys(instructions.including).length > 0) {
+    statement += ", ";
+    statement += Object.entries(instructions.including).map(([key, value]) => `${value} as "${key}"`).join(", ");
+  }
+  return { columns: statement, isJoining, loadedFields };
 };
 
-// node_modules/title/dist/esm/lower-case.js
-var conjunctions = [
-  "for",
-  "and",
-  "nor",
-  "but",
-  "or",
-  "yet",
-  "so"
-];
-var articles = [
-  "a",
-  "an",
-  "the"
-];
-var prepositions = [
-  "aboard",
-  "about",
-  "above",
-  "across",
-  "after",
-  "against",
-  "along",
-  "amid",
-  "among",
-  "anti",
-  "around",
-  "as",
-  "at",
-  "before",
-  "behind",
-  "below",
-  "beneath",
-  "beside",
-  "besides",
-  "between",
-  "beyond",
-  "but",
-  "by",
-  "concerning",
-  "considering",
-  "despite",
-  "down",
-  "during",
-  "except",
-  "excepting",
-  "excluding",
-  "following",
-  "for",
-  "from",
-  "in",
-  "inside",
-  "into",
-  "like",
-  "minus",
-  "near",
-  "of",
-  "off",
-  "on",
-  "onto",
-  "opposite",
-  "over",
-  "past",
-  "per",
-  "plus",
-  "regarding",
-  "round",
-  "save",
-  "since",
-  "than",
-  "through",
-  "to",
-  "toward",
-  "towards",
-  "under",
-  "underneath",
-  "unlike",
-  "until",
-  "up",
-  "upon",
-  "versus",
-  "via",
-  "with",
-  "within",
-  "without"
-];
-var lowerCase = /* @__PURE__ */ new Set([
-  ...conjunctions,
-  ...articles,
-  ...prepositions
-]);
-
-// node_modules/title/dist/esm/specials.js
-var specials = [
-  "ZEIT",
-  "ZEIT Inc.",
-  "Vercel",
-  "Vercel Inc.",
-  "CLI",
-  "API",
-  "HTTP",
-  "HTTPS",
-  "JSX",
-  "DNS",
-  "URL",
-  "now.sh",
-  "now.json",
-  "vercel.app",
-  "vercel.json",
-  "CI",
-  "CD",
-  "CDN",
-  "package.json",
-  "package.lock",
-  "yarn.lock",
-  "GitHub",
-  "GitLab",
-  "CSS",
-  "Sass",
-  "JS",
-  "JavaScript",
-  "TypeScript",
-  "HTML",
-  "WordPress",
-  "Next.js",
-  "Node.js",
-  "Webpack",
-  "Docker",
-  "Bash",
-  "Kubernetes",
-  "SWR",
-  "TinaCMS",
-  "UI",
-  "UX",
-  "TS",
-  "TSX",
-  "iPhone",
-  "iPad",
-  "watchOS",
-  "iOS",
-  "iPadOS",
-  "macOS",
-  "PHP",
-  "composer.json",
-  "composer.lock",
-  "CMS",
-  "SQL",
-  "C",
-  "C#",
-  "GraphQL",
-  "GraphiQL",
-  "JWT",
-  "JWTs"
-];
-
-// node_modules/title/dist/esm/index.js
-var word = `[^\\s'\u2019\\(\\)!?;:"-]`;
-var regex = new RegExp(`(?:(?:(\\s?(?:^|[.\\(\\)!?;:"-])\\s*)(${word}))|(${word}))(${word}*[\u2019']*${word}*)`, "g");
-var convertToRegExp = (specials2) => specials2.map((s) => [new RegExp(`\\b${s}\\b`, "gi"), s]);
-function parseMatch(match) {
-  const firstCharacter = match[0];
-  if (/\s/.test(firstCharacter)) {
-    return match.slice(1);
-  }
-  if (/[\(\)]/.test(firstCharacter)) {
-    return null;
+// src/instructions/to.ts
+var handleTo = (models, model, statementParams, queryType, dependencyStatements, instructions, parentModel) => {
+  const { with: withInstruction, to: toInstruction } = instructions;
+  const defaultFields = {};
+  if (queryType === "set" || toInstruction.ronin) {
+    defaultFields.ronin = {
+      // If records are being updated, bump their update time.
+      ...queryType === "set" ? { updatedAt: CURRENT_TIME_EXPRESSION } : {},
+      // Allow for overwriting the default values provided above.
+      ...toInstruction.ronin
+    };
   }
-  return match;
-}
-var src_default = (str, options = {}) => {
-  str = str.toLowerCase().replace(regex, (m, lead = "", forced, lower, rest, offset, string) => {
-    const isLastWord = m.length + offset >= string.length;
-    const parsedMatch = parseMatch(m);
-    if (!parsedMatch) {
-      return m;
+  const symbol = getSymbol(toInstruction);
+  if (symbol?.type === "query") {
+    const { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
+    const subQueryModel = getModelBySlug(models, subQueryModelSlug);
+    if (subQueryInstructions?.selecting) {
+      const currentFields = new Set(subQueryInstructions.selecting);
+      currentFields.add("id");
+      subQueryInstructions.selecting = Array.from(currentFields);
     }
-    if (!forced) {
-      const fullLower = lower + rest;
-      if (lowerCase.has(fullLower) && !isLastWord) {
-        return parsedMatch;
+    const subQuerySelectedFields = subQueryInstructions?.selecting;
+    const subQueryIncludedFields = subQueryInstructions?.including;
+    const subQueryFields = [
+      ...subQuerySelectedFields || (subQueryModel.fields || []).map((field) => field.slug),
+      ...subQueryIncludedFields ? Object.keys(
+        flatten(subQueryIncludedFields || {})
+      ) : []
+    ];
+    for (const field of subQueryFields || []) {
+      getFieldFromModel(model, field, { instructionName: "to" });
+    }
+    let statement2 = "";
+    if (subQuerySelectedFields) {
+      const columns = subQueryFields.map((field) => {
+        return getFieldFromModel(model, field, { instructionName: "to" }).fieldSelector;
+      });
+      statement2 = `(${columns.join(", ")}) `;
+    }
+    statement2 += compileQueryInput(symbol.value, models, statementParams).main.statement;
+    return statement2;
+  }
+  Object.assign(toInstruction, defaultFields);
+  for (const fieldSlug in toInstruction) {
+    if (!Object.hasOwn(toInstruction, fieldSlug)) continue;
+    const fieldValue = toInstruction[fieldSlug];
+    const fieldDetails = getFieldFromModel(
+      model,
+      fieldSlug,
+      { instructionName: "to" },
+      false
+    );
+    if (fieldDetails?.field.type === "link" && fieldDetails.field.kind === "many") {
+      delete toInstruction[fieldSlug];
+      const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);
+      const composeStatement = (subQueryType, value) => {
+        const source = queryType === "add" ? { id: toInstruction.id } : withInstruction;
+        const recordDetails = { source };
+        if (value) recordDetails.target = value;
+        return compileQueryInput(
+          {
+            [subQueryType]: {
+              [associativeModelSlug]: subQueryType === "add" ? { to: recordDetails } : { with: recordDetails }
+            }
+          },
+          models,
+          [],
+          { returning: false }
+        ).main;
+      };
+      if (Array.isArray(fieldValue)) {
+        dependencyStatements.push(composeStatement("remove"));
+        for (const record of fieldValue) {
+          dependencyStatements.push(composeStatement("add", record));
+        }
+      } else if (isObject(fieldValue)) {
+        const value = fieldValue;
+        for (const recordToAdd of value.containing || []) {
+          dependencyStatements.push(composeStatement("add", recordToAdd));
+        }
+        for (const recordToRemove of value.notContaining || []) {
+          dependencyStatements.push(composeStatement("remove", recordToRemove));
+        }
       }
     }
-    return lead + (lower || forced).toUpperCase() + rest;
-  });
-  const customSpecials = options.special || [];
-  const replace = [...specials, ...customSpecials];
-  const replaceRegExp = convertToRegExp(replace);
-  replaceRegExp.forEach(([pattern, s]) => {
-    str = str.replace(pattern, s);
+  }
+  let statement = composeConditions(models, model, statementParams, "to", toInstruction, {
+    parentModel,
+    type: queryType === "add" ? "fields" : void 0
   });
-  return str;
+  if (queryType === "add") {
+    const deepStatement = composeConditions(
+      models,
+      model,
+      statementParams,
+      "to",
+      toInstruction,
+      {
+        parentModel,
+        type: "values"
+      }
+    );
+    statement = `(${statement}) VALUES (${deepStatement})`;
+  } else if (queryType === "set") {
+    statement = `SET ${statement}`;
+  }
+  return statement;
 };
 
-// src/utils/model.ts
-var getModelBySlug = (models, slug) => {
-  const model = models.find((model2) => {
-    return model2.slug === slug || model2.pluralSlug === slug;
-  });
-  if (!model) {
-    throw new RoninError({
-      message: `No matching model with either Slug or Plural Slug of "${slug}" could be found.`,
-      code: "MODEL_NOT_FOUND"
-    });
+// src/utils/index.ts
+var compileQueryInput = (defaultQuery, models, statementParams, options) => {
+  const dependencyStatements = [];
+  const query = transformMetaQuery(
+    models,
+    dependencyStatements,
+    statementParams,
+    defaultQuery
+  );
+  if (query === null)
+    return { dependencies: [], main: dependencyStatements[0], loadedFields: [] };
+  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 returning = options?.returning ?? true;
+  if (instructions && Object.hasOwn(instructions, "for")) {
+    instructions = handleFor(model, instructions);
   }
-  return model;
-};
-var composeAssociationModelSlug = (model, field) => convertToCamelCase(`ronin_link_${model.slug}_${field.slug}`);
-var getFieldSelector = (model, field, fieldPath, instructionName) => {
-  const symbol = model.tableAlias?.startsWith(QUERY_SYMBOLS.FIELD_PARENT) ? `${model.tableAlias.replace(QUERY_SYMBOLS.FIELD_PARENT, "").slice(0, -1)}.` : "";
-  const tablePrefix = symbol || (model.tableAlias ? `"${model.tableAlias}".` : "");
-  if (field.type === "json" && instructionName !== "to") {
-    const dotParts = fieldPath.split(".");
-    const columnName = tablePrefix + dotParts.shift();
-    const jsonField = dotParts.join(".");
-    return `json_extract(${columnName}, '$.${jsonField}')`;
+  const { columns, isJoining, loadedFields } = handleSelecting(
+    models,
+    model,
+    statementParams,
+    {
+      selecting: instructions?.selecting,
+      including: instructions?.including
+    },
+    options
+  );
+  let statement = "";
+  switch (queryType) {
+    case "get":
+      statement += `SELECT ${columns} FROM `;
+      break;
+    case "set":
+      statement += "UPDATE ";
+      break;
+    case "add":
+      statement += "INSERT INTO ";
+      break;
+    case "remove":
+      statement += "DELETE FROM ";
+      break;
+    case "count":
+      statement += `SELECT COUNT(${columns}) FROM `;
+      break;
   }
-  return `${tablePrefix}"${fieldPath}"`;
-};
-function getFieldFromModel(model, fieldPath, instructionName, shouldThrow = true) {
-  const errorPrefix = `Field "${fieldPath}" defined for \`${instructionName}\``;
-  const modelFields = model.fields || [];
-  let modelField;
-  if (fieldPath.includes(".")) {
-    modelField = modelFields.find((field) => field.slug === fieldPath.split(".")[0]);
-    if (modelField?.type === "json") {
-      const fieldSelector2 = getFieldSelector(
-        model,
-        modelField,
-        fieldPath,
-        instructionName
-      );
-      return { field: modelField, fieldSelector: fieldSelector2 };
+  let isJoiningMultipleRows = false;
+  if (isJoining) {
+    const { statement: including, tableSubQuery } = handleIncluding(
+      models,
+      model,
+      statementParams,
+      instructions?.including
+    );
+    if (tableSubQuery) {
+      statement += `(${tableSubQuery}) as ${model.tableAlias} `;
+      isJoiningMultipleRows = true;
+    } else {
+      statement += `"${model.table}" `;
     }
+    statement += `${including} `;
+  } else {
+    statement += `"${model.table}" `;
   }
-  modelField = modelFields.find((field) => field.slug === fieldPath);
-  if (!modelField) {
-    if (shouldThrow) {
+  if (queryType === "add" || queryType === "set") {
+    if (!isObject(instructions.to) || Object.keys(instructions.to).length === 0) {
       throw new RoninError({
-        message: `${errorPrefix} does not exist in model "${model.name}".`,
-        code: "FIELD_NOT_FOUND",
-        field: fieldPath,
-        queries: null
+        message: `When using a \`${queryType}\` query, the \`to\` instruction must be a non-empty object.`,
+        code: "INVALID_TO_VALUE",
+        queries: [query]
       });
     }
-    return null;
-  }
-  const fieldSelector = getFieldSelector(model, modelField, fieldPath, instructionName);
-  return { field: modelField, fieldSelector };
-}
-var slugToName = (slug) => {
-  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
-  return src_default(name);
-};
-var VOWELS = ["a", "e", "i", "o", "u"];
-var pluralize = (word2) => {
-  const lastLetter = word2.slice(-1).toLowerCase();
-  const secondLastLetter = word2.slice(-2, -1).toLowerCase();
-  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
-    return `${word2.slice(0, -1)}ies`;
+    const toStatement = handleTo(
+      models,
+      model,
+      statementParams,
+      queryType,
+      dependencyStatements,
+      { with: instructions.with, to: instructions.to },
+      options?.parentModel
+    );
+    statement += `${toStatement} `;
   }
-  if (lastLetter === "s" || word2.slice(-2).toLowerCase() === "ch" || word2.slice(-2).toLowerCase() === "sh" || word2.slice(-2).toLowerCase() === "ex") {
-    return `${word2}es`;
+  const conditions = [];
+  if (queryType !== "add" && instructions && Object.hasOwn(instructions, "with")) {
+    const withStatement = handleWith(
+      models,
+      model,
+      statementParams,
+      instructions.with,
+      options?.parentModel
+    );
+    if (withStatement.length > 0) conditions.push(withStatement);
   }
-  return `${word2}s`;
-};
-var modelAttributes = [
-  ["pluralSlug", "slug", pluralize],
-  ["name", "slug", slugToName],
-  ["pluralName", "pluralSlug", slugToName],
-  ["idPrefix", "slug", (slug) => slug.slice(0, 3)],
-  ["table", "pluralSlug", convertToSnakeCase]
-];
-var addDefaultModelFields = (model, isNew) => {
-  const copiedModel = { ...model };
-  for (const [setting, base, generator] of modelAttributes) {
-    if (copiedModel[setting] || !copiedModel[base]) continue;
-    copiedModel[setting] = generator(copiedModel[base]);
+  if ((queryType === "get" || queryType === "count") && !single && instructions?.limitedTo) {
+    instructions = instructions || {};
+    instructions.orderedBy = instructions.orderedBy || {};
+    instructions.orderedBy.ascending = instructions.orderedBy.ascending || [];
+    instructions.orderedBy.descending = instructions.orderedBy.descending || [];
+    if (![
+      ...instructions.orderedBy.ascending,
+      ...instructions.orderedBy.descending
+    ].includes("ronin.createdAt")) {
+      instructions.orderedBy.descending.push("ronin.createdAt");
+    }
   }
-  const newFields = copiedModel.fields || [];
-  if (isNew || newFields.length > 0) {
-    if (!copiedModel.identifiers) copiedModel.identifiers = {};
-    if (!copiedModel.identifiers.name) {
-      const suitableField = newFields.find(
-        (field) => field.type === "string" && field.required === true && ["name"].includes(field.slug)
-      );
-      copiedModel.identifiers.name = suitableField?.slug || "id";
+  if (instructions && (Object.hasOwn(instructions, "before") || Object.hasOwn(instructions, "after"))) {
+    if (single) {
+      throw new RoninError({
+        message: "The `before` and `after` instructions are not supported when querying for a single record.",
+        code: "INVALID_BEFORE_OR_AFTER_INSTRUCTION",
+        queries: [query]
+      });
     }
-    if (!copiedModel.identifiers.slug) {
-      const suitableField = newFields.find(
-        (field) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(field.slug)
-      );
-      copiedModel.identifiers.slug = suitableField?.slug || "id";
+    const beforeAndAfterStatement = handleBeforeOrAfter(model, statementParams, {
+      before: instructions.before,
+      after: instructions.after,
+      with: instructions.with,
+      orderedBy: instructions.orderedBy,
+      limitedTo: instructions.limitedTo
+    });
+    conditions.push(beforeAndAfterStatement);
+  }
+  if (conditions.length > 0) {
+    if (conditions.length === 1) {
+      statement += `WHERE ${conditions[0]} `;
+    } else {
+      statement += `WHERE (${conditions.join(" ")}) `;
     }
-    copiedModel.fields = [...getSystemFields(copiedModel.idPrefix), ...newFields];
   }
-  return copiedModel;
+  if (instructions?.orderedBy) {
+    const orderedByStatement = handleOrderedBy(model, instructions.orderedBy);
+    statement += `${orderedByStatement} `;
+  }
+  if (queryType === "get" && !isJoiningMultipleRows && (single || instructions?.limitedTo)) {
+    statement += handleLimitedTo(single, instructions?.limitedTo);
+  }
+  if (["add", "set", "remove"].includes(queryType) && returning) {
+    statement += "RETURNING * ";
+  }
+  const mainStatement = {
+    statement: statement.trimEnd(),
+    params: statementParams || []
+  };
+  if (returning) mainStatement.returning = true;
+  return {
+    dependencies: dependencyStatements,
+    main: mainStatement,
+    loadedFields
+  };
 };
-var getSystemFields = (idPrefix = "rec") => [
-  {
-    name: "ID",
-    type: "string",
-    slug: "id",
-    defaultValue: {
-      // Since default values in SQLite cannot rely on other columns, we unfortunately
-      // cannot rely on the `idPrefix` column here. Instead, we need to inject it directly
-      // into the expression as a static string.
-      [QUERY_SYMBOLS.EXPRESSION]: `'${idPrefix}_' || lower(substr(hex(randomblob(12)), 1, 16))`
+
+// src/utils/statement.ts
+var replaceJSON = (key, value) => {
+  if (key === QUERY_SYMBOLS.EXPRESSION) return value.replaceAll(`'`, `''`);
+  return value;
+};
+var prepareStatementValue = (statementParams, value) => {
+  if (value === null) return "NULL";
+  if (!statementParams) {
+    const valueString = typeof value === "object" ? `json('${JSON.stringify(value, replaceJSON)}')` : `'${value.toString()}'`;
+    return valueString;
+  }
+  let formattedValue = value;
+  if (Array.isArray(value) || isObject(value)) {
+    formattedValue = JSON.stringify(value);
+  } else if (typeof value === "boolean") {
+    formattedValue = value ? 1 : 0;
+  }
+  const index = statementParams.push(formattedValue);
+  return `?${index}`;
+};
+var parseFieldExpression = (model, instructionName, expression, parentModel) => {
+  return expression.replace(RONIN_MODEL_FIELD_REGEX, (match) => {
+    let toReplace = QUERY_SYMBOLS.FIELD;
+    let rootModel = model;
+    if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT)) {
+      rootModel = parentModel;
+      toReplace = QUERY_SYMBOLS.FIELD_PARENT;
+      if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT_OLD)) {
+        rootModel.tableAlias = toReplace = QUERY_SYMBOLS.FIELD_PARENT_OLD;
+      } else if (match.startsWith(QUERY_SYMBOLS.FIELD_PARENT_NEW)) {
+        rootModel.tableAlias = toReplace = QUERY_SYMBOLS.FIELD_PARENT_NEW;
+      }
     }
-  },
-  {
-    name: "RONIN - Locked",
-    type: "boolean",
-    slug: "ronin.locked"
-  },
-  {
-    name: "RONIN - Created At",
-    type: "date",
-    slug: "ronin.createdAt",
-    defaultValue: CURRENT_TIME_EXPRESSION
-  },
-  {
-    name: "RONIN - Created By",
-    type: "string",
-    slug: "ronin.createdBy"
-  },
-  {
-    name: "RONIN - Updated At",
-    type: "date",
-    slug: "ronin.updatedAt",
-    defaultValue: CURRENT_TIME_EXPRESSION
-  },
-  {
-    name: "RONIN - Updated By",
-    type: "string",
-    slug: "ronin.updatedBy"
-  }
-];
-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.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: "{}" }
-  ]
+    const fieldSlug = match.replace(toReplace, "");
+    const field = getFieldFromModel(rootModel, fieldSlug, { instructionName });
+    return field.fieldSelector;
+  });
 };
-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
-            }
-          ]
-        });
-      }
+var composeFieldValues = (models, model, statementParams, instructionName, value, options) => {
+  const { fieldSelector: conditionSelector } = getFieldFromModel(
+    model,
+    options.fieldSlug,
+    { instructionName }
+  );
+  const collectStatementValue = options.type !== "fields";
+  const symbol = getSymbol(value);
+  const syntax = WITH_CONDITIONS[options.condition || "being"](value);
+  let conditionValue = syntax[1];
+  if (symbol) {
+    if (symbol?.type === "expression") {
+      conditionValue = parseFieldExpression(
+        model,
+        instructionName,
+        symbol.value,
+        options.parentModel
+      );
+    }
+    if (symbol.type === "query" && collectStatementValue) {
+      conditionValue = `(${compileQueryInput(symbol.value, models, statementParams).main.statement})`;
     }
+  } else if (collectStatementValue) {
+    conditionValue = prepareStatementValue(statementParams, conditionValue);
   }
-  return addedModels;
+  if (options.type === "fields") return conditionSelector;
+  if (options.type === "values") return conditionValue;
+  return `${conditionSelector} ${syntax[0]} ${conditionValue}`;
 };
-var addDefaultModelPresets = (list, model) => {
-  const defaultPresets = [];
-  for (const field of model.fields || []) {
-    if (field.type === "link" && !field.slug.startsWith("ronin.")) {
-      const relatedModel = getModelBySlug(list, field.target);
-      if (field.kind === "many") continue;
-      defaultPresets.push({
-        instructions: {
-          including: {
-            [field.slug]: {
-              [QUERY_SYMBOLS.QUERY]: {
-                get: {
-                  [relatedModel.slug]: {
-                    with: {
-                      // Compare the `id` field of the related model to the link field on
-                      // the root model (`field.slug`).
-                      id: {
-                        [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}${field.slug}`
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        },
-        slug: field.slug
-      });
-    }
+var composeConditions = (models, model, statementParams, 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(models, model, statementParams, instructionName, checkValue, {
+        ...options,
+        condition: conditionType
+      })
+    );
+    return conditions.join(" AND ");
   }
-  const childModels = list.map((subModel) => {
-    const field = subModel.fields?.find((field2) => {
-      return field2.type === "link" && field2.target === model.slug;
+  if (options.fieldSlug) {
+    const childField = model.fields.some(({ slug }) => {
+      return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
     });
-    if (!field) return null;
-    return { model: subModel, field };
-  }).filter((match) => match !== null);
-  for (const childMatch of childModels) {
-    const { model: childModel, field: childField } = childMatch;
-    const pluralSlug = childModel.pluralSlug;
-    const presetSlug = childModel.system?.associationSlug || pluralSlug;
-    defaultPresets.push({
-      instructions: {
-        including: {
-          [presetSlug]: {
-            [QUERY_SYMBOLS.QUERY]: {
-              get: {
-                [pluralSlug]: {
-                  with: {
-                    [childField.slug]: {
-                      [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
-                    }
-                  }
-                }
+    if (!childField) {
+      const fieldDetails = getFieldFromModel(model, options.fieldSlug, {
+        instructionName
+      });
+      const { field: modelField } = fieldDetails || {};
+      const consumeJSON = modelField?.type === "json" && instructionName === "to";
+      if (modelField && !(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
+        return composeFieldValues(
+          models,
+          model,
+          statementParams,
+          instructionName,
+          value,
+          { ...options, fieldSlug: options.fieldSlug }
+        );
+      }
+      if (modelField?.type === "link" && 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 relatedModel = getModelBySlug(models, modelField.target);
+          const subQuery = {
+            get: {
+              [relatedModel.slug]: {
+                with: value,
+                selecting: ["id"]
               }
             }
-          }
+          };
+          recordTarget = {
+            [QUERY_SYMBOLS.QUERY]: subQuery
+          };
         }
-      },
-      slug: presetSlug
+        return composeConditions(
+          models,
+          model,
+          statementParams,
+          instructionName,
+          recordTarget,
+          options
+        );
+      }
+    }
+  }
+  if (isNested) {
+    const conditions = Object.entries(value).map(([field, value2]) => {
+      const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
+      return composeConditions(models, model, statementParams, 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 (Object.keys(defaultPresets).length > 0) {
-    model.presets = [...defaultPresets, ...model.presets || []];
+  if (Array.isArray(value)) {
+    const conditions = value.map(
+      (filter) => composeConditions(models, model, statementParams, instructionName, filter, options)
+    );
+    return conditions.join(" OR ");
   }
-  return model;
-};
-var typesInSQLite = {
-  link: "TEXT",
-  string: "TEXT",
-  date: "DATETIME",
-  blob: "TEXT",
-  boolean: "BOOLEAN",
-  number: "INTEGER",
-  json: "TEXT"
+  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 getFieldStatement = (models, model, field) => {
-  let statement = `"${field.slug}" ${typesInSQLite[field.type || "string"]}`;
-  if (field.slug === "id") statement += " PRIMARY KEY";
-  if (field.unique === true) statement += " UNIQUE";
-  if (field.required === true) statement += " NOT NULL";
-  if (typeof field.defaultValue !== "undefined") {
-    const symbol = getSymbol(field.defaultValue);
-    let value = typeof field.defaultValue === "string" ? `'${field.defaultValue}'` : field.defaultValue;
-    if (symbol) value = `(${parseFieldExpression(model, "to", symbol.value)})`;
-    statement += ` DEFAULT ${value}`;
-  }
-  if (field.type === "string" && field.collation) {
-    statement += ` COLLATE ${field.collation}`;
-  }
-  if (field.type === "number" && field.increment === true) {
-    statement += " AUTOINCREMENT";
-  }
-  if (typeof field.check !== "undefined") {
-    const symbol = getSymbol(field.check);
-    statement += ` CHECK (${parseFieldExpression(model, "to", symbol?.value)})`;
-  }
-  if (typeof field.computedAs !== "undefined") {
-    const { kind, value } = field.computedAs;
-    const symbol = getSymbol(value);
-    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 modelList = models.some((item) => item.slug === model.slug) ? models : [...models, model];
-    const targetTable = getModelBySlug(modelList, field.target).table;
-    statement += ` REFERENCES ${targetTable}("id")`;
-    for (const trigger in actions) {
-      if (!Object.hasOwn(actions, trigger)) continue;
-      const triggerName = trigger.toUpperCase().slice(2);
-      const action = actions[trigger];
-      statement += ` ON ${triggerName} ${action}`;
-    }
+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 !== "nameIdentifier" && oldKey !== "slugIdentifier") continue;
+    const identifierName = oldKey === "nameIdentifier" ? "name" : "slug";
+    const value = newNestedInstructions[oldKey];
+    const newKey = identifiers[identifierName];
+    newNestedInstructions[newKey] = value;
+    delete newNestedInstructions[oldKey];
   }
-  return statement;
-};
-var PLURAL_MODEL_ENTITIES = {
-  field: "fields",
-  index: "indexes",
-  trigger: "triggers",
-  preset: "presets"
-};
-var PLURAL_MODEL_ENTITIES_VALUES = Object.values(PLURAL_MODEL_ENTITIES);
-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 handleSystemModel = (models, dependencyStatements, action, systemModel, newModel) => {
-  const { system: _, ...systemModelClean } = systemModel;
-  const query = {
-    [action]: { model: action === "create" ? systemModelClean : systemModelClean.slug }
+  return {
+    ...queryInstructions,
+    [type]: newNestedInstructions
   };
-  if (action === "alter" && newModel && "alter" in query && query.alter) {
-    const { system: _2, ...newModelClean } = newModel;
-    query.alter.to = newModelClean;
-  }
-  const statement = compileQueryInput(query, models, []);
-  dependencyStatements.push(...statement.dependencies);
 };
-var transformMetaQuery = (models, dependencyStatements, statementParams, query) => {
-  const { queryType } = splitQuery(query);
-  const subAltering = "alter" in query && 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 ("create" in query && query.create) {
-    const init = query.create.model;
-    jsonValue = "to" in query.create ? { slug: init, ...query.create.to } : init;
-    slug = modelSlug = jsonValue.slug;
-  }
-  if ("alter" in query && query.alter) {
-    if ("to" in query.alter) {
-      jsonValue = query.alter.to;
-    } else {
-      slug = query.alter[action][entity];
-      if ("create" in query.alter) {
-        const item = query.alter.create[entity];
-        slug = item.slug || `${entity}Slug`;
-        jsonValue = { slug, ...item };
-      }
-      if ("alter" in query.alter && query.alter.alter) jsonValue = query.alter.alter.to;
-    }
-  }
-  if (!(modelSlug && slug)) return query;
-  const model = action === "create" && entity === "model" ? null : getModelBySlug(models, modelSlug);
-  if (entity === "model") {
-    let queryTypeDetails = {};
-    if (action === "create") {
-      const newModel = jsonValue;
-      const modelWithFields = addDefaultModelFields(newModel, true);
-      const modelWithPresets = addDefaultModelPresets(
-        [...models, modelWithFields],
-        modelWithFields
-      );
-      modelWithPresets.fields = modelWithPresets.fields.map((field2) => ({
-        ...field2,
-        // Default field type.
-        type: field2.type || "string",
-        // Default field name.
-        name: field2.name || slugToName(field2.slug)
-      }));
-      const columns = modelWithPresets.fields.map((field2) => getFieldStatement(models, modelWithPresets, field2)).filter(Boolean);
-      const entities = Object.fromEntries(
-        Object.entries(PLURAL_MODEL_ENTITIES).map(([type, pluralType2]) => {
-          const list = modelWithPresets[pluralType2];
-          return [pluralType2, formatModelEntity(type, list)];
-        })
-      );
-      dependencyStatements.push({
-        statement: `CREATE TABLE "${modelWithPresets.table}" (${columns.join(", ")})`,
-        params: []
-      });
-      models.push(modelWithPresets);
-      const modelWithObjects = Object.assign({}, modelWithPresets);
-      for (const entity2 in entities) {
-        if (!Object.hasOwn(entities, entity2)) continue;
-        Object.defineProperty(modelWithObjects, entity2, { value: entities[entity2] });
-      }
-      queryTypeDetails = { to: modelWithObjects };
-      getSystemModels(models, modelWithPresets).map((systemModel) => {
-        return handleSystemModel(models, dependencyStatements, "create", systemModel);
-      });
-    }
-    if (action === "alter" && model) {
-      const newModel = jsonValue;
-      const modelWithFields = addDefaultModelFields(newModel, false);
-      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
-      const newTableName = modelWithPresets.table;
-      if (newTableName) {
-        dependencyStatements.push({
-          statement: `ALTER TABLE "${model.table}" RENAME TO "${newTableName}"`,
-          params: []
-        });
-      }
-      Object.assign(model, modelWithPresets);
-      queryTypeDetails = {
-        with: {
-          slug
-        },
-        to: modelWithPresets
-      };
-    }
-    if (action === "drop" && model) {
-      models.splice(models.indexOf(model), 1);
-      dependencyStatements.push({ statement: `DROP TABLE "${model.table}"`, params: [] });
-      queryTypeDetails = { with: { slug } };
-      models.filter(({ system }) => system?.model === model.slug).map((systemModel) => {
-        return handleSystemModel(models, dependencyStatements, "drop", systemModel);
-      });
-    }
-    const modelSlug2 = "to" in queryTypeDetails ? queryTypeDetails?.to?.slug : "with" in queryTypeDetails ? queryTypeDetails?.with?.slug : void 0;
-    if (modelSlug2 === "model") return null;
-    const queryTypeAction = action === "create" ? "add" : action === "alter" ? "set" : "remove";
-    return {
-      [queryTypeAction]: {
-        model: queryTypeDetails
-      }
-    };
+
+// src/instructions/with.ts
+var getMatcher = (value, negative) => {
+  if (negative) {
+    if (value === null) return "IS NOT";
+    return "!=";
   }
-  const modelBeforeUpdate = structuredClone(model);
-  const existingModel = model;
-  const pluralType = PLURAL_MODEL_ENTITIES[entity];
-  const targetEntityIndex = existingModel[pluralType]?.findIndex(
-    (entity2) => entity2.slug === slug
+  if (value === null) return "IS";
+  return "=";
+};
+var WITH_CONDITIONS = {
+  being: (value) => [getMatcher(value, false), value],
+  notBeing: (value) => [getMatcher(value, 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 = (models, model, statementParams, instruction, parentModel) => {
+  const subStatement = composeConditions(
+    models,
+    model,
+    statementParams,
+    "with",
+    instruction,
+    { parentModel }
   );
-  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]
-    });
+  return `(${subStatement})`;
+};
+
+// node_modules/title/dist/esm/lower-case.js
+var conjunctions = [
+  "for",
+  "and",
+  "nor",
+  "but",
+  "or",
+  "yet",
+  "so"
+];
+var articles = [
+  "a",
+  "an",
+  "the"
+];
+var prepositions = [
+  "aboard",
+  "about",
+  "above",
+  "across",
+  "after",
+  "against",
+  "along",
+  "amid",
+  "among",
+  "anti",
+  "around",
+  "as",
+  "at",
+  "before",
+  "behind",
+  "below",
+  "beneath",
+  "beside",
+  "besides",
+  "between",
+  "beyond",
+  "but",
+  "by",
+  "concerning",
+  "considering",
+  "despite",
+  "down",
+  "during",
+  "except",
+  "excepting",
+  "excluding",
+  "following",
+  "for",
+  "from",
+  "in",
+  "inside",
+  "into",
+  "like",
+  "minus",
+  "near",
+  "of",
+  "off",
+  "on",
+  "onto",
+  "opposite",
+  "over",
+  "past",
+  "per",
+  "plus",
+  "regarding",
+  "round",
+  "save",
+  "since",
+  "than",
+  "through",
+  "to",
+  "toward",
+  "towards",
+  "under",
+  "underneath",
+  "unlike",
+  "until",
+  "up",
+  "upon",
+  "versus",
+  "via",
+  "with",
+  "within",
+  "without"
+];
+var lowerCase = /* @__PURE__ */ new Set([
+  ...conjunctions,
+  ...articles,
+  ...prepositions
+]);
+
+// node_modules/title/dist/esm/specials.js
+var specials = [
+  "ZEIT",
+  "ZEIT Inc.",
+  "Vercel",
+  "Vercel Inc.",
+  "CLI",
+  "API",
+  "HTTP",
+  "HTTPS",
+  "JSX",
+  "DNS",
+  "URL",
+  "now.sh",
+  "now.json",
+  "vercel.app",
+  "vercel.json",
+  "CI",
+  "CD",
+  "CDN",
+  "package.json",
+  "package.lock",
+  "yarn.lock",
+  "GitHub",
+  "GitLab",
+  "CSS",
+  "Sass",
+  "JS",
+  "JavaScript",
+  "TypeScript",
+  "HTML",
+  "WordPress",
+  "Next.js",
+  "Node.js",
+  "Webpack",
+  "Docker",
+  "Bash",
+  "Kubernetes",
+  "SWR",
+  "TinaCMS",
+  "UI",
+  "UX",
+  "TS",
+  "TSX",
+  "iPhone",
+  "iPad",
+  "watchOS",
+  "iOS",
+  "iPadOS",
+  "macOS",
+  "PHP",
+  "composer.json",
+  "composer.lock",
+  "CMS",
+  "SQL",
+  "C",
+  "C#",
+  "GraphQL",
+  "GraphiQL",
+  "JWT",
+  "JWTs"
+];
+
+// node_modules/title/dist/esm/index.js
+var word = `[^\\s'\u2019\\(\\)!?;:"-]`;
+var regex = new RegExp(`(?:(?:(\\s?(?:^|[.\\(\\)!?;:"-])\\s*)(${word}))|(${word}))(${word}*[\u2019']*${word}*)`, "g");
+var convertToRegExp = (specials2) => specials2.map((s) => [new RegExp(`\\b${s}\\b`, "gi"), s]);
+function parseMatch(match) {
+  const firstCharacter = match[0];
+  if (/\s/.test(firstCharacter)) {
+    return match.slice(1);
   }
-  const existingEntity = existingModel[pluralType]?.[targetEntityIndex];
-  if (entity === "field") {
-    const statement = `ALTER TABLE "${existingModel.table}"`;
-    const existingField = existingEntity;
-    const existingLinkField = existingField?.type === "link" && existingField.kind === "many";
-    if (action === "create") {
-      const field2 = jsonValue;
-      field2.type = field2.type || "string";
-      field2.name = field2.name || slugToName(field2.slug);
-      const fieldStatement = getFieldStatement(models, existingModel, field2);
-      if (fieldStatement) {
-        dependencyStatements.push({
-          statement: `${statement} ADD COLUMN ${fieldStatement}`,
-          params: []
-        });
-      }
-    } else if (action === "alter") {
-      const field2 = jsonValue;
-      const newSlug = field2.slug;
-      if (newSlug) {
-        field2.name = field2.name || slugToName(field2.slug);
-        if (!existingLinkField) {
-          dependencyStatements.push({
-            statement: `${statement} RENAME COLUMN "${slug}" TO "${newSlug}"`,
-            params: []
-          });
-        }
-      }
-    } else if (action === "drop" && !existingLinkField) {
-      dependencyStatements.push({
-        statement: `${statement} DROP COLUMN "${slug}"`,
-        params: []
-      });
-    }
+  if (/[\(\)]/.test(firstCharacter)) {
+    return null;
   }
-  const statementAction = action.toUpperCase();
-  if (entity === "index") {
-    const index = jsonValue;
-    const indexName = convertToSnakeCase(slug);
-    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(existingModel, field2.slug, "to"));
-        } else if ("expression" in field2) {
-          fieldSelector = parseFieldExpression(existingModel, "to", field2.expression);
-        }
-        if (field2.collation) fieldSelector += ` COLLATE ${field2.collation}`;
-        if (field2.order) fieldSelector += ` ${field2.order}`;
-        return fieldSelector;
-      });
-      statement += ` ON "${existingModel.table}" (${columns.join(", ")})`;
-      if (index.filter) {
-        const withStatement = handleWith(models, existingModel, null, index.filter);
-        statement += ` WHERE (${withStatement})`;
-      }
+  return match;
+}
+var src_default = (str, options = {}) => {
+  str = str.toLowerCase().replace(regex, (m, lead = "", forced, lower, rest, offset, string) => {
+    const isLastWord = m.length + offset >= string.length;
+    const parsedMatch = parseMatch(m);
+    if (!parsedMatch) {
+      return m;
     }
-    dependencyStatements.push({ statement, params: [] });
-  }
-  if (entity === "trigger") {
-    const triggerName = convertToSnakeCase(slug);
-    let statement = `${statementAction} TRIGGER "${triggerName}"`;
-    if (action === "create") {
-      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 = trigger.fields.map((field2) => {
-          return getFieldFromModel(existingModel, field2.slug, "to").fieldSelector;
-        });
-        statementParts.push(`OF (${fieldSelectors.join(", ")})`);
-      }
-      statementParts.push("ON", `"${existingModel.table}"`);
-      if (trigger.filter || trigger.effects.some((query2) => findInObject(query2, QUERY_SYMBOLS.FIELD))) {
-        statementParts.push("FOR EACH ROW");
-      }
-      if (trigger.filter) {
-        const tableAlias = trigger.action === "DELETE" ? QUERY_SYMBOLS.FIELD_PARENT_OLD : QUERY_SYMBOLS.FIELD_PARENT_NEW;
-        const withStatement = handleWith(
-          models,
-          { ...existingModel, tableAlias },
-          null,
-          trigger.filter
-        );
-        statementParts.push("WHEN", `(${withStatement})`);
+    if (!forced) {
+      const fullLower = lower + rest;
+      if (lowerCase.has(fullLower) && !isLastWord) {
+        return parsedMatch;
       }
-      const effectStatements = trigger.effects.map((effectQuery) => {
-        return compileQueryInput(effectQuery, models, null, {
-          returning: false,
-          parentModel: existingModel
-        }).main.statement;
-      });
-      statementParts.push("BEGIN");
-      statementParts.push(`${effectStatements.join("; ")};`);
-      statementParts.push("END");
-      statement += ` ${statementParts.join(" ")}`;
     }
-    dependencyStatements.push({ statement, params: [] });
+    return lead + (lower || forced).toUpperCase() + rest;
+  });
+  const customSpecials = options.special || [];
+  const replace = [...specials, ...customSpecials];
+  const replaceRegExp = convertToRegExp(replace);
+  replaceRegExp.forEach(([pattern, s]) => {
+    str = str.replace(pattern, s);
+  });
+  return str;
+};
+
+// src/model/defaults.ts
+var slugToName = (slug) => {
+  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
+  return src_default(name);
+};
+var VOWELS = ["a", "e", "i", "o", "u"];
+var pluralize = (word2) => {
+  const lastLetter = word2.slice(-1).toLowerCase();
+  const secondLastLetter = word2.slice(-2, -1).toLowerCase();
+  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
+    return `${word2.slice(0, -1)}ies`;
   }
-  const field = `${QUERY_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];
-      Object.assign(targetEntity[targetEntityIndex], jsonValue);
-      break;
-    }
-    case "drop": {
-      json = `json_remove(${field}, '$.${slug}')`;
-      const targetEntity = existingModel[pluralType];
-      targetEntity.splice(targetEntityIndex, 1);
-    }
+  if (lastLetter === "s" || word2.slice(-2).toLowerCase() === "ch" || word2.slice(-2).toLowerCase() === "sh" || word2.slice(-2).toLowerCase() === "ex") {
+    return `${word2}es`;
   }
-  const currentSystemModels = models.filter(({ system }) => {
-    return system?.model === existingModel.slug;
-  });
-  const newSystemModels = getSystemModels(models, existingModel);
-  const matchSystemModels = (oldSystemModel, newSystemModel) => {
-    const conditions = [
-      oldSystemModel.system?.model === newSystemModel.system?.model
-    ];
-    if (oldSystemModel.system?.associationSlug) {
-      const oldFieldIndex = modelBeforeUpdate?.fields.findIndex((item) => {
-        return item.slug === newSystemModel.system?.associationSlug;
-      });
-      const newFieldIndex = existingModel.fields.findIndex((item) => {
-        return item.slug === oldSystemModel.system?.associationSlug;
-      });
-      conditions.push(oldFieldIndex === newFieldIndex);
+  return `${word2}s`;
+};
+var modelAttributes = [
+  ["pluralSlug", "slug", pluralize],
+  ["name", "slug", slugToName],
+  ["pluralName", "pluralSlug", slugToName],
+  ["idPrefix", "slug", (slug) => slug.slice(0, 3)],
+  ["table", "pluralSlug", convertToSnakeCase]
+];
+var getModelIdentifier = () => {
+  return `mod_${Array.from(crypto.getRandomValues(new Uint8Array(12))).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16).toLowerCase()}`;
+};
+var addDefaultModelAttributes = (model, isNew) => {
+  const copiedModel = { ...model };
+  if (isNew && !copiedModel.id) copiedModel.id = getModelIdentifier();
+  for (const [setting, base, generator] of modelAttributes) {
+    if (copiedModel[setting] || !copiedModel[base]) continue;
+    copiedModel[setting] = generator(copiedModel[base]);
+  }
+  const newFields = copiedModel.fields || [];
+  if (isNew || newFields.length > 0) {
+    if (!copiedModel.identifiers) copiedModel.identifiers = {};
+    if (!copiedModel.identifiers.name) {
+      const suitableField = newFields.find(
+        (field) => field.type === "string" && field.required === true && ["name"].includes(field.slug)
+      );
+      copiedModel.identifiers.name = suitableField?.slug || "id";
     }
-    return conditions.every((condition) => condition === true);
-  };
-  for (const systemModel of currentSystemModels) {
-    const exists = newSystemModels.find(matchSystemModels.bind(null, systemModel));
-    if (exists) {
-      if (exists.slug !== systemModel.slug) {
-        handleSystemModel(models, dependencyStatements, "alter", systemModel, exists);
-      }
-      continue;
+    if (!copiedModel.identifiers.slug) {
+      const suitableField = newFields.find(
+        (field) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(field.slug)
+      );
+      copiedModel.identifiers.slug = suitableField?.slug || "id";
     }
-    handleSystemModel(models, dependencyStatements, "drop", systemModel);
   }
-  for (const systemModel of newSystemModels) {
-    const exists = currentSystemModels.find(matchSystemModels.bind(null, systemModel));
-    if (exists) continue;
-    handleSystemModel(models, dependencyStatements, "create", systemModel);
+  return copiedModel;
+};
+var addDefaultModelFields = (model, isNew) => {
+  const copiedModel = { ...model };
+  const newFields = copiedModel.fields || [];
+  if (isNew || newFields.length > 0) {
+    copiedModel.fields = [...getSystemFields(copiedModel.idPrefix), ...newFields];
+  }
+  return copiedModel;
+};
+var addDefaultModelPresets = (list, model) => {
+  const defaultPresets = [];
+  for (const field of model.fields || []) {
+    if (field.type === "link" && !field.slug.startsWith("ronin.")) {
+      const relatedModel = getModelBySlug(list, field.target);
+      if (field.kind === "many") continue;
+      defaultPresets.push({
+        instructions: {
+          including: {
+            [field.slug]: {
+              [QUERY_SYMBOLS.QUERY]: {
+                get: {
+                  [relatedModel.slug]: {
+                    with: {
+                      // Compare the `id` field of the related model to the link field on
+                      // the root model (`field.slug`).
+                      id: {
+                        [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}${field.slug}`
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        slug: field.slug
+      });
+    }
   }
-  return {
-    set: {
-      model: {
-        with: { slug: modelSlug },
-        to: {
-          [pluralType]: { [QUERY_SYMBOLS.EXPRESSION]: json }
+  const childModels = list.map((subModel) => {
+    const field = subModel.fields?.find((field2) => {
+      return field2.type === "link" && field2.target === model.slug;
+    });
+    if (!field) return null;
+    return { model: subModel, field };
+  }).filter((match) => match !== null);
+  for (const childMatch of childModels) {
+    const { model: childModel, field: childField } = childMatch;
+    const pluralSlug = childModel.pluralSlug;
+    const presetSlug = childModel.system?.associationSlug || pluralSlug;
+    defaultPresets.push({
+      instructions: {
+        including: {
+          [presetSlug]: {
+            [QUERY_SYMBOLS.QUERY]: {
+              get: {
+                [pluralSlug]: {
+                  with: {
+                    [childField.slug]: {
+                      [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
-      }
-    }
-  };
+      },
+      slug: presetSlug
+    });
+  }
+  if (Object.keys(defaultPresets).length > 0) {
+    model.presets = [...defaultPresets, ...model.presets || []];
+  }
+  return model;
 };
 
-// src/utils/pagination.ts
-var CURSOR_SEPARATOR = ",";
-var CURSOR_NULL_PLACEHOLDER = "RONIN_NULL";
-var generatePaginationCursor = (model, orderedBy, record) => {
-  const { ascending = [], descending = [] } = orderedBy || {};
-  const keys = [...ascending, ...descending];
-  if (keys.length === 0) keys.push("ronin.createdAt");
-  const cursors = keys.map((fieldSlug) => {
-    const property = getProperty(record, fieldSlug);
-    if (property === null || property === void 0) return CURSOR_NULL_PLACEHOLDER;
-    const { field } = getFieldFromModel(model, fieldSlug, "orderedBy");
-    if (field.type === "date") return new Date(property).getTime();
-    return property;
+// src/model/index.ts
+var getModelBySlug = (models, slug) => {
+  const model = models.find((model2) => {
+    return model2.slug === slug || model2.pluralSlug === slug;
   });
-  return cursors.map((cursor) => encodeURIComponent(String(cursor))).join(CURSOR_SEPARATOR);
-};
-
-// src/instructions/before-after.ts
-var handleBeforeOrAfter = (model, statementParams, instructions) => {
-  if (!(instructions.before || instructions.after)) {
-    throw new RoninError({
-      message: "The `before` or `after` instruction must not be empty.",
-      code: "MISSING_INSTRUCTION"
-    });
-  }
-  if (instructions.before && instructions.after) {
+  if (!model) {
     throw new RoninError({
-      message: "The `before` and `after` instructions cannot co-exist. Choose one.",
-      code: "MUTUALLY_EXCLUSIVE_INSTRUCTIONS"
+      message: `No matching model with either Slug or Plural Slug of "${slug}" could be found.`,
+      code: "MODEL_NOT_FOUND"
     });
   }
-  if (!instructions.limitedTo) {
-    let message = "When providing a pagination cursor in the `before` or `after`";
-    message += " instruction, a `limitedTo` instruction must be provided as well, to";
-    message += " define the page size.";
-    throw new RoninError({
-      message,
-      code: "MISSING_INSTRUCTION"
-    });
+  return model;
+};
+var composeAssociationModelSlug = (model, field) => convertToCamelCase(`ronin_link_${model.slug}_${field.slug}`);
+var getFieldSelector = (model, field, fieldPath, writing) => {
+  const symbol = model.tableAlias?.startsWith(QUERY_SYMBOLS.FIELD_PARENT) ? `${model.tableAlias.replace(QUERY_SYMBOLS.FIELD_PARENT, "").slice(0, -1)}.` : "";
+  const tablePrefix = symbol || (model.tableAlias ? `"${model.tableAlias}".` : "");
+  if (field.type === "json" && !writing) {
+    const dotParts = fieldPath.split(".");
+    const columnName = tablePrefix + dotParts.shift();
+    const jsonField = dotParts.join(".");
+    return `json_extract(${columnName}, '$.${jsonField}')`;
   }
-  const { ascending = [], descending = [] } = instructions.orderedBy || {};
-  const clause = instructions.with ? "AND " : "";
-  const chunks = (instructions.before || instructions.after).toString().split(CURSOR_SEPARATOR).map(decodeURIComponent);
-  const keys = [...ascending, ...descending];
-  const values = keys.map((key, index) => {
-    const value = chunks[index];
-    if (value === CURSOR_NULL_PLACEHOLDER) {
-      return "NULL";
-    }
-    const { field } = getFieldFromModel(model, key, "orderedBy");
-    if (field.type === "boolean") {
-      return prepareStatementValue(statementParams, value === "true");
-    }
-    if (field.type === "number") {
-      return prepareStatementValue(statementParams, Number.parseInt(value));
-    }
-    if (field.type === "date") {
-      return `'${new Date(Number.parseInt(value)).toJSON()}'`;
-    }
-    return prepareStatementValue(statementParams, value);
-  });
-  const compareOperators = [
-    // Reverse the comparison operators if we're querying for records before.
-    ...new Array(ascending.length).fill(instructions.before ? "<" : ">"),
-    ...new Array(descending.length).fill(instructions.before ? ">" : "<")
-  ];
-  const conditions = new Array();
-  for (let i = 0; i < keys.length; i++) {
-    if (values[i] === "NULL" && compareOperators[i] === "<") {
-      continue;
-    }
-    const condition = new Array();
-    for (let j = 0; j <= i; j++) {
-      const key = keys[j];
-      const value = values[j];
-      let { field, fieldSelector } = getFieldFromModel(model, key, "orderedBy");
-      if (j === i) {
-        const closingParentheses = ")".repeat(condition.length);
-        const operator = value === "NULL" ? "IS NOT" : compareOperators[j];
-        const caseInsensitiveStatement = value !== "NULL" && field.type === "string" ? " COLLATE NOCASE" : "";
-        if (value !== "NULL" && operator === "<" && !["ronin.createdAt", "ronin.updatedAt"].includes(key)) {
-          fieldSelector = `IFNULL(${fieldSelector}, -1e999)`;
-        }
-        condition.push(
-          `(${fieldSelector} ${operator} ${value}${caseInsensitiveStatement})${closingParentheses}`
-        );
-      } else {
-        const operator = value === "NULL" ? "IS" : "=";
-        condition.push(`(${fieldSelector} ${operator} ${value} AND`);
-      }
+  return `${tablePrefix}"${fieldPath}"`;
+};
+function getFieldFromModel(model, fieldPath, source, shouldThrow = true) {
+  const writingField = "instructionName" in source ? source.instructionName === "to" : true;
+  const errorTarget = "instructionName" in source ? `\`${source.instructionName}\`` : `${source.modelEntityType} "${source.modelEntityName}"`;
+  const errorPrefix = `Field "${fieldPath}" defined for ${errorTarget}`;
+  const modelFields = model.fields || [];
+  let modelField;
+  if (fieldPath.includes(".")) {
+    modelField = modelFields.find((field) => field.slug === fieldPath.split(".")[0]);
+    if (modelField?.type === "json") {
+      const fieldSelector2 = getFieldSelector(model, modelField, fieldPath, writingField);
+      return { field: modelField, fieldSelector: fieldSelector2 };
     }
-    conditions.push(condition.join(" "));
   }
-  return `${clause}(${conditions.join(" OR ")})`;
-};
-
-// src/instructions/for.ts
-var handleFor = (model, instructions) => {
-  const normalizedFor = Array.isArray(instructions.for) ? Object.fromEntries(instructions.for.map((presetSlug) => [presetSlug, null])) : instructions.for;
-  for (const presetSlug in normalizedFor) {
-    if (!Object.hasOwn(normalizedFor, presetSlug)) continue;
-    const arg = normalizedFor[presetSlug];
-    const preset = model.presets?.find((preset2) => preset2.slug === presetSlug);
-    if (!preset) {
+  modelField = modelFields.find((field) => field.slug === fieldPath);
+  if (!modelField) {
+    if (shouldThrow) {
       throw new RoninError({
-        message: `Preset "${presetSlug}" does not exist in model "${model.name}".`,
-        code: "PRESET_NOT_FOUND"
+        message: `${errorPrefix} does not exist in model "${model.name}".`,
+        code: "FIELD_NOT_FOUND",
+        field: fieldPath,
+        queries: null
       });
     }
-    const replacedForFilter = structuredClone(preset.instructions);
-    if (arg !== null) {
-      findInObject(
-        replacedForFilter,
-        QUERY_SYMBOLS.VALUE,
-        (match) => match.replace(QUERY_SYMBOLS.VALUE, arg)
-      );
-    }
-    for (const subInstruction in replacedForFilter) {
-      if (!Object.hasOwn(replacedForFilter, subInstruction)) continue;
-      const instructionName = subInstruction;
-      const currentValue = instructions[instructionName];
-      if (currentValue) {
-        let newValue;
-        if (Array.isArray(currentValue)) {
-          newValue = [
-            ...replacedForFilter[instructionName],
-            ...currentValue
-          ];
-        } else if (isObject(currentValue)) {
-          newValue = {
-            ...replacedForFilter[instructionName],
-            ...currentValue
-          };
-        }
-        Object.assign(instructions, { [instructionName]: newValue });
-        continue;
-      }
-      Object.assign(instructions, {
-        [instructionName]: replacedForFilter[instructionName]
-      });
+    return null;
+  }
+  const fieldSelector = getFieldSelector(model, modelField, fieldPath, writingField);
+  return { field: modelField, fieldSelector };
+}
+var getSystemFields = (idPrefix = "rec") => [
+  {
+    name: "ID",
+    type: "string",
+    slug: "id",
+    defaultValue: {
+      // Since default values in SQLite cannot rely on other columns, we unfortunately
+      // cannot rely on the `idPrefix` column here. Instead, we need to inject it directly
+      // into the expression as a static string.
+      [QUERY_SYMBOLS.EXPRESSION]: `'${idPrefix}_' || lower(substr(hex(randomblob(12)), 1, 16))`
     }
+  },
+  {
+    name: "RONIN - Locked",
+    type: "boolean",
+    slug: "ronin.locked"
+  },
+  {
+    name: "RONIN - Created At",
+    type: "date",
+    slug: "ronin.createdAt",
+    defaultValue: CURRENT_TIME_EXPRESSION
+  },
+  {
+    name: "RONIN - Created By",
+    type: "string",
+    slug: "ronin.createdBy"
+  },
+  {
+    name: "RONIN - Updated At",
+    type: "date",
+    slug: "ronin.updatedAt",
+    defaultValue: CURRENT_TIME_EXPRESSION
+  },
+  {
+    name: "RONIN - Updated By",
+    type: "string",
+    slug: "ronin.updatedBy"
   }
-  return instructions;
+];
+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.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: "{}" }
+  ]
 };
-
-// src/instructions/including.ts
-var handleIncluding = (models, model, statementParams, instruction) => {
-  let statement = "";
-  let tableSubQuery;
-  for (const ephemeralFieldSlug in instruction) {
-    if (!Object.hasOwn(instruction, ephemeralFieldSlug)) continue;
-    const symbol = getSymbol(instruction[ephemeralFieldSlug]);
-    if (symbol?.type !== "query") continue;
-    const { queryType, queryModel, queryInstructions } = splitQuery(symbol.value);
-    let modifiableQueryInstructions = queryInstructions;
-    const relatedModel = getModelBySlug(models, queryModel);
-    let joinType = "LEFT";
-    let relatedTableSelector = `"${relatedModel.table}"`;
-    const tableAlias = composeIncludedTableAlias(ephemeralFieldSlug);
-    const single = queryModel !== relatedModel.pluralSlug;
-    if (!modifiableQueryInstructions?.with) {
-      joinType = "CROSS";
-      if (single) {
-        if (!modifiableQueryInstructions) modifiableQueryInstructions = {};
-        modifiableQueryInstructions.limitedTo = 1;
+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.id,
+            associationSlug: field.slug
+          },
+          fields: [
+            {
+              slug: "source",
+              type: "link",
+              target: model.slug
+            },
+            {
+              slug: "target",
+              type: "link",
+              target: relatedModel.slug
+            }
+          ]
+        });
       }
     }
-    if (modifiableQueryInstructions?.limitedTo || modifiableQueryInstructions?.orderedBy) {
-      const subSelect = compileQueryInput(
-        {
-          [queryType]: {
-            [queryModel]: modifiableQueryInstructions
-          }
-        },
-        models,
-        statementParams
-      );
-      relatedTableSelector = `(${subSelect.main.statement})`;
-    }
-    statement += `${joinType} JOIN ${relatedTableSelector} as ${tableAlias}`;
-    model.tableAlias = model.tableAlias || model.table;
-    if (joinType === "LEFT") {
-      const subStatement = composeConditions(
-        models,
-        { ...relatedModel, tableAlias },
-        statementParams,
-        "including",
-        queryInstructions?.with,
-        {
-          parentModel: model
-        }
-      );
-      statement += ` ON (${subStatement})`;
-    }
-    if (!single) tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
   }
-  return { statement, tableSubQuery };
+  return addedModels;
 };
-
-// src/instructions/limited-to.ts
-var handleLimitedTo = (single, instruction) => {
-  let amount;
-  if (instruction) amount = instruction + 1;
-  if (single) amount = 1;
-  return `LIMIT ${amount} `;
+var typesInSQLite = {
+  link: "TEXT",
+  string: "TEXT",
+  date: "DATETIME",
+  blob: "TEXT",
+  boolean: "BOOLEAN",
+  number: "INTEGER",
+  json: "TEXT"
 };
-
-// src/instructions/ordered-by.ts
-var handleOrderedBy = (model, instruction) => {
-  let statement = "";
-  const items = [
-    ...(instruction.ascending || []).map((value) => ({ value, order: "ASC" })),
-    ...(instruction.descending || []).map((value) => ({ value, order: "DESC" }))
-  ];
-  for (const item of items) {
-    if (statement.length > 0) {
-      statement += ", ";
-    }
-    const symbol = getSymbol(item.value);
-    const instructionName = item.order === "ASC" ? "orderedBy.ascending" : "orderedBy.descending";
-    if (symbol?.type === "expression") {
-      statement += `(${parseFieldExpression(model, instructionName, symbol.value)}) ${item.order}`;
-      continue;
-    }
-    const { field: modelField, fieldSelector } = getFieldFromModel(
-      model,
-      item.value,
-      instructionName
-    );
-    const caseInsensitiveStatement = modelField.type === "string" ? " COLLATE NOCASE" : "";
-    statement += `${fieldSelector}${caseInsensitiveStatement} ${item.order}`;
+var getFieldStatement = (models, model, field) => {
+  let statement = `"${field.slug}" ${typesInSQLite[field.type || "string"]}`;
+  if (field.slug === "id") statement += " PRIMARY KEY";
+  if (field.unique === true) statement += " UNIQUE";
+  if (field.required === true) statement += " NOT NULL";
+  if (typeof field.defaultValue !== "undefined") {
+    const symbol = getSymbol(field.defaultValue);
+    let value = typeof field.defaultValue === "string" ? `'${field.defaultValue}'` : field.defaultValue;
+    if (symbol) value = `(${parseFieldExpression(model, "to", symbol.value)})`;
+    statement += ` DEFAULT ${value}`;
   }
-  return `ORDER BY ${statement}`;
-};
-
-// src/instructions/selecting.ts
-var handleSelecting = (models, model, statementParams, instructions, options) => {
-  let loadedFields = [];
-  let expandColumns = false;
-  let statement = "*";
-  let isJoining = false;
-  if (instructions.including) {
-    const flatObject = flatten(instructions.including);
-    instructions.including = {};
-    for (const [key, value] of Object.entries(flatObject)) {
-      const symbol = getSymbol(value);
-      if (symbol?.type === "query") {
-        const { queryModel, queryInstructions } = splitQuery(symbol.value);
-        const subQueryModel = getModelBySlug(models, queryModel);
-        isJoining = true;
-        expandColumns = Boolean(options?.expandColumns || queryInstructions?.selecting);
-        const tableAlias = composeIncludedTableAlias(key);
-        const single = queryModel !== subQueryModel.pluralSlug;
-        if (!single) {
-          model.tableAlias = `sub_${model.table}`;
-        }
-        const queryModelFields = queryInstructions?.selecting ? subQueryModel.fields.filter((field) => {
-          return queryInstructions.selecting?.includes(field.slug);
-        }) : (
-          // Exclude link fields with cardinality "many", since those don't exist as columns.
-          subQueryModel.fields.filter((field) => {
-            return !(field.type === "link" && field.kind === "many");
-          })
-        );
-        for (const field of queryModelFields) {
-          loadedFields.push({ ...field, parentField: key });
-          if (expandColumns) {
-            const newValue2 = parseFieldExpression(
-              { ...subQueryModel, tableAlias },
-              "including",
-              `${QUERY_SYMBOLS.FIELD}${field.slug}`
-            );
-            instructions.including[`${tableAlias}.${field.slug}`] = newValue2;
-          }
-        }
-        continue;
-      }
-      let newValue = value;
-      if (symbol?.type === "expression") {
-        newValue = `(${parseFieldExpression(model, "including", symbol.value)})`;
-      } else {
-        newValue = prepareStatementValue(statementParams, value);
-      }
-      instructions.including[key] = newValue;
-      loadedFields.push({
-        slug: key,
-        type: RAW_FIELD_TYPES.includes(typeof value) ? typeof value : "string"
-      });
-    }
+  if (field.type === "string" && field.collation) {
+    statement += ` COLLATE ${field.collation}`;
   }
-  if (expandColumns) {
-    instructions.selecting = model.fields.filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => field.slug);
+  if (field.type === "number" && field.increment === true) {
+    statement += " AUTOINCREMENT";
   }
-  if (instructions.selecting) {
-    const usableModel = expandColumns ? { ...model, tableAlias: model.tableAlias || model.table } : model;
-    const selectedFields = [];
-    statement = instructions.selecting.map((slug) => {
-      const { field, fieldSelector } = getFieldFromModel(
-        usableModel,
-        slug,
-        "selecting"
-      );
-      selectedFields.push(field);
-      return fieldSelector;
-    }).join(", ");
-    loadedFields = [...selectedFields, ...loadedFields];
-  } else {
-    loadedFields = [
-      ...model.fields.filter(
-        (field) => !(field.type === "link" && field.kind === "many")
-      ),
-      ...loadedFields
-    ];
+  if (typeof field.check !== "undefined") {
+    const symbol = getSymbol(field.check);
+    statement += ` CHECK (${parseFieldExpression(model, "to", symbol?.value)})`;
   }
-  if (instructions.including && Object.keys(instructions.including).length > 0) {
-    statement += ", ";
-    statement += Object.entries(instructions.including).map(([key, value]) => `${value} as "${key}"`).join(", ");
+  if (typeof field.computedAs !== "undefined") {
+    const { kind, value } = field.computedAs;
+    const symbol = getSymbol(value);
+    statement += ` GENERATED ALWAYS AS (${parseFieldExpression(model, "to", symbol?.value)}) ${kind}`;
   }
-  return { columns: statement, isJoining, loadedFields };
+  if (field.type === "link") {
+    if (field.kind === "many") return null;
+    const actions = field.actions || {};
+    const modelList = models.some((item) => item.slug === model.slug) ? models : [...models, model];
+    const targetTable = getModelBySlug(modelList, field.target).table;
+    statement += ` REFERENCES ${targetTable}("id")`;
+    for (const trigger in actions) {
+      if (!Object.hasOwn(actions, trigger)) continue;
+      const triggerName = trigger.toUpperCase().slice(2);
+      const action = actions[trigger];
+      statement += ` ON ${triggerName} ${action}`;
+    }
+  }
+  return statement;
+};
+var PLURAL_MODEL_ENTITIES = {
+  field: "fields",
+  index: "indexes",
+  trigger: "triggers",
+  preset: "presets"
 };
-
-// src/instructions/to.ts
-var handleTo = (models, model, statementParams, queryType, dependencyStatements, instructions, parentModel) => {
-  const { with: withInstruction, to: toInstruction } = instructions;
-  const defaultFields = {};
-  if (queryType === "set" || toInstruction.ronin) {
-    defaultFields.ronin = {
-      // If records are being updated, bump their update time.
-      ...queryType === "set" ? { updatedAt: CURRENT_TIME_EXPRESSION } : {},
-      // Allow for overwriting the default values provided above.
-      ...toInstruction.ronin
-    };
+var PLURAL_MODEL_ENTITIES_VALUES = Object.values(PLURAL_MODEL_ENTITIES);
+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 handleSystemModel = (models, dependencyStatements, action, systemModel, newModel) => {
+  const { system: _, ...systemModelClean } = systemModel;
+  const query = {
+    [action]: { model: action === "create" ? systemModelClean : systemModelClean.slug }
+  };
+  if (action === "alter" && newModel && "alter" in query && query.alter) {
+    const { system: _2, ...newModelClean } = newModel;
+    query.alter.to = newModelClean;
   }
-  const symbol = getSymbol(toInstruction);
-  if (symbol?.type === "query") {
-    const { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
-    const subQueryModel = getModelBySlug(models, subQueryModelSlug);
-    if (subQueryInstructions?.selecting) {
-      const currentFields = new Set(subQueryInstructions.selecting);
-      currentFields.add("id");
-      subQueryInstructions.selecting = Array.from(currentFields);
-    }
-    const subQuerySelectedFields = subQueryInstructions?.selecting;
-    const subQueryIncludedFields = subQueryInstructions?.including;
-    const subQueryFields = [
-      ...subQuerySelectedFields || (subQueryModel.fields || []).map((field) => field.slug),
-      ...subQueryIncludedFields ? Object.keys(
-        flatten(subQueryIncludedFields || {})
-      ) : []
+  const statement = compileQueryInput(query, models, []);
+  dependencyStatements.push(...statement.dependencies);
+};
+var handleSystemModels = (models, dependencyStatements, previousModel, newModel) => {
+  const currentSystemModels = models.filter(({ system }) => {
+    return system?.model === newModel.id;
+  });
+  const newSystemModels = getSystemModels(models, newModel);
+  const matchSystemModels = (oldSystemModel, newSystemModel) => {
+    const conditions = [
+      oldSystemModel.system?.model === newSystemModel.system?.model
     ];
-    for (const field of subQueryFields || []) {
-      getFieldFromModel(model, field, "to");
-    }
-    let statement2 = "";
-    if (subQuerySelectedFields) {
-      const columns = subQueryFields.map((field) => {
-        return getFieldFromModel(model, field, "to").fieldSelector;
+    if (oldSystemModel.system?.associationSlug) {
+      const oldFieldIndex = previousModel.fields.findIndex((item) => {
+        return item.slug === newSystemModel.system?.associationSlug;
       });
-      statement2 = `(${columns.join(", ")}) `;
+      const newFieldIndex = newModel.fields.findIndex((item) => {
+        return item.slug === oldSystemModel.system?.associationSlug;
+      });
+      conditions.push(oldFieldIndex === newFieldIndex);
     }
-    statement2 += compileQueryInput(symbol.value, models, statementParams).main.statement;
-    return statement2;
-  }
-  Object.assign(toInstruction, defaultFields);
-  for (const fieldSlug in toInstruction) {
-    if (!Object.hasOwn(toInstruction, fieldSlug)) continue;
-    const fieldValue = toInstruction[fieldSlug];
-    const fieldDetails = getFieldFromModel(model, fieldSlug, "to", false);
-    if (fieldDetails?.field.type === "link" && fieldDetails.field.kind === "many") {
-      delete toInstruction[fieldSlug];
-      const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);
-      const composeStatement = (subQueryType, value) => {
-        const source = queryType === "add" ? { id: toInstruction.id } : withInstruction;
-        const recordDetails = { source };
-        if (value) recordDetails.target = value;
-        return compileQueryInput(
-          {
-            [subQueryType]: {
-              [associativeModelSlug]: subQueryType === "add" ? { to: recordDetails } : { with: recordDetails }
-            }
-          },
-          models,
-          [],
-          { returning: false }
-        ).main;
-      };
-      if (Array.isArray(fieldValue)) {
-        dependencyStatements.push(composeStatement("remove"));
-        for (const record of fieldValue) {
-          dependencyStatements.push(composeStatement("add", record));
-        }
-      } else if (isObject(fieldValue)) {
-        const value = fieldValue;
-        for (const recordToAdd of value.containing || []) {
-          dependencyStatements.push(composeStatement("add", recordToAdd));
-        }
-        for (const recordToRemove of value.notContaining || []) {
-          dependencyStatements.push(composeStatement("remove", recordToRemove));
-        }
+    return conditions.every((condition) => condition === true);
+  };
+  for (const systemModel of currentSystemModels) {
+    const exists = newSystemModels.find(matchSystemModels.bind(null, systemModel));
+    if (exists) {
+      if (exists.slug !== systemModel.slug) {
+        handleSystemModel(models, dependencyStatements, "alter", systemModel, exists);
       }
+      continue;
     }
+    handleSystemModel(models, dependencyStatements, "drop", systemModel);
   }
-  let statement = composeConditions(models, model, statementParams, "to", toInstruction, {
-    parentModel,
-    type: queryType === "add" ? "fields" : void 0
-  });
-  if (queryType === "add") {
-    const deepStatement = composeConditions(
-      models,
-      model,
-      statementParams,
-      "to",
-      toInstruction,
-      {
-        parentModel,
-        type: "values"
-      }
-    );
-    statement = `(${statement}) VALUES (${deepStatement})`;
-  } else if (queryType === "set") {
-    statement = `SET ${statement}`;
+  for (const systemModel of newSystemModels) {
+    const exists = currentSystemModels.find(matchSystemModels.bind(null, systemModel));
+    if (exists) continue;
+    handleSystemModel(models, dependencyStatements, "create", systemModel);
   }
-  return statement;
 };
-
-// src/utils/index.ts
-var compileQueryInput = (defaultQuery, models, statementParams, options) => {
-  const dependencyStatements = [];
-  const query = transformMetaQuery(
-    models,
-    dependencyStatements,
-    statementParams,
-    defaultQuery
-  );
-  if (query === null)
-    return { dependencies: [], main: dependencyStatements[0], loadedFields: [] };
-  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 returning = options?.returning ?? true;
-  if (instructions && Object.hasOwn(instructions, "for")) {
-    instructions = handleFor(model, instructions);
-  }
-  const { columns, isJoining, loadedFields } = handleSelecting(
-    models,
-    model,
-    statementParams,
-    {
-      selecting: instructions?.selecting,
-      including: instructions?.including
-    },
-    options
-  );
-  let statement = "";
-  switch (queryType) {
-    case "get":
-      statement += `SELECT ${columns} FROM `;
-      break;
-    case "set":
-      statement += "UPDATE ";
-      break;
-    case "add":
-      statement += "INSERT INTO ";
-      break;
-    case "remove":
-      statement += "DELETE FROM ";
-      break;
-    case "count":
-      statement += `SELECT COUNT(${columns}) FROM `;
-      break;
+var transformMetaQuery = (models, dependencyStatements, statementParams, query) => {
+  const { queryType } = splitQuery(query);
+  const subAltering = "alter" in query && 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 ("create" in query && query.create) {
+    const init = query.create.model;
+    jsonValue = "to" in query.create ? { slug: init, ...query.create.to } : init;
+    slug = modelSlug = jsonValue.slug;
   }
-  let isJoiningMultipleRows = false;
-  if (isJoining) {
-    const { statement: including, tableSubQuery } = handleIncluding(
-      models,
-      model,
-      statementParams,
-      instructions?.including
-    );
-    if (tableSubQuery) {
-      statement += `(${tableSubQuery}) as ${model.tableAlias} `;
-      isJoiningMultipleRows = true;
+  if ("alter" in query && query.alter) {
+    if ("to" in query.alter) {
+      jsonValue = query.alter.to;
     } else {
-      statement += `"${model.table}" `;
+      slug = query.alter[action][entity];
+      if ("create" in query.alter) {
+        const item = query.alter.create[entity];
+        slug = item.slug || `${entity}Slug`;
+        jsonValue = { slug, ...item };
+      }
+      if ("alter" in query.alter && query.alter.alter) jsonValue = query.alter.alter.to;
+    }
+  }
+  if (!(modelSlug && slug)) return query;
+  const model = action === "create" && entity === "model" ? null : getModelBySlug(models, modelSlug);
+  if (entity === "model") {
+    let queryTypeDetails = {};
+    if (action === "create") {
+      const newModel = jsonValue;
+      const modelWithAttributes = addDefaultModelAttributes(newModel, true);
+      const modelWithFields = addDefaultModelFields(modelWithAttributes, true);
+      const modelWithPresets = addDefaultModelPresets(
+        [...models, modelWithFields],
+        modelWithFields
+      );
+      modelWithPresets.fields = modelWithPresets.fields.map((field2) => ({
+        ...field2,
+        // Default field type.
+        type: field2.type || "string",
+        // Default field name.
+        name: field2.name || slugToName(field2.slug)
+      }));
+      const columns = modelWithPresets.fields.map((field2) => getFieldStatement(models, modelWithPresets, field2)).filter(Boolean);
+      const entities = Object.fromEntries(
+        Object.entries(PLURAL_MODEL_ENTITIES).map(([type, pluralType2]) => {
+          const list = modelWithPresets[pluralType2];
+          return [pluralType2, formatModelEntity(type, list)];
+        })
+      );
+      dependencyStatements.push({
+        statement: `CREATE TABLE "${modelWithPresets.table}" (${columns.join(", ")})`,
+        params: []
+      });
+      models.push(modelWithPresets);
+      const modelWithObjects = Object.assign({}, modelWithPresets);
+      for (const entity2 in entities) {
+        if (!Object.hasOwn(entities, entity2)) continue;
+        Object.defineProperty(modelWithObjects, entity2, { value: entities[entity2] });
+      }
+      queryTypeDetails = { to: modelWithObjects };
+      getSystemModels(models, modelWithPresets).map((systemModel) => {
+        return handleSystemModel(models, dependencyStatements, "create", systemModel);
+      });
     }
-    statement += `${including} `;
-  } else {
-    statement += `"${model.table}" `;
-  }
-  if (queryType === "add" || queryType === "set") {
-    if (!isObject(instructions.to) || Object.keys(instructions.to).length === 0) {
-      throw new RoninError({
-        message: `When using a \`${queryType}\` query, the \`to\` instruction must be a non-empty object.`,
-        code: "INVALID_TO_VALUE",
-        queries: [query]
+    if (action === "alter" && model) {
+      const modelBeforeUpdate2 = structuredClone(model);
+      const newModel = jsonValue;
+      const modelWithAttributes = addDefaultModelAttributes(newModel, false);
+      const modelWithFields = addDefaultModelFields(modelWithAttributes, false);
+      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
+      const newTableName = modelWithPresets.table;
+      if (newTableName) {
+        dependencyStatements.push({
+          statement: `ALTER TABLE "${model.table}" RENAME TO "${newTableName}"`,
+          params: []
+        });
+      }
+      Object.assign(model, modelWithPresets);
+      queryTypeDetails = {
+        with: {
+          slug
+        },
+        to: modelWithPresets
+      };
+      handleSystemModels(models, dependencyStatements, modelBeforeUpdate2, model);
+    }
+    if (action === "drop" && model) {
+      models.splice(models.indexOf(model), 1);
+      dependencyStatements.push({ statement: `DROP TABLE "${model.table}"`, params: [] });
+      queryTypeDetails = { with: { slug } };
+      models.filter(({ system }) => system?.model === model.id).map((systemModel) => {
+        return handleSystemModel(models, dependencyStatements, "drop", systemModel);
       });
     }
-    const toStatement = handleTo(
-      models,
-      model,
-      statementParams,
-      queryType,
-      dependencyStatements,
-      { with: instructions.with, to: instructions.to },
-      options?.parentModel
-    );
-    statement += `${toStatement} `;
+    const modelSlug2 = "to" in queryTypeDetails ? queryTypeDetails?.to?.slug : "with" in queryTypeDetails ? queryTypeDetails?.with?.slug : void 0;
+    if (modelSlug2 === "model") return null;
+    const queryTypeAction = action === "create" ? "add" : action === "alter" ? "set" : "remove";
+    return {
+      [queryTypeAction]: {
+        model: queryTypeDetails
+      }
+    };
   }
-  const conditions = [];
-  if (queryType !== "add" && instructions && Object.hasOwn(instructions, "with")) {
-    const withStatement = handleWith(
-      models,
-      model,
-      statementParams,
-      instructions.with,
-      options?.parentModel
-    );
-    if (withStatement.length > 0) conditions.push(withStatement);
+  const modelBeforeUpdate = structuredClone(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]
+    });
   }
-  if ((queryType === "get" || queryType === "count") && !single && instructions?.limitedTo) {
-    instructions = instructions || {};
-    instructions.orderedBy = instructions.orderedBy || {};
-    instructions.orderedBy.ascending = instructions.orderedBy.ascending || [];
-    instructions.orderedBy.descending = instructions.orderedBy.descending || [];
-    if (![
-      ...instructions.orderedBy.ascending,
-      ...instructions.orderedBy.descending
-    ].includes("ronin.createdAt")) {
-      instructions.orderedBy.descending.push("ronin.createdAt");
-    }
+  const existingEntity = existingModel[pluralType]?.[targetEntityIndex];
+  if (action === "create" && existingEntity) {
+    throw new RoninError({
+      message: `A ${entity} with the slug "${slug}" already exists.`,
+      code: "EXISTING_MODEL_ENTITY",
+      fields: ["slug"]
+    });
   }
-  if (instructions && (Object.hasOwn(instructions, "before") || Object.hasOwn(instructions, "after"))) {
-    if (single) {
-      throw new RoninError({
-        message: "The `before` and `after` instructions are not supported when querying for a single record.",
-        code: "INVALID_BEFORE_OR_AFTER_INSTRUCTION",
-        queries: [query]
+  if (entity === "field") {
+    const statement = `ALTER TABLE "${existingModel.table}"`;
+    const existingField = existingEntity;
+    const existingLinkField = existingField?.type === "link" && existingField.kind === "many";
+    if (action === "create") {
+      const field2 = jsonValue;
+      field2.type = field2.type || "string";
+      field2.name = field2.name || slugToName(field2.slug);
+      const fieldStatement = getFieldStatement(models, existingModel, field2);
+      if (fieldStatement) {
+        dependencyStatements.push({
+          statement: `${statement} ADD COLUMN ${fieldStatement}`,
+          params: []
+        });
+      }
+    } else if (action === "alter") {
+      const field2 = jsonValue;
+      const newSlug = field2.slug;
+      if (newSlug) {
+        field2.name = field2.name || slugToName(field2.slug);
+        if (!existingLinkField) {
+          dependencyStatements.push({
+            statement: `${statement} RENAME COLUMN "${slug}" TO "${newSlug}"`,
+            params: []
+          });
+        }
+      }
+    } else if (action === "drop" && !existingLinkField) {
+      const systemFields = getSystemFields(existingModel.idPrefix);
+      const isSystemField = systemFields.some((field2) => field2.slug === slug);
+      if (isSystemField) {
+        throw new RoninError({
+          message: `The ${entity} "${slug}" is a system ${entity} and cannot be removed.`,
+          code: "REQUIRED_MODEL_ENTITY"
+        });
+      }
+      dependencyStatements.push({
+        statement: `${statement} DROP COLUMN "${slug}"`,
+        params: []
       });
     }
-    const beforeAndAfterStatement = handleBeforeOrAfter(model, statementParams, {
-      before: instructions.before,
-      after: instructions.after,
-      with: instructions.with,
-      orderedBy: instructions.orderedBy,
-      limitedTo: instructions.limitedTo
-    });
-    conditions.push(beforeAndAfterStatement);
   }
-  if (conditions.length > 0) {
-    if (conditions.length === 1) {
-      statement += `WHERE ${conditions[0]} `;
-    } else {
-      statement += `WHERE (${conditions.join(" ")}) `;
+  const statementAction = action.toUpperCase();
+  if (entity === "index") {
+    const index = jsonValue;
+    const indexName = convertToSnakeCase(slug);
+    let statement = `${statementAction}${index?.unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
+    if (action === "create") {
+      if (!Array.isArray(index.fields) || index.fields.length === 0) {
+        throw new RoninError({
+          message: `When ${actionReadable} ${PLURAL_MODEL_ENTITIES[entity]}, at least one field must be provided.`,
+          code: "INVALID_MODEL_VALUE",
+          fields: ["fields"]
+        });
+      }
+      const columns = index.fields.map((field2) => {
+        let fieldSelector = "";
+        if ("slug" in field2) {
+          ({ fieldSelector } = getFieldFromModel(existingModel, field2.slug, {
+            modelEntityType: "index",
+            modelEntityName: indexName
+          }));
+        } else if ("expression" in field2) {
+          fieldSelector = parseFieldExpression(existingModel, "to", field2.expression);
+        }
+        if (field2.collation) fieldSelector += ` COLLATE ${field2.collation}`;
+        if (field2.order) fieldSelector += ` ${field2.order}`;
+        return fieldSelector;
+      });
+      statement += ` ON "${existingModel.table}" (${columns.join(", ")})`;
+      if (index.filter) {
+        const withStatement = handleWith(models, existingModel, null, index.filter);
+        statement += ` WHERE (${withStatement})`;
+      }
     }
+    dependencyStatements.push({ statement, params: [] });
   }
-  if (instructions?.orderedBy) {
-    const orderedByStatement = handleOrderedBy(model, instructions.orderedBy);
-    statement += `${orderedByStatement} `;
-  }
-  if (queryType === "get" && !isJoiningMultipleRows && (single || instructions?.limitedTo)) {
-    statement += handleLimitedTo(single, instructions?.limitedTo);
+  if (entity === "trigger") {
+    const triggerName = convertToSnakeCase(slug);
+    let statement = `${statementAction} TRIGGER "${triggerName}"`;
+    if (action === "create") {
+      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 = trigger.fields.map((field2) => {
+          return getFieldFromModel(existingModel, field2.slug, {
+            modelEntityType: "trigger",
+            modelEntityName: triggerName
+          }).fieldSelector;
+        });
+        statementParts.push(`OF (${fieldSelectors.join(", ")})`);
+      }
+      statementParts.push("ON", `"${existingModel.table}"`);
+      if (trigger.filter || trigger.effects.some((query2) => findInObject(query2, QUERY_SYMBOLS.FIELD))) {
+        statementParts.push("FOR EACH ROW");
+      }
+      if (trigger.filter) {
+        const tableAlias = trigger.action === "DELETE" ? QUERY_SYMBOLS.FIELD_PARENT_OLD : QUERY_SYMBOLS.FIELD_PARENT_NEW;
+        const withStatement = handleWith(
+          models,
+          { ...existingModel, tableAlias },
+          null,
+          trigger.filter
+        );
+        statementParts.push("WHEN", `(${withStatement})`);
+      }
+      const effectStatements = trigger.effects.map((effectQuery) => {
+        return compileQueryInput(effectQuery, models, null, {
+          returning: false,
+          parentModel: existingModel
+        }).main.statement;
+      });
+      statementParts.push("BEGIN");
+      statementParts.push(`${effectStatements.join("; ")};`);
+      statementParts.push("END");
+      statement += ` ${statementParts.join(" ")}`;
+    }
+    dependencyStatements.push({ statement, params: [] });
   }
-  if (["add", "set", "remove"].includes(queryType) && returning) {
-    statement += "RETURNING * ";
+  const field = `${QUERY_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];
+      Object.assign(targetEntity[targetEntityIndex], jsonValue);
+      break;
+    }
+    case "drop": {
+      json = `json_remove(${field}, '$.${slug}')`;
+      const targetEntity = existingModel[pluralType];
+      targetEntity.splice(targetEntityIndex, 1);
+    }
   }
-  const mainStatement = {
-    statement: statement.trimEnd(),
-    params: statementParams || []
-  };
-  if (returning) mainStatement.returning = true;
+  handleSystemModels(models, dependencyStatements, modelBeforeUpdate, existingModel);
   return {
-    dependencies: dependencyStatements,
-    main: mainStatement,
-    loadedFields
+    set: {
+      model: {
+        with: { slug: modelSlug },
+        to: {
+          [pluralType]: { [QUERY_SYMBOLS.EXPRESSION]: json }
+        }
+      }
+    }
   };
 };
 
@@ -1789,10 +1845,13 @@ var Transaction = class {
    * @returns The composed SQL statements.
    */
   compileQueries = (queries, models, options) => {
+    const modelsWithAttributes = models.map((model) => {
+      return addDefaultModelAttributes(model, true);
+    });
     const modelList = [
-      ROOT_MODEL,
-      ...models.flatMap((model) => getSystemModels(models, model)),
-      ...models
+      addDefaultModelAttributes(ROOT_MODEL, true),
+      ...modelsWithAttributes.flatMap((model) => getSystemModels(modelsWithAttributes, model)).map((model) => addDefaultModelAttributes(model, true)),
+      ...modelsWithAttributes
     ].map((model) => {
       return addDefaultModelFields(model, true);
     });