@ronin/compiler 0.14.1 → 0.14.2-leo-ron-1099-1-experimental-320

package/dist/index.d.ts

@@ -36,6 +36,22 @@ declare class RoninError extends Error {
     queries?: Details['queries'];
     constructor(details: Details);
 }
+/**
+ * Checks if the provided value contains a RONIN model symbol (a represenation of a
+ * particular entity inside a query, such as an expression or a sub query) and returns
+ * its type and value.
+ *
+ * @param value - The value that should be checked.
+ *
+ * @returns The type and value of the symbol, if the provided value contains one.
+ */
+declare const getQuerySymbol: (value: unknown) => {
+    type: "query";
+    value: Query;
+} | {
+    type: "expression";
+    value: string;
+} | null;
 
 type QueryTypeEnum = 'get' | 'set' | 'add' | 'remove' | 'count';
 type ModelQueryTypeEnum = 'create' | 'alter' | 'drop';
@@ -378,4 +394,4 @@ declare class Transaction {
 
 declare const CLEAN_ROOT_MODEL: PublicModel;
 
-export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, type GetInstructions, type GetQuery, type GetInstructions as GetQueryInstructions, type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, QUERY_SYMBOLS, type Query, type QueryInstructionType as QueryInstruction, type QuerySchemaType, type QueryType, CLEAN_ROOT_MODEL as ROOT_MODEL, type RemoveInstructions, type RemoveQuery, type RemoveInstructions as RemoveQueryInstructions, type Result, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, Transaction, type WithInstruction };
+export { type AddInstructions, type AddQuery, type AddInstructions as AddQueryInstructions, type CombinedInstructions, type CountInstructions, type CountQuery, type CountInstructions as CountQueryInstructions, type GetInstructions, type GetQuery, type GetInstructions as GetQueryInstructions, type PublicModel as Model, type ModelField, type ModelIndex, type ModelPreset, type ModelTrigger, QUERY_SYMBOLS, type Query, type QueryInstructionType as QueryInstruction, type QuerySchemaType, type QueryType, CLEAN_ROOT_MODEL as ROOT_MODEL, type RemoveInstructions, type RemoveQuery, type RemoveInstructions as RemoveQueryInstructions, type Result, RoninError, type SetInstructions, type SetQuery, type SetInstructions as SetQueryInstructions, type Statement, Transaction, type WithInstruction, getQuerySymbol };

package/dist/index.js

@@ -70,7 +70,7 @@ var convertToCamelCase = (str) => {
   return sanitize(str).split(SPLIT_REGEX).map((part, index) => index === 0 ? part.toLowerCase() : capitalize(part)).join("");
 };
 var isObject = (value) => value != null && typeof value === "object" && Array.isArray(value) === false;
-var getSymbol = (value) => {
+var getQuerySymbol = (value) => {
   if (!isObject(value)) return null;
   const objectValue = value;
   if (QUERY_SYMBOLS.QUERY in objectValue) {
@@ -110,7 +110,7 @@ var flatten = (obj, prefix = "", res = {}) => {
     if (!Object.hasOwn(obj, key)) continue;
     const path = prefix ? `${prefix}.${key}` : key;
     const value = obj[key];
-    if (typeof value === "object" && value !== null && !getSymbol(value)) {
+    if (typeof value === "object" && value !== null && !getQuerySymbol(value)) {
       flatten(value, path, res);
     } else {
       res[path] = value;
@@ -304,7 +304,7 @@ var handleIncluding = (models, model, statementParams, single, instruction) => {
   let tableSubQuery;
   for (const ephemeralFieldSlug in instruction) {
     if (!Object.hasOwn(instruction, ephemeralFieldSlug)) continue;
-    const symbol = getSymbol(instruction[ephemeralFieldSlug]);
+    const symbol = getQuerySymbol(instruction[ephemeralFieldSlug]);
     if (symbol?.type !== "query") continue;
     const { queryType, queryModel, queryInstructions } = splitQuery(symbol.value);
     let modifiableQueryInstructions = queryInstructions;
@@ -383,7 +383,7 @@ var handleOrderedBy = (model, instruction) => {
     if (statement.length > 0) {
       statement += ", ";
     }
-    const symbol = getSymbol(item.value);
+    const symbol = getQuerySymbol(item.value);
     const instructionName = item.order === "ASC" ? "orderedBy.ascending" : "orderedBy.descending";
     if (symbol?.type === "expression") {
       statement += `(${parseFieldExpression(model, instructionName, symbol.value)}) ${item.order}`;
@@ -403,12 +403,10 @@ var handleOrderedBy = (model, instruction) => {
 // src/instructions/selecting.ts
 var handleSelecting = (models, model, statementParams, single, instructions, options = {}) => {
   let isJoining = false;
-  const selectedFields = (instructions.selecting ? instructions.selecting.map((slug) => {
-    const { field } = getFieldFromModel(model, slug, {
-      instructionName: "selecting"
-    });
-    return field;
-  }) : model.fields).filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => {
+  const selectedFields = filterSelectedFields(
+    model,
+    instructions.selecting
+  ).filter((field) => !(field.type === "link" && field.kind === "many")).map((field) => {
     const newField = { ...field, mountingPath: field.slug };
     if (options.mountingPath) {
       newField.mountingPath = `${options.mountingPath}.${field.slug}`;
@@ -419,14 +417,14 @@ var handleSelecting = (models, model, statementParams, single, instructions, opt
   const joinedSelectedFields = [];
   const joinedColumns = [];
   if (instructions.including) {
-    const symbol = getSymbol(instructions.including);
+    const symbol = getQuerySymbol(instructions.including);
     if (symbol?.type === "query") {
       instructions.including.ronin_root = { ...instructions.including };
       delete instructions.including[QUERY_SYMBOLS.QUERY];
     }
     const flatObject = flatten(instructions.including);
     for (const [key, value] of Object.entries(flatObject)) {
-      const symbol2 = getSymbol(value);
+      const symbol2 = getQuerySymbol(value);
       if (symbol2?.type === "query") {
         const { queryModel, queryInstructions } = splitQuery(symbol2.value);
         const subQueryModel = getModelBySlug(models, queryModel);
@@ -504,15 +502,10 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
       ...toInstruction.ronin
     };
   }
-  const symbol = getSymbol(toInstruction);
+  const symbol = getQuerySymbol(toInstruction);
   if (symbol?.type === "query") {
     const { queryModel: subQueryModelSlug, queryInstructions: subQueryInstructions } = splitQuery(symbol.value);
     const subQueryModel = getModelBySlug(models, subQueryModelSlug);
-    if (subQueryInstructions?.selecting) {
-      const currentFields = new Set(subQueryInstructions.selecting);
-      currentFields.add("id");
-      subQueryInstructions.selecting = Array.from(currentFields);
-    }
     const subQuerySelectedFields = subQueryInstructions?.selecting;
     const subQueryIncludedFields = subQueryInstructions?.including;
     const subQueryFields = [
@@ -762,6 +755,32 @@ var replaceJSON = (key, value) => {
   if (key === QUERY_SYMBOLS.EXPRESSION) return value.replaceAll(`'`, `''`);
   return value;
 };
+var matchSelectedFields = (fields, pattern) => {
+  let regexStr = pattern.replace(/\./g, "\\.");
+  regexStr = regexStr.replace(/\*\*/g, "<<DOUBLESTAR>>");
+  regexStr = regexStr.replace(/\*/g, "[^.]*");
+  regexStr = regexStr.replace(/<<DOUBLESTAR>>/g, ".*");
+  const regex2 = new RegExp(`^${regexStr}$`);
+  return fields.filter((field) => regex2.test(field.slug));
+};
+var filterSelectedFields = (model, instruction) => {
+  if (!instruction) return model.fields;
+  let selectedFields = [];
+  for (const pattern of instruction) {
+    const isNegative = pattern.startsWith("!");
+    const cleanPattern = isNegative ? pattern.slice(1) : pattern;
+    const matchedFields = matchSelectedFields(
+      isNegative ? selectedFields : model.fields,
+      cleanPattern
+    );
+    if (isNegative) {
+      selectedFields = selectedFields.filter((field) => !matchedFields.includes(field));
+    } else {
+      selectedFields.push(...matchedFields);
+    }
+  }
+  return selectedFields;
+};
 var prepareStatementValue = (statementParams, value) => {
   if (value === null) return "NULL";
   if (!statementParams) {
@@ -802,7 +821,7 @@ var composeFieldValues = (models, model, statementParams, instructionName, value
     { instructionName }
   );
   const collectStatementValue = options.type !== "fields";
-  const symbol = getSymbol(value);
+  const symbol = getQuerySymbol(value);
   let conditionMatcher = "=";
   let conditionValue = value;
   if (options.condition) {
@@ -848,7 +867,7 @@ var composeConditions = (models, model, statementParams, instructionName, value,
       });
       const { field: modelField } = fieldDetails || {};
       const consumeJSON = modelField?.type === "json" && instructionName === "to";
-      if (modelField && !(isObject(value) || Array.isArray(value)) || getSymbol(value) || consumeJSON) {
+      if (modelField && !(isObject(value) || Array.isArray(value)) || getQuerySymbol(value) || consumeJSON) {
         return composeFieldValues(
           models,
           model,
@@ -1507,7 +1526,7 @@ var getFieldStatement = (models, model, field) => {
   if (field.unique === true) statement += " UNIQUE";
   if (field.required === true) statement += " NOT NULL";
   if (typeof field.defaultValue !== "undefined") {
-    const symbol = getSymbol(field.defaultValue);
+    const symbol = getQuerySymbol(field.defaultValue);
     let value = typeof field.defaultValue === "string" ? `'${field.defaultValue}'` : field.defaultValue;
     if (symbol) value = `(${parseFieldExpression(model, "to", symbol.value)})`;
     statement += ` DEFAULT ${value}`;
@@ -1519,12 +1538,12 @@ var getFieldStatement = (models, model, field) => {
     statement += " AUTOINCREMENT";
   }
   if (typeof field.check !== "undefined") {
-    const symbol = getSymbol(field.check);
+    const symbol = getQuerySymbol(field.check);
     statement += ` CHECK (${parseFieldExpression(model, "to", symbol?.value)})`;
   }
   if (typeof field.computedAs !== "undefined") {
     const { kind, value } = field.computedAs;
-    const symbol = getSymbol(value);
+    const symbol = getQuerySymbol(value);
     statement += ` GENERATED ALWAYS AS (${parseFieldExpression(model, "to", symbol?.value)}) ${kind}`;
   }
   if (field.type === "link") {
@@ -2090,5 +2109,6 @@ export {
   QUERY_SYMBOLS,
   CLEAN_ROOT_MODEL as ROOT_MODEL,
   RoninError,
-  Transaction
+  Transaction,
+  getQuerySymbol
 };

package/package.json

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