@ronin/compiler 0.4.0 → 0.5.1

package/dist/index.js

@@ -96,19 +96,19 @@ var splitQuery = (query) => {
 };
 
 // src/utils/statement.ts
-var prepareStatementValue = (statementValues, value) => {
+var prepareStatementValue = (statementParams, value) => {
   if (value === null) return "NULL";
-  if (!statementValues) return JSON.stringify(value);
+  if (!statementParams) return JSON.stringify(value);
   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);
+  const index = statementParams.push(formattedValue);
   return `?${index}`;
 };
-var composeFieldValues = (schemas, schema, statementValues, instructionName, value, options) => {
+var composeFieldValues = (schemas, schema, statementParams, instructionName, value, options) => {
   const { field: schemaField, fieldSelector: selector } = getFieldFromSchema(
     schema,
     options.fieldSlug,
@@ -123,8 +123,8 @@ var composeFieldValues = (schemas, schema, statementValues, instructionName, val
     conditionValue = `(${compileQueryInput(
       value[RONIN_SCHEMA_SYMBOLS.QUERY],
       schemas,
-      statementValues
-    ).readStatement})`;
+      statementParams
+    ).main.statement})`;
   } else if (typeof value === "string" && value.startsWith(RONIN_SCHEMA_SYMBOLS.FIELD)) {
     let targetTable = `"${options.rootTable}"`;
     let toReplace = RONIN_SCHEMA_SYMBOLS.FIELD;
@@ -140,21 +140,21 @@ var composeFieldValues = (schemas, schema, statementValues, instructionName, val
   } else if (schemaField.type === "json" && instructionName === "to") {
     conditionSelector = `"${schemaField.slug}"`;
     if (collectStatementValue) {
-      const preparedValue = prepareStatementValue(statementValues, value);
+      const preparedValue = prepareStatementValue(statementParams, value);
       conditionValue = `IIF(${conditionSelector} IS NULL, ${preparedValue}, json_patch(${conditionSelector}, ${preparedValue}))`;
     }
   } else if (collectStatementValue) {
-    conditionValue = prepareStatementValue(statementValues, value);
+    conditionValue = prepareStatementValue(statementParams, value);
   }
   if (options.type === "fields") return conditionSelector;
   if (options.type === "values") return conditionValue;
   return `${conditionSelector} ${WITH_CONDITIONS[options.condition || "being"](conditionValue, value)}`;
 };
-var composeConditions = (schemas, schema, statementValues, instructionName, value, options) => {
+var composeConditions = (schemas, schema, 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, statementValues, instructionName, checkValue, {
+      ([conditionType, checkValue]) => composeConditions(schemas, schema, statementParams, instructionName, checkValue, {
         ...options,
         condition: conditionType
       })
@@ -175,7 +175,7 @@ var composeConditions = (schemas, schema, statementValues, instructionName, valu
       return composeFieldValues(
         schemas,
         schema,
-        statementValues,
+        statementParams,
         instructionName,
         value,
         { ...options, fieldSlug: options.fieldSlug }
@@ -204,7 +204,7 @@ var composeConditions = (schemas, schema, statementValues, instructionName, valu
       return composeConditions(
         schemas,
         schema,
-        statementValues,
+        statementParams,
         instructionName,
         recordTarget,
         options
@@ -214,7 +214,7 @@ var composeConditions = (schemas, schema, statementValues, instructionName, valu
   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, {
+      return composeConditions(schemas, schema, statementParams, instructionName, value2, {
         ...options,
         fieldSlug: nestedFieldSlug
       });
@@ -228,7 +228,7 @@ var composeConditions = (schemas, schema, statementValues, instructionName, valu
       (filter) => composeConditions(
         schemas,
         schema,
-        statementValues,
+        statementParams,
         instructionName,
         filter,
         options
@@ -287,11 +287,11 @@ var WITH_CONDITIONS = {
   lessThan: (value) => `< ${value}`,
   lessOrEqual: (value) => `<= ${value}`
 };
-var handleWith = (schemas, schema, statementValues, instruction, rootTable) => {
+var handleWith = (schemas, schema, statementParams, instruction, rootTable) => {
   const subStatement = composeConditions(
     schemas,
     schema,
-    statementValues,
+    statementParams,
     "with",
     instruction,
     { rootTable }
@@ -317,7 +317,7 @@ var getTableForSchema = (schema) => {
   return convertToSnakeCase(schema.pluralSlug);
 };
 var composeMetaSchemaSlug = (suffix) => convertToCamelCase(`ronin_${suffix}`);
-var composeAssociationSchemaSlug = (schema, field) => composeMetaSchemaSlug(`${schema.pluralSlug}_${field.slug}`);
+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}".` : "");
@@ -352,6 +352,53 @@ var getFieldFromSchema = (schema, fieldPath, instructionName, rootTable) => {
   const fieldSelector = getFieldSelector(schemaField, fieldPath, rootTable);
   return { field: schemaField, fieldSelector };
 };
+var slugToName = (slug) => {
+  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
+  return title(name);
+};
+var VOWELS = ["a", "e", "i", "o", "u"];
+var pluralize = (word) => {
+  const lastLetter = word.slice(-1).toLowerCase();
+  const secondLastLetter = word.slice(-2, -1).toLowerCase();
+  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
+    return `${word.slice(0, -1)}ies`;
+  }
+  if (lastLetter === "s" || word.slice(-2).toLowerCase() === "ch" || word.slice(-2).toLowerCase() === "sh" || word.slice(-2).toLowerCase() === "ex") {
+    return `${word}es`;
+  }
+  return `${word}s`;
+};
+var schemaSettings = [
+  ["pluralSlug", "slug", pluralize],
+  ["name", "slug", slugToName],
+  ["pluralName", "pluralSlug", slugToName],
+  ["idPrefix", "slug", (slug) => slug.slice(0, 3)]
+];
+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]);
+  }
+  const newFields = copiedSchema.fields || [];
+  if (isNew || newFields.length > 0) {
+    if (!copiedSchema.identifiers) copiedSchema.identifiers = {};
+    if (!copiedSchema.identifiers.name) {
+      const suitableField = newFields.find(
+        (field) => field.type === "string" && field.required === true && ["name"].includes(field.slug)
+      );
+      copiedSchema.identifiers.name = suitableField?.slug || "id";
+    }
+    if (!copiedSchema.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";
+    }
+    copiedSchema.fields = [...SYSTEM_FIELDS, ...newFields];
+  }
+  return copiedSchema;
+};
 var SYSTEM_FIELDS = [
   {
     name: "ID",
@@ -392,16 +439,12 @@ var SYSTEM_FIELDS = [
 ];
 var SYSTEM_SCHEMAS = [
   {
-    name: "Schema",
-    pluralName: "Schemas",
     slug: "schema",
-    pluralSlug: "schemas",
     identifiers: {
       name: "name",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "name", type: "string" },
       { slug: "pluralName", type: "string" },
       { slug: "slug", type: "string" },
@@ -412,20 +455,18 @@ var SYSTEM_SCHEMAS = [
       { slug: "identifiers.slug", type: "string" },
       { slug: "fields", type: "json" },
       { slug: "indexes", type: "json" },
-      { slug: "triggers", type: "json" }
+      { slug: "triggers", type: "json" },
+      { slug: "including", type: "json" },
+      { slug: "for", type: "json" }
     ]
   },
   {
-    name: "Field",
-    pluralName: "Fields",
     slug: "field",
-    pluralSlug: "fields",
     identifiers: {
       name: "name",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "name", type: "string" },
       { slug: "slug", type: "string", required: true },
       { slug: "type", type: "string", required: true },
@@ -448,16 +489,12 @@ var SYSTEM_SCHEMAS = [
     ]
   },
   {
-    name: "Index",
-    pluralName: "Indexes",
     slug: "index",
-    pluralSlug: "indexes",
     identifiers: {
       name: "slug",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "slug", type: "string", required: true },
       {
         slug: "schema",
@@ -470,16 +507,12 @@ var SYSTEM_SCHEMAS = [
     ]
   },
   {
-    name: "Trigger",
-    pluralName: "Triggers",
     slug: "trigger",
-    pluralSlug: "triggers",
     identifiers: {
       name: "slug",
       slug: "slug"
     },
     fields: [
-      ...SYSTEM_FIELDS,
       { slug: "slug", type: "string", required: true },
       { slug: "schema", type: "reference", target: { slug: "schema" }, required: true },
       { slug: "cause", type: "string", required: true },
@@ -487,85 +520,89 @@ var SYSTEM_SCHEMAS = [
       { slug: "effects", type: "json", required: true }
     ]
   }
-];
+].map((schema) => addDefaultSchemaFields(schema, true));
 var SYSTEM_SCHEMA_SLUGS = SYSTEM_SCHEMAS.flatMap(({ slug, pluralSlug }) => [
   slug,
   pluralSlug
 ]);
-var prepareSchema = (schema) => {
-  const copiedSchema = { ...schema };
-  if (!copiedSchema.pluralSlug) copiedSchema.pluralSlug = pluralize(copiedSchema.slug);
-  if (!copiedSchema.name) copiedSchema.name = slugToName(copiedSchema.slug);
-  if (!copiedSchema.pluralName)
-    copiedSchema.pluralName = slugToName(copiedSchema.pluralSlug);
-  if (!copiedSchema.idPrefix) copiedSchema.idPrefix = copiedSchema.slug.slice(0, 3);
-  if (!copiedSchema.identifiers) copiedSchema.identifiers = {};
-  if (!copiedSchema.identifiers.name) copiedSchema.identifiers.name = "id";
-  if (!copiedSchema.identifiers.slug) copiedSchema.identifiers.slug = "id";
-  return copiedSchema;
-};
 var addSystemSchemas = (schemas) => {
-  const list = [...SYSTEM_SCHEMAS, ...schemas].map(prepareSchema);
-  for (const schema of list) {
-    const defaultIncluding = {};
+  const associativeSchemas = schemas.flatMap((schema) => {
+    const addedSchemas = [];
     for (const field of schema.fields || []) {
       if (field.type === "reference" && !field.slug.startsWith("ronin.")) {
-        const relatedSchema = getSchemaBySlug(list, field.target.slug);
+        const relatedSchema = getSchemaBySlug(schemas, field.target.slug);
         let fieldSlug = relatedSchema.slug;
         if (field.kind === "many") {
           fieldSlug = composeAssociationSchemaSlug(schema, field);
-          list.push({
+          addedSchemas.push({
             pluralSlug: fieldSlug,
             slug: fieldSlug,
-            identifiers: {
-              name: "id",
-              slug: "id"
-            },
             fields: [
               {
                 slug: "source",
                 type: "reference",
-                target: schema
+                target: { slug: schema.slug }
               },
               {
                 slug: "target",
                 type: "reference",
-                target: relatedSchema
+                target: { slug: 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}`
-              }
+      }
+    }
+    return addedSchemas;
+  });
+  return [...SYSTEM_SCHEMAS, ...associativeSchemas, ...schemas];
+};
+var addDefaultSchemaShortcuts = (list, schema) => {
+  const defaultIncluding = {};
+  for (const field of schema.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);
+      }
+      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 = getSchemaBySlug(list, field.target.slug);
-        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 || []];
+  }
+  const childSchemas = list.map((subSchema) => {
+    const field = subSchema.fields?.find((field2) => {
+      return field2.type === "reference" && field2.target.slug === schema.slug;
+    });
+    if (!field) return null;
+    return { schema: subSchema, field };
+  }).filter((match) => match !== null);
+  for (const childMatch of childSchemas) {
+    const { schema: childSchema, field: childField } = childMatch;
+    const pluralSlug = childSchema.pluralSlug;
+    defaultIncluding[pluralSlug] = {
+      get: {
+        [pluralSlug]: {
+          with: {
+            [childField.slug]: `${RONIN_SCHEMA_SYMBOLS.FIELD}id`
+          }
+        }
+      }
+    };
+  }
+  if (Object.keys(defaultIncluding).length > 0) {
     schema.including = { ...defaultIncluding, ...schema.including };
   }
-  return list;
+  return schema;
 };
 var mappedInstructions = {
   create: "to",
@@ -601,7 +638,7 @@ var getFieldStatement = (field) => {
   }
   return statement;
 };
-var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements) => {
+var addSchemaQueries = (schemas, queryDetails, dependencyStatements) => {
   const {
     queryType,
     querySchema,
@@ -653,30 +690,33 @@ var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements)
       fields: ["schema.slug"]
     });
   }
-  const tableName = convertToSnakeCase(pluralize(kind === "schemas" ? slug : schemaSlug));
+  const usableSlug = kind === "schemas" ? slug : schemaSlug;
+  const tableName = convertToSnakeCase(pluralize(usableSlug));
+  const targetSchema = kind === "schemas" && queryType === "create" ? null : getSchemaBySlug(schemas, usableSlug);
   if (kind === "indexes") {
     const indexName = convertToSnakeCase(slug);
     const unique = instructionList?.unique;
     const filterQuery = instructionList?.filter;
+    const params = [];
     let statement2 = `${tableAction}${unique ? " UNIQUE" : ""} INDEX "${indexName}"`;
     if (queryType === "create") {
       statement2 += ` ON "${tableName}"`;
       if (filterQuery) {
-        const targetSchema = getSchemaBySlug(schemas, schemaSlug);
         const withStatement = handleWith(
           schemas,
           targetSchema,
-          statementValues,
+          params,
           filterQuery
         );
         statement2 += ` WHERE (${withStatement})`;
       }
     }
-    writeStatements.push(statement2);
+    dependencyStatements.push({ statement: statement2, params });
     return queryInstructions;
   }
   if (kind === "triggers") {
     const triggerName = convertToSnakeCase(slug);
+    const params = [];
     let statement2 = `${tableAction} TRIGGER "${triggerName}"`;
     if (queryType === "create") {
       const cause = slugToName(instructionList?.cause).toUpperCase();
@@ -687,48 +727,61 @@ var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements)
         statementParts.push("FOR EACH ROW");
       }
       if (filterQuery) {
-        const targetSchema = getSchemaBySlug(schemas, schemaSlug);
         const tablePlaceholder = cause.endsWith("DELETE") ? RONIN_SCHEMA_SYMBOLS.FIELD_OLD : RONIN_SCHEMA_SYMBOLS.FIELD_NEW;
         const withStatement = handleWith(
           schemas,
           targetSchema,
-          statementValues,
+          params,
           filterQuery,
           tablePlaceholder
         );
         statementParts.push("WHEN", `(${withStatement})`);
       }
       const effectStatements = effectQueries.map((effectQuery) => {
-        return compileQueryInput(effectQuery, schemas, statementValues, {
-          disableReturning: true
-        }).readStatement;
+        return compileQueryInput(effectQuery, schemas, params, {
+          returning: false
+        }).main.statement;
       });
       if (effectStatements.length > 1) statementParts.push("BEGIN");
       statementParts.push(effectStatements.join("; "));
       if (effectStatements.length > 1) statementParts.push("END");
       statement2 += ` ${statementParts.join(" ")}`;
     }
-    writeStatements.push(statement2);
+    dependencyStatements.push({ statement: statement2, params });
     return queryInstructions;
   }
-  let statement = `${tableAction} TABLE "${tableName}"`;
+  const statement = `${tableAction} TABLE "${tableName}"`;
   if (kind === "schemas") {
-    const providedFields = instructionList?.fields || [];
-    const fields = [...SYSTEM_FIELDS, ...providedFields];
     if (queryType === "create" || queryType === "set") {
-      queryInstructions.to = prepareSchema(queryInstructions.to);
+      const schemaWithFields = addDefaultSchemaFields(
+        queryInstructions.to,
+        queryType === "create"
+      );
+      const schemaWithShortcuts = addDefaultSchemaShortcuts(schemas, schemaWithFields);
+      queryInstructions.to = schemaWithShortcuts;
     }
     if (queryType === "create") {
+      const { fields } = queryInstructions.to;
       const columns = fields.map(getFieldStatement).filter(Boolean);
-      statement += ` (${columns.join(", ")})`;
+      dependencyStatements.push({
+        statement: `${statement} (${columns.join(", ")})`,
+        params: []
+      });
+      schemas.push(queryInstructions.to);
     } else if (queryType === "set") {
       const newSlug = queryInstructions.to?.pluralSlug;
       if (newSlug) {
         const newTable = convertToSnakeCase(newSlug);
-        statement += ` RENAME TO "${newTable}"`;
+        dependencyStatements.push({
+          statement: `${statement} RENAME TO "${newTable}"`,
+          params: []
+        });
       }
+      Object.assign(targetSchema, queryInstructions.to);
+    } else if (queryType === "drop") {
+      schemas.splice(schemas.indexOf(targetSchema), 1);
+      dependencyStatements.push({ statement, params: [] });
     }
-    writeStatements.push(statement);
     return queryInstructions;
   }
   if (kind === "fields") {
@@ -740,52 +793,51 @@ var addSchemaQueries = (schemas, statementValues, queryDetails, writeStatements)
           fields: ["type"]
         });
       }
-      statement += ` ADD COLUMN ${getFieldStatement(instructionList)}`;
+      dependencyStatements.push({
+        statement: `${statement} ADD COLUMN ${getFieldStatement(instructionList)}`,
+        params: []
+      });
     } else if (queryType === "set") {
       const newSlug = queryInstructions.to?.slug;
       if (newSlug) {
-        statement += ` RENAME COLUMN "${slug}" TO "${newSlug}"`;
+        dependencyStatements.push({
+          statement: `${statement} RENAME COLUMN "${slug}" TO "${newSlug}"`,
+          params: []
+        });
       }
     } else if (queryType === "drop") {
-      statement += ` DROP COLUMN "${slug}"`;
+      dependencyStatements.push({
+        statement: `${statement} DROP COLUMN "${slug}"`,
+        params: []
+      });
     }
-    writeStatements.push(statement);
   }
   return queryInstructions;
 };
-var slugToName = (slug) => {
-  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
-  return title(name);
-};
-var VOWELS = ["a", "e", "i", "o", "u"];
-var pluralize = (word) => {
-  const lastLetter = word.slice(-1).toLowerCase();
-  const secondLastLetter = word.slice(-2, -1).toLowerCase();
-  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
-    return `${word.slice(0, -1)}ies`;
-  }
-  if (lastLetter === "s" || word.slice(-2).toLowerCase() === "ch" || word.slice(-2).toLowerCase() === "sh" || word.slice(-2).toLowerCase() === "ex") {
-    return `${word}es`;
-  }
-  return `${word}s`;
-};
 
 // src/instructions/before-after.ts
 var CURSOR_SEPARATOR = ",";
 var CURSOR_NULL_PLACEHOLDER = "RONIN_NULL";
-var handleBeforeOrAfter = (schema, statementValues, instructions, rootTable) => {
+var handleBeforeOrAfter = (schema, statementParams, 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
+      code: "MISSING_INSTRUCTION"
     });
   }
   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
+      code: "MUTUALLY_EXCLUSIVE_INSTRUCTIONS"
+    });
+  }
+  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 || {};
@@ -799,15 +851,15 @@ var handleBeforeOrAfter = (schema, statementValues, instructions, rootTable) =>
     }
     const { field } = getFieldFromSchema(schema, key, "orderedBy");
     if (field.type === "boolean") {
-      return prepareStatementValue(statementValues, value === "true");
+      return prepareStatementValue(statementParams, value === "true");
     }
     if (field.type === "number") {
-      return prepareStatementValue(statementValues, Number.parseInt(value));
+      return prepareStatementValue(statementParams, Number.parseInt(value));
     }
     if (field.type === "date") {
       return `'${new Date(Number.parseInt(value)).toJSON()}'`;
     }
-    return prepareStatementValue(statementValues, value);
+    return prepareStatementValue(statementParams, value);
   });
   const compareOperators = [
     // Reverse the comparison operators if we're querying for records before.
@@ -850,7 +902,7 @@ var handleBeforeOrAfter = (schema, statementValues, instructions, rootTable) =>
 };
 
 // src/instructions/for.ts
-var handleFor = (schemas, schema, statementValues, instruction, rootTable) => {
+var handleFor = (schemas, schema, statementParams, instruction, rootTable) => {
   let statement = "";
   if (!instruction) return statement;
   for (const shortcut in instruction) {
@@ -871,7 +923,7 @@ var handleFor = (schemas, schema, statementValues, instruction, rootTable) => {
     const subStatement = composeConditions(
       schemas,
       schema,
-      statementValues,
+      statementParams,
       "for",
       replacedForFilter,
       { rootTable }
@@ -882,7 +934,7 @@ var handleFor = (schemas, schema, statementValues, instruction, rootTable) => {
 };
 
 // src/instructions/including.ts
-var handleIncluding = (schemas, statementValues, schema, instruction, rootTable) => {
+var handleIncluding = (schemas, statementParams, schema, instruction, rootTable) => {
   let statement = "";
   let rootTableSubQuery;
   let rootTableName = rootTable;
@@ -916,9 +968,9 @@ var handleIncluding = (schemas, statementValues, schema, instruction, rootTable)
           }
         },
         schemas,
-        statementValues
+        statementParams
       );
-      relatedTableSelector = `(${subSelect.readStatement})`;
+      relatedTableSelector = `(${subSelect.main.statement})`;
     }
     statement += `${joinType} JOIN ${relatedTableSelector} as ${tableAlias}`;
     if (joinType === "LEFT") {
@@ -929,7 +981,7 @@ var handleIncluding = (schemas, statementValues, schema, instruction, rootTable)
       const subStatement = composeConditions(
         schemas,
         relatedSchema,
-        statementValues,
+        statementParams,
         "including",
         queryInstructions?.with,
         {
@@ -945,9 +997,10 @@ var handleIncluding = (schemas, statementValues, schema, instruction, rootTable)
 
 // src/instructions/limited-to.ts
 var handleLimitedTo = (single, instruction) => {
-  const pageSize = instruction || 100;
-  const finalPageSize = pageSize + 1;
-  return `LIMIT ${single ? "1" : finalPageSize} `;
+  let amount;
+  if (instruction) amount = instruction + 1;
+  if (single) amount = 1;
+  return `LIMIT ${amount} `;
 };
 
 // src/instructions/ordered-by.ts
@@ -983,7 +1036,7 @@ var handleOrderedBy = (schema, instruction, rootTable) => {
 };
 
 // src/instructions/selecting.ts
-var handleSelecting = (schema, statementValues, instructions) => {
+var handleSelecting = (schema, statementParams, instructions) => {
   let statement = instructions.selecting ? instructions.selecting.map((slug) => {
     return getFieldFromSchema(schema, slug, "selecting").fieldSelector;
   }).join(", ") : "*";
@@ -994,14 +1047,14 @@ var handleSelecting = (schema, statementValues, instructions) => {
     ).filter(([_, value]) => {
       return !(isObject(value) && Object.hasOwn(value, RONIN_SCHEMA_SYMBOLS.QUERY));
     }).map(([key, value]) => {
-      return `${prepareStatementValue(statementValues, value)} as "${key}"`;
+      return `${prepareStatementValue(statementParams, value)} as "${key}"`;
     }).join(", ");
   }
   return statement;
 };
 
 // src/instructions/to.ts
-var handleTo = (schemas, schema, statementValues, queryType, writeStatements, instructions, rootTable) => {
+var handleTo = (schemas, schema, statementParams, queryType, dependencyStatements, instructions, rootTable) => {
   const currentTime = (/* @__PURE__ */ new Date()).toISOString();
   const { with: withInstruction, to: toInstruction } = instructions;
   const defaultFields = {};
@@ -1043,7 +1096,7 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
         ...subQueryInstructions.including
       };
     }
-    return compileQueryInput(subQuery, schemas, statementValues).readStatement;
+    return compileQueryInput(subQuery, schemas, statementParams).main.statement;
   }
   Object.assign(toInstruction, defaultFields);
   for (const fieldSlug in toInstruction) {
@@ -1059,29 +1112,28 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
         const source = queryType === "create" ? { id: toInstruction.id } : withInstruction;
         const recordDetails = { source };
         if (value) recordDetails.target = value;
-        const { readStatement } = compileQueryInput(
+        return compileQueryInput(
           {
             [subQueryType]: {
               [associativeSchemaSlug]: subQueryType === "create" ? { to: recordDetails } : { with: recordDetails }
             }
           },
           schemas,
-          statementValues,
-          { disableReturning: true }
-        );
-        return readStatement;
+          [],
+          { returning: false }
+        ).main;
       };
       if (Array.isArray(fieldValue)) {
-        writeStatements.push(composeStatement("drop"));
+        dependencyStatements.push(composeStatement("drop"));
         for (const record of fieldValue) {
-          writeStatements.push(composeStatement("create", record));
+          dependencyStatements.push(composeStatement("create", record));
         }
       } else if (isObject(fieldValue)) {
         for (const recordToAdd of fieldValue.containing || []) {
-          writeStatements.push(composeStatement("create", recordToAdd));
+          dependencyStatements.push(composeStatement("create", recordToAdd));
         }
         for (const recordToRemove of fieldValue.notContaining || []) {
-          writeStatements.push(composeStatement("drop", recordToRemove));
+          dependencyStatements.push(composeStatement("drop", recordToRemove));
         }
       }
     }
@@ -1089,7 +1141,7 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
   let statement = composeConditions(
     schemas,
     schema,
-    statementValues,
+    statementParams,
     "to",
     toInstruction,
     {
@@ -1101,7 +1153,7 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
     const deepStatement = composeConditions(
       schemas,
       schema,
-      statementValues,
+      statementParams,
       "to",
       toInstruction,
       {
@@ -1117,22 +1169,21 @@ var handleTo = (schemas, schema, statementValues, queryType, writeStatements, in
 };
 
 // src/utils/index.ts
-var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
+var compileQueryInput = (query, schemas, statementParams, 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 writeStatements = [];
+  const dependencyStatements = [];
+  const returning = options?.returning ?? true;
   instructions = addSchemaQueries(
     schemas,
-    statementValues,
     { queryType, querySchema, queryInstructions: instructions },
-    writeStatements
+    dependencyStatements
   );
-  const columns = handleSelecting(schema, statementValues, {
+  const columns = handleSelecting(schema, statementParams, {
     selecting: instructions?.selecting,
     including: instructions?.including
   });
@@ -1161,7 +1212,7 @@ var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
       statement: including,
       rootTableSubQuery,
       rootTableName
-    } = handleIncluding(schemas, statementValues, schema, instructions?.including, table);
+    } = handleIncluding(schemas, statementParams, schema, instructions?.including, table);
     if (rootTableSubQuery && rootTableName) {
       table = rootTableName;
       statement += `(${rootTableSubQuery}) as ${rootTableName} `;
@@ -1184,9 +1235,9 @@ var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
     const toStatement = handleTo(
       schemas,
       schema,
-      statementValues,
+      statementParams,
       queryType,
-      writeStatements,
+      dependencyStatements,
       { with: instructions.with, to: instructions.to },
       isJoining ? table : void 0
     );
@@ -1197,7 +1248,7 @@ var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
     const withStatement = handleWith(
       schemas,
       schema,
-      statementValues,
+      statementParams,
       instructions?.with,
       isJoining ? table : void 0
     );
@@ -1207,13 +1258,13 @@ var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
     const forStatement = handleFor(
       schemas,
       schema,
-      statementValues,
+      statementParams,
       instructions?.for,
       isJoining ? table : void 0
     );
     if (forStatement.length > 0) conditions.push(forStatement);
   }
-  if ((queryType === "get" || queryType === "count") && !single) {
+  if ((queryType === "get" || queryType === "count") && !single && instructions?.limitedTo) {
     instructions = instructions || {};
     instructions.orderedBy = instructions.orderedBy || {};
     instructions.orderedBy.ascending = instructions.orderedBy.ascending || [];
@@ -1235,12 +1286,13 @@ var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
     }
     const beforeAndAfterStatement = handleBeforeOrAfter(
       schema,
-      statementValues,
+      statementParams,
       {
         before: instructions.before,
         after: instructions.after,
         with: instructions.with,
-        orderedBy: instructions.orderedBy
+        orderedBy: instructions.orderedBy,
+        limitedTo: instructions.limitedTo
       },
       isJoining ? table : void 0
     );
@@ -1261,25 +1313,44 @@ var compileQueryInput = (query, defaultSchemas, statementValues, options) => {
     );
     statement += `${orderedByStatement} `;
   }
-  if (queryType === "get" && !isJoiningMultipleRows) {
+  if (queryType === "get" && !isJoiningMultipleRows && (single || instructions?.limitedTo)) {
     statement += handleLimitedTo(single, instructions?.limitedTo);
   }
-  if (["create", "set", "drop"].includes(queryType) && !options?.disableReturning) {
+  if (["create", "set", "drop"].includes(queryType) && returning) {
     statement += "RETURNING * ";
   }
-  const finalStatement = statement.trimEnd();
+  const mainStatement = {
+    statement: statement.trimEnd(),
+    params: statementParams || []
+  };
+  if (returning) mainStatement.returning = true;
   return {
-    writeStatements,
-    readStatement: finalStatement,
-    values: statementValues || []
+    dependencies: dependencyStatements,
+    main: mainStatement
   };
 };
 
 // src/index.ts
-var compileQuery = (query, schemas, options) => {
-  const statementValues = options?.inlineValues ? null : [];
-  return compileQueryInput(query, schemas, statementValues);
+var compileQueries = (queries, schemas, options) => {
+  const schemaList = addSystemSchemas(schemas).map((schema) => {
+    return addDefaultSchemaFields(schema, true);
+  });
+  const schemaListWithShortcuts = schemaList.map((schema) => {
+    return addDefaultSchemaShortcuts(schemaList, schema);
+  });
+  const dependencyStatements = [];
+  const mainStatements = [];
+  for (const query of queries) {
+    const result = compileQueryInput(
+      query,
+      schemaListWithShortcuts,
+      options?.inlineValues ? null : []
+    );
+    dependencyStatements.push(...result.dependencies);
+    mainStatements.push(result.main);
+  }
+  return [...dependencyStatements, ...mainStatements];
 };
 export {
-  compileQuery
+  compileQueries
 };