@ronin/compiler 0.1.0

package/dist/index.js

@@ -0,0 +1,1093 @@
+// src/utils/index.ts
+import { init as cuid } from "@paralleldrive/cuid2";
+var RONIN_SCHEMA_SYMBOLS = {
+  QUERY: "__RONIN_QUERY",
+  FIELD: "__RONIN_FIELD_",
+  VALUE: "__RONIN_VALUE"
+};
+var RoninError = class extends Error {
+  code;
+  field;
+  fields;
+  issues;
+  queries;
+  constructor(details) {
+    super(details.message);
+    this.name = "RoninError";
+    this.code = details.code;
+    this.field = details.field;
+    this.fields = details.fields;
+    this.issues = details.issues;
+    this.queries = details.queries || null;
+  }
+};
+var SINGLE_QUOTE_REGEX = /'/g;
+var DOUBLE_QUOTE_REGEX = /"/g;
+var AMPERSAND_REGEX = /\s*&+\s*/g;
+var SPECIAL_CHARACTERS_REGEX = /[^\w\s-]+/g;
+var SPLIT_REGEX = /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|[\s.\-_]+/;
+var generateRecordId = (prefix) => `${prefix || "rec"}_${cuid({ length: 16 })()}`;
+var capitalize = (str) => {
+  if (!str || str.length === 0) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+var sanitize = (str) => {
+  if (!str || str.length === 0) return "";
+  return str.replace(SINGLE_QUOTE_REGEX, "").replace(DOUBLE_QUOTE_REGEX, "").replace(AMPERSAND_REGEX, " and ").replace(SPECIAL_CHARACTERS_REGEX, " ").trim();
+};
+var convertToSnakeCase = (str) => {
+  if (!str || str.length === 0) return "";
+  return sanitize(str).split(SPLIT_REGEX).map((part) => part.toLowerCase()).join("_");
+};
+var convertToCamelCase = (str) => {
+  if (!str || str.length === 0) return "";
+  return sanitize(str).split(SPLIT_REGEX).map((part, index) => index === 0 ? part.toLowerCase() : capitalize(part)).join("");
+};
+var isObject = (value) => value != null && typeof value === "object" && Array.isArray(value) === false;
+var replaceInObject = (obj, pattern, replacer) => {
+  for (const key in obj) {
+    const value = obj[key];
+    if (isObject(value)) {
+      replaceInObject(value, pattern, replacer);
+    } else if (typeof value === "string" && value.startsWith(pattern)) {
+      obj[key] = value.replace(pattern, replacer);
+    }
+  }
+};
+var flatten = (obj, prefix = "", res = {}) => {
+  for (const key in obj) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (typeof obj[key] === "object" && obj[key] !== null) {
+      flatten(obj[key], path, res);
+    } else {
+      res[path] = obj[key];
+    }
+  }
+  return res;
+};
+var expand = (obj) => {
+  return Object.entries(obj).reduce((res, [key, val]) => {
+    key.split(".").reduce((acc, part, i, arr) => {
+      acc[part] = i === arr.length - 1 ? val : acc[part] || {};
+      return acc[part];
+    }, res);
+    return res;
+  }, {});
+};
+var splitQuery = (query) => {
+  const queryType = Object.keys(query)[0];
+  const querySchema = Object.keys(query[queryType])[0];
+  const queryInstructions = query[queryType][querySchema];
+  return { queryType, querySchema, queryInstructions };
+};
+
+// src/utils/schema.ts
+var getSchemaBySlug = (schemas, slug) => {
+  const schema = schemas.find((schema2) => {
+    return schema2.slug === slug || schema2.pluralSlug === slug;
+  });
+  if (!schema) {
+    throw new RoninError({
+      message: `No matching schema with either Slug or Plural Slug of "${slug}" could be found.`,
+      code: "SCHEMA_NOT_FOUND"
+    });
+  }
+  return schema;
+};
+var getTableForSchema = (schema) => {
+  return convertToSnakeCase(schema.pluralSlug);
+};
+var getSchemaName = (schema) => {
+  return schema.name || schema.slug;
+};
+var composeMetaSchemaSlug = (suffix) => convertToCamelCase(`ronin_${suffix}`);
+var composeAssociationSchemaSlug = (schema, field) => composeMetaSchemaSlug(`${schema.pluralSlug}_${field.slug}`);
+var getFieldSelector = (field, fieldPath, rootTable) => {
+  const tablePrefix = rootTable ? `"${rootTable}".` : "";
+  if (field.type === "json") {
+    const dotParts = fieldPath.split(".");
+    const columnName = tablePrefix + dotParts.shift();
+    const jsonField = dotParts.join(".");
+    return `json_extract(${columnName}, '$.${jsonField}')`;
+  }
+  return `${tablePrefix}"${fieldPath}"`;
+};
+var getFieldFromSchema = (schema, fieldPath, instructionName, rootTable) => {
+  const errorPrefix = `Field "${fieldPath}" defined for \`${instructionName}\``;
+  const schemaFields = schema.fields || [];
+  let schemaField;
+  if (fieldPath.includes(".")) {
+    schemaField = schemaFields.find((field) => field.slug === fieldPath.split(".")[0]);
+    if (schemaField?.type === "json") {
+      const fieldSelector2 = getFieldSelector(schemaField, fieldPath, rootTable);
+      return { field: schemaField, fieldSelector: fieldSelector2 };
+    }
+  }
+  schemaField = schemaFields.find((field) => field.slug === fieldPath);
+  if (!schemaField) {
+    throw new RoninError({
+      message: `${errorPrefix} does not exist in schema "${getSchemaName(schema)}".`,
+      code: "FIELD_NOT_FOUND",
+      field: fieldPath,
+      queries: null
+    });
+  }
+  const fieldSelector = getFieldSelector(schemaField, fieldPath, rootTable);
+  return { field: schemaField, fieldSelector };
+};
+var SYSTEM_FIELDS = [
+  {
+    name: "ID",
+    type: "string",
+    slug: "id",
+    displayAs: "single-line"
+  },
+  {
+    name: "RONIN",
+    type: "group",
+    slug: "ronin"
+  },
+  {
+    name: "RONIN - Locked",
+    type: "boolean",
+    slug: "ronin.locked"
+  },
+  {
+    name: "RONIN - Created At",
+    type: "date",
+    slug: "ronin.createdAt"
+  },
+  {
+    name: "RONIN - Created By",
+    type: "reference",
+    schema: "account",
+    slug: "ronin.createdBy"
+  },
+  {
+    name: "RONIN - Updated At",
+    type: "date",
+    slug: "ronin.updatedAt"
+  },
+  {
+    name: "RONIN - Updated By",
+    type: "reference",
+    schema: "account",
+    slug: "ronin.updatedBy"
+  }
+];
+var SYSTEM_SCHEMAS = [
+  {
+    name: "Schema",
+    pluralName: "Schemas",
+    slug: "schema",
+    pluralSlug: "schemas",
+    fields: [
+      ...SYSTEM_FIELDS,
+      { slug: "name", type: "string" },
+      { slug: "pluralName", type: "string" },
+      { slug: "slug", type: "string" },
+      { slug: "pluralSlug", type: "string" },
+      { slug: "idPrefix", type: "string" },
+      { slug: "identifiers", type: "group" },
+      { slug: "identifiers.title", type: "string" },
+      { slug: "identifiers.slug", type: "string" }
+    ]
+  },
+  {
+    name: "Field",
+    pluralName: "Fields",
+    slug: "field",
+    pluralSlug: "fields",
+    fields: [
+      ...SYSTEM_FIELDS,
+      { slug: "name", type: "string" },
+      { slug: "slug", type: "string" },
+      { slug: "type", type: "string" },
+      { slug: "schema", type: "reference", schema: "schema" },
+      { slug: "required", type: "boolean" },
+      { slug: "defaultValue", type: "string" },
+      { slug: "unique", type: "boolean" },
+      { slug: "autoIncrement", type: "boolean" }
+    ]
+  }
+];
+var addSystemSchemas = (schemas) => {
+  const list = [...SYSTEM_SCHEMAS, ...schemas].map((schema) => ({ ...schema }));
+  for (const schema of list) {
+    const defaultIncluding = {};
+    for (const field of schema.fields || []) {
+      if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
+        const relatedSchema = getSchemaBySlug(list, field.schema);
+        let fieldSlug = relatedSchema.slug;
+        if (field.kind === "many") {
+          fieldSlug = composeAssociationSchemaSlug(schema, field);
+          list.push({
+            pluralSlug: fieldSlug,
+            slug: fieldSlug,
+            fields: [
+              {
+                slug: "origin",
+                type: "reference",
+                schema: schema.slug
+              },
+              {
+                slug: "target",
+                type: "reference",
+                schema: relatedSchema.slug
+              }
+            ]
+          });
+        }
+        defaultIncluding[field.slug] = {
+          get: {
+            [fieldSlug]: {
+              with: {
+                // Compare the `id` field of the related schema to the reference field on
+                // the root schema (`field.slug`).
+                id: `${RONIN_SCHEMA_SYMBOLS.FIELD}${field.slug}`
+              }
+            }
+          }
+        };
+        const relatedSchemaToModify = list.find((schema2) => schema2.slug === field.schema);
+        if (!relatedSchemaToModify) throw new Error("Missing related schema");
+        relatedSchemaToModify.including = {
+          [schema.pluralSlug]: {
+            get: {
+              [schema.pluralSlug]: {
+                with: {
+                  [field.slug]: `${RONIN_SCHEMA_SYMBOLS.FIELD}id`
+                }
+              }
+            }
+          },
+          ...relatedSchemaToModify.including
+        };
+      }
+    }
+    schema.fields = [...SYSTEM_FIELDS, ...schema.fields || []];
+    schema.including = { ...defaultIncluding, ...schema.including };
+  }
+  return list;
+};
+var mappedInstructions = {
+  create: "to",
+  set: "with",
+  drop: "with"
+};
+var typesInSQLite = {
+  reference: "TEXT",
+  string: "TEXT",
+  date: "DATETIME",
+  blob: "TEXT",
+  boolean: "BOOLEAN",
+  number: "INTEGER",
+  json: "TEXT"
+};
+var getFieldStatement = (field) => {
+  if (field.type === "group") return null;
+  let statement = `"${field.slug}" ${typesInSQLite[field.type]}`;
+  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")
+    statement += ` DEFAULT ${field.defaultValue}`;
+  return statement;
+};
+var addSchemaQueries = (queryDetails, writeStatements) => {
+  const { queryType, querySchema, queryInstructions } = queryDetails;
+  if (!["create", "set", "drop"].includes(queryType)) return;
+  if (!["schema", "schemas", "field", "fields"].includes(querySchema)) return;
+  const instructionName = mappedInstructions[queryType];
+  const instructionList = queryInstructions[instructionName];
+  const kind = ["schema", "schemas"].includes(querySchema) ? "schemas" : "fields";
+  const instructionTarget = kind === "schemas" ? instructionList : instructionList?.schema;
+  let tableAction = "ALTER";
+  let schemaPluralSlug = null;
+  let queryTypeReadable = null;
+  switch (queryType) {
+    case "create": {
+      if (kind === "schemas") tableAction = "CREATE";
+      schemaPluralSlug = instructionTarget?.pluralSlug;
+      queryTypeReadable = "creating";
+      break;
+    }
+    case "set": {
+      if (kind === "schemas") tableAction = "ALTER";
+      schemaPluralSlug = instructionTarget?.pluralSlug?.being || instructionTarget?.pluralSlug;
+      queryTypeReadable = "updating";
+      break;
+    }
+    case "drop": {
+      if (kind === "schemas") tableAction = "DROP";
+      schemaPluralSlug = instructionTarget?.pluralSlug?.being || instructionTarget?.pluralSlug;
+      queryTypeReadable = "deleting";
+      break;
+    }
+  }
+  if (!schemaPluralSlug) {
+    const field = kind === "schemas" ? "pluralSlug" : "schema.pluralSlug";
+    throw new RoninError({
+      message: `When ${queryTypeReadable} ${kind}, a \`${field}\` field must be provided in the \`${instructionName}\` instruction.`,
+      code: "MISSING_FIELD",
+      fields: [field]
+    });
+  }
+  const table = convertToSnakeCase(schemaPluralSlug);
+  const fields = [...SYSTEM_FIELDS];
+  let statement = `${tableAction} TABLE "${table}"`;
+  if (kind === "schemas") {
+    if (queryType === "create") {
+      const columns = fields.map(getFieldStatement).filter(Boolean);
+      statement += ` (${columns.join(", ")})`;
+    } else if (queryType === "set") {
+      const newSlug = queryInstructions.to?.pluralSlug;
+      if (newSlug) {
+        const newTable = convertToSnakeCase(newSlug);
+        statement += ` RENAME TO "${newTable}"`;
+      }
+    }
+  } else if (kind === "fields") {
+    const fieldSlug = instructionTarget?.slug?.being || instructionList?.slug;
+    if (!fieldSlug) {
+      throw new RoninError({
+        message: `When ${queryTypeReadable} fields, a \`slug\` field must be provided in the \`${instructionName}\` instruction.`,
+        code: "MISSING_FIELD",
+        fields: ["slug"]
+      });
+    }
+    if (queryType === "create") {
+      if (!instructionList.type) {
+        throw new RoninError({
+          message: `When ${queryTypeReadable} fields, a \`type\` field must be provided in the \`to\` instruction.`,
+          code: "MISSING_FIELD",
+          fields: ["type"]
+        });
+      }
+      statement += ` ADD COLUMN ${getFieldStatement(instructionList)}`;
+    } else if (queryType === "set") {
+      const newSlug = queryInstructions.to?.slug;
+      if (newSlug) {
+        statement += ` RENAME COLUMN "${fieldSlug}" TO "${newSlug}"`;
+      }
+    } else if (queryType === "drop") {
+      statement += ` DROP COLUMN "${fieldSlug}"`;
+    }
+  }
+  writeStatements.push(statement);
+};
+
+// src/instructions/with.ts
+var WITH_CONDITIONS = [
+  "being",
+  "notBeing",
+  "startingWith",
+  "notStartingWith",
+  "endingWith",
+  "notEndingWith",
+  "containing",
+  "notContaining",
+  "greaterThan",
+  "greaterOrEqual",
+  "lessThan",
+  "lessOrEqual"
+];
+var handleWith = (schemas, schema, statementValues, instruction, rootTable) => {
+  const subStatement = composeConditions(
+    schemas,
+    schema,
+    statementValues,
+    "with",
+    instruction,
+    { rootTable }
+  );
+  return `(${subStatement})`;
+};
+
+// src/utils/statement.ts
+var prepareStatementValue = (statementValues, value, bindNull = false) => {
+  if (!bindNull && value === null) return "NULL";
+  let formattedValue = value;
+  if (Array.isArray(value) || isObject(value)) {
+    formattedValue = JSON.stringify(value);
+  } else if (typeof value === "boolean") {
+    formattedValue = value ? 1 : 0;
+  }
+  const index = statementValues.push(formattedValue);
+  return `?${index}`;
+};
+var composeFieldValues = (schemas, schema, statementValues, instructionName, value, options) => {
+  const { field: schemaField, fieldSelector: selector } = getFieldFromSchema(
+    schema,
+    options.fieldSlug,
+    instructionName,
+    options.rootTable
+  );
+  const isSubQuery = isObject(value) && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY);
+  const collectStatementValue = options.type !== "fields";
+  let conditionSelector = selector;
+  let conditionValue = value;
+  if (isSubQuery && collectStatementValue) {
+    conditionValue = `(${compileQueryInput(
+      value[RONIN_SCHEMA_SYMBOLS.QUERY],
+      schemas,
+      { statementValues }
+    ).readStatement})`;
+  } else if (typeof value === "string" && value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD)) {
+    conditionSelector = `"${options.customTable}"."${schemaField.slug}"`;
+    conditionValue = `"${options.rootTable}"."${value.replace(RONIN_SCHEMA_SYMBOLS.FIELD, "")}"`;
+  } else if (schemaField.type === "json" && instructionName === "to") {
+    conditionSelector = `"${schemaField.slug}"`;
+    if (collectStatementValue) {
+      const preparedValue = prepareStatementValue(statementValues, value, false);
+      conditionValue = `IIF(${conditionSelector} IS NULL, ${preparedValue}, json_patch(${conditionSelector}, ${preparedValue}))`;
+    }
+  } else if (collectStatementValue) {
+    conditionValue = prepareStatementValue(statementValues, value, false);
+  }
+  if (options.type === "fields") return conditionSelector;
+  if (options.type === "values") return conditionValue;
+  const conditionTypes = {
+    being: [getMatcher(value, false), conditionValue],
+    notBeing: [getMatcher(value, true), conditionValue],
+    startingWith: ["LIKE", `${conditionValue}%`],
+    notStartingWith: ["NOT LIKE", `${conditionValue}%`],
+    endingWith: ["LIKE", `%${conditionValue}`],
+    notEndingWith: ["NOT LIKE", `%${conditionValue}`],
+    containing: ["LIKE", `%${conditionValue}%`],
+    notContaining: ["NOT LIKE", `%${conditionValue}%`],
+    greaterThan: [">", conditionValue],
+    greaterOrEqual: [">=", conditionValue],
+    lessThan: ["<", conditionValue],
+    lessOrEqual: ["<=", conditionValue]
+  };
+  return `${conditionSelector} ${conditionTypes[options.condition || "being"].join(" ")}`;
+};
+var composeConditions = (schemas, schema, statementValues, instructionName, value, options) => {
+  const isNested = isObject(value) && Object.keys(value).length > 0;
+  if (isNested && Object.keys(value).every(
+    (key) => WITH_CONDITIONS.includes(key)
+  )) {
+    const conditions = Object.entries(value).map(
+      ([conditionType, checkValue]) => composeConditions(schemas, schema, statementValues, instructionName, checkValue, {
+        ...options,
+        condition: conditionType
+      })
+    );
+    return conditions.join(" AND ");
+  }
+  if (options.fieldSlug) {
+    const fieldDetails = getFieldFromSchema(
+      schema,
+      options.fieldSlug,
+      instructionName,
+      options.rootTable
+    );
+    const { field: schemaField } = fieldDetails;
+    const consumeJSON = schemaField.type === "json" && instructionName === "to";
+    const isSubQuery = isNested && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY);
+    if (!(isObject(value) || Array.isArray(value)) || isSubQuery || consumeJSON) {
+      return composeFieldValues(
+        schemas,
+        schema,
+        statementValues,
+        instructionName,
+        value,
+        { ...options, fieldSlug: options.fieldSlug }
+      );
+    }
+    if (schemaField.type === "reference" && isNested) {
+      const keys = Object.keys(value);
+      const values = Object.values(value);
+      let recordTarget;
+      if (keys.length === 1 && keys[0] === "id") {
+        recordTarget = values[0];
+      } else {
+        const relatedSchema = getSchemaBySlug(schemas, schemaField.schema);
+        const subQuery = {
+          get: {
+            [relatedSchema.slug]: {
+              with: value,
+              selecting: ["id"]
+            }
+          }
+        };
+        recordTarget = {
+          [RONIN_SCHEMA_SYMBOLS.QUERY]: subQuery
+        };
+      }
+      return composeConditions(
+        schemas,
+        schema,
+        statementValues,
+        instructionName,
+        recordTarget,
+        options
+      );
+    }
+  }
+  if (isNested) {
+    const conditions = Object.entries(value).map(([field, value2]) => {
+      const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
+      return composeConditions(schemas, schema, statementValues, instructionName, value2, {
+        ...options,
+        fieldSlug: nestedFieldSlug
+      });
+    });
+    const joiner = instructionName === "to" ? ", " : " AND ";
+    if (instructionName === "to") return `${conditions.join(joiner)}`;
+    return conditions.length === 1 ? conditions[0] : options.fieldSlug ? `(${conditions.join(joiner)})` : conditions.join(joiner);
+  }
+  if (Array.isArray(value)) {
+    const conditions = value.map(
+      (filter) => composeConditions(
+        schemas,
+        schema,
+        statementValues,
+        instructionName,
+        filter,
+        options
+      )
+    );
+    return conditions.join(" OR ");
+  }
+  throw new RoninError({
+    message: `The \`with\` instruction must not contain an empty field. The following fields are empty: \`${options.fieldSlug}\`. If you meant to query by an empty field, try using \`null\` instead.`,
+    code: "INVALID_WITH_VALUE",
+    queries: null
+  });
+};
+var getMatcher = (value, negative) => {
+  if (negative) {
+    if (value === null) return "IS NOT";
+    return "!=";
+  }
+  if (value === null) return "IS";
+  return "=";
+};
+var formatIdentifiers = ({ identifiers }, queryInstructions) => {
+  if (!queryInstructions) return queryInstructions;
+  const type = "with" in queryInstructions ? "with" : null;
+  if (!type) return queryInstructions;
+  const nestedInstructions = queryInstructions[type];
+  if (!nestedInstructions || Array.isArray(nestedInstructions))
+    return queryInstructions;
+  const newNestedInstructions = { ...nestedInstructions };
+  for (const oldKey of Object.keys(newNestedInstructions)) {
+    if (oldKey !== "titleIdentifier" && oldKey !== "slugIdentifier") continue;
+    const identifierName = oldKey === "titleIdentifier" ? "title" : "slug";
+    const value = newNestedInstructions[oldKey];
+    const newKey = identifiers?.[identifierName] || "id";
+    newNestedInstructions[newKey] = value;
+    delete newNestedInstructions[oldKey];
+  }
+  return {
+    ...queryInstructions,
+    [type]: newNestedInstructions
+  };
+};
+
+// src/instructions/before-after.ts
+var CURSOR_SEPARATOR = ",";
+var CURSOR_NULL_PLACEHOLDER = "RONIN_NULL";
+var handleBeforeOrAfter = (schema, statementValues, instructions, rootTable) => {
+  if (!(instructions.before || instructions.after)) {
+    throw new RoninError({
+      message: "The `before` or `after` instruction must not be empty.",
+      code: "MISSING_INSTRUCTION",
+      queries: null
+    });
+  }
+  if (instructions.before && instructions.after) {
+    throw new RoninError({
+      message: "The `before` and `after` instructions cannot co-exist. Choose one.",
+      code: "MUTUALLY_EXCLUSIVE_INSTRUCTIONS",
+      queries: null
+    });
+  }
+  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 } = getFieldFromSchema(schema, key, "orderedBy");
+    if (field.type === "boolean") {
+      return prepareStatementValue(statementValues, value === "true");
+    }
+    if (field.type === "number") {
+      return prepareStatementValue(statementValues, Number.parseInt(value));
+    }
+    if (field.type === "date") {
+      return `'${new Date(Number.parseInt(value)).toJSON()}'`;
+    }
+    return prepareStatementValue(statementValues, 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 } = getFieldFromSchema(
+        schema,
+        key,
+        "orderedBy",
+        rootTable
+      );
+      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`);
+      }
+    }
+    conditions.push(condition.join(" "));
+  }
+  return `${clause}(${conditions.join(" OR ")})`;
+};
+
+// src/instructions/for.ts
+var handleFor = (schemas, schema, statementValues, instruction, rootTable) => {
+  let statement = "";
+  if (!instruction) return statement;
+  for (const shortcut in instruction) {
+    const args = instruction[shortcut];
+    const forFilter = schema.for?.[shortcut];
+    if (!forFilter) {
+      throw new RoninError({
+        message: `The provided \`for\` shortcut "${shortcut}" does not exist in schema "${getSchemaName(schema)}".`,
+        code: "INVALID_FOR_VALUE"
+      });
+    }
+    const replacedForFilter = structuredClone(forFilter);
+    replaceInObject(
+      replacedForFilter,
+      RONIN_SCHEMA_SYMBOLS.VALUE,
+      (match) => match.replace(RONIN_SCHEMA_SYMBOLS.VALUE, args)
+    );
+    const subStatement = composeConditions(
+      schemas,
+      schema,
+      statementValues,
+      "for",
+      replacedForFilter,
+      { rootTable }
+    );
+    statement += `(${subStatement})`;
+  }
+  return statement;
+};
+
+// src/instructions/including.ts
+var handleIncluding = (schemas, statementValues, schema, instruction, rootTable) => {
+  let statement = "";
+  let rootTableSubQuery;
+  let rootTableName = rootTable;
+  for (const shortcut of instruction || []) {
+    const includingQuery = schema.including?.[shortcut];
+    if (!includingQuery) {
+      throw new RoninError({
+        message: `The provided \`including\` shortcut "${shortcut}" does not exist in schema "${getSchemaName(schema)}".`,
+        code: "INVALID_INCLUDING_VALUE"
+      });
+    }
+    const { queryType, querySchema, queryInstructions } = splitQuery(includingQuery);
+    let modifiableQueryInstructions = queryInstructions;
+    const relatedSchema = getSchemaBySlug(schemas, querySchema);
+    let joinType = "LEFT";
+    let relatedTableSelector = `"${getTableForSchema(relatedSchema)}"`;
+    const tableAlias = `including_${shortcut}`;
+    const single = querySchema !== relatedSchema.pluralSlug;
+    if (!modifiableQueryInstructions?.with) {
+      joinType = "CROSS";
+      if (single) {
+        if (!modifiableQueryInstructions) modifiableQueryInstructions = {};
+        modifiableQueryInstructions.limitedTo = 1;
+      }
+    }
+    if (modifiableQueryInstructions?.limitedTo || modifiableQueryInstructions?.orderedBy) {
+      const subSelect = compileQueryInput(
+        {
+          [queryType]: {
+            [querySchema]: modifiableQueryInstructions
+          }
+        },
+        schemas,
+        { statementValues }
+      );
+      relatedTableSelector = `(${subSelect.readStatement})`;
+    }
+    statement += `${joinType} JOIN ${relatedTableSelector} as ${tableAlias}`;
+    if (joinType === "LEFT") {
+      if (!single) {
+        rootTableSubQuery = `SELECT * FROM "${rootTable}" LIMIT 1`;
+        rootTableName = `sub_${rootTable}`;
+      }
+      const subStatement = composeConditions(
+        schemas,
+        relatedSchema,
+        statementValues,
+        "including",
+        queryInstructions?.with,
+        {
+          rootTable: rootTableName,
+          customTable: tableAlias
+        }
+      );
+      statement += ` ON (${subStatement})`;
+    }
+  }
+  return { statement, rootTableSubQuery, rootTableName };
+};
+
+// src/instructions/limited-to.ts
+var handleLimitedTo = (single, instruction) => {
+  const pageSize = instruction || 100;
+  const finalPageSize = pageSize + 1;
+  return `LIMIT ${single ? "1" : finalPageSize} `;
+};
+
+// src/instructions/ordered-by.ts
+var handleOrderedBy = (schema, instruction, rootTable) => {
+  let statement = "";
+  for (const field of instruction.ascending || []) {
+    const { field: schemaField, fieldSelector } = getFieldFromSchema(
+      schema,
+      field,
+      "orderedBy.ascending",
+      rootTable
+    );
+    if (statement.length > 0) {
+      statement += ", ";
+    }
+    const caseInsensitiveStatement = schemaField.type === "string" ? " COLLATE NOCASE" : "";
+    statement += `${fieldSelector}${caseInsensitiveStatement} ASC`;
+  }
+  for (const field of instruction.descending || []) {
+    const { field: schemaField, fieldSelector } = getFieldFromSchema(
+      schema,
+      field,
+      "orderedBy.descending",
+      rootTable
+    );
+    if (statement.length > 0) {
+      statement += ", ";
+    }
+    const caseInsensitiveStatement = schemaField.type === "string" ? " COLLATE NOCASE" : "";
+    statement += `${fieldSelector}${caseInsensitiveStatement} DESC`;
+  }
+  return `ORDER BY ${statement}`;
+};
+
+// src/instructions/selecting.ts
+var handleSelecting = (schema, statementValues, instructions) => {
+  let statement = instructions.selecting ? instructions.selecting.map((slug) => {
+    return getFieldFromSchema(schema, slug, "selecting").fieldSelector;
+  }).join(", ") : "*";
+  if (isObject(instructions.including)) {
+    statement += ", ";
+    statement += Object.entries(
+      flatten(instructions.including)
+    ).filter(([_, value]) => {
+      return !(isObject(value) && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY));
+    }).map(([key, value]) => {
+      return `${prepareStatementValue(statementValues, value)} as "${key}"`;
+    }).join(", ");
+  }
+  return statement;
+};
+
+// src/instructions/to.ts
+var handleTo = (schemas, schema, statementValues, queryType, writeStatements, instructions, rootTable) => {
+  const currentTime = (/* @__PURE__ */ new Date()).toISOString();
+  const { with: withInstruction, to: toInstruction } = instructions;
+  const defaultFields = {};
+  if (queryType === "create") {
+    defaultFields.id = toInstruction.id || generateRecordId(schema.idPrefix);
+  }
+  defaultFields.ronin = {
+    // If records are being created, set their creation time.
+    ...queryType === "create" ? { createdAt: currentTime } : {},
+    // If records are being created or updated, set their update time.
+    updatedAt: currentTime,
+    // Allow for overwriting the default values provided above.
+    ...toInstruction.ronin
+  };
+  const hasSubQuery = Object.hasOwn(toInstruction, RONIN_SCHEMA_SYMBOLS.QUERY);
+  if (hasSubQuery) {
+    const subQuery = toInstruction[RONIN_SCHEMA_SYMBOLS.QUERY];
+    let { querySchema: subQuerySchemaSlug, queryInstructions: subQueryInstructions } = splitQuery(subQuery);
+    const subQuerySchema = getSchemaBySlug(schemas, subQuerySchemaSlug);
+    const subQuerySelectedFields = subQueryInstructions?.selecting;
+    const subQueryIncludedFields = subQueryInstructions?.including;
+    const subQueryFields = [
+      ...subQuerySelectedFields || (subQuerySchema.fields || []).map((field) => field.slug),
+      ...subQueryIncludedFields ? Object.keys(
+        flatten(subQueryIncludedFields || {})
+      ) : []
+    ];
+    for (const field of subQueryFields || []) {
+      getFieldFromSchema(schema, field, "to");
+    }
+    const defaultFieldsToAdd = subQuerySelectedFields ? Object.entries(flatten(defaultFields)).filter(([key]) => {
+      return !subQuerySelectedFields.includes(key);
+    }) : [];
+    if (defaultFieldsToAdd.length > 0) {
+      const defaultFieldsObject = expand(Object.fromEntries(defaultFieldsToAdd));
+      if (!subQueryInstructions) subQueryInstructions = {};
+      subQueryInstructions.including = {
+        ...defaultFieldsObject,
+        ...subQueryInstructions.including
+      };
+    }
+    return compileQueryInput(subQuery, schemas, {
+      statementValues
+    }).readStatement;
+  }
+  Object.assign(toInstruction, defaultFields);
+  for (const fieldSlug in toInstruction) {
+    const fieldValue = toInstruction[fieldSlug];
+    const fieldDetails = getFieldFromSchema(schema, fieldSlug, "to");
+    if (fieldDetails.field.type === "reference" && fieldDetails.field.kind === "many") {
+      delete toInstruction[fieldSlug];
+      const associativeSchemaSlug = composeAssociationSchemaSlug(
+        schema,
+        fieldDetails.field
+      );
+      const composeStatement = (subQueryType, value) => {
+        const origin = queryType === "create" ? { id: toInstruction.id } : withInstruction;
+        const recordDetails = { origin };
+        if (value) recordDetails.target = value;
+        const { readStatement } = compileQueryInput(
+          {
+            [subQueryType]: {
+              [associativeSchemaSlug]: subQueryType === "create" ? { to: recordDetails } : { with: recordDetails }
+            }
+          },
+          schemas,
+          { statementValues, disableReturning: true }
+        );
+        return readStatement;
+      };
+      if (Array.isArray(fieldValue)) {
+        writeStatements.push(composeStatement("drop"));
+        for (const record of fieldValue) {
+          writeStatements.push(composeStatement("create", record));
+        }
+      } else if (isObject(fieldValue)) {
+        for (const recordToAdd of fieldValue.containing || []) {
+          writeStatements.push(composeStatement("create", recordToAdd));
+        }
+        for (const recordToRemove of fieldValue.notContaining || []) {
+          writeStatements.push(composeStatement("drop", recordToRemove));
+        }
+      }
+    }
+  }
+  let statement = composeConditions(
+    schemas,
+    schema,
+    statementValues,
+    "to",
+    toInstruction,
+    {
+      rootTable,
+      type: queryType === "create" ? "fields" : void 0
+    }
+  );
+  if (queryType === "create") {
+    const deepStatement = composeConditions(
+      schemas,
+      schema,
+      statementValues,
+      "to",
+      toInstruction,
+      {
+        rootTable,
+        type: "values"
+      }
+    );
+    statement = `(${statement}) VALUES (${deepStatement})`;
+  } else if (queryType === "set") {
+    statement = `SET ${statement}`;
+  }
+  return statement;
+};
+
+// src/index.ts
+var compileQueryInput = (query, defaultSchemas, options) => {
+  const parsedQuery = splitQuery(query);
+  const { queryType, querySchema, queryInstructions } = parsedQuery;
+  const schemas = addSystemSchemas(defaultSchemas);
+  const schema = getSchemaBySlug(schemas, querySchema);
+  const single = querySchema !== schema.pluralSlug;
+  let instructions = formatIdentifiers(schema, queryInstructions);
+  let table = getTableForSchema(schema);
+  const statementValues = options?.statementValues || [];
+  const writeStatements = [];
+  addSchemaQueries(parsedQuery, writeStatements);
+  const columns = handleSelecting(schema, statementValues, {
+    selecting: instructions?.selecting,
+    including: instructions?.including
+  });
+  let statement = "";
+  switch (queryType) {
+    case "get":
+      statement += `SELECT ${columns} FROM `;
+      break;
+    case "count":
+      statement += `SELECT COUNT(${columns}) FROM `;
+      break;
+    case "drop":
+      statement += "DELETE FROM ";
+      break;
+    case "create":
+      statement += "INSERT INTO ";
+      break;
+    case "set":
+      statement += "UPDATE ";
+      break;
+  }
+  const isJoining = typeof instructions?.including !== "undefined" && !isObject(instructions.including);
+  let isJoiningMultipleRows = false;
+  if (isJoining) {
+    const {
+      statement: including,
+      rootTableSubQuery,
+      rootTableName
+    } = handleIncluding(schemas, statementValues, schema, instructions?.including, table);
+    if (rootTableSubQuery && rootTableName) {
+      table = rootTableName;
+      statement += `(${rootTableSubQuery}) as ${rootTableName} `;
+      isJoiningMultipleRows = true;
+    } else {
+      statement += `"${table}" `;
+    }
+    statement += `${including} `;
+  } else {
+    statement += `"${table}" `;
+  }
+  if (queryType === "create" || 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]
+      });
+    }
+    const toStatement = handleTo(
+      schemas,
+      schema,
+      statementValues,
+      queryType,
+      writeStatements,
+      { with: instructions.with, to: instructions.to },
+      isJoining ? table : void 0
+    );
+    statement += `${toStatement} `;
+  }
+  const conditions = [];
+  if (queryType !== "create" && instructions && Object.hasOwn(instructions, "with")) {
+    const withStatement = handleWith(
+      schemas,
+      schema,
+      statementValues,
+      instructions?.with,
+      isJoining ? table : void 0
+    );
+    if (withStatement.length > 0) conditions.push(withStatement);
+  }
+  if (instructions && Object.hasOwn(instructions, "for")) {
+    const forStatement = handleFor(
+      schemas,
+      schema,
+      statementValues,
+      instructions?.for,
+      isJoining ? table : void 0
+    );
+    if (forStatement.length > 0) conditions.push(forStatement);
+  }
+  if ((queryType === "get" || queryType === "count") && !single) {
+    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");
+    }
+  }
+  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]
+      });
+    }
+    const beforeAndAfterStatement = handleBeforeOrAfter(
+      schema,
+      statementValues,
+      {
+        before: instructions.before,
+        after: instructions.after,
+        with: instructions.with,
+        orderedBy: instructions.orderedBy
+      },
+      isJoining ? table : void 0
+    );
+    conditions.push(beforeAndAfterStatement);
+  }
+  if (conditions.length > 0) {
+    if (conditions.length === 1) {
+      statement += `WHERE ${conditions[0]} `;
+    } else {
+      statement += `WHERE (${conditions.join(" ")}) `;
+    }
+  }
+  if (instructions?.orderedBy) {
+    const orderedByStatement = handleOrderedBy(
+      schema,
+      instructions.orderedBy,
+      isJoining ? table : void 0
+    );
+    statement += `${orderedByStatement} `;
+  }
+  if (queryType === "get" && !isJoiningMultipleRows) {
+    statement += handleLimitedTo(single, instructions?.limitedTo);
+  }
+  if (["create", "set", "drop"].includes(queryType) && !options?.disableReturning) {
+    statement += "RETURNING * ";
+  }
+  const finalStatement = statement.trimEnd();
+  return {
+    writeStatements,
+    readStatement: finalStatement,
+    values: statementValues
+  };
+};
+export {
+  compileQueryInput
+};