@ronin/compiler 0.6.1 → 0.7.0

package/dist/index.js

@@ -1,19 +1,23 @@
 // src/utils/helpers.ts
 import { init as cuid } from "@paralleldrive/cuid2";
-var RONIN_SCHEMA_SYMBOLS = {
+var RONIN_MODEL_SYMBOLS = {
   // Represents a sub query.
   QUERY: "__RONIN_QUERY",
-  // Represents the value of a field in a schema.
+  // Represents an expression that should be evaluated.
+  EXPRESSION: "__RONIN_EXPRESSION",
+  // Represents the value of a field in the model.
   FIELD: "__RONIN_FIELD_",
-  // Represents the old value of a field in a schema. Used for triggers.
-  FIELD_OLD: "__RONIN_FIELD_OLD_",
-  // Represents the new value of a field in a schema. Used for triggers.
-  FIELD_NEW: "__RONIN_FIELD_NEW_",
+  // Represents the value of a field in the model of a parent query.
+  FIELD_PARENT: "__RONIN_FIELD_PARENT_",
+  // Represents the old value of a field in the parent model. Used for triggers.
+  FIELD_PARENT_OLD: "__RONIN_FIELD_PARENT_OLD_",
+  // Represents the new value of a field in the parent model. Used for triggers.
+  FIELD_PARENT_NEW: "__RONIN_FIELD_PARENT_NEW_",
   // Represents a value provided to a query preset.
   VALUE: "__RONIN_VALUE"
 };
-var RONIN_SCHEMA_FIELD_REGEX = new RegExp(
-  `${RONIN_SCHEMA_SYMBOLS.FIELD}[a-zA-Z0-9]+`,
+var RONIN_MODEL_FIELD_REGEX = new RegExp(
+  `${RONIN_MODEL_SYMBOLS.FIELD}[_a-zA-Z0-9]+`,
   "g"
 );
 var RoninError = class extends Error {
@@ -94,9 +98,9 @@ var expand = (obj) => {
 };
 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 };
+  const queryModel = Object.keys(query[queryType])[0];
+  const queryInstructions = query[queryType][queryModel];
+  return { queryType, queryModel, queryInstructions };
 };
 
 // src/utils/statement.ts
@@ -112,39 +116,44 @@ var prepareStatementValue = (statementParams, value) => {
   const index = statementParams.push(formattedValue);
   return `?${index}`;
 };
-var composeFieldValues = (schemas, schema, statementParams, instructionName, value, options) => {
-  const { field: schemaField, fieldSelector: selector } = getFieldFromSchema(
-    schema,
+var parseFieldExpression = (model, instructionName, expression, parentModel) => {
+  return expression.replace(RONIN_MODEL_FIELD_REGEX, (match) => {
+    let toReplace = RONIN_MODEL_SYMBOLS.FIELD;
+    let rootModel = model;
+    if (match.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT)) {
+      rootModel = parentModel;
+      toReplace = RONIN_MODEL_SYMBOLS.FIELD_PARENT;
+      if (match.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD)) {
+        rootModel.tableAlias = toReplace = RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD;
+      } else if (match.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW)) {
+        rootModel.tableAlias = toReplace = RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
+      }
+    }
+    const fieldSlug = match.replace(toReplace, "");
+    const field = getFieldFromModel(rootModel, fieldSlug, instructionName);
+    return field.fieldSelector;
+  });
+};
+var composeFieldValues = (models, model, statementParams, instructionName, value, options) => {
+  const { fieldSelector: conditionSelector } = getFieldFromModel(
+    model,
     options.fieldSlug,
-    instructionName,
-    options.rootTable
+    instructionName
   );
   const collectStatementValue = options.type !== "fields";
-  let conditionSelector = selector;
+  const symbol = getSymbol(value);
   let conditionValue = value;
-  if (getSubQuery(value) && collectStatementValue) {
-    conditionValue = `(${compileQueryInput(
-      value[RONIN_SCHEMA_SYMBOLS.QUERY],
-      schemas,
-      statementParams
-    ).main.statement})`;
-  } else if (typeof value === "string" && value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD)) {
-    let targetTable = `"${options.rootTable}"`;
-    let toReplace = RONIN_SCHEMA_SYMBOLS.FIELD;
-    if (value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD_OLD)) {
-      targetTable = "OLD";
-      toReplace = RONIN_SCHEMA_SYMBOLS.FIELD_OLD;
-    } else if (value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD_NEW)) {
-      targetTable = "NEW";
-      toReplace = RONIN_SCHEMA_SYMBOLS.FIELD_NEW;
+  if (symbol) {
+    if (symbol?.type === "expression") {
+      conditionValue = parseFieldExpression(
+        model,
+        instructionName,
+        symbol.value,
+        options.parentModel
+      );
     }
-    conditionSelector = `${options.customTable ? `"${options.customTable}".` : ""}"${schemaField.slug}"`;
-    conditionValue = `${targetTable}."${value.replace(toReplace, "")}"`;
-  } else if (schemaField.type === "json" && instructionName === "to") {
-    conditionSelector = `"${schemaField.slug}"`;
-    if (collectStatementValue) {
-      const preparedValue = prepareStatementValue(statementParams, value);
-      conditionValue = `IIF(${conditionSelector} IS NULL, ${preparedValue}, json_patch(${conditionSelector}, ${preparedValue}))`;
+    if (symbol.type === "query" && collectStatementValue) {
+      conditionValue = `(${compileQueryInput(symbol.value, models, statementParams).main.statement})`;
     }
   } else if (collectStatementValue) {
     conditionValue = prepareStatementValue(statementParams, value);
@@ -153,11 +162,11 @@ var composeFieldValues = (schemas, schema, statementParams, instructionName, val
   if (options.type === "values") return conditionValue;
   return `${conditionSelector} ${WITH_CONDITIONS[options.condition || "being"](conditionValue, value)}`;
 };
-var composeConditions = (schemas, schema, statementParams, instructionName, value, options) => {
+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(schemas, schema, statementParams, instructionName, checkValue, {
+      ([conditionType, checkValue]) => composeConditions(models, model, statementParams, instructionName, checkValue, {
         ...options,
         condition: conditionType
       })
@@ -165,47 +174,42 @@ var composeConditions = (schemas, schema, statementParams, instructionName, valu
     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";
-    if (!(isObject(value) || Array.isArray(value)) || getSubQuery(value) || consumeJSON) {
+    const fieldDetails = getFieldFromModel(model, options.fieldSlug, instructionName);
+    const { field: modelField } = fieldDetails;
+    const consumeJSON = modelField.type === "json" && instructionName === "to";
+    if (!(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
       return composeFieldValues(
-        schemas,
-        schema,
+        models,
+        model,
         statementParams,
         instructionName,
         value,
         { ...options, fieldSlug: options.fieldSlug }
       );
     }
-    if (schemaField.type === "reference" && isNested) {
+    if (modelField.type === "reference" && isNested) {
       const keys = Object.keys(value);
       const values = Object.values(value);
       let recordTarget;
       if (keys.length === 1 && keys[0] === "id") {
         recordTarget = values[0];
       } else {
-        const relatedSchema = getSchemaBySlug(schemas, schemaField.target.slug);
+        const relatedModel = getModelBySlug(models, modelField.target.slug);
         const subQuery = {
           get: {
-            [relatedSchema.slug]: {
+            [relatedModel.slug]: {
               with: value,
               selecting: ["id"]
             }
           }
         };
         recordTarget = {
-          [RONIN_SCHEMA_SYMBOLS.QUERY]: subQuery
+          [RONIN_MODEL_SYMBOLS.QUERY]: subQuery
         };
       }
       return composeConditions(
-        schemas,
-        schema,
+        models,
+        model,
         statementParams,
         instructionName,
         recordTarget,
@@ -216,7 +220,7 @@ var composeConditions = (schemas, schema, statementParams, instructionName, valu
   if (isNested) {
     const conditions = Object.entries(value).map(([field, value2]) => {
       const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
-      return composeConditions(schemas, schema, statementParams, instructionName, value2, {
+      return composeConditions(models, model, statementParams, instructionName, value2, {
         ...options,
         fieldSlug: nestedFieldSlug
       });
@@ -227,14 +231,7 @@ var composeConditions = (schemas, schema, statementParams, instructionName, valu
   }
   if (Array.isArray(value)) {
     const conditions = value.map(
-      (filter) => composeConditions(
-        schemas,
-        schema,
-        statementParams,
-        instructionName,
-        filter,
-        options
-      )
+      (filter) => composeConditions(models, model, statementParams, instructionName, filter, options)
     );
     return conditions.join(" OR ");
   }
@@ -265,8 +262,22 @@ var formatIdentifiers = ({ identifiers }, queryInstructions) => {
     [type]: newNestedInstructions
   };
 };
-var getSubQuery = (value) => {
-  return isObject(value) ? value[RONIN_SCHEMA_SYMBOLS.QUERY] || null : null;
+var getSymbol = (value) => {
+  if (!isObject(value)) return null;
+  const objectValue = value;
+  if (RONIN_MODEL_SYMBOLS.QUERY in objectValue) {
+    return {
+      type: "query",
+      value: objectValue[RONIN_MODEL_SYMBOLS.QUERY]
+    };
+  }
+  if (RONIN_MODEL_SYMBOLS.EXPRESSION in objectValue) {
+    return {
+      type: "expression",
+      value: objectValue[RONIN_MODEL_SYMBOLS.EXPRESSION]
+    };
+  }
+  return null;
 };
 
 // src/instructions/with.ts
@@ -292,41 +303,37 @@ var WITH_CONDITIONS = {
   lessThan: (value) => `< ${value}`,
   lessOrEqual: (value) => `<= ${value}`
 };
-var handleWith = (schemas, schema, statementParams, instruction, rootTable) => {
+var handleWith = (models, model, statementParams, instruction, parentModel) => {
   const subStatement = composeConditions(
-    schemas,
-    schema,
+    models,
+    model,
     statementParams,
     "with",
     instruction,
-    { rootTable }
+    { parentModel }
   );
   return `(${subStatement})`;
 };
 
-// src/utils/schema.ts
+// src/utils/model.ts
 import title from "title";
-var getSchemaBySlug = (schemas, slug) => {
-  const schema = schemas.find((schema2) => {
-    return schema2.slug === slug || schema2.pluralSlug === slug;
+var getModelBySlug = (models, slug) => {
+  const model = models.find((model2) => {
+    return model2.slug === slug || model2.pluralSlug === slug;
   });
-  if (!schema) {
+  if (!model) {
     throw new RoninError({
-      message: `No matching schema with either Slug or Plural Slug of "${slug}" could be found.`,
-      code: "SCHEMA_NOT_FOUND"
+      message: `No matching model with either Slug or Plural Slug of "${slug}" could be found.`,
+      code: "MODEL_NOT_FOUND"
     });
   }
-  return schema;
-};
-var getTableForSchema = (schema) => {
-  return convertToSnakeCase(schema.pluralSlug);
+  return model;
 };
-var composeMetaSchemaSlug = (suffix) => convertToCamelCase(`ronin_${suffix}`);
-var composeAssociationSchemaSlug = (schema, field) => composeMetaSchemaSlug(`${schema.slug}_${field.slug}`);
-var getFieldSelector = (field, fieldPath, rootTable) => {
-  const symbol = rootTable?.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD) ? `${rootTable.replace(RONIN_SCHEMA_SYMBOLS.FIELD, "").slice(0, -1)}.` : "";
-  const tablePrefix = symbol || (rootTable ? `"${rootTable}".` : "");
-  if (field.type === "json") {
+var composeAssociationModelSlug = (model, field) => convertToCamelCase(`ronin_link_${model.slug}_${field.slug}`);
+var getFieldSelector = (model, field, fieldPath, instructionName) => {
+  const symbol = model.tableAlias?.startsWith(RONIN_MODEL_SYMBOLS.FIELD_PARENT) ? `${model.tableAlias.replace(RONIN_MODEL_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(".");
@@ -334,28 +341,33 @@ var getFieldSelector = (field, fieldPath, rootTable) => {
   }
   return `${tablePrefix}"${fieldPath}"`;
 };
-var getFieldFromSchema = (schema, fieldPath, instructionName, rootTable) => {
+var getFieldFromModel = (model, fieldPath, instructionName) => {
   const errorPrefix = `Field "${fieldPath}" defined for \`${instructionName}\``;
-  const schemaFields = schema.fields || [];
-  let schemaField;
+  const modelFields = model.fields || [];
+  let modelField;
   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 };
+    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 };
     }
   }
-  schemaField = schemaFields.find((field) => field.slug === fieldPath);
-  if (!schemaField) {
+  modelField = modelFields.find((field) => field.slug === fieldPath);
+  if (!modelField) {
     throw new RoninError({
-      message: `${errorPrefix} does not exist in schema "${schema.name}".`,
+      message: `${errorPrefix} does not exist in model "${model.name}".`,
       code: "FIELD_NOT_FOUND",
       field: fieldPath,
       queries: null
     });
   }
-  const fieldSelector = getFieldSelector(schemaField, fieldPath, rootTable);
-  return { field: schemaField, fieldSelector };
+  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");
@@ -373,36 +385,37 @@ var pluralize = (word) => {
   }
   return `${word}s`;
 };
-var schemaSettings = [
+var modelSettings = [
   ["pluralSlug", "slug", pluralize],
   ["name", "slug", slugToName],
   ["pluralName", "pluralSlug", slugToName],
-  ["idPrefix", "slug", (slug) => slug.slice(0, 3)]
+  ["idPrefix", "slug", (slug) => slug.slice(0, 3)],
+  ["table", "pluralSlug", convertToSnakeCase]
 ];
-var addDefaultSchemaFields = (schema, isNew) => {
-  const copiedSchema = { ...schema };
-  for (const [setting, base, generator] of schemaSettings) {
-    if (copiedSchema[setting] || !copiedSchema[base]) continue;
-    copiedSchema[setting] = generator(copiedSchema[base]);
+var addDefaultModelFields = (model, isNew) => {
+  const copiedModel = { ...model };
+  for (const [setting, base, generator] of modelSettings) {
+    if (copiedModel[setting] || !copiedModel[base]) continue;
+    copiedModel[setting] = generator(copiedModel[base]);
   }
-  const newFields = copiedSchema.fields || [];
+  const newFields = copiedModel.fields || [];
   if (isNew || newFields.length > 0) {
-    if (!copiedSchema.identifiers) copiedSchema.identifiers = {};
-    if (!copiedSchema.identifiers.name) {
+    if (!copiedModel.identifiers) copiedModel.identifiers = {};
+    if (!copiedModel.identifiers.name) {
       const suitableField = newFields.find(
         (field) => field.type === "string" && field.required === true && ["name"].includes(field.slug)
       );
-      copiedSchema.identifiers.name = suitableField?.slug || "id";
+      copiedModel.identifiers.name = suitableField?.slug || "id";
     }
-    if (!copiedSchema.identifiers.slug) {
+    if (!copiedModel.identifiers.slug) {
       const suitableField = newFields.find(
         (field) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(field.slug)
       );
-      copiedSchema.identifiers.slug = suitableField?.slug || "id";
+      copiedModel.identifiers.slug = suitableField?.slug || "id";
     }
-    copiedSchema.fields = [...SYSTEM_FIELDS, ...newFields];
+    copiedModel.fields = [...SYSTEM_FIELDS, ...newFields];
   }
-  return copiedSchema;
+  return copiedModel;
 };
 var SYSTEM_FIELDS = [
   {
@@ -442,9 +455,9 @@ var SYSTEM_FIELDS = [
     slug: "ronin.updatedBy"
   }
 ];
-var SYSTEM_SCHEMAS = [
+var SYSTEM_MODELS = [
   {
-    slug: "schema",
+    slug: "model",
     identifiers: {
       name: "name",
       slug: "slug"
@@ -455,6 +468,7 @@ var SYSTEM_SCHEMAS = [
       { slug: "slug", type: "string" },
       { slug: "pluralSlug", type: "string" },
       { slug: "idPrefix", type: "string" },
+      { slug: "table", type: "string" },
       { slug: "identifiers", type: "group" },
       { slug: "identifiers.name", type: "string" },
       { slug: "identifiers.slug", type: "string" },
@@ -475,9 +489,9 @@ var SYSTEM_SCHEMAS = [
       { slug: "slug", type: "string", required: true },
       { slug: "type", type: "string", required: true },
       {
-        slug: "schema",
+        slug: "model",
         type: "reference",
-        target: { slug: "schema" },
+        target: { slug: "model" },
         required: true
       },
       { slug: "required", type: "boolean" },
@@ -485,7 +499,7 @@ var SYSTEM_SCHEMAS = [
       { slug: "unique", type: "boolean" },
       { slug: "autoIncrement", type: "boolean" },
       // Only allowed for fields of type "reference".
-      { slug: "target", type: "reference", target: { slug: "schema" } },
+      { slug: "target", type: "reference", target: { slug: "model" } },
       { slug: "kind", type: "string" },
       { slug: "actions", type: "group" },
       { slug: "actions.onDelete", type: "string" },
@@ -501,9 +515,9 @@ var SYSTEM_SCHEMAS = [
     fields: [
       { slug: "slug", type: "string", required: true },
       {
-        slug: "schema",
+        slug: "model",
         type: "reference",
-        target: { slug: "schema" },
+        target: { slug: "model" },
         required: true
       },
       { slug: "unique", type: "boolean" },
@@ -520,9 +534,9 @@ var SYSTEM_SCHEMAS = [
     fields: [
       { slug: "slug", type: "string", required: true },
       {
-        slug: "schema",
+        slug: "model",
         type: "reference",
-        target: { slug: "schema" },
+        target: { slug: "model" },
         required: true
       },
       { slug: "when", type: "string", required: true },
@@ -537,71 +551,71 @@ var SYSTEM_SCHEMAS = [
     fields: [
       { slug: "slug", type: "string", required: true },
       {
-        slug: "schema",
+        slug: "model",
         type: "reference",
-        target: { slug: "schema" },
+        target: { slug: "model" },
         required: true
       },
       { slug: "instructions", type: "json", required: true }
     ]
   }
-].map((schema) => addDefaultSchemaFields(schema, true));
-var SYSTEM_SCHEMA_SLUGS = SYSTEM_SCHEMAS.flatMap(({ slug, pluralSlug }) => [
+].map((model) => addDefaultModelFields(model, true));
+var SYSTEM_MODEL_SLUGS = SYSTEM_MODELS.flatMap(({ slug, pluralSlug }) => [
   slug,
   pluralSlug
 ]);
-var addSystemSchemas = (schemas) => {
-  const associativeSchemas = schemas.flatMap((schema) => {
-    const addedSchemas = [];
-    for (const field of schema.fields || []) {
+var addSystemModels = (models) => {
+  const associativeModels = models.flatMap((model) => {
+    const addedModels = [];
+    for (const field of model.fields || []) {
       if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
-        const relatedSchema = getSchemaBySlug(schemas, field.target.slug);
-        let fieldSlug = relatedSchema.slug;
+        const relatedModel = getModelBySlug(models, field.target.slug);
+        let fieldSlug = relatedModel.slug;
         if (field.kind === "many") {
-          fieldSlug = composeAssociationSchemaSlug(schema, field);
-          addedSchemas.push({
+          fieldSlug = composeAssociationModelSlug(model, field);
+          addedModels.push({
             pluralSlug: fieldSlug,
             slug: fieldSlug,
+            associationSlug: field.slug,
             fields: [
               {
                 slug: "source",
                 type: "reference",
-                target: { slug: schema.slug }
+                target: { slug: model.slug }
               },
               {
                 slug: "target",
                 type: "reference",
-                target: { slug: relatedSchema.slug }
+                target: { slug: relatedModel.slug }
               }
             ]
           });
         }
       }
     }
-    return addedSchemas;
+    return addedModels;
   });
-  return [...SYSTEM_SCHEMAS, ...associativeSchemas, ...schemas];
+  return [...SYSTEM_MODELS, ...associativeModels, ...models];
 };
-var addDefaultSchemaPresets = (list, schema) => {
+var addDefaultModelPresets = (list, model) => {
   const defaultPresets = [];
-  for (const field of schema.fields || []) {
+  for (const field of model.fields || []) {
     if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
-      const relatedSchema = getSchemaBySlug(list, field.target.slug);
-      let fieldSlug = relatedSchema.slug;
-      if (field.kind === "many") {
-        fieldSlug = composeAssociationSchemaSlug(schema, field);
-      }
+      const relatedModel = getModelBySlug(list, field.target.slug);
+      if (field.kind === "many") continue;
       defaultPresets.push({
         instructions: {
           including: {
             [field.slug]: {
-              [RONIN_SCHEMA_SYMBOLS.QUERY]: {
+              [RONIN_MODEL_SYMBOLS.QUERY]: {
                 get: {
-                  [fieldSlug]: {
+                  [relatedModel.slug]: {
                     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}`
+                      // Compare the `id` field of the related model to the reference field on
+                      // the root model (`field.slug`).
+                      id: {
+                        [RONIN_MODEL_SYMBOLS.EXPRESSION]: `${RONIN_MODEL_SYMBOLS.FIELD_PARENT}${field.slug}`
+                      }
                     }
                   }
                 }
@@ -613,25 +627,28 @@ var addDefaultSchemaPresets = (list, schema) => {
       });
     }
   }
-  const childSchemas = list.map((subSchema) => {
-    const field = subSchema.fields?.find((field2) => {
-      return field2.type === "reference" && field2.target.slug === schema.slug;
+  const childModels = list.map((subModel) => {
+    const field = subModel.fields?.find((field2) => {
+      return field2.type === "reference" && field2.target.slug === model.slug;
     });
     if (!field) return null;
-    return { schema: subSchema, field };
+    return { model: subModel, field };
   }).filter((match) => match !== null);
-  for (const childMatch of childSchemas) {
-    const { schema: childSchema, field: childField } = childMatch;
-    const pluralSlug = childSchema.pluralSlug;
+  for (const childMatch of childModels) {
+    const { model: childModel, field: childField } = childMatch;
+    const pluralSlug = childModel.pluralSlug;
+    const presetSlug = childModel.associationSlug || pluralSlug;
     defaultPresets.push({
       instructions: {
         including: {
-          [pluralSlug]: {
-            [RONIN_SCHEMA_SYMBOLS.QUERY]: {
+          [presetSlug]: {
+            [RONIN_MODEL_SYMBOLS.QUERY]: {
               get: {
                 [pluralSlug]: {
                   with: {
-                    [childField.slug]: `${RONIN_SCHEMA_SYMBOLS.FIELD}id`
+                    [childField.slug]: {
+                      [RONIN_MODEL_SYMBOLS.EXPRESSION]: `${RONIN_MODEL_SYMBOLS.FIELD_PARENT}id`
+                    }
                   }
                 }
               }
@@ -639,13 +656,13 @@ var addDefaultSchemaPresets = (list, schema) => {
           }
         }
       },
-      slug: pluralSlug
+      slug: presetSlug
     });
   }
   if (Object.keys(defaultPresets).length > 0) {
-    schema.presets = [...defaultPresets, ...schema.presets || []];
+    model.presets = [...defaultPresets, ...model.presets || []];
   }
-  return schema;
+  return model;
 };
 var mappedInstructions = {
   create: "to",
@@ -681,35 +698,31 @@ var getFieldStatement = (field) => {
   }
   return statement;
 };
-var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
-  const {
-    queryType,
-    querySchema,
-    queryInstructions: queryInstructionsRaw
-  } = queryDetails;
+var addModelQueries = (models, queryDetails, dependencyStatements) => {
+  const { queryType, queryModel, queryInstructions: queryInstructionsRaw } = queryDetails;
   const queryInstructions = queryInstructionsRaw;
   if (!["create", "set", "drop"].includes(queryType)) return queryInstructions;
-  if (!SYSTEM_SCHEMA_SLUGS.includes(querySchema)) return queryInstructions;
+  if (!SYSTEM_MODEL_SLUGS.includes(queryModel)) return queryInstructions;
   const instructionName = mappedInstructions[queryType];
   const instructionList = queryInstructions[instructionName];
-  const kind = getSchemaBySlug(SYSTEM_SCHEMAS, querySchema).pluralSlug;
+  const kind = getModelBySlug(SYSTEM_MODELS, queryModel).pluralSlug;
   let tableAction = "ALTER";
   let queryTypeReadable = null;
   switch (queryType) {
     case "create": {
-      if (kind === "schemas" || kind === "indexes" || kind === "triggers") {
+      if (kind === "models" || kind === "indexes" || kind === "triggers") {
         tableAction = "CREATE";
       }
       queryTypeReadable = "creating";
       break;
     }
     case "set": {
-      if (kind === "schemas") tableAction = "ALTER";
+      if (kind === "models") tableAction = "ALTER";
       queryTypeReadable = "updating";
       break;
     }
     case "drop": {
-      if (kind === "schemas" || kind === "indexes" || kind === "triggers") {
+      if (kind === "models" || kind === "indexes" || kind === "triggers") {
         tableAction = "DROP";
       }
       queryTypeReadable = "deleting";
@@ -724,18 +737,18 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
       fields: ["slug"]
     });
   }
-  const schemaInstruction = instructionList?.schema;
-  const schemaSlug = schemaInstruction?.slug?.being || schemaInstruction?.slug;
-  if (kind !== "schemas" && !schemaSlug) {
+  const modelInstruction = instructionList?.model;
+  const modelSlug = modelInstruction?.slug?.being || modelInstruction?.slug;
+  if (kind !== "models" && !modelSlug) {
     throw new RoninError({
-      message: `When ${queryTypeReadable} ${kind}, a \`schema.slug\` field must be provided in the \`${instructionName}\` instruction.`,
+      message: `When ${queryTypeReadable} ${kind}, a \`model.slug\` field must be provided in the \`${instructionName}\` instruction.`,
       code: "MISSING_FIELD",
-      fields: ["schema.slug"]
+      fields: ["model.slug"]
     });
   }
-  const usableSlug = kind === "schemas" ? slug : schemaSlug;
+  const usableSlug = kind === "models" ? slug : modelSlug;
   const tableName = convertToSnakeCase(pluralize(usableSlug));
-  const targetSchema = kind === "schemas" && queryType === "create" ? null : getSchemaBySlug(schemas, usableSlug);
+  const targetModel = kind === "models" && queryType === "create" ? null : getModelBySlug(models, usableSlug);
   if (kind === "indexes") {
     const indexName = convertToSnakeCase(slug);
     const unique = instructionList?.unique;
@@ -744,16 +757,13 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
     const params = [];
     let statement2 = `${tableAction}${unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
     if (queryType === "create") {
-      const schema = targetSchema;
+      const model = targetModel;
       const columns = fields.map((field) => {
         let fieldSelector = "";
         if ("slug" in field) {
-          ({ fieldSelector } = getFieldFromSchema(schema, field.slug, "to"));
+          ({ fieldSelector } = getFieldFromModel(model, field.slug, "to"));
         } else if ("expression" in field) {
-          fieldSelector = field.expression.replace(RONIN_SCHEMA_FIELD_REGEX, (match) => {
-            const fieldSlug = match.replace(RONIN_SCHEMA_SYMBOLS.FIELD, "");
-            return getFieldFromSchema(schema, fieldSlug, "to").fieldSelector;
-          });
+          fieldSelector = parseFieldExpression(model, "to", field.expression, model);
         }
         if (field.collation) fieldSelector += ` COLLATE ${field.collation}`;
         if (field.order) fieldSelector += ` ${field.order}`;
@@ -762,8 +772,8 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
       statement2 += ` ON "${tableName}" (${columns.join(", ")})`;
       if (filterQuery) {
         const withStatement = handleWith(
-          schemas,
-          targetSchema,
+          models,
+          targetModel,
           params,
           filterQuery
         );
@@ -778,6 +788,7 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
     const params = [];
     let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
     if (queryType === "create") {
+      const currentModel = targetModel;
       const { when, action } = instructionList;
       const statementParts = [`${when} ${action}`];
       const effectQueries = instructionList?.effects;
@@ -787,33 +798,33 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
         if (action !== "UPDATE") {
           throw new RoninError({
             message: `When ${queryTypeReadable} ${kind}, targeting specific fields requires the \`UPDATE\` action.`,
-            code: "INVALID_SCHEMA_VALUE",
+            code: "INVALID_MODEL_VALUE",
             fields: ["action"]
           });
         }
         const fieldSelectors = fields.map((field) => {
-          return getFieldFromSchema(targetSchema, field.slug, "to").fieldSelector;
+          return getFieldFromModel(currentModel, field.slug, "to").fieldSelector;
         });
         statementParts.push(`OF (${fieldSelectors.join(", ")})`);
       }
       statementParts.push("ON", `"${tableName}"`);
-      if (filterQuery || effectQueries.some((query) => findInObject(query, RONIN_SCHEMA_SYMBOLS.FIELD))) {
+      if (filterQuery || effectQueries.some((query) => findInObject(query, RONIN_MODEL_SYMBOLS.FIELD))) {
         statementParts.push("FOR EACH ROW");
       }
       if (filterQuery) {
-        const tablePlaceholder = action === "DELETE" ? RONIN_SCHEMA_SYMBOLS.FIELD_OLD : RONIN_SCHEMA_SYMBOLS.FIELD_NEW;
+        const tableAlias = action === "DELETE" ? RONIN_MODEL_SYMBOLS.FIELD_PARENT_OLD : RONIN_MODEL_SYMBOLS.FIELD_PARENT_NEW;
         const withStatement = handleWith(
-          schemas,
-          targetSchema,
+          models,
+          { ...currentModel, tableAlias },
           params,
-          filterQuery,
-          tablePlaceholder
+          filterQuery
         );
         statementParts.push("WHEN", `(${withStatement})`);
       }
       const effectStatements = effectQueries.map((effectQuery) => {
-        return compileQueryInput(effectQuery, schemas, params, {
-          returning: false
+        return compileQueryInput(effectQuery, models, params, {
+          returning: false,
+          parentModel: currentModel
         }).main.statement;
       });
       if (effectStatements.length > 1) statementParts.push("BEGIN");
@@ -825,14 +836,14 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
     return queryInstructions;
   }
   const statement = `${tableAction} TABLE "${tableName}"`;
-  if (kind === "schemas") {
+  if (kind === "models") {
     if (queryType === "create" || queryType === "set") {
-      const schemaWithFields = addDefaultSchemaFields(
+      const modelWithFields = addDefaultModelFields(
         queryInstructions.to,
         queryType === "create"
       );
-      const schemaWithPresets = addDefaultSchemaPresets(schemas, schemaWithFields);
-      queryInstructions.to = schemaWithPresets;
+      const modelWithPresets = addDefaultModelPresets(models, modelWithFields);
+      queryInstructions.to = modelWithPresets;
     }
     if (queryType === "create") {
       const { fields } = queryInstructions.to;
@@ -841,7 +852,7 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
         statement: `${statement} (${columns.join(", ")})`,
         params: []
       });
-      schemas.push(queryInstructions.to);
+      models.push(queryInstructions.to);
     } else if (queryType === "set") {
       const newSlug = queryInstructions.to?.pluralSlug;
       if (newSlug) {
@@ -851,9 +862,9 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
           params: []
         });
       }
-      Object.assign(targetSchema, queryInstructions.to);
+      Object.assign(targetModel, queryInstructions.to);
     } else if (queryType === "drop") {
-      schemas.splice(schemas.indexOf(targetSchema), 1);
+      models.splice(models.indexOf(targetModel), 1);
       dependencyStatements.push({ statement, params: [] });
     }
     return queryInstructions;
@@ -892,7 +903,7 @@ var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
 // src/instructions/before-after.ts
 var CURSOR_SEPARATOR = ",";
 var CURSOR_NULL_PLACEHOLDER = "RONIN_NULL";
-var handleBeforeOrAfter = (schema, statementParams, instructions, rootTable) => {
+var handleBeforeOrAfter = (model, statementParams, instructions) => {
   if (!(instructions.before || instructions.after)) {
     throw new RoninError({
       message: "The `before` or `after` instruction must not be empty.",
@@ -923,7 +934,7 @@ var handleBeforeOrAfter = (schema, statementParams, instructions, rootTable) =>
     if (value === CURSOR_NULL_PLACEHOLDER) {
       return "NULL";
     }
-    const { field } = getFieldFromSchema(schema, key, "orderedBy");
+    const { field } = getFieldFromModel(model, key, "orderedBy");
     if (field.type === "boolean") {
       return prepareStatementValue(statementParams, value === "true");
     }
@@ -949,12 +960,7 @@ var handleBeforeOrAfter = (schema, statementParams, instructions, rootTable) =>
     for (let j = 0; j <= i; j++) {
       const key = keys[j];
       const value = values[j];
-      let { field, fieldSelector } = getFieldFromSchema(
-        schema,
-        key,
-        "orderedBy",
-        rootTable
-      );
+      let { field, fieldSelector } = getFieldFromModel(model, key, "orderedBy");
       if (j === i) {
         const closingParentheses = ")".repeat(condition.length);
         const operator = value === "NULL" ? "IS NOT" : compareOperators[j];
@@ -976,14 +982,14 @@ var handleBeforeOrAfter = (schema, statementParams, instructions, rootTable) =>
 };
 
 // src/instructions/for.ts
-var handleFor = (schema, instructions) => {
+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) {
     const arg = normalizedFor[presetSlug];
-    const preset = schema.presets?.find((preset2) => preset2.slug === presetSlug);
+    const preset = model.presets?.find((preset2) => preset2.slug === presetSlug);
     if (!preset) {
       throw new RoninError({
-        message: `Preset "${presetSlug}" does not exist in schema "${schema.name}".`,
+        message: `Preset "${presetSlug}" does not exist in model "${model.name}".`,
         code: "PRESET_NOT_FOUND"
       });
     }
@@ -991,8 +997,8 @@ var handleFor = (schema, instructions) => {
     if (arg !== null) {
       findInObject(
         replacedForFilter,
-        RONIN_SCHEMA_SYMBOLS.VALUE,
-        (match) => match.replace(RONIN_SCHEMA_SYMBOLS.VALUE, arg)
+        RONIN_MODEL_SYMBOLS.VALUE,
+        (match) => match.replace(RONIN_MODEL_SYMBOLS.VALUE, arg)
       );
     }
     for (const subInstruction in replacedForFilter) {
@@ -1023,20 +1029,19 @@ var handleFor = (schema, instructions) => {
 };
 
 // src/instructions/including.ts
-var handleIncluding = (schemas, statementParams, instruction, rootTable) => {
+var handleIncluding = (models, model, statementParams, instruction) => {
   let statement = "";
-  let rootTableSubQuery;
-  let rootTableName = rootTable;
+  let tableSubQuery;
   for (const ephemeralFieldSlug in instruction) {
-    const includingQuery = getSubQuery(instruction[ephemeralFieldSlug]);
-    if (!includingQuery) continue;
-    const { queryType, querySchema, queryInstructions } = splitQuery(includingQuery);
+    const symbol = getSymbol(instruction[ephemeralFieldSlug]);
+    if (symbol?.type !== "query") continue;
+    const { queryType, queryModel, queryInstructions } = splitQuery(symbol.value);
     let modifiableQueryInstructions = queryInstructions;
-    const relatedSchema = getSchemaBySlug(schemas, querySchema);
+    const relatedModel = getModelBySlug(models, queryModel);
     let joinType = "LEFT";
-    let relatedTableSelector = `"${getTableForSchema(relatedSchema)}"`;
+    let relatedTableSelector = `"${relatedModel.table}"`;
     const tableAlias = `including_${ephemeralFieldSlug}`;
-    const single = querySchema !== relatedSchema.pluralSlug;
+    const single = queryModel !== relatedModel.pluralSlug;
     if (!modifiableQueryInstructions?.with) {
       joinType = "CROSS";
       if (single) {
@@ -1048,35 +1053,35 @@ var handleIncluding = (schemas, statementParams, instruction, rootTable) => {
       const subSelect = compileQueryInput(
         {
           [queryType]: {
-            [querySchema]: modifiableQueryInstructions
+            [queryModel]: modifiableQueryInstructions
           }
         },
-        schemas,
+        models,
         statementParams
       );
       relatedTableSelector = `(${subSelect.main.statement})`;
     }
     statement += `${joinType} JOIN ${relatedTableSelector} as ${tableAlias}`;
+    model.tableAlias = model.table;
     if (joinType === "LEFT") {
       if (!single) {
-        rootTableSubQuery = `SELECT * FROM "${rootTable}" LIMIT 1`;
-        rootTableName = `sub_${rootTable}`;
+        tableSubQuery = `SELECT * FROM "${model.table}" LIMIT 1`;
+        model.tableAlias = `sub_${model.table}`;
       }
       const subStatement = composeConditions(
-        schemas,
-        relatedSchema,
+        models,
+        { ...relatedModel, tableAlias },
         statementParams,
         "including",
         queryInstructions?.with,
         {
-          rootTable: rootTableName,
-          customTable: tableAlias
+          parentModel: model
         }
       );
       statement += ` ON (${subStatement})`;
     }
   }
-  return { statement, rootTableSubQuery, rootTableName };
+  return { statement, tableSubQuery };
 };
 
 // src/instructions/limited-to.ts
@@ -1088,46 +1093,43 @@ var handleLimitedTo = (single, instruction) => {
 };
 
 // src/instructions/ordered-by.ts
-var handleOrderedBy = (schema, instruction, rootTable) => {
+var handleOrderedBy = (model, instruction) => {
   let statement = "";
-  for (const field of instruction.ascending || []) {
-    const { field: schemaField, fieldSelector } = getFieldFromSchema(
-      schema,
-      field,
-      "orderedBy.ascending",
-      rootTable
-    );
+  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 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 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 caseInsensitiveStatement = schemaField.type === "string" ? " COLLATE NOCASE" : "";
-    statement += `${fieldSelector}${caseInsensitiveStatement} DESC`;
+    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}`;
 };
 
 // src/instructions/selecting.ts
-var handleSelecting = (schema, statementParams, instructions) => {
+var handleSelecting = (model, statementParams, instructions) => {
   let isJoining = false;
   let statement = instructions.selecting ? instructions.selecting.map((slug) => {
-    return getFieldFromSchema(schema, slug, "selecting").fieldSelector;
+    return getFieldFromModel(model, slug, "selecting").fieldSelector;
   }).join(", ") : "*";
   if (instructions.including) {
     const filteredObject = Object.entries(instructions.including).filter(([_, value]) => {
-      const hasQuery = getSubQuery(value);
+      const symbol = getSymbol(value);
+      const hasQuery = symbol?.type === "query";
       if (hasQuery) isJoining = true;
       return !hasQuery;
     });
@@ -1143,12 +1145,12 @@ var handleSelecting = (schema, statementParams, instructions) => {
 };
 
 // src/instructions/to.ts
-var handleTo = (schemas, schema, statementParams, queryType, dependencyStatements, instructions, rootTable) => {
+var handleTo = (models, model, statementParams, queryType, dependencyStatements, instructions, parentModel) => {
   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.id = toInstruction.id || generateRecordId(model.idPrefix);
   }
   defaultFields.ronin = {
     // If records are being created, set their creation time.
@@ -1158,20 +1160,20 @@ var handleTo = (schemas, schema, statementParams, queryType, dependencyStatement
     // Allow for overwriting the default values provided above.
     ...toInstruction.ronin
   };
-  const subQuery = getSubQuery(toInstruction);
-  if (subQuery) {
-    let { querySchema: subQuerySchemaSlug, queryInstructions: subQueryInstructions } = splitQuery(subQuery);
-    const subQuerySchema = getSchemaBySlug(schemas, subQuerySchemaSlug);
+  const symbol = getSymbol(toInstruction);
+  if (symbol?.type === "query") {
+    let { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
+    const subQueryModel = getModelBySlug(models, subQueryModelSlug);
     const subQuerySelectedFields = subQueryInstructions?.selecting;
     const subQueryIncludedFields = subQueryInstructions?.including;
     const subQueryFields = [
-      ...subQuerySelectedFields || (subQuerySchema.fields || []).map((field) => field.slug),
+      ...subQuerySelectedFields || (subQueryModel.fields || []).map((field) => field.slug),
       ...subQueryIncludedFields ? Object.keys(
         flatten(subQueryIncludedFields || {})
       ) : []
     ];
     for (const field of subQueryFields || []) {
-      getFieldFromSchema(schema, field, "to");
+      getFieldFromModel(model, field, "to");
     }
     const defaultFieldsToAdd = subQuerySelectedFields ? Object.entries(flatten(defaultFields)).filter(([key]) => {
       return !subQuerySelectedFields.includes(key);
@@ -1184,18 +1186,15 @@ var handleTo = (schemas, schema, statementParams, queryType, dependencyStatement
         ...subQueryInstructions.including
       };
     }
-    return compileQueryInput(subQuery, schemas, statementParams).main.statement;
+    return compileQueryInput(symbol.value, models, statementParams).main.statement;
   }
   Object.assign(toInstruction, defaultFields);
   for (const fieldSlug in toInstruction) {
     const fieldValue = toInstruction[fieldSlug];
-    const fieldDetails = getFieldFromSchema(schema, fieldSlug, "to");
+    const fieldDetails = getFieldFromModel(model, fieldSlug, "to");
     if (fieldDetails.field.type === "reference" && fieldDetails.field.kind === "many") {
       delete toInstruction[fieldSlug];
-      const associativeSchemaSlug = composeAssociationSchemaSlug(
-        schema,
-        fieldDetails.field
-      );
+      const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);
       const composeStatement = (subQueryType, value) => {
         const source = queryType === "create" ? { id: toInstruction.id } : withInstruction;
         const recordDetails = { source };
@@ -1203,10 +1202,10 @@ var handleTo = (schemas, schema, statementParams, queryType, dependencyStatement
         return compileQueryInput(
           {
             [subQueryType]: {
-              [associativeSchemaSlug]: subQueryType === "create" ? { to: recordDetails } : { with: recordDetails }
+              [associativeModelSlug]: subQueryType === "create" ? { to: recordDetails } : { with: recordDetails }
             }
           },
-          schemas,
+          models,
           [],
           { returning: false }
         ).main;
@@ -1226,26 +1225,19 @@ var handleTo = (schemas, schema, statementParams, queryType, dependencyStatement
       }
     }
   }
-  let statement = composeConditions(
-    schemas,
-    schema,
-    statementParams,
-    "to",
-    toInstruction,
-    {
-      rootTable,
-      type: queryType === "create" ? "fields" : void 0
-    }
-  );
+  let statement = composeConditions(models, model, statementParams, "to", toInstruction, {
+    parentModel,
+    type: queryType === "create" ? "fields" : void 0
+  });
   if (queryType === "create") {
     const deepStatement = composeConditions(
-      schemas,
-      schema,
+      models,
+      model,
       statementParams,
       "to",
       toInstruction,
       {
-        rootTable,
+        parentModel,
         type: "values"
       }
     );
@@ -1257,24 +1249,23 @@ var handleTo = (schemas, schema, statementParams, queryType, dependencyStatement
 };
 
 // src/utils/index.ts
-var compileQueryInput = (query, schemas, statementParams, options) => {
+var compileQueryInput = (query, models, statementParams, options) => {
   const parsedQuery = splitQuery(query);
-  const { queryType, querySchema, queryInstructions } = parsedQuery;
-  const schema = getSchemaBySlug(schemas, querySchema);
-  const single = querySchema !== schema.pluralSlug;
-  let instructions = formatIdentifiers(schema, queryInstructions);
-  let table = getTableForSchema(schema);
+  const { queryType, queryModel, queryInstructions } = parsedQuery;
+  const model = getModelBySlug(models, queryModel);
+  const single = queryModel !== model.pluralSlug;
+  let instructions = formatIdentifiers(model, queryInstructions);
   const dependencyStatements = [];
   const returning = options?.returning ?? true;
-  instructions = addSchemaQueries(
-    schemas,
-    { queryType, querySchema, queryInstructions: instructions },
+  instructions = addModelQueries(
+    models,
+    { queryType, queryModel, queryInstructions: instructions },
     dependencyStatements
   );
   if (instructions && Object.hasOwn(instructions, "for")) {
-    instructions = handleFor(schema, instructions);
+    instructions = handleFor(model, instructions);
   }
-  const { columns, isJoining } = handleSelecting(schema, statementParams, {
+  const { columns, isJoining } = handleSelecting(model, statementParams, {
     selecting: instructions?.selecting,
     including: instructions?.including
   });
@@ -1298,21 +1289,21 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
   }
   let isJoiningMultipleRows = false;
   if (isJoining) {
-    const {
-      statement: including,
-      rootTableSubQuery,
-      rootTableName
-    } = handleIncluding(schemas, statementParams, instructions?.including, table);
-    if (rootTableSubQuery && rootTableName) {
-      table = rootTableName;
-      statement += `(${rootTableSubQuery}) as ${rootTableName} `;
+    const { statement: including, tableSubQuery } = handleIncluding(
+      models,
+      model,
+      statementParams,
+      instructions?.including
+    );
+    if (tableSubQuery) {
+      statement += `(${tableSubQuery}) as ${model.tableAlias} `;
       isJoiningMultipleRows = true;
     } else {
-      statement += `"${table}" `;
+      statement += `"${model.table}" `;
     }
     statement += `${including} `;
   } else {
-    statement += `"${table}" `;
+    statement += `"${model.table}" `;
   }
   if (queryType === "create" || queryType === "set") {
     if (!isObject(instructions.to) || Object.keys(instructions.to).length === 0) {
@@ -1323,24 +1314,24 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
       });
     }
     const toStatement = handleTo(
-      schemas,
-      schema,
+      models,
+      model,
       statementParams,
       queryType,
       dependencyStatements,
       { with: instructions.with, to: instructions.to },
-      isJoining ? table : void 0
+      options?.parentModel
     );
     statement += `${toStatement} `;
   }
   const conditions = [];
   if (queryType !== "create" && instructions && Object.hasOwn(instructions, "with")) {
     const withStatement = handleWith(
-      schemas,
-      schema,
+      models,
+      model,
       statementParams,
       instructions?.with,
-      isJoining ? table : void 0
+      options?.parentModel
     );
     if (withStatement.length > 0) conditions.push(withStatement);
   }
@@ -1364,18 +1355,13 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
         queries: [query]
       });
     }
-    const beforeAndAfterStatement = handleBeforeOrAfter(
-      schema,
-      statementParams,
-      {
-        before: instructions.before,
-        after: instructions.after,
-        with: instructions.with,
-        orderedBy: instructions.orderedBy,
-        limitedTo: instructions.limitedTo
-      },
-      isJoining ? table : void 0
-    );
+    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) {
@@ -1386,11 +1372,7 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
     }
   }
   if (instructions?.orderedBy) {
-    const orderedByStatement = handleOrderedBy(
-      schema,
-      instructions.orderedBy,
-      isJoining ? table : void 0
-    );
+    const orderedByStatement = handleOrderedBy(model, instructions.orderedBy);
     statement += `${orderedByStatement} `;
   }
   if (queryType === "get" && !isJoiningMultipleRows && (single || instructions?.limitedTo)) {
@@ -1411,19 +1393,19 @@ var compileQueryInput = (query, schemas, statementParams, options) => {
 };
 
 // src/index.ts
-var compileQueries = (queries, schemas, options) => {
-  const schemaList = addSystemSchemas(schemas).map((schema) => {
-    return addDefaultSchemaFields(schema, true);
+var compileQueries = (queries, models, options) => {
+  const modelList = addSystemModels(models).map((model) => {
+    return addDefaultModelFields(model, true);
   });
-  const schemaListWithPresets = schemaList.map((schema) => {
-    return addDefaultSchemaPresets(schemaList, schema);
+  const modelListWithPresets = modelList.map((model) => {
+    return addDefaultModelPresets(modelList, model);
   });
   const dependencyStatements = [];
   const mainStatements = [];
   for (const query of queries) {
     const result = compileQueryInput(
       query,
-      schemaListWithPresets,
+      modelListWithPresets,
       options?.inlineParams ? null : []
     );
     dependencyStatements.push(...result.dependencies);