@ronin/compiler 0.17.5 → 0.17.6-leo-ron-1099-experimental-390

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,457 @@ 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 craeted, 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.
+      ...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]: {
@@ -1060,386 +1439,6 @@ var handleWith = (models, model, statementParams, 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;
-};
-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/model/index.ts
 var getModelBySlug = (models, slug) => {
   const model = models.find((model2) => {
@@ -1500,7 +1499,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",
@@ -2004,10 +2008,11 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query,
   let json;
   switch (action) {
     case "create": {
-      const value = prepareStatementValue(statementParams, jsonValue);
-      json = `json_insert(${field}, '$.${slug}', ${value})`;
+      const { slug: slug2, ...entityValue } = jsonValue;
+      const value = prepareStatementValue(statementParams, entityValue);
+      json = `json_insert(${field}, '$.${slug2}', ${value})`;
       if (!existingModel[pluralType]) existingModel[pluralType] = {};
-      existingModel[pluralType][slug] = jsonValue;
+      existingModel[pluralType][slug2] = jsonValue;
       break;
     }
     case "alter": {

package/package.json

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