@ronin/compiler 0.17.6 → 0.17.7-leo-ron-1099-experimental-394

package/dist/index.d.ts

@@ -117,6 +117,14 @@ type AddQuery = Record<string, Omit<CombinedInstructions, 'with' | 'using'> & {
 }>;
 type RemoveQuery = Record<string, Omit<CombinedInstructions, 'to'>>;
 type CountQuery = Record<string, Omit<CombinedInstructions, 'to'> | null>;
+type AllQueryInstructions = {
+    for?: string;
+};
+type AllQuery = {
+    all: AllQueryInstructions | null;
+};
+type GetAllQuery = AllQuery;
+type CountAllQuery = AllQuery;
 type GetInstructions = Omit<CombinedInstructions, 'to'>;
 type SetInstructions = Omit<CombinedInstructions, 'to'> & {
     to: FieldSelector;
@@ -158,11 +166,11 @@ type DropQuery = {
     model: string;
 };
 type Query = {
-    get?: GetQuery;
+    get?: GetQuery | GetAllQuery;
     set?: SetQuery;
     add?: AddQuery;
     remove?: RemoveQuery;
-    count?: CountQuery;
+    count?: CountQuery | CountAllQuery;
     create?: CreateQuery;
     alter?: AlterQuery;
     drop?: DropQuery;

package/dist/index.js

@@ -23,12 +23,6 @@ var RAW_FIELD_TYPES = ["string", "number", "boolean"];
 var CURRENT_TIME_EXPRESSION = {
   [QUERY_SYMBOLS.EXPRESSION]: `strftime('%Y-%m-%dT%H:%M:%f', 'now') || 'Z'`
 };
-var ID_EXPRESSION = (idPrefix) => ({
-  // Since default values in SQLite cannot rely on other columns, we unfortunately
-  // cannot rely on the `idPrefix` column here. Instead, we need to inject it directly
-  // into the expression as a static string.
-  [QUERY_SYMBOLS.EXPRESSION]: `'${idPrefix}_' || lower(substr(hex(randomblob(12)), 1, 16))`
-});
 var MOUNTING_PATH_SUFFIX = /(.*?)(\{(\d+)\})?$/;
 var composeMountingPath = (single, key, mountingPath) => {
   if (key === "ronin_root") {
@@ -465,72 +459,458 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
   return { columns: columns.join(", "), isJoining, selectedFields };
 };
 
-// src/instructions/to.ts
-var handleTo = (models, model, statementParams, queryType, dependencyStatements, instructions, options) => {
-  const { with: withInstruction, to: toInstruction } = instructions;
-  const defaultFields = {};
-  const inlineDefaultInsertionFields = queryType === "add" && options?.inlineDefaults;
-  if (inlineDefaultInsertionFields) {
-    defaultFields.id = toInstruction.id || ID_EXPRESSION(model.idPrefix);
+// node_modules/title/dist/esm/lower-case.js
+var conjunctions = [
+  "for",
+  "and",
+  "nor",
+  "but",
+  "or",
+  "yet",
+  "so"
+];
+var articles = [
+  "a",
+  "an",
+  "the"
+];
+var prepositions = [
+  "aboard",
+  "about",
+  "above",
+  "across",
+  "after",
+  "against",
+  "along",
+  "amid",
+  "among",
+  "anti",
+  "around",
+  "as",
+  "at",
+  "before",
+  "behind",
+  "below",
+  "beneath",
+  "beside",
+  "besides",
+  "between",
+  "beyond",
+  "but",
+  "by",
+  "concerning",
+  "considering",
+  "despite",
+  "down",
+  "during",
+  "except",
+  "excepting",
+  "excluding",
+  "following",
+  "for",
+  "from",
+  "in",
+  "inside",
+  "into",
+  "like",
+  "minus",
+  "near",
+  "of",
+  "off",
+  "on",
+  "onto",
+  "opposite",
+  "over",
+  "past",
+  "per",
+  "plus",
+  "regarding",
+  "round",
+  "save",
+  "since",
+  "than",
+  "through",
+  "to",
+  "toward",
+  "towards",
+  "under",
+  "underneath",
+  "unlike",
+  "until",
+  "up",
+  "upon",
+  "versus",
+  "via",
+  "with",
+  "within",
+  "without"
+];
+var lowerCase = /* @__PURE__ */ new Set([
+  ...conjunctions,
+  ...articles,
+  ...prepositions
+]);
+
+// node_modules/title/dist/esm/specials.js
+var specials = [
+  "ZEIT",
+  "ZEIT Inc.",
+  "Vercel",
+  "Vercel Inc.",
+  "CLI",
+  "API",
+  "HTTP",
+  "HTTPS",
+  "JSX",
+  "DNS",
+  "URL",
+  "now.sh",
+  "now.json",
+  "vercel.app",
+  "vercel.json",
+  "CI",
+  "CD",
+  "CDN",
+  "package.json",
+  "package.lock",
+  "yarn.lock",
+  "GitHub",
+  "GitLab",
+  "CSS",
+  "Sass",
+  "JS",
+  "JavaScript",
+  "TypeScript",
+  "HTML",
+  "WordPress",
+  "Next.js",
+  "Node.js",
+  "Webpack",
+  "Docker",
+  "Bash",
+  "Kubernetes",
+  "SWR",
+  "TinaCMS",
+  "UI",
+  "UX",
+  "TS",
+  "TSX",
+  "iPhone",
+  "iPad",
+  "watchOS",
+  "iOS",
+  "iPadOS",
+  "macOS",
+  "PHP",
+  "composer.json",
+  "composer.lock",
+  "CMS",
+  "SQL",
+  "C",
+  "C#",
+  "GraphQL",
+  "GraphiQL",
+  "JWT",
+  "JWTs"
+];
+
+// node_modules/title/dist/esm/index.js
+var word = `[^\\s'\u2019\\(\\)!?;:"-]`;
+var regex = new RegExp(`(?:(?:(\\s?(?:^|[.\\(\\)!?;:"-])\\s*)(${word}))|(${word}))(${word}*[\u2019']*${word}*)`, "g");
+var convertToRegExp = (specials2) => specials2.map((s) => [new RegExp(`\\b${s}\\b`, "gi"), s]);
+function parseMatch(match) {
+  const firstCharacter = match[0];
+  if (/\s/.test(firstCharacter)) {
+    return match.slice(1);
   }
-  if (queryType === "add" || queryType === "set" || toInstruction.ronin) {
-    const defaults = {
-      // If records are being created, set their creation time.
-      ...inlineDefaultInsertionFields ? { createdAt: CURRENT_TIME_EXPRESSION } : {},
-      // If records are being updated, bump their update time.
-      ...queryType === "set" || inlineDefaultInsertionFields ? { updatedAt: CURRENT_TIME_EXPRESSION } : {},
-      // Allow for overwriting the default values provided above.
-      ...toInstruction.ronin
-    };
-    if (Object.keys(defaults).length > 0) defaultFields.ronin = defaults;
+  if (/[\(\)]/.test(firstCharacter)) {
+    return null;
   }
-  const symbol = getQuerySymbol(toInstruction);
-  if (symbol?.type === "query") {
-    const { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
-    const subQueryModel = getModelBySlug(models, subQueryModelSlug);
-    const subQuerySelectedFields = subQueryInstructions?.selecting;
-    const subQueryIncludedFields = subQueryInstructions?.including;
-    const subQueryFields = [
-      ...filterSelectedFields(subQueryModel, subQuerySelectedFields).map(
-        (field) => field.slug
-      ),
-      ...subQueryIncludedFields ? Object.keys(
-        flatten(subQueryIncludedFields || {})
-      ) : []
-    ];
-    for (const field of subQueryFields || []) {
-      getFieldFromModel(model, field, { instructionName: "to" });
+  return match;
+}
+var src_default = (str, options = {}) => {
+  str = str.toLowerCase().replace(regex, (m, lead = "", forced, lower, rest, offset, string) => {
+    const isLastWord = m.length + offset >= string.length;
+    const parsedMatch = parseMatch(m);
+    if (!parsedMatch) {
+      return m;
     }
-    let statement2 = "";
-    if (subQuerySelectedFields) {
-      const columns = subQueryFields.map((field) => {
-        return getFieldFromModel(model, field, { instructionName: "to" }).fieldSelector;
-      });
-      statement2 = `(${columns.join(", ")}) `;
+    if (!forced) {
+      const fullLower = lower + rest;
+      if (lowerCase.has(fullLower) && !isLastWord) {
+        return parsedMatch;
+      }
     }
-    statement2 += compileQueryInput(symbol.value, models, statementParams, {
-      // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
-      inlineDefaults: options?.inlineDefaults || false
-    }).main.statement;
-    return statement2;
+    return lead + (lower || forced).toUpperCase() + rest;
+  });
+  const customSpecials = options.special || [];
+  const replace = [...specials, ...customSpecials];
+  const replaceRegExp = convertToRegExp(replace);
+  replaceRegExp.forEach(([pattern, s]) => {
+    str = str.replace(pattern, s);
+  });
+  return str;
+};
+
+// src/model/defaults.ts
+var slugToName = (slug) => {
+  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
+  return src_default(name);
+};
+var VOWELS = ["a", "e", "i", "o", "u"];
+var pluralize = (word2) => {
+  const lastLetter = word2.slice(-1).toLowerCase();
+  const secondLastLetter = word2.slice(-2, -1).toLowerCase();
+  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
+    return `${word2.slice(0, -1)}ies`;
   }
-  Object.assign(toInstruction, defaultFields);
-  for (const fieldSlug in toInstruction) {
-    if (!Object.hasOwn(toInstruction, fieldSlug)) continue;
-    const fieldValue = toInstruction[fieldSlug];
-    const fieldDetails = getFieldFromModel(
-      model,
-      fieldSlug,
-      { instructionName: "to" },
-      false
-    );
-    if (fieldDetails?.field.type === "link" && fieldDetails.field.kind === "many") {
-      delete toInstruction[fieldSlug];
-      const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);
-      const composeStatement = (subQueryType, value) => {
-        const source = queryType === "add" ? toInstruction : withInstruction;
-        const recordDetails = { source };
-        if (value) recordDetails.target = value;
+  if (lastLetter === "s" || word2.slice(-2).toLowerCase() === "ch" || word2.slice(-2).toLowerCase() === "sh" || word2.slice(-2).toLowerCase() === "ex") {
+    return `${word2}es`;
+  }
+  return `${word2}s`;
+};
+var modelAttributes = [
+  ["pluralSlug", "slug", pluralize, true],
+  ["name", "slug", slugToName, false],
+  ["pluralName", "pluralSlug", slugToName, false],
+  ["idPrefix", "slug", (slug) => slug.slice(0, 3).toLowerCase(), false],
+  ["table", "pluralSlug", convertToSnakeCase, true]
+];
+var getRecordIdentifier = (prefix) => {
+  return `${prefix}_${Array.from(crypto.getRandomValues(new Uint8Array(12))).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16).toLowerCase()}`;
+};
+var addDefaultModelAttributes = (model, isNew) => {
+  const copiedModel = { ...model };
+  if (isNew && !copiedModel.id) copiedModel.id = getRecordIdentifier("mod");
+  for (const [setting, base, generator, mustRegenerate] of modelAttributes) {
+    if (!(isNew || mustRegenerate)) continue;
+    if (copiedModel[setting] || !copiedModel[base]) continue;
+    copiedModel[setting] = generator(copiedModel[base]);
+  }
+  const newFields = copiedModel.fields || [];
+  if (isNew || Object.keys(newFields).length > 0) {
+    if (!copiedModel.identifiers) copiedModel.identifiers = {};
+    if (!copiedModel.identifiers.name) {
+      const suitableField = Object.entries(newFields).find(
+        ([fieldSlug, field]) => field.type === "string" && field.required === true && ["name"].includes(fieldSlug)
+      );
+      copiedModel.identifiers.name = suitableField?.[0] || "id";
+    }
+    if (!copiedModel.identifiers.slug) {
+      const suitableField = Object.entries(newFields).find(
+        ([fieldSlug, field]) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(fieldSlug)
+      );
+      copiedModel.identifiers.slug = suitableField?.[0] || "id";
+    }
+  }
+  return copiedModel;
+};
+var addDefaultModelFields = (model, isNew) => {
+  const copiedModel = { ...model };
+  const existingFields = copiedModel.fields || [];
+  if (isNew || Object.keys(existingFields).length > 0) {
+    const additionalFields = Object.fromEntries(
+      Object.entries(getSystemFields(copiedModel.idPrefix)).filter(([newFieldSlug]) => {
+        return !Object.hasOwn(existingFields, newFieldSlug);
+      })
+    );
+    copiedModel.fields = { ...additionalFields, ...existingFields };
+  }
+  return copiedModel;
+};
+var addDefaultModelPresets = (list, model) => {
+  const defaultPresets = {};
+  for (const [fieldSlug, rest] of Object.entries(model.fields || {})) {
+    const field = { slug: fieldSlug, ...rest };
+    if (field.type === "link" && !fieldSlug.startsWith("ronin.")) {
+      const targetModel = getModelBySlug(list, field.target);
+      if (field.kind === "many") {
+        const systemModel = list.find(({ system }) => {
+          return system?.model === model.id && system?.associationSlug === field.slug;
+        });
+        if (!systemModel) continue;
+        const preset2 = {
+          instructions: {
+            // Perform a LEFT JOIN that adds the associative table.
+            including: {
+              [fieldSlug]: {
+                [QUERY_SYMBOLS.QUERY]: {
+                  get: {
+                    [systemModel.pluralSlug]: {
+                      // ON associative_table.source = origin_model.id
+                      with: {
+                        source: {
+                          [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
+                        }
+                      },
+                      // Perform a LEFT JOIN that adds the target model table.
+                      including: {
+                        [QUERY_SYMBOLS.QUERY]: {
+                          get: {
+                            [targetModel.slug]: {
+                              // ON target_model.id = associative_table.target
+                              with: {
+                                id: {
+                                  [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}target`
+                                }
+                              }
+                            }
+                          }
+                        }
+                      },
+                      selecting: ["**", "!source", "!target"]
+                    }
+                  }
+                }
+              }
+            }
+          }
+        };
+        defaultPresets[fieldSlug] = preset2;
+        continue;
+      }
+      const preset = {
+        instructions: {
+          including: {
+            [fieldSlug]: {
+              [QUERY_SYMBOLS.QUERY]: {
+                get: {
+                  [targetModel.slug]: {
+                    with: {
+                      // Compare the `id` field of the related model to the link field on
+                      // the root model (`field.slug`).
+                      id: {
+                        [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}${field.slug}`
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      defaultPresets[fieldSlug] = preset;
+    }
+  }
+  const childModels = list.map((subModel) => {
+    if (subModel.system?.associationSlug) return null;
+    const field = Object.entries(subModel.fields).find(([fieldSlug, rest]) => {
+      const field2 = { slug: fieldSlug, ...rest };
+      return field2.type === "link" && field2.target === model.slug;
+    });
+    if (!field) return null;
+    return { model: subModel, field: { slug: field[0], ...field[1] } };
+  }).filter((match) => match !== null);
+  for (const childMatch of childModels) {
+    const { model: childModel, field: childField } = childMatch;
+    const pluralSlug = childModel.pluralSlug;
+    const presetSlug = childModel.system?.associationSlug || pluralSlug;
+    const preset = {
+      instructions: {
+        including: {
+          [presetSlug]: {
+            [QUERY_SYMBOLS.QUERY]: {
+              get: {
+                [pluralSlug]: {
+                  with: {
+                    [childField.slug]: {
+                      [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    defaultPresets[presetSlug] = preset;
+  }
+  if (Object.keys(defaultPresets).length > 0) {
+    const existingPresets = model.presets;
+    const additionalPresets = Object.fromEntries(
+      Object.entries(defaultPresets).filter(([newPresetSlug]) => {
+        return !existingPresets?.[newPresetSlug];
+      })
+    );
+    model.presets = { ...additionalPresets, ...existingPresets };
+  }
+  return model;
+};
+
+// src/instructions/to.ts
+var handleTo = (models, model, statementParams, queryType, dependencyStatements, instructions, options) => {
+  const { with: withInstruction, to: toInstruction } = instructions;
+  const defaultFields = {};
+  const currentTime = (/* @__PURE__ */ new Date()).toISOString();
+  if (queryType === "add" && options?.inlineDefaults) {
+    defaultFields.id = toInstruction.id || getRecordIdentifier(model.idPrefix);
+  }
+  if (queryType === "add" || queryType === "set" || toInstruction.ronin) {
+    const defaults = options?.inlineDefaults ? {
+      // If records are being created, set their creation time.
+      ...queryType === "add" && { createdAt: currentTime },
+      // If records are being updated or created, bump their update time.
+      updatedAt: currentTime,
+      // Allow for overwriting the default values provided above.
+      ...toInstruction.ronin
+    } : {
+      // If records are being updated, bump their update time.
+      // The creation time is already set using a default value in the DB.
+      ...queryType === "set" ? { updatedAt: CURRENT_TIME_EXPRESSION } : {},
+      // Allow for overwriting the default values provided above.
+      ...toInstruction.ronin
+    };
+    if (Object.keys(defaults).length > 0) defaultFields.ronin = defaults;
+  }
+  const symbol = getQuerySymbol(toInstruction);
+  if (symbol?.type === "query") {
+    const { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
+    const subQueryModel = getModelBySlug(models, subQueryModelSlug);
+    const subQuerySelectedFields = subQueryInstructions?.selecting;
+    const subQueryIncludedFields = subQueryInstructions?.including;
+    const subQueryFields = [
+      ...filterSelectedFields(subQueryModel, subQuerySelectedFields).map(
+        (field) => field.slug
+      ),
+      ...subQueryIncludedFields ? Object.keys(
+        flatten(subQueryIncludedFields || {})
+      ) : []
+    ];
+    for (const field of subQueryFields || []) {
+      getFieldFromModel(model, field, { instructionName: "to" });
+    }
+    let statement2 = "";
+    if (subQuerySelectedFields) {
+      const columns = subQueryFields.map((field) => {
+        return getFieldFromModel(model, field, { instructionName: "to" }).fieldSelector;
+      });
+      statement2 = `(${columns.join(", ")}) `;
+    }
+    statement2 += compileQueryInput(symbol.value, models, statementParams, {
+      // biome-ignore lint/complexity/useSimplifiedLogicExpression: This is needed.
+      inlineDefaults: options?.inlineDefaults || false
+    }).main.statement;
+    return statement2;
+  }
+  Object.assign(toInstruction, defaultFields);
+  for (const fieldSlug in toInstruction) {
+    if (!Object.hasOwn(toInstruction, fieldSlug)) continue;
+    const fieldValue = toInstruction[fieldSlug];
+    const fieldDetails = getFieldFromModel(
+      model,
+      fieldSlug,
+      { instructionName: "to" },
+      false
+    );
+    if (fieldDetails?.field.type === "link" && fieldDetails.field.kind === "many") {
+      delete toInstruction[fieldSlug];
+      const associativeModelSlug = composeAssociationModelSlug(model, fieldDetails.field);
+      const composeStatement = (subQueryType, value) => {
+        const source = queryType === "add" ? toInstruction : withInstruction;
+        const recordDetails = { source };
+        if (value) recordDetails.target = value;
         const query = compileQueryInput(
           {
             [subQueryType]: {
@@ -912,532 +1292,152 @@ var composeFieldValues = (models, model, statementParams, instructionName, value
   } else if (collectStatementValue) {
     conditionValue = prepareStatementValue(statementParams, conditionValue);
   }
-  if (options.type === "fields") return conditionSelector;
-  if (options.type === "values") return conditionValue;
-  return `${conditionSelector} ${conditionMatcher} ${conditionValue}`;
-};
-var composeConditions = (models, model, statementParams, instructionName, value, options) => {
-  const isNested = isObject(value) && Object.keys(value).length > 0;
-  if (isNested && Object.keys(value).every((key) => key in WITH_CONDITIONS)) {
-    const conditions = Object.entries(value).map(
-      ([conditionType, checkValue]) => composeConditions(models, model, statementParams, instructionName, checkValue, {
-        ...options,
-        condition: conditionType
-      })
-    );
-    return conditions.join(" AND ");
-  }
-  if (options.fieldSlug) {
-    const childField = Object.keys(model.fields).some((slug) => {
-      return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
-    });
-    if (!childField) {
-      const fieldDetails = getFieldFromModel(model, options.fieldSlug, {
-        instructionName
-      });
-      const { field: modelField } = fieldDetails || {};
-      const consumeJSON = (modelField?.type === "json" || modelField?.type === "blob") && instructionName === "to";
-      if (modelField && !(isObject(value) || Array.isArray(value)) || getQuerySymbol(value) || consumeJSON) {
-        return composeFieldValues(
-          models,
-          model,
-          statementParams,
-          instructionName,
-          value,
-          { ...options, fieldSlug: options.fieldSlug }
-        );
-      }
-      if (modelField?.type === "link" && isNested) {
-        const keys = Object.keys(value);
-        const values = Object.values(value);
-        let recordTarget;
-        if (keys.length === 1 && keys[0] === "id") {
-          recordTarget = values[0];
-        } else {
-          const relatedModel = getModelBySlug(models, modelField.target);
-          const subQuery = {
-            get: {
-              [relatedModel.slug]: {
-                with: value,
-                selecting: ["id"]
-              }
-            }
-          };
-          recordTarget = {
-            [QUERY_SYMBOLS.QUERY]: subQuery
-          };
-        }
-        return composeConditions(
-          models,
-          model,
-          statementParams,
-          instructionName,
-          recordTarget,
-          options
-        );
-      }
-    }
-  }
-  if (isNested) {
-    const conditions = Object.entries(value).map(([field, value2]) => {
-      const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
-      return composeConditions(models, model, statementParams, instructionName, value2, {
-        ...options,
-        fieldSlug: nestedFieldSlug
-      });
-    });
-    const joiner = instructionName === "to" ? ", " : " AND ";
-    if (instructionName === "to") return `${conditions.join(joiner)}`;
-    return conditions.length === 1 ? conditions[0] : options.fieldSlug ? `(${conditions.join(joiner)})` : conditions.join(joiner);
-  }
-  if (Array.isArray(value)) {
-    const conditions = value.map(
-      (filter) => composeConditions(models, model, statementParams, instructionName, filter, options)
-    );
-    return conditions.join(" OR ");
-  }
-  throw new RoninError({
-    message: `The \`with\` instruction must not contain an empty field. The following fields are empty: \`${options.fieldSlug}\`. If you meant to query by an empty field, try using \`null\` instead.`,
-    code: "INVALID_WITH_VALUE",
-    queries: null
-  });
-};
-var formatIdentifiers = ({ identifiers }, queryInstructions) => {
-  if (!queryInstructions) return queryInstructions;
-  const type = "with" in queryInstructions ? "with" : null;
-  if (!type) return queryInstructions;
-  const nestedInstructions = queryInstructions[type];
-  if (!nestedInstructions || Array.isArray(nestedInstructions))
-    return queryInstructions;
-  const newNestedInstructions = { ...nestedInstructions };
-  for (const oldKey of Object.keys(newNestedInstructions)) {
-    if (oldKey !== "nameIdentifier" && oldKey !== "slugIdentifier") continue;
-    const identifierName = oldKey === "nameIdentifier" ? "name" : "slug";
-    const value = newNestedInstructions[oldKey];
-    const newKey = identifiers[identifierName];
-    newNestedInstructions[newKey] = value;
-    delete newNestedInstructions[oldKey];
-  }
-  return {
-    ...queryInstructions,
-    [type]: newNestedInstructions
-  };
-};
-
-// src/instructions/with.ts
-var getMatcher = (value, negative) => {
-  if (negative) {
-    if (value === null) return "IS NOT";
-    return "!=";
-  }
-  if (value === null) return "IS";
-  return "=";
-};
-var WITH_CONDITIONS = {
-  being: (value) => [getMatcher(value, false), value],
-  notBeing: (value) => [getMatcher(value, true), value],
-  startingWith: (value) => ["LIKE", `${value}%`],
-  notStartingWith: (value) => ["NOT LIKE", `${value}%`],
-  endingWith: (value) => ["LIKE", `%${value}`],
-  notEndingWith: (value) => ["NOT LIKE", `%${value}`],
-  containing: (value) => ["LIKE", `%${value}%`],
-  notContaining: (value) => ["NOT LIKE", `%${value}%`],
-  greaterThan: (value) => [">", value],
-  greaterOrEqual: (value) => [">=", value],
-  lessThan: (value) => ["<", value],
-  lessOrEqual: (value) => ["<=", value]
-};
-var handleWith = (models, model, statementParams, instruction, parentModel) => {
-  return composeConditions(
-    models,
-    model,
-    statementParams,
-    "with",
-    instruction,
-    {
-      parentModel
-    }
-  );
-};
-
-// node_modules/title/dist/esm/lower-case.js
-var conjunctions = [
-  "for",
-  "and",
-  "nor",
-  "but",
-  "or",
-  "yet",
-  "so"
-];
-var articles = [
-  "a",
-  "an",
-  "the"
-];
-var prepositions = [
-  "aboard",
-  "about",
-  "above",
-  "across",
-  "after",
-  "against",
-  "along",
-  "amid",
-  "among",
-  "anti",
-  "around",
-  "as",
-  "at",
-  "before",
-  "behind",
-  "below",
-  "beneath",
-  "beside",
-  "besides",
-  "between",
-  "beyond",
-  "but",
-  "by",
-  "concerning",
-  "considering",
-  "despite",
-  "down",
-  "during",
-  "except",
-  "excepting",
-  "excluding",
-  "following",
-  "for",
-  "from",
-  "in",
-  "inside",
-  "into",
-  "like",
-  "minus",
-  "near",
-  "of",
-  "off",
-  "on",
-  "onto",
-  "opposite",
-  "over",
-  "past",
-  "per",
-  "plus",
-  "regarding",
-  "round",
-  "save",
-  "since",
-  "than",
-  "through",
-  "to",
-  "toward",
-  "towards",
-  "under",
-  "underneath",
-  "unlike",
-  "until",
-  "up",
-  "upon",
-  "versus",
-  "via",
-  "with",
-  "within",
-  "without"
-];
-var lowerCase = /* @__PURE__ */ new Set([
-  ...conjunctions,
-  ...articles,
-  ...prepositions
-]);
-
-// node_modules/title/dist/esm/specials.js
-var specials = [
-  "ZEIT",
-  "ZEIT Inc.",
-  "Vercel",
-  "Vercel Inc.",
-  "CLI",
-  "API",
-  "HTTP",
-  "HTTPS",
-  "JSX",
-  "DNS",
-  "URL",
-  "now.sh",
-  "now.json",
-  "vercel.app",
-  "vercel.json",
-  "CI",
-  "CD",
-  "CDN",
-  "package.json",
-  "package.lock",
-  "yarn.lock",
-  "GitHub",
-  "GitLab",
-  "CSS",
-  "Sass",
-  "JS",
-  "JavaScript",
-  "TypeScript",
-  "HTML",
-  "WordPress",
-  "Next.js",
-  "Node.js",
-  "Webpack",
-  "Docker",
-  "Bash",
-  "Kubernetes",
-  "SWR",
-  "TinaCMS",
-  "UI",
-  "UX",
-  "TS",
-  "TSX",
-  "iPhone",
-  "iPad",
-  "watchOS",
-  "iOS",
-  "iPadOS",
-  "macOS",
-  "PHP",
-  "composer.json",
-  "composer.lock",
-  "CMS",
-  "SQL",
-  "C",
-  "C#",
-  "GraphQL",
-  "GraphiQL",
-  "JWT",
-  "JWTs"
-];
-
-// node_modules/title/dist/esm/index.js
-var word = `[^\\s'\u2019\\(\\)!?;:"-]`;
-var regex = new RegExp(`(?:(?:(\\s?(?:^|[.\\(\\)!?;:"-])\\s*)(${word}))|(${word}))(${word}*[\u2019']*${word}*)`, "g");
-var convertToRegExp = (specials2) => specials2.map((s) => [new RegExp(`\\b${s}\\b`, "gi"), s]);
-function parseMatch(match) {
-  const firstCharacter = match[0];
-  if (/\s/.test(firstCharacter)) {
-    return match.slice(1);
-  }
-  if (/[\(\)]/.test(firstCharacter)) {
-    return null;
-  }
-  return match;
-}
-var src_default = (str, options = {}) => {
-  str = str.toLowerCase().replace(regex, (m, lead = "", forced, lower, rest, offset, string) => {
-    const isLastWord = m.length + offset >= string.length;
-    const parsedMatch = parseMatch(m);
-    if (!parsedMatch) {
-      return m;
-    }
-    if (!forced) {
-      const fullLower = lower + rest;
-      if (lowerCase.has(fullLower) && !isLastWord) {
-        return parsedMatch;
-      }
-    }
-    return lead + (lower || forced).toUpperCase() + rest;
-  });
-  const customSpecials = options.special || [];
-  const replace = [...specials, ...customSpecials];
-  const replaceRegExp = convertToRegExp(replace);
-  replaceRegExp.forEach(([pattern, s]) => {
-    str = str.replace(pattern, s);
-  });
-  return str;
-};
-
-// src/model/defaults.ts
-var slugToName = (slug) => {
-  const name = slug.replace(/([a-z])([A-Z])/g, "$1 $2");
-  return src_default(name);
-};
-var VOWELS = ["a", "e", "i", "o", "u"];
-var pluralize = (word2) => {
-  const lastLetter = word2.slice(-1).toLowerCase();
-  const secondLastLetter = word2.slice(-2, -1).toLowerCase();
-  if (lastLetter === "y" && !VOWELS.includes(secondLastLetter)) {
-    return `${word2.slice(0, -1)}ies`;
-  }
-  if (lastLetter === "s" || word2.slice(-2).toLowerCase() === "ch" || word2.slice(-2).toLowerCase() === "sh" || word2.slice(-2).toLowerCase() === "ex") {
-    return `${word2}es`;
-  }
-  return `${word2}s`;
-};
-var modelAttributes = [
-  ["pluralSlug", "slug", pluralize, true],
-  ["name", "slug", slugToName, false],
-  ["pluralName", "pluralSlug", slugToName, false],
-  ["idPrefix", "slug", (slug) => slug.slice(0, 3).toLowerCase(), false],
-  ["table", "pluralSlug", convertToSnakeCase, true]
-];
-var getModelIdentifier = () => {
-  return `mod_${Array.from(crypto.getRandomValues(new Uint8Array(12))).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 16).toLowerCase()}`;
-};
-var addDefaultModelAttributes = (model, isNew) => {
-  const copiedModel = { ...model };
-  if (isNew && !copiedModel.id) copiedModel.id = getModelIdentifier();
-  for (const [setting, base, generator, mustRegenerate] of modelAttributes) {
-    if (!(isNew || mustRegenerate)) continue;
-    if (copiedModel[setting] || !copiedModel[base]) continue;
-    copiedModel[setting] = generator(copiedModel[base]);
-  }
-  const newFields = copiedModel.fields || [];
-  if (isNew || Object.keys(newFields).length > 0) {
-    if (!copiedModel.identifiers) copiedModel.identifiers = {};
-    if (!copiedModel.identifiers.name) {
-      const suitableField = Object.entries(newFields).find(
-        ([fieldSlug, field]) => field.type === "string" && field.required === true && ["name"].includes(fieldSlug)
-      );
-      copiedModel.identifiers.name = suitableField?.[0] || "id";
-    }
-    if (!copiedModel.identifiers.slug) {
-      const suitableField = Object.entries(newFields).find(
-        ([fieldSlug, field]) => field.type === "string" && field.unique === true && field.required === true && ["slug", "handle"].includes(fieldSlug)
-      );
-      copiedModel.identifiers.slug = suitableField?.[0] || "id";
-    }
-  }
-  return copiedModel;
+  if (options.type === "fields") return conditionSelector;
+  if (options.type === "values") return conditionValue;
+  return `${conditionSelector} ${conditionMatcher} ${conditionValue}`;
 };
-var addDefaultModelFields = (model, isNew) => {
-  const copiedModel = { ...model };
-  const existingFields = copiedModel.fields || [];
-  if (isNew || Object.keys(existingFields).length > 0) {
-    const additionalFields = Object.fromEntries(
-      Object.entries(getSystemFields(copiedModel.idPrefix)).filter(([newFieldSlug]) => {
-        return !Object.hasOwn(existingFields, newFieldSlug);
+var composeConditions = (models, model, statementParams, instructionName, value, options) => {
+  const isNested = isObject(value) && Object.keys(value).length > 0;
+  if (isNested && Object.keys(value).every((key) => key in WITH_CONDITIONS)) {
+    const conditions = Object.entries(value).map(
+      ([conditionType, checkValue]) => composeConditions(models, model, statementParams, instructionName, checkValue, {
+        ...options,
+        condition: conditionType
       })
     );
-    copiedModel.fields = { ...additionalFields, ...existingFields };
+    return conditions.join(" AND ");
   }
-  return copiedModel;
-};
-var addDefaultModelPresets = (list, model) => {
-  const defaultPresets = {};
-  for (const [fieldSlug, rest] of Object.entries(model.fields || {})) {
-    const field = { slug: fieldSlug, ...rest };
-    if (field.type === "link" && !fieldSlug.startsWith("ronin.")) {
-      const targetModel = getModelBySlug(list, field.target);
-      if (field.kind === "many") {
-        const systemModel = list.find(({ system }) => {
-          return system?.model === model.id && system?.associationSlug === field.slug;
-        });
-        if (!systemModel) continue;
-        const preset2 = {
-          instructions: {
-            // Perform a LEFT JOIN that adds the associative table.
-            including: {
-              [fieldSlug]: {
-                [QUERY_SYMBOLS.QUERY]: {
-                  get: {
-                    [systemModel.pluralSlug]: {
-                      // ON associative_table.source = origin_model.id
-                      with: {
-                        source: {
-                          [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
-                        }
-                      },
-                      // Perform a LEFT JOIN that adds the target model table.
-                      including: {
-                        [QUERY_SYMBOLS.QUERY]: {
-                          get: {
-                            [targetModel.slug]: {
-                              // ON target_model.id = associative_table.target
-                              with: {
-                                id: {
-                                  [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}target`
-                                }
-                              }
-                            }
-                          }
-                        }
-                      },
-                      selecting: ["**", "!source", "!target"]
-                    }
-                  }
-                }
-              }
-            }
-          }
-        };
-        defaultPresets[fieldSlug] = preset2;
-        continue;
+  if (options.fieldSlug) {
+    const childField = Object.keys(model.fields).some((slug) => {
+      return slug.includes(".") && slug.split(".")[0] === options.fieldSlug;
+    });
+    if (!childField) {
+      const fieldDetails = getFieldFromModel(model, options.fieldSlug, {
+        instructionName
+      });
+      const { field: modelField } = fieldDetails || {};
+      const consumeJSON = (modelField?.type === "json" || modelField?.type === "blob") && instructionName === "to";
+      if (modelField && !(isObject(value) || Array.isArray(value)) || getQuerySymbol(value) || consumeJSON) {
+        return composeFieldValues(
+          models,
+          model,
+          statementParams,
+          instructionName,
+          value,
+          { ...options, fieldSlug: options.fieldSlug }
+        );
       }
-      const preset = {
-        instructions: {
-          including: {
-            [fieldSlug]: {
-              [QUERY_SYMBOLS.QUERY]: {
-                get: {
-                  [targetModel.slug]: {
-                    with: {
-                      // Compare the `id` field of the related model to the link field on
-                      // the root model (`field.slug`).
-                      id: {
-                        [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}${field.slug}`
-                      }
-                    }
-                  }
-                }
+      if (modelField?.type === "link" && isNested) {
+        const keys = Object.keys(value);
+        const values = Object.values(value);
+        let recordTarget;
+        if (keys.length === 1 && keys[0] === "id") {
+          recordTarget = values[0];
+        } else {
+          const relatedModel = getModelBySlug(models, modelField.target);
+          const subQuery = {
+            get: {
+              [relatedModel.slug]: {
+                with: value,
+                selecting: ["id"]
               }
             }
-          }
+          };
+          recordTarget = {
+            [QUERY_SYMBOLS.QUERY]: subQuery
+          };
         }
-      };
-      defaultPresets[fieldSlug] = preset;
+        return composeConditions(
+          models,
+          model,
+          statementParams,
+          instructionName,
+          recordTarget,
+          options
+        );
+      }
     }
   }
-  const childModels = list.map((subModel) => {
-    if (subModel.system?.associationSlug) return null;
-    const field = Object.entries(subModel.fields).find(([fieldSlug, rest]) => {
-      const field2 = { slug: fieldSlug, ...rest };
-      return field2.type === "link" && field2.target === model.slug;
+  if (isNested) {
+    const conditions = Object.entries(value).map(([field, value2]) => {
+      const nestedFieldSlug = options.fieldSlug ? `${options.fieldSlug}.${field}` : field;
+      return composeConditions(models, model, statementParams, instructionName, value2, {
+        ...options,
+        fieldSlug: nestedFieldSlug
+      });
     });
-    if (!field) return null;
-    return { model: subModel, field: { slug: field[0], ...field[1] } };
-  }).filter((match) => match !== null);
-  for (const childMatch of childModels) {
-    const { model: childModel, field: childField } = childMatch;
-    const pluralSlug = childModel.pluralSlug;
-    const presetSlug = childModel.system?.associationSlug || pluralSlug;
-    const preset = {
-      instructions: {
-        including: {
-          [presetSlug]: {
-            [QUERY_SYMBOLS.QUERY]: {
-              get: {
-                [pluralSlug]: {
-                  with: {
-                    [childField.slug]: {
-                      [QUERY_SYMBOLS.EXPRESSION]: `${QUERY_SYMBOLS.FIELD_PARENT}id`
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-    defaultPresets[presetSlug] = preset;
+    const joiner = instructionName === "to" ? ", " : " AND ";
+    if (instructionName === "to") return `${conditions.join(joiner)}`;
+    return conditions.length === 1 ? conditions[0] : options.fieldSlug ? `(${conditions.join(joiner)})` : conditions.join(joiner);
   }
-  if (Object.keys(defaultPresets).length > 0) {
-    const existingPresets = model.presets;
-    const additionalPresets = Object.fromEntries(
-      Object.entries(defaultPresets).filter(([newPresetSlug]) => {
-        return !existingPresets?.[newPresetSlug];
-      })
+  if (Array.isArray(value)) {
+    const conditions = value.map(
+      (filter) => composeConditions(models, model, statementParams, instructionName, filter, options)
     );
-    model.presets = { ...additionalPresets, ...existingPresets };
+    return conditions.join(" OR ");
   }
-  return model;
+  throw new RoninError({
+    message: `The \`with\` instruction must not contain an empty field. The following fields are empty: \`${options.fieldSlug}\`. If you meant to query by an empty field, try using \`null\` instead.`,
+    code: "INVALID_WITH_VALUE",
+    queries: null
+  });
+};
+var formatIdentifiers = ({ identifiers }, queryInstructions) => {
+  if (!queryInstructions) return queryInstructions;
+  const type = "with" in queryInstructions ? "with" : null;
+  if (!type) return queryInstructions;
+  const nestedInstructions = queryInstructions[type];
+  if (!nestedInstructions || Array.isArray(nestedInstructions))
+    return queryInstructions;
+  const newNestedInstructions = { ...nestedInstructions };
+  for (const oldKey of Object.keys(newNestedInstructions)) {
+    if (oldKey !== "nameIdentifier" && oldKey !== "slugIdentifier") continue;
+    const identifierName = oldKey === "nameIdentifier" ? "name" : "slug";
+    const value = newNestedInstructions[oldKey];
+    const newKey = identifiers[identifierName];
+    newNestedInstructions[newKey] = value;
+    delete newNestedInstructions[oldKey];
+  }
+  return {
+    ...queryInstructions,
+    [type]: newNestedInstructions
+  };
+};
+
+// src/instructions/with.ts
+var getMatcher = (value, negative) => {
+  if (negative) {
+    if (value === null) return "IS NOT";
+    return "!=";
+  }
+  if (value === null) return "IS";
+  return "=";
+};
+var WITH_CONDITIONS = {
+  being: (value) => [getMatcher(value, false), value],
+  notBeing: (value) => [getMatcher(value, true), value],
+  startingWith: (value) => ["LIKE", `${value}%`],
+  notStartingWith: (value) => ["NOT LIKE", `${value}%`],
+  endingWith: (value) => ["LIKE", `%${value}`],
+  notEndingWith: (value) => ["NOT LIKE", `%${value}`],
+  containing: (value) => ["LIKE", `%${value}%`],
+  notContaining: (value) => ["NOT LIKE", `%${value}%`],
+  greaterThan: (value) => [">", value],
+  greaterOrEqual: (value) => [">=", value],
+  lessThan: (value) => ["<", value],
+  lessOrEqual: (value) => ["<=", value]
+};
+var handleWith = (models, model, statementParams, instruction, parentModel) => {
+  return composeConditions(
+    models,
+    model,
+    statementParams,
+    "with",
+    instruction,
+    {
+      parentModel
+    }
+  );
 };
 
 // src/model/index.ts
@@ -1500,7 +1500,12 @@ var getSystemFields = (idPrefix) => ({
   id: {
     name: "ID",
     type: "string",
-    defaultValue: ID_EXPRESSION(idPrefix)
+    defaultValue: {
+      // Since default values in SQLite cannot rely on other columns, we unfortunately
+      // cannot rely on the `idPrefix` column here. Instead, we need to inject it
+      // directly into the expression as a static string.
+      [QUERY_SYMBOLS.EXPRESSION]: `'${idPrefix}_' || lower(substr(hex(randomblob(12)), 1, 16))`
+    }
   },
   "ronin.createdAt": {
     name: "RONIN - Created At",
@@ -1714,7 +1719,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
   const action = subAltering && query.alter ? Object.keys(query.alter).filter((key) => key !== "model")[0] : queryType;
   const actionReadable = action === "create" ? "creating" : action === "alter" ? "altering" : "dropping";
   const entity = subAltering && query.alter ? Object.keys(query.alter[action])[0] : "model";
-  let slug = entity === "model" && action === "create" ? null : query[queryType].model;
+  let slug = entity === "model" && action === "create" ? null : query[queryType] && "model" in query[queryType] ? query[queryType].model : null;
   let modelSlug = slug;
   let jsonValue;
   if ("create" in query && query.create) {
@@ -1856,7 +1861,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
       }
     };
   }
-  const modelBeforeUpdate = structuredClone(JSON.parse(JSON.stringify(model)));
+  const modelBeforeUpdate = structuredClone(model);
   const existingModel = model;
   const pluralType = PLURAL_MODEL_ENTITIES[entity];
   const existingEntity = existingModel[pluralType]?.[slug];
@@ -2093,9 +2098,19 @@ var Transaction = class {
     const expandedQueries = queries.flatMap((query, expansionIndex) => {
       const { queryType, queryModel, queryInstructions } = splitQuery(query);
       if (queryModel === "all") {
-        return modelsWithAttributes.map((model) => {
+        const { for: forInstruction, ...restInstructions } = queryInstructions || {};
+        let modelList = modelsWithAttributes;
+        if (forInstruction) {
+          const mainModel = getModelBySlug(modelsWithAttributes, forInstruction);
+          modelList = Object.values(mainModel.fields || {}).filter((field) => field.type === "link").map((field) => {
+            return modelsWithAttributes.find(
+              (model) => model.slug === field.target
+            );
+          });
+        }
+        return modelList.map((model) => {
           const query2 = {
-            [queryType]: { [model.pluralSlug]: queryInstructions }
+            [queryType]: { [model.pluralSlug]: restInstructions }
           };
           return { query: query2, expansionIndex };
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.17.6",
+  "version": "0.17.7-leo-ron-1099-experimental-394",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {